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