69b98672b9666c0cb573dea386ec486efd848f11
[OpenSRF.git] / src / libopensrf / osrf_legacy_json.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
17 #include <opensrf/osrf_legacy_json.h>
18
19 /* keep a copy of the length of the current json string so we don't 
20  * have to calculate it in each function
21  */
22 int current_strlen; 
23
24
25 jsonObject* legacy_jsonParseString( char* string) {
26         return json_parse_string( string );
27 }
28
29 jsonObject* legacy_jsonParseStringFmt( char* string, ... ) {
30         VA_LIST_TO_STRING(string);
31         return json_parse_string( VA_BUF );
32 }
33
34
35 jsonObject* json_parse_string(char* string) {
36
37         if(string == NULL) return NULL;
38
39         current_strlen = strlen(string);
40
41         if(current_strlen == 0) 
42                 return NULL;
43
44         unsigned long index = 0;
45
46         json_eat_ws(string, &index, 1, current_strlen); /* remove leading whitespace */
47         if(index == current_strlen) return NULL;
48
49         jsonObject* obj = jsonNewObject(NULL);
50
51         int status = _json_parse_string(string, &index, obj, current_strlen);
52         if(!status) return obj;
53
54         if(status == -2) {
55                 jsonObjectFree(obj);
56                 return NULL;
57         }
58
59         return NULL;
60 }
61
62
63 int _json_parse_string(char* string, unsigned long* index, jsonObject* obj, int current_strlen) {
64         if( !string || !index || *index >= current_strlen) return -2;
65
66         int status = 0; /* return code from parsing routines */
67         char* classname = NULL; /* object class hint */
68         json_eat_ws(string, index, 1, current_strlen); /* remove leading whitespace */
69
70         char c = string[*index];
71
72         /* remove any leading comments */
73         if( c == '/' ) { 
74
75                 while(1) {
76                         (*index)++; /* move to second comment char */
77                         status = json_eat_comment(string, index, &classname, 1, current_strlen);
78                         if(status) return status;
79
80                         json_eat_ws(string, index, 1, current_strlen);
81                         c = string[*index];
82                         if(c != '/')
83                                 break;
84                 }
85         }
86
87         json_eat_ws(string, index, 1, current_strlen); /* remove leading whitespace */
88
89         if(*index >= current_strlen)
90                 return -2;
91
92         switch(c) {
93                                 
94                 /* json string */
95                 case '"': 
96                         (*index)++;
97                         status = json_parse_json_string(string, index, obj, current_strlen); break;
98
99                 /* json array */
100                 case '[':
101                         (*index)++;
102                         status = json_parse_json_array(string, index, obj, current_strlen);                     
103                         break;
104
105                 /* json object */
106                 case '{':
107                         (*index)++;
108                         status = json_parse_json_object(string, index, obj, current_strlen);
109                         break;
110
111                 /* NULL */
112                 case 'n':
113                 case 'N':
114                         status = json_parse_json_null(string, index, obj, current_strlen);
115                         break;
116                         
117
118                 /* true, false */
119                 case 'f':
120                 case 'F':
121                 case 't':
122                 case 'T':
123                         status = json_parse_json_bool(string, index, obj, current_strlen);
124                         break;
125
126                 default:
127                         if(isdigit(c) || c == '.' || c == '-') { /* are we a number? */
128                                 status = json_parse_json_number(string, index, obj, current_strlen);    
129                                 if(status) return status;
130                                 break;
131                         }
132
133                         (*index)--;
134                         /* we should never get here */
135                         return json_handle_error(string, index, "_json_parse_string() final switch clause");
136         }       
137
138         if(status) return status;
139
140         json_eat_ws(string, index, 1, current_strlen);
141
142         if( *index < current_strlen ) {
143                 /* remove any trailing comments */
144                 c = string[*index];
145                 if( c == '/' ) { 
146                         (*index)++;
147                         status = json_eat_comment(string, index, NULL, 0, current_strlen);
148                         if(status) return status;
149                 }
150         }
151
152         if(classname){
153                 jsonObjectSetClass(obj, classname);
154                 free(classname);
155         }
156
157         return 0;
158 }
159
160
161 int json_parse_json_null(char* string, unsigned long* index, jsonObject* obj, int current_strlen) {
162
163         if(*index >= (current_strlen - 3)) {
164                 return json_handle_error(string, index, 
165                         "_parse_json_null(): invalid null" );
166         }
167
168         if(!strncasecmp(string + (*index), "null", 4)) {
169                 (*index) += 4;
170                 obj->type = JSON_NULL;
171                 return 0;
172         } else {
173                 return json_handle_error(string, index,
174                         "_parse_json_null(): invalid null" );
175         }
176 }
177
178 /* should be at the first character of the bool at this point */
179 int json_parse_json_bool(char* string, unsigned long* index, jsonObject* obj, int current_strlen) {
180         if( ! string || ! obj || *index >= current_strlen ) return -1;
181
182         char* ret = "json_parse_json_bool(): truncated bool";
183
184         if( *index >= (current_strlen - 5))
185                 return json_handle_error(string, index, ret);
186         
187         if(!strncasecmp( string + (*index), "false", 5)) {
188                 (*index) += 5;
189                 obj->value.b = 0;
190                 obj->type = JSON_BOOL;
191                 return 0;
192         }
193
194         if( *index >= (current_strlen - 4))
195                 return json_handle_error(string, index, ret);
196
197         if(!strncasecmp( string + (*index), "true", 4)) {
198                 (*index) += 4;
199                 obj->value.b = 1;
200                 obj->type = JSON_BOOL;
201                 return 0;
202         }
203
204         return json_handle_error(string, index, ret);
205 }
206
207
208 /* expecting the first character of the number */
209 int json_parse_json_number(char* string, unsigned long* index, jsonObject* obj, int current_strlen) {
210         if( ! string || ! obj || *index >= current_strlen ) return -1;
211
212         growing_buffer* buf = buffer_init(64);
213         char c = string[*index];
214
215         int done = 0;
216         int dot_seen = 0;
217
218         /* negative number? */
219         if(c == '-') { buffer_add(buf, "-"); (*index)++; }
220
221         c = string[*index];
222
223         while(*index < current_strlen) {
224
225                 if(isdigit(c)) {
226                         buffer_add_char(buf, c);
227                 }
228
229                 else if( c == '.' ) {
230                         if(dot_seen) {
231                                 buffer_free(buf);
232                                 return json_handle_error(string, index, 
233                                         "json_parse_json_number(): malformed json number");
234                         }
235                         dot_seen = 1;
236                         buffer_add_char(buf, c);
237                 } else {
238                         done = 1; break;
239                 }
240
241                 (*index)++;
242                 c = string[*index];
243                 if(done) break;
244         }
245
246         obj->type = JSON_NUMBER;
247         obj->value.n = strtod(buf->buf, NULL);
248         buffer_free(buf);
249         return 0;
250 }
251
252 /* index should point to the character directly following the '['.  when done
253  * index will point to the character directly following the ']' character
254  */
255 int json_parse_json_array(char* string, unsigned long* index, jsonObject* obj, int current_strlen) {
256
257         if( ! string || ! obj || ! index || *index >= current_strlen ) return -1;
258
259         int status = 0;
260         int in_parse = 0; /* true if this array already contains one item */
261         obj->type = JSON_ARRAY;
262         int set = 0;
263         int done = 0;
264
265         while(*index < current_strlen) {
266
267                 json_eat_ws(string, index, 1, current_strlen);
268
269                 if(string[*index] == ']') {
270                         (*index)++;
271                         done = 1;
272                         break;
273                 }
274
275                 if(in_parse) {
276                         json_eat_ws(string, index, 1, current_strlen);
277                         if(string[*index] != ',') {
278                                 return json_handle_error(string, index,
279                                         "json_parse_json_array(): array item not followed by a ','");
280                         }
281                         (*index)++;
282                         json_eat_ws(string, index, 1, current_strlen);
283                 }
284
285                 jsonObject* item = jsonNewObject(NULL);
286
287                 #ifndef STRICT_JSON_READ
288                 if(*index < current_strlen) {
289                         if(string[*index] == ',' || string[*index] == ']') {
290                                 status = 0;
291                                 set = 1;
292                         }
293                 }
294                 if(!set) status = _json_parse_string(string, index, item, current_strlen);
295
296                 #else
297                 status = _json_parse_string(string, index, item, current_strlen);
298                 #endif
299
300                 if(status) { jsonObjectFree(item); return status; }
301                 jsonObjectPush(obj, item);
302                 in_parse = 1;
303                 set = 0;
304         }
305
306         if(!done)
307                 return json_handle_error(string, index,
308                         "json_parse_json_array(): array not closed");
309
310         return 0;
311 }
312
313
314 /* index should point to the character directly following the '{'.  when done
315  * index will point to the character directly following the '}'
316  */
317 int json_parse_json_object(char* string, unsigned long* index, jsonObject* obj, int current_strlen) {
318         if( ! string || !obj || ! index || *index >= current_strlen ) return -1;
319
320         obj->type = JSON_HASH;
321         int status;
322         int in_parse = 0; /* true if we've already added one item to this object */
323         int set = 0;
324         int done = 0;
325
326         while(*index < current_strlen) {
327
328                 json_eat_ws(string, index, 1, current_strlen);
329
330                 if(string[*index] == '}') {
331                         (*index)++;
332                         done = 1;
333                         break;
334                 }
335
336                 if(in_parse) {
337                         if(string[*index] != ',') {
338                                 return json_handle_error(string, index,
339                                         "json_parse_json_object(): object missing ',' between elements" );
340                         }
341                         (*index)++;
342                         json_eat_ws(string, index, 1, current_strlen);
343                 }
344
345                 /* first we grab the hash key */
346                 jsonObject* key_obj = jsonNewObject(NULL);
347                 status = _json_parse_string(string, index, key_obj, current_strlen);
348                 if(status) return status;
349
350                 if(key_obj->type != JSON_STRING) {
351                         return json_handle_error(string, index, 
352                                 "_json_parse_json_object(): hash key not a string");
353                 }
354
355                 char* key = key_obj->value.s;
356
357                 json_eat_ws(string, index, 1, current_strlen);
358
359                 if(string[*index] != ':') {
360                         return json_handle_error(string, index, 
361                                 "json_parse_json_object(): hash key not followed by ':' character");
362                 }
363
364                 (*index)++;
365
366                 /* now grab the value object */
367                 json_eat_ws(string, index, 1, current_strlen);
368                 jsonObject* value_obj = jsonNewObject(NULL);
369
370 #ifndef STRICT_JSON_READ
371                 if(*index < current_strlen) {
372                         if(string[*index] == ',' || string[*index] == '}') {
373                                 status = 0;
374                                 set = 1;
375                         }
376                 }
377                 if(!set)
378                         status = _json_parse_string(string, index, value_obj, current_strlen);
379
380 #else
381                  status = _json_parse_string(string, index, value_obj, current_strlen);
382 #endif
383
384                 if(status) return status;
385
386                 /* put the data into the object and continue */
387                 jsonObjectSetKey(obj, key, value_obj);
388                 jsonObjectFree(key_obj);
389                 in_parse = 1;
390                 set = 0;
391         }
392
393         if(!done)
394                 return json_handle_error(string, index,
395                         "json_parse_json_object(): object not closed");
396
397         return 0;
398 }
399
400
401
402 /* when done, index will point to the character after the closing quote */
403 int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, int current_strlen) {
404         if( ! string || ! index || *index >= current_strlen ) return -1;
405
406         int in_escape = 0;      
407         int done = 0;
408         growing_buffer* buf = buffer_init(64);
409
410         while(*index < current_strlen) {
411
412                 char c = string[*index]; 
413
414                 switch(c) {
415
416                         case '\\':
417                                 if(in_escape) {
418                                         buffer_add(buf, "\\");
419                                         in_escape = 0;
420                                 } else 
421                                         in_escape = 1;
422                                 break;
423
424                         case '"':
425                                 if(in_escape) {
426                                         buffer_add(buf, "\"");
427                                         in_escape = 0;
428                                 } else 
429                                         done = 1;
430                                 break;
431
432                         case 't':
433                                 if(in_escape) {
434                                         buffer_add(buf,"\t");
435                                         in_escape = 0;
436                                 } else 
437                                         buffer_add_char(buf, c);
438                                 break;
439
440                         case 'b':
441                                 if(in_escape) {
442                                         buffer_add(buf,"\b");
443                                         in_escape = 0;
444                                 } else 
445                                         buffer_add_char(buf, c);
446                                 break;
447
448                         case 'f':
449                                 if(in_escape) {
450                                         buffer_add(buf,"\f");
451                                         in_escape = 0;
452                                 } else 
453                                         buffer_add_char(buf, c);
454                                 break;
455
456                         case 'r':
457                                 if(in_escape) {
458                                         buffer_add(buf,"\r");
459                                         in_escape = 0;
460                                 } else 
461                                         buffer_add_char(buf, c);
462                                 break;
463
464                         case 'n':
465                                 if(in_escape) {
466                                         buffer_add(buf,"\n");
467                                         in_escape = 0;
468                                 } else 
469                                         buffer_add_char(buf, c);
470                                 break;
471
472                         case 'u':
473                                 if(in_escape) {
474                                         (*index)++;
475
476                                         if(*index >= (current_strlen - 4)) {
477                                                 buffer_free(buf);
478                                                 return json_handle_error(string, index,
479                                                         "json_parse_json_string(): truncated escaped unicode"); }
480
481                                         char buff[5];
482                                         memset(buff,0,5);
483                                         memcpy(buff, string + (*index), 4);
484
485
486                                         /* ----------------------------------------------------------------------- */
487                                         /* ----------------------------------------------------------------------- */
488                                         /* The following chunk was borrowed with permission from 
489                                                 json-c http://oss.metaparadigm.com/json-c/ */
490                                         unsigned char utf_out[3];
491                                         memset(utf_out,0,3);
492
493                                         #define hexdigit(x) ( ((x) <= '9') ? (x) - '0' : ((x) & 7) + 9)
494
495                                         unsigned int ucs_char =
496                                                 (hexdigit(string[*index] ) << 12) +
497                                                 (hexdigit(string[*index + 1]) << 8) +
498                                                 (hexdigit(string[*index + 2]) << 4) +
499                                                 hexdigit(string[*index + 3]);
500         
501                                         if (ucs_char < 0x80) {
502                                                 utf_out[0] = ucs_char;
503                                                 buffer_add(buf, (char*) utf_out);
504
505                                         } else if (ucs_char < 0x800) {
506                                                 utf_out[0] = 0xc0 | (ucs_char >> 6);
507                                                 utf_out[1] = 0x80 | (ucs_char & 0x3f);
508                                                 buffer_add(buf, (char*) utf_out);
509
510                                         } else {
511                                                 utf_out[0] = 0xe0 | (ucs_char >> 12);
512                                                 utf_out[1] = 0x80 | ((ucs_char >> 6) & 0x3f);
513                                                 utf_out[2] = 0x80 | (ucs_char & 0x3f);
514                                                 buffer_add(buf, (char*) utf_out);
515                                         }
516                                         /* ----------------------------------------------------------------------- */
517                                         /* ----------------------------------------------------------------------- */
518
519                                         (*index) += 3;
520                                         in_escape = 0;
521
522                                 } else {
523
524                                         buffer_add_char(buf, c);
525                                 }
526
527                                 break;
528
529                         default:
530                                 buffer_add_char(buf, c);
531                 }
532
533                 (*index)++;
534                 if(done) break;
535         }
536
537         jsonObjectSetString(obj, buf->buf);
538         buffer_free(buf);
539         return 0;
540 }
541
542
543 void json_eat_ws(char* string, unsigned long* index, int eat_all, int current_strlen) {
544         if( ! string || ! index ) return;
545         if(*index >= current_strlen)
546                 return;
547
548         if( eat_all ) { /* removes newlines, etc */
549                 while(string[*index] == ' '     || 
550                                 string[*index] == '\n'  ||
551                                 string[*index] == '\t') 
552                         (*index)++;
553         }
554
555         else    
556                 while(string[*index] == ' ') (*index)++;
557 }
558
559
560 /* index should be at the '*' character at the beginning of the comment.
561  * when done, index will point to the first character after the final /
562  */
563 int json_eat_comment(char* string, unsigned long* index, char** buffer, int parse_class, int current_strlen) {
564         if( ! string || ! index || *index >= current_strlen ) return -1;
565         
566
567         if(string[*index] != '*' && string[*index] != '/' )
568                 return json_handle_error(string, index, 
569                         "json_eat_comment(): invalid character after /");
570
571         /* chop out any // style comments */
572         if(string[*index] == '/') {
573                 (*index)++;
574                 char c = string[*index];
575                 while(*index < current_strlen) {
576                         (*index)++;
577                         if(c == '\n') 
578                                 return 0;
579                         c = string[*index];
580                 }
581                 return 0;
582         }
583
584         (*index)++;
585
586         int on_star                     = 0; /* true if we just saw a '*' character */
587
588         /* we're just past the '*' */
589         if(!parse_class) { /* we're not concerned with class hints */
590                 while(*index < current_strlen) {
591                         if(string[*index] == '/') {
592                                 if(on_star) {
593                                         (*index)++;
594                                         return 0;
595                                 }
596                         }
597
598                         if(string[*index] == '*') on_star = 1;
599                         else on_star = 0;
600
601                         (*index)++;
602                 }
603                 return 0;
604         }
605
606
607
608         growing_buffer* buf = buffer_init(64);
609
610         int first_dash          = 0;
611         int second_dash = 0;
612         int third_dash          = 0;
613         int fourth_dash = 0;
614
615         int in_hint                     = 0;
616         int done                                = 0;
617
618         /*--S hint--*/   /* <-- Hints  look like this */
619         /*--E hint--*/
620
621         while(*index < current_strlen) {
622                 char c = string[*index];
623
624                 switch(c) {
625
626                         case '-':
627                                 on_star = 0;
628                                 if(third_dash)                  fourth_dash = 1;
629                                 else if(in_hint)                third_dash      = 1;
630                                 else if(first_dash)     second_dash = 1;
631                                 else                                            first_dash = 1;
632                                 break;
633
634                         case 'S':
635                                 on_star = 0;
636                                 if(second_dash && !in_hint) {
637                                         (*index)++;
638                                         json_eat_ws(string, index, 1, current_strlen);
639                                         (*index)--; /* this will get incremented at the bottom of the loop */
640                                         in_hint = 1;
641                                         break;
642                                 } 
643
644                                 if(second_dash && in_hint) {
645                                         buffer_add_char(buf, c);
646                                         break;
647                                 }
648
649                         case 'E':
650                                 on_star = 0;
651                                 if(second_dash && !in_hint) {
652                                         (*index)++;
653                                         json_eat_ws(string, index, 1, current_strlen);
654                                         (*index)--; /* this will get incremented at the bottom of the loop */
655                                         in_hint = 1;
656                                         break;
657                                 }
658
659                                 if(second_dash && in_hint) {
660                                         buffer_add_char(buf, c);
661                                         break;
662                                 }
663
664                         case '*':
665                                 on_star = 1;
666                                 break;
667
668                         case '/':
669                                 if(on_star) 
670                                         done = 1;
671                                 else
672                                 on_star = 0;
673                                 break;
674
675                         default:
676                                 on_star = 0;
677                                 if(in_hint)
678                                         buffer_add_char(buf, c);
679                 }
680
681                 (*index)++;
682                 if(done) break;
683         }
684
685         if( buf->n_used > 0 && buffer)
686                 *buffer = buffer_data(buf);
687
688         buffer_free(buf);
689         return 0;
690 }
691
692 int json_handle_error(char* string, unsigned long* index, char* err_msg) {
693
694         char buf[60];
695         memset(buf, 0, 60);
696
697         if(*index > 30)
698                 strncpy( buf, string + (*index - 30), 59 );
699         else
700                 strncpy( buf, string, 59 );
701
702         fprintf(stderr, 
703                         "\nError parsing json string at charracter %c "
704                         "(code %d) and index %ld\nString length: %d\nMsg:\t%s\nNear:\t%s\nFull String:\t%s\n", 
705                         string[*index], string[*index], *index, current_strlen, err_msg, buf, string );
706
707         return -1;
708 }
709
710
711 jsonObject* legacy_jsonParseFile( const char* filename ) {
712         return json_parse_file( filename );
713 }
714         
715 jsonObject* json_parse_file(const char* filename) {
716         if(!filename) return NULL;
717         char* data = file_to_string(filename);
718         jsonObject* o = json_parse_string(data);
719         free(data);
720         return o;
721 }
722
723
724
725 char* legacy_jsonObjectToJSON( const jsonObject* obj ) {
726
727         if(obj == NULL) return strdup("null");
728
729         growing_buffer* buf = buffer_init(64);
730
731         /* add class hints if we have a class name */
732         if(obj->classname) {
733                 buffer_add(buf,"/*--S ");
734                 buffer_add(buf,obj->classname);
735                 buffer_add(buf, "--*/");
736         }
737
738         switch( obj->type ) {
739
740                 case JSON_BOOL: 
741                         if(obj->value.b) buffer_add(buf, "true"); 
742                         else buffer_add(buf, "false"); 
743                         break;
744
745                 case JSON_NUMBER: {
746                         double x = obj->value.n;
747
748                         /* if the number does not need to be a double,
749                                 turn it into an int on the way out */
750                         if( x == (int) x ) {
751                                 INT_TO_STRING((int)x);  
752                                 buffer_add(buf, INTSTR);
753
754                         } else {
755                                 DOUBLE_TO_STRING(x);
756                                 buffer_add(buf, DOUBLESTR);
757                         }
758                         break;
759                 }
760
761                 case JSON_NULL:
762                         buffer_add(buf, "null");
763                         break;
764
765                 case JSON_STRING:
766                         buffer_add(buf, "\"");
767                         char* data = obj->value.s;
768                         int len = strlen(data);
769                         
770                         char* output = uescape(data, len, 1);
771                         buffer_add(buf, output);
772                         free(output);
773                         buffer_add(buf, "\"");
774                         break;
775
776                 case JSON_ARRAY:
777                         buffer_add(buf, "[");
778                         int i;
779                         for( i = 0; i!= obj->size; i++ ) {
780                                 const jsonObject* x = jsonObjectGetIndex(obj,i);
781                                 char* data = legacy_jsonObjectToJSON(x);
782                                 buffer_add(buf, data);
783                                 free(data);
784                                 if(i != obj->size - 1)
785                                         buffer_add(buf, ",");
786                         }
787                         buffer_add(buf, "]");
788                         break;  
789
790                 case JSON_HASH:
791         
792                         buffer_add(buf, "{");
793                         jsonIterator* itr = jsonNewIterator(obj);
794                         jsonObject* tmp;
795         
796                         while( (tmp = jsonIteratorNext(itr)) ) {
797
798                                 buffer_add(buf, "\"");
799
800                                 char* key = itr->key;
801                                 int len = strlen(key);
802                                 char* output = uescape(key, len, 1);
803                                 buffer_add(buf, output);
804                                 free(output);
805
806                                 buffer_add(buf, "\":");
807                                 char* data =  legacy_jsonObjectToJSON(tmp);
808                                 buffer_add(buf, data);
809                                 if(jsonIteratorHasNext(itr))
810                                         buffer_add(buf, ",");
811                                 free(data);
812                         }
813
814                         jsonIteratorFree(itr);
815                         buffer_add(buf, "}");
816                         break;
817                 
818                         default:
819                                 fprintf(stderr, "Unknown object type %d\n", obj->type);
820                                 break;
821                                 
822         }
823
824         /* close out the object hint */
825         if(obj->classname) {
826                 buffer_add(buf, "/*--E ");
827                 buffer_add(buf, obj->classname);
828                 buffer_add(buf, "--*/");
829         }
830
831         char* data = buffer_data(buf);
832         buffer_free(buf);
833         return data;
834 }
835
836
837
838 static jsonObjectNode* makeNode(jsonObject* obj, unsigned long index, char* key) {
839     jsonObjectNode* node = safe_malloc(sizeof(jsonObjectNode));
840     node->item = obj;
841     node->index = index;
842     node->key = key;
843     return node;
844 }
845
846 jsonObjectIterator* jsonNewObjectIterator(const jsonObject* obj) {
847         if(!obj) return NULL;
848         jsonObjectIterator* itr = safe_malloc(sizeof(jsonObjectIterator));
849     itr->iterator = jsonNewIterator(obj);
850         itr->obj = obj;
851     itr->done = 0;
852     itr->current = NULL;
853         return itr;
854 }
855
856 jsonObjectNode* jsonObjectIteratorNext( jsonObjectIterator* itr ) {
857         if(itr == NULL || itr->done) return NULL;
858
859     if(itr->current) free(itr->current);
860     jsonObject* next = jsonIteratorNext(itr->iterator);
861     if(next == NULL) {
862         itr->current = NULL;
863         itr->done = 1;
864         return NULL;
865     }
866     itr->current = makeNode(next, itr->iterator->index, itr->iterator->key);
867     return itr->current;
868 }
869
870 void jsonObjectIteratorFree(jsonObjectIterator* iter) { 
871     if(iter->current) free(iter->current);
872     jsonIteratorFree(iter->iterator);
873         free(iter);
874 }
875
876 int jsonObjectIteratorHasNext(const jsonObjectIterator* itr) {
877         return (itr && itr->current);
878 }
879
880