Commit | Line | Data |
---|---|---|
d430a5e8 SS |
1 | |
2 | /* | |
3 | Copyright (c) 2009 Dave Gamble | |
4 | ||
5 | Permission is hereby granted, free of charge, to any person obtaining a copy | |
6 | of this software and associated documentation files (the "Software"), to deal | |
7 | in the Software without restriction, including without limitation the rights | |
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
9 | copies of the Software, and to permit persons to whom the Software is | |
10 | furnished to do so, subject to the following conditions: | |
11 | ||
12 | The above copyright notice and this permission notice shall be included in | |
13 | all copies or substantial portions of the Software. | |
14 | ||
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
21 | THE SOFTWARE. | |
22 | */ | |
23 | ||
24 | /* cJSON */ | |
25 | /* JSON parser in C. */ | |
26 | #include <math.h> | |
27 | ||
28 | #include "cJSON.h" | |
29 | #include "komodo_cJSON.h" | |
30 | #include "cJSON.c" | |
31 | ||
32 | #ifndef DBL_EPSILON | |
33 | #define DBL_EPSILON 2.2204460492503131E-16 | |
34 | #endif | |
35 | ||
36 | static const char *ep; | |
37 | ||
38 | long stripquotes(char *str) | |
39 | { | |
40 | long len,offset; | |
41 | if ( str == 0 ) | |
42 | return(0); | |
43 | len = strlen(str); | |
44 | if ( str[0] == '"' && str[len-1] == '"' ) | |
45 | str[len-1] = 0, offset = 1; | |
46 | else offset = 0; | |
47 | return(offset); | |
48 | } | |
49 | ||
50 | static int32_t cJSON_strcasecmp(const char *s1,const char *s2) | |
51 | { | |
52 | if (!s1) return (s1==s2)?0:1;if (!s2) return 1; | |
53 | for(; tolower((int32_t)(*s1)) == tolower((int32_t)(*s2)); ++s1, ++s2) if(*s1 == 0) return 0; | |
54 | return tolower((int32_t)(*(const unsigned char *)s1)) - tolower((int32_t)(*(const unsigned char *)s2)); | |
55 | } | |
56 | ||
57 | // the following written by jl777 | |
58 | /****************************************************************************** | |
59 | * Copyright © 2014-2017 The SuperNET Developers. * | |
60 | * * | |
61 | * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at * | |
62 | * the top-level directory of this distribution for the individual copyright * | |
63 | * holder information and the developer policies on copyright and licensing. * | |
64 | * * | |
65 | * Unless otherwise agreed in a custom licensing agreement, no part of the * | |
66 | * SuperNET software, including this file may be copied, modified, propagated * | |
67 | * or distributed except according to the terms contained in the LICENSE file * | |
68 | * * | |
69 | * Removal or modification of this copyright notice is prohibited. * | |
70 | * * | |
71 | ******************************************************************************/ | |
72 | ||
73 | void copy_cJSON(struct destbuf *dest,cJSON *obj) | |
74 | { | |
75 | char *str; | |
76 | int i; | |
77 | long offset; | |
78 | dest->buf[0] = 0; | |
79 | if ( obj != 0 ) | |
80 | { | |
81 | str = cJSON_Print(obj); | |
82 | if ( str != 0 ) | |
83 | { | |
84 | offset = stripquotes(str); | |
85 | //strcpy(dest,str+offset); | |
86 | for (i=0; i<MAX_JSON_FIELD-1; i++) | |
87 | if ( (dest->buf[i]= str[offset+i]) == 0 ) | |
88 | break; | |
89 | dest->buf[i] = 0; | |
90 | free(str); | |
91 | } | |
92 | } | |
93 | } | |
94 | ||
95 | void copy_cJSON2(char *dest,int32_t maxlen,cJSON *obj) | |
96 | { | |
97 | struct destbuf tmp; | |
98 | maxlen--; | |
99 | dest[0] = 0; | |
100 | if ( maxlen > sizeof(tmp.buf) ) | |
101 | maxlen = sizeof(tmp.buf); | |
102 | copy_cJSON(&tmp,obj); | |
103 | if ( strlen(tmp.buf) < maxlen ) | |
104 | strcpy(dest,tmp.buf); | |
105 | else dest[0] = 0; | |
106 | } | |
107 | ||
108 | int64_t _get_cJSON_int(cJSON *json) | |
109 | { | |
110 | struct destbuf tmp; | |
111 | if ( json != 0 ) | |
112 | { | |
113 | copy_cJSON(&tmp,json); | |
114 | if ( tmp.buf[0] != 0 ) | |
115 | return(calc_nxt64bits(tmp.buf)); | |
116 | } | |
117 | return(0); | |
118 | } | |
119 | ||
120 | int64_t get_cJSON_int(cJSON *json,char *field) | |
121 | { | |
122 | cJSON *numjson; | |
123 | if ( json != 0 ) | |
124 | { | |
125 | numjson = cJSON_GetObjectItem(json,field); | |
126 | if ( numjson != 0 ) | |
127 | return(_get_cJSON_int(numjson)); | |
128 | } | |
129 | return(0); | |
130 | } | |
131 | ||
132 | int64_t conv_floatstr(char *numstr) | |
133 | { | |
134 | double val,corr; | |
135 | val = atof(numstr); | |
136 | corr = (val < 0.) ? -0.50000000001 : 0.50000000001; | |
137 | return((int64_t)(val * SATOSHIDEN + corr)); | |
138 | } | |
139 | ||
140 | int64_t _conv_cJSON_float(cJSON *json) | |
141 | { | |
142 | int64_t conv_floatstr(char *); | |
143 | struct destbuf tmp; | |
144 | if ( json != 0 ) | |
145 | { | |
146 | copy_cJSON(&tmp,json); | |
147 | return(conv_floatstr(tmp.buf)); | |
148 | } | |
149 | return(0); | |
150 | } | |
151 | ||
152 | int64_t conv_cJSON_float(cJSON *json,char *field) | |
153 | { | |
154 | if ( json != 0 ) | |
155 | return(_conv_cJSON_float(cJSON_GetObjectItem(json,field))); | |
156 | return(0); | |
157 | } | |
158 | ||
159 | int32_t extract_cJSON_str(char *dest,int32_t max,cJSON *json,char *field) | |
160 | { | |
161 | int32_t safecopy(char *dest,char *src,long len); | |
162 | char *str; | |
163 | cJSON *obj; | |
164 | int32_t len; | |
165 | long offset; | |
166 | dest[0] = 0; | |
167 | obj = cJSON_GetObjectItem(json,field); | |
168 | if ( obj != 0 ) | |
169 | { | |
170 | str = cJSON_Print(obj); | |
171 | offset = stripquotes(str); | |
172 | len = safecopy(dest,str+offset,max); | |
173 | free(str); | |
174 | return(len); | |
175 | } | |
176 | return(0); | |
177 | } | |
178 | ||
179 | cJSON *gen_list_json(char **list) | |
180 | { | |
181 | cJSON *array,*item; | |
182 | array = cJSON_CreateArray(); | |
183 | while ( list != 0 && *list != 0 && *list[0] != 0 ) | |
184 | { | |
185 | item = cJSON_CreateString(*list++); | |
186 | cJSON_AddItemToArray(array,item); | |
187 | } | |
188 | return(array); | |
189 | } | |
190 | ||
191 | uint64_t get_API_nxt64bits(cJSON *obj) | |
192 | { | |
193 | uint64_t nxt64bits = 0; | |
194 | struct destbuf tmp; | |
195 | if ( obj != 0 ) | |
196 | { | |
197 | if ( cJSON_IsNumber(obj) != 0 ) | |
198 | return((uint64_t)obj->valuedouble); | |
199 | copy_cJSON(&tmp,obj); | |
200 | nxt64bits = calc_nxt64bits(tmp.buf); | |
201 | } | |
202 | return(nxt64bits); | |
203 | } | |
204 | uint64_t j64bits(cJSON *json,char *field) { if ( field == 0 ) return(get_API_nxt64bits(json)); return(get_API_nxt64bits(cJSON_GetObjectItem(json,field))); } | |
205 | uint64_t j64bitsi(cJSON *json,int32_t i) { return(get_API_nxt64bits(cJSON_GetArrayItem(json,i))); } | |
206 | ||
207 | uint64_t get_satoshi_obj(cJSON *json,char *field) | |
208 | { | |
209 | int32_t i,n; | |
210 | uint64_t prev,satoshis,mult = 1; | |
211 | struct destbuf numstr,checkstr; | |
212 | cJSON *numjson; | |
213 | numjson = cJSON_GetObjectItem(json,field); | |
214 | copy_cJSON(&numstr,numjson); | |
215 | satoshis = prev = 0; mult = 1; n = (int32_t)strlen(numstr.buf); | |
216 | for (i=n-1; i>=0; i--,mult*=10) | |
217 | { | |
218 | satoshis += (mult * (numstr.buf[i] - '0')); | |
219 | if ( satoshis < prev ) | |
220 | printf("get_satoshi_obj numstr.(%s) i.%d prev.%llu vs satoshis.%llu\n",numstr.buf,i,(unsigned long long)prev,(unsigned long long)satoshis); | |
221 | prev = satoshis; | |
222 | } | |
223 | sprintf(checkstr.buf,"%llu",(long long)satoshis); | |
224 | if ( strcmp(checkstr.buf,numstr.buf) != 0 ) | |
225 | { | |
226 | printf("SATOSHI GREMLIN?? numstr.(%s) -> %.8f -> (%s)\n",numstr.buf,dstr(satoshis),checkstr.buf); | |
227 | } | |
228 | return(satoshis); | |
229 | } | |
230 | ||
231 | void add_satoshis_json(cJSON *json,char *field,uint64_t satoshis) | |
232 | { | |
233 | cJSON *obj; | |
234 | char numstr[64]; | |
235 | sprintf(numstr,"%lld",(long long)satoshis); | |
236 | obj = cJSON_CreateString(numstr); | |
237 | cJSON_AddItemToObject(json,field,obj); | |
238 | if ( satoshis != get_satoshi_obj(json,field) ) | |
239 | printf("error adding satoshi obj %ld -> %ld\n",(unsigned long)satoshis,(unsigned long)get_satoshi_obj(json,field)); | |
240 | } | |
241 | ||
242 | char *cJSON_str(cJSON *json) | |
243 | { | |
244 | if ( json != 0 && cJSON_IsString(json) != 0 ) | |
245 | return(json->valuestring); | |
246 | return(0); | |
247 | } | |
248 | ||
249 | void jadd(cJSON *json,char *field,cJSON *item) { if ( json != 0 )cJSON_AddItemToObject(json,field,item); } | |
250 | void jaddstr(cJSON *json,char *field,char *str) { if ( json != 0 && str != 0 ) cJSON_AddItemToObject(json,field,cJSON_CreateString(str)); } | |
251 | void jaddnum(cJSON *json,char *field,double num) { if ( json != 0 )cJSON_AddItemToObject(json,field,cJSON_CreateNumber(num)); } | |
252 | void jadd64bits(cJSON *json,char *field,uint64_t nxt64bits) { char numstr[64]; sprintf(numstr,"%llu",(long long)nxt64bits), jaddstr(json,field,numstr); } | |
253 | void jaddi(cJSON *json,cJSON *item) { if ( json != 0 ) cJSON_AddItemToArray(json,item); } | |
254 | void jaddistr(cJSON *json,char *str) { if ( json != 0 ) cJSON_AddItemToArray(json,cJSON_CreateString(str)); } | |
255 | void jaddinum(cJSON *json,double num) { if ( json != 0 ) cJSON_AddItemToArray(json,cJSON_CreateNumber(num)); } | |
256 | void jaddi64bits(cJSON *json,uint64_t nxt64bits) { char numstr[64]; sprintf(numstr,"%llu",(long long)nxt64bits), jaddistr(json,numstr); } | |
257 | char *jstr(cJSON *json,char *field) { if ( json == 0 ) return(0); if ( field == 0 ) return(cJSON_str(json)); return(cJSON_str(cJSON_GetObjectItem(json,field))); } | |
258 | ||
259 | char *jstri(cJSON *json,int32_t i) { return(cJSON_str(cJSON_GetArrayItem(json,i))); } | |
260 | char *jprint(cJSON *json,int32_t freeflag) | |
261 | { | |
262 | char *str; | |
263 | /*static portable_mutex_t mutex; static int32_t initflag; | |
264 | if ( initflag == 0 ) | |
265 | { | |
266 | portable_mutex_init(&mutex); | |
267 | initflag = 1; | |
268 | }*/ | |
269 | if ( json == 0 ) | |
270 | return(clonestr((char *)"{}")); | |
271 | //portable_mutex_lock(&mutex); | |
272 | //usleep(5000); | |
273 | str = cJSON_Print(json), _stripwhite(str,' '); | |
274 | if ( freeflag != 0 ) | |
275 | free_json(json); | |
276 | //portable_mutex_unlock(&mutex); | |
277 | return(str); | |
278 | } | |
279 | ||
280 | bits256 get_API_bits256(cJSON *obj) | |
281 | { | |
282 | bits256 hash; char *str; | |
283 | memset(hash.bytes,0,sizeof(hash)); | |
284 | if ( obj != 0 ) | |
285 | { | |
286 | if ( cJSON_IsString(obj) != 0 && (str= obj->valuestring) != 0 && strlen(str) == 64 ) | |
287 | decode_hex(hash.bytes,sizeof(hash),str); | |
288 | } | |
289 | return(hash); | |
290 | } | |
291 | bits256 jbits256(cJSON *json,char *field) { if ( field == 0 ) return(get_API_bits256(json)); return(get_API_bits256(cJSON_GetObjectItem(json,field))); } | |
292 | bits256 jbits256i(cJSON *json,int32_t i) { return(get_API_bits256(cJSON_GetArrayItem(json,i))); } | |
293 | void jaddbits256(cJSON *json,char *field,bits256 hash) { char str[65]; bits256_str(str,hash), jaddstr(json,field,str); } | |
294 | void jaddibits256(cJSON *json,bits256 hash) { char str[65]; bits256_str(str,hash), jaddistr(json,str); } | |
295 | ||
296 | char *get_cJSON_fieldname(cJSON *obj) | |
297 | { | |
298 | if ( obj != 0 ) | |
299 | { | |
300 | if ( obj->child != 0 && obj->child->string != 0 ) | |
301 | return(obj->child->string); | |
302 | else if ( obj->string != 0 ) | |
303 | return(obj->string); | |
304 | } | |
305 | return((char *)"<no cJSON string field>"); | |
306 | } | |
307 | ||
308 | int32_t jnum(cJSON *obj,char *field) | |
309 | { | |
310 | char *str; int32_t polarity = 1; | |
311 | if ( field != 0 ) | |
312 | obj = jobj(obj,field); | |
313 | if ( obj != 0 ) | |
314 | { | |
315 | if ( cJSON_IsNumber(obj) != 0 ) | |
316 | return(obj->valuedouble); | |
317 | else if ( cJSON_IsString(obj) != 0 && (str= jstr(obj,0)) != 0 ) | |
318 | { | |
319 | if ( str[0] == '-' ) | |
320 | polarity = -1, str++; | |
321 | return(polarity * (int32_t)calc_nxt64bits(str)); | |
322 | } | |
323 | } | |
324 | return(0); | |
325 | } | |
326 | ||
327 | void ensure_jsonitem(cJSON *json,char *field,char *value) | |
328 | { | |
329 | cJSON *obj = cJSON_GetObjectItem(json,field); | |
330 | if ( obj == 0 ) | |
331 | cJSON_AddItemToObject(json,field,cJSON_CreateString(value)); | |
332 | else cJSON_ReplaceItemInObject(json,field,cJSON_CreateString(value)); | |
333 | } | |
334 | ||
335 | int32_t in_jsonarray(cJSON *array,char *value) | |
336 | { | |
337 | int32_t i,n; | |
338 | struct destbuf remote; | |
339 | if ( array != 0 && cJSON_IsArray(array) != 0 ) | |
340 | { | |
341 | n = cJSON_GetArraySize(array); | |
342 | for (i=0; i<n; i++) | |
343 | { | |
344 | if ( array == 0 || n == 0 ) | |
345 | break; | |
346 | copy_cJSON(&remote,cJSON_GetArrayItem(array,i)); | |
347 | if ( strcmp(remote.buf,value) == 0 ) | |
348 | return(1); | |
349 | } | |
350 | } | |
351 | return(0); | |
352 | } | |
353 | ||
354 | int32_t myatoi(char *str,int32_t range) | |
355 | { | |
356 | long x; char *ptr; | |
357 | x = strtol(str,&ptr,10); | |
358 | if ( range != 0 && x >= range ) | |
359 | x = (range - 1); | |
360 | return((int32_t)x); | |
361 | } | |
362 | ||
363 | int32_t get_API_int(cJSON *obj,int32_t val) | |
364 | { | |
365 | struct destbuf buf; | |
366 | if ( obj != 0 ) | |
367 | { | |
368 | if ( cJSON_IsNumber(obj) != 0 ) | |
369 | return((int32_t)obj->valuedouble); | |
370 | copy_cJSON(&buf,obj); | |
371 | val = myatoi(buf.buf,0); | |
372 | if ( val < 0 ) | |
373 | val = 0; | |
374 | } | |
375 | return(val); | |
376 | } | |
377 | ||
378 | int32_t jint(cJSON *json,char *field) { if ( json == 0 ) return(0); if ( field == 0 ) return(get_API_int(json,0)); return(get_API_int(cJSON_GetObjectItem(json,field),0)); } | |
379 | int32_t jinti(cJSON *json,int32_t i) { if ( json == 0 ) return(0); return(get_API_int(cJSON_GetArrayItem(json,i),0)); } | |
380 | ||
381 | uint32_t get_API_uint(cJSON *obj,uint32_t val) | |
382 | { | |
383 | struct destbuf buf; | |
384 | if ( obj != 0 ) | |
385 | { | |
386 | if ( cJSON_IsNumber(obj) != 0 ) | |
387 | return((uint32_t)obj->valuedouble); | |
388 | copy_cJSON(&buf,obj); | |
389 | val = myatoi(buf.buf,0); | |
390 | } | |
391 | return(val); | |
392 | } | |
393 | uint32_t juint(cJSON *json,char *field) { if ( json == 0 ) return(0); if ( field == 0 ) return(get_API_uint(json,0)); return(get_API_uint(cJSON_GetObjectItem(json,field),0)); } | |
394 | uint32_t juinti(cJSON *json,int32_t i) { if ( json == 0 ) return(0); return(get_API_uint(cJSON_GetArrayItem(json,i),0)); } | |
395 | ||
396 | double get_API_float(cJSON *obj) | |
397 | { | |
398 | double val = 0.; | |
399 | struct destbuf buf; | |
400 | if ( obj != 0 ) | |
401 | { | |
402 | if ( cJSON_IsNumber(obj) != 0 ) | |
403 | return(obj->valuedouble); | |
404 | copy_cJSON(&buf,obj); | |
405 | val = atof(buf.buf); | |
406 | } | |
407 | return(val); | |
408 | } | |
409 | ||
410 | double jdouble(cJSON *json,char *field) | |
411 | { | |
412 | if ( json != 0 ) | |
413 | { | |
414 | if ( field == 0 ) | |
415 | return(get_API_float(json)); | |
416 | else return(get_API_float(cJSON_GetObjectItem(json,field))); | |
417 | } else return(0.); | |
418 | } | |
419 | ||
420 | double jdoublei(cJSON *json,int32_t i) | |
421 | { | |
422 | if ( json != 0 ) | |
423 | return(get_API_float(cJSON_GetArrayItem(json,i))); | |
424 | else return(0.); | |
425 | } | |
426 | ||
427 | cJSON *jobj(cJSON *json,char *field) { if ( json != 0 ) return(cJSON_GetObjectItem(json,field)); return(0); } | |
428 | ||
429 | void jdelete(cJSON *json,char *field) | |
430 | { | |
431 | if ( jobj(json,field) != 0 ) | |
432 | cJSON_DeleteItemFromObject(json,field); | |
433 | } | |
434 | ||
435 | cJSON *jduplicate(cJSON *json) { return(cJSON_Duplicate(json,1)); } | |
436 | ||
437 | cJSON *jitem(cJSON *array,int32_t i) { if ( array != 0 && cJSON_IsArray(array) != 0 && cJSON_GetArraySize(array) > i ) return(cJSON_GetArrayItem(array,i)); return(0); } | |
438 | cJSON *jarray(int32_t *nump,cJSON *json,char *field) | |
439 | { | |
440 | cJSON *array; | |
441 | if ( json != 0 ) | |
442 | { | |
443 | if ( field == 0 ) | |
444 | array = json; | |
445 | else array = cJSON_GetObjectItem(json,field); | |
446 | if ( array != 0 && cJSON_IsArray(array) != 0 && (*nump= cJSON_GetArraySize(array)) > 0 ) | |
447 | return(array); | |
448 | } | |
449 | *nump = 0; | |
450 | return(0); | |
451 | } | |
452 | ||
453 | int32_t expand_nxt64bits(char *NXTaddr,uint64_t nxt64bits) | |
454 | { | |
455 | int32_t i,n; | |
456 | uint64_t modval; | |
457 | char rev[64]; | |
458 | for (i=0; nxt64bits!=0; i++) | |
459 | { | |
460 | modval = nxt64bits % 10; | |
461 | rev[i] = (char)(modval + '0'); | |
462 | nxt64bits /= 10; | |
463 | } | |
464 | n = i; | |
465 | for (i=0; i<n; i++) | |
466 | NXTaddr[i] = rev[n-1-i]; | |
467 | NXTaddr[i] = 0; | |
468 | return(n); | |
469 | } | |
470 | ||
471 | char *nxt64str(uint64_t nxt64bits) | |
472 | { | |
473 | static char NXTaddr[64]; | |
474 | expand_nxt64bits(NXTaddr,nxt64bits); | |
475 | return(NXTaddr); | |
476 | } | |
477 | ||
478 | char *nxt64str2(uint64_t nxt64bits) | |
479 | { | |
480 | static char NXTaddr[64]; | |
481 | expand_nxt64bits(NXTaddr,nxt64bits); | |
482 | return(NXTaddr); | |
483 | } | |
484 | ||
485 | int32_t cmp_nxt64bits(const char *str,uint64_t nxt64bits) | |
486 | { | |
487 | char expanded[64]; | |
488 | if ( str == 0 )//|| str[0] == 0 || nxt64bits == 0 ) | |
489 | return(-1); | |
490 | if ( nxt64bits == 0 && str[0] == 0 ) | |
491 | return(0); | |
492 | expand_nxt64bits(expanded,nxt64bits); | |
493 | return(strcmp(str,expanded)); | |
494 | } | |
495 | ||
496 | uint64_t calc_nxt64bits(const char *NXTaddr) | |
497 | { | |
498 | int32_t c; | |
499 | int64_t n,i,polarity = 1; | |
500 | uint64_t lastval,mult,nxt64bits = 0; | |
501 | if ( NXTaddr == 0 ) | |
502 | { | |
503 | printf("calling calc_nxt64bits with null ptr!\n"); | |
504 | return(0); | |
505 | } | |
506 | n = strlen(NXTaddr); | |
507 | if ( n >= 22 ) | |
508 | { | |
509 | printf("calc_nxt64bits: illegal NXTaddr.(%s) too long\n",NXTaddr); | |
510 | return(0); | |
511 | } | |
512 | else if ( strcmp(NXTaddr,"0") == 0 || strcmp(NXTaddr,"false") == 0 ) | |
513 | { | |
514 | // printf("zero address?\n"); getchar(); | |
515 | return(0); | |
516 | } | |
517 | if ( NXTaddr[0] == '-' ) | |
518 | polarity = -1, NXTaddr++, n--; | |
519 | mult = 1; | |
520 | lastval = 0; | |
521 | for (i=n-1; i>=0; i--,mult*=10) | |
522 | { | |
523 | c = NXTaddr[i]; | |
524 | if ( c < '0' || c > '9' ) | |
525 | { | |
526 | printf("calc_nxt64bits: illegal char.(%c %d) in (%s).%d\n",c,c,NXTaddr,(int32_t)i); | |
527 | #ifdef __APPLE__ | |
528 | //while ( 1 ) | |
529 | { | |
530 | //sleep(60); | |
531 | printf("calc_nxt64bits: illegal char.(%c %d) in (%s).%d\n",c,c,NXTaddr,(int32_t)i); | |
532 | } | |
533 | #endif | |
534 | return(0); | |
535 | } | |
536 | nxt64bits += mult * (c - '0'); | |
537 | if ( nxt64bits < lastval ) | |
538 | printf("calc_nxt64bits: warning: 64bit overflow %llx < %llx\n",(long long)nxt64bits,(long long)lastval); | |
539 | lastval = nxt64bits; | |
540 | } | |
541 | while ( *NXTaddr == '0' && *NXTaddr != 0 ) | |
542 | NXTaddr++; | |
543 | if ( cmp_nxt64bits(NXTaddr,nxt64bits) != 0 ) | |
544 | printf("error calculating nxt64bits: %s -> %llx -> %s\n",NXTaddr,(long long)nxt64bits,nxt64str(nxt64bits)); | |
545 | if ( polarity < 0 ) | |
546 | return(-(int64_t)nxt64bits); | |
547 | return(nxt64bits); | |
548 | } | |
549 | ||
550 | cJSON *addrs_jsonarray(uint64_t *addrs,int32_t num) | |
551 | { | |
552 | int32_t j; cJSON *array; | |
553 | array = cJSON_CreateArray(); | |
554 | for (j=0; j<num; j++) | |
555 | jaddi64bits(array,addrs[j]); | |
556 | return(array); | |
557 | } | |
558 | ||
559 | void free_json(cJSON *json) { if ( json != 0 ) cJSON_Delete(json); } |