Lib/txml.c

Go to the documentation of this file.

#ifdef CPLUSPLUS
    #undef CPLUSPLUS
#endif


#include "txml.h"
#include "jbxl_state.h"



// Parser
//

tXML*  xml_parse(char* pp)
{
    tXML* xml;
    tXML* node;

    xml = new_xml_node();                    // アンカー
    xml->ldat.id = XML_ANCHOR_NODE;
    xml->state   = JBXL_STATE_ANCHOR;
    xml->depth   = -1;

    // パース
    node = xml_main_parse(xml, pp, TRUE);
    if (node->state<0) return xml;

    // 元に戻ったか？
    if (xml==node) {
        xml->state = JBXL_XML_PARSED;
    }
    else {
        xml->state = JBXL_XML_NOT_CLOSED;
    }

    // XML rootの数
    if (xml->next!=NULL) {
        int n = 0;
        node = xml->next;
        while(node!=NULL) {
            if (node->ldat.id==XML_NAME_NODE) n++;
            node = node->ysis;
        }
        if (n!=1) xml->state = JBXL_XML_MULTI_ROOT;
    }
    else xml->state = JBXL_XML_DEFAULT_STATE;

    return xml;
}



tXML*  xml_parse_file(const char* fn)
{
    tXML*  xml = NULL;
    Buffer buf;

    buf = read_Buffer_file(fn);
    if (buf.buf!=NULL) {
        xml = xml_parse((char*)(buf.buf));
        free_Buffer(&buf);
    }

    return xml;
}



tXML*  xml_parse_seq(tXML* xml, char* pp)
{
    int   skip = FALSE;
    tXML* node;

    if (xml==NULL) {
        xml = new_tTree_anchor_node();
        //xml->ldat.id = XML_ANCHOR_NODE;
        //xml->depth = -1;
        skip = TRUE;
    }
    else {
        tXML* top = find_xml_top(xml);
        if (top==xml) top->state = JBXL_XML_DEFAULT_STATE;
    }

    node = xml_main_parse(xml, pp, skip);
    xml = find_xml_top(xml);
    xml->altp = node;

    if (xml!=node) return xml;

    if (node->state==JBXL_NORMAL) xml->state = JBXL_XML_PARSED;
    else                          xml->state = node->state;

    if (xml->next!=NULL) {
        int n = 0;
        node = xml->next;
        while(node!=NULL) {
            if (node->ldat.id==XML_NAME_NODE) n++;
            node = node->ysis;
        }
        if (n!=1) xml->state = JBXL_XML_MULTI_ROOT;
    }
    else xml->state = JBXL_XML_DEFAULT_STATE;

    return xml;
}



tXML*  xml_main_parse(tXML* xml, char* pp, int skip)
{
    int   n, node_end;
    char* node_name = NULL;
    char* node_attr = NULL;
    char* value     = NULL;
    
    if (pp ==NULL) return xml;
    if (xml==NULL) return NULL;

    if (skip) while (*pp!='\0' && *pp!='<') pp++;

    while (*pp!='\0') {
        n = 1;

        if (*pp=='<') {
            // End TAG        </   >
            if (*(pp+1)=='/') {
                if (xml->state==JBXL_XML_NODE_OPENED) {
                    n = xml_parse_end_node(pp, &node_name);
                    if (n>0) {
                        if (node_name!=NULL && xml->ldat.key.buf!=NULL) {
                            if (!strcmp((const char*)node_name, (const char*)(xml->ldat.key.buf))) {
                                if (xml->next!=NULL) {
                                    xml->state = JBXL_XML_NODE_CLOSED;
                                }
                                else {
                                    xml->state = JBXL_XML_NODE_EMPTY;
                                }
                                //
                                if (xml->prev!=NULL) xml = xml->prev;
                                else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
                            }
                            else n = xml->state = JBXL_XML_PARSE_ERROR;
                        }
                        else n = xml->state = JBXL_XML_PARSE_ERROR;
                    }
                    else xml->state = n;                    // エラー
                }
                else n = xml->state = JBXL_XML_PARSE_ERROR;
            }

            // Comment TAG        <!--   -->
            else if (!strncmp(pp+1, "!--", 3)) {
                n = xml_parse_comment_node(pp, &value);
                if (n>0) {
                    xml = add_tTree_node_bystr(xml, XML_COMMENT_NODE, 0, (char*)XML_COMMENT_NODE_KEY, value, NULL, 0);
                    xml->state = JBXL_XML_NODE_EMPTY;
                    if (xml->prev!=NULL) xml = xml->prev;
                    else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
                }
            }

            // Data TAG            <!     >
            else if (*(pp+1)=='!') {
                n = xml_parse_data_node(pp, &value);
                if (n>0) {
                    xml = add_tTree_node_bystr(xml, XML_DATA_NODE, 0, (char*)XML_DATA_NODE_KEY, value, NULL, 0);
                    xml->state = JBXL_XML_NODE_EMPTY;
                    if (xml->prev!=NULL) xml = xml->prev;
                    else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
                }
            }

            // Processing TAG      <?   ?>
            else if (*(pp+1)=='?') {
                n = xml_parse_processing_node(pp, &node_name, &node_attr);
                if (n>0) {
                    if (!strncasecmp("xml", node_name, 3)) {
                        tList* lp = xml_parse_attr(node_attr);
                        xml = add_tTree_node_bystr(xml, XML_DOC_NODE, 0, node_name, NULL, NULL, 0);
                        xml->ldat.lst = lp;
                    }
                    else {
                        xml = add_tTree_node_bystr(xml, XML_PROCESS_NODE, 0, node_name, node_attr, NULL, 0);
                    }
                    xml->state = JBXL_XML_NODE_EMPTY;
                    if (xml->prev!=NULL) xml = xml->prev;
                    else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
                }
            }

            // Start TAG  <   > 
            else {
                n = xml_parse_start_node(pp, &node_name, &node_attr, &node_end);

                if (n>0) {
                    tList* lp = xml_parse_attr(node_attr);
                    xml = add_tTree_node_bystr(xml, XML_NAME_NODE, 0, node_name, NULL, NULL, 0);
                    xml->ldat.lst = lp;

                    if (node_end) {
                        xml->state = JBXL_XML_NODE_EMPTY;
                        if (xml->prev!=NULL) xml = xml->prev;
                        else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
                    }
                    else {
                        int m;
                        xml->state = JBXL_XML_NODE_OPENED;
                        // ノード値
                        m = xml_parse_content(pp+n, &value);            // 0 が返る可能性がある
                        if (m>=0) {
                            n += m;
                            if (value!=NULL) {
                                xml = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, value, NULL, NULL, 0);
                                xml->state = JBXL_XML_NODE_CLOSED;
                                if (xml->prev!=NULL) {
                                    xml = xml->prev;
                                    xml->ldat.lv++;
                                }
                                else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
                            }
                        }
                        else n = xml->state = m;                    // エラー
                    }
                }
            }

            freeNull(node_name);
            freeNull(node_attr);
            freeNull(value);
        }

        // Content        (断片的に入力したXMLが content の途中で終わっている場合など)
        else {
            if (xml->state==JBXL_XML_NODE_OPENED) {
                n = xml_parse_content(pp, &value);
                if (n>0) {
                    if (value!=NULL) {
                        xml = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, value, NULL, NULL, 0);
                        xml->state = JBXL_XML_NODE_CLOSED;
                        if (xml->prev!=NULL) {
                            xml = xml->prev;
                            xml->ldat.lv++;
                        }
                        else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
                    }
                }
                else n = xml->state = JBXL_XML_PARSE_ERROR;
                freeNull(value);
            }
            else n = xml->state = JBXL_XML_PARSE_ERROR;
        }

        // エラー
        if (n<=0) return xml;

        pp += n;
        while (*pp==' ' || *pp==CHAR_TAB || *pp==CHAR_LF || *pp==CHAR_CR) pp++;
    }

    return xml;
}



// Paese of TAG
//

int  xml_parse_start_node(char* pp, char** node_name, char** node_attr, int* node_end)
{
    int   nn, mm;
    char* pt;

    if (node_name==NULL || node_attr==NULL || node_end==NULL) return JBXL_ARGS_ERROR;
    *node_end  = FALSE;
    *node_name = NULL;
    *node_attr = NULL;

    if (*pp!='<') return JBXL_XML_PARSE_ERROR;
    pt = pp = pp + 1;
    pt = skip_chars(pt, " />");
    if (pt==NULL) return JBXL_XML_PARSE_ERROR;

    nn = mm = (int)(pt - pp);
    if (mm==0) return JBXL_XML_PARSE_ERROR;

    nn = nn + 1;
    *node_name = (char*)malloc((size_t)(mm + 1));
    if (*node_name==NULL) return JBXL_MALLOC_ERROR;
    memcpy(*node_name, pp, mm);
    (*node_name)[mm] = '\0';
    //PRINT_MESG("START --> %s  %d\n", *node_name, (int)strlen(*node_name));

    if (isnot_xml_name((unsigned char*)*node_name)) {
        freeNull(*node_name);
        return JBXL_XML_PARSE_ERROR;
    }

    // Empty TAG
    if (*pt=='/') {
        if (*(pt+1)!='>') {
            freeNull(*node_name);
            return JBXL_XML_PARSE_ERROR;
        }
        nn += 1;
        *node_end = TRUE;
        //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
    }

    // Attribute
    else if (*pt==' ') {
        pp = pt = pt + 1;
        while (*pt==' ' || *pt==CHAR_TAB || *pt==CHAR_LF || *pt==CHAR_CR) pt++;
        nn += (int)(pt - pp) + 1;

        pp = pt;
        pt = skip_chars(pt, "/>");
        if (pt==NULL) {
            freeNull(*node_name);
            return JBXL_XML_PARSE_ERROR;
        }

        mm = (int)(pt - pp);
        if (mm>0) {
            *node_attr = (char*)malloc((size_t)(mm + 1));
            if (*node_attr==NULL) {
                freeNull(*node_name);
                return JBXL_MALLOC_ERROR;
            }
            memcpy(*node_attr, pp, mm);
            (*node_attr)[mm] = '\0';
            nn += mm;
            //PRINT_MESG("ATTR  --> %s  %d\n", *node_attr, (int)strlen(*node_attr));
        }

        if (*pt=='/') {
            if (*(pt+1)!='>') {
                freeNull(*node_name);
                freeNull(*node_attr);
                return JBXL_XML_PARSE_ERROR;
            }
            nn += 1;
            *node_end = TRUE;
            //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
        }
    }
    
    //else {}   *pt=='>'

    return nn + 1;
}



int  xml_parse_end_node(char* pp, char** node_name)
{
    int   nn, mm;
    char* pt;
    char* work;

    if (pp==NULL) return JBXL_XML_PARSE_ERROR;
    *node_name = NULL;

    if (strncmp(pp ,"</", 2)) return JBXL_XML_PARSE_ERROR;

    pt = pp = pp + 2;
    pt = skip_chars(pt, ">");
    if (pt==NULL) return JBXL_XML_PARSE_ERROR;

    nn = mm = (int)(pt - pp);
    if (mm==0) return JBXL_XML_PARSE_ERROR;

    nn += 2;
    work = (char*)malloc((size_t)(mm+1));
    if (work==NULL) return JBXL_MALLOC_ERROR;
    memcpy(work, pp, mm);
    work[mm] = '\0';
    *node_name = pack_head_tail_char(work, ' ');
    free(work);
    //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));

    return nn + 1;
}



int  xml_parse_content(char* pp, char** content)
{
    int   nn=0, mm;
    char* pt;
    char* work;

    if (pp==NULL || content==NULL) return JBXL_XML_PARSE_ERROR;
    *content = NULL;

    while (*pp==' ' || *pp==CHAR_TAB || *pp==CHAR_LF || *pp==CHAR_CR) {
        pp++;
        nn++;
    }
    if (*pp=='<') return nn;            // <node><

    pt = pp;
    while (*pt!='<' && *pt!='\0') pt++;

    mm = (int)(pt - pp);
    if (mm==0) return nn;
    nn += mm;

    work = (char*)malloc((size_t)(mm+1));
    if (work==NULL) return JBXL_MALLOC_ERROR;
    memcpy(work, pp, mm);
    work[mm] = '\0';

    *content = pack_head_tail_char(work, ' ');
    free(work);
    //PRINT_MESG("VALUE --> %s  %d\n", *content, (int)strlen(*content));

    return nn;
}



tList*  xml_parse_attr(char* pp)
{
    int    sz;
    char*  nm;
    char*  vl;
    char*  pt;
    char   qt;
    tList* lp = NULL;
    tList* lt = NULL;

    // 作業メモリの確保
    if (pp==NULL) return NULL;
    sz = (int)strlen((const char*)pp) + 1;
    nm = (char*)malloc(sz);
    if (nm==NULL) return NULL;
    vl = (char*)malloc(sz);
    if (vl==NULL) {
        free(nm);
        return NULL;
    }

    // Parse for AAA="BBB" CCC="DDDD"
    while (*pp==' ' && *pp!='\0') pp++;
    while (*pp!='\0') {
        pt = pp;
        while (*pt!='=' && *pt!='\0') pt++;
        if (*pt=='\0') {
            if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
            break;
        }

        sz = (int)(pt - pp);
        memcpy(nm, pp, (size_t)sz);
        nm[sz] = '\0';

        pt++;
        if (*pt!='"' && *pt!='\'') {
            if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
            break;
        }
        else qt = *pt;

        pt++;
        pp = pt;
        while(*pt!=qt && *pt!='\0') pt++;
        if (*pt=='\0') {
            if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
            break;
        }

        sz = (int)(pt - pp);
        memcpy(vl+1, pp, (size_t)sz);
        vl[0]     = qt;
        vl[sz+1] = qt;
        vl[sz+2] = '\0';

        lp = add_tList_node_str(lp, nm, vl);
        if (lt==NULL) lt = lp;
        pp = pt + 1;

        if (*pp!=' ' && *pp!='\0') {
            lt->state = JBXL_XML_PARSE_ERROR;
            break;
        }
        while (*pp==' ' && *pp!='\0') pp++;
    }

    //
    free(nm);
    free(vl);

    if (lt!=NULL) {
        if (lt->state!=JBXL_XML_PARSE_ERROR) lt->state = JBXL_XML_NODE_CLOSED;
    }
    return lt;
}



int  xml_parse_processing_node(char* pp, char** node_name, char** node_attr)
{
    int   nn, mm;
    char* pt;

    *node_name = NULL;
    *node_attr = NULL;

    if (pp==NULL) return JBXL_XML_PARSE_ERROR;
    if (strncmp(pp, "<?", 2)) return JBXL_XML_PARSE_ERROR;

    pt = pp = pp + 2;
    pt = skip_chars(pt, " ?");
    if (pt==NULL) return JBXL_XML_PARSE_ERROR;

    nn = mm = (int)(pt - pp);
    if (mm==0) return JBXL_XML_PARSE_ERROR;

    nn += 2;
    *node_name = (char*)malloc((size_t)(mm + 1));
    if (*node_name==NULL) return JBXL_MALLOC_ERROR;
    memcpy(*node_name, pp, mm);
    (*node_name)[mm] = '\0';

    if (isnot_xml_name((unsigned char*)*node_name)) return JBXL_XML_PARSE_ERROR;

    // for attribute
    if (*pt==' ') {
        pp = pt = pt + 1;
        while (*pt==' ' || *pt==CHAR_TAB || *pt==CHAR_LF || *pt==CHAR_CR) pt++;
        nn += (int)(pt - pp) + 1;

        pp = pt;
        pt = skip_chars(pt, "?");
        if (pt==NULL) {
            freeNull(*node_name);
            return JBXL_XML_PARSE_ERROR;
        }

        mm = (int)(pt - pp);
        if (mm>0) {
            *node_attr = (char*)malloc((size_t)(mm + 1));
            if (*node_attr==NULL) {
                freeNull(*node_name);
                return JBXL_MALLOC_ERROR;
            }
            memcpy(*node_attr, pp, mm);
            (*node_attr)[mm] = '\0';
            nn += mm;
            //PRINT_MESG("ATTR  --> %s  %d\n", *node_attr, (int)strlen(*node_attr));
        }
    }
    
    if (strncmp(pt, "?>", 2)) {
        freeNull(*node_name);
        freeNull(*node_attr);
        return JBXL_XML_PARSE_ERROR;
    }

    return nn + 2;
}



int  xml_parse_comment_node(char* pp, char** comment)
{
    int   nn, mm;
    char* pt;

    *comment = NULL;
    if (pp==NULL) return JBXL_XML_PARSE_ERROR;
    if (strncmp(pp, "<!--", 4)) return JBXL_XML_PARSE_ERROR;

    pt = pp = pp + 4;
    pt = skip_chars(pt, ">");
    if (pt==NULL) return JBXL_XML_PARSE_ERROR;

    pt -= 2;
    if (strncmp(pt, "-->", 3)) return JBXL_XML_PARSE_ERROR;

    nn = mm = (int)(pt - pp);
    if (mm==0) return JBXL_XML_PARSE_ERROR;

    nn += 4;
    *comment = (char*)malloc((size_t)(mm+1));
    if (*comment==NULL) return JBXL_MALLOC_ERROR;
    memcpy(*comment, pp, mm);
    (*comment)[mm] = '\0';
    //PRINT_MESG("COMMENT-> %s  %d\n", *comment, (int)strlen(*comment));

    return nn + 3;
}



int  xml_parse_data_node(char* pp, char** data)
{
    int   nn, mm;
    char* pt;

    *data = NULL;
    if (pp==NULL) return JBXL_XML_PARSE_ERROR;
    if (strncmp(pp, "<!", 2)) return JBXL_XML_PARSE_ERROR;

    pt = pp = pp + 2;
    pt = skip_chars(pt, ">");
    if (pt==NULL) return JBXL_XML_PARSE_ERROR;

    nn = mm = (int)(pt - pp);
    if (mm==0) return JBXL_XML_PARSE_ERROR;

    nn += 2;
    *data = (char*)malloc((size_t)(mm+1));
    if (*data==NULL) return JBXL_MALLOC_ERROR;
    memcpy(*data, pp, mm);
    (*data)[mm] = '\0';
    //PRINT_MESG("DATA ---> %s  %d\n", *data, (int)strlen(*data));

    return nn + 1;
}



int  isnot_xml_name(unsigned char* pp)
{
    if (pp==NULL)  return TRUE;
    if (*pp=='\0') return TRUE;

    while (*pp!='\0') {
        if (*pp<=0x2c) return TRUE;                 //  !"#$%&'()*+,
        if (*pp==0x2f) return TRUE;                 // /
        if (*pp>=0x3b && *pp<=0x40) return TRUE;    // ;<=>?@
        if (*pp>=0x5b && *pp<=0x5e) return TRUE;    // [\]^
        if (*pp==0x60) return TRUE;                 // `
        if (*pp>=0x7b && *pp<=0x7f) return TRUE;    // {|}~DEL
        pp++;
    }
    
    return FALSE;
}



void   close_xml(tXML* pp)
{
    if (pp!=NULL) {

        // アンカー
         if (pp->ldat.id==XML_ANCHOR_NODE) {
            pp->state = JBXL_XML_PARSED;
            pp->depth = -1;
            if (pp->next!=NULL) {
                pp->next->depth = 0;
                adjust_tTree_depth(pp->next);
                close_xml(pp->next);
            }
            return;
        }

        while(pp->esis!=NULL) pp = pp->esis;
        do {
            if (pp->next==NULL) pp->state = JBXL_XML_NODE_EMPTY;
            //
            if (pp->state!=JBXL_XML_NODE_EMPTY) pp->state = JBXL_XML_NODE_CLOSED;
            //if (pp->ldat.lst!=NULL) {
            //    if ((pp->ldat.lst)->state!=JBXL_XML_NODE_EMPTY) (pp->ldat.lst)->state = JBXL_XML_NODE_CLOSED;
            //}
            //
            if (pp->next!=NULL) close_xml(pp->next);
       
            pp = pp->ysis;
        } while(pp!=NULL);
    }  
       
    return;
}




// Inverse Parse
//

Buffer  xml_inverse_parse(tXML* pp, int mode)
{
    int cnt;
    Buffer buf;

    buf = init_Buffer();
    if (pp==NULL) return buf;
    if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
    if (pp==NULL) return buf;

    cnt = count_tTree(pp);
    buf = make_Buffer(cnt*LMDATA);
    if (buf.buf==NULL) return buf;

    while (pp->esis!=NULL) pp = pp->esis;
    xml_to_Buffer(pp, &buf, mode, pp->depth);

    return buf;
}



void  xml_to_Buffer(tXML* pp, Buffer* buf, int mode, int indent)
{
    do {
        xml_open_node_Buffer(pp, buf, mode, indent);
        if (pp->next!=NULL) {
            xml_to_Buffer(pp->next, buf, mode, indent);
            xml_close_node_Buffer(pp, buf, mode, indent);
        }
        
        pp = pp->ysis;
    } while(pp!=NULL);

    return;
}



void  xml_open_node_Buffer(tXML* pp, Buffer* buf, int mode, int indent)
{
    int i;

    // Name TAG
    if (pp->ldat.id==XML_NAME_NODE) {
        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
            if (buf->vldsz>0 && buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
        }
        //
        if (mode==XML_INDENT_FORMAT) {
            char* tabs = (char*)malloc(pp->depth-indent+1);
            if (tabs!=NULL) {
                for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
                tabs[pp->depth-indent] = '\0';
                cat_s2Buffer(tabs, buf);
                free(tabs);
            }
        }

        cat_s2Buffer("<", buf);
        cat_Buffer(&(pp->ldat.key), buf);
        if (pp->ldat.lst!=NULL) {
            xml_attr_to_Buffer(pp->ldat.lst, buf);
        }
        if (pp->next==NULL) {
            if (pp->state==JBXL_XML_NODE_EMPTY) {
                cat_s2Buffer(" />", buf);
            }
            else {
                cat_s2Buffer("></", buf);
                cat_Buffer(&(pp->ldat.key), buf);
                cat_s2Buffer(">", buf);
            }
            if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
                cat_s2Buffer("\r\n", buf);
            }
        }
        else {
            cat_s2Buffer(">", buf);
        }
    }
    
    // Content
    else if (pp->ldat.id==XML_CONTENT_NODE) {
        if (buf->buf[buf->vldsz-1]=='\n') {
            buf->buf[buf->vldsz-2] = '\0';
            buf->vldsz -= 2;
        }
        //
        if (pp->esis!=NULL || pp->ysis!=NULL) {
            cat_s2Buffer("\r\n", buf); 
            char* tabs = (char*)malloc(pp->depth-indent+1);
            if (tabs!=NULL) {
                for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
                tabs[pp->depth-indent] = '\0';
                cat_s2Buffer(tabs, buf);
                free(tabs);
            }
        }
        //
        cat_Buffer(&(pp->ldat.key), buf);
        //
        if (pp->esis!=NULL) cat_s2Buffer("\r\n", buf); 
    }

    // xml TAG
    else if (pp->ldat.id==XML_DOC_NODE) {
        if (mode==XML_INDENT_FORMAT) {
            char* tabs = (char*)malloc(pp->depth-indent+1);
            if (tabs!=NULL) {
                for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
                tabs[pp->depth-indent] = '\0';
                cat_s2Buffer(tabs, buf);
                free(tabs);
            }
        }

        cat_s2Buffer("<?", buf);
        if (pp->ldat.key.buf!=NULL) {
            cat_Buffer(&(pp->ldat.key), buf);
        }
        if (pp->ldat.lst!=NULL) {
            xml_attr_to_Buffer(pp->ldat.lst, buf);
        }
        cat_s2Buffer("?>", buf);

        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
    }

    // Comment TAG
    else if (pp->ldat.id==XML_COMMENT_NODE) {
        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
            if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
        }

        if (mode==XML_INDENT_FORMAT) {
            char* tabs = (char*)malloc(pp->depth-indent+1);
            if (tabs!=NULL) {
                for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
                tabs[pp->depth-indent] = '\0';
                cat_s2Buffer(tabs, buf);
                free(tabs);
            }
        }

        cat_s2Buffer("<!--", buf);
        if (pp->ldat.val.buf!=NULL) {
            cat_Buffer(&(pp->ldat.val), buf);
        }
        cat_s2Buffer("-->", buf);

        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
    }

    // Data TAG
    else if (pp->ldat.id==XML_DATA_NODE) {
        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
            if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
        }
        //
        if (mode==XML_INDENT_FORMAT) {
            char* tabs = (char*)malloc(pp->depth-indent+1);
            if (tabs!=NULL) {
                for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
                tabs[pp->depth-indent] = '\0';
                cat_s2Buffer(tabs, buf);
                free(tabs);
            }
        }

        cat_s2Buffer("<!", buf);
        if (pp->ldat.val.buf!=NULL) {
            cat_Buffer(&(pp->ldat.val), buf);
        }
        cat_s2Buffer(">", buf);

        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
    }

    // Processing TAG
    else if (pp->ldat.id==XML_PROCESS_NODE) {
        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
            if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
        }
        //
        if (mode==XML_INDENT_FORMAT) {
            char* tabs = (char*)malloc(pp->depth-indent+1);
            if (tabs!=NULL) {
                for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
                tabs[pp->depth-indent] = '\0';
                cat_s2Buffer(tabs, buf);
                free(tabs);
            }
        }

        cat_s2Buffer("<?", buf);
        if (pp->ldat.key.buf!=NULL) {
            cat_Buffer(&(pp->ldat.key), buf);
        }
        if (pp->ldat.lst!=NULL) {
            xml_attr_to_Buffer(pp->ldat.lst, buf);
        }
        cat_s2Buffer(" ?>", buf);

        if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
    }

    return;
}



void  xml_close_node_Buffer(tXML* pp, Buffer* buf, int mode, int indent)
{
    int i;

    if (pp->ldat.id==XML_NAME_NODE) {
        if (pp->next!=NULL) {
            if (mode==XML_INDENT_FORMAT) {
                if (pp->next->ldat.id!=XML_CONTENT_NODE || pp->next->ysis!=NULL) {
                    char* tabs = (char*)malloc(pp->depth-indent+1);
                    if (tabs!=NULL) {
                        for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
                        tabs[pp->depth-indent] = '\0';
                        cat_s2Buffer(tabs, buf);
                        free(tabs);
                    }
                }
            }

            cat_s2Buffer("</", buf);
            cat_Buffer(&(pp->ldat.key), buf);
            cat_s2Buffer(">", buf);

            if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
        }
    }

    return;
}



void  xml_attr_to_Buffer(tList* pp, Buffer* buf)
{
    while (pp!=NULL) {
        cat_s2Buffer(" ", buf);
        cat_Buffer(&(pp->ldat.key), buf);

        if (pp->ldat.val.buf!=NULL) {
            cat_s2Buffer("=", buf);
            cat_Buffer(&(pp->ldat.val), buf);
        }
        pp = pp->next;
    }
}




// Operation
//

tXML*  init_xml_doc()
{
    tXML* xml = xml_parse((char*)"<?xml version=\"1.0\" encoding=\"utf-8\"?>");
    return xml;
}



tXML*  add_xml_node(tXML* xml, const char* name)
{
    tXML* pp;

    if (name==NULL) return NULL;

    pp = add_tTree_node_bystr(xml, XML_NAME_NODE, 0, name, NULL, NULL, 0);
    pp->state = JBXL_XML_NODE_EMPTY;
    if (pp->prev!=NULL) pp->prev->ldat.lv++;

    return pp;
}



tXML*  insert_xml_node(tXML* xml, const char* name)
{
    tList* pp;

    if (xml==NULL || name==NULL) return NULL;

    pp = insert_tTree_node_bystr(xml, XML_NAME_NODE, 0, name, NULL, NULL, 0);
    pp->state = JBXL_XML_NODE_EMPTY;
    if (pp->prev!=NULL) pp->prev->ldat.lv++;

    return pp;
}



tXML*  add_xml_content(tXML* xml, const char* content)
{
    tList* pp;

    if (xml==NULL || content==NULL) return NULL;
    if (xml->ldat.id!=XML_NAME_NODE) return NULL;

    pp = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, content, NULL, NULL, 0);
    pp->state = JBXL_XML_NODE_CLOSED;
    if (pp->prev!=NULL) pp->prev->ldat.lv++;
  
    return pp;
}



tXML*  append_xml_content(tXML* xml, const char* content)
{
    tList* pp;

    if (xml==NULL || content==NULL) return NULL;
    if (xml->ldat.id!=XML_NAME_NODE) return NULL;
    
    pp = xml->next;
    while (pp!=NULL && pp->ldat.id!=XML_CONTENT_NODE) pp = pp->ysis;

    if (pp==NULL) {
        pp = add_xml_content(xml, content);
    }
    else {
        if (pp->ldat.key.vldsz!=0) cat_s2Buffer(" ", &(pp->ldat.key));
        cat_s2Buffer(content, &(pp->ldat.key));
    }

    return pp;
}


int  add_xml_content_area(tXML* xml, int len)
{
    if (xml==NULL || len<=0) return FALSE;
    
    char* area = (char*)malloc(len);
    if (area==NULL) return FALSE;
    memset(area, (int)' ', len-1);
    area[len-1] = '\0';

    tXML* pp = add_xml_content(xml, area);
    if (pp!=NULL) {
        pp->ldat.key.buf[0] = '\0';
        pp->ldat.key.vldsz  = 0;
    }
    free(area);

    return TRUE;
}


tXML*  add_xml_attr(tXML* xml, const char* attr)
{
    if (xml==NULL || attr==NULL) return NULL;
    if (xml->ldat.id!=XML_NAME_NODE) return NULL;

    tList* lp = xml_parse_attr((char*)attr);

    if (xml->ldat.lst==NULL) xml->ldat.lst = lp;
    else add_tList_end(xml->ldat.lst, lp);

    return xml;
}


tXML*  add_xml_attr_str(tXML* xml, const char* name, const char* value)
{
    if (xml==NULL || name==NULL) return NULL;

    Buffer attr = make_xml_attr_str(name, value);
    add_xml_attr(xml, (char*)attr.buf);
    free_Buffer(&attr);

    return xml;
}


tXML*  add_xml_attr_int(tXML* xml, const char* name, int value)
{
    if (xml==NULL || name==NULL) return NULL;
    //
    Buffer attr = make_xml_attr_int(name, value);
    add_xml_attr(xml, (char*)attr.buf);
    free_Buffer(&attr);

    return xml;
}


tXML*  add_xml_attr_float(tXML* xml, const char* name, float value)
{
    if (xml==NULL || name==NULL) return NULL;
    //
    Buffer attr = make_xml_attr_float(name, value);
    add_xml_attr(xml, (char*)attr.buf);
    free_Buffer(&attr);

    return xml;
}


tXML*  add_xml_attr_double(tXML* xml, const char* name, double value)
{
    if (xml==NULL || name==NULL) return NULL;
    //
    Buffer attr = make_xml_attr_double(name, value);
    add_xml_attr(xml, (char*)attr.buf);
    free_Buffer(&attr);

    return xml;
}



char*  get_first_xml_nodename(tXML* xml)
{  
    char* nodename = NULL;
   
    if (xml==NULL) return NULL;
    tList* lp = xml;
    if (lp->ldat.id==XML_ANCHOR_NODE) lp = lp->next;
   
    while (lp!=NULL) {
        if (lp->ldat.id==XML_NAME_NODE) {
            if (lp->ldat.key.buf!=NULL) {
                nodename = (char*)lp->ldat.key.buf;
                break;
            }
        }
        lp = lp->ysis;
    }
    return nodename;
}


Buffer make_xml_attr_bystr(const char* name, const char* value)
{
    Buffer buf = make_Buffer_bystr(name);
    cat_s2Buffer("=\"", &buf);
    cat_s2Buffer(value, &buf);
    cat_s2Buffer("\"",  &buf);

    return buf;
}


Buffer make_xml_attr_byint(const char* name, int value)
{
    char* str = itostr_ts(value);

    Buffer buf = make_Buffer_bystr(name);
    cat_s2Buffer("=\"", &buf);
    cat_s2Buffer(str, &buf);
    cat_s2Buffer("\"",  &buf);

    freeNull(str);
    return buf;
}


Buffer make_xml_attr_byfloat(const char* name, float value)
{
    char* str = ftostr_ts(value);

    Buffer buf = make_Buffer_bystr(name);
    cat_s2Buffer("=\"", &buf);
    cat_s2Buffer(str, &buf);
    cat_s2Buffer("\"",  &buf);

    freeNull(str);
    return buf;
}


Buffer make_xml_attr_bydouble(const char* name, double value)
{
    char* str = dtostr_ts(value);

    Buffer buf = make_Buffer_bystr(name);
    cat_s2Buffer("=\"", &buf);
    cat_s2Buffer(str, &buf);
    cat_s2Buffer("\"",  &buf);

    freeNull(str);
    return buf;
}



char* xml_get_node_content(tXML* node)
{
    if (node==NULL || node->next==NULL) return NULL;

    if (node->ldat.id==XML_NAME_NODE) {
        if (node->next->ldat.id==XML_CONTENT_NODE) return (char*)(node->next->ldat.key.buf);
    }
    return NULL;
}



char* xml_get_node_attr(tXML* node, const char* attr)
{
    if (node==NULL) return NULL;

    if (node->ldat.id==XML_NAME_NODE) {
        tList* lt = node->ldat.lst;
        while (lt!=NULL) {
            if (!strcmp((const char*)lt->ldat.key.buf, attr)) return (char*)(lt->ldat.val.buf);
            lt = lt->next;
        }
    }
    return NULL;
}



tXML*  dup_merge_xml(tXML* pp, tXML* tp)
{
    if (tp==NULL) return pp;

    if (tp->ldat.id==XML_ANCHOR_NODE) {
        if (tp->next!=NULL) tp = tp->next;
        else return pp;
    }

    pp = dup_merge_tTree(pp, tp);

/*
    tXML* pt;
    if (pp->ldat.id!=XML_ANCHOR_NODE) {
        pt = new_tTree_node();
        pt->ldat.id = XML_ANCHOR_NODE;
        pt->depth = -1;
        add_tTree(pt, pp);
        close_xml(pt);
        return pt;
    }
*/

    return pp;
}



void   print_xml(FILE* fp, tXML* pp, int mode)
{
    if (fp==NULL) fp = stderr;

    if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;

    if (pp!=NULL) {
        Buffer buf = xml_inverse_parse(pp, mode);
        if (buf.buf!=NULL) {
            fprintf(fp, "%s", buf.buf);
            free_Buffer(&buf);
        }
        else fprintf(fp, "(XML is NULL)\n");
    }  
    else {
        fprintf(fp, "(XML is NULL)\n");
    } 
    fflush(fp);
       
    return;
}



void   print_xml_node(FILE* fp, tXML* pp)
{
    if (fp==NULL) fp = stderr;

    //fprintf(fp, "深さ: ノード種別 [状態] ノード名 (属性数)\n");

    if (pp!=NULL) {
        if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
        if (pp!=NULL) {
            int num = count_tList((tList*)pp->ldat.lst);
            fprintf(fp, "%d: %d [%d] %s (%d)", pp->depth, pp->ldat.id, pp->state, pp->ldat.key.buf, num);
            fprintf(fp, "\n");
        }
        else {
            fprintf(fp, "(XML is ANCHOR only)\n");
        }
    }  
    else {
        fprintf(fp, "(XML is NULL)\n");
    }  
    fflush(fp);

    return;
}



void   print_xml_tree(FILE* fp, tXML* pp, const char* space)
{
    int i;
    if (fp==NULL) fp = stderr;

    //fprintf(fp, "深さ: ノード種別 [状態] ノード名 (属性数)\n");

    if (pp!=NULL) {
        if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
        if (pp!=NULL) {
            for(i=0; i<pp->depth; i++)   fprintf(fp, "%s", space);
            for(i=0; i<pp->depth-1; i++) fprintf(fp, "%s", "   ");       // for "-> "
            print_sister_xml_tree(fp, pp, space);
            fprintf(fp, "\n");
        }
        else {
            fprintf(fp, "(XML is ANCHOR only)\n");
        }
    }  
    else {
        fprintf(fp, "(XML is NULL)\n");
    }  
    fflush(fp);

    return;
}



void   print_sister_xml_tree(FILE* fp, tXML* pp, const char* space)
{
    if (fp==NULL) fp = stderr;

    if (pp!=NULL) {
        if (pp->ldat.id==XML_ANCHOR_NODE) {
            if (pp->next!=NULL) pp = pp->next;
        }

        while(pp->esis!=NULL) pp = pp->esis;
        //
        while(pp!=NULL) {
            int i;
            tList_data ld = pp->ldat;

            if (pp->depth>=0) {
                if (pp->esis!=NULL || pp->depth>=0) fprintf(fp, "\n");
                if (pp->depth>0) {
                    for(i=0; i<pp->depth; i++) fprintf(fp, "%s", space);
                    //for(i=0; i<pp->depth-1; i++) fprintf(fp, "%s", "   ");
                    fprintf(fp, "-> ");
                }
            }
            int num = count_tList((tList*)ld.lst);
            fprintf(fp, "%d: %d [%d] %s (%d)", pp->depth, ld.id, pp->state, ld.key.buf, num);

            if (pp->next!=NULL) print_sister_xml_tree(fp, pp->next, space);
       
            pp = pp->ysis;
        };
    }  
    else {
        fprintf(fp, "(XML is NULL)\n");
    } 
    fflush(fp);
       
    return;
}




// Search and Get/Set
//

tXML*  get_xml_node(tXML* pp, tXML* pt)
{
    int fnd;
    tXML* tt;
    tXML* pm;

    if (pp==NULL || pt==NULL) return NULL;

    pm = pp;
    if (pp->ldat.id==XML_ANCHOR_NODE) {
        if (pp->next!=NULL) pp = pp->next;
        else return NULL;
    }
    if (pt->ldat.id==XML_ANCHOR_NODE) {
        if (pt->next!=NULL) pt = pt->next;
        else return NULL;
    }

    tt = find_xml_end(pt);
    if (tt==NULL) return FALSE;

    while(pp->esis!=NULL) pp = pp->esis;
    fnd = find_match_xml(pp, pt);
    if (fnd) tt = tt->altp;
    else     tt = NULL;

    clear_tTree_ctrl(pm);

    return tt;
}



int set_xml_node(tXML* pp, tXML* pt, const char* name)
{
    tXML* tt;

    if (pp==NULL || pt==NULL || name==NULL) return FALSE;

    tt = get_xml_node(pp, pt);
    if (tt==NULL) return FALSE;
    
    copy_s2Buffer(name, &(tt->ldat.key));

    return TRUE;
}



int set_xml_end_node(tXML* pp, tXML* pt)
{
    int      ret;
    tXML* tt;
    tXML* pm;


    if (pp==NULL || pt==NULL) return FALSE;

    pm = pp;
    if (pp->ldat.id==XML_ANCHOR_NODE) {
        if (pp->next!=NULL) pp = pp->next;
        else return FALSE;
    }
    if (pt->ldat.id==XML_ANCHOR_NODE) {
        if (pt->next!=NULL) pt = pt->next;
        else return FALSE;
    }

    tt = find_xml_end(pt);
    if (tt==NULL) return FALSE;
    tt->ctrl = TREE_NOCMP_COPY_NODE;        // 比べない．最後にコピー．

    while(pp->esis!=NULL) pp = pp->esis;
    ret = find_match_xml(pp, pt);
    if (ret) {
        copy_tTree_byctrl(pt);
        adjust_tTree_depth(pp);
    }

    clear_tTree_ctrl(pm);

    return ret;
}



tXML*  get_xml_content(tXML* pp, tXML* pt)
{
    int fnd;
    tXML* tt = NULL;
    tXML* pm;
    tXML* dm;

    if (pp==NULL || pt==NULL) return NULL;

    pm = pp;
    if (pp->ldat.id==XML_ANCHOR_NODE) {
        if (pp->next!=NULL) pp = pp->next;
        else return NULL;
    }
    if (pt->ldat.id==XML_ANCHOR_NODE) {
        if (pt->next!=NULL) pt = pt->next;
        else return NULL;
    }

    tt = find_xml_end(pt);
    if (tt==NULL) return NULL;
    dm = add_xml_content(tt, (char*)"DUMMY");
    if (dm==NULL) return NULL;
    dm->ctrl = TREE_NOCMP_NODE;

    while(pp->esis!=NULL) pp = pp->esis;

    fnd = find_match_xml(pp, pt);
    if (fnd) tt = dm->altp;
    else     tt = NULL;

    del_xml(&dm);
    clear_tTree_ctrl(pm);

    return tt;
}



int set_xml_content(tXML* pp, tXML* pt, const char* content)
{
    tXML* tt;

    if (pp==NULL || pt==NULL || content==NULL) return FALSE;

    tt = get_xml_content(pp, pt);
    if (tt==NULL) return FALSE;
    
    copy_s2Buffer(content, &(tt->ldat.key));
    return TRUE;
}



int  get_xml_int_content(tXML* pp, tXML* pt)
{
    int ret = 0;

    tXML* node = get_xml_content(pp, pt);
    if (node!=NULL) ret = atoi((char*)(node->ldat.key.buf));
    return ret;
}



float  get_xml_float_content(tXML* pp, tXML* pt)
{
    float ret = 0.0;

    tXML* node = get_xml_content(pp, pt);
    if (node!=NULL) ret = (float)atof((char*)(node->ldat.key.buf));
    return ret;
}



double  get_xml_double_content(tXML* pp, tXML* pt)
{
    double ret = 0.0;

    tXML* node = get_xml_content(pp, pt);
    if (node!=NULL) ret = atof((char*)(node->ldat.key.buf));
    return ret;
}



char*   get_xml_char_content(tXML* pp, tXML* pt)
{
    char* ret = NULL;

    tXML* node = get_xml_content(pp, pt);
    if (node!=NULL) ret = (char*)(node->ldat.key.buf);
    return ret;
}



tList*  get_xml_attr(tXML* pp, tXML* pt)
{
    tList* lp = NULL;
    tXML*  tt;

    if (pp==NULL || pt==NULL) return NULL;

    tt  = get_xml_node(pp, pt);
    if (tt!=NULL) lp = tt->ldat.lst;    
    return lp;
}



char*  get_xml_char_attr(tXML* pp, tXML* pt, const char* attr)
{
    char* ret = NULL;
    if (pp==NULL || pt==NULL || attr==NULL) return ret;

    tXML* node = get_xml_node(pp, pt);
    if (node!=NULL) ret = xml_get_node_attr(node, attr);
    return ret;
}



int  get_xml_int_attr(tXML* pp, tXML* pt, const char* attr)
{
    int ret = 0;
    if (pp==NULL || pt==NULL || attr==NULL) return ret;

    tXML* node = get_xml_node(pp, pt);
    if (node!=NULL) {
        char* val = xml_get_node_attr(node, attr);
        if (val!=NULL) {
            Buffer buf = make_Buffer_bystr(val);
            char* ptr  = (char*)buf.buf;
            if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
            if (ptr[0]=='"') ptr++; 
            ret = atoi(ptr);
            free_Buffer(&buf);
        }
    }
    return ret;
}



double  get_xml_double_attr(tXML* pp, tXML* pt, const char* attr)
{
    double ret = 0.0;
    if (pp==NULL || pt==NULL || attr==NULL) return ret;

    tXML* node = get_xml_node(pp, pt);
    if (node!=NULL) {
        char* val = xml_get_node_attr(node, attr);
        if (val!=NULL) {
            Buffer buf = make_Buffer_bystr(val);
            char* ptr  = (char*)buf.buf;
            if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
            if (ptr[0]=='"') ptr++; 
            ret = atof(ptr);
            free_Buffer(&buf);
        }
    }
    return ret;
}



int  set_xml_attr(tXML* pp, tXML* pt, tList* at)
{
    tXML* tt;

    if (pp==NULL || pt==NULL || at==NULL) return FALSE;

    tt  = get_xml_node(pp, pt);
    if (tt!=NULL) {
        del_all_tList(&(tt->ldat.lst));
        tt->ldat.lst = dup_tList(at);
    }
    else return FALSE;
    return TRUE;
}



int  replace_xml_content(tXML* pp, tXML* pt, const char* src, const char* dst)
{
    tXML*  tt;
    Buffer tg;

    if (pp==NULL || pt==NULL || src==NULL || dst==NULL) return FALSE;

    tt = get_xml_content(pp, pt);
    if (tt==NULL) return FALSE;

    tg = replace_sBuffer_bystr(tt->ldat.key, src, dst);
    if (tg.buf==NULL) return FALSE;

    free_Buffer(&(tt->ldat.key));
    tt->ldat.key = tg;
    
    return TRUE;
}



tXML*  get_xml_node_bystr(tXML* pp, const char* str)
{
    tXML* tx;
    tXML* tt;

    if (pp==NULL || str==NULL) return FALSE;

    tx = xml_parse((char*)str);
    tt = get_xml_node(pp, tx);
    del_xml(&tx);
    return tt;
}



int  set_xml_node_bystr(tXML* pp, const char* str, const char* val)
{
    tXML*  tx;
    int    rt;

    if (pp==NULL || str==NULL || val==NULL) return FALSE;

    tx = xml_parse((char*)str);
    rt = set_xml_node(pp, tx, val);
    del_xml(&tx);
    return rt;
}



int  set_xml_end_node_bystr(tXML* pp, const char* str)
{
    tXML*  tx;
    int    rt;

    if (pp==NULL || str==NULL) return FALSE;

    tx = xml_parse((char*)str);
    rt = set_xml_end_node(pp, tx);
    del_xml(&tx);
    return rt;
}



tXML*  get_xml_content_bystr(tXML* pp, const char* str)
{
    tXML* tx;
    tXML* tt;

    if (pp==NULL || str==NULL) return FALSE;

    tx = xml_parse((char*)str);
    tt = get_xml_content(pp, tx);
    del_xml(&tx);
    return tt;
}



int  get_xml_int_content_bystr(tXML* pp, const char* str)
{
    int ret = 0;

    tXML* node = get_xml_content_bystr(pp, str);
    if (node!=NULL) ret = atoi((char*)(node->ldat.key.buf));
    return ret;
}



float  get_xml_float_content_bystr(tXML* pp, const char* str)
{
    float ret = 0.0;

    tXML* node = get_xml_content_bystr(pp, str);
    if (node!=NULL) ret = (float)atof((char*)(node->ldat.key.buf));
    return ret;
}



double  get_xml_double_content_bystr(tXML* pp, const char* str)
{
    double ret = 0.0;

    tXML* node = get_xml_content_bystr(pp, str);
    if (node!=NULL) ret = atof((char*)(node->ldat.key.buf));
    return ret;
}



char*   get_xml_char_content_bystr(tXML* pp, const char* str)
{
    char* ret = NULL;

    tXML* node = get_xml_content_bystr(pp, str);
    if (node!=NULL) ret = (char*)(node->ldat.key.buf);
    return ret;
}



int  set_xml_content_bystr(tXML* pp, const char* str, const char* val)
{
    tXML*  tx;
    int    rt;

    if (pp==NULL || str==NULL || val==NULL) return FALSE;

    tx = xml_parse((char*)str);
    rt = set_xml_content(pp, tx, val);
    del_xml(&tx);
    return rt;
}



tList*  get_xml_attr_bystr(tXML* pp, const char* str)
{
    tXML*  tx;
    tList* tt;

    if (pp==NULL || str==NULL) return NULL;

    tx = xml_parse((char*)str);
    tt = get_xml_attr(pp, tx);
    del_xml(&tx);
    return tt;
}



char*  get_xml_char_attr_bystr(tXML* pp, const char* str, const char* attr)
{
    char* ret = NULL;
    if (pp==NULL || str==NULL || attr==NULL) return ret;

    tXML* node = get_xml_node_bystr(pp, str);
    if (node!=NULL) ret = xml_get_node_attr(node, attr);
    return ret;
}



int  get_xml_int_attr_bystr(tXML* pp, const char* str, const char* attr)
{
    int ret = 0;
    if (pp==NULL || str==NULL || attr==NULL) return ret;

    tXML* node = get_xml_node_bystr(pp, str);
    if (node!=NULL) {
        char* val = xml_get_node_attr(node, attr);
        if (val!=NULL) {
            Buffer buf = make_Buffer_bystr(val);
            char* ptr  = (char*)buf.buf;
            if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
            if (ptr[0]=='"') ptr++; 
            ret = atoi(ptr);
            free_Buffer(&buf);
        }
    }
    return ret;
}



double  get_xml_double_attr_bystr(tXML* pp, const char* str, const char* attr)
{
    double ret = 0.0;
    if (pp==NULL || str==NULL || attr==NULL) return ret;

    tXML* node = get_xml_node_bystr(pp, str);
    if (node!=NULL) {
        char* val = xml_get_node_attr(node, attr);
        if (val!=NULL) {
            Buffer buf = make_Buffer_bystr(val);
            char* ptr  = (char*)buf.buf;
            if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
            if (ptr[0]=='"') ptr++; 
            ret = atof(ptr);
            free_Buffer(&buf);
        }
    }
    return ret;
}



int  set_xml_attr_bystr(tXML* pp, const char* str, tList* at)
{
    tXML* tx;
    int   rt;

    if (pp==NULL || str==NULL || at==NULL) return FALSE;

    tx = xml_parse((char*)str);
    rt = set_xml_attr(pp, tx, at);
    del_xml(&tx);
    return rt;
}



int  replace_xml_content_bystr(tXML*pp, const char* str, const char* src, const char* dst)
{
    tXML* tx;
    int   rt;

    if (pp==NULL || src==NULL || src==NULL || dst==NULL) return FALSE;

    tx = xml_parse((char*)str);
    rt = replace_xml_content(pp, tx, src, dst);
    del_xml(&tx);
    return rt;
}




// Operation for Multi Tags
//

tList*  get_xml_node_list(tXML* pp, tXML* pt)
{
    tList* lp;

    if (pp==NULL || pt==NULL) return NULL;

    if (pp->ldat.id==XML_ANCHOR_NODE) {
        if (pp->next!=NULL) pp = pp->next;
        else return NULL;
    }
    if (pt->ldat.id==XML_ANCHOR_NODE) {
        if (pt->next!=NULL) pt = pt->next;
        else return NULL;
    }

    lp = find_match_xml_endlist(pp, pt);

    return lp;
}



tList*  get_xml_content_list(tXML* pp, tXML* pt)
{
    tList* lp;
    tList* dm;

    if (pp==NULL || pt==NULL) return NULL;

    if (pp->ldat.id==XML_ANCHOR_NODE) {
        if (pp->next!=NULL) pp = pp->next;
        else return NULL;
    }
    if (pt->ldat.id==XML_ANCHOR_NODE) {
        if (pt->next!=NULL) pt = pt->next;
        else return NULL;
    }

    dm = find_xml_end(pt);
    if (dm==NULL) return NULL;
    dm = add_xml_content(dm, (char*)"DUMMY");
    if (dm==NULL) return NULL;
    dm->ctrl = TREE_NOCMP_NODE;

    lp = find_match_xml_endlist(pp, pt);
    del_xml(&dm);

    return lp;
}



int  set_xml_content_list(tXML* pp, tXML* pt, const char* content)
{
    int    num = 0;
    tList* lt;
    tList* lp;

    if (pp==NULL  || pt==NULL || content==NULL)  return 0;

    lp = lt = get_xml_content_list(pp, pt);
    if (lt==NULL) return 0;

    while (lt!=NULL) {
        if (lt->altp!=NULL) {
            copy_s2Buffer(content, &(lt->altp->ldat.key));
            num++;
        }
        lt = lt->next;
    }
    del_tList(&lp);

    return num;
}



tList*  get_xml_node_list_bystr(tXML* pp, const char* str)
{
    tXML*  tx;
    tList* tt;

    if (pp==NULL || str==NULL) return NULL;

    tx = xml_parse((char*)str);
    tt = get_xml_node_list(pp, tx);
    del_xml(&tx);

    return tt;
}



tList*  get_xml_content_list_bystr(tXML* pp, const char* str)
{
    tXML*  tx;
    tList* tt;

    if (pp==NULL || str==NULL) return NULL;

    tx = xml_parse((char*)str);
    tt = get_xml_content_list(pp, tx);
    del_xml(&tx);

    return tt;
}



int  set_xml_content_list_bystr(tXML* pp, const char* str, const char* content)
{
    tXML* tx;
    int   rt;

    if (pp==NULL  || str==NULL || content==NULL) return 0;

    tx = xml_parse((char*)str);
    rt = set_xml_content_list(pp, tx, content);
    del_xml(&tx);

    return rt;
}




// Search Function for XML
//         tTree 用の関数とほぼ同じ
//

int  find_match_xml(tXML* pp, tXML* pt)
{
    int   ret;
    tXML* pm;

    pm = pp;
    while(pp!=NULL) {
        ret = check_match_xml(pp, pt);
        if (ret) return TRUE;

        if (pp->next!=NULL) {
            ret = find_match_xml(pp->next, pt);
            if (ret) {
                clear_tTree_ctrl(pm);
                return TRUE;
            }
        }
        pp = pp->ysis;
    }

    return FALSE;
}



tXML*  find_match_xml_endlist(tXML* pp, tXML* pt)
{
    tXML*  te;
    tList* lp;

    te = find_xml_end(pt);
    while(pp->esis!=NULL) pp = pp->esis;

    lp = find_match_xml_endlist_rcsv(pp, pt, te);
    if (lp!=NULL) clear_tTree_ctrl(pp);
    
    return lp;
}



tList*  find_match_xml_endlist_rcsv(tXML* pp, tXML* pt, tXML* te)
{
    tList* lt = NULL;
    tList* lp = NULL;
                    
    while(pp!=NULL) {             
        int ret = check_match_xml(pp, pt);
        if (ret && te->altp!=NULL) {
            tList* lm = new_tList_node();
            lm->altp = te->altp;  
            lt = insert_tList(lt, lm);
            if (lp==NULL) lp = lt;
            te->altp = NULL;
        }  
                            
        if (pp->next!=NULL) {     
            tList* lm = find_match_xml_endlist_rcsv(pp->next, pt, te);
            if (lm!=NULL) {       
                lt = insert_tList(lt, lm);
                if (lp==NULL) lp = lt;
                clear_tTree_ctrl(pp->next);
            }
        }
                                   
        if (!ret) pp = pp->ysis;    // 見つかった場合はもう一度．見つからなかった場合へ次へ．
    }

    return lp;
}



tXML*  find_match_xml_end_node(tXML* pp, tXML* pt)
{
    int    ret;
    tXML*  tt = NULL;
    tXML*  pm;

    if (pp==NULL || pt==NULL) return NULL;

    pm  = pp;
    ret = find_match_tTree(pp, pt);
    if (ret) {
        tt = find_xml_end(pt);
        if (tt!=NULL) {
            tt = tt->altp;
        }
    }

    clear_tTree_ctrl(pm);

    return tt;
}



int  check_match_xml(tXML* tp, tXML* tr)
{
    int   ret;
    tXML* te;
    tXML* ts;

    tXML* tt;
    tXML* ta;
    tXML* tb;

    if (tp==NULL || tr==NULL) return FALSE;

    te = find_tList_end(tr);

    ts = tp;
    while (ts!=NULL) {
        tt = cmp_sisters_xml(ts, tr);        // その階層で trと全て一致している部分があるかを確認
        if (tt==NULL) return FALSE;          // 一致していなければ，FALSE
        
        ta  = tt;                            // 比べられるツリー
        tb  = tr;                            // 比べるパターン
        ret = TRUE;
        while (tb!=NULL && ret) {
            if (tb->next==NULL) ret = TRUE;
            // ->ta, ->tb->tx: FALSE
            else if (tb->next!=NULL && ta->next==NULL) ret = FALSE;
            // ->ta->xa, ->tb->xb: xaとxbをチェック
            else ret = check_match_xml(ta->next, tb->next);

            ta = ta->ysis;
            tb = tb->ysis;
        }

        if (ret) {
            if (tr==te) tt->ctrl = TREE_ALREADY_FOUND_NODE;
            return TRUE;
        }

        ts = tt->ysis;
    }

    return FALSE;
}



tXML*  cmp_sisters_xml(tXML* tp, tXML* tr)
{
    tXML* ta;
    tXML* tb = NULL;
    tXML* ts;

    ts = tp;
    while (ts!=NULL){
        ta = ts;
        tb = tr;
        while (ta!=NULL && tb!=NULL) {
            // 一致しない場合 break
            if (ta->ctrl==TREE_ALREADY_FOUND_NODE) break;
            if (tb->ctrl!=TREE_NOCMP_NODE && tb->ctrl!=TREE_NOCMP_COPY_NODE) {
                if ((ta->ldat).key.buf!=NULL && (tb->ldat).key.buf!=NULL) {
                    if (ta->ldat.id!=tb->ldat.id || strcmp((char*)((ta->ldat).key.buf), (char*)((tb->ldat).key.buf))) break;
                }
                else break;
            }

            // ta と tb は一致
            tb->altp = ta;
            ta = ta->ysis;
            tb = tb->ysis;
        }

        // ts と tr は完全に一致
        if (tb==NULL) return ts;

        ts = ts->ysis;
    }

    return NULL;
}




// Simple Node Functions  (単純な構造のノードの操作)
//

Buffer  get_node_content(tXML* tp, const char* name, int no)
{
    Buffer content;
    tXML*  tt;
    
    content = init_Buffer();
    if (tp==NULL || name==NULL) return content;

    if (no<=0) no = 1;
    tt = strncmp_tTree(tp, name, 0, no);
    if (tt!=NULL) {
        if (tt->next!=NULL) {
            tt = tt->next;
            while (tt!=NULL && tt->ldat.id!=XML_CONTENT_NODE) tt = tt->ysis;
            if (tt==NULL) return content;
            content = dup_Buffer(tt->ldat.key);
        }
    }

    return content;
}



int  get_node_integer(tXML* tp, const char* name, int no)
{
    int       ret;
    Buffer content;

    content = get_node_content(tp, name, no);

    if (content.buf==NULL) ret = 0;
    else                   ret = atoi((const char*)content.buf);
    free_Buffer(&content);

    return  ret;
}



int   return_exist_node(tXML* tp, const char* name, int no, Buffer* content) 
{
    Buffer buf;
    
    buf = get_node_content(tp, name, no);
    if (buf.buf==NULL) return FALSE;

    if (content!=NULL) *content = buf;
    return TRUE;
}



int  replace_all_node_integer(tXML* tp, const char* name, int src, int dst)
{
    int  n;
    char nums[20], numd[20];

    snprintf(nums, 10, "%d", src);
    snprintf(numd, 10, "%d", dst);

    n = replace_all_node_contents(tp, name, nums, numd);

    return n;
}



int  replace_all_node_contents(tXML* pp, const char* name, const char* src, const char* dst)
{
    int  n;

    if (pp==NULL || dst==NULL) return 0;

    if (pp->ldat.id==XML_ANCHOR_NODE) {
        if (pp->next!=NULL) pp = pp->next;
        else return 0;
    }
    while(pp->esis!=NULL) pp = pp->esis;

    n = replace_all_node_contents_rcsv(pp, name, src, dst);

    return n;
}



int  replace_all_node_contents_rcsv(tXML* pp, const char* name, const char* src, const char* dst)
{
    int  n = 0;

    while(pp!=NULL) {
        if (pp->ldat.key.buf!=NULL && pp->ldat.id==XML_NAME_NODE && pp->ldat.lv>0) {
            if (name==NULL || !strcmp(name, (const char*)(pp->ldat.key.buf))) {
                tXML* tt = pp->next;

                // 複数のコンテント
                while (tt!=NULL) {
                    if (tt->ldat.id==XML_CONTENT_NODE) {
                        if (src==NULL) {
                            copy_s2Buffer(dst, &(tt->ldat.key));
                            n++;
                        }
                        else if (tt->ldat.key.buf!=NULL && strstr((const char*)tt->ldat.key.buf, src)!=NULL) {
                            Buffer buf = replace_sBuffer_bystr(tt->ldat.key, src, dst);
                            free_Buffer(&(tt->ldat.key));
                            tt->ldat.key = buf;
                            n++;
                        }
                    }
                    tt = tt->ysis;
                }
            }
        }

        if (pp->next!=NULL) n += replace_all_node_contents_rcsv(pp->next, name, src, dst);

        pp = pp->ysis;
    }

    return n;
}



int  replace_all_node_byid(tXML* pp, const char* src, const char* dst, int id)
{
    int  n;

    if (pp==NULL || dst==NULL) return 0;

    if (pp->ldat.id==XML_ANCHOR_NODE) {
        if (pp->next!=NULL) pp = pp->next;
        else return 0;
    }
    while(pp->esis!=NULL) pp = pp->esis;

    n = replace_all_node_byid_rcsv(pp, src, dst, id);

    return n;
}



int  replace_all_node_byid_rcsv(tXML* pp, const char* src, const char* dst, int id)
{
    int  n = 0;

    while(pp!=NULL) {
        if (id<0 || pp->ldat.id==id) {
            if (src==NULL) {
                copy_s2Buffer(dst, &(pp->ldat.key));
                n++;
            }
            else if (pp->ldat.key.buf!=NULL && strstr((const char*)pp->ldat.key.buf, src)!=NULL) {
                Buffer buf = replace_sBuffer_bystr(pp->ldat.key, src, dst);
                free_Buffer(&(pp->ldat.key));
                pp->ldat.key = buf;    
                n++;
            }
        }

        if (pp->next!=NULL) n += replace_all_node_byid_rcsv(pp->next, src, dst, id);

        pp = pp->ysis;
    }

    return n;
}




// XML-RPC

Buffer  xml_rpc_request_pack(const char* name, tXML* xml)
{
    tXML* ptr = init_xml_doc();
    tXML* top = add_xml_node(ptr, "methodCall");
    tXML* mnm = add_xml_node(top, "methodName");
    tXML* prs = add_xml_node(top, "params");
    tXML* prm = add_xml_node(prs, "param");
    add_xml_content(mnm, name);

    join_xml(prm, xml);
    Buffer buf = xml_inverse_parse(ptr, XML_ONELINE_FORMAT);

    return buf;
}


tXML*   xml_rpc_add_member(tXML* xml, char* name, char* value, char* kind)
{
    if (name==NULL) return xml;
  
    if (xml==NULL) xml = add_xml_node(NULL, "struct");
    
    tXML* mem = add_xml_node(xml, "member");
    tXML* mnm = add_xml_node(mem, "name");
    tXML* val = add_xml_node(mem, "value");
    tXML* knd;
    if (kind==NULL)         knd = add_xml_node(val, "string");
    else if (kind[0]=='\0') knd = add_xml_node(val, "string");
    else                    knd = add_xml_node(val, kind);

    add_xml_content(mnm, name);
    add_xml_content(knd, value);

    return xml;
}


tXML*   xml_rpc_end_member(tXML* xml)
{
    tXML* ptr = add_xml_node(NULL, "value");
    join_xml(ptr, xml);

    return ptr;
}


tXML*   xml_rpc_add_array(tXML* xml, tXML* array)
{
    if (xml==NULL) xml = add_xml_node(NULL, "data");
    join_xml(xml, array);
    
    return xml;
}



tXML*   xml_rpc_end_array(tXML* xml)
{
    tXML* ptr = add_xml_node(NULL, "value");
    tXML* val = add_xml_node(ptr,  "array");
    join_xml(val, xml);

    return ptr;
}

---