JunkBox_Lib++ (for Windows): BasicLib/Lib/txml.cpp Source File

00001 
00021 #ifdef CPLUSPLUS
00022     #undef CPLUSPLUS
00023 #endif
00024 
00025 
00026 #include "txml.h"
00027 #include "jbxl_state.h"
00028 
00029 
00030 
00032 // Parser
00033 //
00034 
00049 tXML*  xml_parse(char* pp)
00050 {
00051     tXML* xml;
00052     tXML* node;
00053 
00054     xml = new_xml_node();                    // アンカー
00055     xml->ldat.id = XML_ANCHOR_NODE;
00056     xml->state   = JBXL_STATE_ANCHOR;
00057     xml->depth   = -1;
00058 
00059     // パース
00060     node = xml_main_parse(xml, pp, TRUE);
00061     if (node->state<0) return xml;
00062 
00063     // 元に戻ったか？
00064     if (xml==node) {
00065         xml->state = JBXL_XML_PARSED;
00066     }
00067     else {
00068         xml->state = JBXL_XML_NOT_CLOSED;
00069     }
00070 
00071     // XML rootの数
00072     if (xml->next!=NULL) {
00073         int n = 0;
00074         node = xml->next;
00075         while(node!=NULL) {
00076             if (node->ldat.id==XML_NAME_NODE) n++;
00077             node = node->ysis;
00078         }
00079         if (n!=1) xml->state = JBXL_XML_MULTI_ROOT;
00080     }
00081     else xml->state = JBXL_XML_DEFAULT_STATE;
00082 
00083     return xml;
00084 }
00085 
00086 
00087 
00096 tXML*  xml_parse_file(const char* fn)
00097 {
00098     tXML*  xml = NULL;
00099     Buffer buf;
00100 
00101     buf = read_Buffer_file(fn);
00102     if (buf.buf!=NULL) {
00103         xml = xml_parse((char*)(buf.buf));
00104         free_Buffer(&buf);
00105     }
00106 
00107     return xml;
00108 }
00109 
00110 
00111 
00138 tXML*  xml_parse_seq(tXML* xml, char* pp)
00139 {
00140     int   skip = FALSE;
00141     tXML* node;
00142 
00143     if (xml==NULL) {
00144         xml = new_tTree_anchor_node();
00145         //xml->ldat.id = XML_ANCHOR_NODE;
00146         //xml->depth = -1;
00147         skip = TRUE;
00148     }
00149     else {
00150         tXML* top = find_xml_top(xml);
00151         if (top==xml) top->state = JBXL_XML_DEFAULT_STATE;
00152     }
00153 
00154     node = xml_main_parse(xml, pp, skip);
00155     xml = find_xml_top(xml);
00156     xml->altp = node;
00157 
00158     if (xml!=node) return xml;
00159 
00160     if (node->state==JBXL_NORMAL) xml->state = JBXL_XML_PARSED;
00161     else                          xml->state = node->state;
00162 
00163     if (xml->next!=NULL) {
00164         int n = 0;
00165         node = xml->next;
00166         while(node!=NULL) {
00167             if (node->ldat.id==XML_NAME_NODE) n++;
00168             node = node->ysis;
00169         }
00170         if (n!=1) xml->state = JBXL_XML_MULTI_ROOT;
00171     }
00172     else xml->state = JBXL_XML_DEFAULT_STATE;
00173 
00174     return xml;
00175 }
00176 
00177 
00178 
00193 tXML*  xml_main_parse(tXML* xml, char* pp, int skip)
00194 {
00195     int   n, node_end;
00196     char* node_name = NULL;
00197     char* node_attr = NULL;
00198     char* value     = NULL;
00199     
00200     if (pp ==NULL) return xml;
00201     if (xml==NULL) return NULL;
00202 
00203     if (skip) while (*pp!='\0' && *pp!='<') pp++;
00204 
00205     while (*pp!='\0') {
00206         n = 1;
00207 
00208         if (*pp=='<') {
00209             // End TAG        </   >
00210             if (*(pp+1)=='/') {
00211                 if (xml->state==JBXL_XML_NODE_OPENED) {
00212                     n = xml_parse_end_node(pp, &node_name);
00213                     if (n>0) {
00214                         if (node_name!=NULL && xml->ldat.key.buf!=NULL) {
00215                             if (!strcmp((const char*)node_name, (const char*)(xml->ldat.key.buf))) {
00216                                 if (xml->next!=NULL) {
00217                                     xml->state = JBXL_XML_NODE_CLOSED;
00218                                 }
00219                                 else {
00220                                     xml->state = JBXL_XML_NODE_EMPTY;
00221                                 }
00222                                 //
00223                                 if (xml->prev!=NULL) xml = xml->prev;
00224                                 else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00225                             }
00226                             else n = xml->state = JBXL_XML_PARSE_ERROR;
00227                         }
00228                         else n = xml->state = JBXL_XML_PARSE_ERROR;
00229                     }
00230                     else xml->state = n;                    // エラー
00231                 }
00232                 else n = xml->state = JBXL_XML_PARSE_ERROR;
00233             }
00234 
00235             // Comment TAG        <!--   -->
00236             else if (!strncmp(pp+1, "!--", 3)) {
00237                 n = xml_parse_comment_node(pp, &value);
00238                 if (n>0) {
00239                     xml = add_tTree_node_bystr(xml, XML_COMMENT_NODE, 0, (char*)XML_COMMENT_NODE_KEY, value, NULL, 0);
00240                     xml->state = JBXL_XML_NODE_EMPTY;
00241                     if (xml->prev!=NULL) xml = xml->prev;
00242                     else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00243                 }
00244             }
00245 
00246             // Data TAG            <!     >
00247             else if (*(pp+1)=='!') {
00248                 n = xml_parse_data_node(pp, &value);
00249                 if (n>0) {
00250                     xml = add_tTree_node_bystr(xml, XML_DATA_NODE, 0, (char*)XML_DATA_NODE_KEY, value, NULL, 0);
00251                     xml->state = JBXL_XML_NODE_EMPTY;
00252                     if (xml->prev!=NULL) xml = xml->prev;
00253                     else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00254                 }
00255             }
00256 
00257             // Processing TAG      <?   ?>
00258             else if (*(pp+1)=='?') {
00259                 n = xml_parse_processing_node(pp, &node_name, &node_attr);
00260                 if (n>0) {
00261                     if (!strncasecmp("xml", node_name, 3)) {
00262                         tList* lp = xml_parse_attr(node_attr);
00263                         xml = add_tTree_node_bystr(xml, XML_DOC_NODE, 0, node_name, NULL, NULL, 0);
00264                         xml->ldat.lst = lp;
00265                     }
00266                     else {
00267                         xml = add_tTree_node_bystr(xml, XML_PROCESS_NODE, 0, node_name, node_attr, NULL, 0);
00268                     }
00269                     xml->state = JBXL_XML_NODE_EMPTY;
00270                     if (xml->prev!=NULL) xml = xml->prev;
00271                     else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00272                 }
00273             }
00274 
00275             // Start TAG  <   > 
00276             else {
00277                 n = xml_parse_start_node(pp, &node_name, &node_attr, &node_end);
00278 
00279                 if (n>0) {
00280                     tList* lp = xml_parse_attr(node_attr);
00281                     xml = add_tTree_node_bystr(xml, XML_NAME_NODE, 0, node_name, NULL, NULL, 0);
00282                     xml->ldat.lst = lp;
00283 
00284                     if (node_end) {
00285                         xml->state = JBXL_XML_NODE_EMPTY;
00286                         if (xml->prev!=NULL) xml = xml->prev;
00287                         else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00288                     }
00289                     else {
00290                         int m;
00291                         xml->state = JBXL_XML_NODE_OPENED;
00292                         // ノード値
00293                         m = xml_parse_content(pp+n, &value);            // 0 が返る可能性がある
00294                         if (m>=0) {
00295                             n += m;
00296                             if (value!=NULL) {
00297                                 xml = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, value, NULL, NULL, 0);
00298                                 xml->state = JBXL_XML_NODE_CLOSED;
00299                                 if (xml->prev!=NULL) {
00300                                     xml = xml->prev;
00301                                     xml->ldat.lv++;
00302                                 }
00303                                 else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00304                             }
00305                         }
00306                         else n = xml->state = m;                    // エラー
00307                     }
00308                 }
00309             }
00310 
00311             freeNull(node_name);
00312             freeNull(node_attr);
00313             freeNull(value);
00314         }
00315 
00316         // Content        (断片的に入力したXMLが content の途中で終わっている場合など)
00317         else {
00318             if (xml->state==JBXL_XML_NODE_OPENED) {
00319                 n = xml_parse_content(pp, &value);
00320                 if (n>0) {
00321                     if (value!=NULL) {
00322                         xml = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, value, NULL, NULL, 0);
00323                         xml->state = JBXL_XML_NODE_CLOSED;
00324                         if (xml->prev!=NULL) {
00325                             xml = xml->prev;
00326                             xml->ldat.lv++;
00327                         }
00328                         else n = xml->state = JBXL_XML_SEQUENCE_ERROR;
00329                     }
00330                 }
00331                 else n = xml->state = JBXL_XML_PARSE_ERROR;
00332                 freeNull(value);
00333             }
00334             else n = xml->state = JBXL_XML_PARSE_ERROR;
00335         }
00336 
00337         // エラー
00338         if (n<=0) return xml;
00339 
00340         pp += n;
00341         while (*pp==' ' || *pp==CHAR_TAB || *pp==CHAR_LF || *pp==CHAR_CR) pp++;
00342     }
00343 
00344     return xml;
00345 }
00346 
00347 
00348 
00350 // Paese of TAG
00351 //
00352 
00375 int  xml_parse_start_node(char* pp, char** node_name, char** node_attr, int* node_end)
00376 {
00377     int   nn, mm;
00378     char* pt;
00379 
00380     if (node_name==NULL || node_attr==NULL || node_end==NULL) return JBXL_ARGS_ERROR;
00381     *node_end  = FALSE;
00382     *node_name = NULL;
00383     *node_attr = NULL;
00384 
00385     if (*pp!='<') return JBXL_XML_PARSE_ERROR;
00386     pt = pp = pp + 1;
00387     pt = skip_chars(pt, " />");
00388     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00389 
00390     nn = mm = (int)(pt - pp);
00391     if (mm==0) return JBXL_XML_PARSE_ERROR;
00392 
00393     nn = nn + 1;
00394     *node_name = (char*)malloc((size_t)(mm + 1));
00395     if (*node_name==NULL) return JBXL_MALLOC_ERROR;
00396     memcpy(*node_name, pp, mm);
00397     (*node_name)[mm] = '\0';
00398     //PRINT_MESG("START --> %s  %d\n", *node_name, (int)strlen(*node_name));
00399 
00400     if (isnot_xml_name((unsigned char*)*node_name)) {
00401         freeNull(*node_name);
00402         return JBXL_XML_PARSE_ERROR;
00403     }
00404 
00405     // Empty TAG
00406     if (*pt=='/') {
00407         if (*(pt+1)!='>') {
00408             freeNull(*node_name);
00409             return JBXL_XML_PARSE_ERROR;
00410         }
00411         nn += 1;
00412         *node_end = TRUE;
00413         //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
00414     }
00415 
00416     // Attribute
00417     else if (*pt==' ') {
00418         pp = pt = pt + 1;
00419         while (*pt==' ' || *pt==CHAR_TAB || *pt==CHAR_LF || *pt==CHAR_CR) pt++;
00420         nn += (int)(pt - pp) + 1;
00421 
00422         pp = pt;
00423         pt = skip_chars(pt, "/>");
00424         if (pt==NULL) {
00425             freeNull(*node_name);
00426             return JBXL_XML_PARSE_ERROR;
00427         }
00428 
00429         mm = (int)(pt - pp);
00430         if (mm>0) {
00431             *node_attr = (char*)malloc((size_t)(mm + 1));
00432             if (*node_attr==NULL) {
00433                 freeNull(*node_name);
00434                 return JBXL_MALLOC_ERROR;
00435             }
00436             memcpy(*node_attr, pp, mm);
00437             (*node_attr)[mm] = '\0';
00438             nn += mm;
00439             //PRINT_MESG("ATTR  --> %s  %d\n", *node_attr, (int)strlen(*node_attr));
00440         }
00441 
00442         if (*pt=='/') {
00443             if (*(pt+1)!='>') {
00444                 freeNull(*node_name);
00445                 freeNull(*node_attr);
00446                 return JBXL_XML_PARSE_ERROR;
00447             }
00448             nn += 1;
00449             *node_end = TRUE;
00450             //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
00451         }
00452     }
00453     
00454     //else {}   *pt=='>'
00455 
00456     return nn + 1;
00457 }
00458 
00459 
00460 
00473 int  xml_parse_end_node(char* pp, char** node_name)
00474 {
00475     int   nn, mm;
00476     char* pt;
00477     char* work;
00478 
00479     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00480     *node_name = NULL;
00481 
00482     if (strncmp(pp ,"</", 2)) return JBXL_XML_PARSE_ERROR;
00483 
00484     pt = pp = pp + 2;
00485     pt = skip_chars(pt, ">");
00486     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00487 
00488     nn = mm = (int)(pt - pp);
00489     if (mm==0) return JBXL_XML_PARSE_ERROR;
00490 
00491     nn += 2;
00492     work = (char*)malloc((size_t)(mm+1));
00493     if (work==NULL) return JBXL_MALLOC_ERROR;
00494     memcpy(work, pp, mm);
00495     work[mm] = '\0';
00496     *node_name = pack_head_tail_char(work, ' ');
00497     free(work);
00498     //PRINT_MESG("END   --> %s  %d\n", *node_name, (int)strlen(*node_name));
00499 
00500     return nn + 1;
00501 }
00502 
00503 
00504 
00519 int  xml_parse_content(char* pp, char** content)
00520 {
00521     int   nn=0, mm;
00522     char* pt;
00523     char* work;
00524 
00525     if (pp==NULL || content==NULL) return JBXL_XML_PARSE_ERROR;
00526     *content = NULL;
00527 
00528     while (*pp==' ' || *pp==CHAR_TAB || *pp==CHAR_LF || *pp==CHAR_CR) {
00529         pp++;
00530         nn++;
00531     }
00532     if (*pp=='<') return nn;            // <node><
00533 
00534     pt = pp;
00535     while (*pt!='<' && *pt!='\0') pt++;
00536 
00537     mm = (int)(pt - pp);
00538     if (mm==0) return nn;
00539     nn += mm;
00540 
00541     work = (char*)malloc((size_t)(mm+1));
00542     if (work==NULL) return JBXL_MALLOC_ERROR;
00543     memcpy(work, pp, mm);
00544     work[mm] = '\0';
00545 
00546     *content = pack_head_tail_char(work, ' ');
00547     free(work);
00548     //PRINT_MESG("VALUE --> %s  %d\n", *content, (int)strlen(*content));
00549 
00550     return nn;
00551 }
00552 
00553 
00554 
00566 tList*  xml_parse_attr(char* pp)
00567 {
00568     int    sz;
00569     char*  nm;
00570     char*  vl;
00571     char*  pt;
00572     char   qt;
00573     tList* lp = NULL;
00574     tList* lt = NULL;
00575 
00576     // 作業メモリの確保
00577     if (pp==NULL) return NULL;
00578     sz = (int)strlen((const char*)pp) + 1;
00579     nm = (char*)malloc(sz);
00580     if (nm==NULL) return NULL;
00581     vl = (char*)malloc(sz);
00582     if (vl==NULL) {
00583         free(nm);
00584         return NULL;
00585     }
00586 
00587     // Parse for AAA="BBB" CCC="DDDD"
00588     while (*pp==' ' && *pp!='\0') pp++;
00589     while (*pp!='\0') {
00590         pt = pp;
00591         while (*pt!='=' && *pt!='\0') pt++;
00592         if (*pt=='\0') {
00593             if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
00594             break;
00595         }
00596 
00597         sz = (int)(pt - pp);
00598         memcpy(nm, pp, (size_t)sz);
00599         nm[sz] = '\0';
00600 
00601         pt++;
00602         if (*pt!='"' && *pt!='\'') {
00603             if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
00604             break;
00605         }
00606         else qt = *pt;
00607 
00608         pt++;
00609         pp = pt;
00610         while(*pt!=qt && *pt!='\0') pt++;
00611         if (*pt=='\0') {
00612             if (lt!=NULL) lt->state = JBXL_XML_PARSE_ERROR;
00613             break;
00614         }
00615 
00616         sz = (int)(pt - pp);
00617         memcpy(vl+1, pp, (size_t)sz);
00618         vl[0]     = qt;
00619         vl[sz+1] = qt;
00620         vl[sz+2] = '\0';
00621 
00622         lp = add_tList_node_str(lp, nm, vl);
00623         if (lt==NULL) lt = lp;
00624         pp = pt + 1;
00625 
00626         if (*pp!=' ' && *pp!='\0') {
00627             lt->state = JBXL_XML_PARSE_ERROR;
00628             break;
00629         }
00630         while (*pp==' ' && *pp!='\0') pp++;
00631     }
00632 
00633     //
00634     free(nm);
00635     free(vl);
00636 
00637     if (lt!=NULL) {
00638         if (lt->state!=JBXL_XML_PARSE_ERROR) lt->state = JBXL_XML_NODE_CLOSED;
00639     }
00640     return lt;
00641 }
00642 
00643 
00644 
00659 int  xml_parse_processing_node(char* pp, char** node_name, char** node_attr)
00660 {
00661     int   nn, mm;
00662     char* pt;
00663 
00664     *node_name = NULL;
00665     *node_attr = NULL;
00666 
00667     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00668     if (strncmp(pp, "<?", 2)) return JBXL_XML_PARSE_ERROR;
00669 
00670     pt = pp = pp + 2;
00671     pt = skip_chars(pt, " ?");
00672     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00673 
00674     nn = mm = (int)(pt - pp);
00675     if (mm==0) return JBXL_XML_PARSE_ERROR;
00676 
00677     nn += 2;
00678     *node_name = (char*)malloc((size_t)(mm + 1));
00679     if (*node_name==NULL) return JBXL_MALLOC_ERROR;
00680     memcpy(*node_name, pp, mm);
00681     (*node_name)[mm] = '\0';
00682 
00683     if (isnot_xml_name((unsigned char*)*node_name)) return JBXL_XML_PARSE_ERROR;
00684 
00685     // for attribute
00686     if (*pt==' ') {
00687         pp = pt = pt + 1;
00688         while (*pt==' ' || *pt==CHAR_TAB || *pt==CHAR_LF || *pt==CHAR_CR) pt++;
00689         nn += (int)(pt - pp) + 1;
00690 
00691         pp = pt;
00692         pt = skip_chars(pt, "?");
00693         if (pt==NULL) {
00694             freeNull(*node_name);
00695             return JBXL_XML_PARSE_ERROR;
00696         }
00697 
00698         mm = (int)(pt - pp);
00699         if (mm>0) {
00700             *node_attr = (char*)malloc((size_t)(mm + 1));
00701             if (*node_attr==NULL) {
00702                 freeNull(*node_name);
00703                 return JBXL_MALLOC_ERROR;
00704             }
00705             memcpy(*node_attr, pp, mm);
00706             (*node_attr)[mm] = '\0';
00707             nn += mm;
00708             //PRINT_MESG("ATTR  --> %s  %d\n", *node_attr, (int)strlen(*node_attr));
00709         }
00710     }
00711     
00712     if (strncmp(pt, "?>", 2)) {
00713         freeNull(*node_name);
00714         freeNull(*node_attr);
00715         return JBXL_XML_PARSE_ERROR;
00716     }
00717 
00718     return nn + 2;
00719 }
00720 
00721 
00722 
00736 int  xml_parse_comment_node(char* pp, char** comment)
00737 {
00738     int   nn, mm;
00739     char* pt;
00740 
00741     *comment = NULL;
00742     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00743     if (strncmp(pp, "<!--", 4)) return JBXL_XML_PARSE_ERROR;
00744 
00745     pt = pp = pp + 4;
00746     pt = skip_chars(pt, ">");
00747     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00748 
00749     pt -= 2;
00750     if (strncmp(pt, "-->", 3)) return JBXL_XML_PARSE_ERROR;
00751 
00752     nn = mm = (int)(pt - pp);
00753     if (mm==0) return JBXL_XML_PARSE_ERROR;
00754 
00755     nn += 4;
00756     *comment = (char*)malloc((size_t)(mm+1));
00757     if (*comment==NULL) return JBXL_MALLOC_ERROR;
00758     memcpy(*comment, pp, mm);
00759     (*comment)[mm] = '\0';
00760     //PRINT_MESG("COMMENT-> %s  %d\n", *comment, (int)strlen(*comment));
00761 
00762     return nn + 3;
00763 }
00764 
00765 
00766 
00780 int  xml_parse_data_node(char* pp, char** data)
00781 {
00782     int   nn, mm;
00783     char* pt;
00784 
00785     *data = NULL;
00786     if (pp==NULL) return JBXL_XML_PARSE_ERROR;
00787     if (strncmp(pp, "<!", 2)) return JBXL_XML_PARSE_ERROR;
00788 
00789     pt = pp = pp + 2;
00790     pt = skip_chars(pt, ">");
00791     if (pt==NULL) return JBXL_XML_PARSE_ERROR;
00792 
00793     nn = mm = (int)(pt - pp);
00794     if (mm==0) return JBXL_XML_PARSE_ERROR;
00795 
00796     nn += 2;
00797     *data = (char*)malloc((size_t)(mm+1));
00798     if (*data==NULL) return JBXL_MALLOC_ERROR;
00799     memcpy(*data, pp, mm);
00800     (*data)[mm] = '\0';
00801     //PRINT_MESG("DATA ---> %s  %d\n", *data, (int)strlen(*data));
00802 
00803     return nn + 1;
00804 }
00805 
00806 
00807 
00818 int  isnot_xml_name(unsigned char* pp)
00819 {
00820     if (pp==NULL)  return TRUE;
00821     if (*pp=='\0') return TRUE;
00822 
00823     while (*pp!='\0') {
00824         if (*pp<=0x2c) return TRUE;                 //  !"#$%&'()*+,
00825         if (*pp==0x2f) return TRUE;                 // /
00826         if (*pp>=0x3b && *pp<=0x40) return TRUE;    // ;<=>?@
00827         if (*pp>=0x5b && *pp<=0x5e) return TRUE;    // [\]^
00828         if (*pp==0x60) return TRUE;                 // `
00829         if (*pp>=0x7b && *pp<=0x7f) return TRUE;    // {|}~DEL
00830         pp++;
00831     }
00832     
00833     return FALSE;
00834 }
00835 
00836 
00837 
00845 void   close_xml(tXML* pp)
00846 {
00847     if (pp!=NULL) {
00848 
00849         // アンカー
00850          if (pp->ldat.id==XML_ANCHOR_NODE) {
00851             pp->state = JBXL_XML_PARSED;
00852             pp->depth = -1;
00853             if (pp->next!=NULL) {
00854                 pp->next->depth = 0;
00855                 adjust_tTree_depth(pp->next);
00856                 close_xml(pp->next);
00857             }
00858             return;
00859         }
00860 
00861         while(pp->esis!=NULL) pp = pp->esis;
00862         do {
00863             if (pp->next==NULL) pp->state = JBXL_XML_NODE_EMPTY;
00864             //
00865             if (pp->state!=JBXL_XML_NODE_EMPTY) pp->state = JBXL_XML_NODE_CLOSED;
00866             //if (pp->ldat.lst!=NULL) {
00867             //    if ((pp->ldat.lst)->state!=JBXL_XML_NODE_EMPTY) (pp->ldat.lst)->state = JBXL_XML_NODE_CLOSED;
00868             //}
00869             //
00870             if (pp->next!=NULL) close_xml(pp->next);
00871        
00872             pp = pp->ysis;
00873         } while(pp!=NULL);
00874     }  
00875        
00876     return;
00877 }
00878 
00879 
00880 
00881 
00883 // Inverse Parse
00884 //
00885 
00900 Buffer  xml_inverse_parse(tXML* pp, int mode)
00901 {
00902     int cnt;
00903     Buffer buf;
00904 
00905     buf = init_Buffer();
00906     if (pp==NULL) return buf;
00907     if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
00908     if (pp==NULL) return buf;
00909 
00910     cnt = count_tTree(pp);
00911     buf = make_Buffer(cnt*LMDATA);
00912     if (buf.buf==NULL) return buf;
00913 
00914     while (pp->esis!=NULL) pp = pp->esis;
00915     xml_to_Buffer(pp, &buf, mode, pp->depth);
00916 
00917     return buf;
00918 }
00919 
00920 
00921 
00936 void  xml_to_Buffer(tXML* pp, Buffer* buf, int mode, int indent)
00937 {
00938     do {
00939         xml_open_node_Buffer(pp, buf, mode, indent);
00940         if (pp->next!=NULL) {
00941             xml_to_Buffer(pp->next, buf, mode, indent);
00942             xml_close_node_Buffer(pp, buf, mode, indent);
00943         }
00944         
00945         pp = pp->ysis;
00946     } while(pp!=NULL);
00947 
00948     return;
00949 }
00950 
00951 
00952 
00966 void  xml_open_node_Buffer(tXML* pp, Buffer* buf, int mode, int indent)
00967 {
00968     int i;
00969 
00970     // Name TAG
00971     if (pp->ldat.id==XML_NAME_NODE) {
00972         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
00973             if (buf->vldsz>0 && buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
00974         }
00975         //
00976         if (mode==XML_INDENT_FORMAT) {
00977             char* tabs = (char*)malloc(pp->depth-indent+1);
00978             if (tabs!=NULL) {
00979                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
00980                 tabs[pp->depth-indent] = '\0';
00981                 cat_s2Buffer(tabs, buf);
00982                 free(tabs);
00983             }
00984         }
00985 
00986         cat_s2Buffer("<", buf);
00987         cat_Buffer(&(pp->ldat.key), buf);
00988         if (pp->ldat.lst!=NULL) {
00989             xml_attr_to_Buffer(pp->ldat.lst, buf);
00990         }
00991         if (pp->next==NULL) {
00992             if (pp->state==JBXL_XML_NODE_EMPTY) {
00993                 cat_s2Buffer(" />", buf);
00994             }
00995             else {
00996                 cat_s2Buffer("></", buf);
00997                 cat_Buffer(&(pp->ldat.key), buf);
00998                 cat_s2Buffer(">", buf);
00999             }
01000             if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01001                 cat_s2Buffer("\r\n", buf);
01002             }
01003         }
01004         else {
01005             cat_s2Buffer(">", buf);
01006         }
01007     }
01008     
01009     // Content
01010     else if (pp->ldat.id==XML_CONTENT_NODE) {
01011         if (buf->buf[buf->vldsz-1]=='\n') {
01012             buf->buf[buf->vldsz-2] = '\0';
01013             buf->vldsz -= 2;
01014         }
01015         //
01016         if (pp->esis!=NULL || pp->ysis!=NULL) {
01017             cat_s2Buffer("\r\n", buf); 
01018             char* tabs = (char*)malloc(pp->depth-indent+1);
01019             if (tabs!=NULL) {
01020                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01021                 tabs[pp->depth-indent] = '\0';
01022                 cat_s2Buffer(tabs, buf);
01023                 free(tabs);
01024             }
01025         }
01026         //
01027         cat_Buffer(&(pp->ldat.key), buf);
01028         //
01029         if (pp->esis!=NULL) cat_s2Buffer("\r\n", buf); 
01030     }
01031 
01032     // xml TAG
01033     else if (pp->ldat.id==XML_DOC_NODE) {
01034         if (mode==XML_INDENT_FORMAT) {
01035             char* tabs = (char*)malloc(pp->depth-indent+1);
01036             if (tabs!=NULL) {
01037                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01038                 tabs[pp->depth-indent] = '\0';
01039                 cat_s2Buffer(tabs, buf);
01040                 free(tabs);
01041             }
01042         }
01043 
01044         cat_s2Buffer("<?", buf);
01045         if (pp->ldat.key.buf!=NULL) {
01046             cat_Buffer(&(pp->ldat.key), buf);
01047         }
01048         if (pp->ldat.lst!=NULL) {
01049             xml_attr_to_Buffer(pp->ldat.lst, buf);
01050         }
01051         cat_s2Buffer("?>", buf);
01052 
01053         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01054     }
01055 
01056     // Comment TAG
01057     else if (pp->ldat.id==XML_COMMENT_NODE) {
01058         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01059             if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
01060         }
01061 
01062         if (mode==XML_INDENT_FORMAT) {
01063             char* tabs = (char*)malloc(pp->depth-indent+1);
01064             if (tabs!=NULL) {
01065                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01066                 tabs[pp->depth-indent] = '\0';
01067                 cat_s2Buffer(tabs, buf);
01068                 free(tabs);
01069             }
01070         }
01071 
01072         cat_s2Buffer("<!--", buf);
01073         if (pp->ldat.val.buf!=NULL) {
01074             cat_Buffer(&(pp->ldat.val), buf);
01075         }
01076         cat_s2Buffer("-->", buf);
01077 
01078         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01079     }
01080 
01081     // Data TAG
01082     else if (pp->ldat.id==XML_DATA_NODE) {
01083         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01084             if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
01085         }
01086         //
01087         if (mode==XML_INDENT_FORMAT) {
01088             char* tabs = (char*)malloc(pp->depth-indent+1);
01089             if (tabs!=NULL) {
01090                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01091                 tabs[pp->depth-indent] = '\0';
01092                 cat_s2Buffer(tabs, buf);
01093                 free(tabs);
01094             }
01095         }
01096 
01097         cat_s2Buffer("<!", buf);
01098         if (pp->ldat.val.buf!=NULL) {
01099             cat_Buffer(&(pp->ldat.val), buf);
01100         }
01101         cat_s2Buffer(">", buf);
01102 
01103         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01104     }
01105 
01106     // Processing TAG
01107     else if (pp->ldat.id==XML_PROCESS_NODE) {
01108         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) {
01109             if (buf->buf[buf->vldsz-1]!='\n') cat_s2Buffer("\r\n", buf);
01110         }
01111         //
01112         if (mode==XML_INDENT_FORMAT) {
01113             char* tabs = (char*)malloc(pp->depth-indent+1);
01114             if (tabs!=NULL) {
01115                 for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01116                 tabs[pp->depth-indent] = '\0';
01117                 cat_s2Buffer(tabs, buf);
01118                 free(tabs);
01119             }
01120         }
01121 
01122         cat_s2Buffer("<?", buf);
01123         if (pp->ldat.key.buf!=NULL) {
01124             cat_Buffer(&(pp->ldat.key), buf);
01125         }
01126         if (pp->ldat.lst!=NULL) {
01127             xml_attr_to_Buffer(pp->ldat.lst, buf);
01128         }
01129         cat_s2Buffer(" ?>", buf);
01130 
01131         if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01132     }
01133 
01134     return;
01135 }
01136 
01137 
01138 
01152 void  xml_close_node_Buffer(tXML* pp, Buffer* buf, int mode, int indent)
01153 {
01154     int i;
01155 
01156     if (pp->ldat.id==XML_NAME_NODE) {
01157         if (pp->next!=NULL) {
01158             if (mode==XML_INDENT_FORMAT) {
01159                 if (pp->next->ldat.id!=XML_CONTENT_NODE || pp->next->ysis!=NULL) {
01160                     char* tabs = (char*)malloc(pp->depth-indent+1);
01161                     if (tabs!=NULL) {
01162                         for (i=indent; i<pp->depth; i++) tabs[i-indent] = '\t';
01163                         tabs[pp->depth-indent] = '\0';
01164                         cat_s2Buffer(tabs, buf);
01165                         free(tabs);
01166                     }
01167                 }
01168             }
01169 
01170             cat_s2Buffer("</", buf);
01171             cat_Buffer(&(pp->ldat.key), buf);
01172             cat_s2Buffer(">", buf);
01173 
01174             if (mode==XML_INDENT_FORMAT || mode==XML_CRLF_FORMAT) cat_s2Buffer("\r\n", buf);
01175         }
01176     }
01177 
01178     return;
01179 }
01180 
01181 
01182 
01191 void  xml_attr_to_Buffer(tList* pp, Buffer* buf)
01192 {
01193     while (pp!=NULL) {
01194         cat_s2Buffer(" ", buf);
01195         cat_Buffer(&(pp->ldat.key), buf);
01196 
01197         if (pp->ldat.val.buf!=NULL) {
01198             cat_s2Buffer("=", buf);
01199             cat_Buffer(&(pp->ldat.val), buf);
01200         }
01201         pp = pp->next;
01202     }
01203 }
01204 
01205 
01206 
01207 
01209 // Operation
01210 //
01211 
01217 tXML*  init_xml_doc()
01218 {
01219     tXML* xml = xml_parse((char*)"<?xml version=\"1.0\" encoding=\"utf-8\"?>");
01220     return xml;
01221 }
01222 
01223 
01224 
01234 tXML*  add_xml_node(tXML* xml, const char* name)
01235 {
01236     tXML* pp;
01237 
01238     if (name==NULL) return NULL;
01239 
01240     pp = add_tTree_node_bystr(xml, XML_NAME_NODE, 0, name, NULL, NULL, 0);
01241     pp->state = JBXL_XML_NODE_EMPTY;
01242     if (pp->prev!=NULL) pp->prev->ldat.lv++;
01243 
01244     return pp;
01245 }
01246 
01247 
01248 
01258 tXML*  insert_xml_node(tXML* xml, const char* name)
01259 {
01260     tList* pp;
01261 
01262     if (xml==NULL || name==NULL) return NULL;
01263 
01264     pp = insert_tTree_node_bystr(xml, XML_NAME_NODE, 0, name, NULL, NULL, 0);
01265     pp->state = JBXL_XML_NODE_EMPTY;
01266     if (pp->prev!=NULL) pp->prev->ldat.lv++;
01267 
01268     return pp;
01269 }
01270 
01271 
01272 
01280 tXML*  add_xml_content(tXML* xml, const char* content)
01281 {
01282     tList* pp;
01283 
01284     if (xml==NULL || content==NULL) return NULL;
01285     if (xml->ldat.id!=XML_NAME_NODE) return NULL;
01286 
01287     pp = add_tTree_node_bystr(xml, XML_CONTENT_NODE, 0, content, NULL, NULL, 0);
01288     pp->state = JBXL_XML_NODE_CLOSED;
01289     if (pp->prev!=NULL) pp->prev->ldat.lv++;
01290   
01291     return pp;
01292 }
01293 
01294 
01295 
01302 tXML*  append_xml_content(tXML* xml, const char* content)
01303 {
01304     tList* pp;
01305 
01306     if (xml==NULL || content==NULL) return NULL;
01307     if (xml->ldat.id!=XML_NAME_NODE) return NULL;
01308     
01309     pp = xml->next;
01310     while (pp!=NULL && pp->ldat.id!=XML_CONTENT_NODE) pp = pp->ysis;
01311 
01312     if (pp==NULL) {
01313         pp = add_xml_content(xml, content);
01314     }
01315     else {
01316         if (pp->ldat.key.vldsz!=0) cat_s2Buffer(" ", &(pp->ldat.key));
01317         cat_s2Buffer(content, &(pp->ldat.key));
01318     }
01319 
01320     return pp;
01321 }
01322 
01323 
01333 int  add_xml_content_area(tXML* xml, int len)
01334 {
01335     if (xml==NULL || len<=0) return FALSE;
01336     
01337     char* area = (char*)malloc(len);
01338     if (area==NULL) return FALSE;
01339     memset(area, (int)' ', len-1);
01340     area[len-1] = '\0';
01341 
01342     tXML* pp = add_xml_content(xml, area);
01343     if (pp!=NULL) {
01344         pp->ldat.key.buf[0] = '\0';
01345         pp->ldat.key.vldsz  = 0;
01346     }
01347     free(area);
01348 
01349     return TRUE;
01350 }
01351 
01352 
01358 tXML*  add_xml_attr(tXML* xml, const char* attr)
01359 {
01360     if (xml==NULL || attr==NULL) return NULL;
01361     if (xml->ldat.id!=XML_NAME_NODE) return NULL;
01362 
01363     tList* lp = xml_parse_attr((char*)attr);
01364 
01365     if (xml->ldat.lst==NULL) xml->ldat.lst = lp;
01366     else add_tList_end(xml->ldat.lst, lp);
01367 
01368     return xml;
01369 }
01370 
01371 
01377 tXML*  add_xml_attr_str(tXML* xml, const char* name, const char* value)
01378 {
01379     if (xml==NULL || name==NULL) return NULL;
01380 
01381     Buffer attr = make_xml_attr_str(name, value);
01382     add_xml_attr(xml, (char*)attr.buf);
01383     free_Buffer(&attr);
01384 
01385     return xml;
01386 }
01387 
01388 
01394 tXML*  add_xml_attr_int(tXML* xml, const char* name, int value)
01395 {
01396     if (xml==NULL || name==NULL) return NULL;
01397     //
01398     Buffer attr = make_xml_attr_int(name, value);
01399     add_xml_attr(xml, (char*)attr.buf);
01400     free_Buffer(&attr);
01401 
01402     return xml;
01403 }
01404 
01405 
01411 tXML*  add_xml_attr_float(tXML* xml, const char* name, float value)
01412 {
01413     if (xml==NULL || name==NULL) return NULL;
01414     //
01415     Buffer attr = make_xml_attr_float(name, value);
01416     add_xml_attr(xml, (char*)attr.buf);
01417     free_Buffer(&attr);
01418 
01419     return xml;
01420 }
01421 
01422 
01428 tXML*  add_xml_attr_double(tXML* xml, const char* name, double value)
01429 {
01430     if (xml==NULL || name==NULL) return NULL;
01431     //
01432     Buffer attr = make_xml_attr_double(name, value);
01433     add_xml_attr(xml, (char*)attr.buf);
01434     free_Buffer(&attr);
01435 
01436     return xml;
01437 }
01438 
01439 
01440 
01449 char*  get_first_xml_nodename(tXML* xml)
01450 {  
01451     char* nodename = NULL;
01452    
01453     if (xml==NULL) return NULL;
01454     tList* lp = xml;
01455     if (lp->ldat.id==XML_ANCHOR_NODE) lp = lp->next;
01456    
01457     while (lp!=NULL) {
01458         if (lp->ldat.id==XML_NAME_NODE) {
01459             if (lp->ldat.key.buf!=NULL) {
01460                 nodename = (char*)lp->ldat.key.buf;
01461                 break;
01462             }
01463         }
01464         lp = lp->ysis;
01465     }
01466     return nodename;
01467 }
01468 
01469 
01475 Buffer make_xml_attr_bystr(const char* name, const char* value)
01476 {
01477     Buffer buf = make_Buffer_bystr(name);
01478     cat_s2Buffer("=\"", &buf);
01479     cat_s2Buffer(value, &buf);
01480     cat_s2Buffer("\"",  &buf);
01481 
01482     return buf;
01483 }
01484 
01485 
01491 Buffer make_xml_attr_byint(const char* name, int value)
01492 {
01493     char* str = itostr_ts(value);
01494 
01495     Buffer buf = make_Buffer_bystr(name);
01496     cat_s2Buffer("=\"", &buf);
01497     cat_s2Buffer(str, &buf);
01498     cat_s2Buffer("\"",  &buf);
01499 
01500     freeNull(str);
01501     return buf;
01502 }
01503 
01504 
01510 Buffer make_xml_attr_byfloat(const char* name, float value)
01511 {
01512     char* str = ftostr_ts(value);
01513 
01514     Buffer buf = make_Buffer_bystr(name);
01515     cat_s2Buffer("=\"", &buf);
01516     cat_s2Buffer(str, &buf);
01517     cat_s2Buffer("\"",  &buf);
01518 
01519     freeNull(str);
01520     return buf;
01521 }
01522 
01523 
01529 Buffer make_xml_attr_bydouble(const char* name, double value)
01530 {
01531     char* str = dtostr_ts(value);
01532 
01533     Buffer buf = make_Buffer_bystr(name);
01534     cat_s2Buffer("=\"", &buf);
01535     cat_s2Buffer(str, &buf);
01536     cat_s2Buffer("\"",  &buf);
01537 
01538     freeNull(str);
01539     return buf;
01540 }
01541 
01542 
01543 
01549 char* xml_get_node_content(tXML* node)
01550 {
01551     if (node==NULL || node->next==NULL) return NULL;
01552 
01553     if (node->ldat.id==XML_NAME_NODE) {
01554         if (node->next->ldat.id==XML_CONTENT_NODE) return (char*)(node->next->ldat.key.buf);
01555     }
01556     return NULL;
01557 }
01558 
01559 
01560 
01566 char* xml_get_node_attr(tXML* node, const char* attr)
01567 {
01568     if (node==NULL) return NULL;
01569 
01570     if (node->ldat.id==XML_NAME_NODE) {
01571         tList* lt = node->ldat.lst;
01572         while (lt!=NULL) {
01573             if (!strcmp((const char*)lt->ldat.key.buf, attr)) return (char*)(lt->ldat.val.buf);
01574             lt = lt->next;
01575         }
01576     }
01577     return NULL;
01578 }
01579 
01580 
01581 
01593 tXML*  dup_merge_xml(tXML* pp, tXML* tp)
01594 {
01595     if (tp==NULL) return pp;
01596 
01597     if (tp->ldat.id==XML_ANCHOR_NODE) {
01598         if (tp->next!=NULL) tp = tp->next;
01599         else return pp;
01600     }
01601 
01602     pp = dup_merge_tTree(pp, tp);
01603 
01604 /*
01605     tXML* pt;
01606     if (pp->ldat.id!=XML_ANCHOR_NODE) {
01607         pt = new_tTree_node();
01608         pt->ldat.id = XML_ANCHOR_NODE;
01609         pt->depth = -1;
01610         add_tTree(pt, pp);
01611         close_xml(pt);
01612         return pt;
01613     }
01614 */
01615 
01616     return pp;
01617 }
01618 
01619 
01620 
01658 void   print_xml(FILE* fp, tXML* pp, int mode)
01659 {
01660     if (fp==NULL) fp = stderr;
01661 
01662     if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
01663 
01664     if (pp!=NULL) {
01665         Buffer buf = xml_inverse_parse(pp, mode);
01666         if (buf.buf!=NULL) {
01667             fprintf(fp, "%s", buf.buf);
01668             free_Buffer(&buf);
01669         }
01670         else fprintf(fp, "(XML is NULL)\n");
01671     }  
01672     else {
01673         fprintf(fp, "(XML is NULL)\n");
01674     } 
01675     fflush(fp);
01676        
01677     return;
01678 }
01679 
01680 
01681 
01687 void   print_xml_node(FILE* fp, tXML* pp)
01688 {
01689     if (fp==NULL) fp = stderr;
01690 
01691     //fprintf(fp, "深さ: ノード種別 [状態] ノード名 (属性数)\n");
01692 
01693     if (pp!=NULL) {
01694         if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
01695         if (pp!=NULL) {
01696             int num = count_tList((tList*)pp->ldat.lst);
01697             fprintf(fp, "%d: %d [%d] %s (%d)", pp->depth, pp->ldat.id, pp->state, pp->ldat.key.buf, num);
01698             fprintf(fp, "\n");
01699         }
01700         else {
01701             fprintf(fp, "(XML is ANCHOR only)\n");
01702         }
01703     }  
01704     else {
01705         fprintf(fp, "(XML is NULL)\n");
01706     }  
01707     fflush(fp);
01708 
01709     return;
01710 }
01711 
01712 
01713 
01726 void   print_xml_tree(FILE* fp, tXML* pp, const char* space)
01727 {
01728     int i;
01729     if (fp==NULL) fp = stderr;
01730 
01731     //fprintf(fp, "深さ: ノード種別 [状態] ノード名 (属性数)\n");
01732 
01733     if (pp!=NULL) {
01734         if (pp->ldat.id==XML_ANCHOR_NODE) pp = pp->next;
01735         if (pp!=NULL) {
01736             for(i=0; i<pp->depth; i++)   fprintf(fp, "%s", space);
01737             for(i=0; i<pp->depth-1; i++) fprintf(fp, "%s", "   ");       // for "-> "
01738             print_sister_xml_tree(fp, pp, space);
01739             fprintf(fp, "\n");
01740         }
01741         else {
01742             fprintf(fp, "(XML is ANCHOR only)\n");
01743         }
01744     }  
01745     else {
01746         fprintf(fp, "(XML is NULL)\n");
01747     }  
01748     fflush(fp);
01749 
01750     return;
01751 }
01752 
01753 
01754 
01766 void   print_sister_xml_tree(FILE* fp, tXML* pp, const char* space)
01767 {
01768     if (fp==NULL) fp = stderr;
01769 
01770     if (pp!=NULL) {
01771         if (pp->ldat.id==XML_ANCHOR_NODE) {
01772             if (pp->next!=NULL) pp = pp->next;
01773         }
01774 
01775         while(pp->esis!=NULL) pp = pp->esis;
01776         //
01777         while(pp!=NULL) {
01778             int i;
01779             tList_data ld = pp->ldat;
01780 
01781             if (pp->depth>=0) {
01782                 if (pp->esis!=NULL || pp->depth>=0) fprintf(fp, "\n");
01783                 if (pp->depth>0) {
01784                     for(i=0; i<pp->depth; i++) fprintf(fp, "%s", space);
01785                     //for(i=0; i<pp->depth-1; i++) fprintf(fp, "%s", "   ");
01786                     fprintf(fp, "-> ");
01787                 }
01788             }
01789             int num = count_tList((tList*)ld.lst);
01790             fprintf(fp, "%d: %d [%d] %s (%d)", pp->depth, ld.id, pp->state, ld.key.buf, num);
01791 
01792             if (pp->next!=NULL) print_sister_xml_tree(fp, pp->next, space);
01793        
01794             pp = pp->ysis;
01795         };
01796     }  
01797     else {
01798         fprintf(fp, "(XML is NULL)\n");
01799     } 
01800     fflush(fp);
01801        
01802     return;
01803 }
01804 
01805 
01806 
01807 
01809 // Search and Get/Set
01810 //
01811 
01835 tXML*  get_xml_node(tXML* pp, tXML* pt)
01836 {
01837     int fnd;
01838     tXML* tt;
01839     tXML* pm;
01840 
01841     if (pp==NULL || pt==NULL) return NULL;
01842 
01843     pm = pp;
01844     if (pp->ldat.id==XML_ANCHOR_NODE) {
01845         if (pp->next!=NULL) pp = pp->next;
01846         else return NULL;
01847     }
01848     if (pt->ldat.id==XML_ANCHOR_NODE) {
01849         if (pt->next!=NULL) pt = pt->next;
01850         else return NULL;
01851     }
01852 
01853     tt = find_xml_end(pt);
01854     if (tt==NULL) return FALSE;
01855 
01856     while(pp->esis!=NULL) pp = pp->esis;
01857     fnd = find_match_xml(pp, pt);
01858     if (fnd) tt = tt->altp;
01859     else     tt = NULL;
01860 
01861     clear_tTree_ctrl(pm);
01862 
01863     return tt;
01864 }
01865 
01866 
01867 
01883 int set_xml_node(tXML* pp, tXML* pt, const char* name)
01884 {
01885     tXML* tt;
01886 
01887     if (pp==NULL || pt==NULL || name==NULL) return FALSE;
01888 
01889     tt = get_xml_node(pp, pt);
01890     if (tt==NULL) return FALSE;
01891     
01892     copy_s2Buffer(name, &(tt->ldat.key));
01893 
01894     return TRUE;
01895 }
01896 
01897 
01898 
01919 int set_xml_end_node(tXML* pp, tXML* pt)
01920 {
01921     int      ret;
01922     tXML* tt;
01923     tXML* pm;
01924 
01925 
01926     if (pp==NULL || pt==NULL) return FALSE;
01927 
01928     pm = pp;
01929     if (pp->ldat.id==XML_ANCHOR_NODE) {
01930         if (pp->next!=NULL) pp = pp->next;
01931         else return FALSE;
01932     }
01933     if (pt->ldat.id==XML_ANCHOR_NODE) {
01934         if (pt->next!=NULL) pt = pt->next;
01935         else return FALSE;
01936     }
01937 
01938     tt = find_xml_end(pt);
01939     if (tt==NULL) return FALSE;
01940     tt->ctrl = TREE_NOCMP_COPY_NODE;        // 比べない．最後にコピー．
01941 
01942     while(pp->esis!=NULL) pp = pp->esis;
01943     ret = find_match_xml(pp, pt);
01944     if (ret) {
01945         copy_tTree_byctrl(pt);
01946         adjust_tTree_depth(pp);
01947     }
01948 
01949     clear_tTree_ctrl(pm);
01950 
01951     return ret;
01952 }
01953 
01954 
01955 
01982 tXML*  get_xml_content(tXML* pp, tXML* pt)
01983 {
01984     int fnd;
01985     tXML* tt = NULL;
01986     tXML* pm;
01987     tXML* dm;
01988 
01989     if (pp==NULL || pt==NULL) return NULL;
01990 
01991     pm = pp;
01992     if (pp->ldat.id==XML_ANCHOR_NODE) {
01993         if (pp->next!=NULL) pp = pp->next;
01994         else return NULL;
01995     }
01996     if (pt->ldat.id==XML_ANCHOR_NODE) {
01997         if (pt->next!=NULL) pt = pt->next;
01998         else return NULL;
01999     }
02000 
02001     tt = find_xml_end(pt);
02002     if (tt==NULL) return NULL;
02003     dm = add_xml_content(tt, (char*)"DUMMY");
02004     if (dm==NULL) return NULL;
02005     dm->ctrl = TREE_NOCMP_NODE;
02006 
02007     while(pp->esis!=NULL) pp = pp->esis;
02008 
02009     fnd = find_match_xml(pp, pt);
02010     if (fnd) tt = dm->altp;
02011     else     tt = NULL;
02012 
02013     del_xml(&dm);
02014     clear_tTree_ctrl(pm);
02015 
02016     return tt;
02017 }
02018 
02019 
02020 
02038 int set_xml_content(tXML* pp, tXML* pt, const char* content)
02039 {
02040     tXML* tt;
02041 
02042     if (pp==NULL || pt==NULL || content==NULL) return FALSE;
02043 
02044     tt = get_xml_content(pp, pt);
02045     if (tt==NULL) return FALSE;
02046     
02047     copy_s2Buffer(content, &(tt->ldat.key));
02048     return TRUE;
02049 }
02050 
02051 
02052 
02058 int  get_xml_int_content(tXML* pp, tXML* pt)
02059 {
02060     int ret = 0;
02061 
02062     tXML* node = get_xml_content(pp, pt);
02063     if (node!=NULL) ret = atoi((char*)(node->ldat.key.buf));
02064     return ret;
02065 }
02066 
02067 
02068 
02074 float  get_xml_float_content(tXML* pp, tXML* pt)
02075 {
02076     float ret = 0.0;
02077 
02078     tXML* node = get_xml_content(pp, pt);
02079     if (node!=NULL) ret = (float)atof((char*)(node->ldat.key.buf));
02080     return ret;
02081 }
02082 
02083 
02084 
02090 double  get_xml_double_content(tXML* pp, tXML* pt)
02091 {
02092     double ret = 0.0;
02093 
02094     tXML* node = get_xml_content(pp, pt);
02095     if (node!=NULL) ret = atof((char*)(node->ldat.key.buf));
02096     return ret;
02097 }
02098 
02099 
02100 
02106 char*   get_xml_char_content(tXML* pp, tXML* pt)
02107 {
02108     char* ret = NULL;
02109 
02110     tXML* node = get_xml_content(pp, pt);
02111     if (node!=NULL) ret = (char*)(node->ldat.key.buf);
02112     return ret;
02113 }
02114 
02115 
02116 
02131 tList*  get_xml_attr(tXML* pp, tXML* pt)
02132 {
02133     tList* lp = NULL;
02134     tXML*  tt;
02135 
02136     if (pp==NULL || pt==NULL) return NULL;
02137 
02138     tt  = get_xml_node(pp, pt);
02139     if (tt!=NULL) lp = tt->ldat.lst;    
02140     return lp;
02141 }
02142 
02143 
02144 
02150 char*  get_xml_char_attr(tXML* pp, tXML* pt, const char* attr)
02151 {
02152     char* ret = NULL;
02153     if (pp==NULL || pt==NULL || attr==NULL) return ret;
02154 
02155     tXML* node = get_xml_node(pp, pt);
02156     if (node!=NULL) ret = xml_get_node_attr(node, attr);
02157     return ret;
02158 }
02159 
02160 
02161 
02168 int  get_xml_int_attr(tXML* pp, tXML* pt, const char* attr)
02169 {
02170     int ret = 0;
02171     if (pp==NULL || pt==NULL || attr==NULL) return ret;
02172 
02173     tXML* node = get_xml_node(pp, pt);
02174     if (node!=NULL) {
02175         char* val = xml_get_node_attr(node, attr);
02176         if (val!=NULL) {
02177             Buffer buf = make_Buffer_bystr(val);
02178             char* ptr  = (char*)buf.buf;
02179             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02180             if (ptr[0]=='"') ptr++; 
02181             ret = atoi(ptr);
02182             free_Buffer(&buf);
02183         }
02184     }
02185     return ret;
02186 }
02187 
02188 
02189 
02196 double  get_xml_double_attr(tXML* pp, tXML* pt, const char* attr)
02197 {
02198     double ret = 0.0;
02199     if (pp==NULL || pt==NULL || attr==NULL) return ret;
02200 
02201     tXML* node = get_xml_node(pp, pt);
02202     if (node!=NULL) {
02203         char* val = xml_get_node_attr(node, attr);
02204         if (val!=NULL) {
02205             Buffer buf = make_Buffer_bystr(val);
02206             char* ptr  = (char*)buf.buf;
02207             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02208             if (ptr[0]=='"') ptr++; 
02209             ret = atof(ptr);
02210             free_Buffer(&buf);
02211         }
02212     }
02213     return ret;
02214 }
02215 
02216 
02217 
02235 int  set_xml_attr(tXML* pp, tXML* pt, tList* at)
02236 {
02237     tXML* tt;
02238 
02239     if (pp==NULL || pt==NULL || at==NULL) return FALSE;
02240 
02241     tt  = get_xml_node(pp, pt);
02242     if (tt!=NULL) {
02243         del_all_tList(&(tt->ldat.lst));
02244         tt->ldat.lst = dup_tList(at);
02245     }
02246     else return FALSE;
02247     return TRUE;
02248 }
02249 
02250 
02251 
02257 int  replace_xml_content(tXML* pp, tXML* pt, const char* src, const char* dst)
02258 {
02259     tXML*  tt;
02260     Buffer tg;
02261 
02262     if (pp==NULL || pt==NULL || src==NULL || dst==NULL) return FALSE;
02263 
02264     tt = get_xml_content(pp, pt);
02265     if (tt==NULL) return FALSE;
02266 
02267     tg = replace_sBuffer_bystr(tt->ldat.key, src, dst);
02268     if (tg.buf==NULL) return FALSE;
02269 
02270     free_Buffer(&(tt->ldat.key));
02271     tt->ldat.key = tg;
02272     
02273     return TRUE;
02274 }
02275 
02276 
02277 
02283 tXML*  get_xml_node_bystr(tXML* pp, const char* str)
02284 {
02285     tXML* tx;
02286     tXML* tt;
02287 
02288     if (pp==NULL || str==NULL) return FALSE;
02289 
02290     tx = xml_parse((char*)str);
02291     tt = get_xml_node(pp, tx);
02292     del_xml(&tx);
02293     return tt;
02294 }
02295 
02296 
02297 
02303 int  set_xml_node_bystr(tXML* pp, const char* str, const char* val)
02304 {
02305     tXML*  tx;
02306     int    rt;
02307 
02308     if (pp==NULL || str==NULL || val==NULL) return FALSE;
02309 
02310     tx = xml_parse((char*)str);
02311     rt = set_xml_node(pp, tx, val);
02312     del_xml(&tx);
02313     return rt;
02314 }
02315 
02316 
02317 
02323 int  set_xml_end_node_bystr(tXML* pp, const char* str)
02324 {
02325     tXML*  tx;
02326     int    rt;
02327 
02328     if (pp==NULL || str==NULL) return FALSE;
02329 
02330     tx = xml_parse((char*)str);
02331     rt = set_xml_end_node(pp, tx);
02332     del_xml(&tx);
02333     return rt;
02334 }
02335 
02336 
02337 
02343 tXML*  get_xml_content_bystr(tXML* pp, const char* str)
02344 {
02345     tXML* tx;
02346     tXML* tt;
02347 
02348     if (pp==NULL || str==NULL) return FALSE;
02349 
02350     tx = xml_parse((char*)str);
02351     tt = get_xml_content(pp, tx);
02352     del_xml(&tx);
02353     return tt;
02354 }
02355 
02356 
02357 
02364 int  get_xml_int_content_bystr(tXML* pp, const char* str)
02365 {
02366     int ret = 0;
02367 
02368     tXML* node = get_xml_content_bystr(pp, str);
02369     if (node!=NULL) ret = atoi((char*)(node->ldat.key.buf));
02370     return ret;
02371 }
02372 
02373 
02374 
02381 float  get_xml_float_content_bystr(tXML* pp, const char* str)
02382 {
02383     float ret = 0.0;
02384 
02385     tXML* node = get_xml_content_bystr(pp, str);
02386     if (node!=NULL) ret = (float)atof((char*)(node->ldat.key.buf));
02387     return ret;
02388 }
02389 
02390 
02391 
02398 double  get_xml_double_content_bystr(tXML* pp, const char* str)
02399 {
02400     double ret = 0.0;
02401 
02402     tXML* node = get_xml_content_bystr(pp, str);
02403     if (node!=NULL) ret = atof((char*)(node->ldat.key.buf));
02404     return ret;
02405 }
02406 
02407 
02408 
02416 char*   get_xml_char_content_bystr(tXML* pp, const char* str)
02417 {
02418     char* ret = NULL;
02419 
02420     tXML* node = get_xml_content_bystr(pp, str);
02421     if (node!=NULL) ret = (char*)(node->ldat.key.buf);
02422     return ret;
02423 }
02424 
02425 
02426 
02432 int  set_xml_content_bystr(tXML* pp, const char* str, const char* val)
02433 {
02434     tXML*  tx;
02435     int    rt;
02436 
02437     if (pp==NULL || str==NULL || val==NULL) return FALSE;
02438 
02439     tx = xml_parse((char*)str);
02440     rt = set_xml_content(pp, tx, val);
02441     del_xml(&tx);
02442     return rt;
02443 }
02444 
02445 
02446 
02452 tList*  get_xml_attr_bystr(tXML* pp, const char* str)
02453 {
02454     tXML*  tx;
02455     tList* tt;
02456 
02457     if (pp==NULL || str==NULL) return NULL;
02458 
02459     tx = xml_parse((char*)str);
02460     tt = get_xml_attr(pp, tx);
02461     del_xml(&tx);
02462     return tt;
02463 }
02464 
02465 
02466 
02473 char*  get_xml_char_attr_bystr(tXML* pp, const char* str, const char* attr)
02474 {
02475     char* ret = NULL;
02476     if (pp==NULL || str==NULL || attr==NULL) return ret;
02477 
02478     tXML* node = get_xml_node_bystr(pp, str);
02479     if (node!=NULL) ret = xml_get_node_attr(node, attr);
02480     return ret;
02481 }
02482 
02483 
02484 
02492 int  get_xml_int_attr_bystr(tXML* pp, const char* str, const char* attr)
02493 {
02494     int ret = 0;
02495     if (pp==NULL || str==NULL || attr==NULL) return ret;
02496 
02497     tXML* node = get_xml_node_bystr(pp, str);
02498     if (node!=NULL) {
02499         char* val = xml_get_node_attr(node, attr);
02500         if (val!=NULL) {
02501             Buffer buf = make_Buffer_bystr(val);
02502             char* ptr  = (char*)buf.buf;
02503             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02504             if (ptr[0]=='"') ptr++; 
02505             ret = atoi(ptr);
02506             free_Buffer(&buf);
02507         }
02508     }
02509     return ret;
02510 }
02511 
02512 
02513 
02521 double  get_xml_double_attr_bystr(tXML* pp, const char* str, const char* attr)
02522 {
02523     double ret = 0.0;
02524     if (pp==NULL || str==NULL || attr==NULL) return ret;
02525 
02526     tXML* node = get_xml_node_bystr(pp, str);
02527     if (node!=NULL) {
02528         char* val = xml_get_node_attr(node, attr);
02529         if (val!=NULL) {
02530             Buffer buf = make_Buffer_bystr(val);
02531             char* ptr  = (char*)buf.buf;
02532             if (ptr[strlen(ptr)-1]=='"') ptr[strlen(ptr)-1] = '\0';
02533             if (ptr[0]=='"') ptr++; 
02534             ret = atof(ptr);
02535             free_Buffer(&buf);
02536         }
02537     }
02538     return ret;
02539 }
02540 
02541 
02542 
02548 int  set_xml_attr_bystr(tXML* pp, const char* str, tList* at)
02549 {
02550     tXML* tx;
02551     int   rt;
02552 
02553     if (pp==NULL || str==NULL || at==NULL) return FALSE;
02554 
02555     tx = xml_parse((char*)str);
02556     rt = set_xml_attr(pp, tx, at);
02557     del_xml(&tx);
02558     return rt;
02559 }
02560 
02561 
02562 
02568 int  replace_xml_content_bystr(tXML*pp, const char* str, const char* src, const char* dst)
02569 {
02570     tXML* tx;
02571     int   rt;
02572 
02573     if (pp==NULL || src==NULL || src==NULL || dst==NULL) return FALSE;
02574 
02575     tx = xml_parse((char*)str);
02576     rt = replace_xml_content(pp, tx, src, dst);
02577     del_xml(&tx);
02578     return rt;
02579 }
02580 
02581 
02582 
02583 
02585 // Operation for Multi Tags
02586 //
02587 
02601 tList*  get_xml_node_list(tXML* pp, tXML* pt)
02602 {
02603     tList* lp;
02604 
02605     if (pp==NULL || pt==NULL) return NULL;
02606 
02607     if (pp->ldat.id==XML_ANCHOR_NODE) {
02608         if (pp->next!=NULL) pp = pp->next;
02609         else return NULL;
02610     }
02611     if (pt->ldat.id==XML_ANCHOR_NODE) {
02612         if (pt->next!=NULL) pt = pt->next;
02613         else return NULL;
02614     }
02615 
02616     lp = find_match_xml_endlist(pp, pt);
02617 
02618     return lp;
02619 }
02620 
02621 
02622 
02637 tList*  get_xml_content_list(tXML* pp, tXML* pt)
02638 {
02639     tList* lp;
02640     tList* dm;
02641 
02642     if (pp==NULL || pt==NULL) return NULL;
02643 
02644     if (pp->ldat.id==XML_ANCHOR_NODE) {
02645         if (pp->next!=NULL) pp = pp->next;
02646         else return NULL;
02647     }
02648     if (pt->ldat.id==XML_ANCHOR_NODE) {
02649         if (pt->next!=NULL) pt = pt->next;
02650         else return NULL;
02651     }
02652 
02653     dm = find_xml_end(pt);
02654     if (dm==NULL) return NULL;
02655     dm = add_xml_content(dm, (char*)"DUMMY");
02656     if (dm==NULL) return NULL;
02657     dm->ctrl = TREE_NOCMP_NODE;
02658 
02659     lp = find_match_xml_endlist(pp, pt);
02660     del_xml(&dm);
02661 
02662     return lp;
02663 }
02664 
02665 
02666 
02678 int  set_xml_content_list(tXML* pp, tXML* pt, const char* content)
02679 {
02680     int    num = 0;
02681     tList* lt;
02682     tList* lp;
02683 
02684     if (pp==NULL  || pt==NULL || content==NULL)  return 0;
02685 
02686     lp = lt = get_xml_content_list(pp, pt);
02687     if (lt==NULL) return 0;
02688 
02689     while (lt!=NULL) {
02690         if (lt->altp!=NULL) {
02691             copy_s2Buffer(content, &(lt->altp->ldat.key));
02692             num++;
02693         }
02694         lt = lt->next;
02695     }
02696     del_tList(&lp);
02697 
02698     return num;
02699 }
02700 
02701 
02702 
02708 tList*  get_xml_node_list_bystr(tXML* pp, const char* str)
02709 {
02710     tXML*  tx;
02711     tList* tt;
02712 
02713     if (pp==NULL || str==NULL) return NULL;
02714 
02715     tx = xml_parse((char*)str);
02716     tt = get_xml_node_list(pp, tx);
02717     del_xml(&tx);
02718 
02719     return tt;
02720 }
02721 
02722 
02723 
02729 tList*  get_xml_content_list_bystr(tXML* pp, const char* str)
02730 {
02731     tXML*  tx;
02732     tList* tt;
02733 
02734     if (pp==NULL || str==NULL) return NULL;
02735 
02736     tx = xml_parse((char*)str);
02737     tt = get_xml_content_list(pp, tx);
02738     del_xml(&tx);
02739 
02740     return tt;
02741 }
02742 
02743 
02744 
02750 int  set_xml_content_list_bystr(tXML* pp, const char* str, const char* content)
02751 {
02752     tXML* tx;
02753     int   rt;
02754 
02755     if (pp==NULL  || str==NULL || content==NULL) return 0;
02756 
02757     tx = xml_parse((char*)str);
02758     rt = set_xml_content_list(pp, tx, content);
02759     del_xml(&tx);
02760 
02761     return rt;
02762 }
02763 
02764 
02765 
02766 
02768 // Search Function for XML
02769 //         tTree 用の関数とほぼ同じ
02770 //
02771 
02794 int  find_match_xml(tXML* pp, tXML* pt)
02795 {
02796     int   ret;
02797     tXML* pm;
02798 
02799     pm = pp;
02800     while(pp!=NULL) {
02801         ret = check_match_xml(pp, pt);
02802         if (ret) return TRUE;
02803 
02804         if (pp->next!=NULL) {
02805             ret = find_match_xml(pp->next, pt);
02806             if (ret) {
02807                 clear_tTree_ctrl(pm);
02808                 return TRUE;
02809             }
02810         }
02811         pp = pp->ysis;
02812     }
02813 
02814     return FALSE;
02815 }
02816 
02817 
02818 
02833 tXML*  find_match_xml_endlist(tXML* pp, tXML* pt)
02834 {
02835     tXML*  te;
02836     tList* lp;
02837 
02838     te = find_xml_end(pt);
02839     while(pp->esis!=NULL) pp = pp->esis;
02840 
02841     lp = find_match_xml_endlist_rcsv(pp, pt, te);
02842     if (lp!=NULL) clear_tTree_ctrl(pp);
02843     
02844     return lp;
02845 }
02846 
02847 
02848 
02855 tList*  find_match_xml_endlist_rcsv(tXML* pp, tXML* pt, tXML* te)
02856 {
02857     tList* lt = NULL;
02858     tList* lp = NULL;
02859                     
02860     while(pp!=NULL) {             
02861         int ret = check_match_xml(pp, pt);
02862         if (ret && te->altp!=NULL) {
02863             tList* lm = new_tList_node();
02864             lm->altp = te->altp;  
02865             lt = insert_tList(lt, lm);
02866             if (lp==NULL) lp = lt;
02867             te->altp = NULL;
02868         }  
02869                             
02870         if (pp->next!=NULL) {     
02871             tList* lm = find_match_xml_endlist_rcsv(pp->next, pt, te);
02872             if (lm!=NULL) {       
02873                 lt = insert_tList(lt, lm);
02874                 if (lp==NULL) lp = lt;
02875                 clear_tTree_ctrl(pp->next);
02876             }
02877         }
02878                                    
02879         if (!ret) pp = pp->ysis;    // 見つかった場合はもう一度．見つからなかった場合へ次へ．
02880     }
02881 
02882     return lp;
02883 }
02884 
02885 
02886 
02897 tXML*  find_match_xml_end_node(tXML* pp, tXML* pt)
02898 {
02899     int    ret;
02900     tXML*  tt = NULL;
02901     tXML*  pm;
02902 
02903     if (pp==NULL || pt==NULL) return NULL;
02904 
02905     pm  = pp;
02906     ret = find_match_tTree(pp, pt);
02907     if (ret) {
02908         tt = find_xml_end(pt);
02909         if (tt!=NULL) {
02910             tt = tt->altp;
02911         }
02912     }
02913 
02914     clear_tTree_ctrl(pm);
02915 
02916     return tt;
02917 }
02918 
02919 
02920 
02941 int  check_match_xml(tXML* tp, tXML* tr)
02942 {
02943     int   ret;
02944     tXML* te;
02945     tXML* ts;
02946 
02947     tXML* tt;
02948     tXML* ta;
02949     tXML* tb;
02950 
02951     if (tp==NULL || tr==NULL) return FALSE;
02952 
02953     te = find_tList_end(tr);
02954 
02955     ts = tp;
02956     while (ts!=NULL) {
02957         tt = cmp_sisters_xml(ts, tr);        // その階層で trと全て一致している部分があるかを確認
02958         if (tt==NULL) return FALSE;          // 一致していなければ，FALSE
02959         
02960         ta  = tt;                            // 比べられるツリー
02961         tb  = tr;                            // 比べるパターン
02962         ret = TRUE;
02963         while (tb!=NULL && ret) {
02964             if (tb->next==NULL) ret = TRUE;
02965             // ->ta, ->tb->tx: FALSE
02966             else if (tb->next!=NULL && ta->next==NULL) ret = FALSE;
02967             // ->ta->xa, ->tb->xb: xaとxbをチェック
02968             else ret = check_match_xml(ta->next, tb->next);
02969 
02970             ta = ta->ysis;
02971             tb = tb->ysis;
02972         }
02973 
02974         if (ret) {
02975             if (tr==te) tt->ctrl = TREE_ALREADY_FOUND_NODE;
02976             return TRUE;
02977         }
02978 
02979         ts = tt->ysis;
02980     }
02981 
02982     return FALSE;
02983 }
02984 
02985 
02986 
03019 tXML*  cmp_sisters_xml(tXML* tp, tXML* tr)
03020 {
03021     tXML* ta;
03022     tXML* tb = NULL;
03023     tXML* ts;
03024 
03025     ts = tp;
03026     while (ts!=NULL){
03027         ta = ts;
03028         tb = tr;
03029         while (ta!=NULL && tb!=NULL) {
03030             // 一致しない場合 break
03031             if (ta->ctrl==TREE_ALREADY_FOUND_NODE) break;
03032             if (tb->ctrl!=TREE_NOCMP_NODE && tb->ctrl!=TREE_NOCMP_COPY_NODE) {
03033                 if ((ta->ldat).key.buf!=NULL && (tb->ldat).key.buf!=NULL) {
03034                     if (ta->ldat.id!=tb->ldat.id || strcmp((char*)((ta->ldat).key.buf), (char*)((tb->ldat).key.buf))) break;
03035                 }
03036                 else break;
03037             }
03038 
03039             // ta と tb は一致
03040             tb->altp = ta;
03041             ta = ta->ysis;
03042             tb = tb->ysis;
03043         }
03044 
03045         // ts と tr は完全に一致
03046         if (tb==NULL) return ts;
03047 
03048         ts = ts->ysis;
03049     }
03050 
03051     return NULL;
03052 }
03053 
03054 
03055 
03056 
03058 // Simple Node Functions  (単純な構造のノードの操作)
03059 //
03060 
03071 Buffer  get_node_content(tXML* tp, const char* name, int no)
03072 {
03073     Buffer content;
03074     tXML*  tt;
03075     
03076     content = init_Buffer();
03077     if (tp==NULL || name==NULL) return content;
03078 
03079     if (no<=0) no = 1;
03080     tt = strncmp_tTree(tp, name, 0, no);
03081     if (tt!=NULL) {
03082         if (tt->next!=NULL) {
03083             tt = tt->next;
03084             while (tt!=NULL && tt->ldat.id!=XML_CONTENT_NODE) tt = tt->ysis;
03085             if (tt==NULL) return content;
03086             content = dup_Buffer(tt->ldat.key);
03087         }
03088     }
03089 
03090     return content;
03091 }
03092 
03093 
03094 
03100 int  get_node_integer(tXML* tp, const char* name, int no)
03101 {
03102     int       ret;
03103     Buffer content;
03104 
03105     content = get_node_content(tp, name, no);
03106 
03107     if (content.buf==NULL) ret = 0;
03108     else                   ret = atoi((const char*)content.buf);
03109     free_Buffer(&content);
03110 
03111     return  ret;
03112 }
03113 
03114 
03115 
03122 int   return_exist_node(tXML* tp, const char* name, int no, Buffer* content) 
03123 {
03124     Buffer buf;
03125     
03126     buf = get_node_content(tp, name, no);
03127     if (buf.buf==NULL) return FALSE;
03128 
03129     if (content!=NULL) *content = buf;
03130     return TRUE;
03131 }
03132 
03133 
03134 
03147 int  replace_all_node_integer(tXML* tp, const char* name, int src, int dst)
03148 {
03149     int  n;
03150     char nums[20], numd[20];
03151 
03152     snprintf(nums, 10, "%d", src);
03153     snprintf(numd, 10, "%d", dst);
03154 
03155     n = replace_all_node_contents(tp, name, nums, numd);
03156 
03157     return n;
03158 }
03159 
03160 
03161 
03175 int  replace_all_node_contents(tXML* pp, const char* name, const char* src, const char* dst)
03176 {
03177     int  n;
03178 
03179     if (pp==NULL || dst==NULL) return 0;
03180 
03181     if (pp->ldat.id==XML_ANCHOR_NODE) {
03182         if (pp->next!=NULL) pp = pp->next;
03183         else return 0;
03184     }
03185     while(pp->esis!=NULL) pp = pp->esis;
03186 
03187     n = replace_all_node_contents_rcsv(pp, name, src, dst);
03188 
03189     return n;
03190 }
03191 
03192 
03193 
03199 int  replace_all_node_contents_rcsv(tXML* pp, const char* name, const char* src, const char* dst)
03200 {
03201     int  n = 0;
03202 
03203     while(pp!=NULL) {
03204         if (pp->ldat.key.buf!=NULL && pp->ldat.id==XML_NAME_NODE && pp->ldat.lv>0) {
03205             if (name==NULL || !strcmp(name, (const char*)(pp->ldat.key.buf))) {
03206                 tXML* tt = pp->next;
03207 
03208                 // 複数のコンテント
03209                 while (tt!=NULL) {
03210                     if (tt->ldat.id==XML_CONTENT_NODE) {
03211                         if (src==NULL) {
03212                             copy_s2Buffer(dst, &(tt->ldat.key));
03213                             n++;
03214                         }
03215                         else if (tt->ldat.key.buf!=NULL && strstr((const char*)tt->ldat.key.buf, src)!=NULL) {
03216                             Buffer buf = replace_sBuffer_bystr(tt->ldat.key, src, dst);
03217                             free_Buffer(&(tt->ldat.key));
03218                             tt->ldat.key = buf;
03219                             n++;
03220                         }
03221                     }
03222                     tt = tt->ysis;
03223                 }
03224             }
03225         }
03226 
03227         if (pp->next!=NULL) n += replace_all_node_contents_rcsv(pp->next, name, src, dst);
03228 
03229         pp = pp->ysis;
03230     }
03231 
03232     return n;
03233 }
03234 
03235 
03236 
03249 int  replace_all_node_byid(tXML* pp, const char* src, const char* dst, int id)
03250 {
03251     int  n;
03252 
03253     if (pp==NULL || dst==NULL) return 0;
03254 
03255     if (pp->ldat.id==XML_ANCHOR_NODE) {
03256         if (pp->next!=NULL) pp = pp->next;
03257         else return 0;
03258     }
03259     while(pp->esis!=NULL) pp = pp->esis;
03260 
03261     n = replace_all_node_byid_rcsv(pp, src, dst, id);
03262 
03263     return n;
03264 }
03265 
03266 
03267 
03273 int  replace_all_node_byid_rcsv(tXML* pp, const char* src, const char* dst, int id)
03274 {
03275     int  n = 0;
03276 
03277     while(pp!=NULL) {
03278         if (id<0 || pp->ldat.id==id) {
03279             if (src==NULL) {
03280                 copy_s2Buffer(dst, &(pp->ldat.key));
03281                 n++;
03282             }
03283             else if (pp->ldat.key.buf!=NULL && strstr((const char*)pp->ldat.key.buf, src)!=NULL) {
03284                 Buffer buf = replace_sBuffer_bystr(pp->ldat.key, src, dst);
03285                 free_Buffer(&(pp->ldat.key));
03286                 pp->ldat.key = buf;    
03287                 n++;
03288             }
03289         }
03290 
03291         if (pp->next!=NULL) n += replace_all_node_byid_rcsv(pp->next, src, dst, id);
03292 
03293         pp = pp->ysis;
03294     }
03295 
03296     return n;
03297 }
03298 
03299 
03300 
03301 
03303 // XML-RPC
03304 
03336 Buffer  xml_rpc_request_pack(const char* name, tXML* xml)
03337 {
03338     tXML* ptr = init_xml_doc();
03339     tXML* top = add_xml_node(ptr, "methodCall");
03340     tXML* mnm = add_xml_node(top, "methodName");
03341     tXML* prs = add_xml_node(top, "params");
03342     tXML* prm = add_xml_node(prs, "param");
03343     add_xml_content(mnm, name);
03344 
03345     join_xml(prm, xml);
03346     Buffer buf = xml_inverse_parse(ptr, XML_ONELINE_FORMAT);
03347 
03348     return buf;
03349 }
03350 
03351 
03368 tXML*   xml_rpc_add_member(tXML* xml, char* name, char* value, char* kind)
03369 {
03370     if (name==NULL) return xml;
03371   
03372     if (xml==NULL) xml = add_xml_node(NULL, "struct");
03373     
03374     tXML* mem = add_xml_node(xml, "member");
03375     tXML* mnm = add_xml_node(mem, "name");
03376     tXML* val = add_xml_node(mem, "value");
03377     tXML* knd;
03378     if (kind==NULL)         knd = add_xml_node(val, "string");
03379     else if (kind[0]=='\0') knd = add_xml_node(val, "string");
03380     else                    knd = add_xml_node(val, kind);
03381 
03382     add_xml_content(mnm, name);
03383     add_xml_content(knd, value);
03384 
03385     return xml;
03386 }
03387 
03388 
03411 tXML*   xml_rpc_end_member(tXML* xml)
03412 {
03413     tXML* ptr = add_xml_node(NULL, "value");
03414     join_xml(ptr, xml);
03415 
03416     return ptr;
03417 }
03418 
03419 
03429 tXML*   xml_rpc_add_array(tXML* xml, tXML* array)
03430 {
03431     if (xml==NULL) xml = add_xml_node(NULL, "data");
03432     join_xml(xml, array);
03433     
03434     return xml;
03435 }
03436 
03437 
03438 
03451 tXML*   xml_rpc_end_array(tXML* xml)
03452 {
03453     tXML* ptr = add_xml_node(NULL, "value");
03454     tXML* val = add_xml_node(ptr,  "array");
03455     join_xml(val, xml);
03456 
03457     return ptr;
03458 }
03459 
03460