LCOV - code coverage report
Current view: top level - src - cJSON.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 387 815 47.5 %
Date: 2018-11-15 08:49:49 Functions: 33 56 58.9 %

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

Generated by: LCOV version 1.13