Axeda Ready Demo for Freescale FRDM-KL46Z as accident alert system
Dependencies: FRDM_MMA8451Q KL46Z-USBHost MAG3110 SocketModem TSI mbed FATFileSystem
Fork of AxedaGo-Freescal_FRDM-KL46Z by
cJSON/cJSON.c@0:65004368569c, 2014-07-01 (annotated)
- Committer:
- AxedaCorp
- Date:
- Tue Jul 01 21:31:54 2014 +0000
- Revision:
- 0:65004368569c
Made initial
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
AxedaCorp | 0:65004368569c | 1 | /* |
AxedaCorp | 0:65004368569c | 2 | Copyright (c) 2009 Dave Gamble |
AxedaCorp | 0:65004368569c | 3 | |
AxedaCorp | 0:65004368569c | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy |
AxedaCorp | 0:65004368569c | 5 | of this software and associated documentation files (the "Software"), to deal |
AxedaCorp | 0:65004368569c | 6 | in the Software without restriction, including without limitation the rights |
AxedaCorp | 0:65004368569c | 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
AxedaCorp | 0:65004368569c | 8 | copies of the Software, and to permit persons to whom the Software is |
AxedaCorp | 0:65004368569c | 9 | furnished to do so, subject to the following conditions: |
AxedaCorp | 0:65004368569c | 10 | |
AxedaCorp | 0:65004368569c | 11 | The above copyright notice and this permission notice shall be included in |
AxedaCorp | 0:65004368569c | 12 | all copies or substantial portions of the Software. |
AxedaCorp | 0:65004368569c | 13 | |
AxedaCorp | 0:65004368569c | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
AxedaCorp | 0:65004368569c | 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
AxedaCorp | 0:65004368569c | 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
AxedaCorp | 0:65004368569c | 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
AxedaCorp | 0:65004368569c | 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
AxedaCorp | 0:65004368569c | 19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
AxedaCorp | 0:65004368569c | 20 | THE SOFTWARE. |
AxedaCorp | 0:65004368569c | 21 | */ |
AxedaCorp | 0:65004368569c | 22 | |
AxedaCorp | 0:65004368569c | 23 | /* cJSON */ |
AxedaCorp | 0:65004368569c | 24 | /* JSON parser in C. */ |
AxedaCorp | 0:65004368569c | 25 | |
AxedaCorp | 0:65004368569c | 26 | #include <string.h> |
AxedaCorp | 0:65004368569c | 27 | #include <stdio.h> |
AxedaCorp | 0:65004368569c | 28 | #include <math.h> |
AxedaCorp | 0:65004368569c | 29 | #include <stdlib.h> |
AxedaCorp | 0:65004368569c | 30 | #include <float.h> |
AxedaCorp | 0:65004368569c | 31 | #include <limits.h> |
AxedaCorp | 0:65004368569c | 32 | #include <ctype.h> |
AxedaCorp | 0:65004368569c | 33 | #include "cJSON.h" |
AxedaCorp | 0:65004368569c | 34 | |
AxedaCorp | 0:65004368569c | 35 | static const char *ep; |
AxedaCorp | 0:65004368569c | 36 | |
AxedaCorp | 0:65004368569c | 37 | const char *cJSON_GetErrorPtr() {return ep;} |
AxedaCorp | 0:65004368569c | 38 | |
AxedaCorp | 0:65004368569c | 39 | static int cJSON_strcasecmp(const char *s1,const char *s2) |
AxedaCorp | 0:65004368569c | 40 | { |
AxedaCorp | 0:65004368569c | 41 | if (!s1) return (s1==s2)?0:1;if (!s2) return 1; |
AxedaCorp | 0:65004368569c | 42 | for(; tolower(*s1) == tolower(*s2); ++s1, ++s2) if(*s1 == 0) return 0; |
AxedaCorp | 0:65004368569c | 43 | return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2); |
AxedaCorp | 0:65004368569c | 44 | } |
AxedaCorp | 0:65004368569c | 45 | |
AxedaCorp | 0:65004368569c | 46 | static void *(*cJSON_malloc)(size_t sz) = malloc; |
AxedaCorp | 0:65004368569c | 47 | static void (*cJSON_free)(void *ptr) = free; |
AxedaCorp | 0:65004368569c | 48 | |
AxedaCorp | 0:65004368569c | 49 | static char* cJSON_strdup(const char* str) |
AxedaCorp | 0:65004368569c | 50 | { |
AxedaCorp | 0:65004368569c | 51 | size_t len; |
AxedaCorp | 0:65004368569c | 52 | char* copy; |
AxedaCorp | 0:65004368569c | 53 | |
AxedaCorp | 0:65004368569c | 54 | len = strlen(str) + 1; |
AxedaCorp | 0:65004368569c | 55 | if (!(copy = (char*)cJSON_malloc(len))) return 0; |
AxedaCorp | 0:65004368569c | 56 | memcpy(copy,str,len); |
AxedaCorp | 0:65004368569c | 57 | return copy; |
AxedaCorp | 0:65004368569c | 58 | } |
AxedaCorp | 0:65004368569c | 59 | |
AxedaCorp | 0:65004368569c | 60 | void cJSON_InitHooks(cJSON_Hooks* hooks) |
AxedaCorp | 0:65004368569c | 61 | { |
AxedaCorp | 0:65004368569c | 62 | if (!hooks) { /* Reset hooks */ |
AxedaCorp | 0:65004368569c | 63 | cJSON_malloc = malloc; |
AxedaCorp | 0:65004368569c | 64 | cJSON_free = free; |
AxedaCorp | 0:65004368569c | 65 | return; |
AxedaCorp | 0:65004368569c | 66 | } |
AxedaCorp | 0:65004368569c | 67 | |
AxedaCorp | 0:65004368569c | 68 | cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc; |
AxedaCorp | 0:65004368569c | 69 | cJSON_free = (hooks->free_fn)?hooks->free_fn:free; |
AxedaCorp | 0:65004368569c | 70 | } |
AxedaCorp | 0:65004368569c | 71 | |
AxedaCorp | 0:65004368569c | 72 | /* Internal constructor. */ |
AxedaCorp | 0:65004368569c | 73 | static cJSON *cJSON_New_Item() |
AxedaCorp | 0:65004368569c | 74 | { |
AxedaCorp | 0:65004368569c | 75 | cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON)); |
AxedaCorp | 0:65004368569c | 76 | if (node) memset(node,0,sizeof(cJSON)); |
AxedaCorp | 0:65004368569c | 77 | return node; |
AxedaCorp | 0:65004368569c | 78 | } |
AxedaCorp | 0:65004368569c | 79 | |
AxedaCorp | 0:65004368569c | 80 | /* Delete a cJSON structure. */ |
AxedaCorp | 0:65004368569c | 81 | void cJSON_Delete(cJSON *c) |
AxedaCorp | 0:65004368569c | 82 | { |
AxedaCorp | 0:65004368569c | 83 | cJSON *next; |
AxedaCorp | 0:65004368569c | 84 | while (c) |
AxedaCorp | 0:65004368569c | 85 | { |
AxedaCorp | 0:65004368569c | 86 | next=c->next; |
AxedaCorp | 0:65004368569c | 87 | if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child); |
AxedaCorp | 0:65004368569c | 88 | if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring); |
AxedaCorp | 0:65004368569c | 89 | if (c->string) cJSON_free(c->string); |
AxedaCorp | 0:65004368569c | 90 | cJSON_free(c); |
AxedaCorp | 0:65004368569c | 91 | c=next; |
AxedaCorp | 0:65004368569c | 92 | } |
AxedaCorp | 0:65004368569c | 93 | } |
AxedaCorp | 0:65004368569c | 94 | |
AxedaCorp | 0:65004368569c | 95 | /* Parse the input text to generate a number, and populate the result into item. */ |
AxedaCorp | 0:65004368569c | 96 | static const char *parse_number(cJSON *item,const char *num) |
AxedaCorp | 0:65004368569c | 97 | { |
AxedaCorp | 0:65004368569c | 98 | double n=0,sign=1,scale=0;int subscale=0,signsubscale=1; |
AxedaCorp | 0:65004368569c | 99 | |
AxedaCorp | 0:65004368569c | 100 | /* Could use sscanf for this? */ |
AxedaCorp | 0:65004368569c | 101 | if (*num=='-') sign=-1,num++; /* Has sign? */ |
AxedaCorp | 0:65004368569c | 102 | if (*num=='0') num++; /* is zero */ |
AxedaCorp | 0:65004368569c | 103 | if (*num>='1' && *num<='9') do n=(n*10.0)+(*num++ -'0'); while (*num>='0' && *num<='9'); /* Number? */ |
AxedaCorp | 0:65004368569c | 104 | if (*num=='.' && num[1]>='0' && num[1]<='9') {num++; do n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');} /* Fractional part? */ |
AxedaCorp | 0:65004368569c | 105 | if (*num=='e' || *num=='E') /* Exponent? */ |
AxedaCorp | 0:65004368569c | 106 | { num++;if (*num=='+') num++; else if (*num=='-') signsubscale=-1,num++; /* With sign? */ |
AxedaCorp | 0:65004368569c | 107 | while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0'); /* Number? */ |
AxedaCorp | 0:65004368569c | 108 | } |
AxedaCorp | 0:65004368569c | 109 | |
AxedaCorp | 0:65004368569c | 110 | n=sign*n*pow(10.0,(scale+subscale*signsubscale)); /* number = +/- number.fraction * 10^+/- exponent */ |
AxedaCorp | 0:65004368569c | 111 | |
AxedaCorp | 0:65004368569c | 112 | item->valuedouble=n; |
AxedaCorp | 0:65004368569c | 113 | item->valueint=(int)n; |
AxedaCorp | 0:65004368569c | 114 | item->type=cJSON_Number; |
AxedaCorp | 0:65004368569c | 115 | return num; |
AxedaCorp | 0:65004368569c | 116 | } |
AxedaCorp | 0:65004368569c | 117 | |
AxedaCorp | 0:65004368569c | 118 | /* Render the number nicely from the given item into a string. */ |
AxedaCorp | 0:65004368569c | 119 | static char *print_number(cJSON *item) |
AxedaCorp | 0:65004368569c | 120 | { |
AxedaCorp | 0:65004368569c | 121 | char *str; |
AxedaCorp | 0:65004368569c | 122 | double d=item->valuedouble; |
AxedaCorp | 0:65004368569c | 123 | if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN) |
AxedaCorp | 0:65004368569c | 124 | { |
AxedaCorp | 0:65004368569c | 125 | str=(char*)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */ |
AxedaCorp | 0:65004368569c | 126 | if (str) sprintf(str,"%d",item->valueint); |
AxedaCorp | 0:65004368569c | 127 | } |
AxedaCorp | 0:65004368569c | 128 | else |
AxedaCorp | 0:65004368569c | 129 | { |
AxedaCorp | 0:65004368569c | 130 | str=(char*)cJSON_malloc(64); /* This is a nice tradeoff. */ |
AxedaCorp | 0:65004368569c | 131 | if (str) |
AxedaCorp | 0:65004368569c | 132 | { |
AxedaCorp | 0:65004368569c | 133 | if (fabs(floor(d)-d)<=DBL_EPSILON) sprintf(str,"%.0f",d); |
AxedaCorp | 0:65004368569c | 134 | else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9) sprintf(str,"%e",d); |
AxedaCorp | 0:65004368569c | 135 | else sprintf(str,"%f",d); |
AxedaCorp | 0:65004368569c | 136 | } |
AxedaCorp | 0:65004368569c | 137 | } |
AxedaCorp | 0:65004368569c | 138 | return str; |
AxedaCorp | 0:65004368569c | 139 | } |
AxedaCorp | 0:65004368569c | 140 | |
AxedaCorp | 0:65004368569c | 141 | /* Parse the input text into an unescaped cstring, and populate item. */ |
AxedaCorp | 0:65004368569c | 142 | static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; |
AxedaCorp | 0:65004368569c | 143 | static const char *parse_string(cJSON *item,const char *str) |
AxedaCorp | 0:65004368569c | 144 | { |
AxedaCorp | 0:65004368569c | 145 | const char *ptr=str+1;char *ptr2;char *out;int len=0;unsigned uc,uc2; |
AxedaCorp | 0:65004368569c | 146 | if (*str!='\"') {ep=str;return 0;} /* not a string! */ |
AxedaCorp | 0:65004368569c | 147 | |
AxedaCorp | 0:65004368569c | 148 | while (*ptr!='\"' && *ptr && ++len) if (*ptr++ == '\\') ptr++; /* Skip escaped quotes. */ |
AxedaCorp | 0:65004368569c | 149 | |
AxedaCorp | 0:65004368569c | 150 | out=(char*)cJSON_malloc(len+1); /* This is how long we need for the string, roughly. */ |
AxedaCorp | 0:65004368569c | 151 | if (!out) return 0; |
AxedaCorp | 0:65004368569c | 152 | |
AxedaCorp | 0:65004368569c | 153 | ptr=str+1;ptr2=out; |
AxedaCorp | 0:65004368569c | 154 | while (*ptr!='\"' && *ptr) |
AxedaCorp | 0:65004368569c | 155 | { |
AxedaCorp | 0:65004368569c | 156 | if (*ptr!='\\') *ptr2++=*ptr++; |
AxedaCorp | 0:65004368569c | 157 | else |
AxedaCorp | 0:65004368569c | 158 | { |
AxedaCorp | 0:65004368569c | 159 | ptr++; |
AxedaCorp | 0:65004368569c | 160 | switch (*ptr) |
AxedaCorp | 0:65004368569c | 161 | { |
AxedaCorp | 0:65004368569c | 162 | case 'b': *ptr2++='\b'; break; |
AxedaCorp | 0:65004368569c | 163 | case 'f': *ptr2++='\f'; break; |
AxedaCorp | 0:65004368569c | 164 | case 'n': *ptr2++='\n'; break; |
AxedaCorp | 0:65004368569c | 165 | case 'r': *ptr2++='\r'; break; |
AxedaCorp | 0:65004368569c | 166 | case 't': *ptr2++='\t'; break; |
AxedaCorp | 0:65004368569c | 167 | case 'u': /* transcode utf16 to utf8. */ |
AxedaCorp | 0:65004368569c | 168 | sscanf(ptr+1,"%4x",&uc);ptr+=4; /* get the unicode char. */ |
AxedaCorp | 0:65004368569c | 169 | |
AxedaCorp | 0:65004368569c | 170 | if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0) break; // check for invalid. |
AxedaCorp | 0:65004368569c | 171 | |
AxedaCorp | 0:65004368569c | 172 | if (uc>=0xD800 && uc<=0xDBFF) // UTF16 surrogate pairs. |
AxedaCorp | 0:65004368569c | 173 | { |
AxedaCorp | 0:65004368569c | 174 | if (ptr[1]!='\\' || ptr[2]!='u') break; // missing second-half of surrogate. |
AxedaCorp | 0:65004368569c | 175 | sscanf(ptr+3,"%4x",&uc2);ptr+=6; |
AxedaCorp | 0:65004368569c | 176 | if (uc2<0xDC00 || uc2>0xDFFF) break; // invalid second-half of surrogate. |
AxedaCorp | 0:65004368569c | 177 | uc=0x10000 | ((uc&0x3FF)<<10) | (uc2&0x3FF); |
AxedaCorp | 0:65004368569c | 178 | } |
AxedaCorp | 0:65004368569c | 179 | |
AxedaCorp | 0:65004368569c | 180 | len=4;if (uc<0x80) len=1;else if (uc<0x800) len=2;else if (uc<0x10000) len=3; ptr2+=len; |
AxedaCorp | 0:65004368569c | 181 | |
AxedaCorp | 0:65004368569c | 182 | switch (len) { |
AxedaCorp | 0:65004368569c | 183 | case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; |
AxedaCorp | 0:65004368569c | 184 | case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; |
AxedaCorp | 0:65004368569c | 185 | case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; |
AxedaCorp | 0:65004368569c | 186 | case 1: *--ptr2 =(uc | firstByteMark[len]); |
AxedaCorp | 0:65004368569c | 187 | } |
AxedaCorp | 0:65004368569c | 188 | ptr2+=len; |
AxedaCorp | 0:65004368569c | 189 | break; |
AxedaCorp | 0:65004368569c | 190 | default: *ptr2++=*ptr; break; |
AxedaCorp | 0:65004368569c | 191 | } |
AxedaCorp | 0:65004368569c | 192 | ptr++; |
AxedaCorp | 0:65004368569c | 193 | } |
AxedaCorp | 0:65004368569c | 194 | } |
AxedaCorp | 0:65004368569c | 195 | *ptr2=0; |
AxedaCorp | 0:65004368569c | 196 | if (*ptr=='\"') ptr++; |
AxedaCorp | 0:65004368569c | 197 | item->valuestring=out; |
AxedaCorp | 0:65004368569c | 198 | item->type=cJSON_String; |
AxedaCorp | 0:65004368569c | 199 | return ptr; |
AxedaCorp | 0:65004368569c | 200 | } |
AxedaCorp | 0:65004368569c | 201 | |
AxedaCorp | 0:65004368569c | 202 | /* Render the cstring provided to an escaped version that can be printed. */ |
AxedaCorp | 0:65004368569c | 203 | static char *print_string_ptr(const char *str) |
AxedaCorp | 0:65004368569c | 204 | { |
AxedaCorp | 0:65004368569c | 205 | const char *ptr;char *ptr2,*out;int len=0;unsigned char token; |
AxedaCorp | 0:65004368569c | 206 | |
AxedaCorp | 0:65004368569c | 207 | if (!str) return cJSON_strdup(""); |
AxedaCorp | 0:65004368569c | 208 | ptr=str;while ((token=*ptr) && ++len) {if (strchr("\"\\\b\f\n\r\t",token)) len++; else if (token<32) len+=5;ptr++;} |
AxedaCorp | 0:65004368569c | 209 | |
AxedaCorp | 0:65004368569c | 210 | out=(char*)cJSON_malloc(len+3); |
AxedaCorp | 0:65004368569c | 211 | if (!out) return 0; |
AxedaCorp | 0:65004368569c | 212 | |
AxedaCorp | 0:65004368569c | 213 | ptr2=out;ptr=str; |
AxedaCorp | 0:65004368569c | 214 | *ptr2++='\"'; |
AxedaCorp | 0:65004368569c | 215 | while (*ptr) |
AxedaCorp | 0:65004368569c | 216 | { |
AxedaCorp | 0:65004368569c | 217 | if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++; |
AxedaCorp | 0:65004368569c | 218 | else |
AxedaCorp | 0:65004368569c | 219 | { |
AxedaCorp | 0:65004368569c | 220 | *ptr2++='\\'; |
AxedaCorp | 0:65004368569c | 221 | switch (token=*ptr++) |
AxedaCorp | 0:65004368569c | 222 | { |
AxedaCorp | 0:65004368569c | 223 | case '\\': *ptr2++='\\'; break; |
AxedaCorp | 0:65004368569c | 224 | case '\"': *ptr2++='\"'; break; |
AxedaCorp | 0:65004368569c | 225 | case '\b': *ptr2++='b'; break; |
AxedaCorp | 0:65004368569c | 226 | case '\f': *ptr2++='f'; break; |
AxedaCorp | 0:65004368569c | 227 | case '\n': *ptr2++='n'; break; |
AxedaCorp | 0:65004368569c | 228 | case '\r': *ptr2++='r'; break; |
AxedaCorp | 0:65004368569c | 229 | case '\t': *ptr2++='t'; break; |
AxedaCorp | 0:65004368569c | 230 | default: sprintf(ptr2,"u%04x",token);ptr2+=5; break; /* escape and print */ |
AxedaCorp | 0:65004368569c | 231 | } |
AxedaCorp | 0:65004368569c | 232 | } |
AxedaCorp | 0:65004368569c | 233 | } |
AxedaCorp | 0:65004368569c | 234 | *ptr2++='\"';*ptr2++=0; |
AxedaCorp | 0:65004368569c | 235 | return out; |
AxedaCorp | 0:65004368569c | 236 | } |
AxedaCorp | 0:65004368569c | 237 | /* Invote print_string_ptr (which is useful) on an item. */ |
AxedaCorp | 0:65004368569c | 238 | static char *print_string(cJSON *item) {return print_string_ptr(item->valuestring);} |
AxedaCorp | 0:65004368569c | 239 | |
AxedaCorp | 0:65004368569c | 240 | /* Predeclare these prototypes. */ |
AxedaCorp | 0:65004368569c | 241 | static const char *parse_value(cJSON *item,const char *value); |
AxedaCorp | 0:65004368569c | 242 | static char *print_value(cJSON *item,int depth,int fmt); |
AxedaCorp | 0:65004368569c | 243 | static const char *parse_array(cJSON *item,const char *value); |
AxedaCorp | 0:65004368569c | 244 | static char *print_array(cJSON *item,int depth,int fmt); |
AxedaCorp | 0:65004368569c | 245 | static const char *parse_object(cJSON *item,const char *value); |
AxedaCorp | 0:65004368569c | 246 | static char *print_object(cJSON *item,int depth,int fmt); |
AxedaCorp | 0:65004368569c | 247 | |
AxedaCorp | 0:65004368569c | 248 | /* Utility to jump whitespace and cr/lf */ |
AxedaCorp | 0:65004368569c | 249 | static const char *skip(const char *in) {while (in && *in && (unsigned char)*in<=32) in++; return in;} |
AxedaCorp | 0:65004368569c | 250 | |
AxedaCorp | 0:65004368569c | 251 | /* Parse an object - create a new root, and populate. */ |
AxedaCorp | 0:65004368569c | 252 | cJSON *cJSON_Parse(const char *value) |
AxedaCorp | 0:65004368569c | 253 | { |
AxedaCorp | 0:65004368569c | 254 | cJSON *c=cJSON_New_Item(); |
AxedaCorp | 0:65004368569c | 255 | ep=0; |
AxedaCorp | 0:65004368569c | 256 | if (!c) return 0; /* memory fail */ |
AxedaCorp | 0:65004368569c | 257 | |
AxedaCorp | 0:65004368569c | 258 | if (!parse_value(c,skip(value))) {cJSON_Delete(c);return 0;} |
AxedaCorp | 0:65004368569c | 259 | return c; |
AxedaCorp | 0:65004368569c | 260 | } |
AxedaCorp | 0:65004368569c | 261 | |
AxedaCorp | 0:65004368569c | 262 | /* Render a cJSON item/entity/structure to text. */ |
AxedaCorp | 0:65004368569c | 263 | char *cJSON_Print(cJSON *item) {return print_value(item,0,1);} |
AxedaCorp | 0:65004368569c | 264 | char *cJSON_PrintUnformatted(cJSON *item) {return print_value(item,0,0);} |
AxedaCorp | 0:65004368569c | 265 | |
AxedaCorp | 0:65004368569c | 266 | /* Parser core - when encountering text, process appropriately. */ |
AxedaCorp | 0:65004368569c | 267 | static const char *parse_value(cJSON *item,const char *value) |
AxedaCorp | 0:65004368569c | 268 | { |
AxedaCorp | 0:65004368569c | 269 | if (!value) return 0; /* Fail on null. */ |
AxedaCorp | 0:65004368569c | 270 | if (!strncmp(value,"null",4)) { item->type=cJSON_NULL; return value+4; } |
AxedaCorp | 0:65004368569c | 271 | if (!strncmp(value,"false",5)) { item->type=cJSON_False; return value+5; } |
AxedaCorp | 0:65004368569c | 272 | if (!strncmp(value,"true",4)) { item->type=cJSON_True; item->valueint=1; return value+4; } |
AxedaCorp | 0:65004368569c | 273 | if (*value=='\"') { return parse_string(item,value); } |
AxedaCorp | 0:65004368569c | 274 | if (*value=='-' || (*value>='0' && *value<='9')) { return parse_number(item,value); } |
AxedaCorp | 0:65004368569c | 275 | if (*value=='[') { return parse_array(item,value); } |
AxedaCorp | 0:65004368569c | 276 | if (*value=='{') { return parse_object(item,value); } |
AxedaCorp | 0:65004368569c | 277 | |
AxedaCorp | 0:65004368569c | 278 | ep=value;return 0; /* failure. */ |
AxedaCorp | 0:65004368569c | 279 | } |
AxedaCorp | 0:65004368569c | 280 | |
AxedaCorp | 0:65004368569c | 281 | /* Render a value to text. */ |
AxedaCorp | 0:65004368569c | 282 | static char *print_value(cJSON *item,int depth,int fmt) |
AxedaCorp | 0:65004368569c | 283 | { |
AxedaCorp | 0:65004368569c | 284 | char *out=0; |
AxedaCorp | 0:65004368569c | 285 | if (!item) return 0; |
AxedaCorp | 0:65004368569c | 286 | switch ((item->type)&255) |
AxedaCorp | 0:65004368569c | 287 | { |
AxedaCorp | 0:65004368569c | 288 | case cJSON_NULL: out=cJSON_strdup("null"); break; |
AxedaCorp | 0:65004368569c | 289 | case cJSON_False: out=cJSON_strdup("false");break; |
AxedaCorp | 0:65004368569c | 290 | case cJSON_True: out=cJSON_strdup("true"); break; |
AxedaCorp | 0:65004368569c | 291 | case cJSON_Number: out=print_number(item);break; |
AxedaCorp | 0:65004368569c | 292 | case cJSON_String: out=print_string(item);break; |
AxedaCorp | 0:65004368569c | 293 | case cJSON_Array: out=print_array(item,depth,fmt);break; |
AxedaCorp | 0:65004368569c | 294 | case cJSON_Object: out=print_object(item,depth,fmt);break; |
AxedaCorp | 0:65004368569c | 295 | } |
AxedaCorp | 0:65004368569c | 296 | return out; |
AxedaCorp | 0:65004368569c | 297 | } |
AxedaCorp | 0:65004368569c | 298 | |
AxedaCorp | 0:65004368569c | 299 | /* Build an array from input text. */ |
AxedaCorp | 0:65004368569c | 300 | static const char *parse_array(cJSON *item,const char *value) |
AxedaCorp | 0:65004368569c | 301 | { |
AxedaCorp | 0:65004368569c | 302 | cJSON *child; |
AxedaCorp | 0:65004368569c | 303 | if (*value!='[') {ep=value;return 0;} /* not an array! */ |
AxedaCorp | 0:65004368569c | 304 | |
AxedaCorp | 0:65004368569c | 305 | item->type=cJSON_Array; |
AxedaCorp | 0:65004368569c | 306 | value=skip(value+1); |
AxedaCorp | 0:65004368569c | 307 | if (*value==']') return value+1; /* empty array. */ |
AxedaCorp | 0:65004368569c | 308 | |
AxedaCorp | 0:65004368569c | 309 | item->child=child=cJSON_New_Item(); |
AxedaCorp | 0:65004368569c | 310 | if (!item->child) return 0; /* memory fail */ |
AxedaCorp | 0:65004368569c | 311 | value=skip(parse_value(child,skip(value))); /* skip any spacing, get the value. */ |
AxedaCorp | 0:65004368569c | 312 | if (!value) return 0; |
AxedaCorp | 0:65004368569c | 313 | |
AxedaCorp | 0:65004368569c | 314 | while (*value==',') |
AxedaCorp | 0:65004368569c | 315 | { |
AxedaCorp | 0:65004368569c | 316 | cJSON *new_item; |
AxedaCorp | 0:65004368569c | 317 | if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */ |
AxedaCorp | 0:65004368569c | 318 | child->next=new_item;new_item->prev=child;child=new_item; |
AxedaCorp | 0:65004368569c | 319 | value=skip(parse_value(child,skip(value+1))); |
AxedaCorp | 0:65004368569c | 320 | if (!value) return 0; /* memory fail */ |
AxedaCorp | 0:65004368569c | 321 | } |
AxedaCorp | 0:65004368569c | 322 | |
AxedaCorp | 0:65004368569c | 323 | if (*value==']') return value+1; /* end of array */ |
AxedaCorp | 0:65004368569c | 324 | ep=value;return 0; /* malformed. */ |
AxedaCorp | 0:65004368569c | 325 | } |
AxedaCorp | 0:65004368569c | 326 | |
AxedaCorp | 0:65004368569c | 327 | /* Render an array to text */ |
AxedaCorp | 0:65004368569c | 328 | static char *print_array(cJSON *item,int depth,int fmt) |
AxedaCorp | 0:65004368569c | 329 | { |
AxedaCorp | 0:65004368569c | 330 | char **entries; |
AxedaCorp | 0:65004368569c | 331 | char *out=0,*ptr,*ret;int len=5; |
AxedaCorp | 0:65004368569c | 332 | cJSON *child=item->child; |
AxedaCorp | 0:65004368569c | 333 | int numentries=0,i=0,fail=0; |
AxedaCorp | 0:65004368569c | 334 | |
AxedaCorp | 0:65004368569c | 335 | /* How many entries in the array? */ |
AxedaCorp | 0:65004368569c | 336 | while (child) numentries++,child=child->next; |
AxedaCorp | 0:65004368569c | 337 | /* Allocate an array to hold the values for each */ |
AxedaCorp | 0:65004368569c | 338 | entries=(char**)cJSON_malloc(numentries*sizeof(char*)); |
AxedaCorp | 0:65004368569c | 339 | if (!entries) return 0; |
AxedaCorp | 0:65004368569c | 340 | memset(entries,0,numentries*sizeof(char*)); |
AxedaCorp | 0:65004368569c | 341 | /* Retrieve all the results: */ |
AxedaCorp | 0:65004368569c | 342 | child=item->child; |
AxedaCorp | 0:65004368569c | 343 | while (child && !fail) |
AxedaCorp | 0:65004368569c | 344 | { |
AxedaCorp | 0:65004368569c | 345 | ret=print_value(child,depth+1,fmt); |
AxedaCorp | 0:65004368569c | 346 | entries[i++]=ret; |
AxedaCorp | 0:65004368569c | 347 | if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1; |
AxedaCorp | 0:65004368569c | 348 | child=child->next; |
AxedaCorp | 0:65004368569c | 349 | } |
AxedaCorp | 0:65004368569c | 350 | |
AxedaCorp | 0:65004368569c | 351 | /* If we didn't fail, try to malloc the output string */ |
AxedaCorp | 0:65004368569c | 352 | if (!fail) out=(char*)cJSON_malloc(len); |
AxedaCorp | 0:65004368569c | 353 | /* If that fails, we fail. */ |
AxedaCorp | 0:65004368569c | 354 | if (!out) fail=1; |
AxedaCorp | 0:65004368569c | 355 | |
AxedaCorp | 0:65004368569c | 356 | /* Handle failure. */ |
AxedaCorp | 0:65004368569c | 357 | if (fail) |
AxedaCorp | 0:65004368569c | 358 | { |
AxedaCorp | 0:65004368569c | 359 | for (i=0;i<numentries;i++) if (entries[i]) cJSON_free(entries[i]); |
AxedaCorp | 0:65004368569c | 360 | cJSON_free(entries); |
AxedaCorp | 0:65004368569c | 361 | return 0; |
AxedaCorp | 0:65004368569c | 362 | } |
AxedaCorp | 0:65004368569c | 363 | |
AxedaCorp | 0:65004368569c | 364 | /* Compose the output array. */ |
AxedaCorp | 0:65004368569c | 365 | *out='['; |
AxedaCorp | 0:65004368569c | 366 | ptr=out+1;*ptr=0; |
AxedaCorp | 0:65004368569c | 367 | for (i=0;i<numentries;i++) |
AxedaCorp | 0:65004368569c | 368 | { |
AxedaCorp | 0:65004368569c | 369 | strcpy(ptr,entries[i]);ptr+=strlen(entries[i]); |
AxedaCorp | 0:65004368569c | 370 | if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;} |
AxedaCorp | 0:65004368569c | 371 | cJSON_free(entries[i]); |
AxedaCorp | 0:65004368569c | 372 | } |
AxedaCorp | 0:65004368569c | 373 | cJSON_free(entries); |
AxedaCorp | 0:65004368569c | 374 | *ptr++=']';*ptr++=0; |
AxedaCorp | 0:65004368569c | 375 | return out; |
AxedaCorp | 0:65004368569c | 376 | } |
AxedaCorp | 0:65004368569c | 377 | |
AxedaCorp | 0:65004368569c | 378 | /* Build an object from the text. */ |
AxedaCorp | 0:65004368569c | 379 | static const char *parse_object(cJSON *item,const char *value) |
AxedaCorp | 0:65004368569c | 380 | { |
AxedaCorp | 0:65004368569c | 381 | cJSON *child; |
AxedaCorp | 0:65004368569c | 382 | if (*value!='{') {ep=value;return 0;} /* not an object! */ |
AxedaCorp | 0:65004368569c | 383 | |
AxedaCorp | 0:65004368569c | 384 | item->type=cJSON_Object; |
AxedaCorp | 0:65004368569c | 385 | value=skip(value+1); |
AxedaCorp | 0:65004368569c | 386 | if (*value=='}') return value+1; /* empty array. */ |
AxedaCorp | 0:65004368569c | 387 | |
AxedaCorp | 0:65004368569c | 388 | item->child=child=cJSON_New_Item(); |
AxedaCorp | 0:65004368569c | 389 | if (!item->child) return 0; |
AxedaCorp | 0:65004368569c | 390 | value=skip(parse_string(child,skip(value))); |
AxedaCorp | 0:65004368569c | 391 | if (!value) return 0; |
AxedaCorp | 0:65004368569c | 392 | child->string=child->valuestring;child->valuestring=0; |
AxedaCorp | 0:65004368569c | 393 | if (*value!=':') {ep=value;return 0;} /* fail! */ |
AxedaCorp | 0:65004368569c | 394 | value=skip(parse_value(child,skip(value+1))); /* skip any spacing, get the value. */ |
AxedaCorp | 0:65004368569c | 395 | if (!value) return 0; |
AxedaCorp | 0:65004368569c | 396 | |
AxedaCorp | 0:65004368569c | 397 | while (*value==',') |
AxedaCorp | 0:65004368569c | 398 | { |
AxedaCorp | 0:65004368569c | 399 | cJSON *new_item; |
AxedaCorp | 0:65004368569c | 400 | if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */ |
AxedaCorp | 0:65004368569c | 401 | child->next=new_item;new_item->prev=child;child=new_item; |
AxedaCorp | 0:65004368569c | 402 | value=skip(parse_string(child,skip(value+1))); |
AxedaCorp | 0:65004368569c | 403 | if (!value) return 0; |
AxedaCorp | 0:65004368569c | 404 | child->string=child->valuestring;child->valuestring=0; |
AxedaCorp | 0:65004368569c | 405 | if (*value!=':') {ep=value;return 0;} /* fail! */ |
AxedaCorp | 0:65004368569c | 406 | value=skip(parse_value(child,skip(value+1))); /* skip any spacing, get the value. */ |
AxedaCorp | 0:65004368569c | 407 | if (!value) return 0; |
AxedaCorp | 0:65004368569c | 408 | } |
AxedaCorp | 0:65004368569c | 409 | |
AxedaCorp | 0:65004368569c | 410 | if (*value=='}') return value+1; /* end of array */ |
AxedaCorp | 0:65004368569c | 411 | ep=value;return 0; /* malformed. */ |
AxedaCorp | 0:65004368569c | 412 | } |
AxedaCorp | 0:65004368569c | 413 | |
AxedaCorp | 0:65004368569c | 414 | /* Render an object to text. */ |
AxedaCorp | 0:65004368569c | 415 | static char *print_object(cJSON *item,int depth,int fmt) |
AxedaCorp | 0:65004368569c | 416 | { |
AxedaCorp | 0:65004368569c | 417 | char **entries=0,**names=0; |
AxedaCorp | 0:65004368569c | 418 | char *out=0,*ptr,*ret,*str;int len=7,i=0,j; |
AxedaCorp | 0:65004368569c | 419 | cJSON *child=item->child; |
AxedaCorp | 0:65004368569c | 420 | int numentries=0,fail=0; |
AxedaCorp | 0:65004368569c | 421 | /* Count the number of entries. */ |
AxedaCorp | 0:65004368569c | 422 | while (child) numentries++,child=child->next; |
AxedaCorp | 0:65004368569c | 423 | /* Allocate space for the names and the objects */ |
AxedaCorp | 0:65004368569c | 424 | entries=(char**)cJSON_malloc(numentries*sizeof(char*)); |
AxedaCorp | 0:65004368569c | 425 | if (!entries) return 0; |
AxedaCorp | 0:65004368569c | 426 | names=(char**)cJSON_malloc(numentries*sizeof(char*)); |
AxedaCorp | 0:65004368569c | 427 | if (!names) {cJSON_free(entries);return 0;} |
AxedaCorp | 0:65004368569c | 428 | memset(entries,0,sizeof(char*)*numentries); |
AxedaCorp | 0:65004368569c | 429 | memset(names,0,sizeof(char*)*numentries); |
AxedaCorp | 0:65004368569c | 430 | |
AxedaCorp | 0:65004368569c | 431 | /* Collect all the results into our arrays: */ |
AxedaCorp | 0:65004368569c | 432 | child=item->child;depth++;if (fmt) len+=depth; |
AxedaCorp | 0:65004368569c | 433 | while (child) |
AxedaCorp | 0:65004368569c | 434 | { |
AxedaCorp | 0:65004368569c | 435 | names[i]=str=print_string_ptr(child->string); |
AxedaCorp | 0:65004368569c | 436 | entries[i++]=ret=print_value(child,depth,fmt); |
AxedaCorp | 0:65004368569c | 437 | if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1; |
AxedaCorp | 0:65004368569c | 438 | child=child->next; |
AxedaCorp | 0:65004368569c | 439 | } |
AxedaCorp | 0:65004368569c | 440 | |
AxedaCorp | 0:65004368569c | 441 | /* Try to allocate the output string */ |
AxedaCorp | 0:65004368569c | 442 | if (!fail) out=(char*)cJSON_malloc(len); |
AxedaCorp | 0:65004368569c | 443 | if (!out) fail=1; |
AxedaCorp | 0:65004368569c | 444 | |
AxedaCorp | 0:65004368569c | 445 | /* Handle failure */ |
AxedaCorp | 0:65004368569c | 446 | if (fail) |
AxedaCorp | 0:65004368569c | 447 | { |
AxedaCorp | 0:65004368569c | 448 | for (i=0;i<numentries;i++) {if (names[i]) cJSON_free(names[i]);if (entries[i]) cJSON_free(entries[i]);} |
AxedaCorp | 0:65004368569c | 449 | cJSON_free(names);cJSON_free(entries); |
AxedaCorp | 0:65004368569c | 450 | return 0; |
AxedaCorp | 0:65004368569c | 451 | } |
AxedaCorp | 0:65004368569c | 452 | |
AxedaCorp | 0:65004368569c | 453 | /* Compose the output: */ |
AxedaCorp | 0:65004368569c | 454 | *out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0; |
AxedaCorp | 0:65004368569c | 455 | for (i=0;i<numentries;i++) |
AxedaCorp | 0:65004368569c | 456 | { |
AxedaCorp | 0:65004368569c | 457 | if (fmt) for (j=0;j<depth;j++) *ptr++='\t'; |
AxedaCorp | 0:65004368569c | 458 | strcpy(ptr,names[i]);ptr+=strlen(names[i]); |
AxedaCorp | 0:65004368569c | 459 | *ptr++=':';if (fmt) *ptr++='\t'; |
AxedaCorp | 0:65004368569c | 460 | strcpy(ptr,entries[i]);ptr+=strlen(entries[i]); |
AxedaCorp | 0:65004368569c | 461 | if (i!=numentries-1) *ptr++=','; |
AxedaCorp | 0:65004368569c | 462 | if (fmt) *ptr++='\n';*ptr=0; |
AxedaCorp | 0:65004368569c | 463 | cJSON_free(names[i]);cJSON_free(entries[i]); |
AxedaCorp | 0:65004368569c | 464 | } |
AxedaCorp | 0:65004368569c | 465 | |
AxedaCorp | 0:65004368569c | 466 | cJSON_free(names);cJSON_free(entries); |
AxedaCorp | 0:65004368569c | 467 | if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t'; |
AxedaCorp | 0:65004368569c | 468 | *ptr++='}';*ptr++=0; |
AxedaCorp | 0:65004368569c | 469 | return out; |
AxedaCorp | 0:65004368569c | 470 | } |
AxedaCorp | 0:65004368569c | 471 | |
AxedaCorp | 0:65004368569c | 472 | /* Get Array size/item / object item. */ |
AxedaCorp | 0:65004368569c | 473 | int cJSON_GetArraySize(cJSON *array) {cJSON *c=array->child;int i=0;while(c)i++,c=c->next;return i;} |
AxedaCorp | 0:65004368569c | 474 | cJSON *cJSON_GetArrayItem(cJSON *array,int item) {cJSON *c=array->child; while (c && item>0) item--,c=c->next; return c;} |
AxedaCorp | 0:65004368569c | 475 | cJSON *cJSON_GetObjectItem(cJSON *object,const char *string) {cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;} |
AxedaCorp | 0:65004368569c | 476 | |
AxedaCorp | 0:65004368569c | 477 | /* Utility for array list handling. */ |
AxedaCorp | 0:65004368569c | 478 | static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;} |
AxedaCorp | 0:65004368569c | 479 | /* Utility for handling references. */ |
AxedaCorp | 0:65004368569c | 480 | static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item();if (!ref) return 0;memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;} |
AxedaCorp | 0:65004368569c | 481 | |
AxedaCorp | 0:65004368569c | 482 | /* Add item to array/object. */ |
AxedaCorp | 0:65004368569c | 483 | void cJSON_AddItemToArray(cJSON *array, cJSON *item) {cJSON *c=array->child;if (!item) return; if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}} |
AxedaCorp | 0:65004368569c | 484 | void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item) {if (!item) return; if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);} |
AxedaCorp | 0:65004368569c | 485 | void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) {cJSON_AddItemToArray(array,create_reference(item));} |
AxedaCorp | 0:65004368569c | 486 | void cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item) {cJSON_AddItemToObject(object,string,create_reference(item));} |
AxedaCorp | 0:65004368569c | 487 | |
AxedaCorp | 0:65004368569c | 488 | cJSON *cJSON_DetachItemFromArray(cJSON *array,int which) {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0; |
AxedaCorp | 0:65004368569c | 489 | if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;} |
AxedaCorp | 0:65004368569c | 490 | void cJSON_DeleteItemFromArray(cJSON *array,int which) {cJSON_Delete(cJSON_DetachItemFromArray(array,which));} |
AxedaCorp | 0:65004368569c | 491 | cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;} |
AxedaCorp | 0:65004368569c | 492 | void cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));} |
AxedaCorp | 0:65004368569c | 493 | |
AxedaCorp | 0:65004368569c | 494 | /* Replace array/object items with new ones. */ |
AxedaCorp | 0:65004368569c | 495 | void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem) {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return; |
AxedaCorp | 0:65004368569c | 496 | newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem; |
AxedaCorp | 0:65004368569c | 497 | if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);} |
AxedaCorp | 0:65004368569c | 498 | void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}} |
AxedaCorp | 0:65004368569c | 499 | |
AxedaCorp | 0:65004368569c | 500 | /* Create basic types: */ |
AxedaCorp | 0:65004368569c | 501 | cJSON *cJSON_CreateNull() {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_NULL;return item;} |
AxedaCorp | 0:65004368569c | 502 | cJSON *cJSON_CreateTrue() {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_True;return item;} |
AxedaCorp | 0:65004368569c | 503 | cJSON *cJSON_CreateFalse() {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_False;return item;} |
AxedaCorp | 0:65004368569c | 504 | cJSON *cJSON_CreateBool(int b) {cJSON *item=cJSON_New_Item();if(item)item->type=b?cJSON_True:cJSON_False;return item;} |
AxedaCorp | 0:65004368569c | 505 | cJSON *cJSON_CreateNumber(double num) {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;}return item;} |
AxedaCorp | 0:65004368569c | 506 | cJSON *cJSON_CreateString(const char *string) {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_String;item->valuestring=cJSON_strdup(string);}return item;} |
AxedaCorp | 0:65004368569c | 507 | cJSON *cJSON_CreateArray() {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Array;return item;} |
AxedaCorp | 0:65004368569c | 508 | cJSON *cJSON_CreateObject() {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Object;return item;} |
AxedaCorp | 0:65004368569c | 509 | |
AxedaCorp | 0:65004368569c | 510 | /* Create Arrays: */ |
AxedaCorp | 0:65004368569c | 511 | cJSON *cJSON_CreateIntArray(int *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
AxedaCorp | 0:65004368569c | 512 | cJSON *cJSON_CreateFloatArray(float *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
AxedaCorp | 0:65004368569c | 513 | cJSON *cJSON_CreateDoubleArray(double *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
AxedaCorp | 0:65004368569c | 514 | cJSON *cJSON_CreateStringArray(const char **strings,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;} |
AxedaCorp | 0:65004368569c | 515 |