cJSON_Delete: 254| 294k|{ 255| 294k| cJSON *next = NULL; 256| 1.03M| while (item != NULL) ------------------ | Branch (256:12): [True: 741k, False: 294k] ------------------ 257| 741k| { 258| 741k| next = item->next; 259| 741k| if (!(item->type & cJSON_IsReference) && (item->child != NULL)) ------------------ | | 99| 741k|#define cJSON_IsReference 256 ------------------ | Branch (259:13): [True: 741k, False: 0] | Branch (259:50): [True: 243k, False: 497k] ------------------ 260| 243k| { 261| 243k| cJSON_Delete(item->child); 262| 243k| } 263| 741k| if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) ------------------ | | 99| 741k|#define cJSON_IsReference 256 ------------------ | Branch (263:13): [True: 741k, False: 0] | Branch (263:50): [True: 5.16k, False: 735k] ------------------ 264| 5.16k| { 265| 5.16k| global_hooks.deallocate(item->valuestring); 266| 5.16k| item->valuestring = NULL; 267| 5.16k| } 268| 741k| if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) ------------------ | | 100| 741k|#define cJSON_StringIsConst 512 ------------------ | Branch (268:13): [True: 741k, False: 0] | Branch (268:52): [True: 16.5k, False: 724k] ------------------ 269| 16.5k| { 270| 16.5k| global_hooks.deallocate(item->string); 271| 16.5k| item->string = NULL; 272| 16.5k| } 273| 741k| global_hooks.deallocate(item); 274| 741k| item = next; 275| 741k| } 276| 294k|} cJSON_ParseWithOpts: 1100| 1.96k|{ 1101| 1.96k| size_t buffer_length; 1102| | 1103| 1.96k| if (NULL == value) ------------------ | Branch (1103:9): [True: 0, False: 1.96k] ------------------ 1104| 0| { 1105| 0| return NULL; 1106| 0| } 1107| | 1108| | /* Adding null character size due to require_null_terminated. */ 1109| 1.96k| buffer_length = strlen(value) + sizeof(""); 1110| | 1111| 1.96k| return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); 1112| 1.96k|} cJSON_ParseWithLengthOpts: 1116| 1.96k|{ 1117| 1.96k| parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; 1118| 1.96k| cJSON *item = NULL; 1119| | 1120| | /* reset error position */ 1121| 1.96k| global_error.json = NULL; 1122| 1.96k| global_error.position = 0; 1123| | 1124| 1.96k| if (value == NULL || 0 == buffer_length) ------------------ | Branch (1124:9): [True: 0, False: 1.96k] | Branch (1124:26): [True: 0, False: 1.96k] ------------------ 1125| 0| { 1126| 0| goto fail; 1127| 0| } 1128| | 1129| 1.96k| buffer.content = (const unsigned char*)value; 1130| 1.96k| buffer.length = buffer_length; 1131| 1.96k| buffer.offset = 0; 1132| 1.96k| buffer.hooks = global_hooks; 1133| | 1134| 1.96k| item = cJSON_New_Item(&global_hooks); 1135| 1.96k| if (item == NULL) /* memory fail */ ------------------ | Branch (1135:9): [True: 0, False: 1.96k] ------------------ 1136| 0| { 1137| 0| goto fail; 1138| 0| } 1139| | 1140| 1.96k| if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) ------------------ | Branch (1140:9): [True: 901, False: 1.06k] ------------------ 1141| 901| { 1142| | /* parse failure. ep is set. */ 1143| 901| goto fail; 1144| 901| } 1145| | 1146| | /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ 1147| 1.06k| if (require_null_terminated) ------------------ | Branch (1147:9): [True: 309, False: 753] ------------------ 1148| 309| { 1149| 309| buffer_skip_whitespace(&buffer); 1150| 309| if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') ------------------ | | 304| 309|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1150:13): [True: 0, False: 309] | Branch (1150:49): [True: 35, False: 274] ------------------ 1151| 35| { 1152| 35| goto fail; 1153| 35| } 1154| 309| } 1155| 1.02k| if (return_parse_end) ------------------ | Branch (1155:9): [True: 0, False: 1.02k] ------------------ 1156| 0| { 1157| 0| *return_parse_end = (const char*)buffer_at_offset(&buffer); ------------------ | | 304| 0|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 1158| 0| } 1159| | 1160| 1.02k| return item; 1161| | 1162| 936|fail: 1163| 936| if (item != NULL) ------------------ | Branch (1163:9): [True: 936, False: 0] ------------------ 1164| 936| { 1165| 936| cJSON_Delete(item); 1166| 936| } 1167| | 1168| 936| if (value != NULL) ------------------ | Branch (1168:9): [True: 936, False: 0] ------------------ 1169| 936| { 1170| 936| error local_error; 1171| 936| local_error.json = (const unsigned char*)value; 1172| 936| local_error.position = 0; 1173| | 1174| 936| if (buffer.offset < buffer.length) ------------------ | Branch (1174:13): [True: 817, False: 119] ------------------ 1175| 817| { 1176| 817| local_error.position = buffer.offset; 1177| 817| } 1178| 119| else if (buffer.length > 0) ------------------ | Branch (1178:18): [True: 119, False: 0] ------------------ 1179| 119| { 1180| 119| local_error.position = buffer.length - 1; 1181| 119| } 1182| | 1183| 936| if (return_parse_end != NULL) ------------------ | Branch (1183:13): [True: 0, False: 936] ------------------ 1184| 0| { 1185| 0| *return_parse_end = (const char*)local_error.json + local_error.position; 1186| 0| } 1187| | 1188| 936| global_error = local_error; 1189| 936| } 1190| | 1191| 936| return NULL; 1192| 1.06k|} cJSON_Print: 1276| 273|{ 1277| 273| return (char*)print(item, true, &global_hooks); ------------------ | | 65| 273|#define true ((cJSON_bool)1) ------------------ 1278| 273|} cJSON_PrintUnformatted: 1281| 222|{ 1282| 222| return (char*)print(item, false, &global_hooks); ------------------ | | 70| 222|#define false ((cJSON_bool)0) ------------------ 1283| 222|} cJSON_PrintBuffered: 1286| 532|{ 1287| 532| printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; 1288| | 1289| 532| if (prebuffer < 0) ------------------ | Branch (1289:9): [True: 0, False: 532] ------------------ 1290| 0| { 1291| 0| return NULL; 1292| 0| } 1293| | 1294| 532| p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); 1295| 532| if (!p.buffer) ------------------ | Branch (1295:9): [True: 0, False: 532] ------------------ 1296| 0| { 1297| 0| return NULL; 1298| 0| } 1299| | 1300| 532| p.length = (size_t)prebuffer; 1301| 532| p.offset = 0; 1302| 532| p.noalloc = false; ------------------ | | 70| 532|#define false ((cJSON_bool)0) ------------------ 1303| 532| p.format = fmt; 1304| 532| p.hooks = global_hooks; 1305| | 1306| 532| if (!print_value(item, &p)) ------------------ | Branch (1306:9): [True: 0, False: 532] ------------------ 1307| 0| { 1308| 0| global_hooks.deallocate(p.buffer); 1309| 0| p.buffer = NULL; 1310| 0| return NULL; 1311| 0| } 1312| | 1313| 532| return (char*)p.buffer; 1314| 532|} cJSON_Minify: 2883| 838|{ 2884| 838| char *into = json; 2885| | 2886| 838| if (json == NULL) ------------------ | Branch (2886:9): [True: 0, False: 838] ------------------ 2887| 0| { 2888| 0| return; 2889| 0| } 2890| | 2891| 1.83M| while (json[0] != '\0') ------------------ | Branch (2891:12): [True: 1.83M, False: 838] ------------------ 2892| 1.83M| { 2893| 1.83M| switch (json[0]) 2894| 1.83M| { 2895| 257| case ' ': ------------------ | Branch (2895:13): [True: 257, False: 1.83M] ------------------ 2896| 824| case '\t': ------------------ | Branch (2896:13): [True: 567, False: 1.83M] ------------------ 2897| 4.78k| case '\r': ------------------ | Branch (2897:13): [True: 3.96k, False: 1.83M] ------------------ 2898| 6.64k| case '\n': ------------------ | Branch (2898:13): [True: 1.86k, False: 1.83M] ------------------ 2899| 6.64k| json++; 2900| 6.64k| break; 2901| | 2902| 2.43k| case '/': ------------------ | Branch (2902:13): [True: 2.43k, False: 1.83M] ------------------ 2903| 2.43k| if (json[1] == '/') ------------------ | Branch (2903:21): [True: 1.07k, False: 1.36k] ------------------ 2904| 1.07k| { 2905| 1.07k| skip_oneline_comment(&json); 2906| 1.07k| } 2907| 1.36k| else if (json[1] == '*') ------------------ | Branch (2907:26): [True: 376, False: 989] ------------------ 2908| 376| { 2909| 376| skip_multiline_comment(&json); 2910| 989| } else { 2911| 989| json++; 2912| 989| } 2913| 2.43k| break; 2914| | 2915| 11.1k| case '\"': ------------------ | Branch (2915:13): [True: 11.1k, False: 1.82M] ------------------ 2916| 11.1k| minify_string(&json, (char**)&into); 2917| 11.1k| break; 2918| | 2919| 1.81M| default: ------------------ | Branch (2919:13): [True: 1.81M, False: 20.2k] ------------------ 2920| 1.81M| into[0] = json[0]; 2921| 1.81M| json++; 2922| 1.81M| into++; 2923| 1.83M| } 2924| 1.83M| } 2925| | 2926| | /* and null-terminate. */ 2927| 838| *into = '\0'; 2928| 838|} cJSON.c:cJSON_New_Item: 242| 741k|{ 243| 741k| cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); 244| 741k| if (node) ------------------ | Branch (244:9): [True: 741k, False: 0] ------------------ 245| 741k| { 246| 741k| memset(node, '\0', sizeof(cJSON)); 247| 741k| } 248| | 249| 741k| return node; 250| 741k|} cJSON.c:buffer_skip_whitespace: 1059| 2.17M|{ 1060| 2.17M| if ((buffer == NULL) || (buffer->content == NULL)) ------------------ | Branch (1060:9): [True: 0, False: 2.17M] | Branch (1060:29): [True: 0, False: 2.17M] ------------------ 1061| 0| { 1062| 0| return NULL; 1063| 0| } 1064| | 1065| 2.17M| if (cannot_access_at_index(buffer, 0)) ------------------ | | 302| 2.17M|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 2.17M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 2.17M, False: 0] | | | | | Branch (301:65): [True: 2.17M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1066| 0| { 1067| 0| return buffer; 1068| 0| } 1069| | 1070| 3.48M| while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 301| 6.96M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 3.48M, False: 0] | | | Branch (301:65): [True: 3.48M, False: 880] | | ------------------ ------------------ while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 304| 3.48M|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1070:46): [True: 1.30M, False: 2.17M] ------------------ 1071| 1.30M| { 1072| 1.30M| buffer->offset++; 1073| 1.30M| } 1074| | 1075| 2.17M| if (buffer->offset == buffer->length) ------------------ | Branch (1075:9): [True: 880, False: 2.17M] ------------------ 1076| 880| { 1077| 880| buffer->offset--; 1078| 880| } 1079| | 1080| 2.17M| return buffer; 1081| 2.17M|} cJSON.c:skip_utf8_bom: 1085| 1.96k|{ 1086| 1.96k| if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) ------------------ | Branch (1086:9): [True: 0, False: 1.96k] | Branch (1086:29): [True: 0, False: 1.96k] | Branch (1086:58): [True: 0, False: 1.96k] ------------------ 1087| 0| { 1088| 0| return NULL; 1089| 0| } 1090| | 1091| 1.96k| if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 301| 3.92k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 1.96k, False: 0] | | | Branch (301:65): [True: 1.66k, False: 302] | | ------------------ ------------------ if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 304| 1.66k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1091:43): [True: 98, False: 1.56k] ------------------ 1092| 98| { 1093| 98| buffer->offset += 3; 1094| 98| } 1095| | 1096| 1.96k| return buffer; 1097| 1.96k|} cJSON.c:print: 1208| 495|{ 1209| 495| static const size_t default_buffer_size = 256; 1210| 495| printbuffer buffer[1]; 1211| 495| unsigned char *printed = NULL; 1212| | 1213| 495| memset(buffer, 0, sizeof(buffer)); 1214| | 1215| | /* create buffer */ 1216| 495| buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); 1217| 495| buffer->length = default_buffer_size; 1218| 495| buffer->format = format; 1219| 495| buffer->hooks = *hooks; 1220| 495| if (buffer->buffer == NULL) ------------------ | Branch (1220:9): [True: 0, False: 495] ------------------ 1221| 0| { 1222| 0| goto fail; 1223| 0| } 1224| | 1225| | /* print the value */ 1226| 495| if (!print_value(item, buffer)) ------------------ | Branch (1226:9): [True: 0, False: 495] ------------------ 1227| 0| { 1228| 0| goto fail; 1229| 0| } 1230| 495| update_offset(buffer); 1231| | 1232| | /* check if reallocate is available */ 1233| 495| if (hooks->reallocate != NULL) ------------------ | Branch (1233:9): [True: 495, False: 0] ------------------ 1234| 495| { 1235| 495| printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); 1236| 495| if (printed == NULL) { ------------------ | Branch (1236:13): [True: 0, False: 495] ------------------ 1237| 0| goto fail; 1238| 0| } 1239| 495| buffer->buffer = NULL; 1240| 495| } 1241| 0| else /* otherwise copy the JSON over to a new buffer */ 1242| 0| { 1243| 0| printed = (unsigned char*) hooks->allocate(buffer->offset + 1); 1244| 0| if (printed == NULL) ------------------ | Branch (1244:13): [True: 0, False: 0] ------------------ 1245| 0| { 1246| 0| goto fail; 1247| 0| } 1248| 0| memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); ------------------ | | 1205| 0|#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (1205:26): [True: 0, False: 0] | | ------------------ ------------------ 1249| 0| printed[buffer->offset] = '\0'; /* just to be sure */ 1250| | 1251| | /* free the buffer */ 1252| 0| hooks->deallocate(buffer->buffer); 1253| 0| buffer->buffer = NULL; 1254| 0| } 1255| | 1256| 495| return printed; 1257| | 1258| 0|fail: 1259| 0| if (buffer->buffer != NULL) ------------------ | Branch (1259:9): [True: 0, False: 0] ------------------ 1260| 0| { 1261| 0| hooks->deallocate(buffer->buffer); 1262| 0| buffer->buffer = NULL; 1263| 0| } 1264| | 1265| 0| if (printed != NULL) ------------------ | Branch (1265:9): [True: 0, False: 0] ------------------ 1266| 0| { 1267| 0| hooks->deallocate(printed); 1268| 0| printed = NULL; 1269| 0| } 1270| | 1271| 0| return NULL; 1272| 495|} cJSON.c:update_offset: 545| 670k|{ 546| 670k| const unsigned char *buffer_pointer = NULL; 547| 670k| if ((buffer == NULL) || (buffer->buffer == NULL)) ------------------ | Branch (547:9): [True: 0, False: 670k] | Branch (547:29): [True: 0, False: 670k] ------------------ 548| 0| { 549| 0| return; 550| 0| } 551| 670k| buffer_pointer = buffer->buffer + buffer->offset; 552| | 553| 670k| buffer->offset += strlen((const char*)buffer_pointer); 554| 670k|} cJSON.c:parse_value: 1337| 740k|{ 1338| 740k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (1338:9): [True: 0, False: 740k] | Branch (1338:35): [True: 0, False: 740k] ------------------ 1339| 0| { 1340| 0| return false; /* no input */ ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1341| 0| } 1342| | 1343| | /* parse the different types of values */ 1344| | /* null */ 1345| 740k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 299| 1.48M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (299:33): [True: 740k, False: 0] | | | Branch (299:53): [True: 739k, False: 869] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 304| 739k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1345:38): [True: 525, False: 739k] ------------------ 1346| 525| { 1347| 525| item->type = cJSON_NULL; ------------------ | | 92| 525|#define cJSON_NULL (1 << 2) ------------------ 1348| 525| input_buffer->offset += 4; 1349| 525| return true; ------------------ | | 65| 525|#define true ((cJSON_bool)1) ------------------ 1350| 525| } 1351| | /* false */ 1352| 740k| if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 299| 1.48M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (299:33): [True: 740k, False: 0] | | | Branch (299:53): [True: 739k, False: 1.24k] | | ------------------ ------------------ if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 304| 739k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1352:38): [True: 465, False: 738k] ------------------ 1353| 465| { 1354| 465| item->type = cJSON_False; ------------------ | | 90| 465|#define cJSON_False (1 << 0) ------------------ 1355| 465| input_buffer->offset += 5; 1356| 465| return true; ------------------ | | 65| 465|#define true ((cJSON_bool)1) ------------------ 1357| 465| } 1358| | /* true */ 1359| 739k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 299| 1.47M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (299:33): [True: 739k, False: 0] | | | Branch (299:53): [True: 738k, False: 869] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 304| 738k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1359:38): [True: 452, False: 738k] ------------------ 1360| 452| { 1361| 452| item->type = cJSON_True; ------------------ | | 91| 452|#define cJSON_True (1 << 1) ------------------ 1362| 452| item->valueint = 1; 1363| 452| input_buffer->offset += 4; 1364| 452| return true; ------------------ | | 65| 452|#define true ((cJSON_bool)1) ------------------ 1365| 452| } 1366| | /* string */ 1367| 739k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 301| 1.47M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 739k, False: 0] | | | Branch (301:65): [True: 739k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 304| 739k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1367:49): [True: 5.36k, False: 734k] ------------------ 1368| 5.36k| { 1369| 5.36k| return parse_string(item, input_buffer); 1370| 5.36k| } 1371| | /* number */ 1372| 734k| 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.46M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 734k, False: 0] | | | Branch (301:65): [True: 734k, 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| 734k|#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| 732k|#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| 732k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1372:50): [True: 1.28k, False: 732k] | Branch (1372:97): [True: 732k, False: 163] | Branch (1372:143): [True: 22.1k, False: 710k] ------------------ 1373| 23.4k| { 1374| 23.4k| return parse_number(item, input_buffer); 1375| 23.4k| } 1376| | /* array */ 1377| 710k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 301| 1.42M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 710k, False: 0] | | | Branch (301:65): [True: 710k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 304| 710k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1377:49): [True: 283k, False: 426k] ------------------ 1378| 283k| { 1379| 283k| return parse_array(item, input_buffer); 1380| 283k| } 1381| | /* object */ 1382| 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 (1382:49): [True: 426k, False: 330] ------------------ 1383| 426k| { 1384| 426k| return parse_object(item, input_buffer); 1385| 426k| } 1386| | 1387| 330| return false; ------------------ | | 70| 330|#define false ((cJSON_bool)0) ------------------ 1388| 426k|} cJSON.c:parse_string: 793| 22.0k|{ 794| 22.0k| const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; ------------------ | | 304| 22.0k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 795| 22.0k| const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; ------------------ | | 304| 22.0k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 796| 22.0k| unsigned char *output_pointer = NULL; 797| 22.0k| unsigned char *output = NULL; 798| | 799| | /* not a string */ 800| 22.0k| if (buffer_at_offset(input_buffer)[0] != '\"') ------------------ | | 304| 22.0k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (800:9): [True: 142, False: 21.9k] ------------------ 801| 142| { 802| 142| goto fail; 803| 142| } 804| | 805| 21.9k| { 806| | /* calculate approximate size of the output (overestimate) */ 807| 21.9k| size_t allocation_length = 0; 808| 21.9k| size_t skipped_bytes = 0; 809| 25.9M| while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) ------------------ | Branch (809:16): [True: 25.9M, False: 81] | Branch (809:88): [True: 25.9M, False: 21.8k] ------------------ 810| 25.9M| { 811| | /* is escape sequence */ 812| 25.9M| if (input_end[0] == '\\') ------------------ | Branch (812:17): [True: 133k, False: 25.8M] ------------------ 813| 133k| { 814| 133k| if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) ------------------ | Branch (814:21): [True: 0, False: 133k] ------------------ 815| 0| { 816| | /* prevent buffer overflow when last input character is a backslash */ 817| 0| goto fail; 818| 0| } 819| 133k| skipped_bytes++; 820| 133k| input_end++; 821| 133k| } 822| 25.9M| input_end++; 823| 25.9M| } 824| 21.9k| if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) ------------------ | Branch (824:13): [True: 81, False: 21.8k] | Branch (824:86): [True: 0, False: 21.8k] ------------------ 825| 81| { 826| 81| goto fail; /* string ended unexpectedly */ 827| 81| } 828| | 829| | /* This is at most how much we need for the output */ 830| 21.8k| allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; ------------------ | | 304| 21.8k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 831| 21.8k| output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); 832| 21.8k| if (output == NULL) ------------------ | Branch (832:13): [True: 0, False: 21.8k] ------------------ 833| 0| { 834| 0| goto fail; /* allocation failure */ 835| 0| } 836| 21.8k| } 837| | 838| 21.8k| output_pointer = output; 839| | /* loop through the string literal */ 840| 24.2M| while (input_pointer < input_end) ------------------ | Branch (840:12): [True: 24.2M, False: 21.7k] ------------------ 841| 24.2M| { 842| 24.2M| if (*input_pointer != '\\') ------------------ | Branch (842:13): [True: 24.1M, False: 118k] ------------------ 843| 24.1M| { 844| 24.1M| *output_pointer++ = *input_pointer++; 845| 24.1M| } 846| | /* escape sequence */ 847| 118k| else 848| 118k| { 849| 118k| unsigned char sequence_length = 2; 850| 118k| if ((input_end - input_pointer) < 1) ------------------ | Branch (850:17): [True: 0, False: 118k] ------------------ 851| 0| { 852| 0| goto fail; 853| 0| } 854| | 855| 118k| switch (input_pointer[1]) 856| 118k| { 857| 10.7k| case 'b': ------------------ | Branch (857:17): [True: 10.7k, False: 107k] ------------------ 858| 10.7k| *output_pointer++ = '\b'; 859| 10.7k| break; 860| 2.73k| case 'f': ------------------ | Branch (860:17): [True: 2.73k, False: 115k] ------------------ 861| 2.73k| *output_pointer++ = '\f'; 862| 2.73k| break; 863| 2.85k| case 'n': ------------------ | Branch (863:17): [True: 2.85k, False: 115k] ------------------ 864| 2.85k| *output_pointer++ = '\n'; 865| 2.85k| break; 866| 3.98k| case 'r': ------------------ | Branch (866:17): [True: 3.98k, False: 114k] ------------------ 867| 3.98k| *output_pointer++ = '\r'; 868| 3.98k| break; 869| 10.1k| case 't': ------------------ | Branch (869:17): [True: 10.1k, False: 107k] ------------------ 870| 10.1k| *output_pointer++ = '\t'; 871| 10.1k| break; 872| 11.2k| case '\"': ------------------ | Branch (872:17): [True: 11.2k, False: 106k] ------------------ 873| 22.3k| case '\\': ------------------ | Branch (873:17): [True: 11.1k, False: 106k] ------------------ 874| 34.1k| case '/': ------------------ | Branch (874:17): [True: 11.7k, False: 106k] ------------------ 875| 34.1k| *output_pointer++ = input_pointer[1]; 876| 34.1k| break; 877| | 878| | /* UTF-16 literal */ 879| 53.4k| case 'u': ------------------ | Branch (879:17): [True: 53.4k, False: 64.6k] ------------------ 880| 53.4k| sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); 881| 53.4k| if (sequence_length == 0) ------------------ | Branch (881:25): [True: 124, False: 53.2k] ------------------ 882| 124| { 883| | /* failed to convert UTF16-literal to UTF-8 */ 884| 124| goto fail; 885| 124| } 886| 53.2k| break; 887| | 888| 53.2k| default: ------------------ | Branch (888:17): [True: 10, False: 118k] ------------------ 889| 10| goto fail; 890| 118k| } 891| 117k| input_pointer += sequence_length; 892| 117k| } 893| 24.2M| } 894| | 895| | /* zero terminate the output */ 896| 21.7k| *output_pointer = '\0'; 897| | 898| 21.7k| item->type = cJSON_String; ------------------ | | 94| 21.7k|#define cJSON_String (1 << 4) ------------------ 899| 21.7k| item->valuestring = (char*)output; 900| | 901| 21.7k| input_buffer->offset = (size_t) (input_end - input_buffer->content); 902| 21.7k| input_buffer->offset++; 903| | 904| 21.7k| return true; ------------------ | | 65| 21.7k|#define true ((cJSON_bool)1) ------------------ 905| | 906| 357|fail: 907| 357| if (output != NULL) ------------------ | Branch (907:9): [True: 134, False: 223] ------------------ 908| 134| { 909| 134| input_buffer->hooks.deallocate(output); 910| 134| output = NULL; 911| 134| } 912| | 913| 357| if (input_pointer != NULL) ------------------ | Branch (913:9): [True: 357, False: 0] ------------------ 914| 357| { 915| 357| input_buffer->offset = (size_t)(input_pointer - input_buffer->content); 916| 357| } 917| | 918| 357| return false; ------------------ | | 70| 357|#define false ((cJSON_bool)0) ------------------ 919| 21.8k|} cJSON.c:utf16_literal_to_utf8: 672| 53.4k|{ 673| 53.4k| long unsigned int codepoint = 0; 674| 53.4k| unsigned int first_code = 0; 675| 53.4k| const unsigned char *first_sequence = input_pointer; 676| 53.4k| unsigned char utf8_length = 0; 677| 53.4k| unsigned char utf8_position = 0; 678| 53.4k| unsigned char sequence_length = 0; 679| 53.4k| unsigned char first_byte_mark = 0; 680| | 681| 53.4k| if ((input_end - first_sequence) < 6) ------------------ | Branch (681:9): [True: 3, False: 53.3k] ------------------ 682| 3| { 683| | /* input ends unexpectedly */ 684| 3| goto fail; 685| 3| } 686| | 687| | /* get the first utf16 sequence */ 688| 53.3k| first_code = parse_hex4(first_sequence + 2); 689| | 690| | /* check that the code is valid */ 691| 53.3k| if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) ------------------ | Branch (691:10): [True: 3.31k, False: 50.0k] | Branch (691:36): [True: 12, False: 3.30k] ------------------ 692| 12| { 693| 12| goto fail; 694| 12| } 695| | 696| | /* UTF16 surrogate pair */ 697| 53.3k| if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) ------------------ | Branch (697:9): [True: 7.82k, False: 45.5k] | Branch (697:35): [True: 4.52k, False: 3.30k] ------------------ 698| 4.52k| { 699| 4.52k| const unsigned char *second_sequence = first_sequence + 6; 700| 4.52k| unsigned int second_code = 0; 701| 4.52k| sequence_length = 12; /* \uXXXX\uXXXX */ 702| | 703| 4.52k| if ((input_end - second_sequence) < 6) ------------------ | Branch (703:13): [True: 18, False: 4.50k] ------------------ 704| 18| { 705| | /* input ends unexpectedly */ 706| 18| goto fail; 707| 18| } 708| | 709| 4.50k| if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) ------------------ | Branch (709:13): [True: 15, False: 4.49k] | Branch (709:45): [True: 15, False: 4.47k] ------------------ 710| 30| { 711| | /* missing second half of the surrogate pair */ 712| 30| goto fail; 713| 30| } 714| | 715| | /* get the second utf16 sequence */ 716| 4.47k| second_code = parse_hex4(second_sequence + 2); 717| | /* check that the code is valid */ 718| 4.47k| if ((second_code < 0xDC00) || (second_code > 0xDFFF)) ------------------ | Branch (718:13): [True: 56, False: 4.42k] | Branch (718:39): [True: 5, False: 4.41k] ------------------ 719| 61| { 720| | /* invalid second half of the surrogate pair */ 721| 61| goto fail; 722| 61| } 723| | 724| | 725| | /* calculate the unicode codepoint from the surrogate pair */ 726| 4.41k| codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); 727| 4.41k| } 728| 48.8k| else 729| 48.8k| { 730| 48.8k| sequence_length = 6; /* \uXXXX */ 731| 48.8k| codepoint = first_code; 732| 48.8k| } 733| | 734| | /* encode as UTF-8 735| | * takes at maximum 4 bytes to encode: 736| | * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 737| 53.2k| if (codepoint < 0x80) ------------------ | Branch (737:9): [True: 26.9k, False: 26.3k] ------------------ 738| 26.9k| { 739| | /* normal ascii, encoding 0xxxxxxx */ 740| 26.9k| utf8_length = 1; 741| 26.9k| } 742| 26.3k| else if (codepoint < 0x800) ------------------ | Branch (742:14): [True: 8.35k, False: 17.9k] ------------------ 743| 8.35k| { 744| | /* two bytes, encoding 110xxxxx 10xxxxxx */ 745| 8.35k| utf8_length = 2; 746| 8.35k| first_byte_mark = 0xC0; /* 11000000 */ 747| 8.35k| } 748| 17.9k| else if (codepoint < 0x10000) ------------------ | Branch (748:14): [True: 13.5k, False: 4.41k] ------------------ 749| 13.5k| { 750| | /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ 751| 13.5k| utf8_length = 3; 752| 13.5k| first_byte_mark = 0xE0; /* 11100000 */ 753| 13.5k| } 754| 4.41k| else if (codepoint <= 0x10FFFF) ------------------ | Branch (754:14): [True: 4.41k, False: 0] ------------------ 755| 4.41k| { 756| | /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ 757| 4.41k| utf8_length = 4; 758| 4.41k| first_byte_mark = 0xF0; /* 11110000 */ 759| 4.41k| } 760| 0| else 761| 0| { 762| | /* invalid unicode codepoint */ 763| 0| goto fail; 764| 0| } 765| | 766| | /* encode as utf8 */ 767| 101k| for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) ------------------ | Branch (767:60): [True: 48.6k, False: 53.2k] ------------------ 768| 48.6k| { 769| | /* 10xxxxxx */ 770| 48.6k| (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); 771| 48.6k| codepoint >>= 6; 772| 48.6k| } 773| | /* encode first byte */ 774| 53.2k| if (utf8_length > 1) ------------------ | Branch (774:9): [True: 26.3k, False: 26.9k] ------------------ 775| 26.3k| { 776| 26.3k| (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); 777| 26.3k| } 778| 26.9k| else 779| 26.9k| { 780| 26.9k| (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); 781| 26.9k| } 782| | 783| 53.2k| *output_pointer += utf8_length; 784| | 785| 53.2k| return sequence_length; 786| | 787| 124|fail: 788| 124| return 0; 789| 53.2k|} cJSON.c:parse_hex4: 635| 57.8k|{ 636| 57.8k| unsigned int h = 0; 637| 57.8k| size_t i = 0; 638| | 639| 222k| for (i = 0; i < 4; i++) ------------------ | Branch (639:17): [True: 188k, False: 34.0k] ------------------ 640| 188k| { 641| | /* parse digit */ 642| 188k| if ((input[i] >= '0') && (input[i] <= '9')) ------------------ | Branch (642:13): [True: 183k, False: 5.30k] | Branch (642:34): [True: 74.6k, False: 108k] ------------------ 643| 74.6k| { 644| 74.6k| h += (unsigned int) input[i] - '0'; 645| 74.6k| } 646| 113k| else if ((input[i] >= 'A') && (input[i] <= 'F')) ------------------ | Branch (646:18): [True: 102k, False: 11.5k] | Branch (646:39): [True: 19.3k, False: 82.9k] ------------------ 647| 19.3k| { 648| 19.3k| h += (unsigned int) 10 + input[i] - 'A'; 649| 19.3k| } 650| 94.5k| else if ((input[i] >= 'a') && (input[i] <= 'f')) ------------------ | Branch (650:18): [True: 82.6k, False: 11.9k] | Branch (650:39): [True: 70.7k, False: 11.8k] ------------------ 651| 70.7k| { 652| 70.7k| h += (unsigned int) 10 + input[i] - 'a'; 653| 70.7k| } 654| 23.7k| else /* invalid */ 655| 23.7k| { 656| 23.7k| return 0; 657| 23.7k| } 658| | 659| 164k| if (i < 3) ------------------ | Branch (659:13): [True: 130k, False: 34.0k] ------------------ 660| 130k| { 661| | /* shift left to make place for the next nibble */ 662| 130k| h = h << 4; 663| 130k| } 664| 164k| } 665| | 666| 34.0k| return h; 667| 57.8k|} cJSON.c:parse_number: 308| 23.4k|{ 309| 23.4k| double number = 0; 310| 23.4k| unsigned char *after_end = NULL; 311| 23.4k| unsigned char number_c_string[64]; 312| 23.4k| unsigned char decimal_point = get_decimal_point(); 313| 23.4k| size_t i = 0; 314| | 315| 23.4k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (315:9): [True: 0, False: 23.4k] | Branch (315:35): [True: 0, False: 23.4k] ------------------ 316| 0| { 317| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 318| 0| } 319| | 320| | /* copy the number into a temporary buffer and replace '.' with the decimal point 321| | * of the current locale (for strtod) 322| | * This also takes care of '\0' not necessarily being available for marking the end of the input */ 323| 125k| for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) ------------------ | | 301| 124k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 124k, False: 0] | | | Branch (301:65): [True: 124k, False: 0] | | ------------------ ------------------ | Branch (323:17): [True: 124k, False: 199] ------------------ 324| 124k| { 325| 124k| switch (buffer_at_offset(input_buffer)[i]) ------------------ | | 304| 124k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 326| 124k| { 327| 7.04k| case '0': ------------------ | Branch (327:13): [True: 7.04k, False: 117k] ------------------ 328| 16.3k| case '1': ------------------ | Branch (328:13): [True: 9.28k, False: 115k] ------------------ 329| 21.4k| case '2': ------------------ | Branch (329:13): [True: 5.11k, False: 119k] ------------------ 330| 23.9k| case '3': ------------------ | Branch (330:13): [True: 2.47k, False: 122k] ------------------ 331| 32.0k| case '4': ------------------ | Branch (331:13): [True: 8.12k, False: 116k] ------------------ 332| 37.4k| case '5': ------------------ | Branch (332:13): [True: 5.43k, False: 119k] ------------------ 333| 42.5k| case '6': ------------------ | Branch (333:13): [True: 5.03k, False: 119k] ------------------ 334| 44.7k| case '7': ------------------ | Branch (334:13): [True: 2.27k, False: 122k] ------------------ 335| 47.1k| case '8': ------------------ | Branch (335:13): [True: 2.38k, False: 122k] ------------------ 336| 96.8k| case '9': ------------------ | Branch (336:13): [True: 49.6k, False: 75.1k] ------------------ 337| 97.1k| case '+': ------------------ | Branch (337:13): [True: 288, False: 124k] ------------------ 338| 98.6k| case '-': ------------------ | Branch (338:13): [True: 1.49k, False: 123k] ------------------ 339| 100k| case 'e': ------------------ | Branch (339:13): [True: 1.43k, False: 123k] ------------------ 340| 100k| case 'E': ------------------ | Branch (340:13): [True: 676, False: 124k] ------------------ 341| 100k| number_c_string[i] = buffer_at_offset(input_buffer)[i]; ------------------ | | 304| 100k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 342| 100k| break; 343| | 344| 852| case '.': ------------------ | Branch (344:13): [True: 852, False: 123k] ------------------ 345| 852| number_c_string[i] = decimal_point; 346| 852| break; 347| | 348| 23.2k| default: ------------------ | Branch (348:13): [True: 23.2k, False: 101k] ------------------ 349| 23.2k| goto loop_end; 350| 124k| } 351| 124k| } 352| 23.4k|loop_end: 353| 23.4k| number_c_string[i] = '\0'; 354| | 355| 23.4k| number = strtod((const char*)number_c_string, (char**)&after_end); 356| 23.4k| if (number_c_string == after_end) ------------------ | Branch (356:9): [True: 17, False: 23.3k] ------------------ 357| 17| { 358| 17| return false; /* parse_error */ ------------------ | | 70| 17|#define false ((cJSON_bool)0) ------------------ 359| 17| } 360| | 361| 23.3k| item->valuedouble = number; 362| | 363| | /* use saturation in case of overflow */ 364| 23.3k| if (number >= INT_MAX) ------------------ | Branch (364:9): [True: 4.35k, False: 19.0k] ------------------ 365| 4.35k| { 366| 4.35k| item->valueint = INT_MAX; 367| 4.35k| } 368| 19.0k| else if (number <= (double)INT_MIN) ------------------ | Branch (368:14): [True: 532, False: 18.5k] ------------------ 369| 532| { 370| 532| item->valueint = INT_MIN; 371| 532| } 372| 18.5k| else 373| 18.5k| { 374| 18.5k| item->valueint = (int)number; 375| 18.5k| } 376| | 377| 23.3k| item->type = cJSON_Number; ------------------ | | 93| 23.3k|#define cJSON_Number (1 << 3) ------------------ 378| | 379| 23.3k| input_buffer->offset += (size_t)(after_end - number_c_string); 380| 23.3k| return true; ------------------ | | 65| 23.3k|#define true ((cJSON_bool)1) ------------------ 381| 23.4k|} cJSON.c:get_decimal_point: 280| 30.5k|{ 281| 30.5k|#ifdef ENABLE_LOCALES 282| 30.5k| struct lconv *lconv = localeconv(); 283| 30.5k| return (unsigned char) lconv->decimal_point[0]; 284| |#else 285| | return '.'; 286| |#endif 287| 30.5k|} cJSON.c:parse_array: 1466| 283k|{ 1467| 283k| cJSON *head = NULL; /* head of the linked list */ 1468| 283k| cJSON *current_item = NULL; 1469| | 1470| 283k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 283k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1470:9): [True: 1, False: 283k] ------------------ 1471| 1| { 1472| 1| return false; /* to deeply nested */ ------------------ | | 70| 1|#define false ((cJSON_bool)0) ------------------ 1473| 1| } 1474| 283k| input_buffer->depth++; 1475| | 1476| 283k| if (buffer_at_offset(input_buffer)[0] != '[') ------------------ | | 304| 283k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1476:9): [True: 0, False: 283k] ------------------ 1477| 0| { 1478| | /* not an array */ 1479| 0| goto fail; 1480| 0| } 1481| | 1482| 283k| input_buffer->offset++; 1483| 283k| buffer_skip_whitespace(input_buffer); 1484| 283k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 301| 567k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 283k, False: 0] | | | Branch (301:65): [True: 283k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 304| 283k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1484:49): [True: 2.93k, False: 280k] ------------------ 1485| 2.93k| { 1486| | /* empty array */ 1487| 2.93k| goto success; 1488| 2.93k| } 1489| | 1490| | /* check if we skipped to the end of the buffer */ 1491| 280k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 302| 280k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 280k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 280k, False: 0] | | | | | Branch (301:65): [True: 280k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1492| 0| { 1493| 0| input_buffer->offset--; 1494| 0| goto fail; 1495| 0| } 1496| | 1497| | /* step back to character in front of the first element */ 1498| 280k| input_buffer->offset--; 1499| | /* loop through the comma separated array elements */ 1500| 280k| do 1501| 722k| { 1502| | /* allocate next item */ 1503| 722k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1504| 722k| if (new_item == NULL) ------------------ | Branch (1504:13): [True: 0, False: 722k] ------------------ 1505| 0| { 1506| 0| goto fail; /* allocation failure */ 1507| 0| } 1508| | 1509| | /* attach next item to list */ 1510| 722k| if (head == NULL) ------------------ | Branch (1510:13): [True: 280k, False: 441k] ------------------ 1511| 280k| { 1512| | /* start the linked list */ 1513| 280k| current_item = head = new_item; 1514| 280k| } 1515| 441k| else 1516| 441k| { 1517| | /* add to the end and advance */ 1518| 441k| current_item->next = new_item; 1519| 441k| new_item->prev = current_item; 1520| 441k| current_item = new_item; 1521| 441k| } 1522| | 1523| | /* parse next value */ 1524| 722k| input_buffer->offset++; 1525| 722k| buffer_skip_whitespace(input_buffer); 1526| 722k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1526:13): [True: 46.6k, False: 675k] ------------------ 1527| 46.6k| { 1528| 46.6k| goto fail; /* failed to parse value */ 1529| 46.6k| } 1530| 675k| buffer_skip_whitespace(input_buffer); 1531| 675k| } 1532| 675k| while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 301| 1.35M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 675k, False: 0] | | | Branch (301:65): [True: 675k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 304| 675k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1532:52): [True: 441k, False: 234k] ------------------ 1533| | 1534| 234k| if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 302| 468k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 234k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 234k, False: 0] | | | | | Branch (301:65): [True: 234k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 304| 234k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1534:52): [True: 136, False: 234k] ------------------ 1535| 136| { 1536| 136| goto fail; /* expected end of array */ 1537| 136| } 1538| | 1539| 237k|success: 1540| 237k| input_buffer->depth--; 1541| | 1542| 237k| if (head != NULL) { ------------------ | Branch (1542:9): [True: 234k, False: 2.93k] ------------------ 1543| 234k| head->prev = current_item; 1544| 234k| } 1545| | 1546| 237k| item->type = cJSON_Array; ------------------ | | 95| 237k|#define cJSON_Array (1 << 5) ------------------ 1547| 237k| item->child = head; 1548| | 1549| 237k| input_buffer->offset++; 1550| | 1551| 237k| return true; ------------------ | | 65| 237k|#define true ((cJSON_bool)1) ------------------ 1552| | 1553| 46.7k|fail: 1554| 46.7k| if (head != NULL) ------------------ | Branch (1554:9): [True: 46.7k, False: 0] ------------------ 1555| 46.7k| { 1556| 46.7k| cJSON_Delete(head); 1557| 46.7k| } 1558| | 1559| 46.7k| return false; ------------------ | | 70| 46.7k|#define false ((cJSON_bool)0) ------------------ 1560| 234k|} cJSON.c:parse_object: 1626| 426k|{ 1627| 426k| cJSON *head = NULL; /* linked list head */ 1628| 426k| cJSON *current_item = NULL; 1629| | 1630| 426k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 426k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1630:9): [True: 2, False: 426k] ------------------ 1631| 2| { 1632| 2| return false; /* to deeply nested */ ------------------ | | 70| 2|#define false ((cJSON_bool)0) ------------------ 1633| 2| } 1634| 426k| input_buffer->depth++; 1635| | 1636| 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 (1636:52): [True: 0, False: 426k] ------------------ 1637| 0| { 1638| 0| goto fail; /* not an object */ 1639| 0| } 1640| | 1641| 426k| input_buffer->offset++; 1642| 426k| buffer_skip_whitespace(input_buffer); 1643| 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 (1643:49): [True: 414k, False: 11.4k] ------------------ 1644| 414k| { 1645| 414k| goto success; /* empty object */ 1646| 414k| } 1647| | 1648| | /* check if we skipped to the end of the buffer */ 1649| 11.4k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 302| 11.4k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 11.4k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 11.4k, False: 0] | | | | | Branch (301:65): [True: 11.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1650| 0| { 1651| 0| input_buffer->offset--; 1652| 0| goto fail; 1653| 0| } 1654| | 1655| | /* step back to character in front of the first element */ 1656| 11.4k| input_buffer->offset--; 1657| | /* loop through the comma separated array elements */ 1658| 11.4k| do 1659| 16.7k| { 1660| | /* allocate next item */ 1661| 16.7k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1662| 16.7k| if (new_item == NULL) ------------------ | Branch (1662:13): [True: 0, False: 16.7k] ------------------ 1663| 0| { 1664| 0| goto fail; /* allocation failure */ 1665| 0| } 1666| | 1667| | /* attach next item to list */ 1668| 16.7k| if (head == NULL) ------------------ | Branch (1668:13): [True: 11.4k, False: 5.23k] ------------------ 1669| 11.4k| { 1670| | /* start the linked list */ 1671| 11.4k| current_item = head = new_item; 1672| 11.4k| } 1673| 5.23k| else 1674| 5.23k| { 1675| | /* add to the end and advance */ 1676| 5.23k| current_item->next = new_item; 1677| 5.23k| new_item->prev = current_item; 1678| 5.23k| current_item = new_item; 1679| 5.23k| } 1680| | 1681| 16.7k| if (cannot_access_at_index(input_buffer, 1)) ------------------ | | 302| 16.7k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 16.7k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 16.7k, False: 0] | | | | | Branch (301:65): [True: 16.7k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1682| 0| { 1683| 0| goto fail; /* nothing comes after the comma */ 1684| 0| } 1685| | 1686| | /* parse the name of the child */ 1687| 16.7k| input_buffer->offset++; 1688| 16.7k| buffer_skip_whitespace(input_buffer); 1689| 16.7k| if (!parse_string(current_item, input_buffer)) ------------------ | Branch (1689:13): [True: 159, False: 16.5k] ------------------ 1690| 159| { 1691| 159| goto fail; /* failed to parse name */ 1692| 159| } 1693| 16.5k| buffer_skip_whitespace(input_buffer); 1694| | 1695| | /* swap valuestring and string, because we parsed the name */ 1696| 16.5k| current_item->string = current_item->valuestring; 1697| 16.5k| current_item->valuestring = NULL; 1698| | 1699| 16.5k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 302| 33.1k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 16.5k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 16.5k, False: 0] | | | | | Branch (301:65): [True: 16.5k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 304| 16.5k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1699:56): [True: 21, False: 16.5k] ------------------ 1700| 21| { 1701| 21| goto fail; /* invalid object */ 1702| 21| } 1703| | 1704| | /* parse the value */ 1705| 16.5k| input_buffer->offset++; 1706| 16.5k| buffer_skip_whitespace(input_buffer); 1707| 16.5k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1707:13): [True: 2.00k, False: 14.5k] ------------------ 1708| 2.00k| { 1709| 2.00k| goto fail; /* failed to parse value */ 1710| 2.00k| } 1711| 14.5k| buffer_skip_whitespace(input_buffer); 1712| 14.5k| } 1713| 14.5k| while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 301| 29.0k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (301:45): [True: 14.5k, False: 0] | | | Branch (301:65): [True: 14.5k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 304| 14.5k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1713:52): [True: 5.23k, False: 9.30k] ------------------ 1714| | 1715| 9.30k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 302| 18.6k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 301| 9.30k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (301:45): [True: 9.30k, False: 0] | | | | | Branch (301:65): [True: 9.30k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 304| 9.30k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1715:52): [True: 37, False: 9.27k] ------------------ 1716| 37| { 1717| 37| goto fail; /* expected end of object */ 1718| 37| } 1719| | 1720| 424k|success: 1721| 424k| input_buffer->depth--; 1722| | 1723| 424k| if (head != NULL) { ------------------ | Branch (1723:9): [True: 9.27k, False: 414k] ------------------ 1724| 9.27k| head->prev = current_item; 1725| 9.27k| } 1726| | 1727| 424k| item->type = cJSON_Object; ------------------ | | 96| 424k|#define cJSON_Object (1 << 6) ------------------ 1728| 424k| item->child = head; 1729| | 1730| 424k| input_buffer->offset++; 1731| 424k| return true; ------------------ | | 65| 424k|#define true ((cJSON_bool)1) ------------------ 1732| | 1733| 2.22k|fail: 1734| 2.22k| if (head != NULL) ------------------ | Branch (1734:9): [True: 2.22k, False: 0] ------------------ 1735| 2.22k| { 1736| 2.22k| cJSON_Delete(head); 1737| 2.22k| } 1738| | 1739| 2.22k| return false; ------------------ | | 70| 2.22k|#define false ((cJSON_bool)0) ------------------ 1740| 9.30k|} cJSON.c:print_value: 1392| 660k|{ 1393| 660k| unsigned char *output = NULL; 1394| | 1395| 660k| if ((item == NULL) || (output_buffer == NULL)) ------------------ | Branch (1395:9): [True: 0, False: 660k] | Branch (1395:27): [True: 0, False: 660k] ------------------ 1396| 0| { 1397| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1398| 0| } 1399| | 1400| 660k| switch ((item->type) & 0xFF) 1401| 660k| { 1402| 326| case cJSON_NULL: ------------------ | | 92| 326|#define cJSON_NULL (1 << 2) ------------------ | Branch (1402:9): [True: 326, False: 659k] ------------------ 1403| 326| output = ensure(output_buffer, 5); 1404| 326| if (output == NULL) ------------------ | Branch (1404:17): [True: 0, False: 326] ------------------ 1405| 0| { 1406| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1407| 0| } 1408| 326| strcpy((char*)output, "null"); 1409| 326| return true; ------------------ | | 65| 326|#define true ((cJSON_bool)1) ------------------ 1410| | 1411| 268| case cJSON_False: ------------------ | | 90| 268|#define cJSON_False (1 << 0) ------------------ | Branch (1411:9): [True: 268, False: 659k] ------------------ 1412| 268| output = ensure(output_buffer, 6); 1413| 268| if (output == NULL) ------------------ | Branch (1413:17): [True: 0, False: 268] ------------------ 1414| 0| { 1415| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1416| 0| } 1417| 268| strcpy((char*)output, "false"); 1418| 268| return true; ------------------ | | 65| 268|#define true ((cJSON_bool)1) ------------------ 1419| | 1420| 209| case cJSON_True: ------------------ | | 91| 209|#define cJSON_True (1 << 1) ------------------ | Branch (1420:9): [True: 209, False: 659k] ------------------ 1421| 209| output = ensure(output_buffer, 5); 1422| 209| if (output == NULL) ------------------ | Branch (1422:17): [True: 0, False: 209] ------------------ 1423| 0| { 1424| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1425| 0| } 1426| 209| strcpy((char*)output, "true"); 1427| 209| return true; ------------------ | | 65| 209|#define true ((cJSON_bool)1) ------------------ 1428| | 1429| 7.18k| case cJSON_Number: ------------------ | | 93| 7.18k|#define cJSON_Number (1 << 3) ------------------ | Branch (1429:9): [True: 7.18k, False: 652k] ------------------ 1430| 7.18k| return print_number(item, output_buffer); 1431| | 1432| 0| case cJSON_Raw: ------------------ | | 97| 0|#define cJSON_Raw (1 << 7) /* raw json */ ------------------ | Branch (1432:9): [True: 0, False: 660k] ------------------ 1433| 0| { 1434| 0| size_t raw_length = 0; 1435| 0| if (item->valuestring == NULL) ------------------ | Branch (1435:17): [True: 0, False: 0] ------------------ 1436| 0| { 1437| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1438| 0| } 1439| | 1440| 0| raw_length = strlen(item->valuestring) + sizeof(""); 1441| 0| output = ensure(output_buffer, raw_length); 1442| 0| if (output == NULL) ------------------ | Branch (1442:17): [True: 0, False: 0] ------------------ 1443| 0| { 1444| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1445| 0| } 1446| 0| memcpy(output, item->valuestring, raw_length); 1447| 0| return true; ------------------ | | 65| 0|#define true ((cJSON_bool)1) ------------------ 1448| 0| } 1449| | 1450| 863| case cJSON_String: ------------------ | | 94| 863|#define cJSON_String (1 << 4) ------------------ | Branch (1450:9): [True: 863, False: 659k] ------------------ 1451| 863| return print_string(item, output_buffer); 1452| | 1453| 233k| case cJSON_Array: ------------------ | | 95| 233k|#define cJSON_Array (1 << 5) ------------------ | Branch (1453:9): [True: 233k, False: 426k] ------------------ 1454| 233k| return print_array(item, output_buffer); 1455| | 1456| 418k| case cJSON_Object: ------------------ | | 96| 418k|#define cJSON_Object (1 << 6) ------------------ | Branch (1456:9): [True: 418k, False: 242k] ------------------ 1457| 418k| return print_object(item, output_buffer); 1458| | 1459| 0| default: ------------------ | Branch (1459:9): [True: 0, False: 660k] ------------------ 1460| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1461| 660k| } 1462| 660k|} cJSON.c:ensure: 459| 1.77M|{ 460| 1.77M| unsigned char *newbuffer = NULL; 461| 1.77M| size_t newsize = 0; 462| | 463| 1.77M| if ((p == NULL) || (p->buffer == NULL)) ------------------ | Branch (463:9): [True: 0, False: 1.77M] | Branch (463:24): [True: 0, False: 1.77M] ------------------ 464| 0| { 465| 0| return NULL; 466| 0| } 467| | 468| 1.77M| if ((p->length > 0) && (p->offset >= p->length)) ------------------ | Branch (468:9): [True: 1.77M, False: 0] | Branch (468:28): [True: 0, False: 1.77M] ------------------ 469| 0| { 470| | /* make sure that offset is valid */ 471| 0| return NULL; 472| 0| } 473| | 474| 1.77M| if (needed > INT_MAX) ------------------ | Branch (474:9): [True: 0, False: 1.77M] ------------------ 475| 0| { 476| | /* sizes bigger than INT_MAX are currently not supported */ 477| 0| return NULL; 478| 0| } 479| | 480| 1.77M| needed += p->offset + 1; 481| 1.77M| if (needed <= p->length) ------------------ | Branch (481:9): [True: 1.76M, False: 1.60k] ------------------ 482| 1.76M| { 483| 1.76M| return p->buffer + p->offset; 484| 1.76M| } 485| | 486| 1.60k| if (p->noalloc) { ------------------ | Branch (486:9): [True: 0, False: 1.60k] ------------------ 487| 0| return NULL; 488| 0| } 489| | 490| | /* calculate new buffer size */ 491| 1.60k| if (needed > (INT_MAX / 2)) ------------------ | Branch (491:9): [True: 0, False: 1.60k] ------------------ 492| 0| { 493| | /* overflow of int, use INT_MAX if possible */ 494| 0| if (needed <= INT_MAX) ------------------ | Branch (494:13): [True: 0, False: 0] ------------------ 495| 0| { 496| 0| newsize = INT_MAX; 497| 0| } 498| 0| else 499| 0| { 500| 0| return NULL; 501| 0| } 502| 0| } 503| 1.60k| else 504| 1.60k| { 505| 1.60k| newsize = needed * 2; 506| 1.60k| } 507| | 508| 1.60k| if (p->hooks.reallocate != NULL) ------------------ | Branch (508:9): [True: 1.60k, False: 0] ------------------ 509| 1.60k| { 510| | /* reallocate with realloc if available */ 511| 1.60k| newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); 512| 1.60k| if (newbuffer == NULL) ------------------ | Branch (512:13): [True: 0, False: 1.60k] ------------------ 513| 0| { 514| 0| p->hooks.deallocate(p->buffer); 515| 0| p->length = 0; 516| 0| p->buffer = NULL; 517| | 518| 0| return NULL; 519| 0| } 520| 1.60k| } 521| 0| else 522| 0| { 523| | /* otherwise reallocate manually */ 524| 0| newbuffer = (unsigned char*)p->hooks.allocate(newsize); 525| 0| if (!newbuffer) ------------------ | Branch (525:13): [True: 0, False: 0] ------------------ 526| 0| { 527| 0| p->hooks.deallocate(p->buffer); 528| 0| p->length = 0; 529| 0| p->buffer = NULL; 530| | 531| 0| return NULL; 532| 0| } 533| | 534| 0| memcpy(newbuffer, p->buffer, p->offset + 1); 535| 0| p->hooks.deallocate(p->buffer); 536| 0| } 537| 1.60k| p->length = newsize; 538| 1.60k| p->buffer = newbuffer; 539| | 540| 1.60k| return newbuffer + p->offset; 541| 1.60k|} cJSON.c:print_number: 565| 7.18k|{ 566| 7.18k| unsigned char *output_pointer = NULL; 567| 7.18k| double d = item->valuedouble; 568| 7.18k| int length = 0; 569| 7.18k| size_t i = 0; 570| 7.18k| unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ 571| 7.18k| unsigned char decimal_point = get_decimal_point(); 572| 7.18k| double test = 0.0; 573| | 574| 7.18k| if (output_buffer == NULL) ------------------ | Branch (574:9): [True: 0, False: 7.18k] ------------------ 575| 0| { 576| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 577| 0| } 578| | 579| | /* This checks for NaN and Infinity */ 580| 7.18k| if (isnan(d) || isinf(d)) ------------------ | | 77| 14.3k|#define isnan(d) (d != d) | | ------------------ | | | Branch (77:18): [True: 0, False: 7.18k] | | ------------------ ------------------ if (isnan(d) || isinf(d)) ------------------ | | 74| 7.18k|#define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 14.3k|#define isnan(d) (d != d) | | | | ------------------ | | | | | Branch (77:18): [True: 194, False: 6.99k] | | | | ------------------ | | ------------------ | | #define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 194|#define isnan(d) (d != d) | | ------------------ | | | Branch (74:37): [True: 194, False: 0] | | ------------------ ------------------ 581| 194| { 582| 194| length = sprintf((char*)number_buffer, "null"); 583| 194| } 584| 6.99k| else if(d == (double)item->valueint) ------------------ | Branch (584:13): [True: 6.39k, False: 602] ------------------ 585| 6.39k| { 586| 6.39k| length = sprintf((char*)number_buffer, "%d", item->valueint); 587| 6.39k| } 588| 602| else 589| 602| { 590| | /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ 591| 602| length = sprintf((char*)number_buffer, "%1.15g", d); 592| | 593| | /* Check whether the original double can be recovered */ 594| 602| if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) ------------------ | Branch (594:13): [True: 0, False: 602] | Branch (594:66): [True: 355, False: 247] ------------------ 595| 355| { 596| | /* If not, print with 17 decimal places of precision */ 597| 355| length = sprintf((char*)number_buffer, "%1.17g", d); 598| 355| } 599| 602| } 600| | 601| | /* sprintf failed or buffer overrun occurred */ 602| 7.18k| if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) ------------------ | Branch (602:9): [True: 0, False: 7.18k] | Branch (602:25): [True: 0, False: 7.18k] ------------------ 603| 0| { 604| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 605| 0| } 606| | 607| | /* reserve appropriate space in the output */ 608| 7.18k| output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); 609| 7.18k| if (output_pointer == NULL) ------------------ | Branch (609:9): [True: 0, False: 7.18k] ------------------ 610| 0| { 611| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 612| 0| } 613| | 614| | /* copy the printed number to the output and replace locale 615| | * dependent decimal point with '.' */ 616| 21.9k| for (i = 0; i < ((size_t)length); i++) ------------------ | Branch (616:17): [True: 14.7k, False: 7.18k] ------------------ 617| 14.7k| { 618| 14.7k| if (number_buffer[i] == decimal_point) ------------------ | Branch (618:13): [True: 211, False: 14.5k] ------------------ 619| 211| { 620| 211| output_pointer[i] = '.'; 621| 211| continue; 622| 211| } 623| | 624| 14.5k| output_pointer[i] = number_buffer[i]; 625| 14.5k| } 626| 7.18k| output_pointer[i] = '\0'; 627| | 628| 7.18k| output_buffer->offset += (size_t)length; 629| | 630| 7.18k| return true; ------------------ | | 65| 7.18k|#define true ((cJSON_bool)1) ------------------ 631| 7.18k|} cJSON.c:print_string: 1045| 863|{ 1046| 863| return print_string_ptr((unsigned char*)item->valuestring, p); 1047| 863|} cJSON.c:print_string_ptr: 923| 11.3k|{ 924| 11.3k| const unsigned char *input_pointer = NULL; 925| 11.3k| unsigned char *output = NULL; 926| 11.3k| unsigned char *output_pointer = NULL; 927| 11.3k| size_t output_length = 0; 928| | /* numbers of additional characters needed for escaping */ 929| 11.3k| size_t escape_characters = 0; 930| | 931| 11.3k| if (output_buffer == NULL) ------------------ | Branch (931:9): [True: 0, False: 11.3k] ------------------ 932| 0| { 933| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 934| 0| } 935| | 936| | /* empty string */ 937| 11.3k| if (input == NULL) ------------------ | Branch (937:9): [True: 0, False: 11.3k] ------------------ 938| 0| { 939| 0| output = ensure(output_buffer, sizeof("\"\"")); 940| 0| if (output == NULL) ------------------ | Branch (940:13): [True: 0, False: 0] ------------------ 941| 0| { 942| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 943| 0| } 944| 0| strcpy((char*)output, "\"\""); 945| | 946| 0| return true; ------------------ | | 65| 0|#define true ((cJSON_bool)1) ------------------ 947| 0| } 948| | 949| | /* set "flag" to 1 if something needs to be escaped */ 950| 11.2M| for (input_pointer = input; *input_pointer; input_pointer++) ------------------ | Branch (950:33): [True: 11.2M, False: 11.3k] ------------------ 951| 11.2M| { 952| 11.2M| switch (*input_pointer) 953| 11.2M| { 954| 2.73k| case '\"': ------------------ | Branch (954:13): [True: 2.73k, False: 11.2M] ------------------ 955| 4.34k| case '\\': ------------------ | Branch (955:13): [True: 1.60k, False: 11.2M] ------------------ 956| 10.9k| case '\b': ------------------ | Branch (956:13): [True: 6.60k, False: 11.2M] ------------------ 957| 25.1k| case '\f': ------------------ | Branch (957:13): [True: 14.1k, False: 11.2M] ------------------ 958| 230k| case '\n': ------------------ | Branch (958:13): [True: 205k, False: 11.0M] ------------------ 959| 233k| case '\r': ------------------ | Branch (959:13): [True: 2.33k, False: 11.2M] ------------------ 960| 236k| case '\t': ------------------ | Branch (960:13): [True: 3.61k, False: 11.2M] ------------------ 961| | /* one character escape sequence */ 962| 236k| escape_characters++; 963| 236k| break; 964| 11.0M| default: ------------------ | Branch (964:13): [True: 11.0M, False: 236k] ------------------ 965| 11.0M| if (*input_pointer < 32) ------------------ | Branch (965:21): [True: 8.29M, False: 2.70M] ------------------ 966| 8.29M| { 967| | /* UTF-16 escape sequence uXXXX */ 968| 8.29M| escape_characters += 5; 969| 8.29M| } 970| 11.0M| break; 971| 11.2M| } 972| 11.2M| } 973| 11.3k| output_length = (size_t)(input_pointer - input) + escape_characters; 974| | 975| 11.3k| output = ensure(output_buffer, output_length + sizeof("\"\"")); 976| 11.3k| if (output == NULL) ------------------ | Branch (976:9): [True: 0, False: 11.3k] ------------------ 977| 0| { 978| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 979| 0| } 980| | 981| | /* no characters have to be escaped */ 982| 11.3k| if (escape_characters == 0) ------------------ | Branch (982:9): [True: 10.7k, False: 525] ------------------ 983| 10.7k| { 984| 10.7k| output[0] = '\"'; 985| 10.7k| memcpy(output + 1, input, output_length); 986| 10.7k| output[output_length + 1] = '\"'; 987| 10.7k| output[output_length + 2] = '\0'; 988| | 989| 10.7k| return true; ------------------ | | 65| 10.7k|#define true ((cJSON_bool)1) ------------------ 990| 10.7k| } 991| | 992| 525| output[0] = '\"'; 993| 525| output_pointer = output + 1; 994| | /* copy the string */ 995| 11.2M| for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) ------------------ | Branch (995:33): [True: 11.2M, False: 525] ------------------ 996| 11.2M| { 997| 11.2M| if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) ------------------ | Branch (997:13): [True: 2.70M, False: 8.52M] | Branch (997:38): [True: 2.70M, False: 2.73k] | Branch (997:66): [True: 2.70M, False: 1.60k] ------------------ 998| 2.70M| { 999| | /* normal character, copy */ 1000| 2.70M| *output_pointer = *input_pointer; 1001| 2.70M| } 1002| 8.53M| else 1003| 8.53M| { 1004| | /* character needs to be escaped */ 1005| 8.53M| *output_pointer++ = '\\'; 1006| 8.53M| switch (*input_pointer) 1007| 8.53M| { 1008| 1.60k| case '\\': ------------------ | Branch (1008:17): [True: 1.60k, False: 8.53M] ------------------ 1009| 1.60k| *output_pointer = '\\'; 1010| 1.60k| break; 1011| 2.73k| case '\"': ------------------ | Branch (1011:17): [True: 2.73k, False: 8.53M] ------------------ 1012| 2.73k| *output_pointer = '\"'; 1013| 2.73k| break; 1014| 6.60k| case '\b': ------------------ | Branch (1014:17): [True: 6.60k, False: 8.52M] ------------------ 1015| 6.60k| *output_pointer = 'b'; 1016| 6.60k| break; 1017| 14.1k| case '\f': ------------------ | Branch (1017:17): [True: 14.1k, False: 8.51M] ------------------ 1018| 14.1k| *output_pointer = 'f'; 1019| 14.1k| break; 1020| 205k| case '\n': ------------------ | Branch (1020:17): [True: 205k, False: 8.32M] ------------------ 1021| 205k| *output_pointer = 'n'; 1022| 205k| break; 1023| 2.33k| case '\r': ------------------ | Branch (1023:17): [True: 2.33k, False: 8.53M] ------------------ 1024| 2.33k| *output_pointer = 'r'; 1025| 2.33k| break; 1026| 3.61k| case '\t': ------------------ | Branch (1026:17): [True: 3.61k, False: 8.52M] ------------------ 1027| 3.61k| *output_pointer = 't'; 1028| 3.61k| break; 1029| 8.29M| default: ------------------ | Branch (1029:17): [True: 8.29M, False: 236k] ------------------ 1030| | /* escape and print as unicode codepoint */ 1031| 8.29M| sprintf((char*)output_pointer, "u%04x", *input_pointer); 1032| 8.29M| output_pointer += 4; 1033| 8.29M| break; 1034| 8.53M| } 1035| 8.53M| } 1036| 11.2M| } 1037| 525| output[output_length + 1] = '\"'; 1038| 525| output[output_length + 2] = '\0'; 1039| | 1040| 525| return true; ------------------ | | 65| 525|#define true ((cJSON_bool)1) ------------------ 1041| 525|} cJSON.c:print_array: 1564| 233k|{ 1565| 233k| unsigned char *output_pointer = NULL; 1566| 233k| size_t length = 0; 1567| 233k| cJSON *current_element = item->child; 1568| | 1569| 233k| if (output_buffer == NULL) ------------------ | Branch (1569:9): [True: 0, False: 233k] ------------------ 1570| 0| { 1571| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1572| 0| } 1573| | 1574| | /* Compose the output array. */ 1575| | /* opening square bracket */ 1576| 233k| output_pointer = ensure(output_buffer, 1); 1577| 233k| if (output_pointer == NULL) ------------------ | Branch (1577:9): [True: 0, False: 233k] ------------------ 1578| 0| { 1579| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1580| 0| } 1581| | 1582| 233k| *output_pointer = '['; 1583| 233k| output_buffer->offset++; 1584| 233k| output_buffer->depth++; 1585| | 1586| 881k| while (current_element != NULL) ------------------ | Branch (1586:12): [True: 648k, False: 233k] ------------------ 1587| 648k| { 1588| 648k| if (!print_value(current_element, output_buffer)) ------------------ | Branch (1588:13): [True: 0, False: 648k] ------------------ 1589| 0| { 1590| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1591| 0| } 1592| 648k| update_offset(output_buffer); 1593| 648k| if (current_element->next) ------------------ | Branch (1593:13): [True: 418k, False: 230k] ------------------ 1594| 418k| { 1595| 418k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1595:32): [True: 417k, False: 1.20k] ------------------ 1596| 418k| output_pointer = ensure(output_buffer, length + 1); 1597| 418k| if (output_pointer == NULL) ------------------ | Branch (1597:17): [True: 0, False: 418k] ------------------ 1598| 0| { 1599| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1600| 0| } 1601| 418k| *output_pointer++ = ','; 1602| 418k| if(output_buffer->format) ------------------ | Branch (1602:16): [True: 417k, False: 1.20k] ------------------ 1603| 417k| { 1604| 417k| *output_pointer++ = ' '; 1605| 417k| } 1606| 418k| *output_pointer = '\0'; 1607| 418k| output_buffer->offset += length; 1608| 418k| } 1609| 648k| current_element = current_element->next; 1610| 648k| } 1611| | 1612| 233k| output_pointer = ensure(output_buffer, 2); 1613| 233k| if (output_pointer == NULL) ------------------ | Branch (1613:9): [True: 0, False: 233k] ------------------ 1614| 0| { 1615| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1616| 0| } 1617| 233k| *output_pointer++ = ']'; 1618| 233k| *output_pointer = '\0'; 1619| 233k| output_buffer->depth--; 1620| | 1621| 233k| return true; ------------------ | | 65| 233k|#define true ((cJSON_bool)1) ------------------ 1622| 233k|} cJSON.c:print_object: 1744| 418k|{ 1745| 418k| unsigned char *output_pointer = NULL; 1746| 418k| size_t length = 0; 1747| 418k| cJSON *current_item = item->child; 1748| | 1749| 418k| if (output_buffer == NULL) ------------------ | Branch (1749:9): [True: 0, False: 418k] ------------------ 1750| 0| { 1751| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1752| 0| } 1753| | 1754| | /* Compose the output: */ 1755| 418k| length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ ------------------ | Branch (1755:24): [True: 417k, False: 359] ------------------ 1756| 418k| output_pointer = ensure(output_buffer, length + 1); 1757| 418k| if (output_pointer == NULL) ------------------ | Branch (1757:9): [True: 0, False: 418k] ------------------ 1758| 0| { 1759| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1760| 0| } 1761| | 1762| 418k| *output_pointer++ = '{'; 1763| 418k| output_buffer->depth++; 1764| 418k| if (output_buffer->format) ------------------ | Branch (1764:9): [True: 417k, False: 359] ------------------ 1765| 417k| { 1766| 417k| *output_pointer++ = '\n'; 1767| 417k| } 1768| 418k| output_buffer->offset += length; 1769| | 1770| 428k| while (current_item) ------------------ | Branch (1770:12): [True: 10.4k, False: 418k] ------------------ 1771| 10.4k| { 1772| 10.4k| if (output_buffer->format) ------------------ | Branch (1772:13): [True: 10.0k, False: 351] ------------------ 1773| 10.0k| { 1774| 10.0k| size_t i; 1775| 10.0k| output_pointer = ensure(output_buffer, output_buffer->depth); 1776| 10.0k| if (output_pointer == NULL) ------------------ | Branch (1776:17): [True: 0, False: 10.0k] ------------------ 1777| 0| { 1778| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1779| 0| } 1780| 4.12M| for (i = 0; i < output_buffer->depth; i++) ------------------ | Branch (1780:25): [True: 4.11M, False: 10.0k] ------------------ 1781| 4.11M| { 1782| 4.11M| *output_pointer++ = '\t'; 1783| 4.11M| } 1784| 10.0k| output_buffer->offset += output_buffer->depth; 1785| 10.0k| } 1786| | 1787| | /* print key */ 1788| 10.4k| if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) ------------------ | Branch (1788:13): [True: 0, False: 10.4k] ------------------ 1789| 0| { 1790| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1791| 0| } 1792| 10.4k| update_offset(output_buffer); 1793| | 1794| 10.4k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1794:28): [True: 10.0k, False: 351] ------------------ 1795| 10.4k| output_pointer = ensure(output_buffer, length); 1796| 10.4k| if (output_pointer == NULL) ------------------ | Branch (1796:13): [True: 0, False: 10.4k] ------------------ 1797| 0| { 1798| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1799| 0| } 1800| 10.4k| *output_pointer++ = ':'; 1801| 10.4k| if (output_buffer->format) ------------------ | Branch (1801:13): [True: 10.0k, False: 351] ------------------ 1802| 10.0k| { 1803| 10.0k| *output_pointer++ = '\t'; 1804| 10.0k| } 1805| 10.4k| output_buffer->offset += length; 1806| | 1807| | /* print value */ 1808| 10.4k| if (!print_value(current_item, output_buffer)) ------------------ | Branch (1808:13): [True: 0, False: 10.4k] ------------------ 1809| 0| { 1810| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1811| 0| } 1812| 10.4k| update_offset(output_buffer); 1813| | 1814| | /* print comma if not last */ 1815| 10.4k| length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); ------------------ | Branch (1815:28): [True: 10.0k, False: 351] | Branch (1815:70): [True: 2.57k, False: 7.87k] ------------------ 1816| 10.4k| output_pointer = ensure(output_buffer, length + 1); 1817| 10.4k| if (output_pointer == NULL) ------------------ | Branch (1817:13): [True: 0, False: 10.4k] ------------------ 1818| 0| { 1819| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1820| 0| } 1821| 10.4k| if (current_item->next) ------------------ | Branch (1821:13): [True: 2.57k, False: 7.87k] ------------------ 1822| 2.57k| { 1823| 2.57k| *output_pointer++ = ','; 1824| 2.57k| } 1825| | 1826| 10.4k| if (output_buffer->format) ------------------ | Branch (1826:13): [True: 10.0k, False: 351] ------------------ 1827| 10.0k| { 1828| 10.0k| *output_pointer++ = '\n'; 1829| 10.0k| } 1830| 10.4k| *output_pointer = '\0'; 1831| 10.4k| output_buffer->offset += length; 1832| | 1833| 10.4k| current_item = current_item->next; 1834| 10.4k| } 1835| | 1836| 418k| output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); ------------------ | Branch (1836:44): [True: 417k, False: 359] ------------------ 1837| 418k| if (output_pointer == NULL) ------------------ | Branch (1837:9): [True: 0, False: 418k] ------------------ 1838| 0| { 1839| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1840| 0| } 1841| 418k| if (output_buffer->format) ------------------ | Branch (1841:9): [True: 417k, False: 359] ------------------ 1842| 417k| { 1843| 417k| size_t i; 1844| 223M| for (i = 0; i < (output_buffer->depth - 1); i++) ------------------ | Branch (1844:21): [True: 222M, False: 417k] ------------------ 1845| 222M| { 1846| 222M| *output_pointer++ = '\t'; 1847| 222M| } 1848| 417k| } 1849| 418k| *output_pointer++ = '}'; 1850| 418k| *output_pointer = '\0'; 1851| 418k| output_buffer->depth--; 1852| | 1853| 418k| return true; ------------------ | | 65| 418k|#define true ((cJSON_bool)1) ------------------ 1854| 418k|} cJSON.c:skip_oneline_comment: 2834| 1.07k|{ 2835| 1.07k| *input += static_strlen("//"); ------------------ | | 184| 1.07k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2836| | 2837| 31.6k| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2837:12): [True: 31.5k, False: 22] ------------------ 2838| 31.5k| { 2839| 31.5k| if ((*input)[0] == '\n') { ------------------ | Branch (2839:13): [True: 1.04k, False: 30.5k] ------------------ 2840| 1.04k| *input += static_strlen("\n"); ------------------ | | 184| 1.04k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2841| 1.04k| return; 2842| 1.04k| } 2843| 31.5k| } 2844| 1.07k|} cJSON.c:skip_multiline_comment: 2847| 376|{ 2848| 376| *input += static_strlen("/*"); ------------------ | | 184| 376|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2849| | 2850| 3.21k| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2850:12): [True: 3.17k, False: 47] ------------------ 2851| 3.17k| { 2852| 3.17k| if (((*input)[0] == '*') && ((*input)[1] == '/')) ------------------ | Branch (2852:13): [True: 769, False: 2.40k] | Branch (2852:37): [True: 329, False: 440] ------------------ 2853| 329| { 2854| 329| *input += static_strlen("*/"); ------------------ | | 184| 329|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2855| 329| return; 2856| 329| } 2857| 3.17k| } 2858| 376|} cJSON.c:minify_string: 2860| 11.1k|static void minify_string(char **input, char **output) { 2861| 11.1k| (*output)[0] = (*input)[0]; 2862| 11.1k| *input += static_strlen("\""); ------------------ | | 184| 11.1k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2863| 11.1k| *output += static_strlen("\""); ------------------ | | 184| 11.1k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2864| | 2865| | 2866| 12.0M| for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { ------------------ | Branch (2866:12): [True: 12.0M, False: 37] ------------------ 2867| 12.0M| (*output)[0] = (*input)[0]; 2868| | 2869| 12.0M| if ((*input)[0] == '\"') { ------------------ | Branch (2869:13): [True: 11.1k, False: 12.0M] ------------------ 2870| 11.1k| (*output)[0] = '\"'; 2871| 11.1k| *input += static_strlen("\""); ------------------ | | 184| 11.1k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2872| 11.1k| *output += static_strlen("\""); ------------------ | | 184| 11.1k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2873| 11.1k| return; 2874| 12.0M| } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { ------------------ | Branch (2874:20): [True: 21.3k, False: 12.0M] | Branch (2874:45): [True: 2.10k, False: 19.2k] ------------------ 2875| 2.10k| (*output)[1] = (*input)[1]; 2876| 2.10k| *input += static_strlen("\""); ------------------ | | 184| 2.10k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2877| 2.10k| *output += static_strlen("\""); ------------------ | | 184| 2.10k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2878| 2.10k| } 2879| 12.0M| } 2880| 11.1k|} cJSON.c:compare_double: 558| 602|{ 559| 602| double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); ------------------ | Branch (559:21): [True: 335, False: 267] ------------------ 560| 602| return (fabs(a - b) <= maxVal * DBL_EPSILON); 561| 602|} LLVMFuzzerTestOneInput: 14| 2.03k|{ 15| 2.03k| cJSON *json; 16| 2.03k| size_t offset = 4; 17| 2.03k| unsigned char *copied; 18| 2.03k| char *printed_json = NULL; 19| 2.03k| int minify, require_termination, formatted, buffered; 20| | 21| | 22| 2.03k| if(size <= offset) return 0; ------------------ | Branch (22:8): [True: 4, False: 2.02k] ------------------ 23| 2.02k| if(data[size-1] != '\0') return 0; ------------------ | Branch (23:8): [True: 12, False: 2.01k] ------------------ 24| 2.01k| if(data[0] != '1' && data[0] != '0') return 0; ------------------ | Branch (24:8): [True: 450, False: 1.56k] | Branch (24:26): [True: 16, False: 434] ------------------ 25| 2.00k| if(data[1] != '1' && data[1] != '0') return 0; ------------------ | Branch (25:8): [True: 1.42k, False: 571] | Branch (25:26): [True: 12, False: 1.41k] ------------------ 26| 1.98k| if(data[2] != '1' && data[2] != '0') return 0; ------------------ | Branch (26:8): [True: 934, False: 1.05k] | Branch (26:26): [True: 12, False: 922] ------------------ 27| 1.97k| if(data[3] != '1' && data[3] != '0') return 0; ------------------ | Branch (27:8): [True: 939, False: 1.03k] | Branch (27:26): [True: 13, False: 926] ------------------ 28| | 29| 1.96k| minify = data[0] == '1' ? 1 : 0; ------------------ | Branch (29:27): [True: 1.53k, False: 424] ------------------ 30| 1.96k| require_termination = data[1] == '1' ? 1 : 0; ------------------ | Branch (30:27): [True: 560, False: 1.40k] ------------------ 31| 1.96k| formatted = data[2] == '1' ? 1 : 0; ------------------ | Branch (31:27): [True: 1.04k, False: 915] ------------------ 32| 1.96k| buffered = data[3] == '1' ? 1 : 0; ------------------ | Branch (32:27): [True: 1.03k, False: 926] ------------------ 33| | 34| 1.96k| json = cJSON_ParseWithOpts((const char*)data + offset, NULL, require_termination); 35| | 36| 1.96k| if(json == NULL) return 0; ------------------ | Branch (36:8): [True: 936, False: 1.02k] ------------------ 37| | 38| 1.02k| if(buffered) ------------------ | Branch (38:8): [True: 532, False: 495] ------------------ 39| 532| { 40| 532| printed_json = cJSON_PrintBuffered(json, 1, formatted); 41| 532| } 42| 495| else 43| 495| { 44| | /* unbuffered printing */ 45| 495| if(formatted) ------------------ | Branch (45:12): [True: 273, False: 222] ------------------ 46| 273| { 47| 273| printed_json = cJSON_Print(json); 48| 273| } 49| 222| else 50| 222| { 51| 222| printed_json = cJSON_PrintUnformatted(json); 52| 222| } 53| 495| } 54| | 55| 1.02k| if(printed_json != NULL) free(printed_json); ------------------ | Branch (55:8): [True: 1.02k, False: 0] ------------------ 56| | 57| 1.02k| if(minify) ------------------ | Branch (57:8): [True: 838, False: 189] ------------------ 58| 838| { 59| 838| copied = (unsigned char*)malloc(size); 60| 838| if(copied == NULL) return 0; ------------------ | Branch (60:12): [True: 0, False: 838] ------------------ 61| | 62| 838| memcpy(copied, data, size); 63| | 64| 838| cJSON_Minify((char*)copied + offset); 65| | 66| 838| free(copied); 67| 838| } 68| | 69| 1.02k| cJSON_Delete(json); 70| | 71| 1.02k| return 0; 72| 1.02k|}