Patch from Scott McKellar:
[OpenSRF.git] / 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
95                 // Determine the beginning and ending points of a JSON
96                 // fragment to display, from the vicinity of the error
97
98                 int pre = ctx->index - 15;
99                 if( pre < 0 ) pre = 0;
100                 int post= ctx->index + 15;
101                 if( post >= ctx->chunksize ) post = ctx->chunksize - 1;
102
103                 // Copy the fragment into a buffer
104                 
105                 int len = post - pre + 1;  // length of fragment
106                 char buf[len + 1];
107                 memcpy( buf, ctx->chunk + pre, len );
108                 buf[ len ] = '\0';
109
110                 // Issue an error message
111
112                 ctx->handler->handleError( ctx->userData,
113                         "*JSON Parser Error\n - char  = %c\n "
114                         "- index = %d\n - near  => %s\n - %s", 
115                         ctx->chunk[ctx->index], ctx->index, buf, VA_BUF );
116         }
117         JSON_STATE_SET(ctx, JSON_STATE_IS_INVALID);
118         return -1;
119 }
120
121
122 int _jsonParserHandleUnicode( jsonParserContext* ctx ) {
123
124         /* collect as many of the utf characters as we can in this chunk */
125         JSON_CACHE_DATA(ctx, ctx->utfbuf, 4);
126
127         /* we ran off the end of the chunk */
128         if( ctx->utfbuf->n_used < 4 ) {
129                 JSON_STATE_SET(ctx, JSON_STATE_IN_UTF);
130                 return 1;
131         }
132
133         ctx->index--; /* push it back to index of the final utf char */
134
135         /* ----------------------------------------------------------------------- */
136         /* We have all of the escaped unicode data.  Write it to the buffer */
137         /* The following chunk is used with permission from 
138          * json-c http://oss.metaparadigm.com/json-c/ 
139          */
140         #define hexdigit(x) ( ((x) <= '9') ? (x) - '0' : ((x) & 7) + 9)
141         unsigned char utf_out[4];
142         memset(utf_out, 0, sizeof(utf_out));
143         char* buf = ctx->utfbuf->buf;
144
145         unsigned int ucs_char =
146                 (hexdigit(buf[0] ) << 12) +
147                 (hexdigit(buf[1]) << 8) +
148                 (hexdigit(buf[2]) << 4) +
149                 hexdigit(buf[3]);
150
151         if (ucs_char < 0x80) {
152                 utf_out[0] = ucs_char;
153                 OSRF_BUFFER_ADD(ctx->buffer, (char*)utf_out);
154
155         } else if (ucs_char < 0x800) {
156                 utf_out[0] = 0xc0 | (ucs_char >> 6);
157                 utf_out[1] = 0x80 | (ucs_char & 0x3f);
158                 OSRF_BUFFER_ADD(ctx->buffer, (char*)utf_out);
159
160         } else {
161                 utf_out[0] = 0xe0 | (ucs_char >> 12);
162                 utf_out[1] = 0x80 | ((ucs_char >> 6) & 0x3f);
163                 utf_out[2] = 0x80 | (ucs_char & 0x3f);
164                 OSRF_BUFFER_ADD(ctx->buffer, (char*)utf_out);
165         }
166         /* ----------------------------------------------------------------------- */
167         /* ----------------------------------------------------------------------- */
168
169         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_UTF);
170         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_ESCAPE);
171         OSRF_BUFFER_RESET(ctx->utfbuf);
172         return 0;
173 }
174
175
176
177 /* type : 0=null, 1=true, 2=false */
178 int _jsonParserHandleMatch( jsonParserContext* ctx, int type ) {
179
180         switch(type) {
181
182                 case 0: /* JSON null */
183
184                         /* first see if we have it all first */
185                         if( ctx->chunksize > (ctx->index + 3) ) {
186                                 if( strncasecmp(ctx->chunk + ctx->index, "null", 4) ) 
187                                         return _jsonParserError(ctx, "Invalid JSON 'null' sequence");
188                                 if( ctx->handler->handleNull ) 
189                                         ctx->handler->handleNull(ctx->userData);
190                                 ctx->index += 4;
191                                 break;
192                         }
193
194                         JSON_CACHE_DATA(ctx, ctx->buffer, 4);
195                         if( ctx->buffer->n_used < 4 ) {
196                                 JSON_STATE_SET(ctx, JSON_STATE_IN_NULL);
197                                 return 1;
198                         } 
199
200                         if( strncasecmp(ctx->buffer->buf, "null", 4) ) 
201                                 return _jsonParserError(ctx, "Invalid JSON 'null' sequence");
202                         if( ctx->handler->handleNull ) 
203                                 ctx->handler->handleNull(ctx->userData);
204                         break;
205
206                 case 1: /* JSON true */
207
208                         /* see if we have it all first */
209                         if( ctx->chunksize > (ctx->index + 3) ) {
210                                 if( strncasecmp(ctx->chunk + ctx->index, "true", 4) ) 
211                                         return _jsonParserError(ctx, "Invalid JSON 'true' sequence");
212                                 if( ctx->handler->handleBool ) 
213                                         ctx->handler->handleBool(ctx->userData, 1);
214                                 ctx->index += 4;
215                                 break;
216                         }
217
218                         JSON_CACHE_DATA(ctx, ctx->buffer, 4);
219                         if( ctx->buffer->n_used < 4 ) {
220                                 JSON_STATE_SET(ctx, JSON_STATE_IN_TRUE);
221                                 return 1;
222                         } 
223                         if( strncasecmp( ctx->buffer->buf, "true", 4 ) ) {
224                                 return _jsonParserError(ctx, "Invalid JSON 'true' sequence");
225                         }
226                         if( ctx->handler->handleBool ) 
227                                 ctx->handler->handleBool(ctx->userData, 1);
228                         break;
229
230                 case 2: /* JSON false */
231
232                         /* see if we have it all first */
233                         if( ctx->chunksize > (ctx->index + 4) ) {
234                                 if( strncasecmp(ctx->chunk + ctx->index, "false", 5) ) 
235                                         return _jsonParserError(ctx, "Invalid JSON 'false' sequence");
236                                 if( ctx->handler->handleBool ) 
237                                         ctx->handler->handleBool(ctx->userData, 0);
238                                 ctx->index += 5;
239                                 break;
240                         }
241
242                         JSON_CACHE_DATA(ctx, ctx->buffer, 5);
243                         if( ctx->buffer->n_used < 5 ) {
244                                 JSON_STATE_SET(ctx, JSON_STATE_IN_FALSE);
245                                 return 1;
246                         }
247                         if( strncasecmp( ctx->buffer->buf, "false", 5 ) ) 
248                                 return _jsonParserError(ctx, "Invalid JSON 'false' sequence");
249                         if( ctx->handler->handleBool ) 
250                                 ctx->handler->handleBool(ctx->userData, 0);
251                         break;
252
253                 default: 
254                         fprintf(stderr, "Invalid type flag\n");
255                         return -1;
256
257         }
258
259         ctx->index--; /* set it back to the index of the final sequence character */
260         OSRF_BUFFER_RESET(ctx->buffer);
261         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_NULL);
262         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_TRUE);
263         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_FALSE);
264
265         return 0;
266 }
267
268
269 int _jsonParserHandleString( jsonParserContext* ctx ) {
270
271         char c = ctx->chunk[ctx->index];
272
273         if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_ESCAPE) ) {
274
275                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_UTF) ) {
276
277                         return _jsonParserHandleUnicode( ctx );
278                                                 
279                 } else {
280
281                         switch(c) {
282
283                                 /* handle all of the escape chars */
284                                 case '\\': OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\\' ); break;
285                                 case '"'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\"' ); break;
286                                 case 't'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\t' ); break;
287                                 case 'b'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\b' ); break;
288                                 case 'f'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\f' ); break;
289                                 case 'r'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\r' ); break;
290                                 case 'n'        : OSRF_BUFFER_ADD_CHAR( ctx->buffer, '\n' ); break;
291                                 case 'u'        : 
292                                         ctx->index++; /* progress to the first utf char */
293                                         return _jsonParserHandleUnicode( ctx );
294                                 default : OSRF_BUFFER_ADD_CHAR( ctx->buffer, c );
295                         }
296                 }
297
298                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_ESCAPE);
299                 return 0;
300
301         } else {
302
303                 switch(c) {
304
305                         case '"'        : /* this string is ending */
306                                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_KEY) ) {
307
308                                         /* object key */
309                                         if(ctx->handler->handleObjectKey) {
310                                                 ctx->handler->handleObjectKey( 
311                                                         ctx->userData, ctx->buffer->buf);
312                                         }
313
314                                 } else { /* regular json string */
315
316                                         if(ctx->handler->handleString) {
317                                                 ctx->handler->handleString( 
318                                                         ctx->userData, ctx->buffer->buf );
319                                         }
320
321                                 }
322
323                                 OSRF_BUFFER_RESET(ctx->buffer); /* flush the buffer and states */
324                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_STRING);
325                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_KEY);
326                                 break;
327
328                         case '\\' : JSON_STATE_SET(ctx, JSON_STATE_IN_ESCAPE); break;
329                         default  : OSRF_BUFFER_ADD_CHAR( ctx->buffer, c );
330                 }
331         }
332         return 0;
333 }
334
335
336 int _jsonParserHandleNumber( jsonParserContext* ctx ) {
337         char c = ctx->chunk[ctx->index];
338
339         do {
340                 OSRF_BUFFER_ADD_CHAR(ctx->buffer, c);
341                 c = ctx->chunk[++(ctx->index)];
342         } while( strchr(JSON_NUMBER_CHARS, c) && ctx->index < ctx->chunksize );
343
344         /* if we're run off the end of the chunk and we're not parsing the last chunk,
345          * save the number and the state */
346         if( ctx->index >= ctx->chunksize && 
347                         ! JSON_PARSE_FLAG_CHECK(ctx, JSON_PARSE_LAST_CHUNK) ) {
348                 JSON_STATE_SET(ctx, JSON_STATE_IN_NUMBER);
349                 return 1;
350         }
351
352         if(ctx->handler->handleNumber)
353         {
354                 if( jsonIsNumeric( ctx->buffer->buf ) )
355                         ctx->handler->handleNumber( ctx->userData, ctx->buffer->buf );
356                 else {
357                         // The number string is not numeric according to JSON rules.
358                         // Scrub it into an acceptable format.
359
360                         char* scrubbed = jsonScrubNumber( ctx->buffer->buf );
361                         if( !scrubbed )
362                                 return _jsonParserError(ctx, "Invalid number sequence");
363                         else {
364                                 ctx->handler->handleNumber( ctx->userData, scrubbed );
365                                 free( scrubbed );
366                         }
367                 }
368         }
369         
370         ctx->index--; /* scooch back to the first non-digit number */
371         JSON_STATE_REMOVE(ctx, JSON_STATE_IN_NUMBER);
372         OSRF_BUFFER_RESET(ctx->buffer);
373         return 0;
374 }
375
376 int jsonParseChunk( jsonParserContext* ctx, const char* data, int datalen, int flags ) {
377
378         if( !( ctx && ctx->handler && data && datalen > 0 )) return -1;
379         ctx->chunksize  = datalen;
380         ctx->chunk              = data;
381         ctx->flags              = flags;
382         char c;
383
384         if( JSON_STATE_CHECK(ctx, JSON_STATE_IS_INVALID) )
385                 return _jsonParserError( ctx, "JSON Parser cannot continue after an error" );
386
387         if( JSON_STATE_CHECK(ctx, JSON_STATE_IS_DONE) )
388                 return _jsonParserError( ctx, "Extra content at end of JSON data" );
389
390         for( ctx->index = 0; (ctx->index < ctx->chunksize) && 
391                                 (c = ctx->chunk[ctx->index]); ctx->index++ ) {
392
393                 /* middle of parsing a string */
394                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_STRING)) {
395                         if( _jsonParserHandleString(ctx) == -1 )
396                                 return -1;
397                         continue;
398                 }
399
400                 /* middle of parsing a number */
401                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_NUMBER) ) {
402                         if( _jsonParserHandleNumber(ctx) == -1 )
403                                 return -1;
404                         continue;
405                 }
406
407
408 #ifdef OSRF_JSON_ALLOW_COMMENTS
409                 /* we just saw a bare '/' character */
410                 if( JSON_STATE_CHECK(ctx, JSON_STATE_START_COMMENT) ) {
411                         if(c == '*') {
412                                 JSON_STATE_REMOVE(ctx, JSON_STATE_START_COMMENT);
413                                 JSON_STATE_SET(ctx, JSON_STATE_IN_COMMENT);
414                                 continue;
415                         } else {
416                                 return _jsonParserError( ctx, "Invalid comment initializer" );
417                         }
418                 }
419
420                 /* we're currently in the middle of a comment block */
421                 if( JSON_STATE_CHECK(ctx, JSON_STATE_IN_COMMENT) ) {
422                         if(c == '*') {
423                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_COMMENT);
424                                 JSON_STATE_SET(ctx, JSON_STATE_END_COMMENT);
425                                 continue;
426                         } else {
427                                 continue;
428                         }
429                 }
430
431                 /* we're in a comment, and we just saw a '*' character */
432                 if( JSON_STATE_CHECK(ctx, JSON_STATE_END_COMMENT) ) {
433                         if( c == '/' ) { /* comment is finished */
434                                 JSON_STATE_REMOVE(ctx, JSON_STATE_END_COMMENT);
435                                 continue;
436                         } else {
437                                 /* looks like this isn't the end of the comment after all */
438                                 JSON_STATE_SET(ctx, JSON_STATE_IN_COMMENT);
439                                 JSON_STATE_REMOVE(ctx, JSON_STATE_END_COMMENT);
440                         }
441                 }
442 #endif
443
444                 /* if we're in the middle of parsing a null/true/false sequence */
445                 if( JSON_STATE_CHECK(ctx, (JSON_STATE_IN_NULL | 
446                                         JSON_STATE_IN_TRUE | JSON_STATE_IN_FALSE)) ) {
447
448                         int type = (JSON_STATE_CHECK(ctx, JSON_STATE_IN_NULL)) ? 0 :
449                                 (JSON_STATE_CHECK(ctx, JSON_STATE_IN_TRUE)) ? 1 : 2;
450
451                         if( _jsonParserHandleMatch( ctx, type ) == -1 ) 
452                                 return -1;
453                         continue;
454                 }
455
456                 JSON_EAT_WS(ctx);
457
458                 /* handle all of the top level characters */
459                 switch(c) {
460
461                         case '{' : /* starting an object */
462                                 if( ctx->handler->handleStartObject) 
463                                         ctx->handler->handleStartObject( ctx->userData );
464                                 JSON_STATE_PUSH(ctx, JSON_STATE_IN_OBJECT);
465                                 JSON_STATE_SET(ctx, JSON_STATE_IN_KEY);
466                                 break;
467
468                         case '}' : /* ending an object */
469                                 if( ctx->handler->handleEndObject) 
470                                         ctx->handler->handleEndObject( ctx->userData ); 
471                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_KEY);
472                                 JSON_STATE_POP(ctx);
473                                 if( JSON_STATE_PEEK(ctx) == NULL )
474                                         JSON_STATE_SET(ctx, JSON_STATE_IS_DONE);
475                                 break;
476
477                         case '[' : /* starting an array */
478                                 if( ctx->handler->handleStartArray )
479                                         ctx->handler->handleStartArray( ctx->userData );
480                                 JSON_STATE_PUSH(ctx, JSON_STATE_IN_ARRAY);
481                                 break;
482
483                         case ']': /* ending an array */
484                                 if( ctx->handler->handleEndArray )
485                                         ctx->handler->handleEndArray( ctx->userData );
486                                 JSON_STATE_POP(ctx);
487                                 if( JSON_STATE_PEEK(ctx) == NULL )
488                                         JSON_STATE_SET(ctx, JSON_STATE_IS_DONE);
489                                 break;
490                                 
491                         case ':' : /* done with the object key */
492                                 JSON_STATE_REMOVE(ctx, JSON_STATE_IN_KEY);
493                                 break;
494
495                         case ',' : /* after object or array item */
496                                 if( JSON_STATE_CHECK_STACK(ctx, JSON_STATE_IN_OBJECT) )
497                                         JSON_STATE_SET(ctx, JSON_STATE_IN_KEY);
498                                 break;
499
500                         case 'n' :
501                         case 'N' : /* null */
502                                 if( _jsonParserHandleMatch( ctx, 0 ) == -1)
503                                         return -1;
504                                 break;
505
506                         case 't' :
507                         case 'T' :
508                                 if( _jsonParserHandleMatch( ctx, 1 ) == -1 )
509                                         return -1;
510                                 break;
511
512                         case 'f' :
513                         case 'F' :
514                                 if( _jsonParserHandleMatch( ctx, 2 ) == -1)
515                                         return -1;
516                                 break;
517
518                         case '"' : 
519                                 JSON_STATE_SET(ctx, JSON_STATE_IN_STRING);
520                                 break;
521
522 #ifdef OSRF_JSON_ALLOW_COMMENTS
523                         case '/' :
524                                 JSON_STATE_SET(ctx, JSON_STATE_START_COMMENT);
525                                 break;
526 #endif
527
528                         default:
529                                 if( strchr(JSON_NUMBER_CHARS, c) ) {
530                                         if( _jsonParserHandleNumber( ctx ) == -1 )
531                                                 return -1;
532                                 } else {
533                                         return _jsonParserError( ctx, "Invalid Token" );
534                                 }
535                 }
536         }
537
538         return 0;
539 }
540
541
542 jsonInternalParser* _jsonNewInternalParser() {
543         jsonInternalParser* p;
544
545         // Use the static instance of jsonInternalParser,
546         // if it's available
547         
548         if( staticParserInUse )
549                 OSRF_MALLOC(p, sizeof(jsonInternalParser));
550         else {
551                 p = &staticParser;
552                 staticParserInUse = 1;
553         }
554
555         p->ctx = jsonNewParser( &jsonInternalParserHandler, p );
556         p->obj          = NULL;
557         p->current  = NULL;
558         p->lastkey      = NULL;
559         p->handleError = NULL;
560         return p;
561 }
562
563 void _jsonInternalParserFree(jsonInternalParser* p) {
564         if(!p) return;
565         jsonParserFree(p->ctx);
566         free(p->lastkey);
567
568         // if the jsonInternalParser was allocated
569         // dynamically, then free it
570         
571         if( &staticParser == p )
572                 staticParserInUse = 0;
573         else
574                 free(p);
575 }
576
577 static jsonObject* _jsonParseStringImpl(const char* str, void (*errorHandler) (const char*) ) {
578         jsonInternalParser* parser = _jsonNewInternalParser();
579         parser->handleError = errorHandler;
580         jsonParseChunk( parser->ctx, str, strlen(str),  JSON_PARSE_LAST_CHUNK );
581         jsonObject* obj = parser->obj;
582         _jsonInternalParserFree(parser);
583         return obj;
584 }
585
586 jsonObject* jsonParseStringHandleError( 
587                 void (*errorHandler) (const char*), char* str, ... ) {
588         if(!str) return NULL;
589         VA_LIST_TO_STRING(str);
590         return _jsonParseStringImpl(VA_BUF, errorHandler);
591 }
592
593 jsonObject* jsonParseString( const char* str ) {
594         if(!str) return NULL;
595         jsonObject* obj =  _jsonParseStringImpl(str, NULL);
596         jsonObject* obj2 = jsonObjectDecodeClass(obj);
597         jsonObjectFree(obj);
598         return obj2;
599 }
600
601 jsonObject* jsonParseStringRaw( const char* str ) {
602         if(!str) return NULL;
603         return _jsonParseStringImpl(str, NULL);
604 }
605
606 jsonObject* jsonParseStringFmt( const char* str, ... ) {
607         if(!str) return NULL;
608         VA_LIST_TO_STRING(str);
609         return _jsonParseStringImpl(VA_BUF, NULL);
610 }
611
612
613 #define JSON_SHOVE_ITEM(ctx,type)  \
614         jsonInternalParser* p = (jsonInternalParser*) ctx;\
615         _jsonInsertParserItem(p, jsonNewObjectType(type));
616
617 void _jsonHandleStartObject(void* ctx) { JSON_SHOVE_ITEM(ctx, JSON_HASH); }
618 void _jsonHandleStartArray(void* ctx) { JSON_SHOVE_ITEM(ctx, JSON_ARRAY); }
619 void _jsonHandleNull(void* ctx) { JSON_SHOVE_ITEM(ctx, JSON_NULL); }
620
621 void _jsonHandleObjectKey(void* ctx, char* key) {
622         jsonInternalParser* p = (jsonInternalParser*) ctx;
623         free(p->lastkey);
624         p->lastkey = strdup(key);
625 }
626
627 void _jsonHandleEndObject(void* ctx) {
628         jsonInternalParser* p = (jsonInternalParser*) ctx;
629         p->current = p->current->parent;
630 }
631
632 void _jsonHandleEndArray(void* ctx) {
633         jsonInternalParser* p = (jsonInternalParser*) ctx;
634         p->current = p->current->parent;
635 }
636
637 void _jsonHandleString(void* ctx, char* string) {
638         jsonInternalParser* p = (jsonInternalParser*) ctx;
639         _jsonInsertParserItem(p, jsonNewObject(string));
640 }
641
642 void _jsonHandleBool(void* ctx, int boolval) {
643         jsonInternalParser* p = (jsonInternalParser*) ctx;
644         jsonObject* obj = jsonNewObjectType(JSON_BOOL);
645         obj->value.b = boolval;
646         _jsonInsertParserItem(p, obj);
647 }
648
649 void _jsonHandleNumber(void* ctx, const char* numstr) {
650         jsonObject* obj = jsonNewNumberStringObject(numstr);
651         jsonInternalParser* p = (jsonInternalParser*) ctx;
652         _jsonInsertParserItem(p, obj);
653 }
654
655 void _jsonHandleError(void* ctx, char* str, ...) {
656         jsonInternalParser* p = (jsonInternalParser*) ctx;
657         VA_LIST_TO_STRING(str);
658
659         if( p->handleError ) 
660                 p->handleError(VA_BUF);
661         else 
662                 if( jsonClientErrorCallback ) 
663                         jsonClientErrorCallback(VA_BUF);
664
665         else fprintf(stderr, "%s\n", VA_BUF);
666         jsonObjectFree(p->obj);
667         p->obj = NULL;
668 }
669
670
671 void _jsonInsertParserItem( jsonInternalParser* p, jsonObject* newo ) {
672
673         if( !p->obj ) {
674
675                 /* new parser, set the new object to our object */
676                 p->obj = p->current = newo;
677
678         } else {
679
680                 /* insert the new object into the current container object */
681                 if(p->current->type == JSON_HASH)
682                         jsonObjectSetKey(p->current, p->lastkey, newo);
683                 else  // assume it's a JSON_ARRAY; if it isn't, it'll become one
684                         jsonObjectPush(p->current, newo);
685
686                 /* if the new object is a container object, make it our current container */
687                 if( newo->type == JSON_ARRAY || newo->type == JSON_HASH )
688                         p->current = newo;      
689         }
690 }
691
692