JunkBox_Lib: Lib/tjson.c Source File

00001 
00018 #ifdef CPLUSPLUS
00019     #undef CPLUSPLUS
00020 #endif
00021 
00022 
00023 #include "tjson.h"
00024 #include "jbxl_state.h"
00025 
00026 
00027 
00029 // Parser
00030 //
00031 
00051 tJson*  json_parse(char* pp, int num)
00052 {
00053     while(*pp!='{' && *pp!='\0') pp++;
00054     if (*pp=='\0') return NULL;
00055 
00056     tJson* json = new_json_anchor_node();                    // アンカー
00057     //json->ldat.id = JSON_ANCHOR_NODE;
00058     //json->ldat.lv = JSON_VALUE_OBJ;
00059     //json->state   = JBXL_STATE_ANCHOR;
00060     //json->depth   = -1;
00061 
00062     // パース
00063     tJson* node = json_parse_prop(json, pp, num);
00064     if (node->state<0) return node;
00065     if (node->state==JBXL_JSON_PARSE_TERM) return node;     // 中途半端な入力
00066 
00067     // 元に戻ったか？
00068     if (json==node) {
00069         json->state = JBXL_JSON_PARSED;
00070     }
00071     else {
00072         json->state = JBXL_JSON_NOT_CLOSED;
00073     }
00074 
00075     // JSON rootの数
00076     if (json->next!=NULL) {
00077         int n = 0;
00078         node = json->next;
00079         while(node!=NULL) {
00080             if (node->ldat.id==JSON_BRACKET_NODE) n++;
00081             node = node->ysis;
00082         }
00083         if (n!=1) json->state = JBXL_JSON_MULTI_ROOT;
00084     }
00085     else json->state = JBXL_JSON_DEFAULT_STATE;
00086 
00087     return json;
00088 }
00089 
00090 
00091 
00107 tJson*  json_parse_prop(tJson* json, char* pp, int num)
00108 {
00109     char*  pt   = NULL;
00110     tJson* node = NULL;
00111 
00112     if (json==NULL) {
00113         json = new_json_node();
00114         json->ldat.id = JSON_TEMP_NODE;
00115     }
00116 
00117     while (*pp!='\0') {
00118         // 
00119         if (*pp=='{') {
00120             pp++;
00121             if (json->ctrl!=JBXL_JSON_NODE_OPENED) {
00122                 // open {
00123                 if (json->prev==NULL) {
00124                     node = new_json_node();
00125                     node->ldat.id = JSON_BRACKET_NODE;
00126                     node->ldat.lv = JSON_VALUE_OBJ;
00127                     json = add_tTree_node(json, node);
00128                 }
00129                 else {
00130                     if (json->yngr!=NULL) {
00131                         json = json->yngr;
00132                         json->ldat.lv = JSON_VALUE_OBJ;
00133                     }
00134                 }
00135             }
00136             json->ctrl = JBXL_NONE;
00137 
00138             // 最初の \", \', } を見つける
00139             pt = pp;
00140             while(*pt!='\0') {
00141                 while(*pt=='\\') pt += 2;
00142                 if (*pt!='\0') {
00143                     if (*pt=='\'' || *pt=='\"' || *pt=='}') break;
00144                     pt++;
00145                 }
00146             }
00147             if (*pt=='\0') {
00148                 json = _json_parse_term(json, NULL, NULL, "{");
00149                 json->ctrl = JBXL_JSON_NODE_OPENED;
00150                 return json;
00151             }
00152             //
00153 
00154             pp = pt;
00155             if (*pp!='}') {     // \" or \'
00156                 char ch = '\"';
00157                 if (*pt=='\'') ch = '\''; 
00158                 //
00159                 pt = pp + 1;
00160                 while(*pt!='\0') {
00161                     while(*pt=='\\') pt += 2;
00162                     if (*pt!='\0') {
00163                         if (*pt==ch) break;
00164                         pt++;
00165                     }
00166                 }
00167                 if (*pt=='\0') {
00168                     json = _json_parse_term(json, pp, pt, "{");
00169                     json->ctrl = JBXL_JSON_NODE_OPENED;
00170                     return json;
00171                 }
00172 
00173                 int len = (int)(pt - pp) - 1 ;
00174                 node = new_json_node();
00175                 node->ldat.key = set_Buffer(pp + 1, len);
00176                 node->ldat.id  = JSON_DATA_NODE;
00177                 node->ldat.lv  = JSON_VALUE_NULL;
00178                 add_tTree_node(json, node);
00179 
00180                 pt = pt + 1; 
00181                 while(*pt!=',' && *pt!=':' && *pt!='}' && *pt!='\0') pt++; 
00182                 if (*pt=='\0') {
00183                     json->state = JBXL_JSON_PARSE_TERM;
00184                     return json; 
00185                 }
00186                 pp = pt;
00187             }
00188         }
00189 
00190         //
00191         else if (*pp=='[') {
00192             pt = skip_char_pair(pp, '[', ']');
00193             if (*pt=='\0') {
00194                 json = _json_parse_term(json, pp, pt, "[");
00195                 return json;
00196             }
00197 
00198             int len = (int)(pt - pp) + 1;
00199             Buffer temp = set_Buffer(pp, len);
00200             json->yngr->ldat.val = pack_Buffer(temp, '\0');
00201             json->yngr->ldat.lv  = JSON_VALUE_ARRAY;
00202             free_Buffer(&temp);
00203 
00204             pt++; 
00205             while(*pt!=',' && *pt!='}' && *pt!='\0') pt++; 
00206             if (*pt=='\0') {
00207                 json->state = JBXL_JSON_PARSE_TERM;
00208                 return json;    
00209             }
00210             //
00211             if (num>0) _json_array_parse(json->yngr, num-1);
00212 
00213             pp = pt;
00214         }
00215 
00216         //
00217         else if (*pp==',') {
00218             // 最初の \", \', } を見つける
00219             pt = pp;
00220             while(*pt!='\0') {
00221                 while(*pt=='\\') pt += 2;
00222                 if (*pt!='\0') {
00223                     if (*pt=='\'' || *pt=='\"' || *pt=='}') break;
00224                     pt++;
00225                 }
00226             }
00227             if (*pt=='\0') {
00228                 json = _json_parse_term(json, NULL, NULL, ",");
00229                 return json;
00230             }
00231 
00232             pp = pt;
00233             if (*pp!='}') {     // \" or \'
00234                 char ch = '\"';
00235                 if (*pt=='\'') ch = '\''; 
00236                 //
00237                 pt = pp + 1;
00238                 while(*pt!='\0') {
00239                     while(*pt=='\\') pt += 2;
00240                     if (*pt!='\0') {
00241                         if (*pt==ch) break;
00242                         pt++;
00243                     }
00244                 }
00245                 if (*pt=='\0') {
00246                     json = _json_parse_term(json, pp, pt, ",");
00247                     return json;    
00248                 }
00249 
00250                 int len = (int)(pt - pp) - 1 ;
00251                 node = new_json_node();
00252                 node->ldat.key = set_Buffer(pp + 1, len);
00253                 node->ldat.id  = JSON_DATA_NODE;
00254                 node->ldat.lv  = JSON_VALUE_NULL;
00255                 add_tTree_node(json, node);
00256 
00257                 pt = pt + 1; 
00258                 while(*pt!=',' && *pt!=':' && *pt!='}' && *pt!='\0') pt++; 
00259                 if (*pt=='\0') {
00260                     json->state = JBXL_JSON_PARSE_TERM;
00261                     return json;    
00262                 }
00263                 pp = pt;
00264             }
00265         }
00266 
00267         //
00268         else if (*pp==':') {
00269             pt = pp + 1;
00270             while (*pt==' ' && *pt!='\0') pt++;
00271             if (*pt=='\0') {
00272                 json = _json_parse_term(json, NULL, NULL, ":");
00273                 return json;
00274             }
00275             pp = pt;
00276 
00277             if (*pp!='{' && *pp!='[') {
00278                 while(*pt==' ') pt++;
00279                 if (*pt!='\0') while (*pt=='\\') pt += 2;
00280                 //
00281                 if (*pp=='\'' || *pp=='\"') {
00282                     pt = skip_string_end(pt);
00283                     if (*pt!='\0') pt++;
00284                 }
00285                 while (*pt!=',' && *pt!='}' && *pt!='\0') pt++;
00286 
00287                 if (*pt=='\0') {
00288                     json = _json_parse_term(json, pp, pt, ":");
00289                     return json;    
00290                 }
00291                 pt--;
00292                 while (*pt==' ' || *pt==0x0a || *pt==0x0d) pt--;
00293 
00294                 int len = (int)(pt - pp) + 1 ;
00295                 Buffer temp = set_Buffer(pp, len);
00296                 json->yngr->ldat.val = pack_Buffer(temp, '\0');
00297                 free_Buffer(&temp);
00298                 //
00299                 if (*pp=='\"' || *pp=='\'') json->yngr->ldat.lv = JSON_VALUE_STR;
00300                 else {
00301                     const char* val = (const char*)json->yngr->ldat.val.buf;
00302                     if (!strcasecmp("true", val) || !strcasecmp("false", val)) json->yngr->ldat.lv = JSON_VALUE_BOOL;
00303                     else  json->yngr->ldat.lv = JSON_VALUE_UNRESOLV;
00304                 }
00305 
00306                 pt++;
00307                 while (*pt==' ') pt++;
00308                 pp = pt;
00309             }
00310         }
00311 
00312         //
00313         else if (*pp=='}') {
00314             if (json->prev!=NULL) {
00315                 json = json->prev;
00316             }
00317             pt = pp = pp + 1;
00318             while (*pt!=',' && *pt!='}' && *pt!='{' && *pt!='\0') pt++;
00319             if (*pt=='\0' && json->depth>0) {
00320                 json->state = JBXL_JSON_PARSE_TERM;
00321                 return json;    
00322             }
00323             pp = pt;
00324         }
00325 
00326         //
00327         else {
00328             pp++;
00329         }
00330     }
00331 
00332     if (json->ldat.id==JSON_TEMP_NODE) {
00333         tJson* temp = json->next;
00334         del_json_node(&json);
00335         json = temp;
00336     }
00337 
00338     json->state = JBXL_JSON_PARSED;
00339     return json;
00340 }
00341 
00342 
00343 
00353 tJson*  _json_array_parse(tJson* json, int num)
00354 {
00355     char* pp = (char*)(json->ldat.val.buf);
00356     //
00357     json = json_array_parse(json, pp, num);
00358     free_Buffer(&(json->ldat.val));
00359 
00360     return json;
00361 }
00362 
00363 
00364 
00380 tJson*  json_array_parse(tJson* json, char* pp, int num)
00381 {
00382     char* pt;
00383     if (*pp!='[') return json;
00384 
00385     if (json==NULL) {
00386         json = new_json_node();
00387         json->ldat.id = JSON_TEMP_NODE;
00388     }
00389     else {
00390         json->ldat.id = JSON_ARRAY_NODE;
00391     }
00392     json->ldat.lv = JSON_VALUE_NULL;
00393 
00394     //
00395     pp++;
00396     while (*pp!='\0') {
00397         while (*pp==' ') pp++;
00398         if (*pp!='\0') while (*pp=='\\') pp += 2;
00399 
00400         //
00401         if (*pp==']') break;
00402 
00403         //
00404         else if (*pp=='\'' || *pp=='\"') {
00405             char ch = *pp;
00406             pt = pp + 1;
00407             while (*pt!='\0') {
00408                 while (*pt=='\\') pt += 2;
00409                 if (*pt!='\0') {
00410                     if (*pt==ch) break;
00411                     pt++;
00412                 }
00413             }
00414 
00415             if (*pt!='\0') {
00416                 int len = (int)(pt - pp) + 1 ;
00417                 tJson* node = new_json_node();
00418                 Buffer temp    = set_Buffer(pp, len);
00419                 node->ldat.key = make_Buffer_bystr("ARRAY_VALUE");
00420                 node->ldat.val = pack_Buffer(temp, '\0');
00421                 node->ldat.id  = JSON_ARRAY_VALUE_NODE;
00422                 node->ldat.lv  = JSON_VALUE_STR;
00423                 free_Buffer(&temp);
00424                 add_tTree_node(json, node);
00425             
00426                 pp = pt + 1;
00427             }
00428         }
00429 
00430         //
00431         else if (*pp=='{') {
00432             pt = skip_char_pair(pp, '{', '}');
00433 
00434             int len = (int)(pt - pp) + 1 ;
00435             tJson* node = new_json_node();
00436             Buffer temp    = set_Buffer(pp, len);
00437             node->ldat.val = pack_Buffer(temp, '\0');
00438             node->ldat.id  = JSON_ARRAY_VALUE_NODE;
00439             node->ldat.lv  = JSON_VALUE_OBJ;
00440             free_Buffer(&temp);
00441             
00442             if (num>0) {
00443                 node = json_parse_prop(node, (char*)node->ldat.val.buf, num-1);
00444                 add_tTree_node(json, node);
00445                 del_json_node(&node);           // ノードを詰める
00446             }
00447             else {
00448                 add_tTree_node(json, node);
00449             }
00450 
00451             pp = pt + 1;
00452         }
00453 
00454         else if (*pp==',') {
00455             pp++;
00456         }
00457 
00458         else {
00459             pt = skip_chars(pp, ",}]");
00460 
00461             int len = (int)(pt - pp);
00462             tJson* node = new_json_node();
00463             Buffer temp    = set_Buffer(pp, len);
00464             node->ldat.val = pack_Buffer(temp, '\0');
00465             node->ldat.id  = JSON_ARRAY_VALUE_NODE;
00466             node->ldat.lv  = JSON_VALUE_UNRESOLV;
00467             free_Buffer(&temp);
00468             add_tTree_node(json, node);
00469 
00470             pp = pt;
00471         }
00472     }
00473 
00474     return json;
00475 }
00476 
00477 
00478 
00484 tJson*  _json_parse_term(tJson* json, char* st, char* ed, const char* com)
00485 {
00486     if (json==NULL) return NULL;
00487 
00488     json->state = JBXL_JSON_PARSE_TERM;
00489     if (com!=NULL) {
00490         json->ldat.val = set_Buffer((void*)com, -1);
00491         if (st!=NULL && ed!=NULL) {
00492             int len = (int)(ed - st) + 1;
00493             cat_b2Buffer(st, &(json->ldat.val), len);
00494             json->ldat.val.vldsz = (int)strlen((char*)json->ldat.val.buf);
00495         }
00496     }    
00497     return json;
00498 }
00499 
00500 
00501 
00515 tJson*  json_parse_seq(tJson* json, char* pp, int num)
00516 {
00517     if (json==NULL) {
00518         json = json_parse_prop(NULL, pp, num);
00519         return json;
00520     }
00521 
00522     Buffer buf = dup_Buffer(json->ldat.val);
00523     free_Buffer(&(json->ldat.val));
00524     cat_s2Buffer(pp, &buf);
00525 
00526     json->state = JBXL_JSON_DEFAULT_STATE;
00527     json = json_parse_prop(json, (char*)buf.buf, num);
00528     free_Buffer(&buf);
00529 
00530     return json;
00531 }
00532 
00533 
00534 
00535 
00537 // 逆 Parser
00538 //
00539 
00551 Buffer  json_inverse_parse(tJson* pp, int mode)
00552 {
00553     int cnt;
00554     Buffer buf;
00555 
00556     buf = init_Buffer();
00557     if (pp==NULL) return buf;
00558     if (pp->ldat.id==JSON_ANCHOR_NODE) pp = pp->next;
00559     if (pp==NULL) return buf;
00560 
00561     cnt = count_tTree(pp);
00562     buf = make_Buffer(cnt*LSDATA);
00563     if (buf.buf==NULL) return buf;
00564 
00565     if (pp->ctrl!=TREE_NOSIS_NODE) while (pp->esis!=NULL) pp = pp->esis;
00566 
00567     if (mode==JSON_CRLF_FORMAT) {
00568         _json_to_Buffer(pp, &buf, "\r\n", "");
00569     }
00570     else if (mode==JSON_INDENT_FORMAT) {
00571         _json_to_Buffer(pp, &buf, "\r\n", "    ");
00572     }
00573     else {
00574         _json_to_Buffer(pp, &buf, "", "");
00575     }
00576 
00577     return buf;
00578 }
00579 
00580 
00581 
00592 Buffer  json_inverse_parse_opt(tJson* pp, const char* crlf, const char* space)
00593 {
00594     int cnt;
00595     Buffer buf;
00596 
00597     buf = init_Buffer();
00598     if (pp==NULL) return buf;
00599     if (pp->ldat.id==JSON_ANCHOR_NODE) pp = pp->next;
00600     if (pp==NULL) return buf;
00601 
00602     cnt = count_tTree(pp);
00603     buf = make_Buffer(cnt*LSDATA);
00604     if (buf.buf==NULL) return buf;
00605 
00606     if (pp->ctrl!=TREE_NOSIS_NODE) while (pp->esis!=NULL) pp = pp->esis;
00607     _json_to_Buffer(pp, &buf, crlf, space);
00608 
00609     return buf;
00610 }
00611 
00612 
00613 
00625 void  _json_to_Buffer(tJson* pp, Buffer* buf, const char* crlf, const char* space)
00626 {
00627     if (pp==NULL) return;
00628     if (buf==NULL || buf->buf==NULL) return;
00629     //
00630     if (pp->ldat.id==JSON_ANCHOR_NODE) pp = pp->next;
00631 
00632     if (pp!=NULL) {
00633         if (pp->ctrl!=TREE_NOSIS_NODE) while(pp->esis!=NULL) pp = pp->esis; // 長女から逆パースを開始．
00634         do {
00635             int i;
00636             if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00637             //
00638             if (pp->ldat.id==JSON_BRACKET_NODE) {
00639                 cat_s2Buffer("{", buf);
00640                 if (pp->next!=NULL) {
00641                     if (crlf[0]!='\0') cat_s2Buffer(crlf, buf);
00642                     _json_to_Buffer(pp->next, buf, crlf, space);
00643                     if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00644                 }
00645                 //if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00646                 cat_s2Buffer("}", buf); 
00647             }
00648             //
00649             else if (pp->ldat.id==JSON_DATA_NODE) {
00650                 cat_s2Buffer("\"", buf);
00651                 cat_s2Buffer(pp->ldat.key.buf, buf);
00652                 cat_s2Buffer("\"", buf);
00653                 //
00654                 if (pp->ldat.lv==JSON_VALUE_OBJ) {
00655                     cat_s2Buffer(": {", buf);
00656                     if (pp->next!=NULL) {
00657                         if (crlf[0]!='\0') cat_s2Buffer(crlf, buf);
00658                         _json_to_Buffer(pp->next, buf, crlf, space);
00659                         if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00660                     }
00661                     //if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00662                     cat_s2Buffer("}", buf); 
00663                 }
00664                 else {
00665                     if (pp->ldat.lv==JSON_VALUE_NULL) {
00666                         cat_s2Buffer(": null", buf);
00667                     }
00668                     else  {
00669                         cat_s2Buffer(": ", buf);
00670                         cat_s2Buffer(pp->ldat.val.buf, buf);
00671                     }
00672                 }
00673             }
00674             //
00675             // array
00676             else if (pp->ldat.id==JSON_ARRAY_NODE) {
00677                 cat_s2Buffer("\"", buf);
00678                 cat_s2Buffer(pp->ldat.key.buf, buf);
00679                 cat_s2Buffer("\": [", buf);
00680                 if (pp->next!=NULL) {
00681                     if (crlf[0]!='\0') cat_s2Buffer(crlf, buf);
00682                     _json_to_Buffer(pp->next, buf, crlf, space);
00683                     if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00684                 }
00685                 //if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00686                 cat_s2Buffer("]", buf); 
00687             }
00688 
00689             else if (pp->ldat.id==JSON_ARRAY_VALUE_NODE) {
00690                 if (pp->ldat.lv==JSON_VALUE_OBJ) {
00691                     if (pp->ldat.val.buf==NULL) {
00692                         cat_s2Buffer("{", buf);
00693                         if (pp->next!=NULL) {
00694                             if (crlf[0]!='\0') cat_s2Buffer(crlf, buf);
00695                             _json_to_Buffer(pp->next, buf, crlf, space);
00696                             if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00697                         }
00698                         //if (space[0]!='\0') for(i=0; i<pp->depth; i++) cat_s2Buffer(space, buf);
00699                         cat_s2Buffer("}", buf); 
00700                     }
00701                     else {
00702                         cat_Buffer(&pp->ldat.val, buf);
00703                     }
00704                 }
00705                 else {
00706                     if (pp->ldat.lv==JSON_VALUE_NULL) {
00707                         cat_s2Buffer("null", buf);
00708                     }
00709                     else  {
00710                         cat_s2Buffer(pp->ldat.val.buf, buf);
00711                     }
00712                 }
00713             }
00714 
00715             if (pp->ctrl!=TREE_NOSIS_NODE && pp->ysis!=NULL && 
00716                 pp->prev!=NULL && pp->prev->ldat.id!=JSON_ANCHOR_NODE) cat_s2Buffer(",", buf);
00717             if (crlf[0]!='\0') cat_s2Buffer(crlf, buf);
00718 
00719             if (pp->ctrl!=TREE_NOSIS_NODE) pp = pp->ysis;
00720             else                           pp = NULL;
00721         } while(pp!=NULL);
00722     }
00723 
00724     return;
00725 }
00726 
00727 
00728 
00740 void  print_json(FILE* fp, tJson* json, int mode)
00741 {
00742     Buffer buf = json_inverse_parse(json, mode);
00743     if (buf.buf!=NULL) {
00744         fprintf(fp, "%s", buf.buf);
00745         free_Buffer(&buf);
00746     }
00747 
00748     return;
00749 }
00750 
00751 
00752 
00763 void  print_json_opt(FILE* fp, tJson* json, const char* crlf, const char* space)
00764 {
00765     Buffer buf = json_inverse_parse_opt(json, crlf, space);
00766     if (buf.buf!=NULL) {
00767         fprintf(fp, "%s", buf.buf);
00768         free_Buffer(&buf);
00769     }
00770 
00771     return;
00772 }
00773 
00774 
00775 
00776 
00778 // Tools
00779 
00792 tJson*  json_parse_file(const char* fn, int num)
00793 {
00794     tJson* json = NULL;
00795     Buffer buf;
00796 
00797     buf = read_Buffer_file(fn);
00798     if (buf.buf!=NULL) {
00799         json = json_parse((char*)(buf.buf), num);
00800         free_Buffer(&buf);
00801     }
00802 
00803     return json;
00804 }
00805 
00806 
00807 
00813 void  json_set_str_val(tJson* json, char* str)
00814 {
00815     if (json==NULL || str==NULL) return;
00816 
00817     copy_s2Buffer(str, &(json->ldat.val));
00818     json->ldat.lv = JSON_VALUE_STR;
00819 
00820     return;
00821 }
00822 
00823 
00824 
00830 void  json_copy_val(tJson* f_json, tJson* t_json)
00831 {
00832     if (f_json==NULL || t_json==NULL) return;
00833 
00834     t_json->ldat.lv = f_json->ldat.lv;
00835     copy_Buffer(&(f_json->ldat.val), &(t_json->ldat.val));
00836 
00837     return;
00838 }
00839 
00840 
00841 
00847 void  json_copy_data(tJson* f_json, tJson* t_json)
00848 {
00849     if (f_json==NULL || t_json==NULL) return;
00850 
00851     t_json->ldat.id = f_json->ldat.id;
00852     t_json->ldat.lv = f_json->ldat.lv;
00853     copy_Buffer(&(f_json->ldat.key), &(t_json->ldat.key));
00854     copy_Buffer(&(f_json->ldat.val), &(t_json->ldat.val));
00855 
00856     return;
00857 }
00858 
00859 
00860 
00874 void  insert_json_nodes(tJson* parent, tJson* child)
00875 {
00876     if (parent==NULL) return;
00877     if (child ==NULL) return;
00878     if (parent->ldat.id!=JSON_BRACKET_NODE && parent->ldat.id!=JSON_ARRAY_NODE) return;
00879     if (child->ldat.id !=JSON_BRACKET_NODE) return;
00880     
00881     if (parent->ldat.id==JSON_BRACKET_NODE) {
00882         tJson* cp = child->next;
00883         while (cp!=NULL) {
00884             add_tTree(parent, cp);
00885             cp = cp->ysis;
00886         }
00887         free_tList_data(&child->ldat);
00888         free(child);
00889     }
00890 
00891     if (parent->ldat.id==JSON_ARRAY_NODE) {
00892         add_tTree(parent, child);
00893     }
00894 
00895     return;
00896 }
00897 
00898 
00899 
00911 tJson*   join_json(tJson* parent, tJson** child)
00912 {
00913     if (*child==NULL) return parent;
00914     if (parent==NULL) return *child;            // この場合 ANCHOR はそのまま
00915 
00916     if ((*child)->ldat.id==JSON_ANCHOR_NODE || (*child)->ldat.id==JSON_TEMP_NODE) {  // 子として繋げる場合，ANCHOR, TEMP_NODE は削除
00917         tJson* jtmp = (*child)->next;
00918         del_json_node(child);                       // ANCHOR, TEMP_NODE を削除してつめる．
00919         *child = jtmp;
00920     }
00921 
00922     add_tTree(parent, *child); 
00923 
00924     return parent;
00925 }
00926 
00927 
00928 
00930 // Search
00931 
00940 tJson*  search_top_bracket_json(tJson* pp, int nn)
00941 {
00942     if (pp==NULL) return NULL;
00943     if (nn<=0) nn = 1;
00944 
00945     while (pp->prev!=NULL) pp = pp->prev;
00946 
00947     if (pp->ldat.id==JSON_ANCHOR_NODE) {
00948         pp = pp->next;
00949     }
00950     if (pp->ldat.id==JSON_BRACKET_NODE) {
00951         while(pp->esis!=NULL) pp = pp->esis;
00952     }
00953     else {
00954         return NULL;
00955     }
00956 
00957     int i = 1;
00958     while (i<nn && pp!=NULL) {
00959         pp = pp->ysis;
00960         i++;
00961     }
00962 
00963     return pp;
00964 }
00965 
00966 
00967 
00981 tJson*  search_key_json(tJson* pp, char* key, int needval, int nn)
00982 {
00983     if (pp==NULL || key==NULL) return NULL;
00984     if (nn<=0) nn = 1;
00985 
00986     // 開始ノードのチェック
00987     if (!(pp->ldat.lv==JSON_VALUE_OBJ && needval)){
00988         nn = _json_check_node_bykey(pp, key, needval, nn);
00989     }
00990     // 子ノード
00991     if (nn>0 && pp->next!=NULL) {
00992         pp = _search_key_json(pp->next, key, needval, &nn);
00993     }
00994     else return NULL;
00995 
00996     return pp; 
00997 }
00998 
00999 
01000 
01011 tJson*   search_sister_json(tJson* pp, int nn)
01012 {
01013     if (pp==NULL) return NULL;
01014 
01015     if (nn>0) {
01016         int i = 0;
01017         while (pp!=NULL && i<nn) {
01018             pp = pp->ysis;
01019             i++;
01020         }
01021     }
01022     else if (nn<0) {
01023         nn = -nn;
01024         int i = 0;
01025         while (pp!=NULL && i<nn) {
01026             pp = pp->esis;
01027             i++;
01028         }
01029     }
01030     return pp;
01031 }
01032 
01033 
01034 
01047 tJson*  search_key_child_json(tJson* pp, char* key, int needval)
01048 {
01049     if (pp!=NULL && pp->ldat.id==JSON_ANCHOR_NODE) pp = pp->next;
01050     if (pp==NULL || pp->next==NULL) return NULL;
01051 
01052     tJson* json = search_key_sister_json(pp->next, key, needval);
01053 
01054     return json;
01055 }
01056 
01057 
01058 
01071 tJson*  search_key_sister_json(tJson* pp, char* key, int needval)
01072 {
01073     if (pp==NULL || key==NULL) return NULL;
01074     while(pp->esis!=NULL) pp = pp->esis;
01075 
01076     while(pp!=NULL) {
01077         int nn = _json_check_node_bykey(pp, key, needval, 1);
01078         if (nn==0) return pp;
01079         pp = pp->ysis;
01080     }
01081     
01082     return NULL; 
01083 }
01084 
01085 
01086 
01099 tJson*  search_key_json_obj(tJson* pp, char* key, int nn)
01100 {
01101     if (pp==NULL || key==NULL) return NULL;
01102     if (nn<=0) nn = 1;
01103 
01104     // 開始ノードのチェック
01105     if (pp->ldat.lv==JSON_VALUE_OBJ) {
01106         nn = _json_check_node_bykey(pp, key, FALSE, nn);
01107     }
01108     if (nn==0) return pp;
01109 
01110     // 子ノード
01111     if (pp->next!=NULL) {
01112         pp = _search_key_json_obj(pp->next, key, &nn);
01113     }
01114     else return NULL;
01115 
01116     return pp; 
01117 }
01118 
01119 
01120 
01132 tJson*  search_double_key_json(tJson* pp, char* key1, char* key2, int needval)
01133 {
01134     if (pp==NULL || key1==NULL || key2==NULL) return NULL;
01135 
01136     pp = search_key_json_obj(pp, key1, 1);
01137     if (pp==NULL) return NULL;
01138 
01139     if (pp->next!=NULL) {
01140         pp = search_key_json(pp, key2, needval, 1);
01141     }
01142     else return NULL;
01143 
01144     return pp; 
01145 }
01146 
01147 
01148 
01149 /*
01150 tJson*  _search_key_json(tJson* pp, char* key, int needval, int* nn)
01151 
01152 search_key_json() の補助関数
01153 pp が指すノード以下で，名前（属性名）が key である nn番目のノードへのポインタを返す．@n
01154 needval が TRUE の場合は，値（属性値）を持っている場合のみカウントする．
01155 search_key_json() との違いは pp の姉妹ノードも探索することである．
01156 
01157 @param   pp   探索を開始するノード．ppがオブジェクト要素（JSON_VALUE_OBJ）なら，次のノードから探索する．
01158 @param   key  探索するノード名．
01159 @param   needval  TRUE の場合，ノードが値（属性値）を持っていない場合は無視する．"", '' の場合も無視する．
01160 @param   nn   一致するノード内，何番目を返すか指定する．nn<=0 は nn==1 とみなす．
01161 @return  見つかったノードへのポインタ．見つからない場合は，NULL
01162 */
01163 tJson*  _search_key_json(tJson* pp, char* key, int needval, int* nn)
01164 {
01165     while(pp->esis!=NULL) pp = pp->esis;
01166     tJson* esis = pp;
01167 
01168     while(pp!=NULL) {
01169         *nn = _json_check_node_bykey(pp, key, needval, *nn);
01170         if ((*nn)<=0) return pp;
01171         pp = pp->ysis;
01172     }
01173 
01174     // 子ノード
01175     pp = esis;
01176     while(pp!=NULL) {
01177         if (pp->next!=NULL) {
01178             tJson* json = _search_key_json(pp->next, key, needval, nn);
01179             if (json!=NULL) return json;
01180         }
01181         pp = pp->ysis;
01182     }
01183     
01184     return NULL; 
01185 }
01186 
01187 
01188  
01189 /*
01190 tJson*  _search_key_json_obj(tJson* pp, char* key, int* nn)
01191 
01192 search_key_json_obj() の補助関数
01193 pp が指すノード以下で，名前（属性名）が key である nn番目のオブジェクトノードへのポインタを返す．
01194 pp の姉妹ノードは探索しない．
01195 _search_key_json() よりは少し早い．たぶん．
01196 search_key_json_obj() との違いは pp の姉妹ノードも探索することである．
01197 
01198 @param   pp   探索を開始するノード．
01199 @param   key  探索するノード名．
01200 @param   nn   一致するノード内，何番目を返すか指定する．nn<=0 は nn==1 とみなす．
01201 @return  見つかったオブジェクトノードへのポインタ．見つからない場合は，NULL
01202 */
01203 tJson*  _search_key_json_obj(tJson* pp, char* key, int* nn)
01204 {
01205     if (pp==NULL) return NULL;
01206     while(pp->esis!=NULL) pp = pp->esis;
01207     tJson* esis = pp;
01208 
01209     while(pp!=NULL) {
01210         if (pp->ldat.lv==JSON_VALUE_OBJ) {
01211             *nn = _json_check_node_bykey(pp, key, FALSE, *nn);
01212         }
01213         if ((*nn)<=0) return pp;
01214         pp = pp->ysis;
01215     }
01216 
01217     // 子ノード
01218     pp = esis;
01219     while(pp!=NULL) {
01220         if (pp->next!=NULL) {
01221             tJson* json = _search_key_json_obj(pp->next, key, nn);
01222             if (json!=NULL) return json;
01223         }
01224         pp = pp->ysis;
01225     }
01226     
01227     return NULL; 
01228 }
01229 
01230 
01231 
01238 int  _json_check_node_bykey(tJson* pp, char* key, int needval, int nn)
01239 {
01240     if (pp->ldat.key.buf!=NULL) {
01241         if (!strcmp(key, (char*)pp->ldat.key.buf)) {
01242             if (needval) {
01243                 unsigned char* pm = pp->ldat.val.buf;
01244                 if (pm!=NULL) { 
01245                     if (!((pm[0]=='\'' && pm[1]=='\'') || (pm[0]=='"' && pm[1]=='"')) && pm[0]!='\0') nn--; 
01246                 }
01247             }
01248             else {
01249                 nn--;
01250             }
01251         }
01252     }
01253     return nn;
01254 }
01255 
01256 
01257 
01269 tList*   search_all_node_strval_json(tJson* pp, char* name, char* val)
01270 {
01271     if (pp!=NULL && pp->ldat.id==JSON_ANCHOR_NODE) pp = pp->next;
01272     if (pp==NULL) return NULL;
01273 
01274     tList* list = new_json_node();
01275     _search_all_node_strval_json(list, pp, name, val);
01276 
01277     return list;
01278 }
01279 
01280 
01281 
01282 tList*   _search_all_node_strval_json(tList* list, tJson* pp, char* name, char* val)
01283 {
01284     while (pp->esis!=NULL) pp = pp->esis;
01285     do {
01286         if (pp->ldat.id==JSON_DATA_NODE) {
01287             if (!strncasecmp(name, (char*)pp->ldat.key.buf, strlen(name))) {
01288                 if (pp->ldat.lv==JSON_VALUE_STR) {
01289                     if (!strncasecmp(val, (char*)(pp->ldat.val.buf+1), strlen(val))) {
01290                         list->altp = pp;
01291                         tList* temp = new_tList_node();
01292                         temp->ldat.id = list->ldat.id + 1;
01293                         add_tList_node(list, temp);
01294                         list = temp;
01295                     }
01296                 }
01297             }
01298             else if (pp->ldat.id==JSON_VALUE_OBJ) {
01299                 if (pp->next!=NULL) {
01300                     list = _search_all_node_strval_json(list, pp->next, name, val);
01301                 }
01302             }
01303         }
01304         else if (pp->ldat.id==JSON_BRACKET_NODE || pp->ldat.id==JSON_ARRAY_NODE) {
01305             if (pp->next!=NULL) {
01306                 list = _search_all_node_strval_json(list, pp->next, name, val);
01307             }
01308         }
01309         pp = pp->ysis;
01310     } while (pp!=NULL);
01311 
01312     return list;
01313 }
01314 
01315 
01316 
01317 
01318 Buffer  get_json_val(tJson* json)
01319 {
01320     Buffer val = init_Buffer();
01321 
01322     if (json!=NULL) {
01323         char* pp = (char*)json->ldat.val.buf;
01324         if ((*pp=='\"') || (*pp=='\'')) {
01325             val = set_Buffer(pp+1, strlen(pp)-1);
01326             val.buf[val.vldsz-1] = '\0';
01327             val.vldsz = (int)strlen((const char*)val.buf);
01328         }
01329         else {
01330             val = set_Buffer(pp, strlen(pp));
01331         }
01332     }
01333     return val;
01334 }
01335 
01336 
01337 
01350 Buffer  get_key_json_val(tJson* pp, char* key, int nn)
01351 {
01352     tJson* json = search_key_json(pp, key, TRUE, nn);
01353     Buffer val  = get_json_val(json);
01354 
01355     return val;
01356 }
01357 
01358 
01359 
01372 Buffer  get_key_sister_json_val(tJson* pp, char* key)
01373 {
01374     tJson* json = search_key_sister_json(pp, key, TRUE);
01375     Buffer val  = get_json_val(json);
01376 
01377     return val;
01378 }
01379 
01380 
01381 
01393 Buffer  get_double_key_json_val(tJson* pp, char* key1, char* key2)
01394 {
01395     tJson* json = search_double_key_json(pp, key1, key2, TRUE);
01396     Buffer val  = get_json_val(json);
01397 
01398     return val;
01399 }
01400 
01401 
01402 
01403 
01410 Buffer  get_Buffer_from_json(tJson* json)
01411 {
01412     Buffer buf = init_Buffer();
01413 
01414     if (json==NULL) return buf;
01415 
01416     char* pp = (char*)json->ldat.val.buf;
01417 
01418     if (pp!=NULL && json->ldat.lv!=JSON_VALUE_ARRAY) {
01419         if (*pp=='\"' || *pp=='\'') {
01420             char* pt = (char*)&(json->ldat.val.buf[json->ldat.val.vldsz-1]);
01421             if (*pp==*pt) {
01422                 pp++;
01423                 char bkup = *pt;
01424                 *pt = '\0';
01425                 buf = make_Buffer_str(pp);
01426                 *pt = bkup;
01427             }
01428         }
01429         else {
01430             buf = make_Buffer_str(pp);
01431         }
01432     }
01433 
01434     return buf;
01435 }
01436 
01437 
01438 
01446 char*  get_string_from_json(tJson* json)
01447 {
01448     if (json==NULL) return NULL;
01449 
01450     char* str = NULL;
01451     char* pp  = (char*)json->ldat.val.buf;
01452 
01453     if (pp!=NULL) {
01454         if (json->ldat.lv!=JSON_VALUE_ARRAY) {
01455             if (*pp=='\"' || *pp=='\'') {
01456                 char* pt = (char*)&(json->ldat.val.buf[json->ldat.val.vldsz-1]);
01457                 if (*pp==*pt) {
01458                     pp++;
01459                     char bkup = *pt;
01460                     *pt = '\0';
01461                     str = dup_str(pp);
01462                     *pt = bkup;
01463                 }
01464             }
01465         }
01466         if (str==NULL) str = dup_str(pp);
01467     }
01468 
01469 
01470     return str;
01471 }
01472