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