cJSON_Delete: 254| 393k|{ 255| 393k| cJSON *next = NULL; 256| 1.32M| while (item != NULL) ------------------ | Branch (256:12): [True: 935k, False: 393k] ------------------ 257| 935k| { 258| 935k| next = item->next; 259| 935k| if (!(item->type & cJSON_IsReference) && (item->child != NULL)) ------------------ | | 99| 935k|#define cJSON_IsReference 256 ------------------ | Branch (259:13): [True: 935k, False: 0] | Branch (259:50): [True: 346k, False: 589k] ------------------ 260| 346k| { 261| 346k| cJSON_Delete(item->child); 262| 346k| } 263| 935k| if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) ------------------ | | 99| 935k|#define cJSON_IsReference 256 ------------------ | Branch (263:13): [True: 935k, False: 0] | Branch (263:50): [True: 11.8k, False: 923k] ------------------ 264| 11.8k| { 265| 11.8k| global_hooks.deallocate(item->valuestring); 266| 11.8k| } 267| 935k| if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) ------------------ | | 100| 935k|#define cJSON_StringIsConst 512 ------------------ | Branch (267:13): [True: 935k, False: 0] | Branch (267:52): [True: 21.5k, False: 914k] ------------------ 268| 21.5k| { 269| 21.5k| global_hooks.deallocate(item->string); 270| 21.5k| } 271| 935k| global_hooks.deallocate(item); 272| 935k| item = next; 273| 935k| } 274| 393k|} cJSON_ParseWithOpts: 1080| 1.99k|{ 1081| 1.99k| size_t buffer_length; 1082| | 1083| 1.99k| if (NULL == value) ------------------ | Branch (1083:9): [True: 0, False: 1.99k] ------------------ 1084| 0| { 1085| 0| return NULL; 1086| 0| } 1087| | 1088| | /* Adding null character size due to require_null_terminated. */ 1089| 1.99k| buffer_length = strlen(value) + sizeof(""); 1090| | 1091| 1.99k| return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); 1092| 1.99k|} cJSON_ParseWithLengthOpts: 1096| 1.99k|{ 1097| 1.99k| parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; 1098| 1.99k| cJSON *item = NULL; 1099| | 1100| | /* reset error position */ 1101| 1.99k| global_error.json = NULL; 1102| 1.99k| global_error.position = 0; 1103| | 1104| 1.99k| if (value == NULL || 0 == buffer_length) ------------------ | Branch (1104:9): [True: 0, False: 1.99k] | Branch (1104:26): [True: 0, False: 1.99k] ------------------ 1105| 0| { 1106| 0| goto fail; 1107| 0| } 1108| | 1109| 1.99k| buffer.content = (const unsigned char*)value; 1110| 1.99k| buffer.length = buffer_length; 1111| 1.99k| buffer.offset = 0; 1112| 1.99k| buffer.hooks = global_hooks; 1113| | 1114| 1.99k| item = cJSON_New_Item(&global_hooks); 1115| 1.99k| if (item == NULL) /* memory fail */ ------------------ | Branch (1115:9): [True: 0, False: 1.99k] ------------------ 1116| 0| { 1117| 0| goto fail; 1118| 0| } 1119| | 1120| 1.99k| if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) ------------------ | Branch (1120:9): [True: 902, False: 1.09k] ------------------ 1121| 902| { 1122| | /* parse failure. ep is set. */ 1123| 902| goto fail; 1124| 902| } 1125| | 1126| | /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ 1127| 1.09k| if (require_null_terminated) ------------------ | Branch (1127:9): [True: 379, False: 711] ------------------ 1128| 379| { 1129| 379| buffer_skip_whitespace(&buffer); 1130| 379| if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') ------------------ | | 302| 379|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1130:13): [True: 0, False: 379] | Branch (1130:49): [True: 44, False: 335] ------------------ 1131| 44| { 1132| 44| goto fail; 1133| 44| } 1134| 379| } 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| 946|fail: 1143| 946| if (item != NULL) ------------------ | Branch (1143:9): [True: 946, False: 0] ------------------ 1144| 946| { 1145| 946| cJSON_Delete(item); 1146| 946| } 1147| | 1148| 946| if (value != NULL) ------------------ | Branch (1148:9): [True: 946, False: 0] ------------------ 1149| 946| { 1150| 946| error local_error; 1151| 946| local_error.json = (const unsigned char*)value; 1152| 946| local_error.position = 0; 1153| | 1154| 946| if (buffer.offset < buffer.length) ------------------ | Branch (1154:13): [True: 830, False: 116] ------------------ 1155| 830| { 1156| 830| local_error.position = buffer.offset; 1157| 830| } 1158| 116| else if (buffer.length > 0) ------------------ | Branch (1158:18): [True: 116, False: 0] ------------------ 1159| 116| { 1160| 116| local_error.position = buffer.length - 1; 1161| 116| } 1162| | 1163| 946| if (return_parse_end != NULL) ------------------ | Branch (1163:13): [True: 0, False: 946] ------------------ 1164| 0| { 1165| 0| *return_parse_end = (const char*)local_error.json + local_error.position; 1166| 0| } 1167| | 1168| 946| global_error = local_error; 1169| 946| } 1170| | 1171| 946| return NULL; 1172| 1.09k|} cJSON_Print: 1253| 263|{ 1254| 263| return (char*)print(item, true, &global_hooks); ------------------ | | 65| 263|#define true ((cJSON_bool)1) ------------------ 1255| 263|} cJSON_PrintUnformatted: 1258| 241|{ 1259| 241| return (char*)print(item, false, &global_hooks); ------------------ | | 70| 241|#define false ((cJSON_bool)0) ------------------ 1260| 241|} cJSON_PrintBuffered: 1263| 542|{ 1264| 542| printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; 1265| | 1266| 542| if (prebuffer < 0) ------------------ | Branch (1266:9): [True: 0, False: 542] ------------------ 1267| 0| { 1268| 0| return NULL; 1269| 0| } 1270| | 1271| 542| p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); 1272| 542| if (!p.buffer) ------------------ | Branch (1272:9): [True: 0, False: 542] ------------------ 1273| 0| { 1274| 0| return NULL; 1275| 0| } 1276| | 1277| 542| p.length = (size_t)prebuffer; 1278| 542| p.offset = 0; 1279| 542| p.noalloc = false; ------------------ | | 70| 542|#define false ((cJSON_bool)0) ------------------ 1280| 542| p.format = fmt; 1281| 542| p.hooks = global_hooks; 1282| | 1283| 542| if (!print_value(item, &p)) ------------------ | Branch (1283:9): [True: 0, False: 542] ------------------ 1284| 0| { 1285| 0| global_hooks.deallocate(p.buffer); 1286| 0| return NULL; 1287| 0| } 1288| | 1289| 542| return (char*)p.buffer; 1290| 542|} cJSON_Minify: 2839| 754|{ 2840| 754| char *into = json; 2841| | 2842| 754| if (json == NULL) ------------------ | Branch (2842:9): [True: 0, False: 754] ------------------ 2843| 0| { 2844| 0| return; 2845| 0| } 2846| | 2847| 2.28M| while (json[0] != '\0') ------------------ | Branch (2847:12): [True: 2.28M, False: 754] ------------------ 2848| 2.28M| { 2849| 2.28M| switch (json[0]) 2850| 2.28M| { 2851| 196| case ' ': ------------------ | Branch (2851:13): [True: 196, False: 2.28M] ------------------ 2852| 584| case '\t': ------------------ | Branch (2852:13): [True: 388, False: 2.28M] ------------------ 2853| 786| case '\r': ------------------ | Branch (2853:13): [True: 202, False: 2.28M] ------------------ 2854| 2.91k| case '\n': ------------------ | Branch (2854:13): [True: 2.13k, False: 2.28M] ------------------ 2855| 2.91k| json++; 2856| 2.91k| break; 2857| | 2858| 858| case '/': ------------------ | Branch (2858:13): [True: 858, False: 2.28M] ------------------ 2859| 858| if (json[1] == '/') ------------------ | Branch (2859:21): [True: 334, False: 524] ------------------ 2860| 334| { 2861| 334| skip_oneline_comment(&json); 2862| 334| } 2863| 524| else if (json[1] == '*') ------------------ | Branch (2863:26): [True: 238, False: 286] ------------------ 2864| 238| { 2865| 238| skip_multiline_comment(&json); 2866| 286| } else { 2867| 286| json++; 2868| 286| } 2869| 858| break; 2870| | 2871| 7.24k| case '\"': ------------------ | Branch (2871:13): [True: 7.24k, False: 2.28M] ------------------ 2872| 7.24k| minify_string(&json, (char**)&into); 2873| 7.24k| break; 2874| | 2875| 2.27M| default: ------------------ | Branch (2875:13): [True: 2.27M, False: 11.0k] ------------------ 2876| 2.27M| into[0] = json[0]; 2877| 2.27M| json++; 2878| 2.27M| into++; 2879| 2.28M| } 2880| 2.28M| } 2881| | 2882| | /* and null-terminate. */ 2883| 754| *into = '\0'; 2884| 754|} cJSON.c:cJSON_New_Item: 242| 935k|{ 243| 935k| cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); 244| 935k| if (node) ------------------ | Branch (244:9): [True: 935k, False: 0] ------------------ 245| 935k| { 246| 935k| memset(node, '\0', sizeof(cJSON)); 247| 935k| } 248| | 249| 935k| return node; 250| 935k|} cJSON.c:buffer_skip_whitespace: 1039| 2.77M|{ 1040| 2.77M| if ((buffer == NULL) || (buffer->content == NULL)) ------------------ | Branch (1040:9): [True: 0, False: 2.77M] | Branch (1040:29): [True: 0, False: 2.77M] ------------------ 1041| 0| { 1042| 0| return NULL; 1043| 0| } 1044| | 1045| 2.77M| if (cannot_access_at_index(buffer, 0)) ------------------ | | 300| 2.77M|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 2.77M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 2.77M, False: 0] | | | | | Branch (299:65): [True: 2.77M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1046| 0| { 1047| 0| return buffer; 1048| 0| } 1049| | 1050| 3.96M| while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 299| 7.92M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 3.96M, False: 0] | | | Branch (299:65): [True: 3.96M, False: 930] | | ------------------ ------------------ while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) ------------------ | | 302| 3.96M|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1050:46): [True: 1.19M, False: 2.77M] ------------------ 1051| 1.19M| { 1052| 1.19M| buffer->offset++; 1053| 1.19M| } 1054| | 1055| 2.77M| if (buffer->offset == buffer->length) ------------------ | Branch (1055:9): [True: 930, False: 2.77M] ------------------ 1056| 930| { 1057| 930| buffer->offset--; 1058| 930| } 1059| | 1060| 2.77M| return buffer; 1061| 2.77M|} cJSON.c:skip_utf8_bom: 1065| 1.99k|{ 1066| 1.99k| if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) ------------------ | Branch (1066:9): [True: 0, False: 1.99k] | Branch (1066:29): [True: 0, False: 1.99k] | Branch (1066:58): [True: 0, False: 1.99k] ------------------ 1067| 0| { 1068| 0| return NULL; 1069| 0| } 1070| | 1071| 1.99k| if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 299| 3.98k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 1.99k, False: 0] | | | Branch (299:65): [True: 1.69k, False: 299] | | ------------------ ------------------ if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) ------------------ | | 302| 1.69k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1071:43): [True: 101, False: 1.59k] ------------------ 1072| 101| { 1073| 101| buffer->offset += 3; 1074| 101| } 1075| | 1076| 1.99k| return buffer; 1077| 1.99k|} cJSON.c:print: 1188| 504|{ 1189| 504| static const size_t default_buffer_size = 256; 1190| 504| printbuffer buffer[1]; 1191| 504| unsigned char *printed = NULL; 1192| | 1193| 504| memset(buffer, 0, sizeof(buffer)); 1194| | 1195| | /* create buffer */ 1196| 504| buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); 1197| 504| buffer->length = default_buffer_size; 1198| 504| buffer->format = format; 1199| 504| buffer->hooks = *hooks; 1200| 504| if (buffer->buffer == NULL) ------------------ | Branch (1200:9): [True: 0, False: 504] ------------------ 1201| 0| { 1202| 0| goto fail; 1203| 0| } 1204| | 1205| | /* print the value */ 1206| 504| if (!print_value(item, buffer)) ------------------ | Branch (1206:9): [True: 0, False: 504] ------------------ 1207| 0| { 1208| 0| goto fail; 1209| 0| } 1210| 504| update_offset(buffer); 1211| | 1212| | /* check if reallocate is available */ 1213| 504| if (hooks->reallocate != NULL) ------------------ | Branch (1213:9): [True: 504, False: 0] ------------------ 1214| 504| { 1215| 504| printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); 1216| 504| if (printed == NULL) { ------------------ | Branch (1216:13): [True: 0, False: 504] ------------------ 1217| 0| goto fail; 1218| 0| } 1219| 504| buffer->buffer = NULL; 1220| 504| } 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| 504| 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| 504|} cJSON.c:update_offset: 526| 868k|{ 527| 868k| const unsigned char *buffer_pointer = NULL; 528| 868k| if ((buffer == NULL) || (buffer->buffer == NULL)) ------------------ | Branch (528:9): [True: 0, False: 868k] | Branch (528:29): [True: 0, False: 868k] ------------------ 529| 0| { 530| 0| return; 531| 0| } 532| 868k| buffer_pointer = buffer->buffer + buffer->offset; 533| | 534| 868k| buffer->offset += strlen((const char*)buffer_pointer); 535| 868k|} cJSON.c:parse_value: 1313| 935k|{ 1314| 935k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (1314:9): [True: 0, False: 935k] | Branch (1314:35): [True: 0, False: 935k] ------------------ 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| 935k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 297| 1.87M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (297:33): [True: 935k, False: 0] | | | Branch (297:53): [True: 934k, False: 845] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) ------------------ | | 302| 934k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1321:38): [True: 638, False: 933k] ------------------ 1322| 638| { 1323| 638| item->type = cJSON_NULL; ------------------ | | 92| 638|#define cJSON_NULL (1 << 2) ------------------ 1324| 638| input_buffer->offset += 4; 1325| 638| return true; ------------------ | | 65| 638|#define true ((cJSON_bool)1) ------------------ 1326| 638| } 1327| | /* false */ 1328| 934k| if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 297| 1.86M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (297:33): [True: 934k, False: 0] | | | Branch (297:53): [True: 933k, False: 1.23k] | | ------------------ ------------------ if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) ------------------ | | 302| 933k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1328:38): [True: 306, False: 933k] ------------------ 1329| 306| { 1330| 306| item->type = cJSON_False; ------------------ | | 90| 306|#define cJSON_False (1 << 0) ------------------ 1331| 306| input_buffer->offset += 5; 1332| 306| return true; ------------------ | | 65| 306|#define true ((cJSON_bool)1) ------------------ 1333| 306| } 1334| | /* true */ 1335| 934k| if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 297| 1.86M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) | | ------------------ | | | Branch (297:33): [True: 934k, False: 0] | | | Branch (297:53): [True: 933k, False: 845] | | ------------------ ------------------ if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) ------------------ | | 302| 933k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1335:38): [True: 300, False: 933k] ------------------ 1336| 300| { 1337| 300| item->type = cJSON_True; ------------------ | | 91| 300|#define cJSON_True (1 << 1) ------------------ 1338| 300| item->valueint = 1; 1339| 300| input_buffer->offset += 4; 1340| 300| return true; ------------------ | | 65| 300|#define true ((cJSON_bool)1) ------------------ 1341| 300| } 1342| | /* string */ 1343| 934k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 299| 1.86M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 934k, False: 0] | | | Branch (299:65): [True: 934k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) ------------------ | | 302| 934k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1343:49): [True: 12.0k, False: 922k] ------------------ 1344| 12.0k| { 1345| 12.0k| return parse_string(item, input_buffer); 1346| 12.0k| } 1347| | /* number */ 1348| 922k| 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.84M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 922k, False: 0] | | | Branch (299:65): [True: 922k, 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| 922k|#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| 921k|#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| 920k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1348:50): [True: 1.05k, False: 921k] | Branch (1348:97): [True: 920k, False: 150] | Branch (1348:143): [True: 15.2k, False: 905k] ------------------ 1349| 16.2k| { 1350| 16.2k| return parse_number(item, input_buffer); 1351| 16.2k| } 1352| | /* array */ 1353| 905k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 299| 1.81M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 905k, False: 0] | | | Branch (299:65): [True: 905k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) ------------------ | | 302| 905k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1353:49): [True: 388k, False: 517k] ------------------ 1354| 388k| { 1355| 388k| return parse_array(item, input_buffer); 1356| 388k| } 1357| | /* object */ 1358| 517k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) ------------------ | | 299| 1.03M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 517k, False: 0] | | | Branch (299:65): [True: 517k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) ------------------ | | 302| 517k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1358:49): [True: 516k, False: 317] ------------------ 1359| 516k| { 1360| 516k| return parse_object(item, input_buffer); 1361| 516k| } 1362| | 1363| 317| return false; ------------------ | | 70| 317|#define false ((cJSON_bool)0) ------------------ 1364| 517k|} cJSON.c:parse_string: 774| 33.7k|{ 775| 33.7k| const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; ------------------ | | 302| 33.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 776| 33.7k| const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; ------------------ | | 302| 33.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 777| 33.7k| unsigned char *output_pointer = NULL; 778| 33.7k| unsigned char *output = NULL; 779| | 780| | /* not a string */ 781| 33.7k| if (buffer_at_offset(input_buffer)[0] != '\"') ------------------ | | 302| 33.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (781:9): [True: 140, False: 33.5k] ------------------ 782| 140| { 783| 140| goto fail; 784| 140| } 785| | 786| 33.5k| { 787| | /* calculate approximate size of the output (overestimate) */ 788| 33.5k| size_t allocation_length = 0; 789| 33.5k| size_t skipped_bytes = 0; 790| 25.5M| while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) ------------------ | Branch (790:16): [True: 25.5M, False: 80] | Branch (790:88): [True: 25.5M, False: 33.4k] ------------------ 791| 25.5M| { 792| | /* is escape sequence */ 793| 25.5M| if (input_end[0] == '\\') ------------------ | Branch (793:17): [True: 167k, False: 25.3M] ------------------ 794| 167k| { 795| 167k| if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) ------------------ | Branch (795:21): [True: 0, False: 167k] ------------------ 796| 0| { 797| | /* prevent buffer overflow when last input character is a backslash */ 798| 0| goto fail; 799| 0| } 800| 167k| skipped_bytes++; 801| 167k| input_end++; 802| 167k| } 803| 25.5M| input_end++; 804| 25.5M| } 805| 33.5k| if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) ------------------ | Branch (805:13): [True: 80, False: 33.4k] | Branch (805:86): [True: 0, False: 33.4k] ------------------ 806| 80| { 807| 80| goto fail; /* string ended unexpectedly */ 808| 80| } 809| | 810| | /* This is at most how much we need for the output */ 811| 33.4k| allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; ------------------ | | 302| 33.4k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 812| 33.4k| output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); 813| 33.4k| if (output == NULL) ------------------ | Branch (813:13): [True: 0, False: 33.4k] ------------------ 814| 0| { 815| 0| goto fail; /* allocation failure */ 816| 0| } 817| 33.4k| } 818| | 819| 33.4k| output_pointer = output; 820| | /* loop through the string literal */ 821| 23.8M| while (input_pointer < input_end) ------------------ | Branch (821:12): [True: 23.8M, False: 33.3k] ------------------ 822| 23.8M| { 823| 23.8M| if (*input_pointer != '\\') ------------------ | Branch (823:13): [True: 23.6M, False: 145k] ------------------ 824| 23.6M| { 825| 23.6M| *output_pointer++ = *input_pointer++; 826| 23.6M| } 827| | /* escape sequence */ 828| 145k| else 829| 145k| { 830| 145k| unsigned char sequence_length = 2; 831| 145k| if ((input_end - input_pointer) < 1) ------------------ | Branch (831:17): [True: 0, False: 145k] ------------------ 832| 0| { 833| 0| goto fail; 834| 0| } 835| | 836| 145k| switch (input_pointer[1]) 837| 145k| { 838| 10.1k| case 'b': ------------------ | Branch (838:17): [True: 10.1k, False: 135k] ------------------ 839| 10.1k| *output_pointer++ = '\b'; 840| 10.1k| break; 841| 18.8k| case 'f': ------------------ | Branch (841:17): [True: 18.8k, False: 126k] ------------------ 842| 18.8k| *output_pointer++ = '\f'; 843| 18.8k| break; 844| 8.89k| case 'n': ------------------ | Branch (844:17): [True: 8.89k, False: 136k] ------------------ 845| 8.89k| *output_pointer++ = '\n'; 846| 8.89k| break; 847| 19.4k| case 'r': ------------------ | Branch (847:17): [True: 19.4k, False: 126k] ------------------ 848| 19.4k| *output_pointer++ = '\r'; 849| 19.4k| break; 850| 7.98k| case 't': ------------------ | Branch (850:17): [True: 7.98k, False: 137k] ------------------ 851| 7.98k| *output_pointer++ = '\t'; 852| 7.98k| break; 853| 3.60k| case '\"': ------------------ | Branch (853:17): [True: 3.60k, False: 141k] ------------------ 854| 11.1k| case '\\': ------------------ | Branch (854:17): [True: 7.57k, False: 137k] ------------------ 855| 23.3k| case '/': ------------------ | Branch (855:17): [True: 12.2k, False: 133k] ------------------ 856| 23.3k| *output_pointer++ = input_pointer[1]; 857| 23.3k| break; 858| | 859| | /* UTF-16 literal */ 860| 56.8k| case 'u': ------------------ | Branch (860:17): [True: 56.8k, False: 88.6k] ------------------ 861| 56.8k| sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); 862| 56.8k| if (sequence_length == 0) ------------------ | Branch (862:25): [True: 134, False: 56.7k] ------------------ 863| 134| { 864| | /* failed to convert UTF16-literal to UTF-8 */ 865| 134| goto fail; 866| 134| } 867| 56.7k| break; 868| | 869| 56.7k| default: ------------------ | Branch (869:17): [True: 6, False: 145k] ------------------ 870| 6| goto fail; 871| 145k| } 872| 145k| input_pointer += sequence_length; 873| 145k| } 874| 23.8M| } 875| | 876| | /* zero terminate the output */ 877| 33.3k| *output_pointer = '\0'; 878| | 879| 33.3k| item->type = cJSON_String; ------------------ | | 94| 33.3k|#define cJSON_String (1 << 4) ------------------ 880| 33.3k| item->valuestring = (char*)output; 881| | 882| 33.3k| input_buffer->offset = (size_t) (input_end - input_buffer->content); 883| 33.3k| input_buffer->offset++; 884| | 885| 33.3k| return true; ------------------ | | 65| 33.3k|#define true ((cJSON_bool)1) ------------------ 886| | 887| 360|fail: 888| 360| if (output != NULL) ------------------ | Branch (888:9): [True: 140, False: 220] ------------------ 889| 140| { 890| 140| input_buffer->hooks.deallocate(output); 891| 140| } 892| | 893| 360| if (input_pointer != NULL) ------------------ | Branch (893:9): [True: 360, False: 0] ------------------ 894| 360| { 895| 360| input_buffer->offset = (size_t)(input_pointer - input_buffer->content); 896| 360| } 897| | 898| 360| return false; ------------------ | | 70| 360|#define false ((cJSON_bool)0) ------------------ 899| 33.4k|} cJSON.c:utf16_literal_to_utf8: 653| 56.8k|{ 654| 56.8k| long unsigned int codepoint = 0; 655| 56.8k| unsigned int first_code = 0; 656| 56.8k| const unsigned char *first_sequence = input_pointer; 657| 56.8k| unsigned char utf8_length = 0; 658| 56.8k| unsigned char utf8_position = 0; 659| 56.8k| unsigned char sequence_length = 0; 660| 56.8k| unsigned char first_byte_mark = 0; 661| | 662| 56.8k| if ((input_end - first_sequence) < 6) ------------------ | Branch (662:9): [True: 3, False: 56.8k] ------------------ 663| 3| { 664| | /* input ends unexpectedly */ 665| 3| goto fail; 666| 3| } 667| | 668| | /* get the first utf16 sequence */ 669| 56.8k| first_code = parse_hex4(first_sequence + 2); 670| | 671| | /* check that the code is valid */ 672| 56.8k| if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) ------------------ | Branch (672:10): [True: 5.07k, False: 51.8k] | Branch (672:36): [True: 20, False: 5.05k] ------------------ 673| 20| { 674| 20| goto fail; 675| 20| } 676| | 677| | /* UTF16 surrogate pair */ 678| 56.8k| if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) ------------------ | Branch (678:9): [True: 9.25k, False: 47.6k] | Branch (678:35): [True: 4.20k, False: 5.05k] ------------------ 679| 4.20k| { 680| 4.20k| const unsigned char *second_sequence = first_sequence + 6; 681| 4.20k| unsigned int second_code = 0; 682| 4.20k| sequence_length = 12; /* \uXXXX\uXXXX */ 683| | 684| 4.20k| if ((input_end - second_sequence) < 6) ------------------ | Branch (684:13): [True: 18, False: 4.18k] ------------------ 685| 18| { 686| | /* input ends unexpectedly */ 687| 18| goto fail; 688| 18| } 689| | 690| 4.18k| if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) ------------------ | Branch (690:13): [True: 16, False: 4.16k] | Branch (690:45): [True: 15, False: 4.15k] ------------------ 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.15k| second_code = parse_hex4(second_sequence + 2); 698| | /* check that the code is valid */ 699| 4.15k| if ((second_code < 0xDC00) || (second_code > 0xDFFF)) ------------------ | Branch (699:13): [True: 56, False: 4.09k] | Branch (699:39): [True: 6, False: 4.09k] ------------------ 700| 62| { 701| | /* invalid second half of the surrogate pair */ 702| 62| goto fail; 703| 62| } 704| | 705| | 706| | /* calculate the unicode codepoint from the surrogate pair */ 707| 4.09k| codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); 708| 4.09k| } 709| 52.6k| else 710| 52.6k| { 711| 52.6k| sequence_length = 6; /* \uXXXX */ 712| 52.6k| codepoint = first_code; 713| 52.6k| } 714| | 715| | /* encode as UTF-8 716| | * takes at maximum 4 bytes to encode: 717| | * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 718| 56.7k| if (codepoint < 0x80) ------------------ | Branch (718:9): [True: 26.9k, False: 29.7k] ------------------ 719| 26.9k| { 720| | /* normal ascii, encoding 0xxxxxxx */ 721| 26.9k| utf8_length = 1; 722| 26.9k| } 723| 29.7k| else if (codepoint < 0x800) ------------------ | Branch (723:14): [True: 10.9k, False: 18.8k] ------------------ 724| 10.9k| { 725| | /* two bytes, encoding 110xxxxx 10xxxxxx */ 726| 10.9k| utf8_length = 2; 727| 10.9k| first_byte_mark = 0xC0; /* 11000000 */ 728| 10.9k| } 729| 18.8k| else if (codepoint < 0x10000) ------------------ | Branch (729:14): [True: 14.7k, False: 4.09k] ------------------ 730| 14.7k| { 731| | /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ 732| 14.7k| utf8_length = 3; 733| 14.7k| first_byte_mark = 0xE0; /* 11100000 */ 734| 14.7k| } 735| 4.09k| else if (codepoint <= 0x10FFFF) ------------------ | Branch (735:14): [True: 4.09k, False: 0] ------------------ 736| 4.09k| { 737| | /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ 738| 4.09k| utf8_length = 4; 739| 4.09k| first_byte_mark = 0xF0; /* 11110000 */ 740| 4.09k| } 741| 0| else 742| 0| { 743| | /* invalid unicode codepoint */ 744| 0| goto fail; 745| 0| } 746| | 747| | /* encode as utf8 */ 748| 109k| for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) ------------------ | Branch (748:60): [True: 52.7k, False: 56.7k] ------------------ 749| 52.7k| { 750| | /* 10xxxxxx */ 751| 52.7k| (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); 752| 52.7k| codepoint >>= 6; 753| 52.7k| } 754| | /* encode first byte */ 755| 56.7k| if (utf8_length > 1) ------------------ | Branch (755:9): [True: 29.7k, False: 26.9k] ------------------ 756| 29.7k| { 757| 29.7k| (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); 758| 29.7k| } 759| 26.9k| else 760| 26.9k| { 761| 26.9k| (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); 762| 26.9k| } 763| | 764| 56.7k| *output_pointer += utf8_length; 765| | 766| 56.7k| return sequence_length; 767| | 768| 134|fail: 769| 134| return 0; 770| 56.7k|} cJSON.c:parse_hex4: 616| 61.0k|{ 617| 61.0k| unsigned int h = 0; 618| 61.0k| size_t i = 0; 619| | 620| 222k| for (i = 0; i < 4; i++) ------------------ | Branch (620:17): [True: 188k, False: 34.1k] ------------------ 621| 188k| { 622| | /* parse digit */ 623| 188k| if ((input[i] >= '0') && (input[i] <= '9')) ------------------ | Branch (623:13): [True: 180k, False: 7.76k] | Branch (623:34): [True: 72.7k, False: 107k] ------------------ 624| 72.7k| { 625| 72.7k| h += (unsigned int) input[i] - '0'; 626| 72.7k| } 627| 115k| else if ((input[i] >= 'A') && (input[i] <= 'F')) ------------------ | Branch (627:18): [True: 107k, False: 7.92k] | Branch (627:39): [True: 10.7k, False: 96.8k] ------------------ 628| 10.7k| { 629| 10.7k| h += (unsigned int) 10 + input[i] - 'A'; 630| 10.7k| } 631| 104k| else if ((input[i] >= 'a') && (input[i] <= 'f')) ------------------ | Branch (631:18): [True: 95.0k, False: 9.66k] | Branch (631:39): [True: 77.8k, False: 17.2k] ------------------ 632| 77.8k| { 633| 77.8k| h += (unsigned int) 10 + input[i] - 'a'; 634| 77.8k| } 635| 26.9k| else /* invalid */ 636| 26.9k| { 637| 26.9k| return 0; 638| 26.9k| } 639| | 640| 161k| if (i < 3) ------------------ | Branch (640:13): [True: 127k, False: 34.1k] ------------------ 641| 127k| { 642| | /* shift left to make place for the next nibble */ 643| 127k| h = h << 4; 644| 127k| } 645| 161k| } 646| | 647| 34.1k| return h; 648| 61.0k|} cJSON.c:parse_number: 306| 16.2k|{ 307| 16.2k| double number = 0; 308| 16.2k| unsigned char *after_end = NULL; 309| 16.2k| unsigned char number_c_string[64]; 310| 16.2k| unsigned char decimal_point = get_decimal_point(); 311| 16.2k| size_t i = 0; 312| | 313| 16.2k| if ((input_buffer == NULL) || (input_buffer->content == NULL)) ------------------ | Branch (313:9): [True: 0, False: 16.2k] | Branch (313:35): [True: 0, False: 16.2k] ------------------ 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| 77.5k| for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) ------------------ | | 299| 77.3k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 77.3k, False: 0] | | | Branch (299:65): [True: 77.3k, False: 0] | | ------------------ ------------------ | Branch (321:17): [True: 77.3k, False: 200] ------------------ 322| 77.3k| { 323| 77.3k| switch (buffer_at_offset(input_buffer)[i]) ------------------ | | 302| 77.3k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 324| 77.3k| { 325| 7.28k| case '0': ------------------ | Branch (325:13): [True: 7.28k, False: 70.0k] ------------------ 326| 15.2k| case '1': ------------------ | Branch (326:13): [True: 7.94k, False: 69.3k] ------------------ 327| 19.2k| case '2': ------------------ | Branch (327:13): [True: 4.01k, False: 73.3k] ------------------ 328| 28.4k| case '3': ------------------ | Branch (328:13): [True: 9.20k, False: 68.1k] ------------------ 329| 33.7k| case '4': ------------------ | Branch (329:13): [True: 5.32k, False: 72.0k] ------------------ 330| 38.8k| case '5': ------------------ | Branch (330:13): [True: 5.07k, False: 72.2k] ------------------ 331| 44.5k| case '6': ------------------ | Branch (331:13): [True: 5.66k, False: 71.6k] ------------------ 332| 48.7k| case '7': ------------------ | Branch (332:13): [True: 4.20k, False: 73.1k] ------------------ 333| 54.3k| case '8': ------------------ | Branch (333:13): [True: 5.68k, False: 71.6k] ------------------ 334| 57.6k| case '9': ------------------ | Branch (334:13): [True: 3.24k, False: 74.0k] ------------------ 335| 57.8k| case '+': ------------------ | Branch (335:13): [True: 197, False: 77.1k] ------------------ 336| 59.0k| case '-': ------------------ | Branch (336:13): [True: 1.24k, False: 76.0k] ------------------ 337| 60.0k| case 'e': ------------------ | Branch (337:13): [True: 989, False: 76.3k] ------------------ 338| 60.6k| case 'E': ------------------ | Branch (338:13): [True: 552, False: 76.7k] ------------------ 339| 60.6k| number_c_string[i] = buffer_at_offset(input_buffer)[i]; ------------------ | | 302| 60.6k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ 340| 60.6k| break; 341| | 342| 612| case '.': ------------------ | Branch (342:13): [True: 612, False: 76.7k] ------------------ 343| 612| number_c_string[i] = decimal_point; 344| 612| break; 345| | 346| 16.0k| default: ------------------ | Branch (346:13): [True: 16.0k, False: 61.2k] ------------------ 347| 16.0k| goto loop_end; 348| 77.3k| } 349| 77.3k| } 350| 16.2k|loop_end: 351| 16.2k| number_c_string[i] = '\0'; 352| | 353| 16.2k| number = strtod((const char*)number_c_string, (char**)&after_end); 354| 16.2k| if (number_c_string == after_end) ------------------ | Branch (354:9): [True: 17, False: 16.2k] ------------------ 355| 17| { 356| 17| return false; /* parse_error */ ------------------ | | 70| 17|#define false ((cJSON_bool)0) ------------------ 357| 17| } 358| | 359| 16.2k| item->valuedouble = number; 360| | 361| | /* use saturation in case of overflow */ 362| 16.2k| if (number >= INT_MAX) ------------------ | Branch (362:9): [True: 2.00k, False: 14.2k] ------------------ 363| 2.00k| { 364| 2.00k| item->valueint = INT_MAX; 365| 2.00k| } 366| 14.2k| else if (number <= (double)INT_MIN) ------------------ | Branch (366:14): [True: 733, False: 13.5k] ------------------ 367| 733| { 368| 733| item->valueint = INT_MIN; 369| 733| } 370| 13.5k| else 371| 13.5k| { 372| 13.5k| item->valueint = (int)number; 373| 13.5k| } 374| | 375| 16.2k| item->type = cJSON_Number; ------------------ | | 93| 16.2k|#define cJSON_Number (1 << 3) ------------------ 376| | 377| 16.2k| input_buffer->offset += (size_t)(after_end - number_c_string); 378| 16.2k| return true; ------------------ | | 65| 16.2k|#define true ((cJSON_bool)1) ------------------ 379| 16.2k|} cJSON.c:get_decimal_point: 278| 23.8k|{ 279| 23.8k|#ifdef ENABLE_LOCALES 280| 23.8k| struct lconv *lconv = localeconv(); 281| 23.8k| return (unsigned char) lconv->decimal_point[0]; 282| |#else 283| | return '.'; 284| |#endif 285| 23.8k|} cJSON.c:parse_array: 1442| 388k|{ 1443| 388k| cJSON *head = NULL; /* head of the linked list */ 1444| 388k| cJSON *current_item = NULL; 1445| | 1446| 388k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 388k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1446:9): [True: 1, False: 388k] ------------------ 1447| 1| { 1448| 1| return false; /* to deeply nested */ ------------------ | | 70| 1|#define false ((cJSON_bool)0) ------------------ 1449| 1| } 1450| 388k| input_buffer->depth++; 1451| | 1452| 388k| if (buffer_at_offset(input_buffer)[0] != '[') ------------------ | | 302| 388k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1452:9): [True: 0, False: 388k] ------------------ 1453| 0| { 1454| | /* not an array */ 1455| 0| goto fail; 1456| 0| } 1457| | 1458| 388k| input_buffer->offset++; 1459| 388k| buffer_skip_whitespace(input_buffer); 1460| 388k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 299| 777k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 388k, False: 0] | | | Branch (299:65): [True: 388k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) ------------------ | | 302| 388k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1460:49): [True: 5.40k, False: 383k] ------------------ 1461| 5.40k| { 1462| | /* empty array */ 1463| 5.40k| goto success; 1464| 5.40k| } 1465| | 1466| | /* check if we skipped to the end of the buffer */ 1467| 383k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 300| 383k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 383k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 383k, False: 0] | | | | | Branch (299:65): [True: 383k, 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| 383k| input_buffer->offset--; 1475| | /* loop through the comma separated array elements */ 1476| 383k| do 1477| 911k| { 1478| | /* allocate next item */ 1479| 911k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1480| 911k| if (new_item == NULL) ------------------ | Branch (1480:13): [True: 0, False: 911k] ------------------ 1481| 0| { 1482| 0| goto fail; /* allocation failure */ 1483| 0| } 1484| | 1485| | /* attach next item to list */ 1486| 911k| if (head == NULL) ------------------ | Branch (1486:13): [True: 383k, False: 528k] ------------------ 1487| 383k| { 1488| | /* start the linked list */ 1489| 383k| current_item = head = new_item; 1490| 383k| } 1491| 528k| else 1492| 528k| { 1493| | /* add to the end and advance */ 1494| 528k| current_item->next = new_item; 1495| 528k| new_item->prev = current_item; 1496| 528k| current_item = new_item; 1497| 528k| } 1498| | 1499| | /* parse next value */ 1500| 911k| input_buffer->offset++; 1501| 911k| buffer_skip_whitespace(input_buffer); 1502| 911k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1502:13): [True: 44.0k, False: 867k] ------------------ 1503| 44.0k| { 1504| 44.0k| goto fail; /* failed to parse value */ 1505| 44.0k| } 1506| 867k| buffer_skip_whitespace(input_buffer); 1507| 867k| } 1508| 867k| while (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: 867k, False: 0] | | | Branch (299:65): [True: 867k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 302| 867k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1508:52): [True: 528k, False: 339k] ------------------ 1509| | 1510| 339k| if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 300| 678k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 339k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 339k, False: 0] | | | | | Branch (299:65): [True: 339k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') ------------------ | | 302| 339k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1510:52): [True: 135, False: 339k] ------------------ 1511| 135| { 1512| 135| goto fail; /* expected end of array */ 1513| 135| } 1514| | 1515| 344k|success: 1516| 344k| input_buffer->depth--; 1517| | 1518| 344k| if (head != NULL) { ------------------ | Branch (1518:9): [True: 339k, False: 5.40k] ------------------ 1519| 339k| head->prev = current_item; 1520| 339k| } 1521| | 1522| 344k| item->type = cJSON_Array; ------------------ | | 95| 344k|#define cJSON_Array (1 << 5) ------------------ 1523| 344k| item->child = head; 1524| | 1525| 344k| input_buffer->offset++; 1526| | 1527| 344k| return true; ------------------ | | 65| 344k|#define true ((cJSON_bool)1) ------------------ 1528| | 1529| 44.2k|fail: 1530| 44.2k| if (head != NULL) ------------------ | Branch (1530:9): [True: 44.2k, False: 0] ------------------ 1531| 44.2k| { 1532| 44.2k| cJSON_Delete(head); 1533| 44.2k| } 1534| | 1535| 44.2k| return false; ------------------ | | 70| 44.2k|#define false ((cJSON_bool)0) ------------------ 1536| 339k|} cJSON.c:parse_object: 1602| 516k|{ 1603| 516k| cJSON *head = NULL; /* linked list head */ 1604| 516k| cJSON *current_item = NULL; 1605| | 1606| 516k| if (input_buffer->depth >= CJSON_NESTING_LIMIT) ------------------ | | 137| 516k|#define CJSON_NESTING_LIMIT 1000 ------------------ | Branch (1606:9): [True: 1, False: 516k] ------------------ 1607| 1| { 1608| 1| return false; /* to deeply nested */ ------------------ | | 70| 1|#define false ((cJSON_bool)0) ------------------ 1609| 1| } 1610| 516k| input_buffer->depth++; 1611| | 1612| 516k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) ------------------ | | 300| 1.03M|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 516k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 516k, False: 0] | | | | | Branch (299:65): [True: 516k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) ------------------ | | 302| 516k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1612:52): [True: 0, False: 516k] ------------------ 1613| 0| { 1614| 0| goto fail; /* not an object */ 1615| 0| } 1616| | 1617| 516k| input_buffer->offset++; 1618| 516k| buffer_skip_whitespace(input_buffer); 1619| 516k| if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) ------------------ | | 299| 1.03M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 516k, False: 0] | | | Branch (299:65): [True: 516k, False: 0] | | ------------------ ------------------ if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) ------------------ | | 302| 516k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1619:49): [True: 508k, False: 8.05k] ------------------ 1620| 508k| { 1621| 508k| goto success; /* empty object */ 1622| 508k| } 1623| | 1624| | /* check if we skipped to the end of the buffer */ 1625| 8.05k| if (cannot_access_at_index(input_buffer, 0)) ------------------ | | 300| 8.05k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 8.05k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 8.05k, False: 0] | | | | | Branch (299:65): [True: 8.05k, 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| 8.05k| input_buffer->offset--; 1633| | /* loop through the comma separated array elements */ 1634| 8.05k| do 1635| 21.6k| { 1636| | /* allocate next item */ 1637| 21.6k| cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1638| 21.6k| if (new_item == NULL) ------------------ | Branch (1638:13): [True: 0, False: 21.6k] ------------------ 1639| 0| { 1640| 0| goto fail; /* allocation failure */ 1641| 0| } 1642| | 1643| | /* attach next item to list */ 1644| 21.6k| if (head == NULL) ------------------ | Branch (1644:13): [True: 8.05k, False: 13.5k] ------------------ 1645| 8.05k| { 1646| | /* start the linked list */ 1647| 8.05k| current_item = head = new_item; 1648| 8.05k| } 1649| 13.5k| else 1650| 13.5k| { 1651| | /* add to the end and advance */ 1652| 13.5k| current_item->next = new_item; 1653| 13.5k| new_item->prev = current_item; 1654| 13.5k| current_item = new_item; 1655| 13.5k| } 1656| | 1657| | /* parse the name of the child */ 1658| 21.6k| input_buffer->offset++; 1659| 21.6k| buffer_skip_whitespace(input_buffer); 1660| 21.6k| if (!parse_string(current_item, input_buffer)) ------------------ | Branch (1660:13): [True: 149, False: 21.5k] ------------------ 1661| 149| { 1662| 149| goto fail; /* failed to parse name */ 1663| 149| } 1664| 21.5k| buffer_skip_whitespace(input_buffer); 1665| | 1666| | /* swap valuestring and string, because we parsed the name */ 1667| 21.5k| current_item->string = current_item->valuestring; 1668| 21.5k| current_item->valuestring = NULL; 1669| | 1670| 21.5k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 300| 43.0k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 21.5k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 21.5k, False: 0] | | | | | Branch (299:65): [True: 21.5k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) ------------------ | | 302| 21.5k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1670:56): [True: 35, False: 21.4k] ------------------ 1671| 35| { 1672| 35| goto fail; /* invalid object */ 1673| 35| } 1674| | 1675| | /* parse the value */ 1676| 21.4k| input_buffer->offset++; 1677| 21.4k| buffer_skip_whitespace(input_buffer); 1678| 21.4k| if (!parse_value(current_item, input_buffer)) ------------------ | Branch (1678:13): [True: 740, False: 20.7k] ------------------ 1679| 740| { 1680| 740| goto fail; /* failed to parse value */ 1681| 740| } 1682| 20.7k| buffer_skip_whitespace(input_buffer); 1683| 20.7k| } 1684| 20.7k| while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 299| 41.4k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | ------------------ | | | Branch (299:45): [True: 20.7k, False: 0] | | | Branch (299:65): [True: 20.7k, False: 0] | | ------------------ ------------------ while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); ------------------ | | 302| 20.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1684:52): [True: 13.5k, False: 7.13k] ------------------ 1685| | 1686| 7.13k| if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 300| 14.2k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) | | ------------------ | | | | 299| 7.13k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) | | | | ------------------ | | | | | Branch (299:45): [True: 7.13k, False: 0] | | | | | Branch (299:65): [True: 7.13k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) ------------------ | | 302| 7.13k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) ------------------ | Branch (1686:52): [True: 36, False: 7.09k] ------------------ 1687| 36| { 1688| 36| goto fail; /* expected end of object */ 1689| 36| } 1690| | 1691| 515k|success: 1692| 515k| input_buffer->depth--; 1693| | 1694| 515k| if (head != NULL) { ------------------ | Branch (1694:9): [True: 7.09k, False: 508k] ------------------ 1695| 7.09k| head->prev = current_item; 1696| 7.09k| } 1697| | 1698| 515k| item->type = cJSON_Object; ------------------ | | 96| 515k|#define cJSON_Object (1 << 6) ------------------ 1699| 515k| item->child = head; 1700| | 1701| 515k| input_buffer->offset++; 1702| 515k| return true; ------------------ | | 65| 515k|#define true ((cJSON_bool)1) ------------------ 1703| | 1704| 960|fail: 1705| 960| if (head != NULL) ------------------ | Branch (1705:9): [True: 960, False: 0] ------------------ 1706| 960| { 1707| 960| cJSON_Delete(head); 1708| 960| } 1709| | 1710| 960| return false; ------------------ | | 70| 960|#define false ((cJSON_bool)0) ------------------ 1711| 7.13k|} cJSON.c:print_value: 1368| 861k|{ 1369| 861k| unsigned char *output = NULL; 1370| | 1371| 861k| if ((item == NULL) || (output_buffer == NULL)) ------------------ | Branch (1371:9): [True: 0, False: 861k] | Branch (1371:27): [True: 0, False: 861k] ------------------ 1372| 0| { 1373| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1374| 0| } 1375| | 1376| 861k| switch ((item->type) & 0xFF) 1377| 861k| { 1378| 553| case cJSON_NULL: ------------------ | | 92| 553|#define cJSON_NULL (1 << 2) ------------------ | Branch (1378:9): [True: 553, False: 861k] ------------------ 1379| 553| output = ensure(output_buffer, 5); 1380| 553| if (output == NULL) ------------------ | Branch (1380:17): [True: 0, False: 553] ------------------ 1381| 0| { 1382| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1383| 0| } 1384| 553| strcpy((char*)output, "null"); 1385| 553| return true; ------------------ | | 65| 553|#define true ((cJSON_bool)1) ------------------ 1386| | 1387| 211| case cJSON_False: ------------------ | | 90| 211|#define cJSON_False (1 << 0) ------------------ | Branch (1387:9): [True: 211, False: 861k] ------------------ 1388| 211| output = ensure(output_buffer, 6); 1389| 211| if (output == NULL) ------------------ | Branch (1389:17): [True: 0, False: 211] ------------------ 1390| 0| { 1391| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1392| 0| } 1393| 211| strcpy((char*)output, "false"); 1394| 211| return true; ------------------ | | 65| 211|#define true ((cJSON_bool)1) ------------------ 1395| | 1396| 227| case cJSON_True: ------------------ | | 91| 227|#define cJSON_True (1 << 1) ------------------ | Branch (1396:9): [True: 227, False: 861k] ------------------ 1397| 227| output = ensure(output_buffer, 5); 1398| 227| if (output == NULL) ------------------ | Branch (1398:17): [True: 0, False: 227] ------------------ 1399| 0| { 1400| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1401| 0| } 1402| 227| strcpy((char*)output, "true"); 1403| 227| return true; ------------------ | | 65| 227|#define true ((cJSON_bool)1) ------------------ 1404| | 1405| 7.59k| case cJSON_Number: ------------------ | | 93| 7.59k|#define cJSON_Number (1 << 3) ------------------ | Branch (1405:9): [True: 7.59k, False: 854k] ------------------ 1406| 7.59k| 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: 861k] ------------------ 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| 957| case cJSON_String: ------------------ | | 94| 957|#define cJSON_String (1 << 4) ------------------ | Branch (1426:9): [True: 957, False: 860k] ------------------ 1427| 957| return print_string(item, output_buffer); 1428| | 1429| 344k| case cJSON_Array: ------------------ | | 95| 344k|#define cJSON_Array (1 << 5) ------------------ | Branch (1429:9): [True: 344k, False: 517k] ------------------ 1430| 344k| return print_array(item, output_buffer); 1431| | 1432| 507k| case cJSON_Object: ------------------ | | 96| 507k|#define cJSON_Object (1 << 6) ------------------ | Branch (1432:9): [True: 507k, False: 353k] ------------------ 1433| 507k| return print_object(item, output_buffer); 1434| | 1435| 0| default: ------------------ | Branch (1435:9): [True: 0, False: 861k] ------------------ 1436| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1437| 861k| } 1438| 861k|} cJSON.c:ensure: 440| 2.25M|{ 441| 2.25M| unsigned char *newbuffer = NULL; 442| 2.25M| size_t newsize = 0; 443| | 444| 2.25M| if ((p == NULL) || (p->buffer == NULL)) ------------------ | Branch (444:9): [True: 0, False: 2.25M] | Branch (444:24): [True: 0, False: 2.25M] ------------------ 445| 0| { 446| 0| return NULL; 447| 0| } 448| | 449| 2.25M| if ((p->length > 0) && (p->offset >= p->length)) ------------------ | Branch (449:9): [True: 2.25M, False: 0] | Branch (449:28): [True: 0, False: 2.25M] ------------------ 450| 0| { 451| | /* make sure that offset is valid */ 452| 0| return NULL; 453| 0| } 454| | 455| 2.25M| if (needed > INT_MAX) ------------------ | Branch (455:9): [True: 0, False: 2.25M] ------------------ 456| 0| { 457| | /* sizes bigger than INT_MAX are currently not supported */ 458| 0| return NULL; 459| 0| } 460| | 461| 2.25M| needed += p->offset + 1; 462| 2.25M| if (needed <= p->length) ------------------ | Branch (462:9): [True: 2.25M, False: 1.58k] ------------------ 463| 2.25M| { 464| 2.25M| return p->buffer + p->offset; 465| 2.25M| } 466| | 467| 1.58k| if (p->noalloc) { ------------------ | Branch (467:9): [True: 0, False: 1.58k] ------------------ 468| 0| return NULL; 469| 0| } 470| | 471| | /* calculate new buffer size */ 472| 1.58k| if (needed > (INT_MAX / 2)) ------------------ | Branch (472:9): [True: 0, False: 1.58k] ------------------ 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.58k| else 485| 1.58k| { 486| 1.58k| newsize = needed * 2; 487| 1.58k| } 488| | 489| 1.58k| if (p->hooks.reallocate != NULL) ------------------ | Branch (489:9): [True: 1.58k, False: 0] ------------------ 490| 1.58k| { 491| | /* reallocate with realloc if available */ 492| 1.58k| newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); 493| 1.58k| if (newbuffer == NULL) ------------------ | Branch (493:13): [True: 0, False: 1.58k] ------------------ 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.58k| } 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.58k| p->length = newsize; 519| 1.58k| p->buffer = newbuffer; 520| | 521| 1.58k| return newbuffer + p->offset; 522| 1.58k|} cJSON.c:print_number: 546| 7.59k|{ 547| 7.59k| unsigned char *output_pointer = NULL; 548| 7.59k| double d = item->valuedouble; 549| 7.59k| int length = 0; 550| 7.59k| size_t i = 0; 551| 7.59k| unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ 552| 7.59k| unsigned char decimal_point = get_decimal_point(); 553| 7.59k| double test = 0.0; 554| | 555| 7.59k| if (output_buffer == NULL) ------------------ | Branch (555:9): [True: 0, False: 7.59k] ------------------ 556| 0| { 557| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 558| 0| } 559| | 560| | /* This checks for NaN and Infinity */ 561| 7.59k| if (isnan(d) || isinf(d)) ------------------ | | 77| 15.1k|#define isnan(d) (d != d) | | ------------------ | | | Branch (77:18): [True: 0, False: 7.59k] | | ------------------ ------------------ if (isnan(d) || isinf(d)) ------------------ | | 74| 7.59k|#define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 15.1k|#define isnan(d) (d != d) | | | | ------------------ | | | | | Branch (77:18): [True: 195, False: 7.40k] | | | | ------------------ | | ------------------ | | #define isinf(d) (isnan((d - d)) && !isnan(d)) | | ------------------ | | | | 77| 195|#define isnan(d) (d != d) | | ------------------ | | | Branch (74:37): [True: 195, False: 0] | | ------------------ ------------------ 562| 195| { 563| 195| length = sprintf((char*)number_buffer, "null"); 564| 195| } 565| 7.40k| else if(d == (double)item->valueint) ------------------ | Branch (565:10): [True: 6.65k, False: 747] ------------------ 566| 6.65k| { 567| 6.65k| length = sprintf((char*)number_buffer, "%d", item->valueint); 568| 6.65k| } 569| 747| else 570| 747| { 571| | /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ 572| 747| length = sprintf((char*)number_buffer, "%1.15g", d); 573| | 574| | /* Check whether the original double can be recovered */ 575| 747| if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) ------------------ | Branch (575:13): [True: 0, False: 747] | Branch (575:66): [True: 484, False: 263] ------------------ 576| 484| { 577| | /* If not, print with 17 decimal places of precision */ 578| 484| length = sprintf((char*)number_buffer, "%1.17g", d); 579| 484| } 580| 747| } 581| | 582| | /* sprintf failed or buffer overrun occurred */ 583| 7.59k| if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) ------------------ | Branch (583:9): [True: 0, False: 7.59k] | Branch (583:25): [True: 0, False: 7.59k] ------------------ 584| 0| { 585| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 586| 0| } 587| | 588| | /* reserve appropriate space in the output */ 589| 7.59k| output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); 590| 7.59k| if (output_pointer == NULL) ------------------ | Branch (590:9): [True: 0, False: 7.59k] ------------------ 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| 24.8k| for (i = 0; i < ((size_t)length); i++) ------------------ | Branch (597:17): [True: 17.2k, False: 7.59k] ------------------ 598| 17.2k| { 599| 17.2k| if (number_buffer[i] == decimal_point) ------------------ | Branch (599:13): [True: 226, False: 17.0k] ------------------ 600| 226| { 601| 226| output_pointer[i] = '.'; 602| 226| continue; 603| 226| } 604| | 605| 17.0k| output_pointer[i] = number_buffer[i]; 606| 17.0k| } 607| 7.59k| output_pointer[i] = '\0'; 608| | 609| 7.59k| output_buffer->offset += (size_t)length; 610| | 611| 7.59k| return true; ------------------ | | 65| 7.59k|#define true ((cJSON_bool)1) ------------------ 612| 7.59k|} cJSON.c:print_string: 1025| 957|{ 1026| 957| return print_string_ptr((unsigned char*)item->valuestring, p); 1027| 957|} cJSON.c:print_string_ptr: 903| 8.53k|{ 904| 8.53k| const unsigned char *input_pointer = NULL; 905| 8.53k| unsigned char *output = NULL; 906| 8.53k| unsigned char *output_pointer = NULL; 907| 8.53k| size_t output_length = 0; 908| | /* numbers of additional characters needed for escaping */ 909| 8.53k| size_t escape_characters = 0; 910| | 911| 8.53k| if (output_buffer == NULL) ------------------ | Branch (911:9): [True: 0, False: 8.53k] ------------------ 912| 0| { 913| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 914| 0| } 915| | 916| | /* empty string */ 917| 8.53k| if (input == NULL) ------------------ | Branch (917:9): [True: 0, False: 8.53k] ------------------ 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.99M| for (input_pointer = input; *input_pointer; input_pointer++) ------------------ | Branch (930:33): [True: 9.98M, False: 8.53k] ------------------ 931| 9.98M| { 932| 9.98M| switch (*input_pointer) 933| 9.98M| { 934| 492| case '\"': ------------------ | Branch (934:13): [True: 492, False: 9.98M] ------------------ 935| 4.02k| case '\\': ------------------ | Branch (935:13): [True: 3.52k, False: 9.98M] ------------------ 936| 4.74k| case '\b': ------------------ | Branch (936:13): [True: 728, False: 9.98M] ------------------ 937| 6.15k| case '\f': ------------------ | Branch (937:13): [True: 1.40k, False: 9.98M] ------------------ 938| 11.9k| case '\n': ------------------ | Branch (938:13): [True: 5.82k, False: 9.98M] ------------------ 939| 12.7k| case '\r': ------------------ | Branch (939:13): [True: 720, False: 9.98M] ------------------ 940| 13.9k| case '\t': ------------------ | Branch (940:13): [True: 1.21k, False: 9.98M] ------------------ 941| | /* one character escape sequence */ 942| 13.9k| escape_characters++; 943| 13.9k| break; 944| 9.97M| default: ------------------ | Branch (944:13): [True: 9.97M, False: 13.9k] ------------------ 945| 9.97M| if (*input_pointer < 32) ------------------ | Branch (945:21): [True: 9.68M, False: 288k] ------------------ 946| 9.68M| { 947| | /* UTF-16 escape sequence uXXXX */ 948| 9.68M| escape_characters += 5; 949| 9.68M| } 950| 9.97M| break; 951| 9.98M| } 952| 9.98M| } 953| 8.53k| output_length = (size_t)(input_pointer - input) + escape_characters; 954| | 955| 8.53k| output = ensure(output_buffer, output_length + sizeof("\"\"")); 956| 8.53k| if (output == NULL) ------------------ | Branch (956:9): [True: 0, False: 8.53k] ------------------ 957| 0| { 958| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 959| 0| } 960| | 961| | /* no characters have to be escaped */ 962| 8.53k| if (escape_characters == 0) ------------------ | Branch (962:9): [True: 7.18k, False: 1.35k] ------------------ 963| 7.18k| { 964| 7.18k| output[0] = '\"'; 965| 7.18k| memcpy(output + 1, input, output_length); 966| 7.18k| output[output_length + 1] = '\"'; 967| 7.18k| output[output_length + 2] = '\0'; 968| | 969| 7.18k| return true; ------------------ | | 65| 7.18k|#define true ((cJSON_bool)1) ------------------ 970| 7.18k| } 971| | 972| 1.35k| output[0] = '\"'; 973| 1.35k| output_pointer = output + 1; 974| | /* copy the string */ 975| 9.97M| for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) ------------------ | Branch (975:33): [True: 9.97M, False: 1.35k] ------------------ 976| 9.97M| { 977| 9.97M| if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) ------------------ | Branch (977:13): [True: 284k, False: 9.69M] | Branch (977:38): [True: 284k, False: 492] | Branch (977:66): [True: 280k, False: 3.52k] ------------------ 978| 280k| { 979| | /* normal character, copy */ 980| 280k| *output_pointer = *input_pointer; 981| 280k| } 982| 9.69M| else 983| 9.69M| { 984| | /* character needs to be escaped */ 985| 9.69M| *output_pointer++ = '\\'; 986| 9.69M| switch (*input_pointer) 987| 9.69M| { 988| 3.52k| case '\\': ------------------ | Branch (988:17): [True: 3.52k, False: 9.69M] ------------------ 989| 3.52k| *output_pointer = '\\'; 990| 3.52k| break; 991| 492| case '\"': ------------------ | Branch (991:17): [True: 492, False: 9.69M] ------------------ 992| 492| *output_pointer = '\"'; 993| 492| break; 994| 728| case '\b': ------------------ | Branch (994:17): [True: 728, False: 9.69M] ------------------ 995| 728| *output_pointer = 'b'; 996| 728| break; 997| 1.40k| case '\f': ------------------ | Branch (997:17): [True: 1.40k, False: 9.69M] ------------------ 998| 1.40k| *output_pointer = 'f'; 999| 1.40k| break; 1000| 5.82k| case '\n': ------------------ | Branch (1000:17): [True: 5.82k, False: 9.69M] ------------------ 1001| 5.82k| *output_pointer = 'n'; 1002| 5.82k| break; 1003| 720| case '\r': ------------------ | Branch (1003:17): [True: 720, False: 9.69M] ------------------ 1004| 720| *output_pointer = 'r'; 1005| 720| break; 1006| 1.21k| case '\t': ------------------ | Branch (1006:17): [True: 1.21k, False: 9.69M] ------------------ 1007| 1.21k| *output_pointer = 't'; 1008| 1.21k| break; 1009| 9.68M| default: ------------------ | Branch (1009:17): [True: 9.68M, False: 13.9k] ------------------ 1010| | /* escape and print as unicode codepoint */ 1011| 9.68M| sprintf((char*)output_pointer, "u%04x", *input_pointer); 1012| 9.68M| output_pointer += 4; 1013| 9.68M| break; 1014| 9.69M| } 1015| 9.69M| } 1016| 9.97M| } 1017| 1.35k| output[output_length + 1] = '\"'; 1018| 1.35k| output[output_length + 2] = '\0'; 1019| | 1020| 1.35k| return true; ------------------ | | 65| 1.35k|#define true ((cJSON_bool)1) ------------------ 1021| 1.35k|} cJSON.c:print_array: 1540| 344k|{ 1541| 344k| unsigned char *output_pointer = NULL; 1542| 344k| size_t length = 0; 1543| 344k| cJSON *current_element = item->child; 1544| | 1545| 344k| if (output_buffer == NULL) ------------------ | Branch (1545:9): [True: 0, False: 344k] ------------------ 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| 344k| output_pointer = ensure(output_buffer, 1); 1553| 344k| if (output_pointer == NULL) ------------------ | Branch (1553:9): [True: 0, False: 344k] ------------------ 1554| 0| { 1555| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1556| 0| } 1557| | 1558| 344k| *output_pointer = '['; 1559| 344k| output_buffer->offset++; 1560| 344k| output_buffer->depth++; 1561| | 1562| 1.19M| while (current_element != NULL) ------------------ | Branch (1562:12): [True: 853k, False: 344k] ------------------ 1563| 853k| { 1564| 853k| if (!print_value(current_element, output_buffer)) ------------------ | Branch (1564:13): [True: 0, False: 853k] ------------------ 1565| 0| { 1566| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1567| 0| } 1568| 853k| update_offset(output_buffer); 1569| 853k| if (current_element->next) ------------------ | Branch (1569:13): [True: 514k, False: 339k] ------------------ 1570| 514k| { 1571| 514k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1571:32): [True: 512k, False: 1.31k] ------------------ 1572| 514k| output_pointer = ensure(output_buffer, length + 1); 1573| 514k| if (output_pointer == NULL) ------------------ | Branch (1573:17): [True: 0, False: 514k] ------------------ 1574| 0| { 1575| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1576| 0| } 1577| 514k| *output_pointer++ = ','; 1578| 514k| if(output_buffer->format) ------------------ | Branch (1578:16): [True: 512k, False: 1.31k] ------------------ 1579| 512k| { 1580| 512k| *output_pointer++ = ' '; 1581| 512k| } 1582| 514k| *output_pointer = '\0'; 1583| 514k| output_buffer->offset += length; 1584| 514k| } 1585| 853k| current_element = current_element->next; 1586| 853k| } 1587| | 1588| 344k| output_pointer = ensure(output_buffer, 2); 1589| 344k| if (output_pointer == NULL) ------------------ | Branch (1589:9): [True: 0, False: 344k] ------------------ 1590| 0| { 1591| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1592| 0| } 1593| 344k| *output_pointer++ = ']'; 1594| 344k| *output_pointer = '\0'; 1595| 344k| output_buffer->depth--; 1596| | 1597| 344k| return true; ------------------ | | 65| 344k|#define true ((cJSON_bool)1) ------------------ 1598| 344k|} cJSON.c:print_object: 1715| 507k|{ 1716| 507k| unsigned char *output_pointer = NULL; 1717| 507k| size_t length = 0; 1718| 507k| cJSON *current_item = item->child; 1719| | 1720| 507k| if (output_buffer == NULL) ------------------ | Branch (1720:9): [True: 0, False: 507k] ------------------ 1721| 0| { 1722| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1723| 0| } 1724| | 1725| | /* Compose the output: */ 1726| 507k| length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ ------------------ | Branch (1726:24): [True: 507k, False: 771] ------------------ 1727| 507k| output_pointer = ensure(output_buffer, length + 1); 1728| 507k| if (output_pointer == NULL) ------------------ | Branch (1728:9): [True: 0, False: 507k] ------------------ 1729| 0| { 1730| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1731| 0| } 1732| | 1733| 507k| *output_pointer++ = '{'; 1734| 507k| output_buffer->depth++; 1735| 507k| if (output_buffer->format) ------------------ | Branch (1735:9): [True: 507k, False: 771] ------------------ 1736| 507k| { 1737| 507k| *output_pointer++ = '\n'; 1738| 507k| } 1739| 507k| output_buffer->offset += length; 1740| | 1741| 515k| while (current_item) ------------------ | Branch (1741:12): [True: 7.57k, False: 507k] ------------------ 1742| 7.57k| { 1743| 7.57k| if (output_buffer->format) ------------------ | Branch (1743:13): [True: 6.21k, False: 1.36k] ------------------ 1744| 6.21k| { 1745| 6.21k| size_t i; 1746| 6.21k| output_pointer = ensure(output_buffer, output_buffer->depth); 1747| 6.21k| if (output_pointer == NULL) ------------------ | Branch (1747:17): [True: 0, False: 6.21k] ------------------ 1748| 0| { 1749| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1750| 0| } 1751| 2.83M| for (i = 0; i < output_buffer->depth; i++) ------------------ | Branch (1751:25): [True: 2.82M, False: 6.21k] ------------------ 1752| 2.82M| { 1753| 2.82M| *output_pointer++ = '\t'; 1754| 2.82M| } 1755| 6.21k| output_buffer->offset += output_buffer->depth; 1756| 6.21k| } 1757| | 1758| | /* print key */ 1759| 7.57k| if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) ------------------ | Branch (1759:13): [True: 0, False: 7.57k] ------------------ 1760| 0| { 1761| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1762| 0| } 1763| 7.57k| update_offset(output_buffer); 1764| | 1765| 7.57k| length = (size_t) (output_buffer->format ? 2 : 1); ------------------ | Branch (1765:28): [True: 6.21k, False: 1.36k] ------------------ 1766| 7.57k| output_pointer = ensure(output_buffer, length); 1767| 7.57k| if (output_pointer == NULL) ------------------ | Branch (1767:13): [True: 0, False: 7.57k] ------------------ 1768| 0| { 1769| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1770| 0| } 1771| 7.57k| *output_pointer++ = ':'; 1772| 7.57k| if (output_buffer->format) ------------------ | Branch (1772:13): [True: 6.21k, False: 1.36k] ------------------ 1773| 6.21k| { 1774| 6.21k| *output_pointer++ = '\t'; 1775| 6.21k| } 1776| 7.57k| output_buffer->offset += length; 1777| | 1778| | /* print value */ 1779| 7.57k| if (!print_value(current_item, output_buffer)) ------------------ | Branch (1779:13): [True: 0, False: 7.57k] ------------------ 1780| 0| { 1781| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1782| 0| } 1783| 7.57k| update_offset(output_buffer); 1784| | 1785| | /* print comma if not last */ 1786| 7.57k| length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); ------------------ | Branch (1786:28): [True: 6.21k, False: 1.36k] | Branch (1786:70): [True: 3.53k, False: 4.04k] ------------------ 1787| 7.57k| output_pointer = ensure(output_buffer, length + 1); 1788| 7.57k| if (output_pointer == NULL) ------------------ | Branch (1788:13): [True: 0, False: 7.57k] ------------------ 1789| 0| { 1790| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1791| 0| } 1792| 7.57k| if (current_item->next) ------------------ | Branch (1792:13): [True: 3.53k, False: 4.04k] ------------------ 1793| 3.53k| { 1794| 3.53k| *output_pointer++ = ','; 1795| 3.53k| } 1796| | 1797| 7.57k| if (output_buffer->format) ------------------ | Branch (1797:13): [True: 6.21k, False: 1.36k] ------------------ 1798| 6.21k| { 1799| 6.21k| *output_pointer++ = '\n'; 1800| 6.21k| } 1801| 7.57k| *output_pointer = '\0'; 1802| 7.57k| output_buffer->offset += length; 1803| | 1804| 7.57k| current_item = current_item->next; 1805| 7.57k| } 1806| | 1807| 507k| output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); ------------------ | Branch (1807:44): [True: 507k, False: 771] ------------------ 1808| 507k| if (output_pointer == NULL) ------------------ | Branch (1808:9): [True: 0, False: 507k] ------------------ 1809| 0| { 1810| 0| return false; ------------------ | | 70| 0|#define false ((cJSON_bool)0) ------------------ 1811| 0| } 1812| 507k| if (output_buffer->format) ------------------ | Branch (1812:9): [True: 507k, False: 771] ------------------ 1813| 507k| { 1814| 507k| size_t i; 1815| 254M| for (i = 0; i < (output_buffer->depth - 1); i++) ------------------ | Branch (1815:21): [True: 253M, False: 507k] ------------------ 1816| 253M| { 1817| 253M| *output_pointer++ = '\t'; 1818| 253M| } 1819| 507k| } 1820| 507k| *output_pointer++ = '}'; 1821| 507k| *output_pointer = '\0'; 1822| 507k| output_buffer->depth--; 1823| | 1824| 507k| return true; ------------------ | | 65| 507k|#define true ((cJSON_bool)1) ------------------ 1825| 507k|} cJSON.c:skip_oneline_comment: 2790| 334|{ 2791| 334| *input += static_strlen("//"); ------------------ | | 184| 334|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2792| | 2793| 608| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2793:12): [True: 588, False: 20] ------------------ 2794| 588| { 2795| 588| if ((*input)[0] == '\n') { ------------------ | Branch (2795:13): [True: 314, False: 274] ------------------ 2796| 314| *input += static_strlen("\n"); ------------------ | | 184| 314|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2797| 314| return; 2798| 314| } 2799| 588| } 2800| 334|} cJSON.c:skip_multiline_comment: 2803| 238|{ 2804| 238| *input += static_strlen("/*"); ------------------ | | 184| 238|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2805| | 2806| 849| for (; (*input)[0] != '\0'; ++(*input)) ------------------ | Branch (2806:12): [True: 805, False: 44] ------------------ 2807| 805| { 2808| 805| if (((*input)[0] == '*') && ((*input)[1] == '/')) ------------------ | Branch (2808:13): [True: 431, False: 374] | Branch (2808:37): [True: 194, False: 237] ------------------ 2809| 194| { 2810| 194| *input += static_strlen("*/"); ------------------ | | 184| 194|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2811| 194| return; 2812| 194| } 2813| 805| } 2814| 238|} cJSON.c:minify_string: 2816| 7.24k|static void minify_string(char **input, char **output) { 2817| 7.24k| (*output)[0] = (*input)[0]; 2818| 7.24k| *input += static_strlen("\""); ------------------ | | 184| 7.24k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2819| 7.24k| *output += static_strlen("\""); ------------------ | | 184| 7.24k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2820| | 2821| | 2822| 8.98M| for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { ------------------ | Branch (2822:12): [True: 8.98M, False: 34] ------------------ 2823| 8.98M| (*output)[0] = (*input)[0]; 2824| | 2825| 8.98M| if ((*input)[0] == '\"') { ------------------ | Branch (2825:13): [True: 7.20k, False: 8.97M] ------------------ 2826| 7.20k| (*output)[0] = '\"'; 2827| 7.20k| *input += static_strlen("\""); ------------------ | | 184| 7.20k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2828| 7.20k| *output += static_strlen("\""); ------------------ | | 184| 7.20k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2829| 7.20k| return; 2830| 8.97M| } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { ------------------ | Branch (2830:20): [True: 5.59k, False: 8.97M] | Branch (2830:45): [True: 537, False: 5.05k] ------------------ 2831| 537| (*output)[1] = (*input)[1]; 2832| 537| *input += static_strlen("\""); ------------------ | | 184| 537|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2833| 537| *output += static_strlen("\""); ------------------ | | 184| 537|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) ------------------ 2834| 537| } 2835| 8.98M| } 2836| 7.24k|} cJSON.c:compare_double: 539| 747|{ 540| 747| double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); ------------------ | Branch (540:21): [True: 449, False: 298] ------------------ 541| 747| return (fabs(a - b) <= maxVal * DBL_EPSILON); 542| 747|} LLVMFuzzerTestOneInput: 14| 2.06k|{ 15| 2.06k| cJSON *json; 16| 2.06k| size_t offset = 4; 17| 2.06k| unsigned char *copied; 18| 2.06k| char *printed_json = NULL; 19| 2.06k| int minify, require_termination, formatted, buffered; 20| | 21| | 22| 2.06k| if(size <= offset) return 0; ------------------ | Branch (22:8): [True: 4, False: 2.05k] ------------------ 23| 2.05k| if(data[size-1] != '\0') return 0; ------------------ | Branch (23:8): [True: 10, False: 2.04k] ------------------ 24| 2.04k| if(data[0] != '1' && data[0] != '0') return 0; ------------------ | Branch (24:8): [True: 704, False: 1.34k] | Branch (24:26): [True: 13, False: 691] ------------------ 25| 2.03k| if(data[1] != '1' && data[1] != '0') return 0; ------------------ | Branch (25:8): [True: 1.34k, False: 693] | Branch (25:26): [True: 15, False: 1.32k] ------------------ 26| 2.02k| if(data[2] != '1' && data[2] != '0') return 0; ------------------ | Branch (26:8): [True: 945, False: 1.07k] | Branch (26:26): [True: 13, False: 932] ------------------ 27| 2.00k| if(data[3] != '1' && data[3] != '0') return 0; ------------------ | Branch (27:8): [True: 1.01k, False: 995] | Branch (27:26): [True: 16, False: 997] ------------------ 28| | 29| 1.99k| minify = data[0] == '1' ? 1 : 0; ------------------ | Branch (29:27): [True: 1.31k, False: 676] ------------------ 30| 1.99k| require_termination = data[1] == '1' ? 1 : 0; ------------------ | Branch (30:27): [True: 681, False: 1.31k] ------------------ 31| 1.99k| formatted = data[2] == '1' ? 1 : 0; ------------------ | Branch (31:27): [True: 1.07k, False: 922] ------------------ 32| 1.99k| buffered = data[3] == '1' ? 1 : 0; ------------------ | Branch (32:27): [True: 995, False: 997] ------------------ 33| | 34| 1.99k| json = cJSON_ParseWithOpts((const char*)data + offset, NULL, require_termination); 35| | 36| 1.99k| if(json == NULL) return 0; ------------------ | Branch (36:8): [True: 946, False: 1.04k] ------------------ 37| | 38| 1.04k| if(buffered) ------------------ | Branch (38:8): [True: 542, False: 504] ------------------ 39| 542| { 40| 542| printed_json = cJSON_PrintBuffered(json, 1, formatted); 41| 542| } 42| 504| else 43| 504| { 44| | /* unbuffered printing */ 45| 504| if(formatted) ------------------ | Branch (45:12): [True: 263, False: 241] ------------------ 46| 263| { 47| 263| printed_json = cJSON_Print(json); 48| 263| } 49| 241| else 50| 241| { 51| 241| printed_json = cJSON_PrintUnformatted(json); 52| 241| } 53| 504| } 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: 754, False: 292] ------------------ 58| 754| { 59| 754| copied = (unsigned char*)malloc(size); 60| 754| if(copied == NULL) return 0; ------------------ | Branch (60:12): [True: 0, False: 754] ------------------ 61| | 62| 754| memcpy(copied, data, size); 63| | 64| 754| cJSON_Minify((char*)copied + offset); 65| | 66| 754| free(copied); 67| 754| } 68| | 69| 1.04k| cJSON_Delete(json); 70| | 71| 1.04k| return 0; 72| 1.04k|}