src/libopensrf/osrf_json_parser.c

   1 /*
   2 Copyright (C) 2006  Georgia Public Library Service
   3 Bill Erickson <billserickson@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14 */
  15
  16 #include <opensrf/osrf_json.h>
  17 #include <opensrf/osrf_json_utils.h>
  18 #include <ctype.h>
  19
  20
  21 /* if the client sets a global error handler, this will point to it */
  22 static void (*jsonClientErrorCallback) (const char*) = NULL;
  23
  24 /* these are the handlers for our internal parser */
  25 static const jsonParserHandler jsonInternalParserHandler = {
  26         _jsonHandleStartObject,
  27         _jsonHandleObjectKey,
  28         _jsonHandleEndObject,
  29         _jsonHandleStartArray,
  30         _jsonHandleEndArray,
  31         _jsonHandleNull,
  32         _jsonHandleString,
  33         _jsonHandleBool,
  34         _jsonHandleNumber,
  35         _jsonHandleError
  36 };
  37
  38 static jsonParserContext staticContext;
  39 static int staticContextInUse = 0;       // boolean
  40
  41 static jsonInternalParser staticParser;
  42 static int staticParserInUse = 0;        // boolean
  43
  44 jsonParserContext* jsonNewParser( const jsonParserHandler* handler, void* userData) {
  45         jsonParserContext* ctx;
  46
  47         // Use the static instance of jsonParserContext,
  48         // if it's available
  49
  50         if( staticContextInUse )
  51                 OSRF_MALLOC(ctx, sizeof(jsonParserContext));
  52         else {
  53                 ctx = &staticContext;
  54                 staticContextInUse = 1;
  55         }
  56
  57         ctx->stateStack                 = osrfNewList();
  58         ctx->buffer                                     = buffer_init(512);
  59         ctx->utfbuf                                     = buffer_init(5);
  60         ctx->handler                            = handler;
  61         ctx->state                                      = 0;
  62         ctx->index                                      = 0;
  63         ctx->chunksize                          = 0;
  64         ctx->flags                                      = 0;
  65         ctx->chunk                                      = NULL;
  66         ctx->userData                           = userData;
  67         return ctx;
  68 }
  69
  70 void jsonParserFree( jsonParserContext* ctx ) {
  71         if(!ctx) return;
  72         buffer_free(ctx->buffer);
  73         buffer_free(ctx->utfbuf);
  74         osrfListFree(ctx->stateStack);
  75
  76         // if the jsonParserContext was allocated
  77         // dynamically, then free it
  78
  79         if( &staticContext == ctx )
  80                 staticContextInUse = 0;
  81         else
  82                 free(ctx);
  83 }
  84
  85
  86 void jsonSetGlobalErrorHandler(void (*errorHandler) (const char*)) {
  87         jsonClientErrorCallback = errorHandler;
  88 }
  89
  90
  91 int _jsonParserError( jsonParserContext* ctx, char* err, ... ) {
  92         if( ctx->handler->handleError ) {
  93                 VA_LIST_TO_STRING(err);
  94                 int pre = ctx->index - 15;
  95                 int post= ctx->index + 15;
  96                 while( pre < 0 ) pre++;
  97                 while( post >= ctx->chunksize ) post--;
  98                 int l = post - pre;
  99                 char buf[l];
 100                 snprintf(buf, sizeof(buf), ctx->chunk + pre);
 101                 ctx->handler->handleError( ctx->userData,
 102                         "*JSON Parser Error\n - char  = %c\n "
 103                         "- index = %d\n - near  => %s\n - %s",
 104                         ctx->chunk[ctx->index], ctx->index, buf, VA_BUF );
 105         }
 106         JSON_STATE_SET(ctx, JSON_STATE_IS_INVALID);
 107         return -1;
 108 }
 109
 110
 111 int _jsonParserHandleUnicode( jsonParserContext* ctx ) {
 112
 113         /* collect as many of the utf characters as we can in this chunk */
 114         JSON_CACHE_DATA(ctx, ctx->utfbuf, 4);
 115
 116         /* we ran off the end of the chunk */
 117         if( ctx->utfbuf->n_used < 4 ) {
 118                 JSON_STATE_SET(ctx, JSON_STATE_IN_UTF);
 119                 return 1;
 120         }
 121
 122         ctx->index--; /* push it back to index of the final utf char */
 123
 124         /* ----------------------------------------------------------------------- */
 125         /* We have all of the escaped unicode data.  Write it to the buffer */
 126         /* The following chunk is used with permission from
 127          * json-c http://oss.metaparadigm.com/json-c/
 128          */
 129         #define hexdigit(x) ( ((x) <= '9') ? (x) - '0' : ((x) & 7) + 9)
 130         unsigned char utf_out[4];
 131         memset(utf_out, 0, sizeof(utf_out));
 132         char* buf = ctx->utfbuf->buf;
 133
 134         unsigned int ucs_char =
 135                 (hexdigit(buf[0] ) << 12) +
 136                 (hexdigit(buf[1]) << 8) +
 137                 (hexdigit(buf[2]) << 4) +
 138                 hexdigit(buf[3]);
 139
 140         if (ucs_char < 0x80) {
 141                 utf_out[0] = ucs_char;
 142                 OSRF_BUFFER_ADD(ctx->buffer, (char*)utf_out);
 143
 144         } else if (ucs_char < 0x800) {
 145                 utf_out[0] = 0xc0 | (ucs_char >> 6);
 146                 utf_out[1] = 0x80 | (ucs_char & 0x3f);
 147                 OSRF_BUFFER_ADD(ctx->buffer, (char*)utf_out);
 148
 149         } else {
 150                 utf_out[0] = 0xe0 | (ucs_char >> 12);
 151                 utf_out[1] = 0x80 | ((ucs_char >> 6) & 0x3f);
 152                 utf_out[2] = 0x80 | (ucs_char & 0x3f);
 153                 OSRF_BUFFER_ADD(ctx->buffer, (char*)utf_out);
 154         }
 155         /* ----------------------------------------------------------------------- */
 156         /* ----------------------------------------------------------------------- */
 157
 158         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_UTF);
 159         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_ESCAPE);
 160         OSRF_BUFFER_RESET(ctx->utfbuf);
 161         return 0;
 162 }
 163
 164
 165
 166 /* type : 0=null, 1=true, 2=false */
 167 int _jsonParserHandleMatch( jsonParserContext* ctx, int type ) {
 168
 169         switch(type) {
 170
 171                 case 0: /* JSON null */
 172
 173                         /* first see if we have it all first */
 174                         if( ctx->chunksize > (ctx->index + 3) ) {
 175                                 if( strncasecmp(ctx->chunk + ctx->index, "null", 4) )
 176                                         return _jsonParserError(ctx, "Invalid JSON 'null' sequence");
 177                                 if( ctx->handler->handleNull )
 178                                         ctx->handler->handleNull(ctx->userData);
 179                                 ctx->index += 4;
 180                                 break;
 181                         }
 182
 183                         JSON_CACHE_DATA(ctx, ctx->buffer, 4);
 184                         if( ctx->buffer->n_used < 4 ) {
 185                                 JSON_STATE_SET(ctx, JSON_STATE_IN_NULL);
 186                                 return 1;
 187                         }
 188
 189                         if( strncasecmp(ctx->buffer->buf, "null", 4) )
 190                                 return _jsonParserError(ctx, "Invalid JSON 'null' sequence");
 191                         if( ctx->handler->handleNull )
 192                                 ctx->handler->handleNull(ctx->userData);
 193                         break;
 194
 195                 case 1: /* JSON true */
 196
 197                         /* see if we have it all first */
 198                         if( ctx->chunksize > (ctx->index + 3) ) {
 199                                 if( strncasecmp(ctx->chunk + ctx->index, "true", 4) )
 200                                         return _jsonParserError(ctx, "Invalid JSON 'true' sequence");
 201                                 if( ctx->handler->handleBool )
 202                                         ctx->handler->handleBool(ctx->userData, 1);
 203                                 ctx->index += 4;
 204                                 break;
 205                         }
 206
 207                         JSON_CACHE_DATA(ctx, ctx->buffer, 4);
 208                         if( ctx->buffer->n_used < 4 ) {
 209                                 JSON_STATE_SET(ctx, JSON_STATE_IN_TRUE);
 210                                 return 1;
 211                         }
 212                         if( strncasecmp( ctx->buffer->buf, "true", 4 ) ) {
 213                                 return _jsonParserError(ctx, "Invalid JSON 'true' sequence");
 214                         }
 215                         if( ctx->handler->handleBool )
 216                                 ctx->handler->handleBool(ctx->userData, 1);
 217                         break;
 218
 219                 case 2: /* JSON false */
 220
 221                         /* see if we have it all first */
 222                         if( ctx->chunksize > (ctx->index + 4) ) {
 223                                 if( strncasecmp(ctx->chunk + ctx->index, "false", 5) )
 224                                         return _jsonParserError(ctx, "Invalid JSON 'false' sequence");
 225                                 if( ctx->handler->handleBool )
 226                                         ctx->handler->handleBool(ctx->userData, 0);
 227                                 ctx->index += 5;
 228                                 break;
 229                         }
 230
 231                         JSON_CACHE_DATA(ctx, ctx->buffer, 5);
 232                         if( ctx->buffer->n_used < 5 ) {
 233                                 JSON_STATE_SET(ctx, JSON_STATE_IN_FALSE);
 234                                 return 1;
 235                         }
 236                         if( strncasecmp( ctx->buffer->buf, "false", 5 ) )
 237                                 return _jsonParserError(ctx, "Invalid JSON 'false' sequence");
 238                         if( ctx->handler->handleBool )
 239                                 ctx->handler->handleBool(ctx->userData, 0);
 240                         break;
 241
 242                 default:
 243                         fprintf(stderr, "Invalid type flag\n");
 244                         return -1;
 245
 246         }
 247
 248         ctx->index--; /* set it back to the index of the final sequence character */
 249         OSRF_BUFFER_RESET(ctx->buffer);
 250         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_NULL);
 251         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_TRUE);
 252         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_FALSE);
 253
 254         return 0;
 255 }
 256
 257
 258 int _jsonParserHandleString( jsonParserContext* ctx ) {
 259
 260         char c = ctx->chunk[ctx->index];
 261
 262         if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_ESCAPE) ) {
 263
 264                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_UTF) ) {
 265
 266                         return _jsonParserHandleUnicode( ctx );
 267
 268                 } else {
 269
 270                         switch(c) {
 271
 272                                 /* handle all of the escape chars */
 273                                 case '\\': OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\\' ); break;
 274                                 case '"'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\"' ); break;
 275                                 case 't'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\t' ); break;
 276                                 case 'b'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\b' ); break;
 277                                 case 'f'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\f' ); break;
 278                                 case 'r'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\r' ); break;
 279                                 case 'n'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\n' ); break;
 280                                 case 'u'        :
 281                                         ctx->index++; /* progress to the first utf char */
 282                                         return _jsonParserHandleUnicode( ctx );
 283                                 default : OSRF_BUFFER_ADD_CHAR( ctx->buffer, c );
 284                         }
 285                 }
 286
 287                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_ESCAPE);
 288                 return 0;
 289
 290         } else {
 291
 292                 switch(c) {
 293
 294                         case '"'        : /* this string is ending */
 295                                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_KEY) ) {
 296
 297                                         /* object key */
 298                                         if(ctx->handler->handleObjectKey) {
 299                                                 ctx->handler->handleObjectKey(
 300                                                         ctx->userData, ctx->buffer->buf);
 301                                         }
 302
 303                                 } else { /* regular json string */
 304
 305                                         if(ctx->handler->handleString) {
 306                                                 ctx->handler->handleString(
 307                                                         ctx->userData, ctx->buffer->buf );
 308                                         }
 309
 310                                 }
 311
 312                                 OSRF_BUFFER_RESET(ctx->buffer); /* flush the buffer and states */
 313                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_STRING);
 314                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_KEY);
 315                                 break;
 316
 317                         case '\\' : JSON_STATE_SET(ctx, JSON_STATE_IN_ESCAPE); break;
 318                         default  : OSRF_BUFFER_ADD_CHAR( ctx->buffer, c );
 319                 }
 320         }
 321         return 0;
 322 }
 323
 324
 325 int _jsonParserHandleNumber( jsonParserContext* ctx ) {
 326         char c = ctx->chunk[ctx->index];
 327
 328         do {
 329                 OSRF_BUFFER_ADD_CHAR(ctx->buffer, c);
 330                 c = ctx->chunk[++(ctx->index)];
 331         } while( strchr(JSON_NUMBER_CHARS, c) && ctx->index < ctx->chunksize );
 332
 333         /* if we're run off the end of the chunk and we're not parsing the last chunk,
 334          * save the number and the state */
 335         if( ctx->index >= ctx->chunksize &&
 336                         ! JSON_PARSE_FLAG_CHECK(ctx, JSON_PARSE_LAST_CHUNK) ) {
 337                 JSON_STATE_SET(ctx, JSON_STATE_IN_NUMBER);
 338                 return 1;
 339         }
 340
 341         /* make me more strict */
 342         char* err = NULL;
 343         double d = strtod(ctx->buffer->buf, &err);
 344         if(err && err[0] != '\0')
 345                 return _jsonParserError(ctx, "Invalid number sequence");
 346         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_NUMBER);
 347         OSRF_BUFFER_RESET(ctx->buffer);
 348         if(ctx->handler->handleNumber)
 349                 ctx->handler->handleNumber( ctx->userData, d );
 350         ctx->index--; /* scooch back to the first non-digit number */
 351         return 0;
 352 }
 353
 354
 355
 356
 357 int jsonParseChunk( jsonParserContext* ctx, const char* data, int datalen, int flags ) {
 358
 359         if( !( ctx && ctx->handler && data && datalen > 0 )) return -1;
 360         ctx->chunksize  = datalen;
 361         ctx->chunk              = data;
 362         ctx->flags              = flags;
 363         char c;
 364
 365         if( JSON_STATE_CHECK(ctx, JSON_STATE_IS_INVALID) )
 366                 return _jsonParserError( ctx, "JSON Parser cannot continue after an error" );
 367
 368         if( JSON_STATE_CHECK(ctx, JSON_STATE_IS_DONE) )
 369                 return _jsonParserError( ctx, "Extra content at end of JSON data" );
 370
 371         for( ctx->index = 0; (ctx->index < ctx->chunksize) &&
 372                                 (c = ctx->chunk[ctx->index]); ctx->index++ ) {
 373
 374                 /* middle of parsing a string */
 375                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_STRING)) {
 376                         if( _jsonParserHandleString(ctx) == -1 )
 377                                 return -1;
 378                         continue;
 379                 }
 380
 381                 /* middle of parsing a number */
 382                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_NUMBER) ) {
 383                         if( _jsonParserHandleNumber(ctx) == -1 )
 384                                 return -1;
 385                         continue;
 386                 }
 387
 388
 389 #ifdef OSRF_JSON_ALLOW_COMMENTS
 390                 /* we just saw a bare '/' character */
 391                 if( JSON_STATE_CHECK(ctx, JSON_STATE_START_COMMENT) ) {
 392                         if(c == '*') {
 393                                 JSON_STATE_REMOVE(ctx, JSON_STATE_START_COMMENT);
 394                                 JSON_STATE_SET(ctx, JSON_STATE_IN_COMMENT);
 395                                 continue;
 396                         } else {
 397                                 return _jsonParserError( ctx, "Invalid comment initializer" );
 398                         }
 399                 }
 400
 401                 /* we're currently in the middle of a comment block */
 402                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_COMMENT) ) {
 403                         if(c == '*') {
 404                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_COMMENT);
 405                                 JSON_STATE_SET(ctx, JSON_STATE_END_COMMENT);
 406                                 continue;
 407                         } else {
 408                                 continue;
 409                         }
 410                 }
 411
 412                 /* we're in a comment, and we just saw a '*' character */
 413                 if( JSON_STATE_CHECK(ctx, JSON_STATE_END_COMMENT) ) {
 414                         if( c == '/' ) { /* comment is finished */
 415                                 JSON_STATE_REMOVE(ctx, JSON_STATE_END_COMMENT);
 416                                 continue;
 417                         } else {
 418                                 /* looks like this isn't the end of the comment after all */
 419                                 JSON_STATE_SET(ctx, JSON_STATE_IN_COMMENT);
 420                                 JSON_STATE_REMOVE(ctx, JSON_STATE_END_COMMENT);
 421                         }
 422                 }
 423 #endif
 424
 425                 /* if we're in the middle of parsing a null/true/false sequence */
 426                 if( JSON_STATE_CHECK(ctx, (JSON_STATE_IN_NULL |
 427                                         JSON_STATE_IN_TRUE | JSON_STATE_IN_FALSE)) ) {
 428
 429                         int type = (JSON_STATE_CHECK(ctx, JSON_STATE_IN_NULL)) ? 0 :
 430                                 (JSON_STATE_CHECK(ctx, JSON_STATE_IN_TRUE)) ? 1 : 2;
 431
 432                         if( _jsonParserHandleMatch( ctx, type ) == -1 )
 433                                 return -1;
 434                         continue;
 435                 }
 436
 437                 JSON_EAT_WS(ctx);
 438
 439                 /* handle all of the top level characters */
 440                 switch(c) {
 441
 442                         case '{' : /* starting an object */
 443                                 if( ctx->handler->handleStartObject)
 444                                         ctx->handler->handleStartObject( ctx->userData );
 445                                 JSON_STATE_PUSH(ctx, JSON_STATE_IN_OBJECT);
 446                                 JSON_STATE_SET(ctx, JSON_STATE_IN_KEY);
 447                                 break;
 448
 449                         case '}' : /* ending an object */
 450                                 if( ctx->handler->handleEndObject)
 451                                         ctx->handler->handleEndObject( ctx->userData );
 452                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_KEY);
 453                                 JSON_STATE_POP(ctx);
 454                                 if( JSON_STATE_PEEK(ctx) == NULL )
 455                                         JSON_STATE_SET(ctx, JSON_STATE_IS_DONE);
 456                                 break;
 457
 458                         case '[' : /* starting an array */
 459                                 if( ctx->handler->handleStartArray )
 460                                         ctx->handler->handleStartArray( ctx->userData );
 461                                 JSON_STATE_PUSH(ctx, JSON_STATE_IN_ARRAY);
 462                                 break;
 463
 464                         case ']': /* ending an array */
 465                                 if( ctx->handler->handleEndArray )
 466                                         ctx->handler->handleEndArray( ctx->userData );
 467                                 JSON_STATE_POP(ctx);
 468                                 if( JSON_STATE_PEEK(ctx) == NULL )
 469                                         JSON_STATE_SET(ctx, JSON_STATE_IS_DONE);
 470                                 break;
 471
 472                         case ':' : /* done with the object key */
 473                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_KEY);
 474                                 break;
 475
 476                         case ',' : /* after object or array item */
 477                                 if( JSON_STATE_CHECK_STACK(ctx, JSON_STATE_IN_OBJECT) )
 478                                         JSON_STATE_SET(ctx, JSON_STATE_IN_KEY);
 479                                 break;
 480
 481                         case 'n' :
 482                         case 'N' : /* null */
 483                                 if( _jsonParserHandleMatch( ctx, 0 ) == -1)
 484                                         return -1;
 485                                 break;
 486
 487                         case 't' :
 488                         case 'T' :
 489                                 if( _jsonParserHandleMatch( ctx, 1 ) == -1 )
 490                                         return -1;
 491                                 break;
 492
 493                         case 'f' :
 494                         case 'F' :
 495                                 if( _jsonParserHandleMatch( ctx, 2 ) == -1)
 496                                         return -1;
 497                                 break;
 498
 499                         case '"' :
 500                                 JSON_STATE_SET(ctx, JSON_STATE_IN_STRING);
 501                                 break;
 502
 503 #ifdef OSRF_JSON_ALLOW_COMMENTS
 504                         case '/' :
 505                                 JSON_STATE_SET(ctx, JSON_STATE_START_COMMENT);
 506                                 break;
 507 #endif
 508
 509                         default:
 510                                 if( strchr(JSON_NUMBER_CHARS, c) ) {
 511                                         if( _jsonParserHandleNumber( ctx ) == -1 )
 512                                                 return -1;
 513                                 } else {
 514                                         return _jsonParserError( ctx, "Invalid Token" );
 515                                 }
 516                 }
 517         }
 518
 519         return 0;
 520 }
 521
 522
 523 jsonInternalParser* _jsonNewInternalParser() {
 524         jsonInternalParser* p;
 525
 526         // Use the static instance of jsonInternalParser,
 527         // if it's available
 528
 529         if( staticParserInUse )
 530                 OSRF_MALLOC(p, sizeof(jsonInternalParser));
 531         else {
 532                 p = &staticParser;
 533                 staticParserInUse = 1;
 534         }
 535
 536         p->ctx = jsonNewParser( &jsonInternalParserHandler, p );
 537         p->obj          = NULL;
 538         p->current  = NULL;
 539         p->lastkey      = NULL;
 540         p->handleError = NULL;
 541         return p;
 542 }
 543
 544 void _jsonInternalParserFree(jsonInternalParser* p) {
 545         if(!p) return;
 546         jsonParserFree(p->ctx);
 547         free(p->lastkey);
 548
 549         // if the jsonInternalParser was allocated
 550         // dynamically, then free it
 551
 552         if( &staticParser == p )
 553                 staticParserInUse = 0;
 554         else
 555                 free(p);
 556 }
 557
 558 static jsonObject* _jsonParseStringImpl(const char* str, void (*errorHandler) (const char*) ) {
 559         jsonInternalParser* parser = _jsonNewInternalParser();
 560         parser->handleError = errorHandler;
 561         jsonParseChunk( parser->ctx, str, strlen(str),  JSON_PARSE_LAST_CHUNK );
 562         jsonObject* obj = parser->obj;
 563         _jsonInternalParserFree(parser);
 564         return obj;
 565 }
 566
 567 jsonObject* jsonParseStringHandleError(
 568                 void (*errorHandler) (const char*), char* str, ... ) {
 569         if(!str) return NULL;
 570         VA_LIST_TO_STRING(str);
 571         return _jsonParseStringImpl(VA_BUF, errorHandler);
 572 }
 573
 574 jsonObject* jsonParseString( const char* str ) {
 575         if(!str) return NULL;
 576         jsonObject* obj =  _jsonParseStringImpl(str, NULL);
 577         jsonObject* obj2 = jsonObjectDecodeClass(obj);
 578         jsonObjectFree(obj);
 579         return obj2;
 580 }
 581
 582 jsonObject* jsonParseStringRaw( const char* str ) {
 583         if(!str) return NULL;
 584         return _jsonParseStringImpl(str, NULL);
 585 }
 586
 587 jsonObject* jsonParseStringFmt( const char* str, ... ) {
 588         if(!str) return NULL;
 589         VA_LIST_TO_STRING(str);
 590         return _jsonParseStringImpl(VA_BUF, NULL);
 591 }
 592
 593
 594 #define JSON_SHOVE_ITEM(ctx,type)  \
 595         jsonInternalParser* p = (jsonInternalParser*) ctx;\
 596         _jsonInsertParserItem(p, jsonNewObjectType(type));
 597
 598 void _jsonHandleStartObject(void* ctx) { JSON_SHOVE_ITEM(ctx, JSON_HASH); }
 599 void _jsonHandleStartArray(void* ctx) { JSON_SHOVE_ITEM(ctx, JSON_ARRAY); }
 600 void _jsonHandleNull(void* ctx) { JSON_SHOVE_ITEM(ctx, JSON_NULL); }
 601
 602 void _jsonHandleObjectKey(void* ctx, char* key) {
 603         jsonInternalParser* p = (jsonInternalParser*) ctx;
 604         free(p->lastkey);
 605         p->lastkey = strdup(key);
 606 }
 607
 608 void _jsonHandleEndObject(void* ctx) {
 609         jsonInternalParser* p = (jsonInternalParser*) ctx;
 610         p->current = p->current->parent;
 611 }
 612
 613 void _jsonHandleEndArray(void* ctx) {
 614         jsonInternalParser* p = (jsonInternalParser*) ctx;
 615         p->current = p->current->parent;
 616 }
 617
 618 void _jsonHandleString(void* ctx, char* string) {
 619         jsonInternalParser* p = (jsonInternalParser*) ctx;
 620         _jsonInsertParserItem(p, jsonNewObject(string));
 621 }
 622
 623 void _jsonHandleBool(void* ctx, int boolval) {
 624         jsonInternalParser* p = (jsonInternalParser*) ctx;
 625         jsonObject* obj = jsonNewObjectType(JSON_BOOL);
 626         obj->value.b = boolval;
 627         _jsonInsertParserItem(p, obj);
 628 }
 629
 630 void _jsonHandleNumber(void* ctx, double num) {
 631         jsonInternalParser* p = (jsonInternalParser*) ctx;
 632         _jsonInsertParserItem(p, jsonNewNumberObject(num));
 633 }
 634
 635 void _jsonHandleError(void* ctx, char* str, ...) {
 636         jsonInternalParser* p = (jsonInternalParser*) ctx;
 637         VA_LIST_TO_STRING(str);
 638
 639         if( p->handleError )
 640                 p->handleError(VA_BUF);
 641         else
 642                 if( jsonClientErrorCallback )
 643                         jsonClientErrorCallback(VA_BUF);
 644
 645         else fprintf(stderr, "%s\n", VA_BUF);
 646         jsonObjectFree(p->obj);
 647         p->obj = NULL;
 648 }
 649
 650
 651 void _jsonInsertParserItem( jsonInternalParser* p, jsonObject* newo ) {
 652
 653         if( !p->obj ) {
 654
 655                 /* new parser, set the new object to our object */
 656                 p->obj = p->current = newo;
 657
 658         } else {
 659
 660                 /* insert the new object into the current container object */
 661                 switch(p->current->type) {
 662                         case JSON_HASH  : jsonObjectSetKey(p->current, p->lastkey, newo);  break;
 663                         case JSON_ARRAY: jsonObjectPush(p->current, newo); break;
 664                         default: fprintf(stderr, "%s:%d -> how?\n", JSON_LOG_MARK);
 665                 }
 666
 667                 /* if the new object is a container object, make it our current container */
 668                 if( newo->type == JSON_ARRAY || newo->type == JSON_HASH )
 669                         p->current = newo;
 670         }
 671 }
 672
 673