cJSON_Delete: 254| 368k|{ 255| 368k| cJSON *next = NULL; 256| 1.23M| while (item != NULL) ------------------ | Branch (256:12): [True: 868k, False: 368k] ------------------ 257| 868k| { 258| 868k| next = item->next; 259| 868k| if (!(item->type & cJSON_IsReference) && (item->child != NULL)) ------------------ | | 99| 868k|#define cJSON_IsReference 256 ------------------ | Branch (259:13): [True: 868k, False: 0] | Branch (259:50): [True: 320k, False: 547k] ------------------ 260| 320k| { 261| 320k| cJSON_Delete(item->child); 262| 320k| } 263| 868k| if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) ------------------ | | 99| 868k|#define cJSON_IsReference 256 ------------------ | Branch (263:13): [True: 868k, False: 0] | Branch (263:50): [True: 12.7k, False: 855k] ------------------ 264| 12.7k| { 265| 12.7k| global_hooks.deallocate(item->valuestring); 266| 12.7k| } 267| 868k| if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) ------------------ | | 100| 868k|#define cJSON_StringIsConst 512 ------------------ | Branch (267:13): [True: 868k, False: 0] | Branch (267:52): [True: 17.6k, False: 850k] ------------------ 268| 17.6k| { 269| 17.6k| global_hooks.deallocate(item->string); 270| 17.6k| } 271| 868k| global_hooks.deallocate(item); 272| 868k| item = next; 273| 868k| } 274| 368k|} cJSON_ParseWithOpts: 1080| 1.97k|{ 1081| 1.97k| size_t buffer_length; 1082| | 1083| 1.97k| if (NULL == value) ------------------ | Branch (1083:9): [True: 0, False: 1.97k] ------------------ 1084| 0| { 1085| 0| return NULL; 1086| 0| } 1087| | 1088| | /* Adding null character size due to require_null_terminated. */ 1089| 1.97k| buffer_length = strlen(value) + sizeof(""); 1090| | 1091| 1.97k| return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); 1092| 1.97k|} cJSON_ParseWithLengthOpts: 1096| 1.97k|{ 1097| 1.97k| parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; 1098| 1.97k| cJSON *item = NULL; 1099| | 1100| | /* reset error position */ 1101| 1.97k| global_error.json = NULL; 1102| 1.97k| global_error.position = 0; 1103| | 1104| 1.97k| if (value == NULL || 0 == buffer_length) ------------------ | Branch (1104:9): [True: 0, False: 1.97k] | Branch (1104:26): [True: 0, False: 1.97k] ------------------ 1105| 0| { 1106| 0| goto fail; 1107| 0| } 1108| | 1109| 1.97k| buffer.content = (const unsigned char*)value; 1110| 1.97k| buffer.length = buffer_length; 1111| 1.97k| buffer.offset = 0; 1112| 1.97k| buffer.hooks = global_hooks; 1113| | 1114| 1.97k| item = cJSON_New_Item(&global_hooks); 1115| 1.97k| if (item == NULL) /* memory fail */ ------------------ | Branch (1115:9): [True: 0, False: 1.97k] ------------------ 1116| 0| { 1117| 0| goto fail; 1118| 0| } 1119| | 1120| 1.97k| if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) ------------------ | Branch (1120:9): [True: 884, False: 1.08k] ------------------ 1121| 884| { 1122| | /* parse failure. ep is set. */ 1123| 884| goto fail; 1124| 884| } 1125| | 1126| | /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ 1127| 1.08k| if (require_null_terminated) ------------------ | Branch (1127:9): [True: 370, False: 717] ------------------ 1128| 370| { 1129| 370| buffer_skip_whitespace(&buffer); 1130| 370| if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') ------------------ | | 302| 370|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1130:13): [True: 0, False: 370] | Branch (1130:49): [True: 44, False: 326] ------------------ 1131| 44| { 1132| 44| goto fail; 1133| 44| } 1134| 370| } 1135| 1.04k| if (return_parse_end) ------------------ | Branch (1135:9): [True: 0, False: 1.04k] ------------------ 1136| 0| { 1137| 0| *return_parse_end = (const char*)buffer_at_offset(&buffer); ------------------ | | 302| 0|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 1138| 0| } 1139| | 1140| 1.04k| return item; 1141| | 1142| 928|fail: 1143| 928| if (item != NULL) ------------------ | Branch (1143:9): [True: 928, False: 0] ------------------ 1144| 928| { 1145| 928| cJSON_Delete(item); 1146| 928| } 1147| | 1148| 928| if (value != NULL) ------------------ | Branch (1148:9): [True: 928, False: 0] ------------------ 1149| 928| { 1150| 928| error local_error; 1151| 928| local_error.json = (const unsigned char*)value; 1152| 928| local_error.position = 0; 1153| | 1154| 928| if (buffer.offset < buffer.length) ------------------ | Branch (1154:13): [True: 818, False: 110] ------------------ 1155| 818| { 1156| 818| local_error.position = buffer.offset; 1157| 818| } 1158| 110| else if (buffer.length > 0) ------------------ | Branch (1158:18): [True: 110, False: 0] ------------------ 1159| 110| { 1160| 110| local_error.position = buffer.length - 1; 1161| 110| } 1162| | 1163| 928| if (return_parse_end != NULL) ------------------ | Branch (1163:13): [True: 0, False: 928] ------------------ 1164| 0| { 1165| 0| *return_parse_end = (const char*)local_error.json + local_error.position; 1166| 0| } 1167| | 1168| 928| global_error = local_error; 1169| 928| } 1170| | 1171| 928| return NULL; 1172| 1.08k|} cJSON_Print: 1253| 248|{ 1254| 248| return (char*)print(item, true, &global_hooks); ------------------ | | 65| 248|#define true ((cJSON_bool)1) ------------------ 1255| 248|} cJSON_PrintUnformatted: 1258| 258|{ 1259| 258| return (char*)print(item, false, &global_hooks); ------------------ | | 70| 258|#define false ((cJSON_bool)0) ------------------ 1260| 258|} cJSON_PrintBuffered: 1263| 537|{ 1264| 537| printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; 1265| | 1266| 537| if (prebuffer < 0) ------------------ | Branch (1266:9): [True: 0, False: 537] ------------------ 1267| 0| { 1268| 0| return NULL; 1269| 0| } 1270| | 1271| 537| p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); 1272| 537| if (!p.buffer) ------------------ | Branch (1272:9): [True: 0, False: 537] ------------------ 1273| 0| { 1274| 0| return NULL; 1275| 0| } 1276| | 1277| 537| p.length = (size_t)prebuffer; 1278| 537| p.offset = 0; 1279| 537| p.noalloc = false; ------------------ | | 70| 537|#define false ((cJSON_bool)0) ------------------ 1280| 537| p.format = fmt; 1281| 537| p.hooks = global_hooks; 1282| | 1283| 537| if (!print_value(item, &p)) ------------------ | Branch (1283:9): [True: 0, False: 537] ------------------ 1284| 0| { 1285| 0| global_hooks.deallocate(p.buffer); 1286| 0| return NULL; 1287| 0| } 1288| | 1289| 537| return (char*)p.buffer; 1290| 537|} cJSON_Minify: 2839| 793|{ 2840| 793| char *into = json; 2841| | 2842| 793| if (json == NULL) ------------------ | Branch (2842:9): [True: 0, False: 793] ------------------ 2843| 0| { 2844| 0| return; 2845| 0| } 2846| | 2847| 2.90M| while (json[0] != '\0') ------------------ | Branch (2847:12): [True: 2.90M, False: 793] ------------------ 2848| 2.90M| { 2849| 2.90M| switch (json[0]) 2850| 2.90M| { 2851| 199| case ' ': ------------------ | Branch (2851:13): [True: 199, False: 2.90M] ------------------ 2852| 934| case '\t': ------------------ | Branch (2852:13): [True: 735, False: 2.90M] ------------------ 2853| 1.13k| case '\r': ------------------ | Branch (2853:13): [True: 198, False: 2.90M] ------------------ 2854| 3.41k| case '\n': ------------------ | Branch (2854:13): [True: 2.28k, False: 2.90M] ------------------ 2855| 3.41k| json++; 2856| 3.41k| break; 2857| | 2858| 942| case '/': ------------------ | Branch (2858:13): [True: 942, False: 2.90M] ------------------ 2859| 942| if (json[1] == '/') ------------------ | Branch (2859:21): [True: 412, False: 530] ------------------ 2860| 412| { 2861| 412| skip_oneline_comment(&json); 2862| 412| } 2863| 530| else if (json[1] == '*') ------------------ | Branch (2863:26): [True: 239, False: 291] ------------------ 2864| 239| { 2865| 239| skip_multiline_comment(&json); 2866| 291| } else { 2867| 291| json++; 2868| 291| } 2869| 942| break; 2870| | 2871| 12.8k| case '\"': ------------------ | Branch (2871:13): [True: 12.8k, False: 2.89M] ------------------ 2872| 12.8k| minify_string(&json, (char**)&into); 2873| 12.8k| break; 2874| | 2875| 2.89M| default: ------------------ | Branch (2875:13): [True: 2.89M, False: 17.1k] ------------------ 2876| 2.89M| into[0] = json[0]; 2877| 2.89M| json++; 2878| 2.89M| into++; 2879| 2.90M| } 2880| 2.90M| } 2881| | 2882| | /* and null-terminate. */ 2883| 793| *into = '\0'; 2884| 793|} cJSON.c:cJSON_New_Item: 242| 868k|{ 243| 868k| cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); 244| 868k| if (node) ------------------ | Branch (244:9): [True: 868k, False: 0] ------------------ 245| 868k| { 246| 868k| memset(node, '\0', sizeof(cJSON)); 247| 868k| } 248| | 249| 868k| return node; 250| 868k|} cJSON.c:buffer_skip_whitespace: 1039| 2.56M|{ 1040| 2.56M| if ((buffer == NULL) || (buffer->content == NULL)) ------------------ | Branch (1040:9): [True: 0, False: 2.56M] | Branch (1040:29): [True: 0, False: 2.56M] ------------------ 1041| 0| { 1042| 0| return NULL; 1043| 0| } 1044| | 1045| 2.56M| if (cannot_access_at_index(buffer, 0)) ------------------ | | 300| 2.56M|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 2.56M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 2.56M, False: 0] | | | | | Branch (299:65): [True: 2.56M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1046| 0| { 1047| 0| return buffer; 1048| 0| } 1049| | 1050| 3.88M| while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 299| 7.77M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 3.88M, False: 0] | | | Branch (299:65): [True: 3.88M, False: 932] | | ------------------ ------------------ while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 302| 3.88M|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1050:46): [True: 1.32M, False: 2.56M] ------------------ 1051| 1.32M| { 1052| 1.32M| buffer->offset++; 1053| 1.32M| } 1054| | 1055| 2.56M| if (buffer->offset == buffer->length) ------------------ | Branch (1055:9): [True: 932, False: 2.56M] ------------------ 1056| 932| { 1057| 932| buffer->offset--; 1058| 932| } 1059| | 1060| 2.56M| return buffer; 1061| 2.56M|} cJSON.c:skip_utf8_bom: 1065| 1.97k|{ 1066| 1.97k| if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) ------------------ | Branch (1066:9): [True: 0, False: 1.97k] | Branch (1066:29): [True: 0, False: 1.97k] | Branch (1066:58): [True: 0, False: 1.97k] ------------------ 1067| 0| { 1068| 0| return NULL; 1069| 0| } 1070| | 1071| 1.97k| if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 299| 3.94k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 1.97k, False: 0] | | | Branch (299:65): [True: 1.67k, False: 297] | | ------------------ ------------------ if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 302| 1.67k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1071:43): [True: 80, False: 1.59k] ------------------ 1072| 80| { 1073| 80| buffer->offset += 3; 1074| 80| } 1075| | 1076| 1.97k| return buffer; 1077| 1.97k|} cJSON.c:print: 1188| 506|{ 1189| 506| static const size_t default_buffer_size = 256; 1190| 506| printbuffer buffer[1]; 1191| 506| unsigned char *printed = NULL; 1192| | 1193| 506| memset(buffer, 0, sizeof(buffer)); 1194| | 1195| | /* create buffer */ 1196| 506| buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); 1197| 506| buffer->length = default_buffer_size; 1198| 506| buffer->format = format; 1199| 506| buffer->hooks = *hooks; 1200| 506| if (buffer->buffer == NULL) ------------------ | Branch (1200:9): [True: 0, False: 506] ------------------ 1201| 0| { 1202| 0| goto fail; 1203| 0| } 1204| | 1205| | /* print the value */ 1206| 506| if (!print_value(item, buffer)) ------------------ | Branch (1206:9): [True: 0, False: 506] ------------------ 1207| 0| { 1208| 0| goto fail; 1209| 0| } 1210| 506| update_offset(buffer); 1211| | 1212| | /* check if reallocate is available */ 1213| 506| if (hooks->reallocate != NULL) ------------------ | Branch (1213:9): [True: 506, False: 0] ------------------ 1214| 506| { 1215| 506| printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); 1216| 506| if (printed == NULL) { ------------------ | Branch (1216:13): [True: 0, False: 506] ------------------ 1217| 0| goto fail; 1218| 0| } 1219| 506| buffer->buffer = NULL; 1220| 506| } 1221| 0| else /* otherwise copy the JSON over to a new buffer */ 1222| 0| { 1223| 0| printed = (unsigned char*) hooks->allocate(buffer->offset + 1); 1224| 0| if (printed == NULL) ------------------ | Branch (1224:13): [True: 0, False: 0] ------------------ 1225| 0| { 1226| 0| goto fail; 1227| 0| } 1228| 0| memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); ------------------ | | 1185| 0|#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (1185:26): [True: 0, False: 0] | | ------------------ ------------------ 1229| 0| printed[buffer->offset] = '\0'; /* just to be sure */ 1230| | 1231| | /* free the buffer */ 1232| 0| hooks->deallocate(buffer->buffer); 1233| 0| } 1234| | 1235| 506| return printed; 1236| | 1237| 0|fail: 1238| 0| if (buffer->buffer != NULL) ------------------ | Branch (1238:9): [True: 0, False: 0] ------------------ 1239| 0| { 1240| 0| hooks->deallocate(buffer->buffer); 1241| 0| } 1242| | 1243| 0| if (printed != NULL) ------------------ | Branch (1243:9): [True: 0, False: 0] ------------------ 1244| 0| { 1245| 0| hooks->deallocate(printed); 1246| 0| } 1247| | 1248| 0| return NULL; 1249| 506|} cJSON.c:update_offset: 526| 808k|{ 527| 808k| const unsigned char *buffer_pointer = NULL; 528| 808k| if ((buffer == NULL) || (buffer->buffer == NULL)) ------------------ | Branch (528:9): [True: 0, False: 808k] | Branch (528:29): [True: 0, False: 808k] ------------------ 529| 0| { 530| 0| return; 531| 0| } 532| 808k| buffer_pointer = buffer->buffer + buffer->offset; 533| | 534| 808k| buffer->offset += strlen((const char*)buffer_pointer); 535| 808k|} cJSON.c:parse_value: 1313| 867k|{ 1314| 867k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (1314:9): [True: 0, False: 867k] | Branch (1314:35): [True: 0, False: 867k] ------------------ 1315| 0| { 1316| 0| return false; /* no input */ ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1317| 0| } 1318| | 1319| | /* parse the different types of values */ 1320| | /* null */ 1321| 867k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 297| 1.73M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (297:33): [True: 867k, False: 0] | | | Branch (297:53): [True: 867k, False: 846] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 302| 867k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1321:38): [True: 841, False: 866k] ------------------ 1322| 841| { 1323| 841| item->type = cJSON_NULL; ------------------ | | 92| 841|#define cJSON_NULL (1 << 2) ------------------ 1324| 841| input_buffer->offset += 4; 1325| 841| return true; ------------------ | | 65| 841|#define true ((cJSON_bool)1) ------------------ 1326| 841| } 1327| | /* false */ 1328| 867k| if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 297| 1.73M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (297:33): [True: 867k, False: 0] | | | Branch (297:53): [True: 865k, False: 1.21k] | | ------------------ ------------------ if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 302| 865k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1328:38): [True: 375, False: 865k] ------------------ 1329| 375| { 1330| 375| item->type = cJSON_False; ------------------ | | 90| 375|#define cJSON_False (1 << 0) ------------------ 1331| 375| input_buffer->offset += 5; 1332| 375| return true; ------------------ | | 65| 375|#define true ((cJSON_bool)1) ------------------ 1333| 375| } 1334| | /* true */ 1335| 866k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 297| 1.73M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (297:33): [True: 866k, False: 0] | | | Branch (297:53): [True: 865k, False: 846] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 302| 865k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1335:38): [True: 287, False: 865k] ------------------ 1336| 287| { 1337| 287| item->type = cJSON_True; ------------------ | | 91| 287|#define cJSON_True (1 << 1) ------------------ 1338| 287| item->valueint = 1; 1339| 287| input_buffer->offset += 4; 1340| 287| return true; ------------------ | | 65| 287|#define true ((cJSON_bool)1) ------------------ 1341| 287| } 1342| | /* string */ 1343| 866k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 299| 1.73M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 866k, False: 0] | | | Branch (299:65): [True: 866k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 302| 866k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1343:49): [True: 13.0k, False: 853k] ------------------ 1344| 13.0k| { 1345| 13.0k| return parse_string(item, input_buffer); 1346| 13.0k| } 1347| | /* number */ 1348| 853k| 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')))) ------------------ | | 299| 1.70M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 853k, False: 0] | | | Branch (299:65): [True: 853k, 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')))) ------------------ | | 302| 853k|#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')))) ------------------ | | 302| 851k|#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')))) ------------------ | | 302| 851k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1348:50): [True: 1.68k, False: 851k] | Branch (1348:97): [True: 851k, False: 163] | Branch (1348:143): [True: 13.8k, False: 837k] ------------------ 1349| 15.5k| { 1350| 15.5k| return parse_number(item, input_buffer); 1351| 15.5k| } 1352| | /* array */ 1353| 837k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 299| 1.67M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 837k, False: 0] | | | Branch (299:65): [True: 837k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 302| 837k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1353:49): [True: 361k, False: 476k] ------------------ 1354| 361k| { 1355| 361k| return parse_array(item, input_buffer); 1356| 361k| } 1357| | /* object */ 1358| 476k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) ------------------ | | 299| 953k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 476k, False: 0] | | | Branch (299:65): [True: 476k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) ------------------ | | 302| 476k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1358:49): [True: 476k, False: 322] ------------------ 1359| 476k| { 1360| 476k| return parse_object(item, input_buffer); 1361| 476k| } 1362| | 1363| 322| return false; ------------------ | | 70| 322|#define false ((cJSON_bool)0) ------------------ 1364| 476k|} cJSON.c:parse_string: 774| 30.7k|{ 775| 30.7k| const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; ------------------ | | 302| 30.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 776| 30.7k| const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; ------------------ | | 302| 30.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 777| 30.7k| unsigned char *output_pointer = NULL; 778| 30.7k| unsigned char *output = NULL; 779| | 780| | /* not a string */ 781| 30.7k| if (buffer_at_offset(input_buffer)[0] != '\"') ------------------ | | 302| 30.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (781:9): [True: 133, False: 30.6k] ------------------ 782| 133| { 783| 133| goto fail; 784| 133| } 785| | 786| 30.6k| { 787| | /* calculate approximate size of the output (overestimate) */ 788| 30.6k| size_t allocation_length = 0; 789| 30.6k| size_t skipped_bytes = 0; 790| 27.1M| while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) ------------------ | Branch (790:16): [True: 27.1M, False: 71] | Branch (790:88): [True: 27.1M, False: 30.5k] ------------------ 791| 27.1M| { 792| | /* is escape sequence */ 793| 27.1M| if (input_end[0] == '\\') ------------------ | Branch (793:17): [True: 185k, False: 26.9M] ------------------ 794| 185k| { 795| 185k| if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) ------------------ | Branch (795:21): [True: 0, False: 185k] ------------------ 796| 0| { 797| | /* prevent buffer overflow when last input character is a backslash */ 798| 0| goto fail; 799| 0| } 800| 185k| skipped_bytes++; 801| 185k| input_end++; 802| 185k| } 803| 27.1M| input_end++; 804| 27.1M| } 805| 30.6k| if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) ------------------ | Branch (805:13): [True: 71, False: 30.5k] | Branch (805:86): [True: 0, False: 30.5k] ------------------ 806| 71| { 807| 71| goto fail; /* string ended unexpectedly */ 808| 71| } 809| | 810| | /* This is at most how much we need for the output */ 811| 30.5k| allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; ------------------ | | 302| 30.5k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 812| 30.5k| output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); 813| 30.5k| if (output == NULL) ------------------ | Branch (813:13): [True: 0, False: 30.5k] ------------------ 814| 0| { 815| 0| goto fail; /* allocation failure */ 816| 0| } 817| 30.5k| } 818| | 819| 30.5k| output_pointer = output; 820| | /* loop through the string literal */ 821| 22.2M| while (input_pointer < input_end) ------------------ | Branch (821:12): [True: 22.1M, False: 30.4k] ------------------ 822| 22.1M| { 823| 22.1M| if (*input_pointer != '\\') ------------------ | Branch (823:13): [True: 22.0M, False: 163k] ------------------ 824| 22.0M| { 825| 22.0M| *output_pointer++ = *input_pointer++; 826| 22.0M| } 827| | /* escape sequence */ 828| 163k| else 829| 163k| { 830| 163k| unsigned char sequence_length = 2; 831| 163k| if ((input_end - input_pointer) < 1) ------------------ | Branch (831:17): [True: 0, False: 163k] ------------------ 832| 0| { 833| 0| goto fail; 834| 0| } 835| | 836| 163k| switch (input_pointer[1]) 837| 163k| { 838| 10.5k| case 'b': ------------------ | Branch (838:17): [True: 10.5k, False: 152k] ------------------ 839| 10.5k| *output_pointer++ = '\b'; 840| 10.5k| break; 841| 3.95k| case 'f': ------------------ | Branch (841:17): [True: 3.95k, False: 159k] ------------------ 842| 3.95k| *output_pointer++ = '\f'; 843| 3.95k| break; 844| 7.70k| case 'n': ------------------ | Branch (844:17): [True: 7.70k, False: 155k] ------------------ 845| 7.70k| *output_pointer++ = '\n'; 846| 7.70k| break; 847| 10.7k| case 'r': ------------------ | Branch (847:17): [True: 10.7k, False: 152k] ------------------ 848| 10.7k| *output_pointer++ = '\r'; 849| 10.7k| break; 850| 6.05k| case 't': ------------------ | Branch (850:17): [True: 6.05k, False: 157k] ------------------ 851| 6.05k| *output_pointer++ = '\t'; 852| 6.05k| break; 853| 5.45k| case '\"': ------------------ | Branch (853:17): [True: 5.45k, False: 157k] ------------------ 854| 12.0k| case '\\': ------------------ | Branch (854:17): [True: 6.63k, False: 156k] ------------------ 855| 17.7k| case '/': ------------------ | Branch (855:17): [True: 5.69k, False: 157k] ------------------ 856| 17.7k| *output_pointer++ = input_pointer[1]; 857| 17.7k| break; 858| | 859| | /* UTF-16 literal */ 860| 106k| case 'u': ------------------ | Branch (860:17): [True: 106k, False: 56.8k] ------------------ 861| 106k| sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); 862| 106k| if (sequence_length == 0) ------------------ | Branch (862:25): [True: 124, False: 106k] ------------------ 863| 124| { 864| | /* failed to convert UTF16-literal to UTF-8 */ 865| 124| goto fail; 866| 124| } 867| 106k| break; 868| | 869| 106k| default: ------------------ | Branch (869:17): [True: 12, False: 163k] ------------------ 870| 12| goto fail; 871| 163k| } 872| 163k| input_pointer += sequence_length; 873| 163k| } 874| 22.1M| } 875| | 876| | /* zero terminate the output */ 877| 30.4k| *output_pointer = '\0'; 878| | 879| 30.4k| item->type = cJSON_String; ------------------ | | 94| 30.4k|#define cJSON_String (1 << 4) ------------------ 880| 30.4k| item->valuestring = (char*)output; 881| | 882| 30.4k| input_buffer->offset = (size_t) (input_end - input_buffer->content); 883| 30.4k| input_buffer->offset++; 884| | 885| 30.4k| return true; ------------------ | | 65| 30.4k|#define true ((cJSON_bool)1) ------------------ 886| | 887| 340|fail: 888| 340| if (output != NULL) ------------------ | Branch (888:9): [True: 136, False: 204] ------------------ 889| 136| { 890| 136| input_buffer->hooks.deallocate(output); 891| 136| } 892| | 893| 340| if (input_pointer != NULL) ------------------ | Branch (893:9): [True: 340, False: 0] ------------------ 894| 340| { 895| 340| input_buffer->offset = (size_t)(input_pointer - input_buffer->content); 896| 340| } 897| | 898| 340| return false; ------------------ | | 70| 340|#define false ((cJSON_bool)0) ------------------ 899| 30.5k|} cJSON.c:utf16_literal_to_utf8: 653| 106k|{ 654| 106k| long unsigned int codepoint = 0; 655| 106k| unsigned int first_code = 0; 656| 106k| const unsigned char *first_sequence = input_pointer; 657| 106k| unsigned char utf8_length = 0; 658| 106k| unsigned char utf8_position = 0; 659| 106k| unsigned char sequence_length = 0; 660| 106k| unsigned char first_byte_mark = 0; 661| | 662| 106k| if ((input_end - first_sequence) < 6) ------------------ | Branch (662:9): [True: 3, False: 106k] ------------------ 663| 3| { 664| | /* input ends unexpectedly */ 665| 3| goto fail; 666| 3| } 667| | 668| | /* get the first utf16 sequence */ 669| 106k| first_code = parse_hex4(first_sequence + 2); 670| | 671| | /* check that the code is valid */ 672| 106k| if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) ------------------ | Branch (672:10): [True: 1.03k, False: 105k] | Branch (672:36): [True: 15, False: 1.02k] ------------------ 673| 15| { 674| 15| goto fail; 675| 15| } 676| | 677| | /* UTF16 surrogate pair */ 678| 106k| if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) ------------------ | Branch (678:9): [True: 5.59k, False: 100k] | Branch (678:35): [True: 4.57k, False: 1.02k] ------------------ 679| 4.57k| { 680| 4.57k| const unsigned char *second_sequence = first_sequence + 6; 681| 4.57k| unsigned int second_code = 0; 682| 4.57k| sequence_length = 12; /* \uXXXX\uXXXX */ 683| | 684| 4.57k| if ((input_end - second_sequence) < 6) ------------------ | Branch (684:13): [True: 15, False: 4.55k] ------------------ 685| 15| { 686| | /* input ends unexpectedly */ 687| 15| goto fail; 688| 15| } 689| | 690| 4.55k| if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) ------------------ | Branch (690:13): [True: 15, False: 4.54k] | Branch (690:45): [True: 16, False: 4.52k] ------------------ 691| 31| { 692| | /* missing second half of the surrogate pair */ 693| 31| goto fail; 694| 31| } 695| | 696| | /* get the second utf16 sequence */ 697| 4.52k| second_code = parse_hex4(second_sequence + 2); 698| | /* check that the code is valid */ 699| 4.52k| if ((second_code < 0xDC00) || (second_code > 0xDFFF)) ------------------ | Branch (699:13): [True: 55, False: 4.47k] | Branch (699:39): [True: 5, False: 4.46k] ------------------ 700| 60| { 701| | /* invalid second half of the surrogate pair */ 702| 60| goto fail; 703| 60| } 704| | 705| | 706| | /* calculate the unicode codepoint from the surrogate pair */ 707| 4.46k| codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); 708| 4.46k| } 709| 101k| else 710| 101k| { 711| 101k| sequence_length = 6; /* \uXXXX */ 712| 101k| codepoint = first_code; 713| 101k| } 714| | 715| | /* encode as UTF-8 716| | * takes at maximum 4 bytes to encode: 717| | * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 718| 106k| if (codepoint < 0x80) ------------------ | Branch (718:9): [True: 32.2k, False: 74.0k] ------------------ 719| 32.2k| { 720| | /* normal ascii, encoding 0xxxxxxx */ 721| 32.2k| utf8_length = 1; 722| 32.2k| } 723| 74.0k| else if (codepoint < 0x800) ------------------ | Branch (723:14): [True: 33.3k, False: 40.7k] ------------------ 724| 33.3k| { 725| | /* two bytes, encoding 110xxxxx 10xxxxxx */ 726| 33.3k| utf8_length = 2; 727| 33.3k| first_byte_mark = 0xC0; /* 11000000 */ 728| 33.3k| } 729| 40.7k| else if (codepoint < 0x10000) ------------------ | Branch (729:14): [True: 36.2k, False: 4.46k] ------------------ 730| 36.2k| { 731| | /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ 732| 36.2k| utf8_length = 3; 733| 36.2k| first_byte_mark = 0xE0; /* 11100000 */ 734| 36.2k| } 735| 4.46k| else if (codepoint <= 0x10FFFF) ------------------ | Branch (735:14): [True: 4.46k, False: 0] ------------------ 736| 4.46k| { 737| | /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ 738| 4.46k| utf8_length = 4; 739| 4.46k| first_byte_mark = 0xF0; /* 11110000 */ 740| 4.46k| } 741| 0| else 742| 0| { 743| | /* invalid unicode codepoint */ 744| 0| goto fail; 745| 0| } 746| | 747| | /* encode as utf8 */ 748| 225k| for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) ------------------ | Branch (748:60): [True: 119k, False: 106k] ------------------ 749| 119k| { 750| | /* 10xxxxxx */ 751| 119k| (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); 752| 119k| codepoint >>= 6; 753| 119k| } 754| | /* encode first byte */ 755| 106k| if (utf8_length > 1) ------------------ | Branch (755:9): [True: 74.0k, False: 32.2k] ------------------ 756| 74.0k| { 757| 74.0k| (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); 758| 74.0k| } 759| 32.2k| else 760| 32.2k| { 761| 32.2k| (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); 762| 32.2k| } 763| | 764| 106k| *output_pointer += utf8_length; 765| | 766| 106k| return sequence_length; 767| | 768| 124|fail: 769| 124| return 0; 770| 106k|} cJSON.c:parse_hex4: 616| 110k|{ 617| 110k| unsigned int h = 0; 618| 110k| size_t i = 0; 619| | 620| 482k| for (i = 0; i < 4; i++) ------------------ | Branch (620:17): [True: 404k, False: 78.7k] ------------------ 621| 404k| { 622| | /* parse digit */ 623| 404k| if ((input[i] >= '0') && (input[i] <= '9')) ------------------ | Branch (623:13): [True: 399k, False: 4.93k] | Branch (623:34): [True: 218k, False: 180k] ------------------ 624| 218k| { 625| 218k| h += (unsigned int) input[i] - '0'; 626| 218k| } 627| 185k| else if ((input[i] >= 'A') && (input[i] <= 'F')) ------------------ | Branch (627:18): [True: 164k, False: 21.0k] | Branch (627:39): [True: 44.2k, False: 119k] ------------------ 628| 44.2k| { 629| 44.2k| h += (unsigned int) 10 + input[i] - 'A'; 630| 44.2k| } 631| 140k| else if ((input[i] >= 'a') && (input[i] <= 'f')) ------------------ | Branch (631:18): [True: 117k, False: 23.5k] | Branch (631:39): [True: 108k, False: 8.63k] ------------------ 632| 108k| { 633| 108k| h += (unsigned int) 10 + input[i] - 'a'; 634| 108k| } 635| 32.2k| else /* invalid */ 636| 32.2k| { 637| 32.2k| return 0; 638| 32.2k| } 639| | 640| 371k| if (i < 3) ------------------ | Branch (640:13): [True: 293k, False: 78.7k] ------------------ 641| 293k| { 642| | /* shift left to make place for the next nibble */ 643| 293k| h = h << 4; 644| 293k| } 645| 371k| } 646| | 647| 78.7k| return h; 648| 110k|} cJSON.c:parse_number: 306| 15.5k|{ 307| 15.5k| double number = 0; 308| 15.5k| unsigned char *after_end = NULL; 309| 15.5k| unsigned char number_c_string[64]; 310| 15.5k| unsigned char decimal_point = get_decimal_point(); 311| 15.5k| size_t i = 0; 312| | 313| 15.5k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (313:9): [True: 0, False: 15.5k] | Branch (313:35): [True: 0, False: 15.5k] ------------------ 314| 0| { 315| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 316| 0| } 317| | 318| | /* copy the number into a temporary buffer and replace '.' with the decimal point 319| | * of the current locale (for strtod) 320| | * This also takes care of '\0' not necessarily being available for marking the end of the input */ 321| 122k| for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) ------------------ | | 299| 122k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 122k, False: 0] | | | Branch (299:65): [True: 122k, False: 0] | | ------------------ ------------------ | Branch (321:17): [True: 122k, False: 352] ------------------ 322| 122k| { 323| 122k| switch (buffer_at_offset(input_buffer)[i]) ------------------ | | 302| 122k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 324| 122k| { 325| 15.8k| case '0': ------------------ | Branch (325:13): [True: 15.8k, False: 106k] ------------------ 326| 27.6k| case '1': ------------------ | Branch (326:13): [True: 11.7k, False: 110k] ------------------ 327| 36.3k| case '2': ------------------ | Branch (327:13): [True: 8.70k, False: 113k] ------------------ 328| 48.4k| case '3': ------------------ | Branch (328:13): [True: 12.1k, False: 110k] ------------------ 329| 59.1k| case '4': ------------------ | Branch (329:13): [True: 10.7k, False: 111k] ------------------ 330| 70.0k| case '5': ------------------ | Branch (330:13): [True: 10.8k, False: 111k] ------------------ 331| 80.0k| case '6': ------------------ | Branch (331:13): [True: 9.99k, False: 112k] ------------------ 332| 87.8k| case '7': ------------------ | Branch (332:13): [True: 7.78k, False: 114k] ------------------ 333| 96.0k| case '8': ------------------ | Branch (333:13): [True: 8.16k, False: 114k] ------------------ 334| 101k| case '9': ------------------ | Branch (334:13): [True: 5.72k, False: 116k] ------------------ 335| 101k| case '+': ------------------ | Branch (335:13): [True: 236, False: 122k] ------------------ 336| 103k| case '-': ------------------ | Branch (336:13): [True: 1.81k, False: 120k] ------------------ 337| 104k| case 'e': ------------------ | Branch (337:13): [True: 1.03k, False: 121k] ------------------ 338| 105k| case 'E': ------------------ | Branch (338:13): [True: 689, False: 121k] ------------------ 339| 105k| number_c_string[i] = buffer_at_offset(input_buffer)[i]; ------------------ | | 302| 105k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 340| 105k| break; 341| | 342| 1.64k| case '.': ------------------ | Branch (342:13): [True: 1.64k, False: 120k] ------------------ 343| 1.64k| number_c_string[i] = decimal_point; 344| 1.64k| break; 345| | 346| 15.2k| default: ------------------ | Branch (346:13): [True: 15.2k, False: 107k] ------------------ 347| 15.2k| goto loop_end; 348| 122k| } 349| 122k| } 350| 15.5k|loop_end: 351| 15.5k| number_c_string[i] = '\0'; 352| | 353| 15.5k| number = strtod((const char*)number_c_string, (char**)&after_end); 354| 15.5k| if (number_c_string == after_end) ------------------ | Branch (354:9): [True: 16, False: 15.5k] ------------------ 355| 16| { 356| 16| return false; /* parse_error */ ------------------ | | 70| 16|#define false ((cJSON_bool)0) ------------------ 357| 16| } 358| | 359| 15.5k| item->valuedouble = number; 360| | 361| | /* use saturation in case of overflow */ 362| 15.5k| if (number >= INT_MAX) ------------------ | Branch (362:9): [True: 2.28k, False: 13.2k] ------------------ 363| 2.28k| { 364| 2.28k| item->valueint = INT_MAX; 365| 2.28k| } 366| 13.2k| else if (number <= (double)INT_MIN) ------------------ | Branch (366:14): [True: 1.19k, False: 12.0k] ------------------ 367| 1.19k| { 368| 1.19k| item->valueint = INT_MIN; 369| 1.19k| } 370| 12.0k| else 371| 12.0k| { 372| 12.0k| item->valueint = (int)number; 373| 12.0k| } 374| | 375| 15.5k| item->type = cJSON_Number; ------------------ | | 93| 15.5k|#define cJSON_Number (1 << 3) ------------------ 376| | 377| 15.5k| input_buffer->offset += (size_t)(after_end - number_c_string); 378| 15.5k| return true; ------------------ | | 65| 15.5k|#define true ((cJSON_bool)1) ------------------ 379| 15.5k|} cJSON.c:get_decimal_point: 278| 23.6k|{ 279| 23.6k|#ifdef ENABLE_LOCALES 280| 23.6k| struct lconv *lconv = localeconv(); 281| 23.6k| return (unsigned char) lconv->decimal_point[0]; 282| |#else 283| | return '.'; 284| |#endif 285| 23.6k|} cJSON.c:parse_array: 1442| 361k|{ 1443| 361k| cJSON *head = NULL; /* head of the linked list */ 1444| 361k| cJSON *current_item = NULL; 1445| | 1446| 361k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 361k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1446:9): [True: 1, False: 361k] ------------------ 1447| 1| { 1448| 1| return false; /* to deeply nested */ ------------------ | | 70| 1|#define false ((cJSON_bool)0) ------------------ 1449| 1| } 1450| 361k| input_buffer->depth++; 1451| | 1452| 361k| if (buffer_at_offset(input_buffer)[0] != '[') ------------------ | | 302| 361k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1452:9): [True: 0, False: 361k] ------------------ 1453| 0| { 1454| | /* not an array */ 1455| 0| goto fail; 1456| 0| } 1457| | 1458| 361k| input_buffer->offset++; 1459| 361k| buffer_skip_whitespace(input_buffer); 1460| 361k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 299| 722k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 361k, False: 0] | | | Branch (299:65): [True: 361k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 302| 361k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1460:49): [True: 5.17k, False: 355k] ------------------ 1461| 5.17k| { 1462| | /* empty array */ 1463| 5.17k| goto success; 1464| 5.17k| } 1465| | 1466| | /* check if we skipped to the end of the buffer */ 1467| 355k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 300| 355k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 355k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 355k, False: 0] | | | | | Branch (299:65): [True: 355k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1468| 0| { 1469| 0| input_buffer->offset--; 1470| 0| goto fail; 1471| 0| } 1472| | 1473| | /* step back to character in front of the first element */ 1474| 355k| input_buffer->offset--; 1475| | /* loop through the comma separated array elements */ 1476| 355k| do 1477| 848k| { 1478| | /* allocate next item */ 1479| 848k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1480| 848k| if (new_item == NULL) ------------------ | Branch (1480:13): [True: 0, False: 848k] ------------------ 1481| 0| { 1482| 0| goto fail; /* allocation failure */ 1483| 0| } 1484| | 1485| | /* attach next item to list */ 1486| 848k| if (head == NULL) ------------------ | Branch (1486:13): [True: 355k, False: 492k] ------------------ 1487| 355k| { 1488| | /* start the linked list */ 1489| 355k| current_item = head = new_item; 1490| 355k| } 1491| 492k| else 1492| 492k| { 1493| | /* add to the end and advance */ 1494| 492k| current_item->next = new_item; 1495| 492k| new_item->prev = current_item; 1496| 492k| current_item = new_item; 1497| 492k| } 1498| | 1499| | /* parse next value */ 1500| 848k| input_buffer->offset++; 1501| 848k| buffer_skip_whitespace(input_buffer); 1502| 848k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1502:13): [True: 44.2k, False: 804k] ------------------ 1503| 44.2k| { 1504| 44.2k| goto fail; /* failed to parse value */ 1505| 44.2k| } 1506| 804k| buffer_skip_whitespace(input_buffer); 1507| 804k| } 1508| 804k| while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 299| 1.60M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 804k, False: 0] | | | Branch (299:65): [True: 804k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 302| 804k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1508:52): [True: 492k, False: 311k] ------------------ 1509| | 1510| 311k| if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 300| 623k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 311k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 311k, False: 0] | | | | | Branch (299:65): [True: 311k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 302| 311k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1510:52): [True: 130, False: 311k] ------------------ 1511| 130| { 1512| 130| goto fail; /* expected end of array */ 1513| 130| } 1514| | 1515| 316k|success: 1516| 316k| input_buffer->depth--; 1517| | 1518| 316k| if (head != NULL) { ------------------ | Branch (1518:9): [True: 311k, False: 5.17k] ------------------ 1519| 311k| head->prev = current_item; 1520| 311k| } 1521| | 1522| 316k| item->type = cJSON_Array; ------------------ | | 95| 316k|#define cJSON_Array (1 << 5) ------------------ 1523| 316k| item->child = head; 1524| | 1525| 316k| input_buffer->offset++; 1526| | 1527| 316k| return true; ------------------ | | 65| 316k|#define true ((cJSON_bool)1) ------------------ 1528| | 1529| 44.4k|fail: 1530| 44.4k| if (head != NULL) ------------------ | Branch (1530:9): [True: 44.4k, False: 0] ------------------ 1531| 44.4k| { 1532| 44.4k| cJSON_Delete(head); 1533| 44.4k| } 1534| | 1535| 44.4k| return false; ------------------ | | 70| 44.4k|#define false ((cJSON_bool)0) ------------------ 1536| 311k|} cJSON.c:parse_object: 1602| 476k|{ 1603| 476k| cJSON *head = NULL; /* linked list head */ 1604| 476k| cJSON *current_item = NULL; 1605| | 1606| 476k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 476k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1606:9): [True: 1, False: 476k] ------------------ 1607| 1| { 1608| 1| return false; /* to deeply nested */ ------------------ | | 70| 1|#define false ((cJSON_bool)0) ------------------ 1609| 1| } 1610| 476k| input_buffer->depth++; 1611| | 1612| 476k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) ------------------ | | 300| 952k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 476k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 476k, False: 0] | | | | | Branch (299:65): [True: 476k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) ------------------ | | 302| 476k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1612:52): [True: 0, False: 476k] ------------------ 1613| 0| { 1614| 0| goto fail; /* not an object */ 1615| 0| } 1616| | 1617| 476k| input_buffer->offset++; 1618| 476k| buffer_skip_whitespace(input_buffer); 1619| 476k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) ------------------ | | 299| 952k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 476k, False: 0] | | | Branch (299:65): [True: 476k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) ------------------ | | 302| 476k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1619:49): [True: 465k, False: 10.4k] ------------------ 1620| 465k| { 1621| 465k| goto success; /* empty object */ 1622| 465k| } 1623| | 1624| | /* check if we skipped to the end of the buffer */ 1625| 10.4k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 300| 10.4k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 10.4k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 10.4k, False: 0] | | | | | Branch (299:65): [True: 10.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1626| 0| { 1627| 0| input_buffer->offset--; 1628| 0| goto fail; 1629| 0| } 1630| | 1631| | /* step back to character in front of the first element */ 1632| 10.4k| input_buffer->offset--; 1633| | /* loop through the comma separated array elements */ 1634| 10.4k| do 1635| 17.7k| { 1636| | /* allocate next item */ 1637| 17.7k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1638| 17.7k| if (new_item == NULL) ------------------ | Branch (1638:13): [True: 0, False: 17.7k] ------------------ 1639| 0| { 1640| 0| goto fail; /* allocation failure */ 1641| 0| } 1642| | 1643| | /* attach next item to list */ 1644| 17.7k| if (head == NULL) ------------------ | Branch (1644:13): [True: 10.4k, False: 7.36k] ------------------ 1645| 10.4k| { 1646| | /* start the linked list */ 1647| 10.4k| current_item = head = new_item; 1648| 10.4k| } 1649| 7.36k| else 1650| 7.36k| { 1651| | /* add to the end and advance */ 1652| 7.36k| current_item->next = new_item; 1653| 7.36k| new_item->prev = current_item; 1654| 7.36k| current_item = new_item; 1655| 7.36k| } 1656| | 1657| | /* parse the name of the child */ 1658| 17.7k| input_buffer->offset++; 1659| 17.7k| buffer_skip_whitespace(input_buffer); 1660| 17.7k| if (!parse_string(current_item, input_buffer)) ------------------ | Branch (1660:13): [True: 137, False: 17.6k] ------------------ 1661| 137| { 1662| 137| goto fail; /* failed to parse name */ 1663| 137| } 1664| 17.6k| buffer_skip_whitespace(input_buffer); 1665| | 1666| | /* swap valuestring and string, because we parsed the name */ 1667| 17.6k| current_item->string = current_item->valuestring; 1668| 17.6k| current_item->valuestring = NULL; 1669| | 1670| 17.6k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 300| 35.2k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 17.6k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 17.6k, False: 0] | | | | | Branch (299:65): [True: 17.6k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 302| 17.6k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1670:56): [True: 33, False: 17.6k] ------------------ 1671| 33| { 1672| 33| goto fail; /* invalid object */ 1673| 33| } 1674| | 1675| | /* parse the value */ 1676| 17.6k| input_buffer->offset++; 1677| 17.6k| buffer_skip_whitespace(input_buffer); 1678| 17.6k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1678:13): [True: 758, False: 16.8k] ------------------ 1679| 758| { 1680| 758| goto fail; /* failed to parse value */ 1681| 758| } 1682| 16.8k| buffer_skip_whitespace(input_buffer); 1683| 16.8k| } 1684| 16.8k| while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 299| 33.6k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 16.8k, False: 0] | | | Branch (299:65): [True: 16.8k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 302| 16.8k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1684:52): [True: 7.36k, False: 9.48k] ------------------ 1685| | 1686| 9.48k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 300| 18.9k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 9.48k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 9.48k, False: 0] | | | | | Branch (299:65): [True: 9.48k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 302| 9.48k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1686:52): [True: 41, False: 9.44k] ------------------ 1687| 41| { 1688| 41| goto fail; /* expected end of object */ 1689| 41| } 1690| | 1691| 475k|success: 1692| 475k| input_buffer->depth--; 1693| | 1694| 475k| if (head != NULL) { ------------------ | Branch (1694:9): [True: 9.44k, False: 465k] ------------------ 1695| 9.44k| head->prev = current_item; 1696| 9.44k| } 1697| | 1698| 475k| item->type = cJSON_Object; ------------------ | | 96| 475k|#define cJSON_Object (1 << 6) ------------------ 1699| 475k| item->child = head; 1700| | 1701| 475k| input_buffer->offset++; 1702| 475k| return true; ------------------ | | 65| 475k|#define true ((cJSON_bool)1) ------------------ 1703| | 1704| 969|fail: 1705| 969| if (head != NULL) ------------------ | Branch (1705:9): [True: 969, False: 0] ------------------ 1706| 969| { 1707| 969| cJSON_Delete(head); 1708| 969| } 1709| | 1710| 969| return false; ------------------ | | 70| 969|#define false ((cJSON_bool)0) ------------------ 1711| 9.48k|} cJSON.c:print_value: 1368| 798k|{ 1369| 798k| unsigned char *output = NULL; 1370| | 1371| 798k| if ((item == NULL) || (output_buffer == NULL)) ------------------ | Branch (1371:9): [True: 0, False: 798k] | Branch (1371:27): [True: 0, False: 798k] ------------------ 1372| 0| { 1373| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1374| 0| } 1375| | 1376| 798k| switch ((item->type) & 0xFF) 1377| 798k| { 1378| 648| case cJSON_NULL: ------------------ | | 92| 648|#define cJSON_NULL (1 << 2) ------------------ | Branch (1378:9): [True: 648, False: 798k] ------------------ 1379| 648| output = ensure(output_buffer, 5); 1380| 648| if (output == NULL) ------------------ | Branch (1380:17): [True: 0, False: 648] ------------------ 1381| 0| { 1382| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1383| 0| } 1384| 648| strcpy((char*)output, "null"); 1385| 648| return true; ------------------ | | 65| 648|#define true ((cJSON_bool)1) ------------------ 1386| | 1387| 308| case cJSON_False: ------------------ | | 90| 308|#define cJSON_False (1 << 0) ------------------ | Branch (1387:9): [True: 308, False: 798k] ------------------ 1388| 308| output = ensure(output_buffer, 6); 1389| 308| if (output == NULL) ------------------ | Branch (1389:17): [True: 0, False: 308] ------------------ 1390| 0| { 1391| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1392| 0| } 1393| 308| strcpy((char*)output, "false"); 1394| 308| return true; ------------------ | | 65| 308|#define true ((cJSON_bool)1) ------------------ 1395| | 1396| 220| case cJSON_True: ------------------ | | 91| 220|#define cJSON_True (1 << 1) ------------------ | Branch (1396:9): [True: 220, False: 798k] ------------------ 1397| 220| output = ensure(output_buffer, 5); 1398| 220| if (output == NULL) ------------------ | Branch (1398:17): [True: 0, False: 220] ------------------ 1399| 0| { 1400| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1401| 0| } 1402| 220| strcpy((char*)output, "true"); 1403| 220| return true; ------------------ | | 65| 220|#define true ((cJSON_bool)1) ------------------ 1404| | 1405| 8.05k| case cJSON_Number: ------------------ | | 93| 8.05k|#define cJSON_Number (1 << 3) ------------------ | Branch (1405:9): [True: 8.05k, False: 790k] ------------------ 1406| 8.05k| return print_number(item, output_buffer); 1407| | 1408| 0| case cJSON_Raw: ------------------ | | 97| 0|#define cJSON_Raw (1 << 7) /* raw json */ ------------------ | Branch (1408:9): [True: 0, False: 798k] ------------------ 1409| 0| { 1410| 0| size_t raw_length = 0; 1411| 0| if (item->valuestring == NULL) ------------------ | Branch (1411:17): [True: 0, False: 0] ------------------ 1412| 0| { 1413| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1414| 0| } 1415| | 1416| 0| raw_length = strlen(item->valuestring) + sizeof(""); 1417| 0| output = ensure(output_buffer, raw_length); 1418| 0| if (output == NULL) ------------------ | Branch (1418:17): [True: 0, False: 0] ------------------ 1419| 0| { 1420| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1421| 0| } 1422| 0| memcpy(output, item->valuestring, raw_length); 1423| 0| return true; ------------------ | | 65| 0|#define true ((cJSON_bool)1) ------------------ 1424| 0| } 1425| | 1426| 1.40k| case cJSON_String: ------------------ | | 94| 1.40k|#define cJSON_String (1 << 4) ------------------ | Branch (1426:9): [True: 1.40k, False: 797k] ------------------ 1427| 1.40k| return print_string(item, output_buffer); 1428| | 1429| 316k| case cJSON_Array: ------------------ | | 95| 316k|#define cJSON_Array (1 << 5) ------------------ | Branch (1429:9): [True: 316k, False: 482k] ------------------ 1430| 316k| return print_array(item, output_buffer); 1431| | 1432| 471k| case cJSON_Object: ------------------ | | 96| 471k|#define cJSON_Object (1 << 6) ------------------ | Branch (1432:9): [True: 471k, False: 327k] ------------------ 1433| 471k| return print_object(item, output_buffer); 1434| | 1435| 0| default: ------------------ | Branch (1435:9): [True: 0, False: 798k] ------------------ 1436| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1437| 798k| } 1438| 798k|} cJSON.c:ensure: 440| 2.10M|{ 441| 2.10M| unsigned char *newbuffer = NULL; 442| 2.10M| size_t newsize = 0; 443| | 444| 2.10M| if ((p == NULL) || (p->buffer == NULL)) ------------------ | Branch (444:9): [True: 0, False: 2.10M] | Branch (444:24): [True: 0, False: 2.10M] ------------------ 445| 0| { 446| 0| return NULL; 447| 0| } 448| | 449| 2.10M| if ((p->length > 0) && (p->offset >= p->length)) ------------------ | Branch (449:9): [True: 2.10M, False: 0] | Branch (449:28): [True: 0, False: 2.10M] ------------------ 450| 0| { 451| | /* make sure that offset is valid */ 452| 0| return NULL; 453| 0| } 454| | 455| 2.10M| if (needed > INT_MAX) ------------------ | Branch (455:9): [True: 0, False: 2.10M] ------------------ 456| 0| { 457| | /* sizes bigger than INT_MAX are currently not supported */ 458| 0| return NULL; 459| 0| } 460| | 461| 2.10M| needed += p->offset + 1; 462| 2.10M| if (needed <= p->length) ------------------ | Branch (462:9): [True: 2.10M, False: 1.52k] ------------------ 463| 2.10M| { 464| 2.10M| return p->buffer + p->offset; 465| 2.10M| } 466| | 467| 1.52k| if (p->noalloc) { ------------------ | Branch (467:9): [True: 0, False: 1.52k] ------------------ 468| 0| return NULL; 469| 0| } 470| | 471| | /* calculate new buffer size */ 472| 1.52k| if (needed > (INT_MAX / 2)) ------------------ | Branch (472:9): [True: 0, False: 1.52k] ------------------ 473| 0| { 474| | /* overflow of int, use INT_MAX if possible */ 475| 0| if (needed <= INT_MAX) ------------------ | Branch (475:13): [True: 0, False: 0] ------------------ 476| 0| { 477| 0| newsize = INT_MAX; 478| 0| } 479| 0| else 480| 0| { 481| 0| return NULL; 482| 0| } 483| 0| } 484| 1.52k| else 485| 1.52k| { 486| 1.52k| newsize = needed * 2; 487| 1.52k| } 488| | 489| 1.52k| if (p->hooks.reallocate != NULL) ------------------ | Branch (489:9): [True: 1.52k, False: 0] ------------------ 490| 1.52k| { 491| | /* reallocate with realloc if available */ 492| 1.52k| newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); 493| 1.52k| if (newbuffer == NULL) ------------------ | Branch (493:13): [True: 0, False: 1.52k] ------------------ 494| 0| { 495| 0| p->hooks.deallocate(p->buffer); 496| 0| p->length = 0; 497| 0| p->buffer = NULL; 498| | 499| 0| return NULL; 500| 0| } 501| 1.52k| } 502| 0| else 503| 0| { 504| | /* otherwise reallocate manually */ 505| 0| newbuffer = (unsigned char*)p->hooks.allocate(newsize); 506| 0| if (!newbuffer) ------------------ | Branch (506:13): [True: 0, False: 0] ------------------ 507| 0| { 508| 0| p->hooks.deallocate(p->buffer); 509| 0| p->length = 0; 510| 0| p->buffer = NULL; 511| | 512| 0| return NULL; 513| 0| } 514| | 515| 0| memcpy(newbuffer, p->buffer, p->offset + 1); 516| 0| p->hooks.deallocate(p->buffer); 517| 0| } 518| 1.52k| p->length = newsize; 519| 1.52k| p->buffer = newbuffer; 520| | 521| 1.52k| return newbuffer + p->offset; 522| 1.52k|} cJSON.c:print_number: 546| 8.05k|{ 547| 8.05k| unsigned char *output_pointer = NULL; 548| 8.05k| double d = item->valuedouble; 549| 8.05k| int length = 0; 550| 8.05k| size_t i = 0; 551| 8.05k| unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ 552| 8.05k| unsigned char decimal_point = get_decimal_point(); 553| 8.05k| double test = 0.0; 554| | 555| 8.05k| if (output_buffer == NULL) ------------------ | Branch (555:9): [True: 0, False: 8.05k] ------------------ 556| 0| { 557| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 558| 0| } 559| | 560| | /* This checks for NaN and Infinity */ 561| 8.05k| if (isnan(d) || isinf(d)) ------------------ | | 77| 16.1k|#define isnan(d) (d != d) | | ------------------ | | | Branch (77:18): [True: 0, False: 8.05k] | | ------------------ ------------------ if (isnan(d) || isinf(d)) ------------------ | | 74| 8.05k|#define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 16.1k|#define isnan(d) (d != d) | | | | ------------------ | | | | | Branch (77:18): [True: 462, False: 7.59k] | | | | ------------------ | | ------------------ | | #define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 462|#define isnan(d) (d != d) | | ------------------ | | | Branch (74:37): [True: 462, False: 0] | | ------------------ ------------------ 562| 462| { 563| 462| length = sprintf((char*)number_buffer, "null"); 564| 462| } 565| 7.59k| else if(d == (double)item->valueint) ------------------ | Branch (565:10): [True: 6.16k, False: 1.43k] ------------------ 566| 6.16k| { 567| 6.16k| length = sprintf((char*)number_buffer, "%d", item->valueint); 568| 6.16k| } 569| 1.43k| else 570| 1.43k| { 571| | /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ 572| 1.43k| length = sprintf((char*)number_buffer, "%1.15g", d); 573| | 574| | /* Check whether the original double can be recovered */ 575| 1.43k| if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) ------------------ | Branch (575:13): [True: 0, False: 1.43k] | Branch (575:66): [True: 685, False: 748] ------------------ 576| 685| { 577| | /* If not, print with 17 decimal places of precision */ 578| 685| length = sprintf((char*)number_buffer, "%1.17g", d); 579| 685| } 580| 1.43k| } 581| | 582| | /* sprintf failed or buffer overrun occurred */ 583| 8.05k| if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) ------------------ | Branch (583:9): [True: 0, False: 8.05k] | Branch (583:25): [True: 0, False: 8.05k] ------------------ 584| 0| { 585| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 586| 0| } 587| | 588| | /* reserve appropriate space in the output */ 589| 8.05k| output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); 590| 8.05k| if (output_pointer == NULL) ------------------ | Branch (590:9): [True: 0, False: 8.05k] ------------------ 591| 0| { 592| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 593| 0| } 594| | 595| | /* copy the printed number to the output and replace locale 596| | * dependent decimal point with '.' */ 597| 37.2k| for (i = 0; i < ((size_t)length); i++) ------------------ | Branch (597:17): [True: 29.1k, False: 8.05k] ------------------ 598| 29.1k| { 599| 29.1k| if (number_buffer[i] == decimal_point) ------------------ | Branch (599:13): [True: 992, False: 28.1k] ------------------ 600| 992| { 601| 992| output_pointer[i] = '.'; 602| 992| continue; 603| 992| } 604| | 605| 28.1k| output_pointer[i] = number_buffer[i]; 606| 28.1k| } 607| 8.05k| output_pointer[i] = '\0'; 608| | 609| 8.05k| output_buffer->offset += (size_t)length; 610| | 611| 8.05k| return true; ------------------ | | 65| 8.05k|#define true ((cJSON_bool)1) ------------------ 612| 8.05k|} cJSON.c:print_string: 1025| 1.40k|{ 1026| 1.40k| return print_string_ptr((unsigned char*)item->valuestring, p); 1027| 1.40k|} cJSON.c:print_string_ptr: 903| 11.9k|{ 904| 11.9k| const unsigned char *input_pointer = NULL; 905| 11.9k| unsigned char *output = NULL; 906| 11.9k| unsigned char *output_pointer = NULL; 907| 11.9k| size_t output_length = 0; 908| | /* numbers of additional characters needed for escaping */ 909| 11.9k| size_t escape_characters = 0; 910| | 911| 11.9k| if (output_buffer == NULL) ------------------ | Branch (911:9): [True: 0, False: 11.9k] ------------------ 912| 0| { 913| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 914| 0| } 915| | 916| | /* empty string */ 917| 11.9k| if (input == NULL) ------------------ | Branch (917:9): [True: 0, False: 11.9k] ------------------ 918| 0| { 919| 0| output = ensure(output_buffer, sizeof("\"\"")); 920| 0| if (output == NULL) ------------------ | Branch (920:13): [True: 0, False: 0] ------------------ 921| 0| { 922| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 923| 0| } 924| 0| strcpy((char*)output, "\"\""); 925| | 926| 0| return true; ------------------ | | 65| 0|#define true ((cJSON_bool)1) ------------------ 927| 0| } 928| | 929| | /* set "flag" to 1 if something needs to be escaped */ 930| 9.82M| for (input_pointer = input; *input_pointer; input_pointer++) ------------------ | Branch (930:33): [True: 9.80M, False: 11.9k] ------------------ 931| 9.80M| { 932| 9.80M| switch (*input_pointer) 933| 9.80M| { 934| 612| case '\"': ------------------ | Branch (934:13): [True: 612, False: 9.80M] ------------------ 935| 3.73k| case '\\': ------------------ | Branch (935:13): [True: 3.12k, False: 9.80M] ------------------ 936| 4.45k| case '\b': ------------------ | Branch (936:13): [True: 719, False: 9.80M] ------------------ 937| 5.40k| case '\f': ------------------ | Branch (937:13): [True: 952, False: 9.80M] ------------------ 938| 11.4k| case '\n': ------------------ | Branch (938:13): [True: 6.04k, False: 9.80M] ------------------ 939| 28.3k| case '\r': ------------------ | Branch (939:13): [True: 16.9k, False: 9.79M] ------------------ 940| 29.7k| case '\t': ------------------ | Branch (940:13): [True: 1.35k, False: 9.80M] ------------------ 941| | /* one character escape sequence */ 942| 29.7k| escape_characters++; 943| 29.7k| break; 944| 9.77M| default: ------------------ | Branch (944:13): [True: 9.77M, False: 29.7k] ------------------ 945| 9.77M| if (*input_pointer < 32) ------------------ | Branch (945:21): [True: 9.23M, False: 542k] ------------------ 946| 9.23M| { 947| | /* UTF-16 escape sequence uXXXX */ 948| 9.23M| escape_characters += 5; 949| 9.23M| } 950| 9.77M| break; 951| 9.80M| } 952| 9.80M| } 953| 11.9k| output_length = (size_t)(input_pointer - input) + escape_characters; 954| | 955| 11.9k| output = ensure(output_buffer, output_length + sizeof("\"\"")); 956| 11.9k| if (output == NULL) ------------------ | Branch (956:9): [True: 0, False: 11.9k] ------------------ 957| 0| { 958| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 959| 0| } 960| | 961| | /* no characters have to be escaped */ 962| 11.9k| if (escape_characters == 0) ------------------ | Branch (962:9): [True: 11.0k, False: 870] ------------------ 963| 11.0k| { 964| 11.0k| output[0] = '\"'; 965| 11.0k| memcpy(output + 1, input, output_length); 966| 11.0k| output[output_length + 1] = '\"'; 967| 11.0k| output[output_length + 2] = '\0'; 968| | 969| 11.0k| return true; ------------------ | | 65| 11.0k|#define true ((cJSON_bool)1) ------------------ 970| 11.0k| } 971| | 972| 870| output[0] = '\"'; 973| 870| output_pointer = output + 1; 974| | /* copy the string */ 975| 9.79M| for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) ------------------ | Branch (975:33): [True: 9.79M, False: 870] ------------------ 976| 9.79M| { 977| 9.79M| if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) ------------------ | Branch (977:13): [True: 535k, False: 9.26M] | Branch (977:38): [True: 534k, False: 612] | Branch (977:66): [True: 531k, False: 3.12k] ------------------ 978| 531k| { 979| | /* normal character, copy */ 980| 531k| *output_pointer = *input_pointer; 981| 531k| } 982| 9.26M| else 983| 9.26M| { 984| | /* character needs to be escaped */ 985| 9.26M| *output_pointer++ = '\\'; 986| 9.26M| switch (*input_pointer) 987| 9.26M| { 988| 3.12k| case '\\': ------------------ | Branch (988:17): [True: 3.12k, False: 9.26M] ------------------ 989| 3.12k| *output_pointer = '\\'; 990| 3.12k| break; 991| 612| case '\"': ------------------ | Branch (991:17): [True: 612, False: 9.26M] ------------------ 992| 612| *output_pointer = '\"'; 993| 612| break; 994| 719| case '\b': ------------------ | Branch (994:17): [True: 719, False: 9.26M] ------------------ 995| 719| *output_pointer = 'b'; 996| 719| break; 997| 952| case '\f': ------------------ | Branch (997:17): [True: 952, False: 9.26M] ------------------ 998| 952| *output_pointer = 'f'; 999| 952| break; 1000| 6.04k| case '\n': ------------------ | Branch (1000:17): [True: 6.04k, False: 9.25M] ------------------ 1001| 6.04k| *output_pointer = 'n'; 1002| 6.04k| break; 1003| 16.9k| case '\r': ------------------ | Branch (1003:17): [True: 16.9k, False: 9.24M] ------------------ 1004| 16.9k| *output_pointer = 'r'; 1005| 16.9k| break; 1006| 1.35k| case '\t': ------------------ | Branch (1006:17): [True: 1.35k, False: 9.26M] ------------------ 1007| 1.35k| *output_pointer = 't'; 1008| 1.35k| break; 1009| 9.23M| default: ------------------ | Branch (1009:17): [True: 9.23M, False: 29.7k] ------------------ 1010| | /* escape and print as unicode codepoint */ 1011| 9.23M| sprintf((char*)output_pointer, "u%04x", *input_pointer); 1012| 9.23M| output_pointer += 4; 1013| 9.23M| break; 1014| 9.26M| } 1015| 9.26M| } 1016| 9.79M| } 1017| 870| output[output_length + 1] = '\"'; 1018| 870| output[output_length + 2] = '\0'; 1019| | 1020| 870| return true; ------------------ | | 65| 870|#define true ((cJSON_bool)1) ------------------ 1021| 870|} cJSON.c:print_array: 1540| 316k|{ 1541| 316k| unsigned char *output_pointer = NULL; 1542| 316k| size_t length = 0; 1543| 316k| cJSON *current_element = item->child; 1544| | 1545| 316k| if (output_buffer == NULL) ------------------ | Branch (1545:9): [True: 0, False: 316k] ------------------ 1546| 0| { 1547| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1548| 0| } 1549| | 1550| | /* Compose the output array. */ 1551| | /* opening square bracket */ 1552| 316k| output_pointer = ensure(output_buffer, 1); 1553| 316k| if (output_pointer == NULL) ------------------ | Branch (1553:9): [True: 0, False: 316k] ------------------ 1554| 0| { 1555| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1556| 0| } 1557| | 1558| 316k| *output_pointer = '['; 1559| 316k| output_buffer->offset++; 1560| 316k| output_buffer->depth++; 1561| | 1562| 1.10M| while (current_element != NULL) ------------------ | Branch (1562:12): [True: 787k, False: 316k] ------------------ 1563| 787k| { 1564| 787k| if (!print_value(current_element, output_buffer)) ------------------ | Branch (1564:13): [True: 0, False: 787k] ------------------ 1565| 0| { 1566| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1567| 0| } 1568| 787k| update_offset(output_buffer); 1569| 787k| if (current_element->next) ------------------ | Branch (1569:13): [True: 475k, False: 311k] ------------------ 1570| 475k| { 1571| 475k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1571:32): [True: 473k, False: 2.83k] ------------------ 1572| 475k| output_pointer = ensure(output_buffer, length + 1); 1573| 475k| if (output_pointer == NULL) ------------------ | Branch (1573:17): [True: 0, False: 475k] ------------------ 1574| 0| { 1575| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1576| 0| } 1577| 475k| *output_pointer++ = ','; 1578| 475k| if(output_buffer->format) ------------------ | Branch (1578:16): [True: 473k, False: 2.83k] ------------------ 1579| 473k| { 1580| 473k| *output_pointer++ = ' '; 1581| 473k| } 1582| 475k| *output_pointer = '\0'; 1583| 475k| output_buffer->offset += length; 1584| 475k| } 1585| 787k| current_element = current_element->next; 1586| 787k| } 1587| | 1588| 316k| output_pointer = ensure(output_buffer, 2); 1589| 316k| if (output_pointer == NULL) ------------------ | Branch (1589:9): [True: 0, False: 316k] ------------------ 1590| 0| { 1591| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1592| 0| } 1593| 316k| *output_pointer++ = ']'; 1594| 316k| *output_pointer = '\0'; 1595| 316k| output_buffer->depth--; 1596| | 1597| 316k| return true; ------------------ | | 65| 316k|#define true ((cJSON_bool)1) ------------------ 1598| 316k|} cJSON.c:print_object: 1715| 471k|{ 1716| 471k| unsigned char *output_pointer = NULL; 1717| 471k| size_t length = 0; 1718| 471k| cJSON *current_item = item->child; 1719| | 1720| 471k| if (output_buffer == NULL) ------------------ | Branch (1720:9): [True: 0, False: 471k] ------------------ 1721| 0| { 1722| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1723| 0| } 1724| | 1725| | /* Compose the output: */ 1726| 471k| length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ ------------------ | Branch (1726:24): [True: 471k, False: 399] ------------------ 1727| 471k| output_pointer = ensure(output_buffer, length + 1); 1728| 471k| if (output_pointer == NULL) ------------------ | Branch (1728:9): [True: 0, False: 471k] ------------------ 1729| 0| { 1730| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1731| 0| } 1732| | 1733| 471k| *output_pointer++ = '{'; 1734| 471k| output_buffer->depth++; 1735| 471k| if (output_buffer->format) ------------------ | Branch (1735:9): [True: 471k, False: 399] ------------------ 1736| 471k| { 1737| 471k| *output_pointer++ = '\n'; 1738| 471k| } 1739| 471k| output_buffer->offset += length; 1740| | 1741| 482k| while (current_item) ------------------ | Branch (1741:12): [True: 10.5k, False: 471k] ------------------ 1742| 10.5k| { 1743| 10.5k| if (output_buffer->format) ------------------ | Branch (1743:13): [True: 10.1k, False: 393] ------------------ 1744| 10.1k| { 1745| 10.1k| size_t i; 1746| 10.1k| output_pointer = ensure(output_buffer, output_buffer->depth); 1747| 10.1k| if (output_pointer == NULL) ------------------ | Branch (1747:17): [True: 0, False: 10.1k] ------------------ 1748| 0| { 1749| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1750| 0| } 1751| 4.24M| for (i = 0; i < output_buffer->depth; i++) ------------------ | Branch (1751:25): [True: 4.23M, False: 10.1k] ------------------ 1752| 4.23M| { 1753| 4.23M| *output_pointer++ = '\t'; 1754| 4.23M| } 1755| 10.1k| output_buffer->offset += output_buffer->depth; 1756| 10.1k| } 1757| | 1758| | /* print key */ 1759| 10.5k| if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) ------------------ | Branch (1759:13): [True: 0, False: 10.5k] ------------------ 1760| 0| { 1761| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1762| 0| } 1763| 10.5k| update_offset(output_buffer); 1764| | 1765| 10.5k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1765:28): [True: 10.1k, False: 393] ------------------ 1766| 10.5k| output_pointer = ensure(output_buffer, length); 1767| 10.5k| if (output_pointer == NULL) ------------------ | Branch (1767:13): [True: 0, False: 10.5k] ------------------ 1768| 0| { 1769| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1770| 0| } 1771| 10.5k| *output_pointer++ = ':'; 1772| 10.5k| if (output_buffer->format) ------------------ | Branch (1772:13): [True: 10.1k, False: 393] ------------------ 1773| 10.1k| { 1774| 10.1k| *output_pointer++ = '\t'; 1775| 10.1k| } 1776| 10.5k| output_buffer->offset += length; 1777| | 1778| | /* print value */ 1779| 10.5k| if (!print_value(current_item, output_buffer)) ------------------ | Branch (1779:13): [True: 0, False: 10.5k] ------------------ 1780| 0| { 1781| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1782| 0| } 1783| 10.5k| update_offset(output_buffer); 1784| | 1785| | /* print comma if not last */ 1786| 10.5k| length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); ------------------ | Branch (1786:28): [True: 10.1k, False: 393] | Branch (1786:70): [True: 2.63k, False: 7.92k] ------------------ 1787| 10.5k| output_pointer = ensure(output_buffer, length + 1); 1788| 10.5k| if (output_pointer == NULL) ------------------ | Branch (1788:13): [True: 0, False: 10.5k] ------------------ 1789| 0| { 1790| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1791| 0| } 1792| 10.5k| if (current_item->next) ------------------ | Branch (1792:13): [True: 2.63k, False: 7.92k] ------------------ 1793| 2.63k| { 1794| 2.63k| *output_pointer++ = ','; 1795| 2.63k| } 1796| | 1797| 10.5k| if (output_buffer->format) ------------------ | Branch (1797:13): [True: 10.1k, False: 393] ------------------ 1798| 10.1k| { 1799| 10.1k| *output_pointer++ = '\n'; 1800| 10.1k| } 1801| 10.5k| *output_pointer = '\0'; 1802| 10.5k| output_buffer->offset += length; 1803| | 1804| 10.5k| current_item = current_item->next; 1805| 10.5k| } 1806| | 1807| 471k| output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); ------------------ | Branch (1807:44): [True: 471k, False: 399] ------------------ 1808| 471k| if (output_pointer == NULL) ------------------ | Branch (1808:9): [True: 0, False: 471k] ------------------ 1809| 0| { 1810| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1811| 0| } 1812| 471k| if (output_buffer->format) ------------------ | Branch (1812:9): [True: 471k, False: 399] ------------------ 1813| 471k| { 1814| 471k| size_t i; 1815| 242M| for (i = 0; i < (output_buffer->depth - 1); i++) ------------------ | Branch (1815:21): [True: 242M, False: 471k] ------------------ 1816| 242M| { 1817| 242M| *output_pointer++ = '\t'; 1818| 242M| } 1819| 471k| } 1820| 471k| *output_pointer++ = '}'; 1821| 471k| *output_pointer = '\0'; 1822| 471k| output_buffer->depth--; 1823| | 1824| 471k| return true; ------------------ | | 65| 471k|#define true ((cJSON_bool)1) ------------------ 1825| 471k|} cJSON.c:skip_oneline_comment: 2790| 412|{ 2791| 412| *input += static_strlen("//"); ------------------ | | 184| 412|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2792| | 2793| 2.39k| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2793:12): [True: 2.37k, False: 20] ------------------ 2794| 2.37k| { 2795| 2.37k| if ((*input)[0] == '\n') { ------------------ | Branch (2795:13): [True: 392, False: 1.97k] ------------------ 2796| 392| *input += static_strlen("\n"); ------------------ | | 184| 392|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2797| 392| return; 2798| 392| } 2799| 2.37k| } 2800| 412|} cJSON.c:skip_multiline_comment: 2803| 239|{ 2804| 239| *input += static_strlen("/*"); ------------------ | | 184| 239|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2805| | 2806| 852| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2806:12): [True: 807, False: 45] ------------------ 2807| 807| { 2808| 807| if (((*input)[0] == '*') && ((*input)[1] == '/')) ------------------ | Branch (2808:13): [True: 416, False: 391] | Branch (2808:37): [True: 194, False: 222] ------------------ 2809| 194| { 2810| 194| *input += static_strlen("*/"); ------------------ | | 184| 194|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2811| 194| return; 2812| 194| } 2813| 807| } 2814| 239|} cJSON.c:minify_string: 2816| 12.8k|static void minify_string(char **input, char **output) { 2817| 12.8k| (*output)[0] = (*input)[0]; 2818| 12.8k| *input += static_strlen("\""); ------------------ | | 184| 12.8k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2819| 12.8k| *output += static_strlen("\""); ------------------ | | 184| 12.8k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2820| | 2821| | 2822| 10.0M| for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { ------------------ | Branch (2822:12): [True: 10.0M, False: 37] ------------------ 2823| 10.0M| (*output)[0] = (*input)[0]; 2824| | 2825| 10.0M| if ((*input)[0] == '\"') { ------------------ | Branch (2825:13): [True: 12.7k, False: 10.0M] ------------------ 2826| 12.7k| (*output)[0] = '\"'; 2827| 12.7k| *input += static_strlen("\""); ------------------ | | 184| 12.7k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2828| 12.7k| *output += static_strlen("\""); ------------------ | | 184| 12.7k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2829| 12.7k| return; 2830| 10.0M| } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { ------------------ | Branch (2830:20): [True: 27.0k, False: 10.0M] | Branch (2830:45): [True: 1.55k, False: 25.4k] ------------------ 2831| 1.55k| (*output)[1] = (*input)[1]; 2832| 1.55k| *input += static_strlen("\""); ------------------ | | 184| 1.55k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2833| 1.55k| *output += static_strlen("\""); ------------------ | | 184| 1.55k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2834| 1.55k| } 2835| 10.0M| } 2836| 12.8k|} cJSON.c:compare_double: 539| 1.43k|{ 540| 1.43k| double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); ------------------ | Branch (540:21): [True: 402, False: 1.03k] ------------------ 541| 1.43k| return (fabs(a - b) <= maxVal * DBL_EPSILON); 542| 1.43k|} 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.03k] ------------------ 23| 2.03k| if(data[size-1] != '\0') return 0; ------------------ | Branch (23:8): [True: 10, False: 2.02k] ------------------ 24| 2.02k| if(data[0] != '1' && data[0] != '0') return 0; ------------------ | Branch (24:8): [True: 542, False: 1.48k] | Branch (24:26): [True: 14, False: 528] ------------------ 25| 2.01k| if(data[1] != '1' && data[1] != '0') return 0; ------------------ | Branch (25:8): [True: 1.34k, False: 664] | Branch (25:26): [True: 12, False: 1.33k] ------------------ 26| 1.99k| if(data[2] != '1' && data[2] != '0') return 0; ------------------ | Branch (26:8): [True: 1.01k, False: 983] | Branch (26:26): [True: 15, False: 1.00k] ------------------ 27| 1.98k| if(data[3] != '1' && data[3] != '0') return 0; ------------------ | Branch (27:8): [True: 1.01k, False: 974] | Branch (27:26): [True: 13, False: 997] ------------------ 28| | 29| 1.97k| minify = data[0] == '1' ? 1 : 0; ------------------ | Branch (29:27): [True: 1.45k, False: 513] ------------------ 30| 1.97k| require_termination = data[1] == '1' ? 1 : 0; ------------------ | Branch (30:27): [True: 652, False: 1.31k] ------------------ 31| 1.97k| formatted = data[2] == '1' ? 1 : 0; ------------------ | Branch (31:27): [True: 976, False: 995] ------------------ 32| 1.97k| buffered = data[3] == '1' ? 1 : 0; ------------------ | Branch (32:27): [True: 974, False: 997] ------------------ 33| | 34| 1.97k| json = cJSON_ParseWithOpts((const char*)data + offset, NULL, require_termination); 35| | 36| 1.97k| if(json == NULL) return 0; ------------------ | Branch (36:8): [True: 928, False: 1.04k] ------------------ 37| | 38| 1.04k| if(buffered) ------------------ | Branch (38:8): [True: 537, False: 506] ------------------ 39| 537| { 40| 537| printed_json = cJSON_PrintBuffered(json, 1, formatted); 41| 537| } 42| 506| else 43| 506| { 44| | /* unbuffered printing */ 45| 506| if(formatted) ------------------ | Branch (45:12): [True: 248, False: 258] ------------------ 46| 248| { 47| 248| printed_json = cJSON_Print(json); 48| 248| } 49| 258| else 50| 258| { 51| 258| printed_json = cJSON_PrintUnformatted(json); 52| 258| } 53| 506| } 54| | 55| 1.04k| if(printed_json != NULL) free(printed_json); ------------------ | Branch (55:8): [True: 1.04k, False: 0] ------------------ 56| | 57| 1.04k| if(minify) ------------------ | Branch (57:8): [True: 793, False: 250] ------------------ 58| 793| { 59| 793| copied = (unsigned char*)malloc(size); 60| 793| if(copied == NULL) return 0; ------------------ | Branch (60:12): [True: 0, False: 793] ------------------ 61| | 62| 793| memcpy(copied, data, size); 63| | 64| 793| cJSON_Minify((char*)copied + offset); 65| | 66| 793| free(copied); 67| 793| } 68| | 69| 1.04k| cJSON_Delete(json); 70| | 71| 1.04k| return 0; 72| 1.04k|}