json: Fix uninitialized key unref in op_delete
[gpgme.git] / src / cJSON.c
1 /* cJSON.c - JSON parser in C.
2  * Copyright (c) 2009 Dave Gamble
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a copy
5  * of this software and associated documentation files (the "Software"), to deal
6  * in the Software without restriction, including without limitation the rights
7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8  * copies of the Software, and to permit persons to whom the Software is
9  * furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20  * THE SOFTWARE.
21  *
22  * SPDX-License-Identifier: MIT
23  *
24  * Note that this code has been modified from the original code taken
25  * from cjson-code-58.zip before 2014 (my first local commit was in
26  * 2014 but I may used the code even earlier).  Since 2016 the project
27  * was revived and moved to https://github.com/DaveGamble/cJSON.git.
28  * It is now a lot more complex and has substantial changes so that it
29  * is not possible to merge them directly.  In any case we only need a
30  * simple parser and not a complete library.  I have looked through
31  * the commits and fixed a few things which should apply; I also added
32  * a few references to the upstream code.  Regression test are missing!
33  */
34
35 #ifdef HAVE_CONFIG_H
36 # include <config.h>
37 #endif
38
39 #include <string.h>
40 #include <stdio.h>
41 #include <math.h>
42 #include <stdlib.h>
43 #include <float.h>
44 #include <limits.h>
45 #include <ctype.h>
46 #include <errno.h>
47
48 #include "cJSON.h"
49
50 /* We use malloc function wrappers from gpgrt (aka libgpg-error).  */
51 #if GPGRT_VERSION_NUMBER >= 0x011c00 /* 1.28 */
52 # include <gpgrt.h>
53 # define xtrymalloc(a)   gpgrt_malloc ((a))
54 # define xtrycalloc(a,b) gpgrt_calloc ((a), (b))
55 # define xtrystrdup(a)   gpgrt_strdup ((a))
56 # define xfree(a)        gpgrt_free ((a))
57 #else /* Without gpgrt (aka libgpg-error).  */
58 # define xtrymalloc(a)   malloc ((a))
59 # define xtrycalloc(a,b) calloc ((a), (b))
60 # define xtrystrdup(a)   strdup ((a))
61 # define xfree(a)        free ((a))
62 #endif
63
64
65 static int
66 cJSON_strcasecmp (const char *s1, const char *s2)
67 {
68   if (!s1)
69     return (s1 == s2) ? 0 : 1;
70   if (!s2)
71     return 1;
72   for (; tolower (*(const unsigned char *)s1)
73          == tolower (*(const unsigned char *) s2); ++s1, ++s2)
74     if (*s1 == 0)
75       return 0;
76   return tolower (*(const unsigned char *) s1) -
77     tolower (*(const unsigned char *) s2);
78 }
79
80 /* Internal constructor. */
81 static cJSON *
82 cJSON_New_Item (void)
83 {
84   return xtrycalloc (1, sizeof (cJSON));
85 }
86
87 /* Delete a cJSON structure.  (Does not clobber ERRNO). */
88 void
89 cJSON_Delete (cJSON * c)
90 {
91   cJSON *next;
92   int save_errno;
93
94   if (!c)
95     return;
96
97   save_errno = errno;
98   while (c)
99     {
100       next = c->next;
101       if (!(c->type & cJSON_IsReference) && c->child)
102         cJSON_Delete (c->child);
103       if (!(c->type & cJSON_IsReference) && c->valuestring)
104         xfree (c->valuestring);
105       if (c->string)
106         xfree (c->string);
107       xfree (c);
108       c = next;
109     }
110   errno = save_errno;
111 }
112
113 /* Parse the input text to generate a number, and populate the result
114  * into item. */
115 static const char *
116 parse_number (cJSON * item, const char *num)
117 {
118   double n = 0, sign = 1, scale = 0;
119   int subscale = 0, signsubscale = 1;
120
121   if (*num == '-')
122     sign = -1, num++;           /* Has sign? */
123   if (*num == '0')
124     num++;                      /* is zero */
125   if (*num >= '1' && *num <= '9')
126     do
127       n = (n * 10.0) + (*num++ - '0');
128     while (*num >= '0' && *num <= '9'); /* Number? */
129   if (*num == '.' && num[1] >= '0' && num[1] <= '9')
130     {
131       num++;
132       do
133         n = (n * 10.0) + (*num++ - '0'), scale--;
134       while (*num >= '0' && *num <= '9');
135     }                           /* Fractional part? */
136   if (*num == 'e' || *num == 'E')       /* Exponent? */
137     {
138       num++;
139       if (*num == '+')
140         num++;
141       else if (*num == '-')
142         signsubscale = -1, num++;       /* With sign? */
143       while (*num >= '0' && *num <= '9')
144         subscale = (subscale * 10) + (*num++ - '0');    /* Number? */
145     }
146
147   /* number = +/- number.fraction * 10^+/- exponent */
148   n = sign * n * pow (10.0, (scale + subscale * signsubscale));
149
150   item->valuedouble = n;
151   item->valueint = (int) n;
152   item->type = cJSON_Number;
153   return num;
154 }
155
156 /* Render the number nicely from the given item into a string. */
157 static char *
158 print_number (cJSON * item)
159 {
160   char *str;
161   double d = item->valuedouble;
162   if (fabs (((double) item->valueint) - d) <= DBL_EPSILON && d <= INT_MAX
163       && d >= INT_MIN)
164     {
165       /* 2^64+1 can be represented in 21 chars. */
166       str = xtrymalloc (21);
167       if (str)
168         sprintf (str, "%d", item->valueint);
169     }
170   else
171     {
172       str = xtrymalloc (64);    /* This is a nice tradeoff. */
173       if (str)
174         {
175           if (fabs (floor (d) - d) <= DBL_EPSILON && fabs (d) < 1.0e60)
176             sprintf (str, "%.0f", d);
177           else if (fabs (d) < 1.0e-6 || fabs (d) > 1.0e9)
178             sprintf (str, "%e", d);
179           else
180             sprintf (str, "%f", d);
181         }
182     }
183   return str;
184 }
185
186 static unsigned
187 parse_hex4 (const char *str)
188 {
189   unsigned h = 0;
190   if (*str >= '0' && *str <= '9')
191     h += (*str) - '0';
192   else if (*str >= 'A' && *str <= 'F')
193     h += 10 + (*str) - 'A';
194   else if (*str >= 'a' && *str <= 'f')
195     h += 10 + (*str) - 'a';
196   else
197     return 0;
198   h = h << 4;
199   str++;
200   if (*str >= '0' && *str <= '9')
201     h += (*str) - '0';
202   else if (*str >= 'A' && *str <= 'F')
203     h += 10 + (*str) - 'A';
204   else if (*str >= 'a' && *str <= 'f')
205     h += 10 + (*str) - 'a';
206   else
207     return 0;
208   h = h << 4;
209   str++;
210   if (*str >= '0' && *str <= '9')
211     h += (*str) - '0';
212   else if (*str >= 'A' && *str <= 'F')
213     h += 10 + (*str) - 'A';
214   else if (*str >= 'a' && *str <= 'f')
215     h += 10 + (*str) - 'a';
216   else
217     return 0;
218   h = h << 4;
219   str++;
220   if (*str >= '0' && *str <= '9')
221     h += (*str) - '0';
222   else if (*str >= 'A' && *str <= 'F')
223     h += 10 + (*str) - 'A';
224   else if (*str >= 'a' && *str <= 'f')
225     h += 10 + (*str) - 'a';
226   else
227     return 0;
228   return h;
229 }
230
231 /* Parse the input text into an unescaped cstring, and populate item. */
232 static const unsigned char firstByteMark[7] =
233   { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
234 static const char *
235 parse_string (cJSON * item, const char *str, const char **ep)
236 {
237   const char *ptr = str + 1;
238   char *ptr2;
239   char *out;
240   int len = 0;
241   unsigned uc, uc2;
242
243   /* FIXME: We should consider eary failure like it is done with
244    * commit 8656386c4f4a12f1cf3d6b26158407fd05e65029 in upstream.  */
245   if (*str != '\"')
246     {
247       *ep = str;
248       return 0;
249     }                           /* not a string! */
250
251   while (*ptr != '\"' && *ptr && ++len)
252     if (*ptr++ == '\\')
253       ptr++;                    /* Skip escaped quotes. */
254
255   out = xtrymalloc (len + 2);   /* This is how long we need for the
256                                  * string, roughly.  We add one extra
257                                  * byte in case the last input
258                                  * character is a backslash.  */
259   if (!out)
260     return 0;
261
262   ptr = str + 1;
263   ptr2 = out;
264   while (*ptr != '\"' && *ptr)
265     {
266       if (*ptr != '\\')
267         *ptr2++ = *ptr++;
268       else
269         {
270           ptr++;
271           switch (*ptr)
272             {
273             case 'b':
274               *ptr2++ = '\b';
275               break;
276             case 'f':
277               *ptr2++ = '\f';
278               break;
279             case 'n':
280               *ptr2++ = '\n';
281               break;
282             case 'r':
283               *ptr2++ = '\r';
284               break;
285             case 't':
286               *ptr2++ = '\t';
287               break;
288             case 'u':           /* transcode utf16 to utf8. */
289               uc = parse_hex4 (ptr + 1);
290               if (!uc)
291                 break;          /* Bad hex; continue right after the 'u'. */
292               ptr += 4;         /* get the unicode char. */
293
294               if ((uc >= 0xDC00 && uc <= 0xDFFF))
295                 break;          /* check for invalid.   */
296
297               if (uc >= 0xD800 && uc <= 0xDBFF) /* UTF16 surrogate pairs. */
298                 {
299                   if (ptr[1] != '\\' || ptr[2] != 'u')
300                     break;      /* missing second-half of surrogate.    */
301                   ptr += 2;
302                   uc2 = parse_hex4 (ptr + 1);
303                   if (!uc2)
304                     break;      /* Bad hex; continue right after the 'u'. */
305                   ptr += 4;
306                   if (uc2 < 0xDC00 || uc2 > 0xDFFF)
307                     break;      /* invalid second-half of surrogate.    */
308                   uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF));
309                 }
310
311               len = 4;
312               if (uc < 0x80)
313                 len = 1;
314               else if (uc < 0x800)
315                 len = 2;
316               else if (uc < 0x10000)
317                 len = 3;
318               ptr2 += len;
319
320               switch (len)
321                 {
322                 case 4:
323                   *--ptr2 = ((uc | 0x80) & 0xBF);
324                   uc >>= 6;
325                 case 3:
326                   *--ptr2 = ((uc | 0x80) & 0xBF);
327                   uc >>= 6;
328                 case 2:
329                   *--ptr2 = ((uc | 0x80) & 0xBF);
330                   uc >>= 6;
331                 case 1:
332                   *--ptr2 = (uc | firstByteMark[len]);
333                 }
334               ptr2 += len;
335               break;
336             default:
337               /* Fixme: Should we fail here: See
338                * https://github.com/DaveGamble/cJSON/issues/10  */
339               *ptr2++ = *ptr;
340               break;
341             }
342           ptr++;
343         }
344     }
345   *ptr2 = 0;
346   if (*ptr == '\"')
347     ptr++;
348   item->valuestring = out;
349   item->type = cJSON_String;
350   return ptr;
351 }
352
353 /* Render the cstring provided to an escaped version that can be printed. */
354 static char *
355 print_string_ptr (const char *str)
356 {
357   const char *ptr;
358   char *ptr2, *out;
359   int len = 0;
360   unsigned char token;
361
362   if (!str)
363     return xtrystrdup ("");
364   ptr = str;
365   while ((token = *ptr) && ++len)
366     {
367       if (strchr ("\"\\\b\f\n\r\t", token))
368         len++;
369       else if (token < 32)
370         len += 5;
371       ptr++;
372     }
373
374   out = xtrymalloc (len + 3);
375   if (!out)
376     return 0;
377
378   ptr2 = out;
379   ptr = str;
380   *ptr2++ = '\"';
381   while (*ptr)
382     {
383       if ((unsigned char) *ptr > 31 && *ptr != '\"' && *ptr != '\\')
384         *ptr2++ = *ptr++;
385       else
386         {
387           *ptr2++ = '\\';
388           switch (token = *ptr++)
389             {
390             case '\\':
391               *ptr2++ = '\\';
392               break;
393             case '\"':
394               *ptr2++ = '\"';
395               break;
396             case '\b':
397               *ptr2++ = 'b';
398               break;
399             case '\f':
400               *ptr2++ = 'f';
401               break;
402             case '\n':
403               *ptr2++ = 'n';
404               break;
405             case '\r':
406               *ptr2++ = 'r';
407               break;
408             case '\t':
409               *ptr2++ = 't';
410               break;
411             default:
412               sprintf (ptr2, "u%04x", token);
413               ptr2 += 5;
414               break;            /* escape and print */
415             }
416         }
417     }
418   *ptr2++ = '\"';
419   *ptr2++ = 0;
420   return out;
421 }
422
423 /* Invote print_string_ptr (which is useful) on an item. */
424 static char *
425 print_string (cJSON * item)
426 {
427   return print_string_ptr (item->valuestring);
428 }
429
430 /* Predeclare these prototypes. */
431 static const char *parse_value (cJSON * item, const char *value,
432                                 const char **ep);
433 static char *print_value (cJSON * item, int depth, int fmt);
434 static const char *parse_array (cJSON * item, const char *value,
435                                 const char **ep);
436 static char *print_array (cJSON * item, int depth, int fmt);
437 static const char *parse_object (cJSON * item, const char *value,
438                                  const char **ep);
439 static char *print_object (cJSON * item, int depth, int fmt);
440
441 /* Utility to jump whitespace and cr/lf */
442 static const char *
443 skip (const char *in)
444 {
445   while (in && *in && (unsigned char) *in <= 32)
446     in++;
447   return in;
448 }
449
450 /* Parse an object - create a new root, and populate. */
451 cJSON *
452 cJSON_ParseWithOpts (const char *value, const char **return_parse_end,
453                      int require_null_terminated, size_t *r_erroff)
454 {
455   const char *end = 0;
456   const char *ep = 0;
457   cJSON *c;
458
459   if (r_erroff)
460     *r_erroff = 0;
461
462   c = cJSON_New_Item ();
463   if (!c)
464     return NULL; /* memory fail */
465
466   end = parse_value (c, skip (value), &ep);
467   if (!end)
468     {
469       cJSON_Delete (c);
470       errno = EINVAL;
471       if (r_erroff)
472         *r_erroff = ep - value;
473       return 0;
474     }                           /* parse failure. ep is set. */
475
476   /* if we require null-terminated JSON without appended garbage, skip
477      and then check for a null terminator */
478   if (require_null_terminated)
479     {
480       end = skip (end);
481       if (*end)
482         {
483           cJSON_Delete (c);
484           ep = end;
485           errno = EINVAL;
486           if (r_erroff)
487             *r_erroff = ep - value;
488           return 0;
489         }
490     }
491   if (return_parse_end)
492     *return_parse_end = end;
493   return c;
494 }
495
496 /* Default options for cJSON_Parse */
497 cJSON *
498 cJSON_Parse (const char *value, size_t *r_erroff)
499 {
500   return cJSON_ParseWithOpts (value, 0, 0, r_erroff);
501 }
502
503 /* Render a cJSON item/entity/structure to text. */
504 char *
505 cJSON_Print (cJSON * item)
506 {
507   return print_value (item, 0, 1);
508 }
509
510 char *
511 cJSON_PrintUnformatted (cJSON * item)
512 {
513   return print_value (item, 0, 0);
514 }
515
516 /* Parser core - when encountering text, process appropriately. */
517 static const char *
518 parse_value (cJSON * item, const char *value, const char **ep)
519 {
520   if (!value)
521     return 0;                   /* Fail on null. */
522   if (!strncmp (value, "null", 4))
523     {
524       item->type = cJSON_NULL;
525       return value + 4;
526     }
527   if (!strncmp (value, "false", 5))
528     {
529       item->type = cJSON_False;
530       return value + 5;
531     }
532   if (!strncmp (value, "true", 4))
533     {
534       item->type = cJSON_True;
535       item->valueint = 1;
536       return value + 4;
537     }
538   if (*value == '\"')
539     {
540       return parse_string (item, value, ep);
541     }
542   if (*value == '-' || (*value >= '0' && *value <= '9'))
543     {
544       return parse_number (item, value);
545     }
546   if (*value == '[')
547     {
548       return parse_array (item, value, ep);
549     }
550   if (*value == '{')
551     {
552       return parse_object (item, value, ep);
553     }
554
555   *ep = value;
556   return 0;                     /* failure. */
557 }
558
559 /* Render a value to text. */
560 static char *
561 print_value (cJSON * item, int depth, int fmt)
562 {
563   char *out = 0;
564   if (!item)
565     return 0;
566   switch ((item->type) & 255)
567     {
568     case cJSON_NULL:
569       out = xtrystrdup ("null");
570       break;
571     case cJSON_False:
572       out = xtrystrdup ("false");
573       break;
574     case cJSON_True:
575       out = xtrystrdup ("true");
576       break;
577     case cJSON_Number:
578       out = print_number (item);
579       break;
580     case cJSON_String:
581       out = print_string (item);
582       break;
583     case cJSON_Array:
584       out = print_array (item, depth, fmt);
585       break;
586     case cJSON_Object:
587       out = print_object (item, depth, fmt);
588       break;
589     }
590   return out;
591 }
592
593 /* Build an array from input text. */
594 static const char *
595 parse_array (cJSON * item, const char *value, const char **ep)
596 {
597   cJSON *child;
598   if (*value != '[')
599     {
600       *ep = value;
601       return 0;
602     }                           /* not an array! */
603
604   item->type = cJSON_Array;
605   value = skip (value + 1);
606   if (*value == ']')
607     return value + 1;           /* empty array. */
608
609   item->child = child = cJSON_New_Item ();
610   if (!item->child)
611     return 0;                   /* memory fail */
612   /* skip any spacing, get the value. */
613   value = skip (parse_value (child, skip (value), ep));
614   if (!value)
615     return 0;
616
617   while (*value == ',')
618     {
619       cJSON *new_item;
620       if (!(new_item = cJSON_New_Item ()))
621         return 0;               /* memory fail */
622       child->next = new_item;
623       new_item->prev = child;
624       child = new_item;
625       value = skip (parse_value (child, skip (value + 1), ep));
626       if (!value)
627         return 0;               /* memory fail */
628     }
629
630   if (*value == ']')
631     return value + 1;           /* end of array */
632   *ep = value;
633   return 0;                     /* malformed. */
634 }
635
636 /* Render an array to text */
637 static char *
638 print_array (cJSON * item, int depth, int fmt)
639 {
640   char **entries;
641   char *out = 0, *ptr, *ret;
642   int len = 5;
643   cJSON *child = item->child;
644   int numentries = 0, i = 0, fail = 0;
645
646   /* How many entries in the array? */
647   while (child)
648     numentries++, child = child->next;
649   /* Explicitly handle numentries==0 */
650   if (!numentries)
651     {
652       out = xtrymalloc (3);
653       if (out)
654         strcpy (out, "[]");
655       return out;
656     }
657   /* Allocate an array to hold the values for each */
658   entries = xtrymalloc (numentries * sizeof (char *));
659   if (!entries)
660     return 0;
661   memset (entries, 0, numentries * sizeof (char *));
662   /* Retrieve all the results: */
663   child = item->child;
664   while (child && !fail)
665     {
666       ret = print_value (child, depth + 1, fmt);
667       entries[i++] = ret;
668       if (ret)
669         len += strlen (ret) + 2 + (fmt ? 1 : 0);
670       else
671         fail = 1;
672       child = child->next;
673     }
674
675   /* If we didn't fail, try to xtrymalloc the output string */
676   if (!fail)
677     out = xtrymalloc (len);
678   /* If that fails, we fail. */
679   if (!out)
680     fail = 1;
681
682   /* Handle failure. */
683   if (fail)
684     {
685       for (i = 0; i < numentries; i++)
686         if (entries[i])
687           xfree (entries[i]);
688       xfree (entries);
689       return 0;
690     }
691
692   /* Compose the output array. */
693   *out = '[';
694   ptr = out + 1;
695   *ptr = 0;
696   for (i = 0; i < numentries; i++)
697     {
698       strcpy (ptr, entries[i]);
699       ptr += strlen (entries[i]);
700       if (i != numentries - 1)
701         {
702           *ptr++ = ',';
703           if (fmt)
704             *ptr++ = ' ';
705           *ptr = 0;
706         }
707       xfree (entries[i]);
708     }
709   xfree (entries);
710   *ptr++ = ']';
711   *ptr++ = 0;
712   return out;
713 }
714
715 /* Build an object from the text. */
716 static const char *
717 parse_object (cJSON * item, const char *value, const char **ep)
718 {
719   cJSON *child;
720   if (*value != '{')
721     {
722       *ep = value;
723       return 0;
724     }                           /* not an object! */
725
726   item->type = cJSON_Object;
727   value = skip (value + 1);
728   if (*value == '}')
729     return value + 1;           /* empty array. */
730
731   item->child = child = cJSON_New_Item ();
732   if (!item->child)
733     return 0;
734   value = skip (parse_string (child, skip (value), ep));
735   if (!value)
736     return 0;
737   child->string = child->valuestring;
738   child->valuestring = 0;
739   if (*value != ':')
740     {
741       *ep = value;
742       return 0;
743     }                           /* fail! */
744   /* skip any spacing, get the value. */
745   value = skip (parse_value (child, skip (value + 1), ep));
746   if (!value)
747     return 0;
748
749   while (*value == ',')
750     {
751       cJSON *new_item;
752       if (!(new_item = cJSON_New_Item ()))
753         return 0;               /* memory fail */
754       child->next = new_item;
755       new_item->prev = child;
756       child = new_item;
757       value = skip (parse_string (child, skip (value + 1), ep));
758       if (!value)
759         return 0;
760       child->string = child->valuestring;
761       child->valuestring = 0;
762       if (*value != ':')
763         {
764           *ep = value;
765           return 0;
766         }                       /* fail! */
767       /* skip any spacing, get the value. */
768       value = skip (parse_value (child, skip (value + 1), ep));
769       if (!value)
770         return 0;
771     }
772
773   if (*value == '}')
774     return value + 1;           /* end of array */
775   *ep = value;
776   return 0;                     /* malformed. */
777 }
778
779 /* Render an object to text. */
780 static char *
781 print_object (cJSON * item, int depth, int fmt)
782 {
783   char **entries = 0, **names = 0;
784   char *out = 0, *ptr, *ret, *str;
785   int len = 7, i = 0, j;
786   cJSON *child = item->child;
787   int numentries = 0, fail = 0;
788   /* Count the number of entries. */
789   while (child)
790     numentries++, child = child->next;
791   /* Explicitly handle empty object case */
792   if (!numentries)
793     {
794       out = xtrymalloc (fmt ? depth + 4 : 3);
795       if (!out)
796         return 0;
797       ptr = out;
798       *ptr++ = '{';
799       if (fmt)
800         {
801           *ptr++ = '\n';
802           for (i = 0; i < depth - 1; i++)
803             *ptr++ = '\t';
804         }
805       *ptr++ = '}';
806       *ptr++ = 0;
807       return out;
808     }
809   /* Allocate space for the names and the objects */
810   entries = xtrymalloc (numentries * sizeof (char *));
811   if (!entries)
812     return 0;
813   names = xtrymalloc (numentries * sizeof (char *));
814   if (!names)
815     {
816       xfree (entries);
817       return 0;
818     }
819   memset (entries, 0, sizeof (char *) * numentries);
820   memset (names, 0, sizeof (char *) * numentries);
821
822   /* Collect all the results into our arrays: */
823   child = item->child;
824   depth++;
825   if (fmt)
826     len += depth;
827   while (child)
828     {
829       names[i] = str = print_string_ptr (child->string);
830       entries[i++] = ret = print_value (child, depth, fmt);
831       if (str && ret)
832         len += strlen (ret) + strlen (str) + 2 + (fmt ? 2 + depth : 0);
833       else
834         fail = 1;
835       child = child->next;
836     }
837
838   /* Try to allocate the output string */
839   if (!fail)
840     out = xtrymalloc (len);
841   if (!out)
842     fail = 1;
843
844   /* Handle failure */
845   if (fail)
846     {
847       for (i = 0; i < numentries; i++)
848         {
849           if (names[i])
850             xfree (names[i]);
851           if (entries[i])
852             xfree (entries[i]);
853         }
854       xfree (names);
855       xfree (entries);
856       return 0;
857     }
858
859   /* Compose the output: */
860   *out = '{';
861   ptr = out + 1;
862   if (fmt)
863     *ptr++ = '\n';
864   *ptr = 0;
865   for (i = 0; i < numentries; i++)
866     {
867       if (fmt)
868         for (j = 0; j < depth; j++)
869           *ptr++ = '\t';
870       strcpy (ptr, names[i]);
871       ptr += strlen (names[i]);
872       *ptr++ = ':';
873       if (fmt)
874         *ptr++ = '\t';
875       strcpy (ptr, entries[i]);
876       ptr += strlen (entries[i]);
877       if (i != numentries - 1)
878         *ptr++ = ',';
879       if (fmt)
880         *ptr++ = '\n';
881       *ptr = 0;
882       xfree (names[i]);
883       xfree (entries[i]);
884     }
885
886   xfree (names);
887   xfree (entries);
888   if (fmt)
889     for (i = 0; i < depth - 1; i++)
890       *ptr++ = '\t';
891   *ptr++ = '}';
892   *ptr++ = 0;
893   return out;
894 }
895
896 /* Get Array size/item / object item. */
897 int
898 cJSON_GetArraySize (cJSON * array)
899 {
900   cJSON *c = array->child;
901   int i = 0;
902   while (c)
903     i++, c = c->next;
904   return i;
905 }
906
907 cJSON *
908 cJSON_GetArrayItem (cJSON * array, int item)
909 {
910   cJSON *c = array->child;
911   while (c && item > 0)
912     item--, c = c->next;
913   return c;
914 }
915
916 cJSON *
917 cJSON_GetObjectItem (cJSON * object, const char *string)
918 {
919   cJSON *c = object->child;
920   while (c && cJSON_strcasecmp (c->string, string))
921     c = c->next;
922   return c;
923 }
924
925 /* Utility for array list handling. */
926 static void
927 suffix_object (cJSON * prev, cJSON * item)
928 {
929   prev->next = item;
930   item->prev = prev;
931 }
932
933 /* Utility for handling references. */
934 static cJSON *
935 create_reference (cJSON * item)
936 {
937   cJSON *ref = cJSON_New_Item ();
938   if (!ref)
939     return 0;
940   memcpy (ref, item, sizeof (cJSON));
941   ref->string = 0;
942   ref->type |= cJSON_IsReference;
943   ref->next = ref->prev = 0;
944   return ref;
945 }
946
947 /* Add item to array/object. */
948 void
949 cJSON_AddItemToArray (cJSON * array, cJSON * item)
950 {
951   cJSON *c;
952
953   if (!item || !array)
954     return;
955   c = array->child;
956   if (!c)
957     {
958       array->child = item;
959     }
960   else
961     {
962       while (c && c->next)
963         c = c->next;
964       suffix_object (c, item);
965     }
966 }
967
968 cJSON *
969 cJSON_AddItemToObject (cJSON * object, const char *string, cJSON * item)
970 {
971   char *tmp;
972
973   if (!item)
974     return 0;
975   tmp = xtrystrdup (string);
976   if (!tmp)
977     return NULL;
978
979   if (item->string)
980     xfree (item->string);
981   item->string = tmp;
982   cJSON_AddItemToArray (object, item);
983   return object;
984 }
985
986 cJSON *
987 cJSON_AddNullToObject (cJSON *object, const char *name)
988 {
989   cJSON *obj, *tmp;
990
991   tmp = cJSON_CreateNull ();
992   if (!tmp)
993     return NULL;
994   obj = cJSON_AddItemToObject(object, name, tmp);
995   if (!obj)
996     cJSON_Delete (tmp);
997   return obj;
998 }
999
1000 cJSON *
1001 cJSON_AddTrueToObject (cJSON *object, const char *name)
1002 {
1003   cJSON *obj, *tmp;
1004
1005   tmp = cJSON_CreateTrue ();
1006   if (!tmp)
1007     return NULL;
1008   obj = cJSON_AddItemToObject(object, name, tmp);
1009   if (!obj)
1010     cJSON_Delete (tmp);
1011   return obj;
1012 }
1013
1014 cJSON *
1015 cJSON_AddFalseToObject (cJSON *object, const char *name)
1016 {
1017   cJSON *obj, *tmp;
1018
1019   tmp = cJSON_CreateFalse ();
1020   if (!tmp)
1021     return NULL;
1022   obj = cJSON_AddItemToObject(object, name, tmp);
1023   if (!obj)
1024     cJSON_Delete (tmp);
1025   return obj;
1026 }
1027
1028 cJSON *
1029 cJSON_AddBoolToObject (cJSON *object, const char *name, int b)
1030 {
1031   cJSON *obj, *tmp;
1032
1033   tmp = cJSON_CreateBool (b);
1034   if (!tmp)
1035     return NULL;
1036   obj = cJSON_AddItemToObject(object, name, tmp);
1037   if (!obj)
1038     cJSON_Delete (tmp);
1039   return obj;
1040 }
1041
1042 cJSON *
1043 cJSON_AddNumberToObject (cJSON *object, const char *name, double num)
1044 {
1045   cJSON *obj, *tmp;
1046
1047   tmp = cJSON_CreateNumber (num);
1048   if (!tmp)
1049     return NULL;
1050   obj = cJSON_AddItemToObject(object, name, tmp);
1051   if (!obj)
1052     cJSON_Delete (tmp);
1053   return obj;
1054 }
1055
1056 cJSON *
1057 cJSON_AddStringToObject (cJSON *object, const char *name, const char *string)
1058 {
1059   cJSON *obj, *tmp;
1060
1061   tmp = cJSON_CreateString (string);
1062   if (!tmp)
1063     return NULL;
1064   obj = cJSON_AddItemToObject(object, name, tmp);
1065   if (!obj)
1066     cJSON_Delete (tmp);
1067   return obj;
1068 }
1069
1070 void
1071 cJSON_AddItemReferenceToArray (cJSON * array, cJSON * item)
1072 {
1073   cJSON_AddItemToArray (array, create_reference (item));
1074 }
1075
1076 void
1077 cJSON_AddItemReferenceToObject (cJSON * object, const char *string,
1078                                 cJSON * item)
1079 {
1080   cJSON_AddItemToObject (object, string, create_reference (item));
1081 }
1082
1083 cJSON *
1084 cJSON_DetachItemFromArray (cJSON * array, int which)
1085 {
1086   cJSON *c = array->child;
1087   while (c && which > 0)
1088     c = c->next, which--;
1089   if (!c)
1090     return 0;
1091   if (c->prev)
1092     c->prev->next = c->next;
1093   if (c->next)
1094     c->next->prev = c->prev;
1095   if (c == array->child)
1096     array->child = c->next;
1097   c->prev = c->next = 0;
1098   return c;
1099 }
1100
1101 void
1102 cJSON_DeleteItemFromArray (cJSON * array, int which)
1103 {
1104   cJSON_Delete (cJSON_DetachItemFromArray (array, which));
1105 }
1106
1107 cJSON *
1108 cJSON_DetachItemFromObject (cJSON * object, const char *string)
1109 {
1110   int i = 0;
1111   cJSON *c = object->child;
1112   while (c && cJSON_strcasecmp (c->string, string))
1113     i++, c = c->next;
1114   if (c)
1115     return cJSON_DetachItemFromArray (object, i);
1116   return 0;
1117 }
1118
1119 void
1120 cJSON_DeleteItemFromObject (cJSON * object, const char *string)
1121 {
1122   cJSON_Delete (cJSON_DetachItemFromObject (object, string));
1123 }
1124
1125 /* Replace array/object items with new ones. */
1126 void
1127 cJSON_ReplaceItemInArray (cJSON * array, int which, cJSON * newitem)
1128 {
1129   cJSON *c = array->child;
1130   while (c && which > 0)
1131     c = c->next, which--;
1132   if (!c)
1133     return;
1134   newitem->next = c->next;
1135   newitem->prev = c->prev;
1136   if (newitem->next)
1137     newitem->next->prev = newitem;
1138   if (c == array->child)
1139     array->child = newitem;
1140   else
1141     newitem->prev->next = newitem;
1142   c->next = c->prev = 0;
1143   cJSON_Delete (c);
1144 }
1145
1146 void
1147 cJSON_ReplaceItemInObject (cJSON * object, const char *string,
1148                            cJSON * newitem)
1149 {
1150   int i = 0;
1151   cJSON *c = object->child;
1152   while (c && cJSON_strcasecmp (c->string, string))
1153     i++, c = c->next;
1154   if (c)
1155     {
1156       /* FIXME: I guess we should free newitem->string here.  See
1157        * upstream commit 0d10e279c8b604f71829b5d49d092719f4ae96b6.  */
1158       newitem->string = xtrystrdup (string);
1159       cJSON_ReplaceItemInArray (object, i, newitem);
1160     }
1161 }
1162
1163 /* Create basic types: */
1164 cJSON *
1165 cJSON_CreateNull (void)
1166 {
1167   cJSON *item = cJSON_New_Item ();
1168   if (item)
1169     item->type = cJSON_NULL;
1170   return item;
1171 }
1172
1173 cJSON *
1174 cJSON_CreateTrue (void)
1175 {
1176   cJSON *item = cJSON_New_Item ();
1177   if (item)
1178     item->type = cJSON_True;
1179   return item;
1180 }
1181
1182 cJSON *
1183 cJSON_CreateFalse (void)
1184 {
1185   cJSON *item = cJSON_New_Item ();
1186   if (item)
1187     item->type = cJSON_False;
1188   return item;
1189 }
1190
1191 cJSON *
1192 cJSON_CreateBool (int b)
1193 {
1194   cJSON *item = cJSON_New_Item ();
1195   if (item)
1196     item->type = b ? cJSON_True : cJSON_False;
1197   return item;
1198 }
1199
1200 cJSON *
1201 cJSON_CreateNumber (double num)
1202 {
1203   cJSON *item = cJSON_New_Item ();
1204   if (item)
1205     {
1206       item->type = cJSON_Number;
1207       item->valuedouble = num;
1208       item->valueint = (int) num;
1209     }
1210   return item;
1211 }
1212
1213 cJSON *
1214 cJSON_CreateString (const char *string)
1215 {
1216   cJSON *item = cJSON_New_Item ();
1217   if (item)
1218     {
1219       item->type = cJSON_String;
1220       item->valuestring = xtrystrdup (string);
1221     }
1222   return item;
1223 }
1224
1225 cJSON *
1226 cJSON_CreateStringConvey (char *string)
1227 {
1228   cJSON *item = cJSON_New_Item ();
1229   if (item)
1230     {
1231       item->type = cJSON_String;
1232       item->valuestring = string;
1233     }
1234   return item;
1235 }
1236
1237 cJSON *
1238 cJSON_CreateArray (void)
1239 {
1240   cJSON *item = cJSON_New_Item ();
1241   if (item)
1242     item->type = cJSON_Array;
1243   return item;
1244 }
1245
1246 cJSON *
1247 cJSON_CreateObject (void)
1248 {
1249   cJSON *item = cJSON_New_Item ();
1250   if (item)
1251     item->type = cJSON_Object;
1252   return item;
1253 }
1254
1255 /* Create Arrays: */
1256 cJSON *
1257 cJSON_CreateIntArray (const int *numbers, int count)
1258 {
1259   int i;
1260   cJSON *n = 0, *p = 0, *a = cJSON_CreateArray ();
1261   for (i = 0; a && i < count; i++)
1262     {
1263       n = cJSON_CreateNumber (numbers[i]);
1264       if (!i)
1265         a->child = n;
1266       else
1267         suffix_object (p, n);
1268       p = n;
1269     }
1270   return a;
1271 }
1272
1273 cJSON *
1274 cJSON_CreateFloatArray (const float *numbers, int count)
1275 {
1276   int i;
1277   cJSON *n = 0, *p = 0, *a = cJSON_CreateArray ();
1278   for (i = 0; a && i < count; i++)
1279     {
1280       n = cJSON_CreateNumber (numbers[i]);
1281       if (!i)
1282         a->child = n;
1283       else
1284         suffix_object (p, n);
1285       p = n;
1286     }
1287   return a;
1288 }
1289
1290 cJSON *
1291 cJSON_CreateDoubleArray (const double *numbers, int count)
1292 {
1293   int i;
1294   cJSON *n = 0, *p = 0, *a = cJSON_CreateArray ();
1295   for (i = 0; a && i < count; i++)
1296     {
1297       n = cJSON_CreateNumber (numbers[i]);
1298       if (!i)
1299         a->child = n;
1300       else
1301         suffix_object (p, n);
1302       p = n;
1303     }
1304   return a;
1305 }
1306
1307 cJSON *
1308 cJSON_CreateStringArray (const char **strings, int count)
1309 {
1310   int i;
1311   cJSON *n = 0, *p = 0, *a = cJSON_CreateArray ();
1312   for (i = 0; a && i < count; i++)
1313     {
1314       n = cJSON_CreateString (strings[i]);
1315       if (!i)
1316         a->child = n;
1317       else
1318         suffix_object (p, n);
1319       p = n;
1320     }
1321   return a;
1322 }
1323
1324 /* Duplication */
1325 cJSON *
1326 cJSON_Duplicate (cJSON * item, int recurse)
1327 {
1328   cJSON *newitem, *cptr, *nptr = 0, *newchild;
1329   /* Bail on bad ptr */
1330   if (!item)
1331     return 0;
1332   /* Create new item */
1333   newitem = cJSON_New_Item ();
1334   if (!newitem)
1335     return 0;
1336   /* Copy over all vars */
1337   newitem->type = item->type & (~cJSON_IsReference), newitem->valueint =
1338     item->valueint, newitem->valuedouble = item->valuedouble;
1339   if (item->valuestring)
1340     {
1341       newitem->valuestring = xtrystrdup (item->valuestring);
1342       if (!newitem->valuestring)
1343         {
1344           cJSON_Delete (newitem);
1345           return 0;
1346         }
1347     }
1348   if (item->string)
1349     {
1350       newitem->string = xtrystrdup (item->string);
1351       if (!newitem->string)
1352         {
1353           cJSON_Delete (newitem);
1354           return 0;
1355         }
1356     }
1357   /* If non-recursive, then we're done! */
1358   if (!recurse)
1359     return newitem;
1360   /* Walk the ->next chain for the child. */
1361   cptr = item->child;
1362   while (cptr)
1363     {
1364       /* Duplicate (with recurse) each item in the ->next chain */
1365       newchild = cJSON_Duplicate (cptr, 1);
1366       if (!newchild)
1367         {
1368           cJSON_Delete (newitem);
1369           return 0;
1370         }
1371       if (nptr)
1372         {
1373           /* If newitem->child already set,
1374            * then crosswire ->prev and ->next and move on.  */
1375           nptr->next = newchild, newchild->prev = nptr;
1376           nptr = newchild;
1377         }
1378       else
1379         {
1380           /* Set newitem->child and move to it.  */
1381           newitem->child = newchild;
1382           nptr = newchild;
1383         }
1384       cptr = cptr->next;
1385     }
1386   return newitem;
1387 }
1388
1389 void
1390 cJSON_Minify (char *json)
1391 {
1392   char *into = json;
1393   while (*json)
1394     {
1395       if (*json == ' ')
1396         json++;
1397       else if (*json == '\t')
1398         json++;                 /* Whitespace characters.  */
1399       else if (*json == '\r')
1400         json++;
1401       else if (*json == '\n')
1402         json++;
1403       else if (*json == '/' && json[1] == '/')
1404         while (*json && *json != '\n')
1405           json++;               /* Double-slash comments, to end of line.  */
1406       else if (*json == '/' && json[1] == '*')
1407         {
1408           while (*json && !(*json == '*' && json[1] == '/'))
1409             json++;
1410           json += 2;
1411         }                       /* Multiline comments.  */
1412       else if (*json == '\"')
1413         {
1414           *into++ = *json++;
1415           while (*json && *json != '\"')
1416             {
1417               if (*json == '\\')
1418                 *into++ = *json++;
1419               *into++ = *json++;
1420             }
1421           *into++ = *json++;
1422         }                       /* String literals, which are \" sensitive.  */
1423       else
1424         *into++ = *json++;      /* All other characters.  */
1425     }
1426   *into = 0;                    /* and null-terminate.  */
1427 }