cJSON_Delete: 254| 306k|{ 255| 306k| cJSON *next = NULL; 256| 1.08M| while (item != NULL) ------------------ | Branch (256:12): [True: 775k, False: 306k] ------------------ 257| 775k| { 258| 775k| next = item->next; 259| 775k| if (!(item->type & cJSON_IsReference) && (item->child != NULL)) ------------------ | | 99| 775k|#define cJSON_IsReference 256 ------------------ | Branch (259:13): [True: 775k, False: 0] | Branch (259:50): [True: 257k, False: 518k] ------------------ 260| 257k| { 261| 257k| cJSON_Delete(item->child); 262| 257k| } 263| 775k| if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) ------------------ | | 99| 775k|#define cJSON_IsReference 256 ------------------ | Branch (263:13): [True: 775k, False: 0] | Branch (263:50): [True: 5.46k, False: 770k] ------------------ 264| 5.46k| { 265| 5.46k| global_hooks.deallocate(item->valuestring); 266| 5.46k| item->valuestring = NULL; 267| 5.46k| } 268| 775k| if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) ------------------ | | 100| 775k|#define cJSON_StringIsConst 512 ------------------ | Branch (268:13): [True: 775k, False: 0] | Branch (268:52): [True: 33.6k, False: 742k] ------------------ 269| 33.6k| { 270| 33.6k| global_hooks.deallocate(item->string); 271| | item->string = NULL; 272| 33.6k| } 273| 775k| global_hooks.deallocate(item); 274| 775k| item = next; 275| 775k| } 276| 306k|} cJSON_ParseWithOpts: 1132| 2.01k|{ 1133| 2.01k| size_t buffer_length; 1134| | 1135| 2.01k| if (NULL == value) ------------------ | Branch (1135:9): [True: 0, False: 2.01k] ------------------ 1136| 0| { 1137| 0| return NULL; 1138| 0| } 1139| | 1140| | /* Adding null character size due to require_null_terminated. */ 1141| 2.01k| buffer_length = strlen(value) + sizeof(""); 1142| | 1143| 2.01k| return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); 1144| 2.01k|} cJSON_ParseWithLengthOpts: 1148| 2.01k|{ 1149| 2.01k| parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; 1150| 2.01k| cJSON *item = NULL; 1151| | 1152| | /* reset error position */ 1153| 2.01k| global_error.json = NULL; 1154| 2.01k| global_error.position = 0; 1155| | 1156| 2.01k| if (value == NULL || 0 == buffer_length) ------------------ | Branch (1156:9): [True: 0, False: 2.01k] | Branch (1156:26): [True: 0, False: 2.01k] ------------------ 1157| 0| { 1158| 0| goto fail; 1159| 0| } 1160| | 1161| 2.01k| buffer.content = (const unsigned char*)value; 1162| 2.01k| buffer.length = buffer_length; 1163| 2.01k| buffer.offset = 0; 1164| 2.01k| buffer.hooks = global_hooks; 1165| | 1166| 2.01k| item = cJSON_New_Item(&global_hooks); 1167| 2.01k| if (item == NULL) /* memory fail */ ------------------ | Branch (1167:9): [True: 0, False: 2.01k] ------------------ 1168| 0| { 1169| 0| goto fail; 1170| 0| } 1171| | 1172| 2.01k| if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) ------------------ | Branch (1172:9): [True: 865, False: 1.14k] ------------------ 1173| 865| { 1174| | /* parse failure. ep is set. */ 1175| 865| goto fail; 1176| 865| } 1177| | 1178| | /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ 1179| 1.14k| if (require_null_terminated) ------------------ | Branch (1179:9): [True: 424, False: 722] ------------------ 1180| 424| { 1181| 424| buffer_skip_whitespace(&buffer); 1182| 424| if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') ------------------ | | 304| 424|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1182:13): [True: 0, False: 424] | Branch (1182:49): [True: 48, False: 376] ------------------ 1183| 48| { 1184| 48| goto fail; 1185| 48| } 1186| 424| } 1187| 1.09k| if (return_parse_end) ------------------ | Branch (1187:9): [True: 0, False: 1.09k] ------------------ 1188| 0| { 1189| 0| *return_parse_end = (const char*)buffer_at_offset(&buffer); ------------------ | | 304| 0|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 1190| 0| } 1191| | 1192| 1.09k| return item; 1193| | 1194| 913|fail: 1195| 913| if (item != NULL) ------------------ | Branch (1195:9): [True: 913, False: 0] ------------------ 1196| 913| { 1197| 913| cJSON_Delete(item); 1198| 913| } 1199| | 1200| 913| if (value != NULL) ------------------ | Branch (1200:9): [True: 913, False: 0] ------------------ 1201| 913| { 1202| 913| error local_error; 1203| 913| local_error.json = (const unsigned char*)value; 1204| 913| local_error.position = 0; 1205| | 1206| 913| if (buffer.offset < buffer.length) ------------------ | Branch (1206:13): [True: 801, False: 112] ------------------ 1207| 801| { 1208| 801| local_error.position = buffer.offset; 1209| 801| } 1210| 112| else if (buffer.length > 0) ------------------ | Branch (1210:18): [True: 112, False: 0] ------------------ 1211| 112| { 1212| 112| local_error.position = buffer.length - 1; 1213| 112| } 1214| | 1215| 913| if (return_parse_end != NULL) ------------------ | Branch (1215:13): [True: 0, False: 913] ------------------ 1216| 0| { 1217| 0| *return_parse_end = (const char*)local_error.json + local_error.position; 1218| 0| } 1219| | 1220| 913| global_error = local_error; 1221| 913| } 1222| | 1223| | return NULL; 1224| 1.14k|} cJSON_Print: 1308| 291|{ 1309| 291| return (char*)print(item, true, &global_hooks); ------------------ | | 65| 291|#define true ((cJSON_bool)1) ------------------ 1310| 291|} cJSON_PrintUnformatted: 1313| 238|{ 1314| 238| return (char*)print(item, false, &global_hooks); ------------------ | | 70| 238|#define false ((cJSON_bool)0) ------------------ 1315| 238|} cJSON_PrintBuffered: 1318| 569|{ 1319| 569| printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; 1320| | 1321| 569| if (prebuffer < 0) ------------------ | Branch (1321:9): [True: 0, False: 569] ------------------ 1322| 0| { 1323| 0| return NULL; 1324| 0| } 1325| | 1326| 569| p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); 1327| 569| if (!p.buffer) ------------------ | Branch (1327:9): [True: 0, False: 569] ------------------ 1328| 0| { 1329| 0| return NULL; 1330| 0| } 1331| | 1332| 569| p.length = (size_t)prebuffer; 1333| 569| p.offset = 0; 1334| 569| p.noalloc = false; ------------------ | | 70| 569|#define false ((cJSON_bool)0) ------------------ 1335| 569| p.format = fmt; 1336| 569| p.hooks = global_hooks; 1337| | 1338| 569| if (!print_value(item, &p)) ------------------ | Branch (1338:9): [True: 0, False: 569] ------------------ 1339| 0| { 1340| 0| global_hooks.deallocate(p.buffer); 1341| 0| p.buffer = NULL; 1342| 0| return NULL; 1343| 0| } 1344| | 1345| 569| return (char*)p.buffer; 1346| 569|} cJSON_Minify: 2925| 886|{ 2926| 886| char *into = json; 2927| | 2928| 886| if (json == NULL) ------------------ | Branch (2928:9): [True: 0, False: 886] ------------------ 2929| 0| { 2930| 0| return; 2931| 0| } 2932| | 2933| 2.80M| while (json[0] != '\0') ------------------ | Branch (2933:12): [True: 2.79M, False: 886] ------------------ 2934| 2.79M| { 2935| 2.79M| switch (json[0]) 2936| 2.79M| { 2937| 1.32k| case ' ': ------------------ | Branch (2937:13): [True: 1.32k, False: 2.79M] ------------------ 2938| 3.09k| case '\t': ------------------ | Branch (2938:13): [True: 1.77k, False: 2.79M] ------------------ 2939| 3.47k| case '\r': ------------------ | Branch (2939:13): [True: 375, False: 2.79M] ------------------ 2940| 5.58k| case '\n': ------------------ | Branch (2940:13): [True: 2.10k, False: 2.79M] ------------------ 2941| 5.58k| json++; 2942| 5.58k| break; 2943| | 2944| 3.33k| case '/': ------------------ | Branch (2944:13): [True: 3.33k, False: 2.79M] ------------------ 2945| 3.33k| if (json[1] == '/') ------------------ | Branch (2945:21): [True: 1.66k, False: 1.66k] ------------------ 2946| 1.66k| { 2947| 1.66k| skip_oneline_comment(&json); 2948| 1.66k| } 2949| 1.66k| else if (json[1] == '*') ------------------ | Branch (2949:26): [True: 304, False: 1.36k] ------------------ 2950| 304| { 2951| 304| skip_multiline_comment(&json); 2952| 1.36k| } else { 2953| 1.36k| json++; 2954| 1.36k| } 2955| 3.33k| break; 2956| | 2957| 18.7k| case '\"': ------------------ | Branch (2957:13): [True: 18.7k, False: 2.78M] ------------------ 2958| 18.7k| minify_string(&json, (char**)&into); 2959| 18.7k| break; 2960| | 2961| 2.77M| default: ------------------ | Branch (2961:13): [True: 2.77M, False: 27.6k] ------------------ 2962| 2.77M| into[0] = json[0]; 2963| 2.77M| json++; 2964| 2.77M| into++; 2965| 2.79M| } 2966| 2.79M| } 2967| | 2968| | /* and null-terminate. */ 2969| 886| *into = '\0'; 2970| 886|} cJSON.c:cJSON_New_Item: 242| 775k|{ 243| 775k| cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); 244| 775k| if (node) ------------------ | Branch (244:9): [True: 775k, False: 0] ------------------ 245| 775k| { 246| 775k| memset(node, '\0', sizeof(cJSON)); 247| 775k| } 248| | 249| 775k| return node; 250| 775k|} cJSON.c:buffer_skip_whitespace: 1091| 2.28M|{ 1092| 2.28M| if ((buffer == NULL) || (buffer->content == NULL)) ------------------ | Branch (1092:9): [True: 0, False: 2.28M] | Branch (1092:29): [True: 0, False: 2.28M] ------------------ 1093| 0| { 1094| 0| return NULL; 1095| 0| } 1096| | 1097| 2.28M| if (cannot_access_at_index(buffer, 0)) ------------------ | | 302| 2.28M|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 2.28M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 2.28M, False: 0] | | | | | Branch (301:65): [True: 2.28M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1098| 0| { 1099| 0| return buffer; 1100| 0| } 1101| | 1102| 3.11M| while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 301| 6.22M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 3.11M, False: 0] | | | Branch (301:65): [True: 3.10M, False: 964] | | ------------------ ------------------ while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 304| 3.10M|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1102:46): [True: 821k, False: 2.28M] ------------------ 1103| 821k| { 1104| 821k| buffer->offset++; 1105| 821k| } 1106| | 1107| 2.28M| if (buffer->offset == buffer->length) ------------------ | Branch (1107:9): [True: 964, False: 2.28M] ------------------ 1108| 964| { 1109| 964| buffer->offset--; 1110| 964| } 1111| | 1112| 2.28M| return buffer; 1113| 2.28M|} cJSON.c:skip_utf8_bom: 1117| 2.01k|{ 1118| 2.01k| if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) ------------------ | Branch (1118:9): [True: 0, False: 2.01k] | Branch (1118:29): [True: 0, False: 2.01k] | Branch (1118:58): [True: 0, False: 2.01k] ------------------ 1119| 0| { 1120| 0| return NULL; 1121| 0| } 1122| | 1123| 2.01k| if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 301| 4.02k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 2.01k, False: 0] | | | Branch (301:65): [True: 1.72k, False: 290] | | ------------------ ------------------ if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 304| 1.72k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1123:43): [True: 89, False: 1.63k] ------------------ 1124| 89| { 1125| 89| buffer->offset += 3; 1126| 89| } 1127| | 1128| 2.01k| return buffer; 1129| 2.01k|} cJSON.c:print: 1240| 529|{ 1241| 529| static const size_t default_buffer_size = 256; 1242| 529| printbuffer buffer[1]; 1243| 529| unsigned char *printed = NULL; 1244| | 1245| 529| memset(buffer, 0, sizeof(buffer)); 1246| | 1247| | /* create buffer */ 1248| 529| buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); 1249| 529| buffer->length = default_buffer_size; 1250| 529| buffer->format = format; 1251| 529| buffer->hooks = *hooks; 1252| 529| if (buffer->buffer == NULL) ------------------ | Branch (1252:9): [True: 0, False: 529] ------------------ 1253| 0| { 1254| 0| goto fail; 1255| 0| } 1256| | 1257| | /* print the value */ 1258| 529| if (!print_value(item, buffer)) ------------------ | Branch (1258:9): [True: 0, False: 529] ------------------ 1259| 0| { 1260| 0| goto fail; 1261| 0| } 1262| 529| update_offset(buffer); 1263| | 1264| | /* check if reallocate is available */ 1265| 529| if (hooks->reallocate != NULL) ------------------ | Branch (1265:9): [True: 529, False: 0] ------------------ 1266| 529| { 1267| 529| printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); 1268| 529| if (printed == NULL) { ------------------ | Branch (1268:13): [True: 0, False: 529] ------------------ 1269| 0| goto fail; 1270| 0| } 1271| 529| buffer->buffer = NULL; 1272| 529| } 1273| 0| else /* otherwise copy the JSON over to a new buffer */ 1274| 0| { 1275| 0| printed = (unsigned char*) hooks->allocate(buffer->offset + 1); 1276| 0| if (printed == NULL) ------------------ | Branch (1276:13): [True: 0, False: 0] ------------------ 1277| 0| { 1278| 0| goto fail; 1279| 0| } 1280| 0| memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); ------------------ | | 1237| 0|#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (1237:26): [True: 0, False: 0] | | ------------------ ------------------ 1281| 0| printed[buffer->offset] = '\0'; /* just to be sure */ 1282| | 1283| | /* free the buffer */ 1284| 0| hooks->deallocate(buffer->buffer); 1285| 0| buffer->buffer = NULL; 1286| 0| } 1287| | 1288| 529| return printed; 1289| | 1290| 0|fail: 1291| 0| if (buffer->buffer != NULL) ------------------ | Branch (1291:9): [True: 0, False: 0] ------------------ 1292| 0| { 1293| 0| hooks->deallocate(buffer->buffer); 1294| 0| buffer->buffer = NULL; 1295| 0| } 1296| | 1297| 0| if (printed != NULL) ------------------ | Branch (1297:9): [True: 0, False: 0] ------------------ 1298| 0| { 1299| 0| hooks->deallocate(printed); 1300| 0| printed = NULL; 1301| 0| } 1302| | 1303| | return NULL; 1304| 529|} cJSON.c:update_offset: 577| 694k|{ 578| 694k| const unsigned char *buffer_pointer = NULL; 579| 694k| if ((buffer == NULL) || (buffer->buffer == NULL)) ------------------ | Branch (579:9): [True: 0, False: 694k] | Branch (579:29): [True: 0, False: 694k] ------------------ 580| 0| { 581| 0| return; 582| 0| } 583| 694k| buffer_pointer = buffer->buffer + buffer->offset; 584| | 585| 694k| buffer->offset += strlen((const char*)buffer_pointer); 586| 694k|} cJSON.c:parse_value: 1369| 775k|{ 1370| 775k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (1370:9): [True: 0, False: 775k] | Branch (1370:35): [True: 0, False: 775k] ------------------ 1371| 0| { 1372| 0| return false; /* no input */ ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1373| 0| } 1374| | 1375| | /* parse the different types of values */ 1376| | /* null */ 1377| 775k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 299| 1.55M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (299:33): [True: 775k, False: 0] | | | Branch (299:53): [True: 774k, False: 841] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 304| 774k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1377:38): [True: 552, False: 774k] ------------------ 1378| 552| { 1379| 552| item->type = cJSON_NULL; ------------------ | | 92| 552|#define cJSON_NULL (1 << 2) ------------------ 1380| 552| input_buffer->offset += 4; 1381| 552| return true; ------------------ | | 65| 552|#define true ((cJSON_bool)1) ------------------ 1382| 552| } 1383| | /* false */ 1384| 774k| if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 299| 1.54M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (299:33): [True: 774k, False: 0] | | | Branch (299:53): [True: 773k, False: 1.20k] | | ------------------ ------------------ if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 304| 773k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1384:38): [True: 829, False: 772k] ------------------ 1385| 829| { 1386| 829| item->type = cJSON_False; ------------------ | | 90| 829|#define cJSON_False (1 << 0) ------------------ 1387| 829| input_buffer->offset += 5; 1388| 829| return true; ------------------ | | 65| 829|#define true ((cJSON_bool)1) ------------------ 1389| 829| } 1390| | /* true */ 1391| 774k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 299| 1.54M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (299:33): [True: 774k, False: 0] | | | Branch (299:53): [True: 773k, False: 841] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 304| 773k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1391:38): [True: 2.01k, False: 771k] ------------------ 1392| 2.01k| { 1393| 2.01k| item->type = cJSON_True; ------------------ | | 91| 2.01k|#define cJSON_True (1 << 1) ------------------ 1394| 2.01k| item->valueint = 1; 1395| 2.01k| input_buffer->offset += 4; 1396| 2.01k| return true; ------------------ | | 65| 2.01k|#define true ((cJSON_bool)1) ------------------ 1397| 2.01k| } 1398| | /* string */ 1399| 772k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 301| 1.54M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 772k, False: 0] | | | Branch (301:65): [True: 772k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 304| 772k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1399:49): [True: 5.66k, False: 766k] ------------------ 1400| 5.66k| { 1401| 5.66k| return parse_string(item, input_buffer); 1402| 5.66k| } 1403| | /* number */ 1404| 766k| if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) ------------------ | | 301| 1.53M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 766k, False: 0] | | | Branch (301:65): [True: 766k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) ------------------ | | 304| 766k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) ------------------ | | 304| 764k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) ------------------ | | 304| 764k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1404:50): [True: 1.67k, False: 764k] | Branch (1404:97): [True: 764k, False: 163] | Branch (1404:143): [True: 44.9k, False: 719k] ------------------ 1405| 46.6k| { 1406| 46.6k| return parse_number(item, input_buffer); 1407| 46.6k| } 1408| | /* array */ 1409| 719k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 301| 1.43M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 719k, False: 0] | | | Branch (301:65): [True: 719k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 304| 719k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1409:49): [True: 292k, False: 426k] ------------------ 1410| 292k| { 1411| 292k| return parse_array(item, input_buffer); 1412| 292k| } 1413| | /* object */ 1414| 426k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) ------------------ | | 301| 853k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 426k, False: 0] | | | Branch (301:65): [True: 426k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) ------------------ | | 304| 426k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1414:49): [True: 426k, False: 313] ------------------ 1415| 426k| { 1416| 426k| return parse_object(item, input_buffer); 1417| 426k| } 1418| | 1419| 313| return false; ------------------ | | 70| 313|#define false ((cJSON_bool)0) ------------------ 1420| 426k|} cJSON.c:parse_string: 825| 39.4k|{ 826| 39.4k| const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; ------------------ | | 304| 39.4k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 827| 39.4k| const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; ------------------ | | 304| 39.4k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 828| 39.4k| unsigned char *output_pointer = NULL; 829| 39.4k| unsigned char *output = NULL; 830| | 831| | /* not a string */ 832| 39.4k| if (buffer_at_offset(input_buffer)[0] != '\"') ------------------ | | 304| 39.4k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (832:9): [True: 134, False: 39.2k] ------------------ 833| 134| { 834| 134| goto fail; 835| 134| } 836| | 837| 39.2k| { 838| | /* calculate approximate size of the output (overestimate) */ 839| 39.2k| size_t allocation_length = 0; 840| 39.2k| size_t skipped_bytes = 0; 841| 25.7M| while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) ------------------ | Branch (841:16): [True: 25.7M, False: 69] | Branch (841:88): [True: 25.6M, False: 39.2k] ------------------ 842| 25.6M| { 843| | /* is escape sequence */ 844| 25.6M| if (input_end[0] == '\\') ------------------ | Branch (844:17): [True: 214k, False: 25.4M] ------------------ 845| 214k| { 846| 214k| if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) ------------------ | Branch (846:21): [True: 0, False: 214k] ------------------ 847| 0| { 848| | /* prevent buffer overflow when last input character is a backslash */ 849| 0| goto fail; 850| 0| } 851| 214k| skipped_bytes++; 852| 214k| input_end++; 853| 214k| } 854| 25.6M| input_end++; 855| 25.6M| } 856| 39.2k| if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) ------------------ | Branch (856:13): [True: 69, False: 39.2k] | Branch (856:86): [True: 0, False: 39.2k] ------------------ 857| 69| { 858| 69| goto fail; /* string ended unexpectedly */ 859| 69| } 860| | 861| | /* This is at most how much we need for the output */ 862| 39.2k| allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; ------------------ | | 304| 39.2k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 863| 39.2k| output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); 864| 39.2k| if (output == NULL) ------------------ | Branch (864:13): [True: 0, False: 39.2k] ------------------ 865| 0| { 866| 0| goto fail; /* allocation failure */ 867| 0| } 868| 39.2k| } 869| | 870| 39.2k| output_pointer = output; 871| | /* loop through the string literal */ 872| 23.9M| while (input_pointer < input_end) ------------------ | Branch (872:12): [True: 23.8M, False: 39.0k] ------------------ 873| 23.8M| { 874| 23.8M| if (*input_pointer != '\\') ------------------ | Branch (874:13): [True: 23.6M, False: 194k] ------------------ 875| 23.6M| { 876| 23.6M| *output_pointer++ = *input_pointer++; 877| 23.6M| } 878| | /* escape sequence */ 879| 194k| else 880| 194k| { 881| 194k| unsigned char sequence_length = 2; 882| 194k| if ((input_end - input_pointer) < 1) ------------------ | Branch (882:17): [True: 0, False: 194k] ------------------ 883| 0| { 884| 0| goto fail; 885| 0| } 886| | 887| 194k| switch (input_pointer[1]) 888| 194k| { 889| 11.8k| case 'b': ------------------ | Branch (889:17): [True: 11.8k, False: 182k] ------------------ 890| 11.8k| *output_pointer++ = '\b'; 891| 11.8k| break; 892| 10.3k| case 'f': ------------------ | Branch (892:17): [True: 10.3k, False: 183k] ------------------ 893| 10.3k| *output_pointer++ = '\f'; 894| 10.3k| break; 895| 11.3k| case 'n': ------------------ | Branch (895:17): [True: 11.3k, False: 182k] ------------------ 896| 11.3k| *output_pointer++ = '\n'; 897| 11.3k| break; 898| 7.38k| case 'r': ------------------ | Branch (898:17): [True: 7.38k, False: 186k] ------------------ 899| 7.38k| *output_pointer++ = '\r'; 900| 7.38k| break; 901| 18.0k| case 't': ------------------ | Branch (901:17): [True: 18.0k, False: 175k] ------------------ 902| 18.0k| *output_pointer++ = '\t'; 903| 18.0k| break; 904| 22.6k| case '\"': ------------------ | Branch (904:17): [True: 22.6k, False: 171k] ------------------ 905| 36.7k| case '\\': ------------------ | Branch (905:17): [True: 14.1k, False: 179k] ------------------ 906| 58.6k| case '/': ------------------ | Branch (906:17): [True: 21.9k, False: 172k] ------------------ 907| 58.6k| *output_pointer++ = input_pointer[1]; 908| 58.6k| break; 909| | 910| | /* UTF-16 literal */ 911| 76.3k| case 'u': ------------------ | Branch (911:17): [True: 76.3k, False: 117k] ------------------ 912| 76.3k| sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); 913| 76.3k| if (sequence_length == 0) ------------------ | Branch (913:25): [True: 131, False: 76.2k] ------------------ 914| 131| { 915| | /* failed to convert UTF16-literal to UTF-8 */ 916| 131| goto fail; 917| 131| } 918| 76.2k| break; 919| | 920| 76.2k| default: ------------------ | Branch (920:17): [True: 13, False: 194k] ------------------ 921| 13| goto fail; 922| 194k| } 923| 193k| input_pointer += sequence_length; 924| 193k| } 925| 23.8M| } 926| | 927| | /* zero terminate the output */ 928| 39.0k| *output_pointer = '\0'; 929| | 930| 39.0k| item->type = cJSON_String; ------------------ | | 94| 39.0k|#define cJSON_String (1 << 4) ------------------ 931| 39.0k| item->valuestring = (char*)output; 932| | 933| 39.0k| input_buffer->offset = (size_t) (input_end - input_buffer->content); 934| 39.0k| input_buffer->offset++; 935| | 936| 39.0k| return true; ------------------ | | 65| 39.0k|#define true ((cJSON_bool)1) ------------------ 937| | 938| 347|fail: 939| 347| if (output != NULL) ------------------ | Branch (939:9): [True: 144, False: 203] ------------------ 940| 144| { 941| 144| input_buffer->hooks.deallocate(output); 942| 144| output = NULL; 943| 144| } 944| | 945| 347| if (input_pointer != NULL) ------------------ | Branch (945:9): [True: 347, False: 0] ------------------ 946| 347| { 947| 347| input_buffer->offset = (size_t)(input_pointer - input_buffer->content); 948| 347| } 949| | 950| 347| return false; ------------------ | | 70| 347|#define false ((cJSON_bool)0) ------------------ 951| 39.2k|} cJSON.c:utf16_literal_to_utf8: 704| 76.3k|{ 705| 76.3k| long unsigned int codepoint = 0; 706| 76.3k| unsigned int first_code = 0; 707| 76.3k| const unsigned char *first_sequence = input_pointer; 708| 76.3k| unsigned char utf8_length = 0; 709| 76.3k| unsigned char utf8_position = 0; 710| 76.3k| unsigned char sequence_length = 0; 711| 76.3k| unsigned char first_byte_mark = 0; 712| | 713| 76.3k| if ((input_end - first_sequence) < 6) ------------------ | Branch (713:9): [True: 3, False: 76.3k] ------------------ 714| 3| { 715| | /* input ends unexpectedly */ 716| 3| goto fail; 717| 3| } 718| | 719| | /* get the first utf16 sequence */ 720| 76.3k| first_code = parse_hex4(first_sequence + 2); 721| | 722| | /* check that the code is valid */ 723| 76.3k| if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) ------------------ | Branch (723:10): [True: 8.98k, False: 67.3k] | Branch (723:36): [True: 14, False: 8.97k] ------------------ 724| 14| { 725| 14| goto fail; 726| 14| } 727| | 728| | /* UTF16 surrogate pair */ 729| 76.3k| if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) ------------------ | Branch (729:9): [True: 13.2k, False: 63.1k] | Branch (729:35): [True: 4.25k, False: 8.97k] ------------------ 730| 4.25k| { 731| 4.25k| const unsigned char *second_sequence = first_sequence + 6; 732| 4.25k| unsigned int second_code = 0; 733| 4.25k| sequence_length = 12; /* \uXXXX\uXXXX */ 734| | 735| 4.25k| if ((input_end - second_sequence) < 6) ------------------ | Branch (735:13): [True: 18, False: 4.23k] ------------------ 736| 18| { 737| | /* input ends unexpectedly */ 738| 18| goto fail; 739| 18| } 740| | 741| 4.23k| if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) ------------------ | Branch (741:13): [True: 14, False: 4.21k] | Branch (741:45): [True: 17, False: 4.20k] ------------------ 742| 31| { 743| | /* missing second half of the surrogate pair */ 744| 31| goto fail; 745| 31| } 746| | 747| | /* get the second utf16 sequence */ 748| 4.20k| second_code = parse_hex4(second_sequence + 2); 749| | /* check that the code is valid */ 750| 4.20k| if ((second_code < 0xDC00) || (second_code > 0xDFFF)) ------------------ | Branch (750:13): [True: 57, False: 4.14k] | Branch (750:39): [True: 8, False: 4.13k] ------------------ 751| 65| { 752| | /* invalid second half of the surrogate pair */ 753| 65| goto fail; 754| 65| } 755| | 756| | 757| | /* calculate the unicode codepoint from the surrogate pair */ 758| 4.13k| codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); 759| 4.13k| } 760| 72.0k| else 761| 72.0k| { 762| 72.0k| sequence_length = 6; /* \uXXXX */ 763| 72.0k| codepoint = first_code; 764| 72.0k| } 765| | 766| | /* encode as UTF-8 767| | * takes at maximum 4 bytes to encode: 768| | * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 769| 76.2k| if (codepoint < 0x80) ------------------ | Branch (769:9): [True: 40.1k, False: 36.1k] ------------------ 770| 40.1k| { 771| | /* normal ascii, encoding 0xxxxxxx */ 772| 40.1k| utf8_length = 1; 773| 40.1k| } 774| 36.1k| else if (codepoint < 0x800) ------------------ | Branch (774:14): [True: 7.08k, False: 29.0k] ------------------ 775| 7.08k| { 776| | /* two bytes, encoding 110xxxxx 10xxxxxx */ 777| 7.08k| utf8_length = 2; 778| 7.08k| first_byte_mark = 0xC0; /* 11000000 */ 779| 7.08k| } 780| 29.0k| else if (codepoint < 0x10000) ------------------ | Branch (780:14): [True: 24.8k, False: 4.13k] ------------------ 781| 24.8k| { 782| | /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ 783| 24.8k| utf8_length = 3; 784| 24.8k| first_byte_mark = 0xE0; /* 11100000 */ 785| 24.8k| } 786| 4.13k| else if (codepoint <= 0x10FFFF) ------------------ | Branch (786:14): [True: 4.13k, False: 0] ------------------ 787| 4.13k| { 788| | /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ 789| 4.13k| utf8_length = 4; 790| 4.13k| first_byte_mark = 0xF0; /* 11110000 */ 791| 4.13k| } 792| 0| else 793| 0| { 794| | /* invalid unicode codepoint */ 795| 0| goto fail; 796| 0| } 797| | 798| | /* encode as utf8 */ 799| 145k| for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) ------------------ | Branch (799:60): [True: 69.2k, False: 76.2k] ------------------ 800| 69.2k| { 801| | /* 10xxxxxx */ 802| 69.2k| (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); 803| 69.2k| codepoint >>= 6; 804| 69.2k| } 805| | /* encode first byte */ 806| 76.2k| if (utf8_length > 1) ------------------ | Branch (806:9): [True: 36.1k, False: 40.1k] ------------------ 807| 36.1k| { 808| 36.1k| (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); 809| 36.1k| } 810| 40.1k| else 811| 40.1k| { 812| 40.1k| (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); 813| 40.1k| } 814| | 815| 76.2k| *output_pointer += utf8_length; 816| | 817| 76.2k| return sequence_length; 818| | 819| 131|fail: 820| 131| return 0; 821| 76.2k|} cJSON.c:parse_hex4: 667| 80.5k|{ 668| 80.5k| unsigned int h = 0; 669| 80.5k| size_t i = 0; 670| | 671| 287k| for (i = 0; i < 4; i++) ------------------ | Branch (671:17): [True: 244k, False: 42.8k] ------------------ 672| 244k| { 673| | /* parse digit */ 674| 244k| if ((input[i] >= '0') && (input[i] <= '9')) ------------------ | Branch (674:13): [True: 237k, False: 7.74k] | Branch (674:34): [True: 79.9k, False: 157k] ------------------ 675| 79.9k| { 676| 79.9k| h += (unsigned int) input[i] - '0'; 677| 79.9k| } 678| 164k| else if ((input[i] >= 'A') && (input[i] <= 'F')) ------------------ | Branch (678:18): [True: 148k, False: 16.6k] | Branch (678:39): [True: 28.8k, False: 119k] ------------------ 679| 28.8k| { 680| 28.8k| h += (unsigned int) 10 + input[i] - 'A'; 681| 28.8k| } 682| 136k| else if ((input[i] >= 'a') && (input[i] <= 'f')) ------------------ | Branch (682:18): [True: 118k, False: 17.9k] | Branch (682:39): [True: 98.3k, False: 19.6k] ------------------ 683| 98.3k| { 684| 98.3k| h += (unsigned int) 10 + input[i] - 'a'; 685| 98.3k| } 686| 37.6k| else /* invalid */ 687| 37.6k| { 688| 37.6k| return 0; 689| 37.6k| } 690| | 691| 207k| if (i < 3) ------------------ | Branch (691:13): [True: 164k, False: 42.8k] ------------------ 692| 164k| { 693| | /* shift left to make place for the next nibble */ 694| 164k| h = h << 4; 695| 164k| } 696| 207k| } 697| | 698| 42.8k| return h; 699| 80.5k|} cJSON.c:parse_number: 308| 46.6k|{ 309| 46.6k| double number = 0; 310| 46.6k| unsigned char *after_end = NULL; 311| 46.6k| unsigned char *number_c_string; 312| 46.6k| unsigned char decimal_point = get_decimal_point(); 313| 46.6k| size_t i = 0; 314| 46.6k| size_t number_string_length = 0; 315| 46.6k| cJSON_bool has_decimal_point = false; ------------------ | | 70| 46.6k|#define false ((cJSON_bool)0) ------------------ 316| | 317| 46.6k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (317:9): [True: 0, False: 46.6k] | Branch (317:35): [True: 0, False: 46.6k] ------------------ 318| 0| { 319| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 320| 0| } 321| | 322| | /* copy the number into a temporary buffer and replace '.' with the decimal point 323| | * of the current locale (for strtod) 324| | * This also takes care of '\0' not necessarily being available for marking the end of the input */ 325| 719k| for (i = 0; can_access_at_index(input_buffer, i); i++) ------------------ | | 301| 719k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 719k, False: 0] | | | Branch (301:65): [True: 719k, False: 0] | | ------------------ ------------------ 326| 719k| { 327| 719k| switch (buffer_at_offset(input_buffer)[i]) ------------------ | | 304| 719k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 328| 719k| { 329| 452k| case '0': ------------------ | Branch (329:13): [True: 452k, False: 266k] ------------------ 330| 485k| case '1': ------------------ | Branch (330:13): [True: 32.8k, False: 687k] ------------------ 331| 500k| case '2': ------------------ | Branch (331:13): [True: 15.1k, False: 704k] ------------------ 332| 508k| case '3': ------------------ | Branch (332:13): [True: 7.60k, False: 712k] ------------------ 333| 515k| case '4': ------------------ | Branch (333:13): [True: 6.59k, False: 713k] ------------------ 334| 526k| case '5': ------------------ | Branch (334:13): [True: 11.6k, False: 708k] ------------------ 335| 542k| case '6': ------------------ | Branch (335:13): [True: 15.7k, False: 704k] ------------------ 336| 554k| case '7': ------------------ | Branch (336:13): [True: 12.3k, False: 707k] ------------------ 337| 569k| case '8': ------------------ | Branch (337:13): [True: 14.3k, False: 705k] ------------------ 338| 598k| case '9': ------------------ | Branch (338:13): [True: 29.4k, False: 690k] ------------------ 339| 600k| case '+': ------------------ | Branch (339:13): [True: 1.40k, False: 718k] ------------------ 340| 655k| case '-': ------------------ | Branch (340:13): [True: 55.4k, False: 664k] ------------------ 341| 657k| case 'e': ------------------ | Branch (341:13): [True: 2.04k, False: 717k] ------------------ 342| 664k| case 'E': ------------------ | Branch (342:13): [True: 6.54k, False: 713k] ------------------ 343| 664k| number_string_length++; 344| 664k| break; 345| | 346| 9.12k| case '.': ------------------ | Branch (346:13): [True: 9.12k, False: 710k] ------------------ 347| 9.12k| number_string_length++; 348| 9.12k| has_decimal_point = true; ------------------ | | 65| 9.12k|#define true ((cJSON_bool)1) ------------------ 349| 9.12k| break; 350| | 351| 46.6k| default: ------------------ | Branch (351:13): [True: 46.6k, False: 673k] ------------------ 352| 46.6k| goto loop_end; 353| 719k| } 354| 719k| } 355| 46.6k|loop_end: 356| | /* malloc for temporary buffer, add 1 for '\0' */ 357| 46.6k| number_c_string = (unsigned char *) input_buffer->hooks.allocate(number_string_length + 1); 358| 46.6k| if (number_c_string == NULL) ------------------ | Branch (358:9): [True: 0, False: 46.6k] ------------------ 359| 0| { 360| 0| return false; /* allocation failure */ ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 361| 0| } 362| | 363| 46.6k| memcpy(number_c_string, buffer_at_offset(input_buffer), number_string_length); ------------------ | | 304| 46.6k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 364| 46.6k| number_c_string[number_string_length] = '\0'; 365| | 366| 46.6k| if (has_decimal_point) ------------------ | Branch (366:9): [True: 1.27k, False: 45.3k] ------------------ 367| 1.27k| { 368| 598k| for (i = 0; i < number_string_length; i++) ------------------ | Branch (368:21): [True: 597k, False: 1.27k] ------------------ 369| 597k| { 370| 597k| if (number_c_string[i] == '.') ------------------ | Branch (370:17): [True: 9.12k, False: 588k] ------------------ 371| 9.12k| { 372| | /* replace '.' with the decimal point of the current locale (for strtod) */ 373| 9.12k| number_c_string[i] = decimal_point; 374| 9.12k| } 375| 597k| } 376| 1.27k| } 377| | 378| 46.6k| number = strtod((const char*)number_c_string, (char**)&after_end); 379| 46.6k| if (number_c_string == after_end) ------------------ | Branch (379:9): [True: 18, False: 46.6k] ------------------ 380| 18| { 381| | /* free the temporary buffer */ 382| 18| input_buffer->hooks.deallocate(number_c_string); 383| 18| return false; /* parse_error */ ------------------ | | 70| 18|#define false ((cJSON_bool)0) ------------------ 384| 18| } 385| | 386| 46.6k| item->valuedouble = number; 387| | 388| | /* use saturation in case of overflow */ 389| 46.6k| if (number >= INT_MAX) ------------------ | Branch (389:9): [True: 2.97k, False: 43.6k] ------------------ 390| 2.97k| { 391| 2.97k| item->valueint = INT_MAX; 392| 2.97k| } 393| 43.6k| else if (number <= (double)INT_MIN) ------------------ | Branch (393:14): [True: 320, False: 43.3k] ------------------ 394| 320| { 395| 320| item->valueint = INT_MIN; 396| 320| } 397| 43.3k| else 398| 43.3k| { 399| 43.3k| item->valueint = (int)number; 400| 43.3k| } 401| | 402| 46.6k| item->type = cJSON_Number; ------------------ | | 93| 46.6k|#define cJSON_Number (1 << 3) ------------------ 403| | 404| 46.6k| input_buffer->offset += (size_t)(after_end - number_c_string); 405| | /* free the temporary buffer */ 406| 46.6k| input_buffer->hooks.deallocate(number_c_string); 407| 46.6k| return true; ------------------ | | 65| 46.6k|#define true ((cJSON_bool)1) ------------------ 408| 46.6k|} cJSON.c:get_decimal_point: 280| 78.9k|{ 281| 78.9k|#ifdef ENABLE_LOCALES 282| 78.9k| struct lconv *lconv = localeconv(); 283| 78.9k| return (unsigned char) lconv->decimal_point[0]; 284| |#else 285| | return '.'; 286| |#endif 287| 78.9k|} cJSON.c:parse_array: 1498| 292k|{ 1499| 292k| cJSON *head = NULL; /* head of the linked list */ 1500| 292k| cJSON *current_item = NULL; 1501| | 1502| 292k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 292k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1502:9): [True: 2, False: 292k] ------------------ 1503| 2| { 1504| 2| return false; /* to deeply nested */ ------------------ | | 70| 2|#define false ((cJSON_bool)0) ------------------ 1505| 2| } 1506| 292k| input_buffer->depth++; 1507| | 1508| 292k| if (buffer_at_offset(input_buffer)[0] != '[') ------------------ | | 304| 292k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1508:9): [True: 0, False: 292k] ------------------ 1509| 0| { 1510| | /* not an array */ 1511| 0| goto fail; 1512| 0| } 1513| | 1514| 292k| input_buffer->offset++; 1515| 292k| buffer_skip_whitespace(input_buffer); 1516| 292k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 301| 585k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 292k, False: 0] | | | Branch (301:65): [True: 292k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 304| 292k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1516:49): [True: 3.34k, False: 289k] ------------------ 1517| 3.34k| { 1518| | /* empty array */ 1519| 3.34k| goto success; 1520| 3.34k| } 1521| | 1522| | /* check if we skipped to the end of the buffer */ 1523| 289k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 302| 289k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 289k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 289k, False: 0] | | | | | Branch (301:65): [True: 289k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1524| 0| { 1525| 0| input_buffer->offset--; 1526| 0| goto fail; 1527| 0| } 1528| | 1529| | /* step back to character in front of the first element */ 1530| 289k| input_buffer->offset--; 1531| | /* loop through the comma separated array elements */ 1532| 289k| do 1533| 739k| { 1534| | /* allocate next item */ 1535| 739k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1536| 739k| if (new_item == NULL) ------------------ | Branch (1536:13): [True: 0, False: 739k] ------------------ 1537| 0| { 1538| 0| goto fail; /* allocation failure */ 1539| 0| } 1540| | 1541| | /* attach next item to list */ 1542| 739k| if (head == NULL) ------------------ | Branch (1542:13): [True: 289k, False: 450k] ------------------ 1543| 289k| { 1544| | /* start the linked list */ 1545| 289k| current_item = head = new_item; 1546| 289k| } 1547| 450k| else 1548| 450k| { 1549| | /* add to the end and advance */ 1550| 450k| current_item->next = new_item; 1551| 450k| new_item->prev = current_item; 1552| 450k| current_item = new_item; 1553| 450k| } 1554| | 1555| | /* parse next value */ 1556| 739k| input_buffer->offset++; 1557| 739k| buffer_skip_whitespace(input_buffer); 1558| 739k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1558:13): [True: 43.2k, False: 696k] ------------------ 1559| 43.2k| { 1560| 43.2k| goto fail; /* failed to parse value */ 1561| 43.2k| } 1562| 696k| buffer_skip_whitespace(input_buffer); 1563| 696k| } 1564| 696k| while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 301| 1.39M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 696k, False: 0] | | | Branch (301:65): [True: 696k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 304| 696k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1564:52): [True: 450k, False: 246k] ------------------ 1565| | 1566| 246k| if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 302| 492k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 246k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 246k, False: 0] | | | | | Branch (301:65): [True: 246k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 304| 246k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1566:52): [True: 112, False: 246k] ------------------ 1567| 112| { 1568| 112| goto fail; /* expected end of array */ 1569| 112| } 1570| | 1571| 249k|success: 1572| 249k| input_buffer->depth--; 1573| | 1574| 249k| if (head != NULL) { ------------------ | Branch (1574:9): [True: 246k, False: 3.34k] ------------------ 1575| 246k| head->prev = current_item; 1576| 246k| } 1577| | 1578| 249k| item->type = cJSON_Array; ------------------ | | 95| 249k|#define cJSON_Array (1 << 5) ------------------ 1579| 249k| item->child = head; 1580| | 1581| 249k| input_buffer->offset++; 1582| | 1583| 249k| return true; ------------------ | | 65| 249k|#define true ((cJSON_bool)1) ------------------ 1584| | 1585| 43.3k|fail: 1586| 43.3k| if (head != NULL) ------------------ | Branch (1586:9): [True: 43.3k, False: 0] ------------------ 1587| 43.3k| { 1588| 43.3k| cJSON_Delete(head); 1589| 43.3k| } 1590| | 1591| 43.3k| return false; ------------------ | | 70| 43.3k|#define false ((cJSON_bool)0) ------------------ 1592| 246k|} cJSON.c:parse_object: 1663| 426k|{ 1664| 426k| cJSON *head = NULL; /* linked list head */ 1665| 426k| cJSON *current_item = NULL; 1666| | 1667| 426k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 426k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1667:9): [True: 2, False: 426k] ------------------ 1668| 2| { 1669| 2| return false; /* to deeply nested */ ------------------ | | 70| 2|#define false ((cJSON_bool)0) ------------------ 1670| 2| } 1671| 426k| input_buffer->depth++; 1672| | 1673| 426k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) ------------------ | | 302| 852k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 426k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 426k, False: 0] | | | | | Branch (301:65): [True: 426k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) ------------------ | | 304| 426k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1673:52): [True: 0, False: 426k] ------------------ 1674| 0| { 1675| 0| goto fail; /* not an object */ 1676| 0| } 1677| | 1678| 426k| input_buffer->offset++; 1679| 426k| buffer_skip_whitespace(input_buffer); 1680| 426k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) ------------------ | | 301| 852k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 426k, False: 0] | | | Branch (301:65): [True: 426k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) ------------------ | | 304| 426k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1680:49): [True: 411k, False: 15.2k] ------------------ 1681| 411k| { 1682| 411k| goto success; /* empty object */ 1683| 411k| } 1684| | 1685| | /* check if we skipped to the end of the buffer */ 1686| 15.2k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 302| 15.2k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 15.2k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 15.2k, False: 0] | | | | | Branch (301:65): [True: 15.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1687| 0| { 1688| 0| input_buffer->offset--; 1689| 0| goto fail; 1690| 0| } 1691| | 1692| | /* step back to character in front of the first element */ 1693| 15.2k| input_buffer->offset--; 1694| | /* loop through the comma separated array elements */ 1695| 15.2k| do 1696| 33.7k| { 1697| | /* allocate next item */ 1698| 33.7k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1699| 33.7k| if (new_item == NULL) ------------------ | Branch (1699:13): [True: 0, False: 33.7k] ------------------ 1700| 0| { 1701| 0| goto fail; /* allocation failure */ 1702| 0| } 1703| | 1704| | /* attach next item to list */ 1705| 33.7k| if (head == NULL) ------------------ | Branch (1705:13): [True: 15.2k, False: 18.5k] ------------------ 1706| 15.2k| { 1707| | /* start the linked list */ 1708| 15.2k| current_item = head = new_item; 1709| 15.2k| } 1710| 18.5k| else 1711| 18.5k| { 1712| | /* add to the end and advance */ 1713| 18.5k| current_item->next = new_item; 1714| 18.5k| new_item->prev = current_item; 1715| 18.5k| current_item = new_item; 1716| 18.5k| } 1717| | 1718| 33.7k| if (cannot_access_at_index(input_buffer, 1)) ------------------ | | 302| 33.7k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 33.7k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 33.7k, False: 0] | | | | | Branch (301:65): [True: 33.7k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1719| 0| { 1720| 0| goto fail; /* nothing comes after the comma */ 1721| 0| } 1722| | 1723| | /* parse the name of the child */ 1724| 33.7k| input_buffer->offset++; 1725| 33.7k| buffer_skip_whitespace(input_buffer); 1726| 33.7k| if (!parse_string(current_item, input_buffer)) ------------------ | Branch (1726:13): [True: 148, False: 33.6k] ------------------ 1727| 148| { 1728| 148| goto fail; /* failed to parse name */ 1729| 148| } 1730| 33.6k| buffer_skip_whitespace(input_buffer); 1731| | 1732| | /* swap valuestring and string, because we parsed the name */ 1733| 33.6k| current_item->string = current_item->valuestring; 1734| 33.6k| current_item->valuestring = NULL; 1735| | 1736| 33.6k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 302| 67.2k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 33.6k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 33.6k, False: 0] | | | | | Branch (301:65): [True: 33.6k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 304| 33.6k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1736:56): [True: 33, False: 33.5k] ------------------ 1737| 33| { 1738| 33| goto fail; /* invalid object */ 1739| 33| } 1740| | 1741| | /* parse the value */ 1742| 33.5k| input_buffer->offset++; 1743| 33.5k| buffer_skip_whitespace(input_buffer); 1744| 33.5k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1744:13): [True: 4.04k, False: 29.5k] ------------------ 1745| 4.04k| { 1746| 4.04k| goto fail; /* failed to parse value */ 1747| 4.04k| } 1748| 29.5k| buffer_skip_whitespace(input_buffer); 1749| 29.5k| } 1750| 29.5k| while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 301| 59.0k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 29.5k, False: 0] | | | Branch (301:65): [True: 29.5k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 304| 29.5k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1750:52): [True: 18.5k, False: 11.0k] ------------------ 1751| | 1752| 11.0k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 302| 22.0k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 11.0k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 11.0k, False: 0] | | | | | Branch (301:65): [True: 11.0k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 304| 11.0k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1752:52): [True: 38, False: 10.9k] ------------------ 1753| 38| { 1754| 38| goto fail; /* expected end of object */ 1755| 38| } 1756| | 1757| 422k|success: 1758| 422k| input_buffer->depth--; 1759| | 1760| 422k| if (head != NULL) { ------------------ | Branch (1760:9): [True: 10.9k, False: 411k] ------------------ 1761| 10.9k| head->prev = current_item; 1762| 10.9k| } 1763| | 1764| 422k| item->type = cJSON_Object; ------------------ | | 96| 422k|#define cJSON_Object (1 << 6) ------------------ 1765| 422k| item->child = head; 1766| | 1767| 422k| input_buffer->offset++; 1768| 422k| return true; ------------------ | | 65| 422k|#define true ((cJSON_bool)1) ------------------ 1769| | 1770| 4.26k|fail: 1771| 4.26k| if (head != NULL) ------------------ | Branch (1771:9): [True: 4.26k, False: 0] ------------------ 1772| 4.26k| { 1773| 4.26k| cJSON_Delete(head); 1774| 4.26k| } 1775| | 1776| 4.26k| return false; ------------------ | | 70| 4.26k|#define false ((cJSON_bool)0) ------------------ 1777| 11.0k|} cJSON.c:print_value: 1424| 678k|{ 1425| 678k| unsigned char *output = NULL; 1426| | 1427| 678k| if ((item == NULL) || (output_buffer == NULL)) ------------------ | Branch (1427:9): [True: 0, False: 678k] | Branch (1427:27): [True: 0, False: 678k] ------------------ 1428| 0| { 1429| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1430| 0| } 1431| | 1432| 678k| switch ((item->type) & 0xFF) 1433| 678k| { 1434| 356| case cJSON_NULL: ------------------ | | 92| 356|#define cJSON_NULL (1 << 2) ------------------ | Branch (1434:9): [True: 356, False: 677k] ------------------ 1435| 356| output = ensure(output_buffer, 5); 1436| 356| if (output == NULL) ------------------ | Branch (1436:17): [True: 0, False: 356] ------------------ 1437| 0| { 1438| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1439| 0| } 1440| 356| strcpy((char*)output, "null"); 1441| 356| return true; ------------------ | | 65| 356|#define true ((cJSON_bool)1) ------------------ 1442| | 1443| 593| case cJSON_False: ------------------ | | 90| 593|#define cJSON_False (1 << 0) ------------------ | Branch (1443:9): [True: 593, False: 677k] ------------------ 1444| 593| output = ensure(output_buffer, 6); 1445| 593| if (output == NULL) ------------------ | Branch (1445:17): [True: 0, False: 593] ------------------ 1446| 0| { 1447| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1448| 0| } 1449| 593| strcpy((char*)output, "false"); 1450| 593| return true; ------------------ | | 65| 593|#define true ((cJSON_bool)1) ------------------ 1451| | 1452| 1.73k| case cJSON_True: ------------------ | | 91| 1.73k|#define cJSON_True (1 << 1) ------------------ | Branch (1452:9): [True: 1.73k, False: 676k] ------------------ 1453| 1.73k| output = ensure(output_buffer, 5); 1454| 1.73k| if (output == NULL) ------------------ | Branch (1454:17): [True: 0, False: 1.73k] ------------------ 1455| 0| { 1456| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1457| 0| } 1458| 1.73k| strcpy((char*)output, "true"); 1459| 1.73k| return true; ------------------ | | 65| 1.73k|#define true ((cJSON_bool)1) ------------------ 1460| | 1461| 32.3k| case cJSON_Number: ------------------ | | 93| 32.3k|#define cJSON_Number (1 << 3) ------------------ | Branch (1461:9): [True: 32.3k, False: 645k] ------------------ 1462| 32.3k| return print_number(item, output_buffer); 1463| | 1464| 0| case cJSON_Raw: ------------------ | | 97| 0|#define cJSON_Raw (1 << 7) /* raw json */ ------------------ | Branch (1464:9): [True: 0, False: 678k] ------------------ 1465| 0| { 1466| 0| size_t raw_length = 0; 1467| 0| if (item->valuestring == NULL) ------------------ | Branch (1467:17): [True: 0, False: 0] ------------------ 1468| 0| { 1469| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1470| 0| } 1471| | 1472| 0| raw_length = strlen(item->valuestring) + sizeof(""); 1473| 0| output = ensure(output_buffer, raw_length); 1474| 0| if (output == NULL) ------------------ | Branch (1474:17): [True: 0, False: 0] ------------------ 1475| 0| { 1476| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1477| 0| } 1478| 0| memcpy(output, item->valuestring, raw_length); 1479| 0| return true; ------------------ | | 65| 0|#define true ((cJSON_bool)1) ------------------ 1480| 0| } 1481| | 1482| 2.50k| case cJSON_String: ------------------ | | 94| 2.50k|#define cJSON_String (1 << 4) ------------------ | Branch (1482:9): [True: 2.50k, False: 675k] ------------------ 1483| 2.50k| return print_string(item, output_buffer); 1484| | 1485| 235k| case cJSON_Array: ------------------ | | 95| 235k|#define cJSON_Array (1 << 5) ------------------ | Branch (1485:9): [True: 235k, False: 442k] ------------------ 1486| 235k| return print_array(item, output_buffer); 1487| | 1488| 404k| case cJSON_Object: ------------------ | | 96| 404k|#define cJSON_Object (1 << 6) ------------------ | Branch (1488:9): [True: 404k, False: 273k] ------------------ 1489| 404k| return print_object(item, output_buffer); 1490| | 1491| 0| default: ------------------ | Branch (1491:9): [True: 0, False: 678k] ------------------ 1492| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1493| 678k| } 1494| 678k|} cJSON.c:ensure: 491| 1.80M|{ 492| 1.80M| unsigned char *newbuffer = NULL; 493| 1.80M| size_t newsize = 0; 494| | 495| 1.80M| if ((p == NULL) || (p->buffer == NULL)) ------------------ | Branch (495:9): [True: 0, False: 1.80M] | Branch (495:24): [True: 0, False: 1.80M] ------------------ 496| 0| { 497| 0| return NULL; 498| 0| } 499| | 500| 1.80M| if ((p->length > 0) && (p->offset >= p->length)) ------------------ | Branch (500:9): [True: 1.80M, False: 0] | Branch (500:28): [True: 0, False: 1.80M] ------------------ 501| 0| { 502| | /* make sure that offset is valid */ 503| 0| return NULL; 504| 0| } 505| | 506| 1.80M| if (needed > INT_MAX) ------------------ | Branch (506:9): [True: 0, False: 1.80M] ------------------ 507| 0| { 508| | /* sizes bigger than INT_MAX are currently not supported */ 509| 0| return NULL; 510| 0| } 511| | 512| 1.80M| needed += p->offset + 1; 513| 1.80M| if (needed <= p->length) ------------------ | Branch (513:9): [True: 1.80M, False: 1.95k] ------------------ 514| 1.80M| { 515| 1.80M| return p->buffer + p->offset; 516| 1.80M| } 517| | 518| 1.95k| if (p->noalloc) { ------------------ | Branch (518:9): [True: 0, False: 1.95k] ------------------ 519| 0| return NULL; 520| 0| } 521| | 522| | /* calculate new buffer size */ 523| 1.95k| if (needed > (INT_MAX / 2)) ------------------ | Branch (523:9): [True: 0, False: 1.95k] ------------------ 524| 0| { 525| | /* overflow of int, use INT_MAX if possible */ 526| 0| if (needed <= INT_MAX) ------------------ | Branch (526:13): [True: 0, False: 0] ------------------ 527| 0| { 528| 0| newsize = INT_MAX; 529| 0| } 530| 0| else 531| 0| { 532| 0| return NULL; 533| 0| } 534| 0| } 535| 1.95k| else 536| 1.95k| { 537| 1.95k| newsize = needed * 2; 538| 1.95k| } 539| | 540| 1.95k| if (p->hooks.reallocate != NULL) ------------------ | Branch (540:9): [True: 1.95k, False: 0] ------------------ 541| 1.95k| { 542| | /* reallocate with realloc if available */ 543| 1.95k| newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); 544| 1.95k| if (newbuffer == NULL) ------------------ | Branch (544:13): [True: 0, False: 1.95k] ------------------ 545| 0| { 546| 0| p->hooks.deallocate(p->buffer); 547| 0| p->length = 0; 548| 0| p->buffer = NULL; 549| | 550| 0| return NULL; 551| 0| } 552| 1.95k| } 553| 0| else 554| 0| { 555| | /* otherwise reallocate manually */ 556| 0| newbuffer = (unsigned char*)p->hooks.allocate(newsize); 557| 0| if (!newbuffer) ------------------ | Branch (557:13): [True: 0, False: 0] ------------------ 558| 0| { 559| 0| p->hooks.deallocate(p->buffer); 560| 0| p->length = 0; 561| 0| p->buffer = NULL; 562| | 563| 0| return NULL; 564| 0| } 565| | 566| 0| memcpy(newbuffer, p->buffer, p->offset + 1); 567| 0| p->hooks.deallocate(p->buffer); 568| 0| } 569| 1.95k| p->length = newsize; 570| 1.95k| p->buffer = newbuffer; 571| | 572| 1.95k| return newbuffer + p->offset; 573| 1.95k|} cJSON.c:print_number: 597| 32.3k|{ 598| 32.3k| unsigned char *output_pointer = NULL; 599| 32.3k| double d = item->valuedouble; 600| 32.3k| int length = 0; 601| 32.3k| size_t i = 0; 602| 32.3k| unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ 603| 32.3k| unsigned char decimal_point = get_decimal_point(); 604| 32.3k| double test = 0.0; 605| | 606| 32.3k| if (output_buffer == NULL) ------------------ | Branch (606:9): [True: 0, False: 32.3k] ------------------ 607| 0| { 608| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 609| 0| } 610| | 611| | /* This checks for NaN and Infinity */ 612| 32.3k| if (isnan(d) || isinf(d)) ------------------ | | 77| 64.6k|#define isnan(d) (d != d) | | ------------------ | | | Branch (77:18): [True: 0, False: 32.3k] | | ------------------ ------------------ if (isnan(d) || isinf(d)) ------------------ | | 74| 32.3k|#define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 64.6k|#define isnan(d) (d != d) | | | | ------------------ | | | | | Branch (77:18): [True: 992, False: 31.3k] | | | | ------------------ | | ------------------ | | #define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 992|#define isnan(d) (d != d) | | ------------------ | | | Branch (74:37): [True: 992, False: 0] | | ------------------ ------------------ 613| 992| { 614| 992| length = sprintf((char*)number_buffer, "null"); 615| 992| } 616| 31.3k| else if(d == (double)item->valueint) ------------------ | Branch (616:13): [True: 29.5k, False: 1.80k] ------------------ 617| 29.5k| { 618| 29.5k| length = sprintf((char*)number_buffer, "%d", item->valueint); 619| 29.5k| } 620| 1.80k| else 621| 1.80k| { 622| | /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ 623| 1.80k| length = sprintf((char*)number_buffer, "%1.15g", d); 624| | 625| | /* Check whether the original double can be recovered */ 626| 1.80k| if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) ------------------ | Branch (626:13): [True: 0, False: 1.80k] | Branch (626:66): [True: 595, False: 1.20k] ------------------ 627| 595| { 628| | /* If not, print with 17 decimal places of precision */ 629| 595| length = sprintf((char*)number_buffer, "%1.17g", d); 630| 595| } 631| 1.80k| } 632| | 633| | /* sprintf failed or buffer overrun occurred */ 634| 32.3k| if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) ------------------ | Branch (634:9): [True: 0, False: 32.3k] | Branch (634:25): [True: 0, False: 32.3k] ------------------ 635| 0| { 636| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 637| 0| } 638| | 639| | /* reserve appropriate space in the output */ 640| 32.3k| output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); 641| 32.3k| if (output_pointer == NULL) ------------------ | Branch (641:9): [True: 0, False: 32.3k] ------------------ 642| 0| { 643| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 644| 0| } 645| | 646| | /* copy the printed number to the output and replace locale 647| | * dependent decimal point with '.' */ 648| 85.2k| for (i = 0; i < ((size_t)length); i++) ------------------ | Branch (648:17): [True: 52.9k, False: 32.3k] ------------------ 649| 52.9k| { 650| 52.9k| if (number_buffer[i] == decimal_point) ------------------ | Branch (650:13): [True: 948, False: 51.9k] ------------------ 651| 948| { 652| 948| output_pointer[i] = '.'; 653| 948| continue; 654| 948| } 655| | 656| 51.9k| output_pointer[i] = number_buffer[i]; 657| 51.9k| } 658| 32.3k| output_pointer[i] = '\0'; 659| | 660| 32.3k| output_buffer->offset += (size_t)length; 661| | 662| 32.3k| return true; ------------------ | | 65| 32.3k|#define true ((cJSON_bool)1) ------------------ 663| 32.3k|} cJSON.c:print_string: 1077| 2.50k|{ 1078| 2.50k| return print_string_ptr((unsigned char*)item->valuestring, p); 1079| 2.50k|} cJSON.c:print_string_ptr: 955| 19.7k|{ 956| 19.7k| const unsigned char *input_pointer = NULL; 957| 19.7k| unsigned char *output = NULL; 958| 19.7k| unsigned char *output_pointer = NULL; 959| 19.7k| size_t output_length = 0; 960| | /* numbers of additional characters needed for escaping */ 961| 19.7k| size_t escape_characters = 0; 962| | 963| 19.7k| if (output_buffer == NULL) ------------------ | Branch (963:9): [True: 0, False: 19.7k] ------------------ 964| 0| { 965| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 966| 0| } 967| | 968| | /* empty string */ 969| 19.7k| if (input == NULL) ------------------ | Branch (969:9): [True: 0, False: 19.7k] ------------------ 970| 0| { 971| 0| output = ensure(output_buffer, sizeof("\"\"")); 972| 0| if (output == NULL) ------------------ | Branch (972:13): [True: 0, False: 0] ------------------ 973| 0| { 974| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 975| 0| } 976| 0| strcpy((char*)output, "\"\""); 977| | 978| 0| return true; ------------------ | | 65| 0|#define true ((cJSON_bool)1) ------------------ 979| 0| } 980| | 981| | /* set "flag" to 1 if something needs to be escaped */ 982| 9.26M| for (input_pointer = input; *input_pointer; input_pointer++) ------------------ | Branch (982:33): [True: 9.24M, False: 19.7k] ------------------ 983| 9.24M| { 984| 9.24M| switch (*input_pointer) 985| 9.24M| { 986| 1.12k| case '\"': ------------------ | Branch (986:13): [True: 1.12k, False: 9.24M] ------------------ 987| 2.59k| case '\\': ------------------ | Branch (987:13): [True: 1.47k, False: 9.24M] ------------------ 988| 15.7k| case '\b': ------------------ | Branch (988:13): [True: 13.1k, False: 9.22M] ------------------ 989| 42.0k| case '\f': ------------------ | Branch (989:13): [True: 26.3k, False: 9.21M] ------------------ 990| 101k| case '\n': ------------------ | Branch (990:13): [True: 59.6k, False: 9.18M] ------------------ 991| 106k| case '\r': ------------------ | Branch (991:13): [True: 5.08k, False: 9.23M] ------------------ 992| 200k| case '\t': ------------------ | Branch (992:13): [True: 93.7k, False: 9.14M] ------------------ 993| | /* one character escape sequence */ 994| 200k| escape_characters++; 995| 200k| break; 996| 9.04M| default: ------------------ | Branch (996:13): [True: 9.04M, False: 200k] ------------------ 997| 9.04M| if (*input_pointer < 32) ------------------ | Branch (997:21): [True: 6.67M, False: 2.36M] ------------------ 998| 6.67M| { 999| | /* UTF-16 escape sequence uXXXX */ 1000| 6.67M| escape_characters += 5; 1001| 6.67M| } 1002| 9.04M| break; 1003| 9.24M| } 1004| 9.24M| } 1005| 19.7k| output_length = (size_t)(input_pointer - input) + escape_characters; 1006| | 1007| 19.7k| output = ensure(output_buffer, output_length + sizeof("\"\"")); 1008| 19.7k| if (output == NULL) ------------------ | Branch (1008:9): [True: 0, False: 19.7k] ------------------ 1009| 0| { 1010| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1011| 0| } 1012| | 1013| | /* no characters have to be escaped */ 1014| 19.7k| if (escape_characters == 0) ------------------ | Branch (1014:9): [True: 17.2k, False: 2.52k] ------------------ 1015| 17.2k| { 1016| 17.2k| output[0] = '\"'; 1017| 17.2k| memcpy(output + 1, input, output_length); 1018| 17.2k| output[output_length + 1] = '\"'; 1019| 17.2k| output[output_length + 2] = '\0'; 1020| | 1021| 17.2k| return true; ------------------ | | 65| 17.2k|#define true ((cJSON_bool)1) ------------------ 1022| 17.2k| } 1023| | 1024| 2.52k| output[0] = '\"'; 1025| 2.52k| output_pointer = output + 1; 1026| | /* copy the string */ 1027| 9.22M| for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) ------------------ | Branch (1027:33): [True: 9.21M, False: 2.52k] ------------------ 1028| 9.21M| { 1029| 9.21M| if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) ------------------ | Branch (1029:13): [True: 2.34M, False: 6.87M] | Branch (1029:38): [True: 2.34M, False: 1.12k] | Branch (1029:66): [True: 2.34M, False: 1.47k] ------------------ 1030| 2.34M| { 1031| | /* normal character, copy */ 1032| 2.34M| *output_pointer = *input_pointer; 1033| 2.34M| } 1034| 6.87M| else 1035| 6.87M| { 1036| | /* character needs to be escaped */ 1037| 6.87M| *output_pointer++ = '\\'; 1038| 6.87M| switch (*input_pointer) 1039| 6.87M| { 1040| 1.47k| case '\\': ------------------ | Branch (1040:17): [True: 1.47k, False: 6.87M] ------------------ 1041| 1.47k| *output_pointer = '\\'; 1042| 1.47k| break; 1043| 1.12k| case '\"': ------------------ | Branch (1043:17): [True: 1.12k, False: 6.87M] ------------------ 1044| 1.12k| *output_pointer = '\"'; 1045| 1.12k| break; 1046| 13.1k| case '\b': ------------------ | Branch (1046:17): [True: 13.1k, False: 6.86M] ------------------ 1047| 13.1k| *output_pointer = 'b'; 1048| 13.1k| break; 1049| 26.3k| case '\f': ------------------ | Branch (1049:17): [True: 26.3k, False: 6.84M] ------------------ 1050| 26.3k| *output_pointer = 'f'; 1051| 26.3k| break; 1052| 59.6k| case '\n': ------------------ | Branch (1052:17): [True: 59.6k, False: 6.81M] ------------------ 1053| 59.6k| *output_pointer = 'n'; 1054| 59.6k| break; 1055| 5.08k| case '\r': ------------------ | Branch (1055:17): [True: 5.08k, False: 6.87M] ------------------ 1056| 5.08k| *output_pointer = 'r'; 1057| 5.08k| break; 1058| 93.7k| case '\t': ------------------ | Branch (1058:17): [True: 93.7k, False: 6.78M] ------------------ 1059| 93.7k| *output_pointer = 't'; 1060| 93.7k| break; 1061| 6.67M| default: ------------------ | Branch (1061:17): [True: 6.67M, False: 200k] ------------------ 1062| | /* escape and print as unicode codepoint */ 1063| 6.67M| sprintf((char*)output_pointer, "u%04x", *input_pointer); 1064| 6.67M| output_pointer += 4; 1065| 6.67M| break; 1066| 6.87M| } 1067| 6.87M| } 1068| 9.21M| } 1069| 2.52k| output[output_length + 1] = '\"'; 1070| 2.52k| output[output_length + 2] = '\0'; 1071| | 1072| 2.52k| return true; ------------------ | | 65| 2.52k|#define true ((cJSON_bool)1) ------------------ 1073| 2.52k|} cJSON.c:print_array: 1596| 235k|{ 1597| 235k| unsigned char *output_pointer = NULL; 1598| 235k| size_t length = 0; 1599| 235k| cJSON *current_element = item->child; 1600| | 1601| 235k| if (output_buffer == NULL) ------------------ | Branch (1601:9): [True: 0, False: 235k] ------------------ 1602| 0| { 1603| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1604| 0| } 1605| | 1606| 235k| if (output_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 235k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1606:9): [True: 0, False: 235k] ------------------ 1607| 0| { 1608| 0| return false; /* nesting is too deep */ ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1609| 0| } 1610| | 1611| | /* Compose the output array. */ 1612| | /* opening square bracket */ 1613| 235k| output_pointer = ensure(output_buffer, 1); 1614| 235k| if (output_pointer == NULL) ------------------ | Branch (1614:9): [True: 0, False: 235k] ------------------ 1615| 0| { 1616| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1617| 0| } 1618| | 1619| 235k| *output_pointer = '['; 1620| 235k| output_buffer->offset++; 1621| 235k| output_buffer->depth++; 1622| | 1623| 895k| while (current_element != NULL) ------------------ | Branch (1623:12): [True: 659k, False: 235k] ------------------ 1624| 659k| { 1625| 659k| if (!print_value(current_element, output_buffer)) ------------------ | Branch (1625:13): [True: 0, False: 659k] ------------------ 1626| 0| { 1627| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1628| 0| } 1629| 659k| update_offset(output_buffer); 1630| 659k| if (current_element->next) ------------------ | Branch (1630:13): [True: 426k, False: 232k] ------------------ 1631| 426k| { 1632| 426k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1632:32): [True: 416k, False: 9.92k] ------------------ 1633| 426k| output_pointer = ensure(output_buffer, length + 1); 1634| 426k| if (output_pointer == NULL) ------------------ | Branch (1634:17): [True: 0, False: 426k] ------------------ 1635| 0| { 1636| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1637| 0| } 1638| 426k| *output_pointer++ = ','; 1639| 426k| if(output_buffer->format) ------------------ | Branch (1639:16): [True: 416k, False: 9.92k] ------------------ 1640| 416k| { 1641| 416k| *output_pointer++ = ' '; 1642| 416k| } 1643| 426k| *output_pointer = '\0'; 1644| 426k| output_buffer->offset += length; 1645| 426k| } 1646| 659k| current_element = current_element->next; 1647| 659k| } 1648| | 1649| 235k| output_pointer = ensure(output_buffer, 2); 1650| 235k| if (output_pointer == NULL) ------------------ | Branch (1650:9): [True: 0, False: 235k] ------------------ 1651| 0| { 1652| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1653| 0| } 1654| 235k| *output_pointer++ = ']'; 1655| 235k| *output_pointer = '\0'; 1656| 235k| output_buffer->depth--; 1657| | 1658| 235k| return true; ------------------ | | 65| 235k|#define true ((cJSON_bool)1) ------------------ 1659| 235k|} cJSON.c:print_object: 1781| 404k|{ 1782| 404k| unsigned char *output_pointer = NULL; 1783| 404k| size_t length = 0; 1784| 404k| cJSON *current_item = item->child; 1785| | 1786| 404k| if (output_buffer == NULL) ------------------ | Branch (1786:9): [True: 0, False: 404k] ------------------ 1787| 0| { 1788| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1789| 0| } 1790| | 1791| 404k| if (output_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 404k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1791:9): [True: 0, False: 404k] ------------------ 1792| 0| { 1793| 0| return false; /* nesting is too deep */ ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1794| 0| } 1795| | 1796| | /* Compose the output: */ 1797| 404k| length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ ------------------ | Branch (1797:24): [True: 403k, False: 945] ------------------ 1798| 404k| output_pointer = ensure(output_buffer, length + 1); 1799| 404k| if (output_pointer == NULL) ------------------ | Branch (1799:9): [True: 0, False: 404k] ------------------ 1800| 0| { 1801| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1802| 0| } 1803| | 1804| 404k| *output_pointer++ = '{'; 1805| 404k| output_buffer->depth++; 1806| 404k| if (output_buffer->format) ------------------ | Branch (1806:9): [True: 403k, False: 945] ------------------ 1807| 403k| { 1808| 403k| *output_pointer++ = '\n'; 1809| 403k| } 1810| 404k| output_buffer->offset += length; 1811| | 1812| 422k| while (current_item) ------------------ | Branch (1812:12): [True: 17.2k, False: 404k] ------------------ 1813| 17.2k| { 1814| 17.2k| if (output_buffer->format) ------------------ | Branch (1814:13): [True: 12.3k, False: 4.90k] ------------------ 1815| 12.3k| { 1816| 12.3k| size_t i; 1817| 12.3k| output_pointer = ensure(output_buffer, output_buffer->depth); 1818| 12.3k| if (output_pointer == NULL) ------------------ | Branch (1818:17): [True: 0, False: 12.3k] ------------------ 1819| 0| { 1820| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1821| 0| } 1822| 4.33M| for (i = 0; i < output_buffer->depth; i++) ------------------ | Branch (1822:25): [True: 4.32M, False: 12.3k] ------------------ 1823| 4.32M| { 1824| 4.32M| *output_pointer++ = '\t'; 1825| 4.32M| } 1826| 12.3k| output_buffer->offset += output_buffer->depth; 1827| 12.3k| } 1828| | 1829| | /* print key */ 1830| 17.2k| if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) ------------------ | Branch (1830:13): [True: 0, False: 17.2k] ------------------ 1831| 0| { 1832| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1833| 0| } 1834| 17.2k| update_offset(output_buffer); 1835| | 1836| 17.2k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1836:28): [True: 12.3k, False: 4.90k] ------------------ 1837| 17.2k| output_pointer = ensure(output_buffer, length); 1838| 17.2k| if (output_pointer == NULL) ------------------ | Branch (1838:13): [True: 0, False: 17.2k] ------------------ 1839| 0| { 1840| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1841| 0| } 1842| 17.2k| *output_pointer++ = ':'; 1843| 17.2k| if (output_buffer->format) ------------------ | Branch (1843:13): [True: 12.3k, False: 4.90k] ------------------ 1844| 12.3k| { 1845| 12.3k| *output_pointer++ = '\t'; 1846| 12.3k| } 1847| 17.2k| output_buffer->offset += length; 1848| | 1849| | /* print value */ 1850| 17.2k| if (!print_value(current_item, output_buffer)) ------------------ | Branch (1850:13): [True: 0, False: 17.2k] ------------------ 1851| 0| { 1852| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1853| 0| } 1854| 17.2k| update_offset(output_buffer); 1855| | 1856| | /* print comma if not last */ 1857| 17.2k| length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); ------------------ | Branch (1857:28): [True: 12.3k, False: 4.90k] | Branch (1857:70): [True: 7.40k, False: 9.88k] ------------------ 1858| 17.2k| output_pointer = ensure(output_buffer, length + 1); 1859| 17.2k| if (output_pointer == NULL) ------------------ | Branch (1859:13): [True: 0, False: 17.2k] ------------------ 1860| 0| { 1861| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1862| 0| } 1863| 17.2k| if (current_item->next) ------------------ | Branch (1863:13): [True: 7.40k, False: 9.88k] ------------------ 1864| 7.40k| { 1865| 7.40k| *output_pointer++ = ','; 1866| 7.40k| } 1867| | 1868| 17.2k| if (output_buffer->format) ------------------ | Branch (1868:13): [True: 12.3k, False: 4.90k] ------------------ 1869| 12.3k| { 1870| 12.3k| *output_pointer++ = '\n'; 1871| 12.3k| } 1872| 17.2k| *output_pointer = '\0'; 1873| 17.2k| output_buffer->offset += length; 1874| | 1875| 17.2k| current_item = current_item->next; 1876| 17.2k| } 1877| | 1878| 404k| output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); ------------------ | Branch (1878:44): [True: 403k, False: 945] ------------------ 1879| 404k| if (output_pointer == NULL) ------------------ | Branch (1879:9): [True: 0, False: 404k] ------------------ 1880| 0| { 1881| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1882| 0| } 1883| 404k| if (output_buffer->format) ------------------ | Branch (1883:9): [True: 403k, False: 945] ------------------ 1884| 403k| { 1885| 403k| size_t i; 1886| 220M| for (i = 0; i < (output_buffer->depth - 1); i++) ------------------ | Branch (1886:21): [True: 219M, False: 403k] ------------------ 1887| 219M| { 1888| 219M| *output_pointer++ = '\t'; 1889| 219M| } 1890| 403k| } 1891| 404k| *output_pointer++ = '}'; 1892| 404k| *output_pointer = '\0'; 1893| 404k| output_buffer->depth--; 1894| | 1895| 404k| return true; ------------------ | | 65| 404k|#define true ((cJSON_bool)1) ------------------ 1896| 404k|} cJSON.c:skip_oneline_comment: 2876| 1.66k|{ 2877| 1.66k| *input += static_strlen("//"); ------------------ | | 184| 1.66k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2878| | 2879| 37.2k| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2879:12): [True: 37.2k, False: 20] ------------------ 2880| 37.2k| { 2881| 37.2k| if ((*input)[0] == '\n') { ------------------ | Branch (2881:13): [True: 1.64k, False: 35.6k] ------------------ 2882| 1.64k| *input += static_strlen("\n"); ------------------ | | 184| 1.64k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2883| 1.64k| return; 2884| 1.64k| } 2885| 37.2k| } 2886| 1.66k|} cJSON.c:skip_multiline_comment: 2889| 304|{ 2890| 304| *input += static_strlen("/*"); ------------------ | | 184| 304|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2891| | 2892| 3.57k| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2892:12): [True: 3.52k, False: 45] ------------------ 2893| 3.52k| { 2894| 3.52k| if (((*input)[0] == '*') && ((*input)[1] == '/')) ------------------ | Branch (2894:13): [True: 759, False: 2.77k] | Branch (2894:37): [True: 259, False: 500] ------------------ 2895| 259| { 2896| 259| *input += static_strlen("*/"); ------------------ | | 184| 259|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2897| 259| return; 2898| 259| } 2899| 3.52k| } 2900| 304|} cJSON.c:minify_string: 2902| 18.7k|static void minify_string(char **input, char **output) { 2903| 18.7k| (*output)[0] = (*input)[0]; 2904| 18.7k| *input += static_strlen("\""); ------------------ | | 184| 18.7k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2905| 18.7k| *output += static_strlen("\""); ------------------ | | 184| 18.7k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2906| | 2907| | 2908| 9.61M| for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { ------------------ | Branch (2908:12): [True: 9.61M, False: 35] ------------------ 2909| 9.61M| (*output)[0] = (*input)[0]; 2910| | 2911| 9.61M| if ((*input)[0] == '\"') { ------------------ | Branch (2911:13): [True: 18.7k, False: 9.59M] ------------------ 2912| 18.7k| (*output)[0] = '\"'; 2913| 18.7k| *input += static_strlen("\""); ------------------ | | 184| 18.7k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2914| 18.7k| *output += static_strlen("\""); ------------------ | | 184| 18.7k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2915| 18.7k| return; 2916| 9.59M| } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { ------------------ | Branch (2916:20): [True: 27.4k, False: 9.57M] | Branch (2916:45): [True: 1.19k, False: 26.2k] ------------------ 2917| 1.19k| (*output)[1] = (*input)[1]; 2918| 1.19k| *input += static_strlen("\""); ------------------ | | 184| 1.19k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2919| 1.19k| *output += static_strlen("\""); ------------------ | | 184| 1.19k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2920| 1.19k| } 2921| 9.61M| } 2922| 18.7k|} cJSON.c:compare_double: 590| 1.80k|{ 591| 1.80k| double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); ------------------ | Branch (591:21): [True: 567, False: 1.23k] ------------------ 592| | return (fabs(a - b) <= maxVal * DBL_EPSILON); 593| 1.80k|} LLVMFuzzerTestOneInput: 14| 2.08k|{ 15| 2.08k| cJSON *json; 16| 2.08k| size_t offset = 4; 17| 2.08k| unsigned char *copied; 18| 2.08k| char *printed_json = NULL; 19| 2.08k| int minify, require_termination, formatted, buffered; 20| | 21| | 22| 2.08k| if(size <= offset) return 0; ------------------ | Branch (22:8): [True: 4, False: 2.07k] ------------------ 23| 2.07k| if(data[size-1] != '\0') return 0; ------------------ | Branch (23:8): [True: 9, False: 2.07k] ------------------ 24| 2.07k| if(data[0] != '1' && data[0] != '0') return 0; ------------------ | Branch (24:8): [True: 452, False: 1.61k] | Branch (24:26): [True: 13, False: 439] ------------------ 25| 2.05k| if(data[1] != '1' && data[1] != '0') return 0; ------------------ | Branch (25:8): [True: 1.32k, False: 728] | Branch (25:26): [True: 13, False: 1.31k] ------------------ 26| 2.04k| if(data[2] != '1' && data[2] != '0') return 0; ------------------ | Branch (26:8): [True: 913, False: 1.13k] | Branch (26:26): [True: 16, False: 897] ------------------ 27| 2.02k| if(data[3] != '1' && data[3] != '0') return 0; ------------------ | Branch (27:8): [True: 981, False: 1.04k] | Branch (27:26): [True: 17, False: 964] ------------------ 28| | 29| 2.01k| minify = data[0] == '1' ? 1 : 0; ------------------ | Branch (29:27): [True: 1.58k, False: 428] ------------------ 30| 2.01k| require_termination = data[1] == '1' ? 1 : 0; ------------------ | Branch (30:27): [True: 713, False: 1.29k] ------------------ 31| 2.01k| formatted = data[2] == '1' ? 1 : 0; ------------------ | Branch (31:27): [True: 1.12k, False: 890] ------------------ 32| 2.01k| buffered = data[3] == '1' ? 1 : 0; ------------------ | Branch (32:27): [True: 1.04k, False: 964] ------------------ 33| | 34| 2.01k| json = cJSON_ParseWithOpts((const char*)data + offset, NULL, require_termination); 35| | 36| 2.01k| if(json == NULL) return 0; ------------------ | Branch (36:8): [True: 913, False: 1.09k] ------------------ 37| | 38| 1.09k| if(buffered) ------------------ | Branch (38:8): [True: 569, False: 529] ------------------ 39| 569| { 40| 569| printed_json = cJSON_PrintBuffered(json, 1, formatted); 41| 569| } 42| 529| else 43| 529| { 44| | /* unbuffered printing */ 45| 529| if(formatted) ------------------ | Branch (45:12): [True: 291, False: 238] ------------------ 46| 291| { 47| 291| printed_json = cJSON_Print(json); 48| 291| } 49| 238| else 50| 238| { 51| 238| printed_json = cJSON_PrintUnformatted(json); 52| 238| } 53| 529| } 54| | 55| 1.09k| if(printed_json != NULL) free(printed_json); ------------------ | Branch (55:8): [True: 1.09k, False: 0] ------------------ 56| | 57| 1.09k| if(minify) ------------------ | Branch (57:8): [True: 886, False: 212] ------------------ 58| 886| { 59| 886| copied = (unsigned char*)malloc(size); 60| 886| if(copied == NULL) return 0; ------------------ | Branch (60:12): [True: 0, False: 886] ------------------ 61| | 62| 886| memcpy(copied, data, size); 63| | 64| 886| cJSON_Minify((char*)copied + offset); 65| | 66| 886| free(copied); 67| 886| } 68| | 69| 1.09k| cJSON_Delete(json); 70| | 71| 1.09k| return 0; 72| 1.09k|}