binop_plus: 84| 2.50M|jv binop_plus(jv a, jv b) { 85| 2.50M| if (jv_get_kind(a) == JV_KIND_NULL) { ------------------ | Branch (85:7): [True: 10.6k, False: 2.49M] ------------------ 86| 10.6k| jv_free(a); 87| 10.6k| return b; 88| 2.49M| } else if (jv_get_kind(b) == JV_KIND_NULL) { ------------------ | Branch (88:14): [True: 13.7k, False: 2.47M] ------------------ 89| 13.7k| jv_free(b); 90| 13.7k| return a; 91| 2.47M| } else if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) { ------------------ | Branch (91:14): [True: 168k, False: 2.31M] | Branch (91:50): [True: 168k, False: 496] ------------------ 92| 168k| jv r = jv_number(jv_number_value(a) + 93| 168k| jv_number_value(b)); 94| 168k| jv_free(a); 95| 168k| jv_free(b); 96| 168k| return r; 97| 2.31M| } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) { ------------------ | Branch (97:14): [True: 649k, False: 1.66M] | Branch (97:50): [True: 649k, False: 18] ------------------ 98| 649k| return jv_string_concat(a, b); 99| 1.66M| } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) { ------------------ | Branch (99:14): [True: 1.61M, False: 46.6k] | Branch (99:49): [True: 1.61M, False: 3] ------------------ 100| 1.61M| return jv_array_concat(a, b); 101| 1.61M| } else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) { ------------------ | Branch (101:14): [True: 46.1k, False: 518] | Branch (101:50): [True: 46.1k, False: 1] ------------------ 102| 46.1k| return jv_object_merge(a, b); 103| 46.1k| } else { 104| 519| return type_error2(a, b, "cannot be added"); 105| 519| } 106| 2.50M|} binop_minus: 289| 543k|jv binop_minus(jv a, jv b) { 290| 543k| if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) { ------------------ | Branch (290:7): [True: 543k, False: 32] | Branch (290:43): [True: 543k, False: 1] ------------------ 291| 543k| jv r = jv_number(jv_number_value(a) - jv_number_value(b)); 292| 543k| jv_free(a); 293| 543k| jv_free(b); 294| 543k| return r; 295| 543k| } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) { ------------------ | Branch (295:14): [True: 30, False: 3] | Branch (295:49): [True: 23, False: 7] ------------------ 296| 23| jv out = jv_array(); 297| 634| jv_array_foreach(a, i, x) { ------------------ | | 93| 23| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 46| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 23, False: 23] | | ------------------ | | 95| 23| for (jv x; \ | | 96| 657| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 634, False: 23] | | | Branch (96:10): [True: 634, False: 23] | | ------------------ | | 97| 657| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 634| i++) ------------------ 298| 634| int include = 1; 299| 1.26k| jv_array_foreach(b, j, y) { ------------------ | | 93| 634| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 1.26k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 634, False: 634] | | ------------------ | | 95| 634| for (jv x; \ | | 96| 1.66k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 1.26k, False: 394] | | | Branch (96:10): [True: 1.26k, False: 394] | | ------------------ | | 97| 1.66k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 1.02k| i++) ------------------ 300| 1.26k| int equal = jv_equal(jv_copy(x), y); 301| 1.26k| if (equal < 0) { ------------------ | Branch (301:13): [True: 0, False: 1.26k] ------------------ 302| 0| jv_free(out); 303| 0| jv_free(x); 304| 0| jv_free(a); 305| 0| jv_free(b); 306| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 307| 0| } 308| 1.26k| if (equal) { ------------------ | Branch (308:13): [True: 240, False: 1.02k] ------------------ 309| 240| include = 0; 310| 240| break; 311| 240| } 312| 1.26k| } 313| 634| if (include) ------------------ | Branch (313:11): [True: 394, False: 240] ------------------ 314| 394| out = jv_array_append(out, jv_copy(x)); 315| 634| jv_free(x); 316| 634| } 317| 23| jv_free(a); 318| 23| jv_free(b); 319| 23| return out; 320| 23| } else { 321| 10| return type_error2(a, b, "cannot be subtracted"); 322| 10| } 323| 543k|} binop_multiply: 325| 546k|jv binop_multiply(jv a, jv b) { 326| 546k| jv_kind ak = jv_get_kind(a); 327| 546k| jv_kind bk = jv_get_kind(b); 328| 546k| if (ak == JV_KIND_NUMBER && bk == JV_KIND_NUMBER) { ------------------ | Branch (328:7): [True: 546k, False: 620] | Branch (328:31): [True: 546k, False: 9] ------------------ 329| 546k| jv r = jv_number(jv_number_value(a) * jv_number_value(b)); 330| 546k| jv_free(a); 331| 546k| jv_free(b); 332| 546k| return r; 333| 546k| } else if ((ak == JV_KIND_STRING && bk == JV_KIND_NUMBER) || ------------------ | Branch (333:15): [True: 613, False: 16] | Branch (333:39): [True: 613, False: 0] ------------------ 334| 616| (ak == JV_KIND_NUMBER && bk == JV_KIND_STRING)) { ------------------ | Branch (334:15): [True: 9, False: 7] | Branch (334:39): [True: 3, False: 6] ------------------ 335| 616| jv str = a; 336| 616| jv num = b; 337| 616| if (ak == JV_KIND_NUMBER) { ------------------ | Branch (337:9): [True: 3, False: 613] ------------------ 338| 3| str = b; 339| 3| num = a; 340| 3| } 341| 616| double d = jv_number_value(num); 342| 616| jv_free(num); 343| 616| return jv_string_repeat(str, 344| 616| d < 0 || isnan(d) ? -1 : d > INT_MAX ? INT_MAX : (int)d); ------------------ | Branch (344:9): [True: 0, False: 616] | Branch (344:18): [True: 0, False: 616] | Branch (344:34): [True: 3, False: 613] ------------------ 345| 616| } else if (ak == JV_KIND_OBJECT && bk == JV_KIND_OBJECT) { ------------------ | Branch (345:14): [True: 4, False: 9] | Branch (345:38): [True: 0, False: 4] ------------------ 346| 0| return jv_object_merge_recursive(a, b); 347| 13| } else { 348| 13| return type_error2(a, b, "cannot be multiplied"); 349| 13| } 350| 546k|} binop_divide: 352| 1.45k|jv binop_divide(jv a, jv b) { 353| 1.45k| if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) { ------------------ | Branch (353:7): [True: 1.37k, False: 82] | Branch (353:43): [True: 946, False: 426] ------------------ 354| 946| if (jv_number_value(b) == 0.0) ------------------ | Branch (354:9): [True: 921, False: 25] ------------------ 355| 921| return type_error2(a, b, "cannot be divided because the divisor is zero"); 356| 25| jv r = jv_number(jv_number_value(a) / jv_number_value(b)); 357| 25| jv_free(a); 358| 25| jv_free(b); 359| 25| return r; 360| 946| } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) { ------------------ | Branch (360:14): [True: 18, False: 490] | Branch (360:50): [True: 18, False: 0] ------------------ 361| 18| return jv_string_split(a, b); 362| 490| } else { 363| 490| return type_error2(a, b, "cannot be divided"); 364| 490| } 365| 1.45k|} binop_equal: 391| 2.08M|jv binop_equal(jv a, jv b) { 392| 2.08M| int r = jv_equal(a, b); 393| 2.08M| if (r < 0) ------------------ | Branch (393:7): [True: 0, False: 2.08M] ------------------ 394| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 395| 2.08M| return jv_bool(r); 396| 2.08M|} binop_notequal: 398| 44.5k|jv binop_notequal(jv a, jv b) { 399| 44.5k| int r = jv_equal(a, b); 400| 44.5k| if (r < 0) ------------------ | Branch (400:7): [True: 0, False: 44.5k] ------------------ 401| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 402| 44.5k| return jv_bool(!r); 403| 44.5k|} binop_less: 422| 547k|jv binop_less(jv a, jv b) { 423| 547k| return order_cmp(a, b, CMP_OP_LESS); 424| 547k|} binop_greater: 426| 6.14k|jv binop_greater(jv a, jv b) { 427| 6.14k| return order_cmp(a, b, CMP_OP_GREATER); 428| 6.14k|} binop_lesseq: 430| 1.47M|jv binop_lesseq(jv a, jv b) { 431| 1.47M| return order_cmp(a, b, CMP_OP_LESSEQ); 432| 1.47M|} binop_greatereq: 434| 701|jv binop_greatereq(jv a, jv b) { 435| 701| return order_cmp(a, b, CMP_OP_GREATEREQ); 436| 701|} builtins_bind: 2144| 7.64k|int builtins_bind(jq_state *jq, block* bb) { 2145| 7.64k| block builtins; 2146| 7.64k| struct locfile* src = locfile_init(jq, "", jq_builtins, sizeof(jq_builtins)-1); 2147| 7.64k| int nerrors = jq_parse_library(src, &builtins); 2148| 7.64k| assert(!nerrors); ------------------ | Branch (2148:3): [True: 0, False: 7.64k] | Branch (2148:3): [True: 7.64k, False: 0] ------------------ 2149| 7.64k| locfile_free(src); 2150| | 2151| 7.64k| builtins = bind_bytecoded_builtins(builtins); 2152| 7.64k| builtins = gen_cbinding(function_list, sizeof(function_list)/sizeof(function_list[0]), builtins); 2153| 7.64k| builtins = gen_builtin_list(builtins); 2154| | 2155| 7.64k| *bb = block_bind_referenced(builtins, *bb, OP_IS_CALL_PSEUDO); 2156| 7.64k| return nerrors; 2157| 7.64k|} builtin.c:type_error2: 61| 2.05k|static jv type_error2(jv bad1, jv bad2, const char* msg) { 62| 2.05k| char errbuf1[30], errbuf2[30]; 63| 2.05k| const char *badkind1 = jv_kind_name(jv_get_kind(bad1)); 64| 2.05k| const char *badkind2 = jv_kind_name(jv_get_kind(bad2)); 65| 2.05k| jv err = jv_invalid_with_msg(jv_string_fmt( 66| 2.05k| "%s (%s) and %s (%s) %s", badkind1, 67| 2.05k| jv_dump_string_trunc(bad1, errbuf1, sizeof(errbuf1)), 68| 2.05k| badkind2, 69| 2.05k| jv_dump_string_trunc(bad2, errbuf2, sizeof(errbuf2)), msg)); 70| 2.05k| return err; 71| 2.05k|} builtin.c:order_cmp: 412| 2.03M|static jv order_cmp(jv a, jv b, enum cmp_op op) { 413| 2.03M| int r = jv_cmp(a, b); 414| 2.03M| if (r == INT_MIN) ------------------ | Branch (414:7): [True: 0, False: 2.03M] ------------------ 415| 0| return jv_invalid_with_msg(jv_string("Comparison too deep")); 416| 2.03M| return jv_bool((op == CMP_OP_LESS && r < 0) || ------------------ | Branch (416:19): [True: 547k, False: 1.48M] | Branch (416:40): [True: 4.19k, False: 543k] ------------------ 417| 2.02M| (op == CMP_OP_LESSEQ && r <= 0) || ------------------ | Branch (417:19): [True: 1.47M, False: 550k] | Branch (417:42): [True: 596k, False: 882k] ------------------ 418| 1.43M| (op == CMP_OP_GREATEREQ && r >= 0) || ------------------ | Branch (418:19): [True: 701, False: 1.43M] | Branch (418:45): [True: 471, False: 230] ------------------ 419| 1.43M| (op == CMP_OP_GREATER && r > 0)); ------------------ | Branch (419:19): [True: 6.14k, False: 1.42M] | Branch (419:43): [True: 190, False: 5.95k] ------------------ 420| 2.03M|} builtin.c:bind_bytecoded_builtins: 2087| 7.64k|static block bind_bytecoded_builtins(block b) { 2088| 7.64k| block builtins = gen_noop(); 2089| 7.64k| { 2090| 7.64k| struct bytecoded_builtin builtin_defs[] = { 2091| 7.64k| {"empty", gen_op_simple(BACKTRACK)}, 2092| 7.64k| {"not", gen_condbranch(gen_const(jv_false()), 2093| 7.64k| gen_const(jv_true()))} 2094| 7.64k| }; 2095| 22.9k| for (unsigned i=0; i 0x10FFFF || (nv >= 0xD800 && nv <= 0xDFFF)) ------------------ | Branch (1440:9): [True: 1.86k, False: 887k] | Branch (1440:19): [True: 622, False: 887k] | Branch (1440:37): [True: 33.9k, False: 853k] | Branch (1440:53): [True: 239, False: 33.7k] ------------------ 1441| 2.72k| nv = 0xFFFD; // U+FFFD REPLACEMENT CHARACTER 1442| 889k| s = jv_string_append_codepoint(s, nv); 1443| 889k| if (!jv_is_valid(s)) break; ------------------ | Branch (1443:9): [True: 0, False: 889k] ------------------ 1444| 889k| } 1445| | 1446| 50.2k| jv_free(a); 1447| 50.2k| return s; 1448| 50.2k|} builtin.c:f_string_indexes: 1357| 19|static jv f_string_indexes(jq_state *jq, jv a, jv b) { 1358| 19| if (jv_get_kind(a) != JV_KIND_STRING) { ------------------ | Branch (1358:7): [True: 0, False: 19] ------------------ 1359| 0| jv_free(b); 1360| 0| return type_error(a, "cannot be searched, as it is not a string"); 1361| 0| } 1362| 19| if (jv_get_kind(b) != JV_KIND_STRING) { ------------------ | Branch (1362:7): [True: 0, False: 19] ------------------ 1363| 0| jv_free(a); 1364| 0| return type_error(b, "is not a string"); 1365| 0| } 1366| 19| return jv_string_indexes(a, b); 1367| 19|} builtin.c:f_setpath: 1450| 1.71M|static jv f_setpath(jq_state *jq, jv a, jv b, jv c) { return jv_setpath(a, b, c); } builtin.c:f_getpath: 1452| 1.25M|static jv f_getpath(jq_state *jq, jv a, jv b) { 1453| 1.25M| return _jq_path_append(jq, a, b, jv_getpath(jv_copy(a), jv_copy(b))); 1454| 1.25M|} builtin.c:f_delpaths: 1455| 119k|static jv f_delpaths(jq_state *jq, jv a, jv b) { return jv_delpaths(a, b); } builtin.c:f_has: 1456| 15.2k|static jv f_has(jq_state *jq, jv a, jv b) { return jv_has(a, b); } builtin.c:f_contains: 438| 58|static jv f_contains(jq_state *jq, jv a, jv b) { 439| 58| if (jv_get_kind(a) == jv_get_kind(b)) { ------------------ | Branch (439:7): [True: 39, False: 19] ------------------ 440| 39| int r = jv_contains(a, b); 441| 39| if (r < 0) ------------------ | Branch (441:9): [True: 0, False: 39] ------------------ 442| 0| return jv_invalid_with_msg(jv_string("Containment check too deep")); 443| 39| return jv_bool(r); 444| 39| } else { 445| 19| return type_error2(a, b, "cannot have their containment checked"); 446| 19| } 447| 58|} builtin.c:f_length: 512| 1.92M|static jv f_length(jq_state *jq, jv input) { 513| 1.92M| if (jv_get_kind(input) == JV_KIND_ARRAY) { ------------------ | Branch (513:7): [True: 1.34M, False: 570k] ------------------ 514| 1.34M| return jv_number(jv_array_length(input)); 515| 1.34M| } else if (jv_get_kind(input) == JV_KIND_OBJECT) { ------------------ | Branch (515:14): [True: 488, False: 569k] ------------------ 516| 488| return jv_number(jv_object_length(input)); 517| 569k| } else if (jv_get_kind(input) == JV_KIND_STRING) { ------------------ | Branch (517:14): [True: 1.79k, False: 567k] ------------------ 518| 1.79k| return jv_number(jv_string_length_codepoints(input)); 519| 567k| } else if (jv_get_kind(input) == JV_KIND_NUMBER) { ------------------ | Branch (519:14): [True: 567k, False: 258] ------------------ 520| 567k| jv r = jv_number_abs(input); 521| 567k| jv_free(input); 522| 567k| return r; 523| 567k| } else if (jv_get_kind(input) == JV_KIND_NULL) { ------------------ | Branch (523:14): [True: 257, False: 1] ------------------ 524| 257| jv_free(input); 525| 257| return jv_number(0); 526| 257| } else { 527| 1| return type_error(input, "has no length"); 528| 1| } 529| 1.92M|} builtin.c:f_utf8bytelength: 539| 3|static jv f_utf8bytelength(jq_state *jq, jv input) { 540| 3| if (jv_get_kind(input) != JV_KIND_STRING) ------------------ | Branch (540:7): [True: 2, False: 1] ------------------ 541| 2| return type_error(input, "only strings have UTF-8 byte length"); 542| 1| return jv_number(jv_string_length_bytes(input)); 543| 3|} builtin.c:f_type: 1240| 46.1k|static jv f_type(jq_state *jq, jv input) { 1241| 46.1k| jv out = jv_string(jv_kind_name(jv_get_kind(input))); 1242| 46.1k| jv_free(input); 1243| 46.1k| return out; 1244| 46.1k|} builtin.c:f_infinite: 1279| 11|static jv f_infinite(jq_state *jq, jv input) { 1280| 11| jv_free(input); 1281| | return jv_number(INFINITY); 1282| 11|} builtin.c:f_sort: 862| 6.91k|static jv f_sort(jq_state *jq, jv input){ 863| 6.91k| if (jv_get_kind(input) == JV_KIND_ARRAY) { ------------------ | Branch (863:7): [True: 6.90k, False: 1] ------------------ 864| 6.90k| return jv_sort(input, jv_copy(input)); 865| 6.90k| } else { 866| 1| return type_error(input, "cannot be sorted, as it is not an array"); 867| 1| } 868| 6.91k|} builtin.c:f_sort_by_impl: 870| 7|static jv f_sort_by_impl(jq_state *jq, jv input, jv keys) { 871| 7| if (jv_get_kind(input) == JV_KIND_ARRAY && ------------------ | Branch (871:7): [True: 6, False: 1] ------------------ 872| 6| jv_get_kind(keys) == JV_KIND_ARRAY && ------------------ | Branch (872:7): [True: 6, False: 0] ------------------ 873| 6| jv_array_length(jv_copy(input)) == jv_array_length(jv_copy(keys))) { ------------------ | Branch (873:7): [True: 6, False: 0] ------------------ 874| 6| return jv_sort(input, keys); 875| 6| } else { 876| 1| return type_error2(input, keys, "cannot be sorted, as they are not both arrays"); 877| 1| } 878| 7|} builtin.c:f_group_by_impl: 920| 16|static jv f_group_by_impl(jq_state *jq, jv input, jv keys) { 921| 16| if (jv_get_kind(input) == JV_KIND_ARRAY && ------------------ | Branch (921:7): [True: 15, False: 1] ------------------ 922| 15| jv_get_kind(keys) == JV_KIND_ARRAY && ------------------ | Branch (922:7): [True: 15, False: 0] ------------------ 923| 15| jv_array_length(jv_copy(input)) == jv_array_length(jv_copy(keys))) { ------------------ | Branch (923:7): [True: 15, False: 0] ------------------ 924| 15| return jv_group(input, keys); 925| 15| } else { 926| 1| return type_error2(input, keys, "cannot be sorted, as they are not both arrays"); 927| 1| } 928| 16|} builtin.c:f_unique: 930| 441|static jv f_unique(jq_state *jq, jv input) { 931| 441| if (jv_get_kind(input) == JV_KIND_ARRAY) { ------------------ | Branch (931:7): [True: 433, False: 8] ------------------ 932| 433| return jv_unique(input, jv_copy(input)); 933| 433| } else { 934| 8| return type_error(input, "cannot be sorted, as it is not an array"); 935| 8| } 936| 441|} builtin.c:f_unique_by_impl: 938| 233|static jv f_unique_by_impl(jq_state *jq, jv input, jv keys) { 939| 233| if (jv_get_kind(input) == JV_KIND_ARRAY && ------------------ | Branch (939:7): [True: 180, False: 53] ------------------ 940| 180| jv_get_kind(keys) == JV_KIND_ARRAY && ------------------ | Branch (940:7): [True: 180, False: 0] ------------------ 941| 180| jv_array_length(jv_copy(input)) == jv_array_length(jv_copy(keys))) { ------------------ | Branch (941:7): [True: 180, False: 0] ------------------ 942| 180| return jv_unique(input, keys); 943| 180| } else { 944| 53| return type_error2(input, keys, "cannot be sorted, as they are not both arrays"); 945| 53| } 946| 233|} builtin.c:f_bsearch: 886| 20|static jv f_bsearch(jq_state *jq, jv input, jv target) { 887| 20| if (jv_get_kind(input) != JV_KIND_ARRAY) { ------------------ | Branch (887:7): [True: 2, False: 18] ------------------ 888| 2| jv_free(target); 889| 2| return type_error(input, "cannot be searched from"); 890| 2| } 891| 18| int start = 0; 892| 18| int end = jv_array_length(jv_copy(input)); 893| 18| jv answer = jv_invalid(); 894| 107| while (start < end) { ------------------ | Branch (894:10): [True: 92, False: 15] ------------------ 895| 92| int mid = start + (end - start) / 2; 896| 92| int result = jv_cmp(jv_copy(target), jv_array_get(jv_copy(input), mid)); 897| 92| if (result == INT_MIN) { ------------------ | Branch (897:9): [True: 0, False: 92] ------------------ 898| 0| jv_free(answer); 899| 0| jv_free(input); 900| 0| jv_free(target); 901| 0| return jv_invalid_with_msg(jv_string("Comparison too deep")); 902| 0| } 903| 92| if (result == 0) { ------------------ | Branch (903:9): [True: 3, False: 89] ------------------ 904| 3| answer = jv_number(mid); 905| 3| break; 906| 89| } else if (result < 0) { ------------------ | Branch (906:16): [True: 57, False: 32] ------------------ 907| 57| end = mid; 908| 57| } else { 909| 32| start = mid + 1; 910| 32| } 911| 92| } 912| 18| if (!jv_is_valid(answer)) { ------------------ | Branch (912:7): [True: 15, False: 3] ------------------ 913| 15| answer = jv_number(-1 - start); 914| 15| } 915| 18| jv_free(input); 916| 18| jv_free(target); 917| 18| return answer; 918| 18|} builtin.c:f_min: 1223| 75|static jv f_min(jq_state *jq, jv x) { 1224| 75| return minmax_by(x, jv_copy(x), 1); 1225| 75|} builtin.c:minmax_by: 1182| 149|static jv minmax_by(jv values, jv keys, int is_min) { 1183| 149| if (jv_get_kind(values) != JV_KIND_ARRAY) ------------------ | Branch (1183:7): [True: 28, False: 121] ------------------ 1184| 28| return type_error2(values, keys, "cannot be iterated over"); 1185| 121| if (jv_get_kind(keys) != JV_KIND_ARRAY) ------------------ | Branch (1185:7): [True: 0, False: 121] ------------------ 1186| 0| return type_error2(values, keys, "cannot be iterated over"); 1187| 121| if (jv_array_length(jv_copy(values)) != jv_array_length(jv_copy(keys))) ------------------ | Branch (1187:7): [True: 0, False: 121] ------------------ 1188| 0| return type_error2(values, keys, "have wrong length"); 1189| | 1190| 121| if (jv_array_length(jv_copy(values)) == 0) { ------------------ | Branch (1190:7): [True: 1, False: 120] ------------------ 1191| 1| jv_free(values); 1192| 1| jv_free(keys); 1193| 1| return jv_null(); 1194| 1| } 1195| 120| jv ret = jv_array_get(jv_copy(values), 0); 1196| 120| jv retkey = jv_array_get(jv_copy(keys), 0); 1197| 559k| for (int i=1; i>\0''\0\""\0"); 684| 190| } else if (!strcmp(fmt_s, "uri")) { ------------------ | Branch (684:14): [True: 0, False: 190] ------------------ 685| 0| jv_free(fmt); 686| 0| input = f_tostring(jq, input); 687| 0| const char* s = jv_string_value(input); 688| 0| int len = jv_string_length_bytes(jv_copy(input)); 689| 0| char *result = jv_mem_alloc((size_t)len * 3 + 1); 690| 0| uint32_t ri = 0; 691| 0| for (int i = 0; i < len; i++) { ------------------ | Branch (691:21): [True: 0, False: 0] ------------------ 692| 0| unsigned c = (unsigned)(unsigned char)s[i]; 693| 0| if (c < 128 && URI_UNRESERVED[c]) { ------------------ | Branch (693:11): [True: 0, False: 0] | Branch (693:22): [True: 0, False: 0] ------------------ 694| 0| result[ri++] = (char)c; 695| 0| } else { 696| 0| result[ri++] = '%'; 697| 0| result[ri++] = "0123456789ABCDEF"[c >> 4]; 698| 0| result[ri++] = "0123456789ABCDEF"[c & 0x0F]; 699| 0| } 700| 0| } 701| 0| jv line = jv_string_sized(result, ri); 702| 0| free(result); 703| 0| jv_free(input); 704| 0| return line; 705| 190| } else if (!strcmp(fmt_s, "urid")) { ------------------ | Branch (705:14): [True: 0, False: 190] ------------------ 706| 0| jv_free(fmt); 707| 0| input = f_tostring(jq, input); 708| 0| const char *errmsg = "is not a valid uri encoding"; 709| 0| const char *s = jv_string_value(input); 710| 0| int len = jv_string_length_bytes(jv_copy(input)); 711| 0| char *result = jv_mem_alloc((size_t)len + 1); 712| 0| uint32_t ri = 0; 713| 0| for (int i = 0; i < len; i++) { ------------------ | Branch (713:21): [True: 0, False: 0] ------------------ 714| 0| char c = s[i]; 715| 0| if (c != '%') { ------------------ | Branch (715:11): [True: 0, False: 0] ------------------ 716| 0| result[ri++] = c; 717| 0| } else { 718| 0| int hi = 0, lo = 0; 719| 0| for (int j = 0; j < 2; j++) { ------------------ | Branch (719:25): [True: 0, False: 0] ------------------ 720| 0| if (++i >= len) { ------------------ | Branch (720:15): [True: 0, False: 0] ------------------ 721| 0| free(result); 722| 0| return type_error(input, errmsg); 723| 0| } 724| 0| int *d = j == 0 ? &hi : &lo; ------------------ | Branch (724:20): [True: 0, False: 0] ------------------ 725| 0| c = s[i]; 726| 0| if ('0' <= c && c <= '9') *d = c - '0'; ------------------ | Branch (726:15): [True: 0, False: 0] | Branch (726:27): [True: 0, False: 0] ------------------ 727| 0| else if ('a' <= c && c <= 'f') *d = c - 'a' + 10; ------------------ | Branch (727:20): [True: 0, False: 0] | Branch (727:32): [True: 0, False: 0] ------------------ 728| 0| else if ('A' <= c && c <= 'F') *d = c - 'A' + 10; ------------------ | Branch (728:20): [True: 0, False: 0] | Branch (728:32): [True: 0, False: 0] ------------------ 729| 0| else { 730| 0| free(result); 731| 0| return type_error(input, errmsg); 732| 0| } 733| 0| } 734| 0| result[ri++] = (hi << 4) | lo; 735| 0| } 736| 0| } 737| 0| if (!jvp_utf8_is_valid(result, result + ri)) { ------------------ | Branch (737:9): [True: 0, False: 0] ------------------ 738| 0| free(result); 739| 0| return type_error(input, errmsg); 740| 0| } 741| 0| jv line = jv_string_sized(result, ri); 742| 0| free(result); 743| 0| jv_free(input); 744| 0| return line; 745| 190| } else if (!strcmp(fmt_s, "sh")) { ------------------ | Branch (745:14): [True: 66, False: 124] ------------------ 746| 66| jv_free(fmt); 747| 66| if (jv_get_kind(input) != JV_KIND_ARRAY) ------------------ | Branch (747:9): [True: 6, False: 60] ------------------ 748| 6| input = jv_array_set(jv_array(), 0, input); 749| 66| jv line = jv_string(""); 750| 548k| jv_array_foreach(input, i, x) { ------------------ | | 93| 66| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 130| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 66, False: 64] | | ------------------ | | 95| 66| for (jv x; \ | | 96| 548k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 548k, False: 64] | | | Branch (96:10): [True: 548k, False: 64] | | ------------------ | | 97| 548k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 548k| i++) ------------------ 751| 548k| if (i) line = jv_string_append_str(line, " "); ------------------ | Branch (751:11): [True: 548k, False: 65] ------------------ 752| 548k| switch (jv_get_kind(x)) { 753| 232| case JV_KIND_NULL: ------------------ | Branch (753:7): [True: 232, False: 548k] ------------------ 754| 299| case JV_KIND_TRUE: ------------------ | Branch (754:7): [True: 67, False: 548k] ------------------ 755| 2.34k| case JV_KIND_FALSE: ------------------ | Branch (755:7): [True: 2.04k, False: 546k] ------------------ 756| 547k| case JV_KIND_NUMBER: ------------------ | Branch (756:7): [True: 545k, False: 3.31k] ------------------ 757| 547k| line = jv_string_concat(line, jv_dump_string(x, 0)); 758| 547k| break; 759| | 760| 976| case JV_KIND_STRING: { ------------------ | Branch (760:7): [True: 976, False: 547k] ------------------ 761| 976| line = jv_string_append_str(line, "'"); 762| 976| line = jv_string_concat(line, escape_string(x, "''\\''\0")); 763| 976| line = jv_string_append_str(line, "'"); 764| 976| break; 765| 2.34k| } 766| | 767| 2| default: ------------------ | Branch (767:7): [True: 2, False: 548k] ------------------ 768| 2| jv_free(input); 769| 2| jv_free(line); 770| 2| return type_error(x, "can not be escaped for shell"); 771| 548k| } 772| 548k| } 773| 64| jv_free(input); 774| 64| return line; 775| 124| } else if (!strcmp(fmt_s, "base64")) { ------------------ | Branch (775:14): [True: 36, False: 88] ------------------ 776| 36| jv_free(fmt); 777| 36| input = f_tostring(jq, input); 778| 36| jv line = jv_string(""); 779| 36| const unsigned char* data = (const unsigned char*)jv_string_value(input); 780| 36| int len = jv_string_length_bytes(jv_copy(input)); 781| 533k| for (int i=0; i= 3 ? 3 : len-i; ------------------ | Branch (783:15): [True: 532k, False: 25] ------------------ 784| 2.13M| for (int j=0; j<3; j++) { ------------------ | Branch (784:21): [True: 1.59M, False: 532k] ------------------ 785| 1.59M| code <<= 8; 786| 1.59M| code |= j < n ? (unsigned)data[i+j] : 0; ------------------ | Branch (786:17): [True: 1.59M, False: 38] ------------------ 787| 1.59M| } 788| 532k| char buf[4]; 789| 2.66M| for (int j=0; j<4; j++) { ------------------ | Branch (789:21): [True: 2.13M, False: 532k] ------------------ 790| 2.13M| buf[j] = BASE64_ENCODE_TABLE[(code >> (18 - j*6)) & 0x3f]; 791| 2.13M| } 792| 532k| if (n < 3) buf[3] = '='; ------------------ | Branch (792:11): [True: 25, False: 532k] ------------------ 793| 532k| if (n < 2) buf[2] = '='; ------------------ | Branch (793:11): [True: 13, False: 532k] ------------------ 794| 532k| line = jv_string_append_buf(line, buf, sizeof(buf)); 795| 532k| } 796| 36| jv_free(input); 797| 36| return line; 798| 88| } else if (!strcmp(fmt_s, "base64d")) { ------------------ | Branch (798:14): [True: 88, False: 0] ------------------ 799| 88| jv_free(fmt); 800| 88| input = f_tostring(jq, input); 801| 88| const unsigned char* data = (const unsigned char*)jv_string_value(input); 802| 88| int len = jv_string_length_bytes(jv_copy(input)); 803| 88| size_t decoded_len = MAX((3 * (size_t)len) / 4, (size_t)1); // 3 usable bytes for every 4 bytes of input ------------------ | | 55| 88| ({ __typeof__ (a) _a = (a); \ | | 56| 88| __typeof__ (b) _b = (b); \ | | 57| 88| _a > _b ? _a : _b; }) | | ------------------ | | | Branch (57:4): [True: 81, False: 7] | | ------------------ ------------------ 804| 88| char *result = jv_mem_calloc(decoded_len, sizeof(char)); 805| 88| uint32_t ri = 0; 806| 88| int input_bytes_read=0; 807| 88| uint32_t code = 0; 808| 1.79k| for (int i=0; i> 16) & 0xFF; 820| 420| result[ri++] = (code >> 8) & 0xFF; 821| 420| result[ri++] = code & 0xFF; 822| 420| input_bytes_read = 0; 823| 420| code = 0; 824| 420| } 825| 1.71k| } 826| 19| if (input_bytes_read == 3) { ------------------ | Branch (826:9): [True: 3, False: 16] ------------------ 827| 3| result[ri++] = (code >> 10) & 0xFF; 828| 3| result[ri++] = (code >> 2) & 0xFF; 829| 16| } else if (input_bytes_read == 2) { ------------------ | Branch (829:16): [True: 4, False: 12] ------------------ 830| 4| result[ri++] = (code >> 4) & 0xFF; 831| 12| } else if (input_bytes_read == 1) { ------------------ | Branch (831:16): [True: 5, False: 7] ------------------ 832| 5| free(result); 833| 5| return type_error(input, "trailing base64 byte found"); 834| 5| } 835| | 836| 14| jv line = jv_string_sized(result, ri); 837| 14| jv_free(input); 838| 14| free(result); 839| 14| return line; 840| 19| } else { 841| 0| jv_free(input); 842| 0| return jv_invalid_with_msg(jv_string_concat(fmt, jv_string(" is not a valid format"))); 843| 0| } 844| 63.5k|} builtin.c:escape_string: 587| 1.01k|static jv escape_string(jv input, const char* escapings) { 588| | 589| 1.01k| assert(jv_get_kind(input) == JV_KIND_STRING); ------------------ | Branch (589:3): [True: 0, False: 1.01k] | Branch (589:3): [True: 1.01k, False: 0] ------------------ 590| 1.01k| const char* lookup[128] = {0}; 591| 1.01k| const char* p = escapings; 592| 1.01k| lookup[0] = "\\0"; 593| 2.17k| while (*p) { ------------------ | Branch (593:10): [True: 1.16k, False: 1.01k] ------------------ 594| 1.16k| lookup[(int)*p] = p+1; 595| 1.16k| p++; 596| 1.16k| p += strlen(p); 597| 1.16k| p++; 598| 1.16k| } 599| | 600| 1.01k| jv ret = jv_string(""); 601| 1.01k| const char* i = jv_string_value(input); 602| 1.01k| const char* end = i + jv_string_length_bytes(jv_copy(input)); 603| 1.01k| const char* cstart; 604| 1.01k| int c = 0; 605| 437k| while ((i = jvp_utf8_next((cstart = i), end, &c))) { ------------------ | Branch (605:10): [True: 436k, False: 1.01k] ------------------ 606| 436k| if (c < 128 && lookup[c]) { ------------------ | Branch (606:9): [True: 434k, False: 2.25k] | Branch (606:20): [True: 1.01k, False: 433k] ------------------ 607| 1.01k| ret = jv_string_append_str(ret, lookup[c]); 608| 435k| } else { 609| 435k| ret = jv_string_append_buf(ret, cstart, i - cstart); 610| 435k| } 611| 436k| } 612| 1.01k| jv_free(input); 613| 1.01k| return ret; 614| | 615| 1.01k|} builtin.c:f_env: 1298| 4|static jv f_env(jq_state *jq, jv input) { 1299| 4| jv_free(input); 1300| 4| jv env = jv_object(); 1301| 4| const char *var, *val; 1302| 136| for (char **e = environ; *e != NULL; e++) { ------------------ | Branch (1302:28): [True: 132, False: 4] ------------------ 1303| 132| var = e[0]; 1304| 132| val = strchr(e[0], '='); 1305| 132| if (val == NULL) ------------------ | Branch (1305:9): [True: 0, False: 132] ------------------ 1306| 0| env = jv_object_set(env, jv_string(var), jv_null()); 1307| 132| else if (val - var < INT_MAX) ------------------ | Branch (1307:14): [True: 132, False: 0] ------------------ 1308| 132| env = jv_object_set(env, jv_string_sized(var, val - var), jv_string(val + 1)); 1309| 132| } 1310| 4| return env; 1311| 4|} builtin.c:f_match: 965| 47.0k|static jv f_match(jq_state *jq, jv input, jv regex, jv modifiers, jv testmode) { 966| 47.0k| int test = jv_equal(testmode, jv_true()); 967| 47.0k| jv result; 968| 47.0k| int onigret; 969| 47.0k| int global = 0; 970| 47.0k| regex_t *reg; 971| 47.0k| OnigErrorInfo einfo; 972| 47.0k| OnigRegion* region; 973| | 974| 47.0k| if (jv_get_kind(input) != JV_KIND_STRING) { ------------------ | Branch (974:7): [True: 79, False: 46.9k] ------------------ 975| 79| jv_free(regex); 976| 79| jv_free(modifiers); 977| 79| return type_error(input, "cannot be matched, as it is not a string"); 978| 79| } 979| | 980| 46.9k| if (jv_get_kind(regex) != JV_KIND_STRING) { ------------------ | Branch (980:7): [True: 0, False: 46.9k] ------------------ 981| 0| jv_free(input); 982| 0| jv_free(modifiers); 983| 0| return type_error(regex, "is not a string"); 984| 0| } 985| | 986| 46.9k| OnigOptionType options = ONIG_OPTION_CAPTURE_GROUP; ------------------ | | 385| 46.9k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | ------------------ | | | | 384| 46.9k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | ------------------ | | | | | | 383| 46.9k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | ------------------ | | | | | | | | 382| 46.9k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | ------------------ | | | | | | | | | | 381| 46.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 380| 46.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 379| 46.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 378| 46.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 377| 46.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 987| | 988| 46.9k| if (jv_get_kind(modifiers) == JV_KIND_STRING) { ------------------ | Branch (988:7): [True: 46.8k, False: 108] ------------------ 989| 46.8k| jv modarray = jv_string_explode(jv_copy(modifiers)); 990| 46.8k| jv_array_foreach(modarray, i, mod) { ------------------ | | 93| 46.8k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 93.6k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 46.8k, False: 46.8k] | | ------------------ | | 95| 46.8k| for (jv x; \ | | 96| 79.6k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 32.8k, False: 46.8k] | | | Branch (96:10): [True: 32.8k, False: 46.8k] | | ------------------ | | 97| 79.6k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 46.8k| i++) ------------------ 991| 32.8k| switch ((int)jv_number_value(mod)) { 992| 30.4k| case 'g': ------------------ | Branch (992:9): [True: 30.4k, False: 2.37k] ------------------ 993| 30.4k| global = 1; 994| 30.4k| break; 995| 2.24k| case 'i': ------------------ | Branch (995:9): [True: 2.24k, False: 30.6k] ------------------ 996| 2.24k| options |= ONIG_OPTION_IGNORECASE; ------------------ | | 377| 2.24k|#define ONIG_OPTION_IGNORECASE 1U ------------------ 997| 2.24k| break; 998| 80| case 'x': ------------------ | Branch (998:9): [True: 80, False: 32.7k] ------------------ 999| 80| options |= ONIG_OPTION_EXTEND; ------------------ | | 378| 80|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | ------------------ | | | | 377| 80|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ ------------------ 1000| 80| break; 1001| 0| case 'm': ------------------ | Branch (1001:9): [True: 0, False: 32.8k] ------------------ 1002| 0| options |= ONIG_OPTION_MULTILINE; ------------------ | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | ------------------ | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | ------------------ | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | ------------------ | | ------------------ ------------------ 1003| 0| break; 1004| 0| case 's': ------------------ | Branch (1004:9): [True: 0, False: 32.8k] ------------------ 1005| 0| options |= ONIG_OPTION_SINGLELINE; ------------------ | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | ------------------ | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1006| 0| break; 1007| 0| case 'p': ------------------ | Branch (1007:9): [True: 0, False: 32.8k] ------------------ 1008| 0| options |= ONIG_OPTION_MULTILINE | ONIG_OPTION_SINGLELINE; ------------------ | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | ------------------ | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | ------------------ | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | ------------------ | | ------------------ ------------------ options |= ONIG_OPTION_MULTILINE | ONIG_OPTION_SINGLELINE; ------------------ | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | ------------------ | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1009| 0| break; 1010| 0| case 'l': ------------------ | Branch (1010:9): [True: 0, False: 32.8k] ------------------ 1011| 0| options |= ONIG_OPTION_FIND_LONGEST; ------------------ | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | ------------------ | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | ------------------ | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | ------------------ | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | ------------------ | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1012| 0| break; 1013| 46| case 'n': ------------------ | Branch (1013:9): [True: 46, False: 32.8k] ------------------ 1014| 46| options |= ONIG_OPTION_FIND_NOT_EMPTY; ------------------ | | 382| 46|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | ------------------ | | | | 381| 46|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 380| 46|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 379| 46|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 378| 46|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 377| 46|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1015| 46| break; 1016| 0| default: ------------------ | Branch (1016:9): [True: 0, False: 32.8k] ------------------ 1017| 0| jv_free(input); 1018| 0| jv_free(regex); 1019| 0| jv_free(modarray); 1020| 0| return jv_invalid_with_msg(jv_string_concat(modifiers, 1021| 0| jv_string(" is not a valid modifier string"))); 1022| 32.8k| } 1023| 32.8k| } 1024| 46.8k| jv_free(modarray); 1025| 46.8k| } else if (jv_get_kind(modifiers) != JV_KIND_NULL) { ------------------ | Branch (1025:14): [True: 0, False: 108] ------------------ 1026| | // If it isn't a string or null, then it is the wrong type... 1027| 0| jv_free(input); 1028| 0| jv_free(regex); 1029| 0| return type_error(modifiers, "is not a string"); 1030| 0| } 1031| | 1032| 46.9k| jv_free(modifiers); 1033| | 1034| 46.9k| onigret = onig_new(®, (const UChar*)jv_string_value(regex), 1035| 46.9k| (const UChar*)(jv_string_value(regex) + jv_string_length_bytes(jv_copy(regex))), 1036| 46.9k| options, ONIG_ENCODING_UTF8, ONIG_SYNTAX_PERL_NG, &einfo); ------------------ | | 205| 46.9k|#define ONIG_ENCODING_UTF8 (&OnigEncodingUTF8) ------------------ options, ONIG_ENCODING_UTF8, ONIG_SYNTAX_PERL_NG, &einfo); ------------------ | | 443| 46.9k|#define ONIG_SYNTAX_PERL_NG (&OnigSyntaxPerl_NG) ------------------ 1037| 46.9k| if (onigret != ONIG_NORMAL) { ------------------ | | 563| 46.9k|#define ONIG_NORMAL 0 ------------------ | Branch (1037:7): [True: 0, False: 46.9k] ------------------ 1038| 0| UChar ebuf[ONIG_MAX_ERROR_MESSAGE_LEN]; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 1039| 0| onig_error_code_to_str(ebuf, onigret, &einfo); 1040| 0| jv_free(input); 1041| 0| jv_free(regex); 1042| 0| return jv_invalid_with_msg(jv_string_concat(jv_string("Regex failure: "), 1043| 0| jv_string((char*)ebuf))); 1044| 0| } 1045| 46.9k| result = test ? jv_false() : jv_array(); ------------------ | Branch (1045:12): [True: 25, False: 46.9k] ------------------ 1046| 46.9k| const char *input_string = jv_string_value(input); 1047| 46.9k| const UChar* start = (const UChar*)jv_string_value(input); 1048| 46.9k| const unsigned long length = jv_string_length_bytes(jv_copy(input)); 1049| 46.9k| const UChar* end = start + length; 1050| 46.9k| region = onig_region_new(); 1051| 140k| do { 1052| 140k| onigret = onig_search(reg, 1053| 140k| (const UChar*)jv_string_value(input), end, /* string boundaries */ 1054| 140k| start, end, /* search boundaries */ 1055| 140k| region, ONIG_OPTION_NONE); ------------------ | | 375| 140k|#define ONIG_OPTION_NONE 0U ------------------ 1056| 140k| if (onigret >= 0) { ------------------ | Branch (1056:9): [True: 97.8k, False: 42.2k] ------------------ 1057| 97.8k| if (test) { ------------------ | Branch (1057:11): [True: 18, False: 97.7k] ------------------ 1058| 18| result = jv_true(); 1059| 18| break; 1060| 18| } 1061| | 1062| | // Zero-width match 1063| 97.7k| if (region->end[0] == region->beg[0]) { ------------------ | Branch (1063:11): [True: 46.5k, False: 51.2k] ------------------ 1064| 46.5k| unsigned long idx; 1065| 46.5k| const char *fr = (const char*)input_string; 1066| 160M| for (idx = 0; fr < input_string+region->beg[0]; idx++) { ------------------ | Branch (1066:23): [True: 160M, False: 46.5k] ------------------ 1067| 160M| fr += jvp_utf8_decode_length(*fr); 1068| 160M| } 1069| 46.5k| jv match = jv_object_set(jv_object(), jv_string("offset"), jv_number(idx)); 1070| 46.5k| match = jv_object_set(match, jv_string("length"), jv_number(0)); 1071| 46.5k| match = jv_object_set(match, jv_string("string"), jv_string("")); 1072| 46.5k| jv captures = jv_array(); 1073| 47.3k| for (int i = 1; i < region->num_regs; ++i) { ------------------ | Branch (1073:25): [True: 808, False: 46.5k] ------------------ 1074| 808| jv cap = jv_object(); 1075| 808| if (region->beg[i] == -1) { ------------------ | Branch (1075:15): [True: 0, False: 808] ------------------ 1076| 0| cap = jv_object_set(cap, jv_string("offset"), jv_number(-1)); 1077| 0| cap = jv_object_set(cap, jv_string("string"), jv_null()); 1078| 808| } else { 1079| 808| cap = jv_object_set(cap, jv_string("offset"), jv_number(idx)); 1080| 808| cap = jv_object_set(cap, jv_string("string"), jv_string("")); 1081| 808| } 1082| 808| cap = jv_object_set(cap, jv_string("length"), jv_number(0)); 1083| 808| cap = jv_object_set(cap, jv_string("name"), jv_null()); 1084| 808| captures = jv_array_append(captures, cap); 1085| 808| } 1086| 46.5k| onig_foreach_name(reg, f_match_name_iter, &captures); 1087| 46.5k| match = jv_object_set(match, jv_string("captures"), captures); 1088| 46.5k| result = jv_array_append(result, match); 1089| | // ensure '"qux" | match("(?=u)"; "g")' matches just once; advance the 1090| | // search start past the whole codepoint, not a single byte, so we don't 1091| | // land in the middle of a multibyte character (which would yield a 1092| | // spurious duplicate match at the same offset). 1093| 46.5k| start = (const UChar*)(input_string + region->end[0] + 1094| 46.5k| ((size_t)region->end[0] < length ------------------ | Branch (1094:14): [True: 46.2k, False: 246] ------------------ 1095| 46.5k| ? jvp_utf8_decode_length(input_string[region->end[0]]) 1096| 46.5k| : 1)); 1097| 46.5k| continue; 1098| 46.5k| } 1099| | 1100| 51.2k| unsigned long idx; 1101| 51.2k| unsigned long len; 1102| 51.2k| const char *fr = (const char*)input_string; 1103| | 1104| 351M| for (idx = len = 0; fr < input_string+region->end[0]; len++) { ------------------ | Branch (1104:27): [True: 351M, False: 51.2k] ------------------ 1105| 351M| if (fr == input_string+region->beg[0]) idx = len, len=0; ------------------ | Branch (1105:13): [True: 51.2k, False: 351M] ------------------ 1106| 351M| fr += jvp_utf8_decode_length(*fr); 1107| 351M| } 1108| | 1109| 51.2k| jv match = jv_object_set(jv_object(), jv_string("offset"), jv_number(idx)); 1110| | 1111| 51.2k| unsigned long blen = region->end[0]-region->beg[0]; 1112| 51.2k| match = jv_object_set(match, jv_string("length"), jv_number(len)); 1113| 51.2k| match = jv_object_set(match, jv_string("string"), jv_string_sized(input_string+region->beg[0],blen)); 1114| 51.2k| jv captures = jv_array(); 1115| 95.8k| for (int i = 1; i < region->num_regs; ++i) { ------------------ | Branch (1115:23): [True: 44.6k, False: 51.2k] ------------------ 1116| | // Empty capture. 1117| 44.6k| if (region->beg[i] == region->end[i]) { ------------------ | Branch (1117:13): [True: 527, False: 44.0k] ------------------ 1118| | // Didn't match. 1119| 527| jv cap; 1120| 527| if (region->beg[i] == -1) { ------------------ | Branch (1120:15): [True: 481, False: 46] ------------------ 1121| 481| cap = jv_object_set(jv_object(), jv_string("offset"), jv_number(-1)); 1122| 481| cap = jv_object_set(cap, jv_string("string"), jv_null()); 1123| 481| } else { 1124| 46| fr = input_string; 1125| 1.53M| for (idx = 0; fr < input_string+region->beg[i]; idx++) { ------------------ | Branch (1125:27): [True: 1.53M, False: 46] ------------------ 1126| 1.53M| fr += jvp_utf8_decode_length(*fr); 1127| 1.53M| } 1128| 46| cap = jv_object_set(jv_object(), jv_string("offset"), jv_number(idx)); 1129| 46| cap = jv_object_set(cap, jv_string("string"), jv_string("")); 1130| 46| } 1131| 527| cap = jv_object_set(cap, jv_string("length"), jv_number(0)); 1132| 527| cap = jv_object_set(cap, jv_string("name"), jv_null()); 1133| 527| captures = jv_array_append(captures, cap); 1134| 527| continue; 1135| 527| } 1136| 44.0k| fr = input_string; 1137| 385M| for (idx = len = 0; fr < input_string+region->end[i]; len++) { ------------------ | Branch (1137:29): [True: 385M, False: 44.0k] ------------------ 1138| 385M| if (fr == input_string+region->beg[i]) idx = len, len=0; ------------------ | Branch (1138:15): [True: 44.0k, False: 385M] ------------------ 1139| 385M| fr += jvp_utf8_decode_length(*fr); 1140| 385M| } 1141| | 1142| 44.0k| blen = region->end[i]-region->beg[i]; 1143| 44.0k| jv cap = jv_object_set(jv_object(), jv_string("offset"), jv_number(idx)); 1144| 44.0k| cap = jv_object_set(cap, jv_string("length"), jv_number(len)); 1145| 44.0k| cap = jv_object_set(cap, jv_string("string"), jv_string_sized(input_string+region->beg[i],blen)); 1146| 44.0k| cap = jv_object_set(cap, jv_string("name"), jv_null()); 1147| 44.0k| captures = jv_array_append(captures,cap); 1148| 44.0k| } 1149| 51.2k| onig_foreach_name(reg,f_match_name_iter,&captures); 1150| 51.2k| match = jv_object_set(match, jv_string("captures"), captures); 1151| 51.2k| result = jv_array_append(result, match); 1152| 51.2k| start = (const UChar*)(input_string+region->end[0]); 1153| 51.2k| onig_region_free(region,0); 1154| 51.2k| } else if (onigret == ONIG_MISMATCH) { ------------------ | | 565| 42.2k|#define ONIG_MISMATCH -1 ------------------ | Branch (1154:16): [True: 42.2k, False: 0] ------------------ 1155| 42.2k| break; 1156| 42.2k| } else { /* Error */ 1157| 0| UChar ebuf[ONIG_MAX_ERROR_MESSAGE_LEN]; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 1158| 0| onig_error_code_to_str(ebuf, onigret, &einfo); 1159| 0| jv_free(result); 1160| 0| result = jv_invalid_with_msg(jv_string_concat(jv_string("Regex failure: "), 1161| 0| jv_string((char*)ebuf))); 1162| 0| break; 1163| 0| } 1164| 140k| } while (global && start <= end); ------------------ | Branch (1164:12): [True: 93.3k, False: 4.46k] | Branch (1164:22): [True: 93.0k, False: 246] ------------------ 1165| 46.9k| onig_region_free(region,1); 1166| | region = NULL; 1167| 46.9k| onig_free(reg); 1168| 46.9k| jv_free(input); 1169| 46.9k| jv_free(regex); 1170| 46.9k| return result; 1171| 46.9k|} builtin.c:f_match_name_iter: 950| 43.7k| int *groups, regex_t *reg, void *arg) { 951| 43.7k| jv captures = *(jv*)arg; 952| 87.5k| for (int i = 0; i < ngroups; ++i) { ------------------ | Branch (952:19): [True: 43.7k, False: 43.7k] ------------------ 953| 43.7k| jv cap = jv_array_get(jv_copy(captures),groups[i]-1); 954| 43.7k| if (jv_get_kind(cap) == JV_KIND_OBJECT) { ------------------ | Branch (954:9): [True: 43.7k, False: 0] ------------------ 955| 43.7k| cap = jv_object_set(cap, jv_string("name"), jv_string_sized((const char*)name, name_end-name)); 956| 43.7k| captures = jv_array_set(captures,groups[i]-1,cap); 957| 43.7k| } else { 958| 0| jv_free(cap); 959| 0| } 960| 43.7k| } 961| 43.7k| *(jv *)arg = captures; 962| 43.7k| return 0; 963| 43.7k|} builtin.c:f_strptime: 1631| 20|static jv f_strptime(jq_state *jq, jv a, jv b) { 1632| 20| if (jv_get_kind(a) != JV_KIND_STRING || jv_get_kind(b) != JV_KIND_STRING) { ------------------ | Branch (1632:7): [True: 1, False: 19] | Branch (1632:43): [True: 0, False: 19] ------------------ 1633| 1| return ret_error2(a, b, jv_string("strptime/1 requires string inputs and arguments")); 1634| 1| } 1635| | 1636| 19| struct tm tm; 1637| 19| memset(&tm, 0, sizeof(tm)); 1638| 19| tm.tm_wday = 8; // sentinel 1639| 19| tm.tm_yday = 367; // sentinel 1640| | 1641| 19| const char *input = jv_string_value(a); 1642| 19| const char *fmt = jv_string_value(b); 1643| 19| const char *end = strptime(input, fmt, &tm); 1644| 19| if (end == NULL || (*end != '\0' && !isspace((unsigned char)*end))) { ------------------ | Branch (1644:7): [True: 19, False: 0] | Branch (1644:23): [True: 0, False: 0] | Branch (1644:39): [True: 0, False: 0] ------------------ 1645| 19| return ret_error2(a, b, jv_string_fmt("date \"%s\" does not match format \"%s\"", input, fmt)); 1646| 19| } 1647| 0| jv_free(b); 1648| | /* 1649| | * This is OS X or some *BSD whose strptime() is just not that 1650| | * helpful! 1651| | * 1652| | * We don't know that the format string did involve parsing a 1653| | * year, or a month (if tm->tm_mon == 0). But with our invalid 1654| | * day-of-week and day-of-year sentinel checks above, the worst 1655| | * this can do is produce garbage. 1656| | */ 1657| |#ifdef __APPLE__ 1658| | /* 1659| | * Apple has made it worse, and different versions of the OS have different 1660| | * behaviors. Some versions just don't touch the fields, but others do, and 1661| | * sometimes provide wrong answers, at that! We can't tell at compile-time 1662| | * which behavior the target system will have, so instead we always use our 1663| | * functions to set these on OS X, and document that %u and %j are 1664| | * unsupported on OS X. 1665| | */ 1666| | set_tm_wday(&tm); 1667| | set_tm_yday(&tm); 1668| |#elif defined(WIN32) || !defined(HAVE_STRPTIME) 1669| | set_tm_wday(&tm); 1670| |#else 1671| 0| if (tm.tm_wday == 8 && tm.tm_mday != 0 && tm.tm_mon >= 0 && tm.tm_mon <= 11) ------------------ | Branch (1671:7): [True: 0, False: 0] | Branch (1671:26): [True: 0, False: 0] | Branch (1671:45): [True: 0, False: 0] | Branch (1671:63): [True: 0, False: 0] ------------------ 1672| 0| set_tm_wday(&tm); 1673| 0| if (tm.tm_yday == 367 && tm.tm_mday != 0 && tm.tm_mon >= 0 && tm.tm_mon <= 11) ------------------ | Branch (1673:7): [True: 0, False: 0] | Branch (1673:28): [True: 0, False: 0] | Branch (1673:47): [True: 0, False: 0] | Branch (1673:65): [True: 0, False: 0] ------------------ 1674| 0| set_tm_yday(&tm); 1675| 0|#endif 1676| 0| jv r = tm2jv(&tm, 0); 1677| 0| if (*end != '\0') ------------------ | Branch (1677:7): [True: 0, False: 0] ------------------ 1678| 0| r = jv_array_append(r, jv_string(end)); 1679| 0| jv_free(a); // must come after `*end` because `end` is a pointer into `a`'s string 1680| 0| return r; 1681| 19|} builtin.c:gen_builtin_list: 2139| 7.64k|static block gen_builtin_list(block builtins) { 2140| 7.64k| jv list = jv_array_append(block_list_funcs(builtins, 1), jv_string("builtins/0")); 2141| 7.64k| return BLOCK(builtins, gen_function("builtins", gen_noop(), gen_const(list))); ------------------ | | 102| 7.64k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.64k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.64k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 7.64k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2142| 7.64k|} opcode_describe: 31| 162M|const struct opcode_description* opcode_describe(opcode op) { 32| 162M| if ((int)op >= 0 && (int)op < NUM_OPCODES) { ------------------ | Branch (32:7): [True: 162M, False: 0] | Branch (32:23): [True: 162M, False: 0] ------------------ 33| 162M| return &opcode_descriptions[op]; 34| 162M| } else { 35| 0| return &invalid_opcode_description; 36| 0| } 37| 162M|} bytecode_operation_length: 40| 657k|int bytecode_operation_length(uint16_t* codeptr) { 41| 657k| int length = opcode_describe(*codeptr)->length; 42| 657k| if (*codeptr == CALL_JQ || *codeptr == TAIL_CALL_JQ) { ------------------ | Branch (42:7): [True: 35.8k, False: 621k] | Branch (42:30): [True: 6.10k, False: 615k] ------------------ 43| 42.0k| length += codeptr[1] * 2; 44| 42.0k| } 45| 657k| return length; 46| 657k|} bytecode_free: 149| 49.8k|void bytecode_free(struct bytecode* bc) { 150| 49.8k| if (!bc) ------------------ | Branch (150:7): [True: 5, False: 49.8k] ------------------ 151| 5| return; 152| 49.8k| jv_mem_free(bc->code); 153| 49.8k| jv_free(bc->constants); 154| 91.9k| for (int i=0; insubfunctions; i++) ------------------ | Branch (154:17): [True: 42.1k, False: 49.8k] ------------------ 155| 42.1k| bytecode_free(bc->subfunctions[i]); 156| 49.8k| if (!bc->parent) ------------------ | Branch (156:7): [True: 7.64k, False: 42.1k] ------------------ 157| 7.64k| symbol_table_free(bc->globals); 158| 49.8k| jv_mem_free(bc->subfunctions); 159| 49.8k| jv_free(bc->debuginfo); 160| 49.8k| jv_mem_free(bc); 161| 49.8k|} bytecode.c:symbol_table_free: 58| 7.64k|static void symbol_table_free(struct symbol_table* syms) { 59| 7.64k| jv_mem_free(syms->cfunctions); 60| 7.64k| jv_free(syms->cfunc_names); 61| 7.64k| jv_mem_free(syms); 62| 7.64k|} block_is_single: 102| 82.1M|int block_is_single(block b) { 103| 82.1M| return b.first && b.first == b.last; ------------------ | Branch (103:10): [True: 81.9M, False: 232k] | Branch (103:21): [True: 81.4M, False: 488k] ------------------ 104| 82.1M|} gen_location: 120| 3.36M|block gen_location(location loc, struct locfile* l, block b) { 121| 7.57M| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (121:27): [True: 4.20M, False: 3.36M] ------------------ 122| 4.20M| if (i->source.start == UNKNOWN_LOCATION.start && ------------------ | Branch (122:9): [True: 4.06M, False: 145k] ------------------ 123| 4.06M| i->source.end == UNKNOWN_LOCATION.end) { ------------------ | Branch (123:9): [True: 4.06M, False: 0] ------------------ 124| 4.06M| i->source = loc; 125| 4.06M| i->locfile = locfile_retain(l); 126| 4.06M| } 127| 4.20M| } 128| 3.36M| return b; 129| 3.36M|} gen_noop: 131| 59.7M|block gen_noop(void) { 132| 59.7M| block b = {0,0}; 133| 59.7M| return b; 134| 59.7M|} block_is_noop: 136| 3.05M|int block_is_noop(block b) { 137| 3.05M| return (b.first == 0 && b.last == 0); ------------------ | Branch (137:11): [True: 853k, False: 2.20M] | Branch (137:27): [True: 853k, False: 0] ------------------ 138| 3.05M|} gen_op_simple: 140| 7.22M|block gen_op_simple(opcode op) { 141| 7.22M| assert(opcode_describe(op)->length == 1); ------------------ | Branch (141:3): [True: 0, False: 7.22M] | Branch (141:3): [True: 7.22M, False: 0] ------------------ 142| 7.22M| return inst_block(inst_new(op)); 143| 7.22M|} gen_const: 153| 3.32M|block gen_const(jv constant) { 154| 3.32M| assert(opcode_describe(LOADK)->flags & OP_HAS_CONSTANT); ------------------ | Branch (154:3): [True: 0, False: 3.32M] | Branch (154:3): [True: 3.32M, False: 0] ------------------ 155| 3.32M| inst* i = inst_new(LOADK); 156| 3.32M| i->imm.constant = constant; 157| 3.32M| return inst_block(i); 158| 3.32M|} gen_op_pushk_under: 170| 794k|block gen_op_pushk_under(jv constant) { 171| 794k| assert(opcode_describe(PUSHK_UNDER)->flags & OP_HAS_CONSTANT); ------------------ | Branch (171:3): [True: 0, False: 794k] | Branch (171:3): [True: 794k, False: 0] ------------------ 172| 794k| inst* i = inst_new(PUSHK_UNDER); 173| 794k| i->imm.constant = constant; 174| 794k| return inst_block(i); 175| 794k|} block_is_const: 177| 2.75M|int block_is_const(block b) { 178| 2.75M| return (block_is_single(b) && (b.first->op == LOADK || b.first->op == PUSHK_UNDER)); ------------------ | Branch (178:11): [True: 2.73M, False: 22.9k] | Branch (178:34): [True: 2.31M, False: 421k] | Branch (178:58): [True: 0, False: 421k] ------------------ 179| 2.75M|} block_const_kind: 181| 7.64k|jv_kind block_const_kind(block b) { 182| 7.64k| assert(block_is_const(b)); ------------------ | Branch (182:3): [True: 0, False: 7.64k] | Branch (182:3): [True: 7.64k, False: 0] ------------------ 183| 7.64k| return jv_get_kind(b.first->imm.constant); 184| 7.64k|} block_const: 186| 1.53M|jv block_const(block b) { 187| 1.53M| assert(block_is_const(b)); ------------------ | Branch (187:3): [True: 0, False: 1.53M] | Branch (187:3): [True: 1.53M, False: 0] ------------------ 188| 1.53M| return jv_copy(b.first->imm.constant); 189| 1.53M|} gen_op_target: 191| 1.99M|block gen_op_target(opcode op, block target) { 192| 1.99M| assert(opcode_describe(op)->flags & OP_HAS_BRANCH); ------------------ | Branch (192:3): [True: 0, False: 1.99M] | Branch (192:3): [True: 1.99M, False: 0] ------------------ 193| 1.99M| assert(target.last); ------------------ | Branch (193:3): [True: 0, False: 1.99M] | Branch (193:3): [True: 1.99M, False: 0] ------------------ 194| 1.99M| inst* i = inst_new(op); 195| 1.99M| i->imm.target = target.last; 196| 1.99M| return inst_block(i); 197| 1.99M|} gen_op_targetlater: 199| 139k|block gen_op_targetlater(opcode op) { 200| 139k| assert(opcode_describe(op)->flags & OP_HAS_BRANCH); ------------------ | Branch (200:3): [True: 0, False: 139k] | Branch (200:3): [True: 139k, False: 0] ------------------ 201| 139k| inst* i = inst_new(op); 202| 139k| i->imm.target = 0; 203| 139k| return inst_block(i); 204| 139k|} inst_set_target: 205| 139k|void inst_set_target(block b, block target) { 206| 139k| assert(block_is_single(b)); ------------------ | Branch (206:3): [True: 0, False: 139k] | Branch (206:3): [True: 139k, False: 0] ------------------ 207| 139k| assert(opcode_describe(b.first->op)->flags & OP_HAS_BRANCH); ------------------ | Branch (207:3): [True: 0, False: 139k] | Branch (207:3): [True: 139k, False: 0] ------------------ 208| 139k| assert(target.last); ------------------ | Branch (208:3): [True: 0, False: 139k] | Branch (208:3): [True: 139k, False: 0] ------------------ 209| 139k| b.first->imm.target = target.last; 210| 139k|} gen_op_unbound: 212| 7.37M|block gen_op_unbound(opcode op, const char* name) { 213| 7.37M| assert(opcode_describe(op)->flags & OP_HAS_BINDING); ------------------ | Branch (213:3): [True: 0, False: 7.37M] | Branch (213:3): [True: 7.37M, False: 0] ------------------ 214| 7.37M| inst* i = inst_new(op); 215| 7.37M| i->symbol = strdup(name); 216| 7.37M| i->any_unbound = 1; 217| 7.37M| return inst_block(i); 218| 7.37M|} gen_op_var_fresh: 220| 423k|block gen_op_var_fresh(opcode op, const char* name) { 221| 423k| assert(opcode_describe(op)->flags & OP_HAS_VARIABLE); ------------------ | Branch (221:3): [True: 0, False: 423k] | Branch (221:3): [True: 423k, False: 0] ------------------ 222| 423k| block b = gen_op_unbound(op, name); 223| 423k| b.first->bound_by = b.first; 224| 423k| return b; 225| 423k|} gen_op_bound: 227| 941k|block gen_op_bound(opcode op, block binder) { 228| 941k| assert(block_is_single(binder)); ------------------ | Branch (228:3): [True: 0, False: 941k] | Branch (228:3): [True: 941k, False: 0] ------------------ 229| 941k| block b = gen_op_unbound(op, binder.first->symbol); 230| 941k| b.first->bound_by = binder.first; 231| 941k| b.first->any_unbound = 0; 232| 941k| return b; 233| 941k|} gen_dictpair: 235| 91.9k|block gen_dictpair(block k, block v) { 236| 91.9k| return BLOCK(gen_subexp(k), gen_subexp(v), gen_op_simple(INSERT)); ------------------ | | 102| 91.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 91.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 91.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 91.9k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 91.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 237| 91.9k|} block_append: 248| 20.7M|void block_append(block* b, block b2) { 249| 20.7M| if (b2.first) { ------------------ | Branch (249:7): [True: 19.6M, False: 1.14M] ------------------ 250| 19.6M| if (b->last) { ------------------ | Branch (250:9): [True: 18.8M, False: 770k] ------------------ 251| 18.8M| inst_join(b->last, b2.first); 252| 18.8M| } else { 253| 770k| b->first = b2.first; 254| 770k| } 255| 19.6M| b->last = b2.last; 256| 19.6M| } 257| 20.7M|} block_join: 259| 20.7M|block block_join(block a, block b) { 260| 20.7M| block c = a; 261| 20.7M| block_append(&c, b); 262| 20.7M| return c; 263| 20.7M|} block_has_only_binders_and_imports: 265| 7.64k|int block_has_only_binders_and_imports(block binders, int bindflags) { 266| 7.64k| bindflags |= OP_HAS_BINDING; 267| 818k| for (inst* curr = binders.first; curr; curr = curr->next) { ------------------ | Branch (267:36): [True: 810k, False: 7.64k] ------------------ 268| 810k| if ((opcode_describe(curr->op)->flags & bindflags) != bindflags && curr->op != DEPS && curr->op != MODULEMETA) { ------------------ | Branch (268:9): [True: 0, False: 810k] | Branch (268:72): [True: 0, False: 0] | Branch (268:92): [True: 0, False: 0] ------------------ 269| 0| return 0; 270| 0| } 271| 810k| } 272| 7.64k| return 1; 273| 7.64k|} block_has_only_binders: 279| 84.4k|int block_has_only_binders(block binders, int bindflags) { 280| 84.4k| bindflags |= OP_HAS_BINDING; 281| 84.4k| bindflags &= ~OP_BIND_WILDCARD; 282| 2.05M| for (inst* curr = binders.first; curr; curr = curr->next) { ------------------ | Branch (282:36): [True: 1.97M, False: 84.4k] ------------------ 283| 1.97M| if ((opcode_describe(curr->op)->flags & bindflags) != bindflags && curr->op != MODULEMETA) { ------------------ | Branch (283:9): [True: 0, False: 1.97M] | Branch (283:72): [True: 0, False: 0] ------------------ 284| 0| return 0; 285| 0| } 286| 1.97M| } 287| 84.4k| return 1; 288| 84.4k|} block_bind_referenced: 421| 61.4k|block block_bind_referenced(block binder, block body, int bindflags) { 422| 61.4k| assert(block_has_only_binders(binder, bindflags)); ------------------ | Branch (422:3): [True: 0, False: 61.4k] | Branch (422:3): [True: 61.4k, False: 0] ------------------ 423| 61.4k| bindflags |= OP_HAS_BINDING; 424| | 425| 61.4k| inst* curr; 426| 2.01M| while ((curr = block_take_last(&binder))) { ------------------ | Branch (426:10): [True: 1.95M, False: 61.4k] ------------------ 427| 1.95M| block b = inst_block(curr); 428| 1.95M| if (block_bind_subblock(b, body, bindflags, 0) == 0) { ------------------ | Branch (428:9): [True: 1.85M, False: 92.6k] ------------------ 429| 1.85M| block_free(b); 430| 1.85M| } else { 431| 92.6k| body = BLOCK(b, body); ------------------ | | 102| 92.6k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 92.6k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 92.6k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 92.6k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 432| 92.6k| } 433| 1.95M| } 434| 61.4k| return body; 435| 61.4k|} block_drop_unreferenced: 468| 7.64k|block block_drop_unreferenced(block body) { 469| 7.64k| block_mark_referenced(body); 470| | 471| 7.64k| block refd = gen_noop(); 472| 7.64k| inst* curr; 473| 51.2k| while ((curr = block_take(&body))) { ------------------ | Branch (473:10): [True: 43.6k, False: 7.64k] ------------------ 474| 43.6k| if (curr->bound_by == curr && !curr->referenced) { ------------------ | Branch (474:9): [True: 3.83k, False: 39.7k] | Branch (474:35): [True: 0, False: 3.83k] ------------------ 475| 0| inst_free(curr); 476| 43.6k| } else { 477| 43.6k| refd = BLOCK(refd, inst_block(curr)); ------------------ | | 102| 43.6k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 43.6k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 43.6k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 43.6k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 478| 43.6k| } 479| 43.6k| } 480| 7.64k| return refd; 481| 7.64k|} block_take_imports: 483| 7.64k|jv block_take_imports(block* body) { 484| 7.64k| jv imports = jv_array(); 485| | 486| | /* Parser should never generate TOP before imports */ 487| 7.64k| assert(!(body->first && body->first->op == TOP && body->first->next && ------------------ | Branch (487:3): [True: 0, False: 7.64k] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 7.64k, False: 0] | Branch (487:3): [True: 0, False: 7.64k] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 0, False: 0] ------------------ 488| 7.64k| (body->first->next->op == MODULEMETA || body->first->next->op == DEPS))); 489| | 490| 15.2k| while (body->first && (body->first->op == MODULEMETA || body->first->op == DEPS)) { ------------------ | Branch (490:10): [True: 15.2k, False: 0] | Branch (490:26): [True: 0, False: 15.2k] | Branch (490:59): [True: 7.64k, False: 7.64k] ------------------ 491| 7.64k| inst* dep = block_take(body); 492| 7.64k| if (dep->op == DEPS) { ------------------ | Branch (492:9): [True: 7.64k, False: 0] ------------------ 493| 7.64k| imports = jv_array_append(imports, jv_copy(dep->imm.constant)); 494| 7.64k| } 495| 7.64k| inst_free(dep); 496| 7.64k| } 497| 7.64k| return imports; 498| 7.64k|} block_list_funcs: 500| 7.64k|jv block_list_funcs(block body, int omit_underscores) { 501| 7.64k| jv funcs = jv_object(); // Use the keys for set semantics. 502| 1.89M| for (inst *pos = body.first; pos != NULL; pos = pos->next) { ------------------ | Branch (502:32): [True: 1.88M, False: 7.64k] ------------------ 503| 1.88M| if (pos->op == CLOSURE_CREATE || pos->op == CLOSURE_CREATE_C) { ------------------ | Branch (503:9): [True: 848k, False: 1.04M] | Branch (503:38): [True: 1.04M, False: 0] ------------------ 504| 1.88M| if (pos->symbol != NULL && (!omit_underscores || pos->symbol[0] != '_')) { ------------------ | Branch (504:11): [True: 1.88M, False: 0] | Branch (504:35): [True: 0, False: 1.88M] | Branch (504:56): [True: 1.72M, False: 168k] ------------------ 505| 1.72M| funcs = jv_object_set(funcs, jv_string_fmt("%s/%i", pos->symbol, pos->nformals), jv_null()); 506| 1.72M| } 507| 1.88M| } 508| 1.88M| } 509| 7.64k| return jv_keys_unsorted(funcs); 510| 7.64k|} gen_import: 528| 7.64k|block gen_import(jv name, jv as, int is_data) { 529| 7.64k| assert(jv_get_kind(name) == JV_KIND_STRING); ------------------ | Branch (529:3): [True: 0, False: 7.64k] | Branch (529:3): [True: 7.64k, False: 0] ------------------ 530| 7.64k| assert(!jv_is_valid(as) || jv_get_kind(as) == JV_KIND_STRING); ------------------ | Branch (530:3): [True: 7.64k, False: 0] | Branch (530:3): [True: 0, False: 0] | Branch (530:3): [True: 7.64k, False: 0] | Branch (530:3): [True: 0, False: 0] ------------------ 531| 7.64k| inst* i = inst_new(DEPS); 532| 7.64k| jv meta = jv_object(); 533| 7.64k| if (jv_is_valid(as)) ------------------ | Branch (533:7): [True: 0, False: 7.64k] ------------------ 534| 0| meta = jv_object_set(meta, jv_string("as"), as); 535| 7.64k| else 536| 7.64k| jv_free(as); 537| 7.64k| meta = jv_object_set(meta, jv_string("is_data"), is_data ? jv_true() : jv_false()); ------------------ | Branch (537:52): [True: 0, False: 7.64k] ------------------ 538| 7.64k| meta = jv_object_set(meta, jv_string("relpath"), name); 539| 7.64k| i->imm.constant = meta; 540| 7.64k| return inst_block(i); 541| 7.64k|} gen_import_meta: 543| 7.64k|block gen_import_meta(block import, block metadata) { 544| 7.64k| assert(block_is_single(import) && import.first->op == DEPS); ------------------ | Branch (544:3): [True: 0, False: 7.64k] | Branch (544:3): [True: 0, False: 0] | Branch (544:3): [True: 7.64k, False: 0] | Branch (544:3): [True: 7.64k, False: 0] ------------------ 545| 7.64k| assert(block_is_const(metadata) && block_const_kind(metadata) == JV_KIND_OBJECT); ------------------ | Branch (545:3): [True: 0, False: 7.64k] | Branch (545:3): [True: 0, False: 0] | Branch (545:3): [True: 7.64k, False: 0] | Branch (545:3): [True: 7.64k, False: 0] ------------------ 546| 7.64k| inst *i = import.first; 547| 7.64k| i->imm.constant = jv_object_merge(block_const(metadata), i->imm.constant); 548| 7.64k| block_free(metadata); 549| 7.64k| return import; 550| 7.64k|} gen_function: 552| 3.87M|block gen_function(const char* name, block formals, block body) { 553| 3.87M| inst* i = inst_new(CLOSURE_CREATE); 554| 3.87M| int nformals = 0; 555| 4.68M| for (inst* i = formals.last; i; i = i->prev) { ------------------ | Branch (555:32): [True: 818k, False: 3.87M] ------------------ 556| 818k| nformals++; 557| 818k| i->nformals = 0; 558| 818k| if (i->op == CLOSURE_PARAM_REGULAR) { ------------------ | Branch (558:9): [True: 282k, False: 535k] ------------------ 559| 282k| i->op = CLOSURE_PARAM; 560| 282k| body = gen_var_binding(gen_call(i->symbol, gen_noop()), i->symbol, body); 561| 282k| } 562| 818k| block_bind_subblock(inst_block(i), body, OP_IS_CALL_PSEUDO | OP_HAS_BINDING, 0); 563| 818k| } 564| 3.87M| i->subfn = body; 565| 3.87M| i->symbol = strdup(name); 566| 3.87M| i->any_unbound = -1; 567| 3.87M| i->nformals = nformals; 568| 3.87M| i->arglist = formals; 569| 3.87M| block b = inst_block(i); 570| 3.87M| block_bind_subblock(b, b, OP_IS_CALL_PSEUDO | OP_HAS_BINDING, 0); 571| 3.87M| return b; 572| 3.87M|} gen_param_regular: 574| 282k|block gen_param_regular(const char* name) { 575| 282k| return gen_op_unbound(CLOSURE_PARAM_REGULAR, name); 576| 282k|} gen_param: 578| 535k|block gen_param(const char* name) { 579| 535k| return gen_op_unbound(CLOSURE_PARAM, name); 580| 535k|} gen_lambda: 582| 2.95M|block gen_lambda(block body) { 583| 2.95M| return gen_function("@lambda", gen_noop(), body); 584| 2.95M|} gen_call: 586| 3.40M|block gen_call(const char* name, block args) { 587| 3.40M| block b = gen_op_unbound(CALL_JQ, name); 588| 3.40M| b.first->arglist = args; 589| 3.40M| b.first->nactuals = block_count_actuals(b.first->arglist); 590| 3.40M| return b; 591| 3.40M|} gen_subexp: 593| 1.88M|block gen_subexp(block a) { 594| 1.88M| if (block_is_noop(a)) { ------------------ | Branch (594:7): [True: 77.0k, False: 1.80M] ------------------ 595| 77.0k| return gen_op_simple(DUP); 596| 77.0k| } 597| 1.80M| if (block_is_single(a) && a.first->op == LOADK) { ------------------ | Branch (597:7): [True: 1.46M, False: 342k] | Branch (597:29): [True: 794k, False: 668k] ------------------ 598| 794k| jv c = block_const(a); 599| 794k| block_free(a); 600| 794k| return gen_op_pushk_under(c); 601| 794k| } 602| 1.01M| return BLOCK(gen_op_simple(SUBEXP_BEGIN), a, gen_op_simple(SUBEXP_END)); ------------------ | | 102| 1.01M| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.01M|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.01M| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 1.01M|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 1.01M|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 603| 1.80M|} gen_both: 605| 139k|block gen_both(block a, block b) { 606| 139k| block jump = gen_op_targetlater(JUMP); 607| 139k| block fork = gen_op_target(FORK, jump); 608| 139k| block c = BLOCK(fork, a, jump, b); ------------------ | | 102| 139k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 139k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 139k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 139k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 139k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 139k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 609| 139k| inst_set_target(jump, c); 610| 139k| return c; 611| 139k|} gen_const_object: 613| 84.2k|block gen_const_object(block expr) { 614| 84.2k| int is_const = 1; 615| 84.2k| jv o = jv_object(); 616| 84.2k| jv k = jv_null(); 617| 84.2k| jv v = jv_null(); 618| 114k| for (inst *i = expr.first; i; i = i->next) { ------------------ | Branch (618:30): [True: 68.9k, False: 45.9k] ------------------ 619| 68.9k| if (i->op == PUSHK_UNDER) { ------------------ | Branch (619:9): [True: 45.9k, False: 22.9k] ------------------ 620| 45.9k| k = jv_copy(i->imm.constant); 621| 45.9k| i = i->next; 622| 45.9k| } else if (i->op != SUBEXP_BEGIN || ------------------ | Branch (622:16): [True: 0, False: 22.9k] ------------------ 623| 22.9k| i->next == NULL || ------------------ | Branch (623:9): [True: 0, False: 22.9k] ------------------ 624| 22.9k| i->next->op != LOADK || ------------------ | Branch (624:9): [True: 22.9k, False: 0] ------------------ 625| 0| i->next->next == NULL || ------------------ | Branch (625:9): [True: 0, False: 0] ------------------ 626| 22.9k| i->next->next->op != SUBEXP_END) { ------------------ | Branch (626:9): [True: 0, False: 0] ------------------ 627| 22.9k| is_const = 0; 628| 22.9k| break; 629| 22.9k| } else { 630| 0| k = jv_copy(i->next->imm.constant); 631| 0| i = i->next->next->next; 632| 0| } 633| 45.9k| if (i != NULL && i->op == PUSHK_UNDER) { ------------------ | Branch (633:9): [True: 45.9k, False: 0] | Branch (633:22): [True: 30.6k, False: 15.3k] ------------------ 634| 30.6k| v = jv_copy(i->imm.constant); 635| 30.6k| i = i->next; 636| 30.6k| } else if (i == NULL || ------------------ | Branch (636:16): [True: 0, False: 15.3k] ------------------ 637| 15.3k| i->op != SUBEXP_BEGIN || ------------------ | Branch (637:9): [True: 2, False: 15.3k] ------------------ 638| 15.3k| i->next == NULL || ------------------ | Branch (638:9): [True: 0, False: 15.3k] ------------------ 639| 15.3k| i->next->op != LOADK || ------------------ | Branch (639:9): [True: 15.3k, False: 0] ------------------ 640| 0| i->next->next == NULL || ------------------ | Branch (640:9): [True: 0, False: 0] ------------------ 641| 15.3k| i->next->next->op != SUBEXP_END) { ------------------ | Branch (641:9): [True: 0, False: 0] ------------------ 642| 15.3k| is_const = 0; 643| 15.3k| break; 644| 15.3k| } else { 645| 0| v = jv_copy(i->next->imm.constant); 646| 0| i = i->next->next->next; 647| 0| } 648| 30.6k| if (i == NULL || i->op != INSERT) { ------------------ | Branch (648:9): [True: 0, False: 30.6k] | Branch (648:22): [True: 0, False: 30.6k] ------------------ 649| 0| is_const = 0; 650| 0| break; 651| 0| } 652| 30.6k| if (jv_get_kind(k) != JV_KIND_STRING) { ------------------ | Branch (652:9): [True: 0, False: 30.6k] ------------------ 653| 0| is_const = 0; 654| 0| break; 655| 0| } 656| 30.6k| o = jv_object_set(o, k, v); 657| 30.6k| k = jv_null(); 658| 30.6k| v = jv_null(); 659| 30.6k| } 660| 84.2k| if (!is_const) { ------------------ | Branch (660:7): [True: 38.2k, False: 45.9k] ------------------ 661| 38.2k| jv_free(o); 662| 38.2k| jv_free(k); 663| 38.2k| jv_free(v); 664| 38.2k| block b = {0,0}; 665| 38.2k| return b; 666| 38.2k| } 667| 45.9k| block_free(expr); 668| 45.9k| return gen_const(o); 669| 84.2k|} gen_collect: 730| 240k|block gen_collect(block expr) { 731| 240k| block const_array = gen_const_array(expr); 732| 240k| if (const_array.first != NULL) ------------------ | Branch (732:7): [True: 39.5k, False: 200k] ------------------ 733| 39.5k| return const_array; 734| | 735| 200k| block array_var = gen_op_var_fresh(STOREV, "collect"); 736| 200k| block c = BLOCK(gen_op_simple(DUP), gen_const(jv_array()), array_var); ------------------ | | 102| 200k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 200k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 200k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 200k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 200k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 737| | 738| 200k| block tail = BLOCK(gen_op_bound(APPEND, array_var), ------------------ | | 102| 200k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 200k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 200k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 200k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 739| 200k| gen_op_simple(BACKTRACK)); 740| | 741| 200k| return BLOCK(c, ------------------ | | 102| 200k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 200k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 200k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 95| 200k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | ------------------ | | | | | | | | | | 94| 200k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 93| 200k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 92| 200k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 742| 240k| gen_op_target(FORK, tail), 743| 240k| expr, 744| 240k| tail, 745| 240k| gen_op_bound(LOADVN, array_var)); 746| 240k|} gen_reduce: 833| 92.4k|block gen_reduce(block source, block matcher, block init, block body) { 834| 92.4k| block res_var = gen_op_var_fresh(STOREV, "reduce"); 835| 92.4k| block loop = BLOCK(gen_op_simple(DUPN), ------------------ | | 102| 92.4k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 92.4k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 92.4k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 92.4k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 92.4k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 92.4k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 836| 92.4k| source, 837| 92.4k| bind_alternation_matchers(matcher, 838| 92.4k| BLOCK(gen_op_bound(LOADVN, res_var), 839| 92.4k| body, 840| 92.4k| gen_op_bound(STOREV, res_var))), 841| 92.4k| gen_op_simple(BACKTRACK)); 842| 92.4k| return BLOCK(gen_op_simple(DUP), ------------------ | | 102| 92.4k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 92.4k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 92.4k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 96| 92.4k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | ------------------ | | | | | | | | | | 95| 92.4k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 94| 92.4k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 93| 92.4k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 92| 92.4k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 843| 92.4k| init, 844| 92.4k| res_var, 845| 92.4k| gen_op_target(FORK, loop), 846| 92.4k| loop, 847| 92.4k| gen_op_bound(LOADVN, res_var)); 848| 92.4k|} gen_foreach: 850| 30.5k|block gen_foreach(block source, block matcher, block init, block update, block extract) { 851| 30.5k| block state_var = gen_op_var_fresh(STOREV, "foreach"); 852| 30.5k| return BLOCK(gen_op_simple(DUP), ------------------ | | 102| 30.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 30.5k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 30.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 96| 30.5k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | ------------------ | | | | | | | | | | 95| 30.5k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 94| 30.5k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 93| 30.5k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 92| 30.5k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 853| 30.5k| init, 854| 30.5k| state_var, 855| 30.5k| gen_op_simple(DUP), 856| | // get a value from the source expression: 857| 30.5k| source, 858| | // destructure the value into variable(s) for all the code 859| | // in the body to see 860| 30.5k| bind_alternation_matchers(matcher, 861| | // load the loop state variable 862| 30.5k| BLOCK(gen_op_bound(LOADVN, state_var), 863| | // generate updated state 864| 30.5k| update, 865| | // save the updated state for value extraction 866| 30.5k| gen_op_simple(DUP), 867| | // save new state 868| 30.5k| gen_op_bound(STOREV, state_var), 869| | // extract an output... 870| 30.5k| extract))); 871| 30.5k|} gen_definedor: 873| 61.2k|block gen_definedor(block a, block b) { 874| | // var found := false 875| 61.2k| block found_var = gen_op_var_fresh(STOREV, "found"); 876| 61.2k| block init = BLOCK(gen_op_simple(DUP), gen_const(jv_false()), found_var); ------------------ | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 61.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 61.2k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 61.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 877| | 878| | // if found, backtrack. Otherwise execute b 879| 61.2k| block backtrack = gen_op_simple(BACKTRACK); 880| 61.2k| block tail = BLOCK(gen_op_simple(DUP), ------------------ | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 61.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 96| 61.2k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | ------------------ | | | | | | | | | | 95| 61.2k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 94| 61.2k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 93| 61.2k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 92| 61.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 881| 61.2k| gen_op_bound(LOADV, found_var), 882| 61.2k| gen_op_target(JUMP_F, backtrack), 883| 61.2k| backtrack, 884| 61.2k| gen_op_simple(POP), 885| 61.2k| b); 886| | 887| | // try again 888| 61.2k| block if_notfound = gen_op_simple(BACKTRACK); 889| | 890| | // found := true, produce result 891| 61.2k| block if_found = BLOCK(gen_op_simple(DUP), ------------------ | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 61.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 61.2k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 61.2k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 61.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 892| 61.2k| gen_const(jv_true()), 893| 61.2k| gen_op_bound(STOREV, found_var), 894| 61.2k| gen_op_target(JUMP, tail)); 895| | 896| 61.2k| return BLOCK(init, ------------------ | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 61.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 61.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 97| 61.2k|#define BLOCK_7(b1,b2,b3,b4,b5,b6,b7) (block_join(BLOCK_6(b1,b2,b3,b4,b5,b6),(b7))) | | | | | | | | ------------------ | | | | | | | | | | 96| 61.2k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 95| 61.2k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 94| 61.2k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 93| 61.2k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 92| 61.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 897| 61.2k| gen_op_target(FORK, if_notfound), 898| 61.2k| a, 899| 61.2k| gen_op_target(JUMP_F, if_found), 900| 61.2k| if_found, 901| 61.2k| if_notfound, 902| 61.2k| tail); 903| 61.2k|} block_has_main: 905| 15.2k|int block_has_main(block top) { 906| 825k| for (inst *c = top.first; c; c = c->next) { ------------------ | Branch (906:29): [True: 818k, False: 7.64k] ------------------ 907| 818k| if (c->op == TOP) ------------------ | Branch (907:9): [True: 7.64k, False: 810k] ------------------ 908| 7.64k| return 1; 909| 818k| } 910| 7.64k| return 0; 911| 15.2k|} gen_condbranch: 919| 619k|block gen_condbranch(block iftrue, block iffalse) { 920| 619k| iftrue = BLOCK(iftrue, gen_op_target(JUMP, iffalse)); ------------------ | | 102| 619k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 619k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 619k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 619k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 921| 619k| return BLOCK(gen_op_target(JUMP_F, iftrue), iftrue, iffalse); ------------------ | | 102| 619k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 619k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 619k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 619k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 619k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 922| 619k|} gen_and: 924| 107k|block gen_and(block a, block b) { 925| | // a and b = if a then (if b then true else false) else false 926| 107k| return BLOCK(gen_op_simple(DUP), a, ------------------ | | 102| 107k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 107k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 107k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 107k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 107k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 927| 107k| gen_condbranch(BLOCK(gen_op_simple(POP), 928| 107k| b, 929| 107k| gen_condbranch(gen_const(jv_true()), 930| 107k| gen_const(jv_false()))), 931| 107k| BLOCK(gen_op_simple(POP), gen_const(jv_false())))); 932| 107k|} gen_or: 934| 22.9k|block gen_or(block a, block b) { 935| | // a or b = if a then true else (if b then true else false) 936| 22.9k| return BLOCK(gen_op_simple(DUP), a, ------------------ | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 22.9k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 22.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 937| 22.9k| gen_condbranch(BLOCK(gen_op_simple(POP), gen_const(jv_true())), 938| 22.9k| BLOCK(gen_op_simple(POP), 939| 22.9k| b, 940| 22.9k| gen_condbranch(gen_const(jv_true()), 941| 22.9k| gen_const(jv_false()))))); 942| 22.9k|} gen_destructure_alt: 944| 22|block gen_destructure_alt(block matcher) { 945| 328| for (inst *i = matcher.first; i; i = i->next) { ------------------ | Branch (945:33): [True: 306, False: 22] ------------------ 946| 306| if (i->op == STOREV) { ------------------ | Branch (946:9): [True: 58, False: 248] ------------------ 947| 58| i->op = STOREVN; 948| 58| } 949| 306| } 950| 22| inst* i = inst_new(DESTRUCTURE_ALT); 951| 22| i->subfn = matcher; 952| 22| return inst_block(i); 953| 22|} gen_var_binding: 955| 282k|block gen_var_binding(block var, const char* name, block body) { 956| 282k| return gen_destructure(var, gen_op_unbound(STOREV, name), body); 957| 282k|} gen_array_matcher: 959| 72|block gen_array_matcher(block left, block curr) { 960| 72| int index; 961| 72| if (block_is_noop(left)) ------------------ | Branch (961:7): [True: 46, False: 26] ------------------ 962| 46| index = 0; 963| 26| else { 964| | // `left` was returned by this function, so the third inst is the 965| | // constant containing the previously used index 966| 26| assert(left.first->op == DUP); ------------------ | Branch (966:5): [True: 0, False: 26] | Branch (966:5): [True: 26, False: 0] ------------------ 967| 26| assert(left.first->next != NULL); ------------------ | Branch (967:5): [True: 0, False: 26] | Branch (967:5): [True: 26, False: 0] ------------------ 968| 26| inst *i = NULL; 969| 26| if (left.first->next->op == PUSHK_UNDER) { ------------------ | Branch (969:9): [True: 26, False: 0] ------------------ 970| 26| i = left.first->next; 971| 26| } else { 972| 0| assert(left.first->next->op == SUBEXP_BEGIN); ------------------ | Branch (972:7): [True: 0, False: 0] | Branch (972:7): [True: 0, False: 0] ------------------ 973| 0| assert(left.first->next->next->op == LOADK); ------------------ | Branch (973:7): [True: 0, False: 0] | Branch (973:7): [True: 0, False: 0] ------------------ 974| 0| i = left.first->next->next; 975| 0| } 976| 26| index = 1 + (int) jv_number_value(i->imm.constant); 977| 26| } 978| | 979| | // `left` goes at the end so that the const index is in a predictable place 980| 72| return BLOCK(gen_op_simple(DUP), gen_subexp(gen_const(jv_number(index))), ------------------ | | 102| 72| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 72|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 72| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 95| 72|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | ------------------ | | | | | | | | | | 94| 72|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 93| 72|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 92| 72|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 981| 72| gen_op_simple(INDEX), curr, left); 982| 72|} gen_object_matcher: 984| 15.4k|block gen_object_matcher(block name, block curr) { 985| 15.4k| return BLOCK(gen_op_simple(DUP), gen_subexp(name), gen_op_simple(INDEX), ------------------ | | 102| 15.4k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 15.4k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 15.4k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 15.4k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 15.4k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 15.4k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 986| 15.4k| curr); 987| 15.4k|} gen_destructure: 989| 451k|block gen_destructure(block var, block matchers, block body) { 990| | // var bindings can be added after coding the program; leave the TOP first. 991| 451k| block top = gen_noop(); 992| 451k| if (body.first && body.first->op == TOP) ------------------ | Branch (992:7): [True: 451k, False: 0] | Branch (992:21): [True: 0, False: 451k] ------------------ 993| 0| top = inst_block(block_take(&body)); 994| | 995| 451k| if (matchers.first && matchers.first->op == DESTRUCTURE_ALT) { ------------------ | Branch (995:7): [True: 451k, False: 0] | Branch (995:25): [True: 22, False: 451k] ------------------ 996| 22| block_append(&var, gen_op_simple(DUP)); 997| 451k| } else { 998| 451k| top = BLOCK(top, gen_op_simple(DUP)); ------------------ | | 102| 451k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 451k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 451k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 451k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 999| 451k| } 1000| | 1001| 451k| return BLOCK(top, gen_subexp(var), gen_op_simple(POP), bind_alternation_matchers(matchers, body)); ------------------ | | 102| 451k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 451k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 451k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 451k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 451k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 451k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1002| 451k|} gen_cond: 1011| 352k|block gen_cond(block cond, block iftrue, block iffalse) { 1012| 352k| return BLOCK(gen_op_simple(DUP), BLOCK(gen_subexp(cond), gen_op_simple(POP)), ------------------ | | 102| 352k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 352k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 352k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 352k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 352k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1013| 352k| gen_condbranch(BLOCK(gen_op_simple(POP), iftrue), 1014| 352k| BLOCK(gen_op_simple(POP), iffalse))); 1015| 352k|} gen_try: 1017| 30.8k|block gen_try(block exp, block handler) { 1018| | /* 1019| | * Produce: 1020| | * 1021| | * TRY_BEGIN handler 1022| | * 1023| | * TRY_END 1024| | * JUMP past_handler 1025| | * handler: 1026| | * past_handler: 1027| | * 1028| | * If backtracks then TRY_BEGIN will backtrack. 1029| | * 1030| | * If produces a value then we'll execute whatever bytecode follows 1031| | * this sequence. If that code raises an exception, then TRY_END will wrap 1032| | * and re-raise that exception, and TRY_BEGIN will unwrap and re-raise the 1033| | * exception (see jq_next()). 1034| | * 1035| | * If raises then the TRY_BEGIN will see a non-wrapped exception and 1036| | * will jump to the handler (note the TRY_END will not execute in this case), 1037| | * and if the handler produces any values, then we'll execute whatever 1038| | * bytecode follows this sequence. Note that TRY_END will not execute in 1039| | * this case, so if the handler raises an exception, or code past the handler 1040| | * raises an exception, then that exception won't be wrapped and re-raised, 1041| | * and the TRY_BEGIN will not catch it because it does not stack_save() when 1042| | * it branches to the handler. 1043| | */ 1044| | 1045| 30.8k| if (block_is_noop(handler)) ------------------ | Branch (1045:7): [True: 0, False: 30.8k] ------------------ 1046| 0| handler = BLOCK(gen_op_simple(DUP), gen_op_simple(POP)); ------------------ | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 0|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 0|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1047| | 1048| 30.8k| block jump = gen_op_target(JUMP, handler); 1049| 30.8k| return BLOCK(gen_op_target(TRY_BEGIN, jump), exp, gen_op_simple(TRY_END), ------------------ | | 102| 30.8k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 30.8k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 30.8k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 95| 30.8k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | ------------------ | | | | | | | | | | 94| 30.8k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 93| 30.8k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 92| 30.8k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1050| 30.8k| jump, handler); 1051| 30.8k|} gen_label: 1053| 22.9k|block gen_label(const char *label, block exp) { 1054| 22.9k| block cond = gen_call("_equal", 1055| 22.9k| BLOCK(gen_lambda(gen_noop()), ------------------ | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 22.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1056| 22.9k| gen_lambda(gen_op_unbound(LOADV, label)))); 1057| 22.9k| return gen_wildvar_binding(gen_op_simple(GENLABEL), label, 1058| 22.9k| BLOCK(gen_op_simple(POP), ------------------ | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 22.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1059| | // try exp catch if . == $label 1060| | // then empty 1061| | // else error end 1062| | // 1063| | // Can't use gen_binop(), as that's firmly 1064| | // stuck in parser.y as it refers to things 1065| | // like EQ. 1066| 22.9k| gen_try(exp, 1067| 22.9k| gen_cond(cond, 1068| 22.9k| gen_op_simple(BACKTRACK), 1069| 22.9k| gen_call("error", gen_noop()))))); 1070| 22.9k|} gen_cbinding: 1072| 7.64k|block gen_cbinding(const struct cfunction* cfunctions, int ncfunctions, block code) { 1073| 1.04M| for (int cfunc=0; cfuncimm.cfunc = &cfunctions[cfunc]; 1076| 1.04M| i->symbol = strdup(cfunctions[cfunc].name); 1077| 1.04M| i->nformals = cfunctions[cfunc].nargs - 1; 1078| 1.04M| i->any_unbound = 0; 1079| 1.04M| code = BLOCK(inst_block(i), code); ------------------ | | 102| 1.04M| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.04M|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.04M| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 1.04M|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1080| 1.04M| } 1081| 7.64k| return code; 1082| 7.64k|} block_compile: 1367| 7.64k|int block_compile(block b, struct bytecode** out, struct locfile* lf, jv args) { 1368| 7.64k| struct bytecode* bc = jv_mem_alloc(sizeof(struct bytecode)); 1369| 7.64k| bc->parent = 0; 1370| 7.64k| bc->nclosures = 0; 1371| 7.64k| bc->globals = jv_mem_alloc(sizeof(struct symbol_table)); 1372| 7.64k| int ncfunc = count_cfunctions(b); 1373| 7.64k| bc->globals->ncfunctions = 0; 1374| 7.64k| bc->globals->cfunctions = jv_mem_calloc(MAX(ncfunc, 1), sizeof(struct cfunction)); ------------------ | | 55| 7.64k| ({ __typeof__ (a) _a = (a); \ | | 56| 7.64k| __typeof__ (b) _b = (b); \ | | 57| 7.64k| _a > _b ? _a : _b; }) | | ------------------ | | | Branch (57:4): [True: 3.35k, False: 4.29k] | | ------------------ ------------------ 1375| 7.64k| bc->globals->cfunc_names = jv_array(); 1376| 7.64k| bc->debuginfo = jv_object_set(jv_object(), jv_string("name"), jv_null()); 1377| 7.64k| jv env = jv_invalid(); 1378| 7.64k| int nerrors = compile(bc, b, lf, args, &env); 1379| 7.64k| jv_free(args); 1380| 7.64k| jv_free(env); 1381| 7.64k| assert(bc->globals->ncfunctions == ncfunc); ------------------ | Branch (1381:3): [True: 0, False: 7.64k] | Branch (1381:3): [True: 7.64k, False: 0] ------------------ 1382| 7.64k| if (nerrors > 0) { ------------------ | Branch (1382:7): [True: 0, False: 7.64k] ------------------ 1383| 0| bytecode_free(bc); 1384| 0| *out = 0; 1385| 7.64k| } else { 1386| 7.64k| *out = bc; 1387| 7.64k| } 1388| 7.64k| return nerrors; 1389| 7.64k|} block_free: 1391| 55.0M|void block_free(block b) { 1392| 55.0M| struct inst* next; 1393| 80.7M| for (struct inst* curr = b.first; curr; curr = next) { ------------------ | Branch (1393:37): [True: 25.7M, False: 55.0M] ------------------ 1394| 25.7M| next = curr->next; 1395| 25.7M| inst_free(curr); 1396| 25.7M| } 1397| 55.0M|} compile.c:inst_block: 97| 29.7M|static block inst_block(inst* i) { 98| 29.7M| block b = {i,i}; 99| 29.7M| return b; 100| 29.7M|} compile.c:inst_new: 67| 25.7M|static inst* inst_new(opcode op) { 68| 25.7M| inst* i = jv_mem_alloc(sizeof(inst)); 69| 25.7M| i->next = i->prev = 0; 70| 25.7M| i->op = op; 71| 25.7M| i->bytecode_pos = -1; 72| 25.7M| i->bound_by = 0; 73| 25.7M| i->symbol = 0; 74| 25.7M| i->any_unbound = 0; 75| 25.7M| i->referenced = 0; 76| 25.7M| i->nformals = -1; 77| 25.7M| i->nactuals = -1; 78| 25.7M| i->subfn = gen_noop(); 79| 25.7M| i->arglist = gen_noop(); 80| 25.7M| i->source = UNKNOWN_LOCATION; 81| 25.7M| i->locfile = 0; 82| 25.7M| return i; 83| 25.7M|} compile.c:inst_join: 240| 18.8M|static void inst_join(inst* a, inst* b) { 241| 18.8M| assert(a && b); ------------------ | Branch (241:3): [True: 0, False: 18.8M] | Branch (241:3): [True: 0, False: 0] | Branch (241:3): [True: 18.8M, False: 0] | Branch (241:3): [True: 18.8M, False: 0] ------------------ 242| 18.8M| assert(!a->next); ------------------ | Branch (242:3): [True: 0, False: 18.8M] | Branch (242:3): [True: 18.8M, False: 0] ------------------ 243| 18.8M| assert(!b->prev); ------------------ | Branch (243:3): [True: 0, False: 18.8M] | Branch (243:3): [True: 18.8M, False: 0] ------------------ 244| 18.8M| a->next = b; 245| 18.8M| b->prev = a; 246| 18.8M|} compile.c:block_bind_subblock: 352| 7.24M|static int block_bind_subblock(block binder, block body, int bindflags, int break_distance) { 353| 7.24M| int any_unbound; 354| 7.24M| return block_bind_subblock_inner(&any_unbound, binder, body, bindflags, break_distance); 355| 7.24M|} compile.c:block_bind_subblock_inner: 306| 74.9M|static int block_bind_subblock_inner(int* any_unbound, block binder, block body, int bindflags, int break_distance) { 307| 74.9M| assert(block_is_single(binder)); ------------------ | Branch (307:3): [True: 0, False: 74.9M] | Branch (307:3): [True: 74.9M, False: 0] ------------------ 308| 74.9M| assert((opcode_describe(binder.first->op)->flags & bindflags) == (bindflags & ~OP_BIND_WILDCARD)); ------------------ | Branch (308:3): [True: 0, False: 74.9M] | Branch (308:3): [True: 74.9M, False: 0] ------------------ 309| 74.9M| assert(binder.first->symbol); ------------------ | Branch (309:3): [True: 0, False: 74.9M] | Branch (309:3): [True: 74.9M, False: 0] ------------------ 310| 74.9M| assert(binder.first->bound_by == 0 || binder.first->bound_by == binder.first); ------------------ | Branch (310:3): [True: 74.9M, False: 0] | Branch (310:3): [True: 0, False: 0] | Branch (310:3): [True: 6.33M, False: 68.6M] | Branch (310:3): [True: 68.6M, False: 0] ------------------ 311| 74.9M| assert(break_distance >= 0); ------------------ | Branch (311:3): [True: 0, False: 74.9M] | Branch (311:3): [True: 74.9M, False: 0] ------------------ 312| | 313| 74.9M| binder.first->bound_by = binder.first; 314| 74.9M| int nrefs = 0; 315| 230M| for (inst* i = body.first; i; i = i->next) { ------------------ | Branch (315:30): [True: 155M, False: 74.9M] ------------------ 316| 155M| if (i->any_unbound == 0) ------------------ | Branch (316:9): [True: 121M, False: 33.8M] ------------------ 317| 121M| continue; 318| | 319| 33.8M| int flags = opcode_describe(i->op)->flags; 320| 33.8M| if ((flags & bindflags) == (bindflags & ~OP_BIND_WILDCARD) && i->bound_by == 0 && ------------------ | Branch (320:9): [True: 27.0M, False: 6.77M] | Branch (320:67): [True: 15.4M, False: 11.6M] ------------------ 321| 15.4M| (!strcmp(i->symbol, binder.first->symbol) || ------------------ | Branch (321:10): [True: 2.38M, False: 13.0M] ------------------ 322| | // Check for break/break2/break3; see parser.y 323| 13.0M| ((bindflags & OP_BIND_WILDCARD) && i->symbol[0] == '*' && ------------------ | Branch (323:11): [True: 53.5k, False: 13.0M] | Branch (323:45): [True: 0, False: 53.5k] ------------------ 324| 0| break_distance <= 3 && (i->symbol[1] == '1' + break_distance) && ------------------ | Branch (324:11): [True: 0, False: 0] | Branch (324:34): [True: 0, False: 0] ------------------ 325| 2.38M| i->symbol[2] == '\0'))) { ------------------ | Branch (325:11): [True: 0, False: 0] ------------------ 326| | // bind this instruction 327| 2.38M| if (i->nactuals == -1 || i->nactuals == binder.first->nformals) { ------------------ | Branch (327:11): [True: 1.17M, False: 1.20M] | Branch (327:32): [True: 1.01M, False: 189k] ------------------ 328| 2.19M| i->bound_by = binder.first; 329| 2.19M| nrefs++; 330| 2.19M| } 331| 31.4M| } else if ((flags & bindflags) == (bindflags & ~OP_BIND_WILDCARD) && i->bound_by != 0 && ------------------ | Branch (331:16): [True: 24.7M, False: 6.77M] | Branch (331:74): [True: 11.6M, False: 13.0M] ------------------ 332| 11.6M| !strncmp(binder.first->symbol, "*anonlabel", sizeof("*anonlabel") - 1) && ------------------ | Branch (332:16): [True: 0, False: 11.6M] ------------------ 333| 0| !strncmp(i->symbol, "*anonlabel", sizeof("*anonlabel") - 1)) { ------------------ | Branch (333:16): [True: 0, False: 0] ------------------ 334| | // Increment the break distance required for this binder to match 335| | // a break whenever we come across a STOREV of *anonlabel... 336| 0| break_distance++; 337| 0| } 338| | 339| 33.8M| i->any_unbound = (i->symbol && !i->bound_by); ------------------ | Branch (339:23): [True: 33.8M, False: 0] | Branch (339:36): [True: 17.4M, False: 16.3M] ------------------ 340| | 341| | // binding recurses into closures 342| 33.8M| nrefs += block_bind_subblock_inner(&i->any_unbound, binder, i->subfn, bindflags, break_distance); 343| | // binding recurses into argument list 344| 33.8M| nrefs += block_bind_subblock_inner(&i->any_unbound, binder, i->arglist, bindflags, break_distance); 345| | 346| 33.8M| if (i->any_unbound) ------------------ | Branch (346:9): [True: 27.4M, False: 6.43M] ------------------ 347| 27.4M| *any_unbound = 1; 348| 33.8M| } 349| 74.9M| return nrefs; 350| 74.9M|} compile.c:block_take_last: 404| 2.01M|static inst* block_take_last(block* b) { 405| 2.01M| inst* i = b->last; 406| 2.01M| if (i == 0) ------------------ | Branch (406:7): [True: 61.4k, False: 1.95M] ------------------ 407| 61.4k| return 0; 408| 1.95M| if (i->prev) { ------------------ | Branch (408:7): [True: 1.88M, False: 61.4k] ------------------ 409| 1.88M| i->prev->next = i->next; 410| 1.88M| b->last = i->prev; 411| 1.88M| i->prev = 0; 412| 1.88M| } else { 413| 61.4k| b->first = 0; 414| 61.4k| b->last = 0; 415| 61.4k| } 416| 1.95M| return i; 417| 2.01M|} compile.c:block_mark_referenced: 451| 171k|static void block_mark_referenced(block body) { 452| 171k| int saw_top = 0; 453| 252k| for (inst* i = body.last; i; i = i->prev) { ------------------ | Branch (453:29): [True: 81.7k, False: 171k] ------------------ 454| 81.7k| if (saw_top && i->bound_by == i && !i->referenced) ------------------ | Branch (454:9): [True: 0, False: 81.7k] | Branch (454:20): [True: 0, False: 0] | Branch (454:40): [True: 0, False: 0] ------------------ 455| 0| continue; 456| 81.7k| if (i->op == TOP) { ------------------ | Branch (456:9): [True: 7.64k, False: 74.0k] ------------------ 457| 7.64k| saw_top = 1; 458| 7.64k| } 459| 81.7k| if (i->bound_by) { ------------------ | Branch (459:9): [True: 28.2k, False: 53.5k] ------------------ 460| 28.2k| i->bound_by->referenced = 1; 461| 28.2k| } 462| | 463| 81.7k| block_mark_referenced(i->arglist); 464| 81.7k| block_mark_referenced(i->subfn); 465| 81.7k| } 466| 171k|} compile.c:block_take: 106| 895k|static inst* block_take(block* b) { 107| 895k| if (b->first == 0) return 0; ------------------ | Branch (107:7): [True: 190k, False: 704k] ------------------ 108| 704k| inst* i = b->first; 109| 704k| if (i->next) { ------------------ | Branch (109:7): [True: 558k, False: 145k] ------------------ 110| 558k| i->next->prev = 0; 111| 558k| b->first = i->next; 112| 558k| i->next = 0; 113| 558k| } else { 114| 145k| b->first = 0; 115| 145k| b->last = 0; 116| 145k| } 117| 704k| return i; 118| 895k|} compile.c:inst_free: 85| 25.7M|static void inst_free(struct inst* i) { 86| 25.7M| jv_mem_free(i->symbol); 87| 25.7M| block_free(i->subfn); 88| 25.7M| block_free(i->arglist); 89| 25.7M| if (i->locfile) ------------------ | Branch (89:7): [True: 4.06M, False: 21.7M] ------------------ 90| 4.06M| locfile_free(i->locfile); 91| 25.7M| if (opcode_describe(i->op)->flags & OP_HAS_CONSTANT) { ------------------ | Branch (91:7): [True: 4.12M, False: 21.6M] ------------------ 92| 4.12M| jv_free(i->imm.constant); 93| 4.12M| } 94| 25.7M| jv_mem_free(i); 95| 25.7M|} compile.c:block_count_actuals: 291| 3.40M|static int block_count_actuals(block b) { 292| 3.40M| int args = 0; 293| 6.36M| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (293:27): [True: 2.95M, False: 3.40M] ------------------ 294| 2.95M| switch (i->op) { 295| 0| default: assert(0 && "Unknown function type"); break; ------------------ | Branch (295:5): [True: 0, False: 2.95M] | Branch (295:14): [Folded, False: 0] | Branch (295:14): [True: 0, False: 0] | Branch (295:14): [Folded, False: 0] | Branch (295:14): [True: 0, False: 0] ------------------ 296| 2.95M| case CLOSURE_CREATE: ------------------ | Branch (296:5): [True: 2.95M, False: 0] ------------------ 297| 2.95M| case CLOSURE_PARAM: ------------------ | Branch (297:5): [True: 0, False: 2.95M] ------------------ 298| 2.95M| case CLOSURE_CREATE_C: ------------------ | Branch (298:5): [True: 0, False: 2.95M] ------------------ 299| 2.95M| args++; 300| 2.95M| break; 301| 2.95M| } 302| 2.95M| } 303| 3.40M| return args; 304| 3.40M|} compile.c:gen_const_array: 671| 240k|static block gen_const_array(block expr) { 672| | /* 673| | * An expr of all constant elements looks like this: 674| | * 675| | * 0009 FORK 0027 676| | * 0011 FORK 0023 677| | * 0013 FORK 0019 678| | * 0015 LOADK 1 679| | * 0017 JUMP 0021 680| | * 0019 LOADK 2 681| | * 0021 JUMP 0025 682| | * 0023 LOADK 3 683| | * 0025 JUMP 0029 684| | * 0027 LOADK 4 685| | * 686| | * That's: N-1 commas for N elements, N LOADKs, and a JUMP between 687| | * every LOADK. The sequence ends in a LOADK. Any deviation and it's 688| | * not a list of constants. 689| | * 690| | * Here we check for this pattern almost exactly. We don't check that 691| | * the targets of the FORK and JUMP instructions are in the right 692| | * sequence. 693| | */ 694| 240k| int all_const = 1; 695| 240k| int commas = 0; 696| 240k| int normal = 1; 697| 240k| jv a = jv_array(); 698| 1.05M| for (inst *i = expr.first; i; i = i->next) { ------------------ | Branch (698:30): [True: 835k, False: 217k] ------------------ 699| 835k| if (i->op == FORK) { ------------------ | Branch (699:9): [True: 70.4k, False: 765k] ------------------ 700| 70.4k| commas++; 701| 70.4k| if (i->imm.target == NULL || i->imm.target->op != JUMP || ------------------ | Branch (701:11): [True: 0, False: 70.4k] | Branch (701:36): [True: 23.1k, False: 47.2k] ------------------ 702| 47.2k| jv_array_length(jv_copy(a)) > 0) { ------------------ | Branch (702:11): [True: 0, False: 47.2k] ------------------ 703| 23.1k| normal = 0; 704| 23.1k| break; 705| 23.1k| } 706| 765k| } else if (all_const && i->op == LOADK) { ------------------ | Branch (706:16): [True: 257k, False: 507k] | Branch (706:29): [True: 55.7k, False: 201k] ------------------ 707| 55.7k| if (i->next != NULL && i->next->op != JUMP) { ------------------ | Branch (707:11): [True: 8.46k, False: 47.2k] | Branch (707:30): [True: 1, False: 8.46k] ------------------ 708| 1| normal = 0; 709| 1| break; 710| 1| } 711| 55.7k| a = jv_array_append(a, jv_copy(i->imm.constant)); 712| 709k| } else if (i->op != JUMP || i->imm.target == NULL || ------------------ | Branch (712:16): [True: 662k, False: 47.2k] | Branch (712:33): [True: 0, False: 47.2k] ------------------ 713| 700k| i->imm.target->op != LOADK) { ------------------ | Branch (713:16): [True: 38.7k, False: 8.51k] ------------------ 714| 700k| all_const = 0; 715| 700k| } 716| 835k| } 717| | 718| 240k| if (all_const && normal && ------------------ | Branch (718:7): [True: 47.2k, False: 193k] | Branch (718:20): [True: 47.2k, False: 1] ------------------ 719| 47.2k| (expr.last == NULL || expr.last->op == LOADK) && ------------------ | Branch (719:8): [True: 0, False: 47.2k] | Branch (719:29): [True: 47.2k, False: 0] ------------------ 720| 47.2k| jv_array_length(jv_copy(a)) == commas + 1) { ------------------ | Branch (720:7): [True: 39.5k, False: 7.69k] ------------------ 721| 39.5k| block_free(expr); 722| 39.5k| return gen_const(a); 723| 39.5k| } 724| | 725| 200k| jv_free(a); 726| 200k| block b = {0,0}; 727| 200k| return b; 728| 240k|} compile.c:bind_alternation_matchers: 782| 574k|static block bind_alternation_matchers(block matchers, block body) { 783| 574k| block preamble = {0}; 784| 574k| block altmatchers = {0}; 785| 574k| block mb = {0}; 786| 574k| block final_matcher = matchers; 787| | 788| | // Pass through the matchers to find all destructured names. 789| 574k| while (final_matcher.first && final_matcher.first->op == DESTRUCTURE_ALT) { ------------------ | Branch (789:10): [True: 574k, False: 0] | Branch (789:33): [True: 22, False: 574k] ------------------ 790| 22| block_append(&altmatchers, inst_block(block_take(&final_matcher))); 791| 22| } 792| | 793| | // We don't have any alternations here, so we can use the simplest case. 794| 574k| if (altmatchers.first == NULL) { ------------------ | Branch (794:7): [True: 574k, False: 22] ------------------ 795| 574k| return bind_matcher(final_matcher, body); 796| 574k| } 797| | 798| | // Collect var names 799| 22| jv all_vars = jv_object(); 800| 22| block_get_unbound_vars(altmatchers, &all_vars); 801| 22| block_get_unbound_vars(final_matcher, &all_vars); 802| | 803| | // We need a preamble of STOREVs to which to bind the matchers and the body. 804| 70| jv_object_keys_foreach(all_vars, key) { ------------------ | | 169| 44| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (169:52): [True: 22, False: 22] | | ------------------ | | 170| 22| for (jv k; \ | | 171| 92| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (171:10): [True: 70, False: 22] | | | Branch (171:10): [True: 70, False: 22] | | ------------------ | | 172| 92| (k = jv_object_iter_key(t, jv_i__), \ | | 173| 70| 1) \ | | 174| 92| : 0; \ | | 175| 70| jv_i__ = jv_object_iter_next(t, jv_i__)) ------------------ 805| 70| preamble = BLOCK(preamble, ------------------ | | 102| 70| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 70|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 70| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 70|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 70|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 70|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 806| 70| gen_op_simple(DUP), 807| 70| gen_const(jv_null()), 808| 70| gen_op_unbound(STOREV, jv_string_value(key))); 809| 70| jv_free(key); 810| 70| } 811| 22| jv_free(all_vars); 812| | 813| | // Now we build each matcher in turn 814| 44| for (inst *i = altmatchers.first; i; i = i->next) { ------------------ | Branch (814:37): [True: 22, False: 22] ------------------ 815| 22| block submatcher = i->subfn; 816| | 817| | // If we're successful, jump to the end of the matchers 818| 22| submatcher = BLOCK(submatcher, gen_op_target(JUMP, final_matcher)); ------------------ | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 22|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 819| | 820| | // DESTRUCTURE_ALT to the end of this submatcher so we can skip to the next one on error 821| 22| mb = BLOCK(mb, gen_op_target(DESTRUCTURE_ALT, submatcher), submatcher); ------------------ | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 22|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 22|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 822| | 823| | // We're done with this inst and we don't want it anymore 824| | // But we can't let it free the submatcher block. 825| 22| i->subfn.first = i->subfn.last = NULL; 826| 22| } 827| | // We're done with these insts now. 828| 22| block_free(altmatchers); 829| | 830| 22| return bind_matcher(preamble, BLOCK(mb, final_matcher, body)); ------------------ | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 22|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 22|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 831| 574k|} compile.c:bind_matcher: 748| 574k|static block bind_matcher(block matcher, block body) { 749| | // cannot call block_bind(matcher, body) because that requires 750| | // block_has_only_binders(matcher), which is not true here as matchers 751| | // may also contain code to extract the correct elements 752| 1.21M| for (inst* i = matcher.first; i; i = i->next) { ------------------ | Branch (752:33): [True: 636k, False: 574k] ------------------ 753| 636k| if ((i->op == STOREV || i->op == STOREVN) && !i->bound_by) ------------------ | Branch (753:10): [True: 582k, False: 53.8k] | Branch (753:29): [True: 0, False: 53.8k] | Branch (753:50): [True: 582k, False: 0] ------------------ 754| 582k| block_bind_subblock(inst_block(i), body, OP_HAS_VARIABLE, 0); 755| 636k| } 756| 574k| return BLOCK(matcher, body); ------------------ | | 102| 574k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 574k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 574k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 574k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 757| 574k|} compile.c:block_get_unbound_vars: 762| 66|static void block_get_unbound_vars(block b, jv *vars) { 763| 66| assert(vars != NULL); ------------------ | Branch (763:3): [True: 0, False: 66] | Branch (763:3): [True: 66, False: 0] ------------------ 764| 66| assert(jv_get_kind(*vars) == JV_KIND_OBJECT); ------------------ | Branch (764:3): [True: 0, False: 66] | Branch (764:3): [True: 66, False: 0] ------------------ 765| 752| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (765:27): [True: 686, False: 66] ------------------ 766| 686| if (i->subfn.first) { ------------------ | Branch (766:9): [True: 22, False: 664] ------------------ 767| 22| block_get_unbound_vars(i->subfn, vars); 768| 22| continue; 769| 22| } 770| 664| if ((i->op == STOREV || i->op == STOREVN) && i->bound_by == NULL) { ------------------ | Branch (770:10): [True: 58, False: 606] | Branch (770:29): [True: 58, False: 548] | Branch (770:50): [True: 116, False: 0] ------------------ 771| 116| *vars = jv_object_set(*vars, jv_string(i->symbol), jv_true()); 772| 116| } 773| 664| } 774| 66|} compile.c:gen_wildvar_binding: 1005| 22.9k|static block gen_wildvar_binding(block var, const char* name, block body) { 1006| 22.9k| return BLOCK(gen_op_simple(DUP), var, ------------------ | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 22.9k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 22.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1007| 22.9k| block_bind(gen_op_unbound(STOREV, name), 1008| 22.9k| body, OP_HAS_VARIABLE | OP_BIND_WILDCARD)); 1009| 22.9k|} compile.c:block_bind: 367| 22.9k|static block block_bind(block binder, block body, int bindflags) { 368| 22.9k| block_bind_each(binder, body, bindflags); 369| 22.9k| return block_join(binder, body); 370| 22.9k|} compile.c:block_bind_each: 357| 22.9k|static int block_bind_each(block binder, block body, int bindflags) { 358| 22.9k| assert(block_has_only_binders(binder, bindflags)); ------------------ | Branch (358:3): [True: 0, False: 22.9k] | Branch (358:3): [True: 22.9k, False: 0] ------------------ 359| 22.9k| bindflags |= OP_HAS_BINDING; 360| 22.9k| int nrefs = 0; 361| 45.8k| for (inst* curr = binder.first; curr; curr = curr->next) { ------------------ | Branch (361:35): [True: 22.9k, False: 22.9k] ------------------ 362| 22.9k| nrefs += block_bind_subblock(inst_block(curr), body, bindflags, 0); 363| 22.9k| } 364| 22.9k| return nrefs; 365| 22.9k|} compile.c:count_cfunctions: 1095| 435k|static int count_cfunctions(block b) { 1096| 435k| int n = 0; 1097| 862k| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (1097:27): [True: 427k, False: 435k] ------------------ 1098| 427k| if (i->op == CLOSURE_CREATE_C) n++; ------------------ | Branch (1098:9): [True: 22.4k, False: 405k] ------------------ 1099| 427k| n += count_cfunctions(i->subfn); 1100| 427k| } 1101| 435k| return n; 1102| 435k|} compile.c:compile: 1218| 49.8k|static int compile(struct bytecode* bc, block b, struct locfile* lf, jv args, jv *env) { 1219| 49.8k| int errors = 0; 1220| 49.8k| int pos = 0; 1221| 49.8k| int var_frame_idx = 0; 1222| 49.8k| bc->nsubfunctions = 0; 1223| 49.8k| errors += expand_call_arglist(&b, args, env); 1224| 49.8k| b = BLOCK(b, gen_op_simple(RET)); ------------------ | | 102| 49.8k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 49.8k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 49.8k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 49.8k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1225| 49.8k| jv localnames = jv_array(); 1226| 771k| for (inst* curr = b.first; curr; curr = curr->next) { ------------------ | Branch (1226:30): [True: 721k, False: 49.8k] ------------------ 1227| 721k| if (!curr->next) assert(curr == b.last); ------------------ | Branch (1227:9): [True: 49.8k, False: 671k] | Branch (1227:22): [True: 0, False: 49.8k] | Branch (1227:22): [True: 49.8k, False: 0] ------------------ 1228| 721k| int length = opcode_describe(curr->op)->length; 1229| 721k| if (curr->op == CALL_JQ) { ------------------ | Branch (1229:9): [True: 42.0k, False: 679k] ------------------ 1230| 67.1k| for (inst* arg = curr->arglist.first; arg; arg = arg->next) { ------------------ | Branch (1230:45): [True: 25.1k, False: 42.0k] ------------------ 1231| 25.1k| length += 2; 1232| 25.1k| } 1233| 42.0k| } 1234| 721k| pos += length; 1235| 721k| curr->bytecode_pos = pos; 1236| 721k| curr->compiled = bc; 1237| | 1238| 721k| assert(curr->op != CLOSURE_REF && curr->op != CLOSURE_PARAM); ------------------ | Branch (1238:5): [True: 0, False: 721k] | Branch (1238:5): [True: 0, False: 0] | Branch (1238:5): [True: 721k, False: 0] | Branch (1238:5): [True: 721k, False: 0] ------------------ 1239| | 1240| 721k| if ((opcode_describe(curr->op)->flags & OP_HAS_VARIABLE) && ------------------ | Branch (1240:9): [True: 122k, False: 599k] ------------------ 1241| 122k| curr->bound_by == curr) { ------------------ | Branch (1241:9): [True: 42.1k, False: 80.2k] ------------------ 1242| 42.1k| curr->imm.intval = var_frame_idx++; 1243| 42.1k| localnames = jv_array_append(localnames, jv_string(curr->symbol)); 1244| 42.1k| } 1245| | 1246| 721k| if (curr->op == CLOSURE_CREATE) { ------------------ | Branch (1246:9): [True: 42.1k, False: 679k] ------------------ 1247| 42.1k| assert(curr->bound_by == curr); ------------------ | Branch (1247:7): [True: 0, False: 42.1k] | Branch (1247:7): [True: 42.1k, False: 0] ------------------ 1248| | // Prevent subfunction index from overflowing into ARG_NEWCLOSURE flag 1249| 42.1k| if (bc->nsubfunctions >= ARG_NEWCLOSURE) { ------------------ | | 70| 42.1k|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (1249:11): [True: 0, False: 42.1k] ------------------ 1250| 0| locfile_locate(lf, curr->source, 1251| 0| "too many function parameters or local function definitions (max %d)", ARG_NEWCLOSURE - 1); ------------------ | | 70| 0|#define ARG_NEWCLOSURE 0x1000 ------------------ 1252| 0| errors++; 1253| 0| break; 1254| 0| } 1255| 42.1k| curr->imm.intval = bc->nsubfunctions++; 1256| 42.1k| } 1257| 721k| if (curr->op == CLOSURE_CREATE_C) { ------------------ | Branch (1257:9): [True: 22.4k, False: 699k] ------------------ 1258| 22.4k| assert(curr->bound_by == curr); ------------------ | Branch (1258:7): [True: 0, False: 22.4k] | Branch (1258:7): [True: 22.4k, False: 0] ------------------ 1259| 22.4k| int idx = bc->globals->ncfunctions++; 1260| 22.4k| bc->globals->cfunc_names = jv_array_append(bc->globals->cfunc_names, 1261| 22.4k| jv_string(curr->symbol)); 1262| 22.4k| bc->globals->cfunctions[idx] = *curr->imm.cfunc; 1263| 22.4k| curr->imm.intval = idx; 1264| 22.4k| } 1265| 721k| } 1266| 49.8k| if (pos > 0xFFFF) { ------------------ | Branch (1266:7): [True: 0, False: 49.8k] ------------------ 1267| | // too long for program counter to fit in uint16_t 1268| 0| locfile_locate(lf, UNKNOWN_LOCATION, 1269| 0| "function compiled to %d bytes which is too long", pos); 1270| 0| errors++; 1271| 0| } 1272| 49.8k| bc->codelen = pos; 1273| 49.8k| bc->debuginfo = jv_object_set(bc->debuginfo, jv_string("locals"), localnames); 1274| 49.8k| if (bc->nsubfunctions && !errors) { ------------------ | Branch (1274:7): [True: 11.6k, False: 38.1k] | Branch (1274:28): [True: 11.6k, False: 0] ------------------ 1275| 11.6k| bc->subfunctions = jv_mem_calloc(bc->nsubfunctions, sizeof(struct bytecode*)); 1276| 481k| for (inst* curr = b.first; curr; curr = curr->next) { ------------------ | Branch (1276:32): [True: 469k, False: 11.6k] ------------------ 1277| 469k| if (curr->op == CLOSURE_CREATE) { ------------------ | Branch (1277:11): [True: 42.1k, False: 427k] ------------------ 1278| 42.1k| struct bytecode* subfn = jv_mem_alloc(sizeof(struct bytecode)); 1279| 42.1k| bc->subfunctions[curr->imm.intval] = subfn; 1280| 42.1k| subfn->globals = bc->globals; 1281| 42.1k| subfn->parent = bc; 1282| 42.1k| subfn->nclosures = 0; 1283| 42.1k| subfn->debuginfo = jv_object_set(jv_object(), jv_string("name"), jv_string(curr->symbol)); 1284| 42.1k| jv params = jv_array(); 1285| 64.4k| for (inst* param = curr->arglist.first; param; param = param->next) { ------------------ | Branch (1285:49): [True: 22.3k, False: 42.1k] ------------------ 1286| 22.3k| assert(param->op == CLOSURE_PARAM); ------------------ | Branch (1286:11): [True: 0, False: 22.3k] | Branch (1286:11): [True: 22.3k, False: 0] ------------------ 1287| 22.3k| assert(param->bound_by == param); ------------------ | Branch (1287:11): [True: 0, False: 22.3k] | Branch (1287:11): [True: 22.3k, False: 0] ------------------ 1288| | // Prevent closure index from overflowing into ARG_NEWCLOSURE flag 1289| 22.3k| if (subfn->nclosures >= ARG_NEWCLOSURE) { ------------------ | | 70| 22.3k|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (1289:15): [True: 0, False: 22.3k] ------------------ 1290| 0| locfile_locate(lf, curr->source, 1291| 0| "function has too many parameters (max %d)", ARG_NEWCLOSURE - 1); ------------------ | | 70| 0|#define ARG_NEWCLOSURE 0x1000 ------------------ 1292| 0| errors++; 1293| 0| break; 1294| 0| } 1295| 22.3k| param->imm.intval = subfn->nclosures++; 1296| 22.3k| param->compiled = subfn; 1297| 22.3k| params = jv_array_append(params, jv_string(param->symbol)); 1298| 22.3k| } 1299| 42.1k| subfn->debuginfo = jv_object_set(subfn->debuginfo, jv_string("params"), params); 1300| 42.1k| errors += compile(subfn, curr->subfn, lf, args, env); 1301| 42.1k| curr->subfn = gen_noop(); 1302| 42.1k| } 1303| 469k| } 1304| 38.1k| } else { 1305| 38.1k| bc->nsubfunctions = 0; 1306| 38.1k| bc->subfunctions = 0; 1307| 38.1k| } 1308| 49.8k| uint16_t* code = jv_mem_calloc(bc->codelen, sizeof(uint16_t)); 1309| 49.8k| bc->code = code; 1310| 49.8k| pos = 0; 1311| 49.8k| jv constant_pool = jv_array(); 1312| 49.8k| int maxvar = -1; 1313| 771k| if (!errors) for (inst* curr = b.first; curr; curr = curr->next) { ------------------ | Branch (1313:7): [True: 49.8k, False: 0] | Branch (1313:43): [True: 721k, False: 49.8k] ------------------ 1314| 721k| const struct opcode_description* op = opcode_describe(curr->op); 1315| 721k| if (op->length == 0) ------------------ | Branch (1315:9): [True: 64.6k, False: 657k] ------------------ 1316| 64.6k| continue; 1317| 657k| code[pos++] = curr->op; 1318| 657k| assert(curr->op != CLOSURE_REF && curr->op != CLOSURE_PARAM); ------------------ | Branch (1318:5): [True: 0, False: 657k] | Branch (1318:5): [True: 0, False: 0] | Branch (1318:5): [True: 657k, False: 0] | Branch (1318:5): [True: 657k, False: 0] ------------------ 1319| 657k| if (curr->op == CALL_BUILTIN) { ------------------ | Branch (1319:9): [True: 38.7k, False: 618k] ------------------ 1320| 38.7k| assert(curr->bound_by->op == CLOSURE_CREATE_C); ------------------ | Branch (1320:7): [True: 0, False: 38.7k] | Branch (1320:7): [True: 38.7k, False: 0] ------------------ 1321| 38.7k| assert(!curr->arglist.first); ------------------ | Branch (1321:7): [True: 0, False: 38.7k] | Branch (1321:7): [True: 38.7k, False: 0] ------------------ 1322| 38.7k| code[pos++] = (uint16_t)curr->imm.intval; 1323| 38.7k| code[pos++] = curr->bound_by->imm.intval; 1324| 618k| } else if (curr->op == CALL_JQ) { ------------------ | Branch (1324:16): [True: 42.0k, False: 576k] ------------------ 1325| 42.0k| assert(curr->bound_by->op == CLOSURE_CREATE || ------------------ | Branch (1325:7): [True: 42.0k, False: 0] | Branch (1325:7): [True: 0, False: 0] | Branch (1325:7): [True: 19.6k, False: 22.3k] | Branch (1325:7): [True: 22.3k, False: 0] ------------------ 1326| 42.0k| curr->bound_by->op == CLOSURE_PARAM); 1327| 42.0k| code[pos++] = (uint16_t)curr->imm.intval; 1328| 42.0k| code[pos++] = nesting_level(bc, curr->bound_by); 1329| 42.0k| code[pos++] = curr->bound_by->imm.intval | 1330| 42.0k| (curr->bound_by->op == CLOSURE_CREATE ? ARG_NEWCLOSURE : 0); ------------------ | | 70| 19.6k|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (1330:10): [True: 19.6k, False: 22.3k] ------------------ 1331| 67.1k| for (inst* arg = curr->arglist.first; arg; arg = arg->next) { ------------------ | Branch (1331:45): [True: 25.1k, False: 42.0k] ------------------ 1332| 25.1k| assert(arg->op == CLOSURE_REF && arg->bound_by->op == CLOSURE_CREATE); ------------------ | Branch (1332:9): [True: 0, False: 25.1k] | Branch (1332:9): [True: 0, False: 0] | Branch (1332:9): [True: 25.1k, False: 0] | Branch (1332:9): [True: 25.1k, False: 0] ------------------ 1333| 25.1k| code[pos++] = nesting_level(bc, arg->bound_by); 1334| 25.1k| code[pos++] = arg->bound_by->imm.intval | ARG_NEWCLOSURE; ------------------ | | 70| 25.1k|#define ARG_NEWCLOSURE 0x1000 ------------------ 1335| 25.1k| } 1336| 576k| } else if ((op->flags & OP_HAS_CONSTANT) && (op->flags & OP_HAS_VARIABLE)) { ------------------ | Branch (1336:16): [True: 71.9k, False: 504k] | Branch (1336:49): [True: 0, False: 71.9k] ------------------ 1337| | // STORE_GLOBAL: constant global, basically 1338| 0| code[pos++] = jv_array_length(jv_copy(constant_pool)); 1339| 0| constant_pool = jv_array_append(constant_pool, jv_copy(curr->imm.constant)); 1340| 0| code[pos++] = nesting_level(bc, curr->bound_by); 1341| 0| uint16_t var = (uint16_t)curr->bound_by->imm.intval; 1342| 0| code[pos++] = var; 1343| 0| if (var > maxvar) maxvar = var; ------------------ | Branch (1343:11): [True: 0, False: 0] ------------------ 1344| 576k| } else if (op->flags & OP_HAS_CONSTANT) { ------------------ | Branch (1344:16): [True: 71.9k, False: 504k] ------------------ 1345| 71.9k| code[pos++] = jv_array_length(jv_copy(constant_pool)); 1346| 71.9k| constant_pool = jv_array_append(constant_pool, jv_copy(curr->imm.constant)); 1347| 504k| } else if (op->flags & OP_HAS_VARIABLE) { ------------------ | Branch (1347:16): [True: 122k, False: 381k] ------------------ 1348| 122k| code[pos++] = nesting_level(bc, curr->bound_by); 1349| 122k| uint16_t var = (uint16_t)curr->bound_by->imm.intval; 1350| 122k| code[pos++] = var; 1351| 122k| if (var > maxvar) maxvar = var; ------------------ | Branch (1351:11): [True: 50.8k, False: 71.5k] ------------------ 1352| 381k| } else if (op->flags & OP_HAS_BRANCH) { ------------------ | Branch (1352:16): [True: 49.6k, False: 332k] ------------------ 1353| 49.6k| assert(curr->imm.target->bytecode_pos != -1); ------------------ | Branch (1353:7): [True: 0, False: 49.6k] | Branch (1353:7): [True: 49.6k, False: 0] ------------------ 1354| 49.6k| assert(curr->imm.target->bytecode_pos > pos); // only forward branches ------------------ | Branch (1354:7): [True: 0, False: 49.6k] | Branch (1354:7): [True: 49.6k, False: 0] ------------------ 1355| 49.6k| code[pos] = curr->imm.target->bytecode_pos - (pos + 1); 1356| 49.6k| pos++; 1357| 332k| } else if (op->length > 1) { ------------------ | Branch (1357:16): [True: 0, False: 332k] ------------------ 1358| 0| assert(0 && "codegen not implemented for this operation"); ------------------ | Branch (1358:7): [Folded, False: 0] | Branch (1358:7): [True: 0, False: 0] | Branch (1358:7): [Folded, False: 0] | Branch (1358:7): [True: 0, False: 0] ------------------ 1359| 0| } 1360| 657k| } 1361| 49.8k| bc->constants = constant_pool; 1362| 49.8k| bc->nlocals = maxvar + 2; // FIXME: frames of size zero? 1363| 49.8k| block_free(b); 1364| 49.8k| return errors; 1365| 49.8k|} compile.c:expand_call_arglist: 1128| 102k|static int expand_call_arglist(block* b, jv args, jv *env) { 1129| 102k| int errors = 0; 1130| 102k| block ret = gen_noop(); 1131| 677k| for (inst* curr; (curr = block_take(b));) { ------------------ | Branch (1131:20): [True: 575k, False: 102k] ------------------ 1132| 575k| if (opcode_describe(curr->op)->flags & OP_HAS_BINDING) { ------------------ | Branch (1132:9): [True: 242k, False: 332k] ------------------ 1133| 242k| if (!curr->bound_by && curr->op == LOADV && strcmp(curr->symbol, "ENV") == 0) { ------------------ | Branch (1133:11): [True: 3, False: 242k] | Branch (1133:30): [True: 3, False: 0] | Branch (1133:51): [True: 3, False: 0] ------------------ 1134| 3| curr->op = LOADK; 1135| 3| *env = curr->imm.constant = make_env(*env); 1136| 242k| } else if (!curr->bound_by && curr->op == LOADV && jv_object_has(jv_copy(args), jv_string(curr->symbol))) { ------------------ | Branch (1136:18): [True: 0, False: 242k] | Branch (1136:37): [True: 0, False: 0] | Branch (1136:58): [True: 0, False: 0] ------------------ 1137| 0| curr->op = LOADK; 1138| 0| curr->imm.constant = jv_object_get(jv_copy(args), jv_string(curr->symbol)); 1139| 242k| } else if (!curr->bound_by) { ------------------ | Branch (1139:18): [True: 0, False: 242k] ------------------ 1140| 0| if (curr->symbol[0] == '*' && curr->symbol[1] >= '1' && curr->symbol[1] <= '3' && curr->symbol[2] == '\0') ------------------ | Branch (1140:13): [True: 0, False: 0] | Branch (1140:39): [True: 0, False: 0] | Branch (1140:65): [True: 0, False: 0] | Branch (1140:91): [True: 0, False: 0] ------------------ 1141| 0| locfile_locate(curr->locfile, curr->source, "jq: error: break used outside labeled control structure"); 1142| 0| else if (curr->op == LOADV) ------------------ | Branch (1142:18): [True: 0, False: 0] ------------------ 1143| 0| locfile_locate(curr->locfile, curr->source, "jq: error: $%s is not defined", curr->symbol); 1144| 0| else 1145| 0| locfile_locate(curr->locfile, curr->source, "jq: error: %s/%d is not defined", curr->symbol, curr->nactuals); 1146| 0| errors++; 1147| | // don't process this instruction if it's not well-defined 1148| 0| ret = BLOCK(ret, inst_block(curr)); ------------------ | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 0|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 0|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1149| 0| continue; 1150| 0| } 1151| 242k| } 1152| | 1153| 575k| block prelude = gen_noop(); 1154| 575k| if (curr->op == CALL_JQ) { ------------------ | Branch (1154:9): [True: 80.7k, False: 494k] ------------------ 1155| 80.7k| int actual_args = 0, desired_args = 0; 1156| | // We expand the argument list as a series of instructions 1157| 80.7k| switch (curr->bound_by->op) { 1158| 0| default: assert(0 && "Unknown function type"); break; ------------------ | Branch (1158:7): [True: 0, False: 80.7k] | Branch (1158:16): [Folded, False: 0] | Branch (1158:16): [True: 0, False: 0] | Branch (1158:16): [Folded, False: 0] | Branch (1158:16): [True: 0, False: 0] ------------------ 1159| 19.6k| case CLOSURE_CREATE: ------------------ | Branch (1159:7): [True: 19.6k, False: 61.0k] ------------------ 1160| 42.0k| case CLOSURE_PARAM: { ------------------ | Branch (1160:7): [True: 22.3k, False: 58.4k] ------------------ 1161| 42.0k| block callargs = gen_noop(); 1162| 67.1k| for (inst* i; (i = block_take(&curr->arglist));) { ------------------ | Branch (1162:23): [True: 25.1k, False: 42.0k] ------------------ 1163| 25.1k| assert(opcode_describe(i->op)->flags & OP_IS_CALL_PSEUDO); ------------------ | Branch (1163:11): [True: 0, False: 25.1k] | Branch (1163:11): [True: 25.1k, False: 0] ------------------ 1164| 25.1k| block b = inst_block(i); 1165| 25.1k| switch (i->op) { 1166| 0| default: assert(0 && "Unknown type of parameter"); break; ------------------ | Branch (1166:11): [True: 0, False: 25.1k] | Branch (1166:20): [Folded, False: 0] | Branch (1166:20): [True: 0, False: 0] | Branch (1166:20): [Folded, False: 0] | Branch (1166:20): [True: 0, False: 0] ------------------ 1167| 0| case CLOSURE_REF: ------------------ | Branch (1167:11): [True: 0, False: 25.1k] ------------------ 1168| 0| block_append(&callargs, b); 1169| 0| break; 1170| 25.1k| case CLOSURE_CREATE: ------------------ | Branch (1170:11): [True: 25.1k, False: 0] ------------------ 1171| 25.1k| block_append(&prelude, b); 1172| 25.1k| block_append(&callargs, gen_op_bound(CLOSURE_REF, b)); 1173| 25.1k| break; 1174| 25.1k| } 1175| 25.1k| actual_args++; 1176| 25.1k| } 1177| 42.0k| curr->imm.intval = actual_args; 1178| 42.0k| curr->arglist = callargs; 1179| | 1180| 42.0k| if (curr->bound_by->op == CLOSURE_CREATE) { ------------------ | Branch (1180:13): [True: 19.6k, False: 22.3k] ------------------ 1181| 44.8k| for (inst* i = curr->bound_by->arglist.first; i; i = i->next) { ------------------ | Branch (1181:57): [True: 25.1k, False: 19.6k] ------------------ 1182| 25.1k| assert(i->op == CLOSURE_PARAM); ------------------ | Branch (1182:13): [True: 0, False: 25.1k] | Branch (1182:13): [True: 25.1k, False: 0] ------------------ 1183| 25.1k| desired_args++; 1184| 25.1k| } 1185| 19.6k| } 1186| 42.0k| break; 1187| 42.0k| } 1188| | 1189| 42.0k| case CLOSURE_CREATE_C: { ------------------ | Branch (1189:7): [True: 38.7k, False: 42.0k] ------------------ 1190| 91.4k| for (inst* i; (i = block_take(&curr->arglist)); ) { ------------------ | Branch (1190:23): [True: 52.7k, False: 38.7k] ------------------ 1191| 52.7k| assert(i->op == CLOSURE_CREATE); // FIXME ------------------ | Branch (1191:11): [True: 0, False: 52.7k] | Branch (1191:11): [True: 52.7k, False: 0] ------------------ 1192| 52.7k| block body = i->subfn; 1193| 52.7k| i->subfn = gen_noop(); 1194| 52.7k| inst_free(i); 1195| | // arguments should be pushed in reverse order, prepend them to prelude 1196| 52.7k| errors += expand_call_arglist(&body, args, env); 1197| 52.7k| prelude = BLOCK(gen_subexp(body), prelude); ------------------ | | 102| 52.7k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 52.7k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 52.7k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 52.7k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1198| 52.7k| actual_args++; 1199| 52.7k| } 1200| 38.7k| assert(curr->op == CALL_JQ); ------------------ | Branch (1200:9): [True: 0, False: 38.7k] | Branch (1200:9): [True: 38.7k, False: 0] ------------------ 1201| 38.7k| curr->op = CALL_BUILTIN; 1202| 38.7k| curr->imm.intval = actual_args + 1 /* include the implicit input in arg count */; 1203| 38.7k| assert(curr->bound_by->op == CLOSURE_CREATE_C); ------------------ | Branch (1203:9): [True: 0, False: 38.7k] | Branch (1203:9): [True: 38.7k, False: 0] ------------------ 1204| 38.7k| desired_args = curr->bound_by->imm.cfunc->nargs - 1; 1205| 38.7k| assert(!curr->arglist.first); ------------------ | Branch (1205:9): [True: 0, False: 38.7k] | Branch (1205:9): [True: 38.7k, False: 0] ------------------ 1206| 38.7k| break; 1207| 38.7k| } 1208| 80.7k| } 1209| | 1210| 80.7k| assert(actual_args == desired_args); // because now handle this above ------------------ | Branch (1210:7): [True: 0, False: 80.7k] | Branch (1210:7): [True: 80.7k, False: 0] ------------------ 1211| 80.7k| } 1212| 575k| ret = BLOCK(ret, prelude, inst_block(curr)); ------------------ | | 102| 575k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 575k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 575k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 575k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 575k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1213| 575k| } 1214| 102k| *b = ret; 1215| 102k| return errors; 1216| 102k|} compile.c:make_env: 1110| 3|{ 1111| 3| if (jv_is_valid(env)) ------------------ | Branch (1111:7): [True: 0, False: 3] ------------------ 1112| 0| return jv_copy(env); 1113| 3| jv r = jv_object(); 1114| 3| if (environ == NULL) ------------------ | Branch (1114:7): [True: 0, False: 3] ------------------ 1115| 0| return r; 1116| 102| for (size_t i = 0; environ[i] != NULL; i++) { ------------------ | Branch (1116:22): [True: 99, False: 3] ------------------ 1117| 99| const char *eq; 1118| | 1119| 99| if ((eq = strchr(environ[i], '=')) == NULL) ------------------ | Branch (1119:9): [True: 0, False: 99] ------------------ 1120| 0| r = jv_object_delete(r, jv_string(environ[i])); 1121| 99| else 1122| 99| r = jv_object_set(r, jv_string_sized(environ[i], eq - environ[i]), jv_string(eq + 1)); 1123| 99| } 1124| 3| return jv_copy(r); 1125| 3|} compile.c:nesting_level: 1084| 189k|static uint16_t nesting_level(struct bytecode* bc, inst* target) { 1085| 189k| uint16_t level = 0; 1086| 189k| assert(bc && target && target->compiled); ------------------ | Branch (1086:3): [True: 0, False: 189k] | Branch (1086:3): [True: 0, False: 0] | Branch (1086:3): [True: 0, False: 0] | Branch (1086:3): [True: 189k, False: 0] | Branch (1086:3): [True: 189k, False: 0] | Branch (1086:3): [True: 189k, False: 0] ------------------ 1087| 219k| while (bc && target->compiled != bc) { ------------------ | Branch (1087:10): [True: 219k, False: 0] | Branch (1087:16): [True: 29.5k, False: 189k] ------------------ 1088| 29.5k| level++; 1089| 29.5k| bc = bc->parent; 1090| 29.5k| } 1091| 189k| assert(bc && bc == target->compiled); ------------------ | Branch (1091:3): [True: 0, False: 189k] | Branch (1091:3): [True: 0, False: 0] | Branch (1091:3): [True: 189k, False: 0] | Branch (1091:3): [True: 189k, False: 0] ------------------ 1092| 189k| return level; 1093| 189k|} execute.c:stack_push_block: 101| 383M|static stack_ptr stack_push_block(struct stack* s, stack_ptr p, size_t sz) { 102| 383M| int alloc_sz = align_round_up(sz) + ALIGNMENT; 103| 383M| stack_ptr r = s->limit - alloc_sz; 104| 383M| if (r < s->bound) { ------------------ | Branch (104:7): [True: 9.33k, False: 383M] ------------------ 105| 9.33k| stack_reallocate(s, alloc_sz); 106| 9.33k| } 107| 383M| s->limit = r; 108| 383M| *stack_block_next(s, r) = p; 109| 383M| return r; 110| 383M|} execute.c:align_round_up: 46| 767M|static size_t align_round_up(size_t sz) { 47| 767M| return ((sz + (ALIGNMENT - 1)) / ALIGNMENT) * ALIGNMENT; 48| 767M|} execute.c:stack_reallocate: 85| 9.33k|static void stack_reallocate(struct stack* s, size_t sz) { 86| 9.33k| size_t old_mem_length = (size_t)(-(s->bound)) + ALIGNMENT; 87| 9.33k| char* old_mem_start = s->mem_end != NULL ? s->mem_end - old_mem_length : NULL; ------------------ | Branch (87:25): [True: 2.77k, False: 6.55k] ------------------ 88| | 89| 9.33k| size_t new_mem_length = align_round_up((old_mem_length + sz + 256) * 2); 90| 9.33k| if (new_mem_length > INT_MAX) { ------------------ | Branch (90:7): [True: 0, False: 9.33k] ------------------ 91| 0| fprintf(stderr, "jq: error: cannot allocate memory\n"); 92| 0| abort(); 93| 0| } 94| 9.33k| char* new_mem_start = jv_mem_realloc(old_mem_start, new_mem_length); 95| 9.33k| memmove(new_mem_start + (new_mem_length - old_mem_length), 96| 9.33k| new_mem_start, old_mem_length); 97| 9.33k| s->mem_end = new_mem_start + new_mem_length; 98| 9.33k| s->bound = -(int)(new_mem_length - ALIGNMENT); 99| 9.33k|} execute.c:stack_block: 77| 2.38G|static void* stack_block(struct stack* s, stack_ptr p) { 78| 2.38G| return (void*)(s->mem_end + p); 79| 2.38G|} execute.c:stack_pop_will_free: 73| 480M|static int stack_pop_will_free(struct stack* s, stack_ptr p) { 74| 480M| return p == s->limit; 75| 480M|} execute.c:stack_pop_block: 112| 455M|static stack_ptr stack_pop_block(struct stack* s, stack_ptr p, size_t sz) { 113| 455M| stack_ptr r = *stack_block_next(s, p); 114| 455M| if (p == s->limit) { ------------------ | Branch (114:7): [True: 383M, False: 71.8M] ------------------ 115| 383M| int alloc_sz = align_round_up(sz) + ALIGNMENT; 116| 383M| s->limit += alloc_sz; 117| 383M| } 118| 455M| return r; 119| 455M|} execute.c:stack_block_next: 81| 1.05G|static stack_ptr* stack_block_next(struct stack* s, stack_ptr p) { 82| 1.05G| return &((stack_ptr*)stack_block(s, p))[-1]; 83| 1.05G|} execute.c:stack_init: 58| 29.5k|static void stack_init(struct stack* s) { 59| 29.5k| s->mem_end = 0; 60| 29.5k| s->bound = ALIGNMENT; 61| 29.5k| s->limit = 0; 62| 29.5k|} execute.c:stack_reset: 64| 21.8k|static void stack_reset(struct stack* s) { 65| 21.8k| assert(s->limit == 0 && "stack freed while not empty"); ------------------ | Branch (65:3): [True: 0, False: 21.8k] | Branch (65:3): [True: 0, False: 0] | Branch (65:3): [True: 21.8k, False: 0] | Branch (65:3): [True: 21.8k, False: 0] ------------------ 66| 21.8k| if(s->mem_end != NULL) { ------------------ | Branch (66:6): [True: 6.55k, False: 15.3k] ------------------ 67| 6.55k| char* mem_start = s->mem_end - ( -s->bound + ALIGNMENT); 68| 6.55k| free(mem_start); 69| 6.55k| } 70| 21.8k| stack_init(s); 71| 21.8k|} stack_push: 162| 336M|void stack_push(jq_state *jq, jv val) { 163| 336M| assert(jv_is_valid(val)); ------------------ | Branch (163:3): [True: 0, False: 336M] | Branch (163:3): [True: 336M, False: 0] ------------------ 164| 336M| jq->stk_top = stack_push_block(&jq->stk, jq->stk_top, sizeof(jv)); 165| 336M| jv* sval = stack_block(&jq->stk, jq->stk_top); 166| 336M| *sval = val; 167| 336M|} stack_pop: 169| 348M|jv stack_pop(jq_state *jq) { 170| 348M| jv* sval = stack_block(&jq->stk, jq->stk_top); 171| 348M| jv val = *sval; 172| 348M| if (!stack_pop_will_free(&jq->stk, jq->stk_top)) { ------------------ | Branch (172:7): [True: 14.5M, False: 334M] ------------------ 173| 14.5M| val = jv_copy(val); 174| 14.5M| } 175| 348M| jq->stk_top = stack_pop_block(&jq->stk, jq->stk_top, sizeof(jv)); 176| 348M| assert(jv_is_valid(val)); ------------------ | Branch (176:3): [True: 0, False: 348M] | Branch (176:3): [True: 348M, False: 0] ------------------ 177| 348M| return val; 178| 348M|} stack_popn: 182| 6.92M|jv stack_popn(jq_state *jq) { 183| 6.92M| jv* sval = stack_block(&jq->stk, jq->stk_top); 184| 6.92M| jv val = *sval; 185| 6.92M| if (!stack_pop_will_free(&jq->stk, jq->stk_top)) { ------------------ | Branch (185:7): [True: 4.34M, False: 2.57M] ------------------ 186| 4.34M| *sval = jv_null(); 187| 4.34M| } 188| 6.92M| jq->stk_top = stack_pop_block(&jq->stk, jq->stk_top, sizeof(jv)); 189| 6.92M| assert(jv_is_valid(val)); ------------------ | Branch (189:3): [True: 0, False: 6.92M] | Branch (189:3): [True: 6.92M, False: 0] ------------------ 190| 6.92M| return val; 191| 6.92M|} stack_get_pos: 206| 38.3M|struct stack_pos stack_get_pos(jq_state* jq) { 207| 38.3M| struct stack_pos sp = {jq->stk_top, jq->curr_frame}; 208| 38.3M| return sp; 209| 38.3M|} stack_save: 211| 38.3M|void stack_save(jq_state *jq, uint16_t* retaddr, struct stack_pos sp){ 212| 38.3M| jq->fork_top = stack_push_block(&jq->stk, jq->fork_top, sizeof(struct forkpoint)); 213| 38.3M| struct forkpoint* fork = stack_block(&jq->stk, jq->fork_top); 214| 38.3M| fork->saved_data_stack = jq->stk_top; 215| 38.3M| fork->saved_curr_frame = jq->curr_frame; 216| 38.3M| fork->path_len = 217| 38.3M| jv_get_kind(jq->path) == JV_KIND_ARRAY ? jv_array_length(jv_copy(jq->path)) : 0; ------------------ | Branch (217:5): [True: 1.92M, False: 36.4M] ------------------ 218| 38.3M| fork->value_at_path = jv_copy(jq->value_at_path); 219| 38.3M| fork->subexp_nest = jq->subexp_nest; 220| 38.3M| fork->return_address = retaddr; 221| 38.3M| jq->stk_top = sp.saved_data_stack; 222| 38.3M| jq->curr_frame = sp.saved_curr_frame; 223| 38.3M|} _jq_path_append: 250| 1.25M|_jq_path_append(jq_state *jq, jv v, jv p, jv value_at_path) { 251| 1.25M| if (jq->subexp_nest != 0 || ------------------ | Branch (251:7): [True: 857k, False: 395k] ------------------ 252| 395k| jv_get_kind(jq->path) != JV_KIND_ARRAY || ------------------ | Branch (252:7): [True: 395k, False: 0] ------------------ 253| 1.25M| !jv_is_valid(value_at_path)) { ------------------ | Branch (253:7): [True: 0, False: 0] ------------------ 254| 1.25M| jv_free(v); 255| 1.25M| jv_free(p); 256| 1.25M| return value_at_path; 257| 1.25M| } 258| 0| if (!jv_identical(v, jv_copy(jq->value_at_path))) { ------------------ | Branch (258:7): [True: 0, False: 0] ------------------ 259| 0| jv_free(p); 260| 0| return value_at_path; 261| 0| } 262| 0| if (jv_get_kind(p) == JV_KIND_ARRAY) ------------------ | Branch (262:7): [True: 0, False: 0] ------------------ 263| 0| jq->path = jv_array_concat(jq->path, p); 264| 0| else 265| 0| jq->path = jv_array_append(jq->path, p); 266| 0| jv_free(jq->value_at_path); 267| 0| return jv_copy(jq->value_at_path = value_at_path); 268| 0|} stack_restore: 270| 38.3M|uint16_t* stack_restore(jq_state *jq){ 271| 49.6M| while (!stack_pop_will_free(&jq->stk, jq->fork_top)) { ------------------ | Branch (271:10): [True: 11.2M, False: 38.3M] ------------------ 272| 11.2M| if (stack_pop_will_free(&jq->stk, jq->stk_top)) { ------------------ | Branch (272:9): [True: 8.58M, False: 2.65M] ------------------ 273| 8.58M| jv_free(stack_pop(jq)); 274| 8.58M| } else if (stack_pop_will_free(&jq->stk, jq->curr_frame)) { ------------------ | Branch (274:16): [True: 2.65M, False: 0] ------------------ 275| 2.65M| frame_pop(jq); 276| 2.65M| } else { 277| 0| assert(0); ------------------ | Branch (277:7): [Folded, False: 0] | Branch (277:7): [Folded, False: 0] ------------------ 278| 0| } 279| 11.2M| } 280| | 281| 38.3M| if (jq->fork_top == 0) { ------------------ | Branch (281:7): [True: 23.9k, False: 38.3M] ------------------ 282| 23.9k| return 0; 283| 23.9k| } 284| | 285| 38.3M| struct forkpoint* fork = stack_block(&jq->stk, jq->fork_top); 286| 38.3M| uint16_t* retaddr = fork->return_address; 287| 38.3M| jq->stk_top = fork->saved_data_stack; 288| 38.3M| jq->curr_frame = fork->saved_curr_frame; 289| 38.3M| int path_len = fork->path_len; 290| 38.3M| if (jv_get_kind(jq->path) == JV_KIND_ARRAY) { ------------------ | Branch (290:7): [True: 2.51M, False: 35.8M] ------------------ 291| 2.51M| assert(path_len >= 0); ------------------ | Branch (291:5): [True: 0, False: 2.51M] | Branch (291:5): [True: 2.51M, False: 0] ------------------ 292| 2.51M| jq->path = jv_array_slice(jq->path, 0, path_len); 293| 35.8M| } else { 294| 35.8M| fork->path_len = 0; 295| 35.8M| } 296| 38.3M| jv_free(jq->value_at_path); 297| 38.3M| jq->value_at_path = fork->value_at_path; 298| 38.3M| jq->subexp_nest = fork->subexp_nest; 299| 38.3M| jq->fork_top = stack_pop_block(&jq->stk, jq->fork_top, sizeof(struct forkpoint)); 300| 38.3M| return retaddr; 301| 38.3M|} jq_report_error: 326| 10|void jq_report_error(jq_state *jq, jv value) { 327| 10| assert(jq->err_cb); ------------------ | Branch (327:3): [True: 0, False: 10] | Branch (327:3): [True: 10, False: 0] ------------------ 328| | // callback must jv_free() its jv argument 329| 10| jq->err_cb(jq->err_cb_data, value); 330| 10|} jq_next: 340| 6.14k|jv jq_next(jq_state *jq) { 341| 6.14k| jv_nomem_handler(jq->nomem_handler, jq->nomem_handler_data); 342| | 343| 6.14k| uint16_t* pc = stack_restore(jq); 344| 6.14k| assert(pc); ------------------ | Branch (344:3): [True: 0, False: 6.14k] | Branch (344:3): [True: 6.14k, False: 0] ------------------ 345| | 346| 6.14k| int raising; 347| 6.14k| int backtracking = !jq->initial_execution; 348| | 349| 6.14k| jq->initial_execution = 0; 350| 6.14k| assert(jv_get_kind(jq->error) == JV_KIND_NULL); ------------------ | Branch (350:3): [True: 0, False: 6.14k] | Branch (350:3): [True: 6.14k, False: 0] ------------------ 351| 335M| while (1) { ------------------ | Branch (351:10): [True: 335M, Folded] ------------------ 352| 335M| if (jq->halted) { ------------------ | Branch (352:9): [True: 0, False: 335M] ------------------ 353| 0| if (jq->debug_trace_enabled) ------------------ | Branch (353:11): [True: 0, False: 0] ------------------ 354| 0| printf("\t\n"); 355| 0| return jv_invalid(); 356| 0| } 357| 335M| uint16_t opcode = *pc; 358| 335M| raising = 0; 359| | 360| 335M| if (jq->debug_trace_enabled) { ------------------ | Branch (360:9): [True: 0, False: 335M] ------------------ 361| 0| dump_operation(frame_current(jq)->bc, pc); 362| 0| printf("\t"); 363| 0| const struct opcode_description* opdesc = opcode_describe(opcode); 364| 0| stack_ptr param = 0; 365| 0| if (!backtracking) { ------------------ | Branch (365:11): [True: 0, False: 0] ------------------ 366| 0| int stack_in = opdesc->stack_in; 367| 0| if (stack_in == -1) stack_in = pc[1]; ------------------ | Branch (367:13): [True: 0, False: 0] ------------------ 368| 0| param = jq->stk_top; 369| 0| for (int i=0; istk, param); 373| 0| } 374| 0| if (!param) break; ------------------ | Branch (374:15): [True: 0, False: 0] ------------------ 375| 0| jv_dump(jv_copy(*(jv*)stack_block(&jq->stk, param)), JV_PRINT_REFCOUNT); 376| | //printf("<%d>", jv_get_refcnt(param->val)); 377| | //printf(" -- "); 378| | //jv_dump(jv_copy(jq->path), 0); 379| 0| } 380| 0| if (jq->debug_trace_enabled & JQ_DEBUG_TRACE_DETAIL) { ------------------ | Branch (380:13): [True: 0, False: 0] ------------------ 381| 0| while ((param = *stack_block_next(&jq->stk, param))) { ------------------ | Branch (381:18): [True: 0, False: 0] ------------------ 382| 0| printf(" || "); 383| 0| jv_dump(jv_copy(*(jv*)stack_block(&jq->stk, param)), JV_PRINT_REFCOUNT); 384| 0| } 385| 0| } 386| 0| } else { 387| 0| printf("\t"); 388| 0| } 389| | 390| 0| printf("\n"); 391| 0| } 392| | 393| 335M| if (backtracking) { ------------------ | Branch (393:9): [True: 38.3M, False: 296M] ------------------ 394| 38.3M| opcode = ON_BACKTRACK(opcode); ------------------ | | 338| 38.3M|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ 395| 38.3M| backtracking = 0; 396| 38.3M| raising = !jv_is_valid(jq->error); 397| 38.3M| } 398| 335M| pc++; 399| | 400| 335M| switch (opcode) { 401| 0| default: assert(0 && "invalid instruction"); ------------------ | Branch (401:5): [True: 0, False: 335M] | Branch (401:14): [Folded, False: 0] | Branch (401:14): [True: 0, False: 0] | Branch (401:14): [Folded, False: 0] | Branch (401:14): [True: 0, False: 0] ------------------ 402| | 403| 6.14k| case TOP: break; ------------------ | Branch (403:5): [True: 6.14k, False: 335M] ------------------ 404| | 405| 0| case ERRORK: { ------------------ | Branch (405:5): [True: 0, False: 335M] ------------------ 406| 0| jv v = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++); 407| 0| set_error(jq, jv_invalid_with_msg(v)); 408| 0| goto do_backtrack; 409| 0| } 410| | 411| 5.34M| case LOADK: { ------------------ | Branch (411:5): [True: 5.34M, False: 329M] ------------------ 412| 5.34M| jv v = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++); 413| 5.34M| assert(jv_is_valid(v)); ------------------ | Branch (413:7): [True: 0, False: 5.34M] | Branch (413:7): [True: 5.34M, False: 0] ------------------ 414| 5.34M| jv_free(stack_pop(jq)); 415| 5.34M| stack_push(jq, v); 416| 5.34M| break; 417| 5.34M| } 418| | 419| 857k| case GENLABEL: { ------------------ | Branch (419:5): [True: 857k, False: 334M] ------------------ 420| 857k| stack_push(jq, JV_OBJECT(jv_string("__jq"), jv_number(jq->next_label++))); ------------------ | | 207| 857k| JV_OBJECT_IDX(__VA_ARGS__, \ | | ------------------ | | | | 205| 857k|#define JV_OBJECT_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,NAME,...) NAME | | | | ------------------ | | | | | | 212| 857k| JV_OBJECT_2, JV_OBJECT_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 178| 857k|#define JV_OBJECT_2(k1,v1) (jv_object_set(jv_object(),(k1),(v1))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 208| 857k| JV_OBJECT_18, JV_OBJECT_17, JV_OBJECT_16, JV_OBJECT_15, \ | | 209| 857k| JV_OBJECT_14, JV_OBJECT_13, JV_OBJECT_12, JV_OBJECT_11, \ | | 210| 857k| JV_OBJECT_10, JV_OBJECT_9, JV_OBJECT_8, JV_OBJECT_7, \ | | 211| 857k| JV_OBJECT_6, JV_OBJECT_5, JV_OBJECT_4, JV_OBJECT_3, \ | | 212| 857k| JV_OBJECT_2, JV_OBJECT_1)(__VA_ARGS__) ------------------ 421| 857k| break; 422| 5.34M| } 423| | 424| 17.7M| case DUP: { ------------------ | Branch (424:5): [True: 17.7M, False: 317M] ------------------ 425| 17.7M| jv v = stack_pop(jq); 426| 17.7M| stack_push(jq, jv_copy(v)); 427| 17.7M| stack_push(jq, v); 428| 17.7M| break; 429| 5.34M| } 430| | 431| 757k| case DUPN: { ------------------ | Branch (431:5): [True: 757k, False: 334M] ------------------ 432| 757k| jv v = stack_popn(jq); 433| 757k| stack_push(jq, jv_copy(v)); 434| 757k| stack_push(jq, v); 435| 757k| break; 436| 5.34M| } 437| | 438| 0| case DUP2: { ------------------ | Branch (438:5): [True: 0, False: 335M] ------------------ 439| 0| jv keep = stack_pop(jq); 440| 0| jv v = stack_pop(jq); 441| 0| stack_push(jq, jv_copy(v)); 442| 0| stack_push(jq, keep); 443| 0| stack_push(jq, v); 444| 0| break; 445| 5.34M| } 446| | 447| 19.9M| case SUBEXP_BEGIN: { ------------------ | Branch (447:5): [True: 19.9M, False: 315M] ------------------ 448| 19.9M| jv v = stack_pop(jq); 449| 19.9M| stack_push(jq, jv_copy(v)); 450| 19.9M| stack_push(jq, v); 451| 19.9M| jq->subexp_nest++; 452| 19.9M| break; 453| 5.34M| } 454| | 455| 20.2M| case SUBEXP_END: { ------------------ | Branch (455:5): [True: 20.2M, False: 315M] ------------------ 456| 20.2M| assert(jq->subexp_nest > 0); ------------------ | Branch (456:7): [True: 0, False: 20.2M] | Branch (456:7): [True: 20.2M, False: 0] ------------------ 457| 20.2M| jq->subexp_nest--; 458| 20.2M| jv a = stack_pop(jq); 459| 20.2M| jv b = stack_pop(jq); 460| 20.2M| stack_push(jq, a); 461| 20.2M| stack_push(jq, b); 462| 20.2M| break; 463| 20.2M| } 464| | 465| 15.8M| case PUSHK_UNDER: { ------------------ | Branch (465:5): [True: 15.8M, False: 319M] ------------------ 466| 15.8M| jv v = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++); 467| 15.8M| assert(jv_is_valid(v)); ------------------ | Branch (467:7): [True: 0, False: 15.8M] | Branch (467:7): [True: 15.8M, False: 0] ------------------ 468| 15.8M| jv v2 = stack_pop(jq); 469| 15.8M| stack_push(jq, v); 470| 15.8M| stack_push(jq, v2); 471| 15.8M| break; 472| 15.8M| } 473| | 474| 14.3M| case POP: { ------------------ | Branch (474:5): [True: 14.3M, False: 320M] ------------------ 475| 14.3M| jv_free(stack_pop(jq)); 476| 14.3M| break; 477| 15.8M| } 478| | 479| 28.5M| case APPEND: { ------------------ | Branch (479:5): [True: 28.5M, False: 306M] ------------------ 480| 28.5M| jv v = stack_pop(jq); 481| 28.5M| uint16_t level = *pc++; 482| 28.5M| uint16_t vidx = *pc++; 483| 28.5M| jv* var = frame_local_var(jq, vidx, level); 484| 28.5M| assert(jv_get_kind(*var) == JV_KIND_ARRAY); ------------------ | Branch (484:7): [True: 0, False: 28.5M] | Branch (484:7): [True: 28.5M, False: 0] ------------------ 485| 28.5M| *var = jv_array_append(*var, v); 486| 28.5M| break; 487| 28.5M| } 488| | 489| 1.82M| case INSERT: { ------------------ | Branch (489:5): [True: 1.82M, False: 333M] ------------------ 490| 1.82M| jv stktop = stack_pop(jq); 491| 1.82M| jv v = stack_pop(jq); 492| 1.82M| jv k = stack_pop(jq); 493| 1.82M| jv objv = stack_pop(jq); 494| 1.82M| assert(jv_get_kind(objv) == JV_KIND_OBJECT); ------------------ | Branch (494:7): [True: 0, False: 1.82M] | Branch (494:7): [True: 1.82M, False: 0] ------------------ 495| 1.82M| if (jv_get_kind(k) == JV_KIND_STRING) { ------------------ | Branch (495:11): [True: 1.82M, False: 2] ------------------ 496| 1.82M| stack_push(jq, jv_object_set(objv, k, v)); 497| 1.82M| stack_push(jq, stktop); 498| 1.82M| } else { 499| 2| char errbuf[30]; 500| 2| set_error(jq, jv_invalid_with_msg(jv_string_fmt( 501| 2| "Cannot use %s (%s) as object key", 502| 2| jv_kind_name(jv_get_kind(k)), 503| 2| jv_dump_string_trunc(jv_copy(k), errbuf, sizeof(errbuf))))); 504| 2| jv_free(stktop); 505| 2| jv_free(v); 506| 2| jv_free(k); 507| 2| jv_free(objv); 508| 2| goto do_backtrack; 509| 2| } 510| 1.82M| break; 511| 1.82M| } 512| | 513| 23.9M| case ON_BACKTRACK(RANGE): ------------------ | | 338| 23.9M|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (513:5): [True: 23.9M, False: 311M] ------------------ 514| 23.9M| case RANGE: { ------------------ | Branch (514:5): [True: 69.1k, False: 335M] ------------------ 515| 23.9M| uint16_t level = *pc++; 516| 23.9M| uint16_t v = *pc++; 517| 23.9M| jv* var = frame_local_var(jq, v, level); 518| 23.9M| jv max = stack_pop(jq); 519| 23.9M| if (raising) { ------------------ | Branch (519:11): [True: 570, False: 23.9M] ------------------ 520| 570| jv_free(max); 521| 570| goto do_backtrack; 522| 570| } 523| 23.9M| if (jv_get_kind(*var) != JV_KIND_NUMBER || ------------------ | Branch (523:11): [True: 0, False: 23.9M] ------------------ 524| 23.9M| jv_get_kind(max) != JV_KIND_NUMBER) { ------------------ | Branch (524:11): [True: 1, False: 23.9M] ------------------ 525| 1| set_error(jq, jv_invalid_with_msg(jv_string_fmt("Range bounds must be numeric"))); 526| 1| jv_free(max); 527| 1| goto do_backtrack; 528| 23.9M| } else if (jv_number_value(*var) >= jv_number_value(max)) { ------------------ | Branch (528:18): [True: 68.5k, False: 23.9M] ------------------ 529| | /* finished iterating */ 530| 68.5k| jv_free(max); 531| 68.5k| goto do_backtrack; 532| 23.9M| } else { 533| 23.9M| jv curr = *var; 534| 23.9M| *var = jv_number(jv_number_value(*var) + 1); 535| | 536| 23.9M| struct stack_pos spos = stack_get_pos(jq); 537| 23.9M| stack_push(jq, max); 538| 23.9M| stack_save(jq, pc - 3, spos); 539| | 540| 23.9M| stack_push(jq, curr); 541| 23.9M| } 542| 23.9M| break; 543| 23.9M| } 544| | 545| | // FIXME: loadv/storev may do too much copying/freeing 546| 23.9M| case LOADV: { ------------------ | Branch (546:5): [True: 10.6M, False: 324M] ------------------ 547| 10.6M| uint16_t level = *pc++; 548| 10.6M| uint16_t v = *pc++; 549| 10.6M| jv* var = frame_local_var(jq, v, level); 550| 10.6M| if (jq->debug_trace_enabled) { ------------------ | Branch (550:11): [True: 0, False: 10.6M] ------------------ 551| 0| printf("V%d = ", v); 552| 0| jv_dump(jv_copy(*var), JV_PRINT_REFCOUNT); 553| 0| printf("\n"); 554| 0| } 555| 10.6M| jv_free(stack_pop(jq)); 556| 10.6M| stack_push(jq, jv_copy(*var)); 557| 10.6M| break; 558| 23.9M| } 559| | 560| | // Does a load but replaces the variable with null 561| 6.16M| case LOADVN: { ------------------ | Branch (561:5): [True: 6.16M, False: 329M] ------------------ 562| 6.16M| uint16_t level = *pc++; 563| 6.16M| uint16_t v = *pc++; 564| 6.16M| jv* var = frame_local_var(jq, v, level); 565| 6.16M| if (jq->debug_trace_enabled) { ------------------ | Branch (565:11): [True: 0, False: 6.16M] ------------------ 566| 0| printf("V%d = ", v); 567| 0| jv_dump(jv_copy(*var), JV_PRINT_REFCOUNT); 568| 0| printf("\n"); 569| 0| } 570| 6.16M| jv_free(stack_popn(jq)); 571| | 572| | // This `stack_push()` invalidates the `var` reference, so 573| 6.16M| stack_push(jq, *var); 574| | // we have to re-resolve `var` before we can set it to null 575| 6.16M| var = frame_local_var(jq, v, level); 576| 6.16M| *var = jv_null(); 577| 6.16M| break; 578| 23.9M| } 579| | 580| 16| case STOREVN: ------------------ | Branch (580:5): [True: 16, False: 335M] ------------------ 581| 16| stack_save(jq, pc - 1, stack_get_pos(jq)); 582| 16| JQ_FALLTHROUGH; ------------------ | | 14| 16|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 583| 13.1M| case STOREV: { ------------------ | Branch (583:5): [True: 13.1M, False: 322M] ------------------ 584| 13.1M| uint16_t level = *pc++; 585| 13.1M| uint16_t v = *pc++; 586| 13.1M| jv* var = frame_local_var(jq, v, level); 587| 13.1M| jv val = stack_pop(jq); 588| 13.1M| if (jq->debug_trace_enabled) { ------------------ | Branch (588:11): [True: 0, False: 13.1M] ------------------ 589| 0| printf("V%d = ", v); 590| 0| jv_dump(jv_copy(val), 0); 591| 0| printf(" (%d)\n", jv_get_refcnt(val)); 592| 0| } 593| 13.1M| jv_free(*var); 594| 13.1M| *var = val; 595| 13.1M| break; 596| 16| } 597| | 598| 4| case ON_BACKTRACK(STOREVN): { ------------------ | | 338| 4|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (598:5): [True: 4, False: 335M] ------------------ 599| 4| uint16_t level = *pc++; 600| 4| uint16_t v = *pc++; 601| 4| jv* var = frame_local_var(jq, v, level); 602| 4| jv_free(*var); 603| 4| *var = jv_null(); 604| 4| goto do_backtrack; 605| 0| break; 606| 16| } 607| | 608| 0| case STORE_GLOBAL: { ------------------ | Branch (608:5): [True: 0, False: 335M] ------------------ 609| | // Get the constant 610| 0| jv val = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++); 611| 0| assert(jv_is_valid(val)); ------------------ | Branch (611:7): [True: 0, False: 0] | Branch (611:7): [True: 0, False: 0] ------------------ 612| | 613| | // Store the var 614| 0| uint16_t level = *pc++; 615| 0| uint16_t v = *pc++; 616| 0| jv* var = frame_local_var(jq, v, level); 617| 0| if (jq->debug_trace_enabled) { ------------------ | Branch (617:11): [True: 0, False: 0] ------------------ 618| 0| printf("V%d = ", v); 619| 0| jv_dump(jv_copy(val), 0); 620| 0| printf(" (%d)\n", jv_get_refcnt(val)); 621| 0| } 622| 0| jv_free(*var); 623| 0| *var = val; 624| 0| break; 625| 0| } 626| | 627| 584k| case PATH_BEGIN: { ------------------ | Branch (627:5): [True: 584k, False: 334M] ------------------ 628| 584k| jv v = stack_pop(jq); 629| 584k| stack_push(jq, jq->path); 630| | 631| 584k| stack_save(jq, pc - 1, stack_get_pos(jq)); 632| | 633| 584k| stack_push(jq, jv_number(jq->subexp_nest)); 634| 584k| stack_push(jq, jq->value_at_path); 635| 584k| stack_push(jq, jv_copy(v)); 636| | 637| 584k| jq->path = jv_array(); 638| 584k| jq->value_at_path = v; // next INDEX operation must index into v 639| 584k| jq->subexp_nest = 0; 640| 584k| break; 641| 0| } 642| | 643| 1.71M| case PATH_END: { ------------------ | Branch (643:5): [True: 1.71M, False: 333M] ------------------ 644| 1.71M| jv v = stack_pop(jq); 645| | // detect invalid path expression like path(.a | reverse) 646| 1.71M| if (!path_intact(jq, jv_copy(v))) { ------------------ | Branch (646:11): [True: 0, False: 1.71M] ------------------ 647| 0| char errbuf[30]; 648| 0| jv msg = jv_string_fmt( 649| 0| "Invalid path expression with result %s", 650| 0| jv_dump_string_trunc(v, errbuf, sizeof(errbuf))); 651| 0| set_error(jq, jv_invalid_with_msg(msg)); 652| 0| goto do_backtrack; 653| 0| } 654| 1.71M| jv_free(v); // discard value, only keep path 655| | 656| 1.71M| jv old_value_at_path = stack_pop(jq); 657| 1.71M| int old_subexp_nest = (int)jv_number_value(stack_pop(jq)); 658| | 659| 1.71M| jv path = jq->path; 660| 1.71M| jq->path = stack_pop(jq); 661| | 662| 1.71M| struct stack_pos spos = stack_get_pos(jq); 663| 1.71M| stack_push(jq, jv_copy(path)); 664| 1.71M| stack_save(jq, pc - 1, spos); 665| | 666| 1.71M| stack_push(jq, path); 667| 1.71M| jq->subexp_nest = old_subexp_nest; 668| 1.71M| jv_free(jq->value_at_path); 669| 1.71M| jq->value_at_path = old_value_at_path; 670| 1.71M| break; 671| 1.71M| } 672| | 673| 584k| case ON_BACKTRACK(PATH_BEGIN): ------------------ | | 338| 584k|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (673:5): [True: 584k, False: 334M] ------------------ 674| 2.30M| case ON_BACKTRACK(PATH_END): { ------------------ | | 338| 2.30M|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (674:5): [True: 1.71M, False: 333M] ------------------ 675| 2.30M| jv_free(jq->path); 676| 2.30M| jq->path = stack_pop(jq); 677| 2.30M| goto do_backtrack; 678| 584k| } 679| | 680| 7.62M| case INDEX: ------------------ | Branch (680:5): [True: 7.62M, False: 327M] ------------------ 681| 7.62M| case INDEX_OPT: { ------------------ | Branch (681:5): [True: 540, False: 335M] ------------------ 682| 7.62M| jv t = stack_pop(jq); 683| 7.62M| jv k = stack_pop(jq); 684| | // detect invalid path expression like path(reverse | .a) 685| 7.62M| if (!path_intact(jq, jv_copy(t))) { ------------------ | Branch (685:11): [True: 0, False: 7.62M] ------------------ 686| 0| char keybuf[30]; 687| 0| char objbuf[30]; 688| 0| jv msg = jv_string_fmt( 689| 0| "Invalid path expression near attempt to access element %s of %s", 690| 0| jv_dump_string_trunc(k, keybuf, sizeof(keybuf)), 691| 0| jv_dump_string_trunc(t, objbuf, sizeof(objbuf))); 692| 0| set_error(jq, jv_invalid_with_msg(msg)); 693| 0| goto do_backtrack; 694| 0| } 695| 7.62M| jv v = jv_get(t, jv_copy(k)); 696| 7.62M| if (jv_is_valid(v)) { ------------------ | Branch (696:11): [True: 7.62M, False: 1.40k] ------------------ 697| 7.62M| path_append(jq, k, jv_copy(v)); 698| 7.62M| stack_push(jq, v); 699| 7.62M| } else { 700| 1.40k| jv_free(k); 701| 1.40k| if (opcode == INDEX) ------------------ | Branch (701:13): [True: 863, False: 540] ------------------ 702| 863| set_error(jq, v); 703| 540| else 704| 540| jv_free(v); 705| 1.40k| goto do_backtrack; 706| 1.40k| } 707| 7.62M| break; 708| 7.62M| } 709| | 710| | 711| 7.62M| case JUMP: { ------------------ | Branch (711:5): [True: 5.40M, False: 329M] ------------------ 712| 5.40M| uint16_t offset = *pc++; 713| 5.40M| pc += offset; 714| 5.40M| break; 715| 7.62M| } 716| | 717| 6.22M| case JUMP_F: { ------------------ | Branch (717:5): [True: 6.22M, False: 329M] ------------------ 718| 6.22M| uint16_t offset = *pc++; 719| 6.22M| jv t = stack_pop(jq); 720| 6.22M| jv_kind kind = jv_get_kind(t); 721| 6.22M| if (kind == JV_KIND_FALSE || kind == JV_KIND_NULL) { ------------------ | Branch (721:11): [True: 3.68M, False: 2.53M] | Branch (721:36): [True: 4.46k, False: 2.53M] ------------------ 722| 3.69M| pc += offset; 723| 3.69M| } 724| 6.22M| stack_push(jq, t); // FIXME do this better 725| 6.22M| break; 726| 7.62M| } 727| | 728| 667k| case EACH: ------------------ | Branch (728:5): [True: 667k, False: 334M] ------------------ 729| 1.45M| case EACH_OPT: { ------------------ | Branch (729:5): [True: 792k, False: 334M] ------------------ 730| 1.45M| jv container = stack_pop(jq); 731| | // detect invalid path expression like path(reverse | .[]) 732| 1.45M| if (!path_intact(jq, jv_copy(container))) { ------------------ | Branch (732:11): [True: 0, False: 1.45M] ------------------ 733| 0| char errbuf[30]; 734| 0| jv msg = jv_string_fmt( 735| 0| "Invalid path expression near attempt to iterate through %s", 736| 0| jv_dump_string_trunc(container, errbuf, sizeof(errbuf))); 737| 0| set_error(jq, jv_invalid_with_msg(msg)); 738| 0| goto do_backtrack; 739| 0| } 740| 1.45M| stack_push(jq, container); 741| 1.45M| stack_push(jq, jv_number(-1)); 742| 1.45M| JQ_FALLTHROUGH; ------------------ | | 14| 1.45M|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 743| 1.45M| } 744| 4.57M| case ON_BACKTRACK(EACH): ------------------ | | 338| 4.57M|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (744:5): [True: 3.11M, False: 332M] ------------------ 745| 5.36M| case ON_BACKTRACK(EACH_OPT): { ------------------ | | 338| 5.36M|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (745:5): [True: 787k, False: 334M] ------------------ 746| 5.36M| int idx = jv_number_value(stack_pop(jq)); 747| 5.36M| jv container = stack_pop(jq); 748| | 749| 5.36M| int keep_going, is_last = 0; 750| 5.36M| jv key, value; 751| 5.36M| if (jv_get_kind(container) == JV_KIND_ARRAY) { ------------------ | Branch (751:11): [True: 4.54M, False: 812k] ------------------ 752| 4.54M| if (opcode == EACH || opcode == EACH_OPT) idx = 0; ------------------ | Branch (752:13): [True: 658k, False: 3.89M] | Branch (752:31): [True: 4.21k, False: 3.88M] ------------------ 753| 3.88M| else idx = idx + 1; 754| 4.54M| int len = jv_array_length(jv_copy(container)); 755| 4.54M| keep_going = idx < len; 756| 4.54M| is_last = idx == len - 1; 757| 4.54M| if (keep_going) { ------------------ | Branch (757:13): [True: 4.44M, False: 103k] ------------------ 758| 4.44M| key = jv_number(idx); 759| 4.44M| value = jv_array_get(jv_copy(container), idx); 760| 4.44M| } 761| 4.54M| } else if (jv_get_kind(container) == JV_KIND_OBJECT) { ------------------ | Branch (761:18): [True: 30.0k, False: 781k] ------------------ 762| 30.0k| if (opcode == EACH || opcode == EACH_OPT) idx = jv_object_iter(container); ------------------ | Branch (762:13): [True: 9.20k, False: 20.8k] | Branch (762:31): [True: 6.03k, False: 14.8k] ------------------ 763| 14.8k| else idx = jv_object_iter_next(container, idx); 764| 30.0k| keep_going = jv_object_iter_valid(container, idx); 765| 30.0k| if (keep_going) { ------------------ | Branch (765:13): [True: 15.6k, False: 14.4k] ------------------ 766| 15.6k| key = jv_object_iter_key(container, idx); 767| 15.6k| value = jv_object_iter_value(container, idx); 768| 15.6k| } 769| 781k| } else { 770| 781k| assert(opcode == EACH || opcode == EACH_OPT); ------------------ | Branch (770:9): [True: 781k, False: 0] | Branch (770:9): [True: 0, False: 0] | Branch (770:9): [True: 66, False: 781k] | Branch (770:9): [True: 781k, False: 0] ------------------ 771| 781k| if (opcode == EACH) { ------------------ | Branch (771:13): [True: 66, False: 781k] ------------------ 772| 66| char errbuf[30]; 773| 66| set_error(jq, jv_invalid_with_msg(jv_string_fmt( 774| 66| "Cannot iterate over %s (%s)", 775| 66| jv_kind_name(jv_get_kind(container)), 776| 66| jv_dump_string_trunc(jv_copy(container), errbuf, sizeof(errbuf))))); 777| 66| } 778| 781k| keep_going = 0; 779| 781k| } 780| | 781| 5.36M| if (!keep_going || raising) { ------------------ | Branch (781:11): [True: 900k, False: 4.46M] | Branch (781:26): [True: 397k, False: 4.06M] ------------------ 782| 1.29M| if (keep_going) { ------------------ | Branch (782:13): [True: 397k, False: 900k] ------------------ 783| 397k| jv_free(key); 784| 397k| jv_free(value); 785| 397k| } 786| 1.29M| jv_free(container); 787| 1.29M| goto do_backtrack; 788| 4.06M| } else if (is_last) { ------------------ | Branch (788:18): [True: 143k, False: 3.92M] ------------------ 789| | // we don't need to make a backtrack point 790| 143k| jv_free(container); 791| 143k| path_append(jq, key, jv_copy(value)); 792| 143k| stack_push(jq, value); 793| 3.92M| } else { 794| 3.92M| struct stack_pos spos = stack_get_pos(jq); 795| 3.92M| stack_push(jq, container); 796| 3.92M| stack_push(jq, jv_number(idx)); 797| 3.92M| stack_save(jq, pc - 1, spos); 798| 3.92M| path_append(jq, key, jv_copy(value)); 799| 3.92M| stack_push(jq, value); 800| 3.92M| } 801| 4.06M| break; 802| 5.36M| } 803| | 804| 6.84M| do_backtrack: 805| 38.3M| case BACKTRACK: { ------------------ | Branch (805:5): [True: 31.4M, False: 303M] ------------------ 806| 38.3M| pc = stack_restore(jq); 807| 38.3M| if (!pc) { ------------------ | Branch (807:11): [True: 2.05k, False: 38.3M] ------------------ 808| 2.05k| if (!jv_is_valid(jq->error)) { ------------------ | Branch (808:13): [True: 1.87k, False: 177] ------------------ 809| 1.87k| jv error = jq->error; 810| 1.87k| jq->error = jv_null(); 811| 1.87k| return error; 812| 1.87k| } 813| 177| return jv_invalid(); 814| 2.05k| } 815| 38.3M| backtracking = 1; 816| 38.3M| break; 817| 38.3M| } 818| | 819| 876k| case TRY_BEGIN: ------------------ | Branch (819:5): [True: 876k, False: 334M] ------------------ 820| 876k| stack_save(jq, pc - 1, stack_get_pos(jq)); 821| 876k| pc++; // skip handler offset this time 822| 876k| break; 823| | 824| 858k| case TRY_END: ------------------ | Branch (824:5): [True: 858k, False: 334M] ------------------ 825| 858k| stack_save(jq, pc - 1, stack_get_pos(jq)); 826| 858k| break; 827| | 828| 876k| case ON_BACKTRACK(TRY_BEGIN): { ------------------ | | 338| 876k|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (828:5): [True: 876k, False: 334M] ------------------ 829| 876k| if (!raising) { ------------------ | Branch (829:11): [True: 50.3k, False: 826k] ------------------ 830| | /* 831| | * `try EXP ...` -- EXP backtracked (e.g., EXP was `empty`), so we 832| | * backtrack more: 833| | */ 834| 50.3k| jv_free(stack_pop(jq)); 835| 50.3k| goto do_backtrack; 836| 50.3k| } 837| | 838| | /* 839| | * Else `(try EXP ... ) | EXP2` raised an error. 840| | * 841| | * If the error was wrapped in another error, then that means EXP2 raised 842| | * the error. We unwrap it and re-raise it as it wasn't raised by EXP. 843| | * 844| | * See commentary in gen_try(). 845| | */ 846| 826k| jv e = jv_invalid_get_msg(jv_copy(jq->error)); 847| 826k| if (!jv_is_valid(e) && jv_invalid_has_msg(jv_copy(e))) { ------------------ | Branch (847:11): [True: 0, False: 826k] | Branch (847:30): [True: 0, False: 0] ------------------ 848| 0| set_error(jq, e); 849| 0| goto do_backtrack; 850| 0| } 851| 826k| jv_free(e); 852| | 853| | /* 854| | * Else we caught an error containing a non-error value, so we jump to 855| | * the handler. 856| | * 857| | * See commentary in gen_try(). 858| | */ 859| 826k| uint16_t offset = *pc++; 860| 826k| jv_free(stack_pop(jq)); // free the input 861| 826k| stack_push(jq, jv_invalid_get_msg(jq->error)); // push the error's message 862| 826k| jq->error = jv_null(); 863| 826k| pc += offset; 864| 826k| break; 865| 826k| } 866| 858k| case ON_BACKTRACK(TRY_END): ------------------ | | 338| 858k|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (866:5): [True: 858k, False: 334M] ------------------ 867| | // Wrap the error so the matching TRY_BEGIN doesn't catch it 868| 858k| if (raising) ------------------ | Branch (868:11): [True: 0, False: 858k] ------------------ 869| 0| set_error(jq, jv_invalid_with_msg(jv_copy(jq->error))); 870| 858k| goto do_backtrack; 871| | 872| 15| case DESTRUCTURE_ALT: ------------------ | Branch (872:5): [True: 15, False: 335M] ------------------ 873| 6.44M| case FORK: { ------------------ | Branch (873:5): [True: 6.44M, False: 328M] ------------------ 874| 6.44M| stack_save(jq, pc - 1, stack_get_pos(jq)); 875| 6.44M| pc++; // skip offset this time 876| 6.44M| break; 877| 15| } 878| | 879| 11| case ON_BACKTRACK(DESTRUCTURE_ALT): { ------------------ | | 338| 11|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (879:5): [True: 11, False: 335M] ------------------ 880| 11| if (jv_is_valid(jq->error)) { ------------------ | Branch (880:11): [True: 0, False: 11] ------------------ 881| | // `try EXP ...` backtracked here (no value, `empty`), so we backtrack more 882| 0| jv_free(stack_pop(jq)); 883| 0| goto do_backtrack; 884| 0| } 885| | // `try EXP ...` exception caught in EXP 886| | // DESTRUCTURE_ALT doesn't want the error message on the stack, 887| | // as we would just want to throw it away anyway. 888| 11| if (opcode != ON_BACKTRACK(DESTRUCTURE_ALT)) { ------------------ | | 338| 11|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (888:11): [True: 0, False: 11] ------------------ 889| 0| jv_free(stack_pop(jq)); // free the input 890| 0| stack_push(jq, jv_invalid_get_msg(jq->error)); // push the error's message 891| 11| } else { 892| 11| jv_free(jq->error); 893| 11| } 894| 11| jq->error = jv_null(); 895| 11| uint16_t offset = *pc++; 896| 11| pc += offset; 897| 11| break; 898| 11| } 899| 6.44M| case ON_BACKTRACK(FORK): { ------------------ | | 338| 6.44M|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (899:5): [True: 6.44M, False: 328M] ------------------ 900| 6.44M| if (raising) goto do_backtrack; ------------------ | Branch (900:11): [True: 1.44M, False: 5.00M] ------------------ 901| 5.00M| uint16_t offset = *pc++; 902| 5.00M| pc += offset; 903| 5.00M| break; 904| 6.44M| } 905| | 906| 13.5M| case CALL_BUILTIN: { ------------------ | Branch (906:5): [True: 13.5M, False: 321M] ------------------ 907| 13.5M| int nargs = *pc++; 908| 13.5M| struct cfunction* function = &frame_current(jq)->bc->globals->cfunctions[*pc++]; 909| 13.5M| jv in[MAX_CFUNCTION_ARGS]; 910| 46.8M| for (int i = 0; i < nargs; ++i) ------------------ | Branch (910:23): [True: 33.3M, False: 13.5M] ------------------ 911| 33.3M| in[i] = stack_pop(jq); 912| | 913| 13.5M| jv top; 914| 13.5M| switch (function->nargs) { 915| 2.92M| case 1: top = function->fptr.a1(jq, in[0]); break; ------------------ | Branch (915:7): [True: 2.92M, False: 10.6M] ------------------ 916| 1.45M| case 2: top = function->fptr.a2(jq, in[0], in[1]); break; ------------------ | Branch (916:7): [True: 1.45M, False: 12.0M] ------------------ 917| 9.10M| case 3: top = function->fptr.a3(jq, in[0], in[1], in[2]); break; ------------------ | Branch (917:7): [True: 9.10M, False: 4.42M] ------------------ 918| 47.0k| case 4: top = function->fptr.a4(jq, in[0], in[1], in[2], in[3]); break; ------------------ | Branch (918:7): [True: 47.0k, False: 13.4M] ------------------ 919| 0| default: assert(0 && "Invalid number of arguments"); ------------------ | Branch (919:7): [True: 0, False: 13.5M] | Branch (919:16): [Folded, False: 0] | Branch (919:16): [True: 0, False: 0] | Branch (919:16): [Folded, False: 0] | Branch (919:16): [True: 0, False: 0] ------------------ 920| 13.5M| } 921| | 922| 13.5M| if (!jv_is_valid(top)) { ------------------ | Branch (922:11): [True: 827k, False: 12.7M] ------------------ 923| 827k| if (jv_invalid_has_msg(jv_copy(top))) ------------------ | Branch (923:13): [True: 827k, False: 0] ------------------ 924| 827k| set_error(jq, top); 925| 0| else 926| 0| jv_free(top); 927| 827k| goto do_backtrack; 928| 827k| } 929| | 930| 12.7M| stack_push(jq, top); 931| 12.7M| break; 932| 13.5M| } 933| | 934| 2.43M| case TAIL_CALL_JQ: ------------------ | Branch (934:5): [True: 2.43M, False: 332M] ------------------ 935| 8.67M| case CALL_JQ: { ------------------ | Branch (935:5): [True: 6.23M, False: 329M] ------------------ 936| | /* 937| | * Bytecode layout here: 938| | * 939| | * CALL_JQ 940| | * (i.e., number of call arguments) 941| | * (what we're calling) 942| | * (frame reference + code pointer) 943| | * 944| | * 945| | * 946| | * Each closure consists of two uint16_t values: a "level" 947| | * identifying the frame to be closed over, and an index. 948| | * 949| | * The level is a relative number of call frames reachable from 950| | * the currently one; 0 -> current frame, 1 -> previous frame, and 951| | * so on. 952| | * 953| | * The index is either an index of the closed frame's subfunctions 954| | * or of the closed frame's parameter closures. If the latter, 955| | * that closure will be passed, else the closed frame's pointer 956| | * and the subfunction's code will form the closure to be passed. 957| | * 958| | * See make_closure() for more information. 959| | */ 960| 8.67M| jv input = stack_pop(jq); 961| 8.67M| uint16_t nclosures = *pc++; 962| 8.67M| uint16_t* retaddr = pc + 2 + nclosures*2; 963| 8.67M| stack_ptr retdata = jq->stk_top; 964| 8.67M| struct frame* new_frame; 965| 8.67M| struct closure cl = make_closure(jq, pc); 966| 8.67M| if (opcode == TAIL_CALL_JQ) { ------------------ | Branch (966:11): [True: 2.43M, False: 6.23M] ------------------ 967| 2.43M| retaddr = frame_current(jq)->retaddr; 968| 2.43M| retdata = frame_current(jq)->retdata; 969| 2.43M| frame_pop(jq); 970| 2.43M| } 971| 8.67M| new_frame = frame_push(jq, cl, pc + 2, nclosures); 972| 8.67M| new_frame->retdata = retdata; 973| 8.67M| new_frame->retaddr = retaddr; 974| 8.67M| pc = new_frame->bc->code; 975| 8.67M| stack_push(jq, input); 976| 8.67M| break; 977| 2.43M| } 978| | 979| 56.5M| case RET: { ------------------ | Branch (979:5): [True: 56.5M, False: 278M] ------------------ 980| 56.5M| jv value = stack_pop(jq); 981| 56.5M| assert(jq->stk_top == frame_current(jq)->retdata); ------------------ | Branch (981:7): [True: 0, False: 56.5M] | Branch (981:7): [True: 56.5M, False: 0] ------------------ 982| 56.5M| uint16_t* retaddr = frame_current(jq)->retaddr; 983| 56.5M| if (retaddr) { ------------------ | Branch (983:11): [True: 56.5M, False: 4.09k] ------------------ 984| | // function return 985| 56.5M| pc = retaddr; 986| 56.5M| frame_pop(jq); 987| 56.5M| } else { 988| | // top-level return, yielding value 989| 4.09k| struct stack_pos spos = stack_get_pos(jq); 990| 4.09k| stack_push(jq, jv_null()); 991| 4.09k| stack_save(jq, pc - 1, spos); 992| 4.09k| return value; 993| 4.09k| } 994| 56.5M| stack_push(jq, value); 995| 56.5M| break; 996| 56.5M| } 997| 0| case ON_BACKTRACK(RET): { ------------------ | | 338| 0|#define ON_BACKTRACK(op) ((op)+NUM_OPCODES) ------------------ | Branch (997:5): [True: 0, False: 335M] ------------------ 998| | // resumed after top-level return 999| 0| goto do_backtrack; 1000| 56.5M| } 1001| 335M| } 1002| 335M| } 1003| 6.14k|} jq_format_error: 1005| 10|jv jq_format_error(jv msg) { 1006| 10| if (jv_get_kind(msg) == JV_KIND_NULL || ------------------ | Branch (1006:7): [True: 0, False: 10] ------------------ 1007| 10| (jv_get_kind(msg) == JV_KIND_INVALID && !jv_invalid_has_msg(jv_copy(msg)))) { ------------------ | Branch (1007:8): [True: 0, False: 10] | Branch (1007:47): [True: 0, False: 0] ------------------ 1008| 0| jv_free(msg); 1009| 0| fprintf(stderr, "jq: error: out of memory\n"); 1010| 0| return jv_null(); 1011| 0| } 1012| | 1013| 10| if (jv_get_kind(msg) == JV_KIND_STRING) ------------------ | Branch (1013:7): [True: 10, False: 0] ------------------ 1014| 10| return msg; // expected to already be formatted 1015| | 1016| 0| if (jv_get_kind(msg) == JV_KIND_INVALID) ------------------ | Branch (1016:7): [True: 0, False: 0] ------------------ 1017| 0| msg = jv_invalid_get_msg(msg); 1018| | 1019| 0| if (jv_get_kind(msg) == JV_KIND_NULL) ------------------ | Branch (1019:7): [True: 0, False: 0] ------------------ 1020| 0| return jq_format_error(msg); // ENOMEM 1021| | 1022| | // Invalid with msg; prefix with "jq: error: " 1023| | 1024| 0| if (jv_get_kind(msg) != JV_KIND_INVALID) { ------------------ | Branch (1024:7): [True: 0, False: 0] ------------------ 1025| 0| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (1025:9): [True: 0, False: 0] ------------------ 1026| 0| jv r = jv_string_fmt("jq: error: %s", jv_string_value(msg)); 1027| 0| jv_free(msg); 1028| 0| return r; 1029| 0| } 1030| | 1031| 0| msg = jv_dump_string(msg, JV_PRINT_INVALID); 1032| 0| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (1032:9): [True: 0, False: 0] ------------------ 1033| 0| jv r = jv_string_fmt("jq: error: %s", jv_string_value(msg)); 1034| 0| jv_free(msg); 1035| 0| return r; 1036| 0| } 1037| 0| jv_free(msg); 1038| 0| return jq_format_error(jv_null()); // ENOMEM 1039| 0| } 1040| | 1041| | // An invalid inside an invalid! 1042| 0| return jq_format_error(jv_invalid_get_msg(msg)); 1043| 0|} jq_init: 1054| 7.65k|jq_state *jq_init(void) { 1055| 7.65k| jq_state *jq; 1056| 7.65k| jq = jv_mem_alloc_unguarded(sizeof(*jq)); 1057| 7.65k| if (jq == NULL) ------------------ | Branch (1057:7): [True: 0, False: 7.65k] ------------------ 1058| 0| return NULL; 1059| | 1060| 7.65k| jq->bc = 0; 1061| 7.65k| jq->next_label = 0; 1062| | 1063| 7.65k| stack_init(&jq->stk); 1064| 7.65k| jq->stk_top = 0; 1065| 7.65k| jq->fork_top = 0; 1066| 7.65k| jq->curr_frame = 0; 1067| 7.65k| jq->error = jv_null(); 1068| | 1069| 7.65k| jq->halted = 0; 1070| 7.65k| jq->exit_code = jv_invalid(); 1071| 7.65k| jq->error_message = jv_invalid(); 1072| | 1073| 7.65k| jq->input_cb = NULL; 1074| 7.65k| jq->input_cb_data = NULL; 1075| | 1076| 7.65k| jq->debug_cb = NULL; 1077| 7.65k| jq->debug_cb_data = NULL; 1078| | 1079| 7.65k| jq->stderr_cb = NULL; 1080| 7.65k| jq->stderr_cb_data = NULL; 1081| | 1082| 7.65k| jq->err_cb = default_err_cb; 1083| 7.65k| jq->err_cb_data = stderr; 1084| | 1085| 7.65k| jq->attrs = jv_object(); 1086| 7.65k| jq->path = jv_null(); 1087| 7.65k| jq->value_at_path = jv_null(); 1088| | 1089| 7.65k| jq->nomem_handler = NULL; 1090| | jq->nomem_handler_data = NULL; 1091| 7.65k| return jq; 1092| 7.65k|} jq_start: 1116| 6.55k|void jq_start(jq_state *jq, jv input, int flags) { 1117| 6.55k| jv_nomem_handler(jq->nomem_handler, jq->nomem_handler_data); 1118| 6.55k| jq_reset(jq); 1119| | 1120| 6.55k| struct closure top = {jq->bc, -1}; 1121| 6.55k| struct frame* top_frame = frame_push(jq, top, 0, 0); 1122| 6.55k| top_frame->retdata = 0; 1123| 6.55k| top_frame->retaddr = 0; 1124| | 1125| 6.55k| stack_push(jq, input); 1126| 6.55k| stack_save(jq, jq->bc->code, stack_get_pos(jq)); 1127| 6.55k| jq->debug_trace_enabled = flags & JQ_DEBUG_TRACE_ALL; 1128| 6.55k| jq->initial_execution = 1; 1129| 6.55k|} jq_teardown: 1131| 7.65k|void jq_teardown(jq_state **jq) { 1132| 7.65k| jq_state *old_jq = *jq; 1133| 7.65k| if (old_jq == NULL) ------------------ | Branch (1133:7): [True: 0, False: 7.65k] ------------------ 1134| 0| return; 1135| 7.65k| *jq = NULL; 1136| | 1137| 7.65k| jq_reset(old_jq); 1138| 7.65k| bytecode_free(old_jq->bc); 1139| 7.65k| old_jq->bc = 0; 1140| 7.65k| jv_free(old_jq->attrs); 1141| | 1142| 7.65k| jv_mem_free(old_jq); 1143| 7.65k|} jq_compile_args: 1232| 7.65k|int jq_compile_args(jq_state *jq, const char* str, jv args) { 1233| 7.65k| jv_nomem_handler(jq->nomem_handler, jq->nomem_handler_data); 1234| 7.65k| assert(jv_get_kind(args) == JV_KIND_ARRAY || jv_get_kind(args) == JV_KIND_OBJECT); ------------------ | Branch (1234:3): [True: 7.65k, False: 0] | Branch (1234:3): [True: 0, False: 0] | Branch (1234:3): [True: 0, False: 7.65k] | Branch (1234:3): [True: 7.65k, False: 0] ------------------ 1235| 7.65k| struct locfile* locations; 1236| 7.65k| locations = locfile_init(jq, "", str, strlen(str)); 1237| 7.65k| block program; 1238| 7.65k| jq_reset(jq); 1239| 7.65k| if (jq->bc) { ------------------ | Branch (1239:7): [True: 0, False: 7.65k] ------------------ 1240| 0| bytecode_free(jq->bc); 1241| 0| jq->bc = 0; 1242| 0| } 1243| 7.65k| int nerrors = load_program(jq, locations, &program); 1244| 7.65k| if (nerrors == 0) { ------------------ | Branch (1244:7): [True: 7.64k, False: 5] ------------------ 1245| 7.64k| nerrors = builtins_bind(jq, &program); 1246| 7.64k| if (nerrors == 0) ------------------ | Branch (1246:9): [True: 7.64k, False: 0] ------------------ 1247| 7.64k| nerrors = block_compile(program, &jq->bc, locations, args2obj(args)); 1248| 0| else 1249| 0| jv_free(args); 1250| 7.64k| } else 1251| 5| jv_free(args); 1252| 7.65k| if (nerrors) ------------------ | Branch (1252:7): [True: 5, False: 7.64k] ------------------ 1253| 5| jq_report_error(jq, jv_string_fmt("jq: %d compile %s", nerrors, nerrors > 1 ? "errors" : "error")); ------------------ | Branch (1253:69): [True: 0, False: 5] ------------------ 1254| 7.65k| if (jq->bc) ------------------ | Branch (1254:7): [True: 7.64k, False: 5] ------------------ 1255| 7.64k| jq->bc = optimize(jq->bc); 1256| 7.65k| locfile_free(locations); 1257| | return jq->bc != NULL; 1258| 7.65k|} jq_compile: 1260| 7.65k|int jq_compile(jq_state *jq, const char* str) { 1261| 7.65k| return jq_compile_args(jq, str, jv_object()); 1262| 7.65k|} jq_get_jq_origin: 1264| 7.64k|jv jq_get_jq_origin(jq_state *jq) { 1265| 7.64k| return jq_get_attr(jq, jv_string("JQ_ORIGIN")); 1266| 7.64k|} jq_get_prog_origin: 1268| 7.64k|jv jq_get_prog_origin(jq_state *jq) { 1269| 7.64k| return jq_get_attr(jq, jv_string("PROGRAM_ORIGIN")); 1270| 7.64k|} jq_set_attr: 1283| 7.65k|void jq_set_attr(jq_state *jq, jv attr, jv val) { 1284| 7.65k| jq->attrs = jv_object_set(jq->attrs, attr, val); 1285| 7.65k|} jq_get_attr: 1287| 15.2k|jv jq_get_attr(jq_state *jq, jv attr) { 1288| 15.2k| return jv_object_get(jv_copy(jq->attrs), attr); 1289| 15.2k|} execute.c:frame_pop: 150| 61.6M|static void frame_pop(struct jq_state* jq) { 151| 61.6M| assert(jq->curr_frame); ------------------ | Branch (151:3): [True: 0, False: 61.6M] | Branch (151:3): [True: 61.6M, False: 0] ------------------ 152| 61.6M| struct frame* fp = frame_current(jq); 153| 61.6M| if (stack_pop_will_free(&jq->stk, jq->curr_frame)) { ------------------ | Branch (153:7): [True: 8.67M, False: 53.0M] ------------------ 154| 8.67M| int nlocals = fp->bc->nlocals; 155| 26.2M| for (int i=0; icurr_frame = stack_pop_block(&jq->stk, jq->curr_frame, frame_size(fp->bc)); 160| 61.6M|} execute.c:frame_size: 73| 70.3M|static int frame_size(struct bytecode* bc) { 74| 70.3M| return sizeof(struct frame) + sizeof(union frame_entry) * (bc->nclosures + bc->nlocals); 75| 70.3M|} execute.c:frame_current: 77| 214M|static struct frame* frame_current(struct jq_state* jq) { 78| 214M| struct frame* fp = stack_block(&jq->stk, jq->curr_frame); 79| | 80| 214M| stack_ptr next = *stack_block_next(&jq->stk, jq->curr_frame); 81| 214M| if (next) { ------------------ | Branch (81:7): [True: 214M, False: 152k] ------------------ 82| 214M| struct frame* fpnext = stack_block(&jq->stk, next); 83| 214M| struct bytecode* bc = fpnext->bc; 84| 214M| assert(fp->retaddr >= bc->code && fp->retaddr < bc->code + bc->codelen); ------------------ | Branch (84:5): [True: 0, False: 214M] | Branch (84:5): [True: 0, False: 0] | Branch (84:5): [True: 214M, False: 0] | Branch (84:5): [True: 214M, False: 0] ------------------ 85| 214M| } else { 86| 152k| assert(fp->retaddr == 0); ------------------ | Branch (86:5): [True: 0, False: 152k] | Branch (86:5): [True: 152k, False: 0] ------------------ 87| 152k| } 88| 214M| return fp; 89| 214M|} execute.c:set_error: 332| 828k|static void set_error(jq_state *jq, jv value) { 333| | // Record so try/catch can find it. 334| 828k| jv_free(jq->error); 335| 828k| jq->error = value; 336| 828k|} execute.c:frame_local_var: 100| 106M|static jv* frame_local_var(struct jq_state* jq, int var, int level) { 101| 106M| struct frame* fr = stack_block(&jq->stk, frame_get_level(jq, level)); 102| 106M| assert(var >= 0); ------------------ | Branch (102:3): [True: 0, False: 106M] | Branch (102:3): [True: 106M, False: 0] ------------------ 103| 106M| assert(var < fr->bc->nlocals); ------------------ | Branch (103:3): [True: 0, False: 106M] | Branch (103:3): [True: 106M, False: 0] ------------------ 104| 106M| return &fr->entries[fr->bc->nclosures + var].localvar; 105| 106M|} execute.c:frame_get_level: 91| 116M|static stack_ptr frame_get_level(struct jq_state* jq, int level) { 92| 116M| stack_ptr fr = jq->curr_frame; 93| 122M| for (int i=0; istk, fr); 95| 5.65M| fr = fp->env; 96| 5.65M| } 97| 116M| return fr; 98| 116M|} execute.c:path_intact: 225| 10.7M|static int path_intact(jq_state *jq, jv curr) { 226| 10.7M| if (jq->subexp_nest == 0 && jv_get_kind(jq->path) == JV_KIND_ARRAY) { ------------------ | Branch (226:7): [True: 3.00M, False: 7.79M] | Branch (226:31): [True: 2.80M, False: 199k] ------------------ 227| 2.80M| return jv_identical(curr, jv_copy(jq->value_at_path)); 228| 7.99M| } else { 229| 7.99M| jv_free(curr); 230| 7.99M| return 1; 231| 7.99M| } 232| 10.7M|} execute.c:path_append: 234| 11.6M|static void path_append(jq_state* jq, jv component, jv value_at_path) { 235| 11.6M| if (jq->subexp_nest == 0 && jv_get_kind(jq->path) == JV_KIND_ARRAY) { ------------------ | Branch (235:7): [True: 3.01M, False: 8.66M] | Branch (235:31): [True: 1.82M, False: 1.19M] ------------------ 236| 1.82M| int n1 = jv_array_length(jv_copy(jq->path)); 237| 1.82M| jq->path = jv_array_append(jq->path, component); 238| 1.82M| int n2 = jv_array_length(jv_copy(jq->path)); 239| 1.82M| assert(n2 == n1 + 1); ------------------ | Branch (239:5): [True: 0, False: 1.82M] | Branch (239:5): [True: 1.82M, False: 0] ------------------ 240| 1.82M| jv_free(jq->value_at_path); 241| 1.82M| jq->value_at_path = value_at_path; 242| 9.85M| } else { 243| 9.85M| jv_free(component); 244| 9.85M| jv_free(value_at_path); 245| 9.85M| } 246| 11.6M|} execute.c:make_closure: 107| 10.2M|static struct closure make_closure(struct jq_state* jq, uint16_t* pc) { 108| 10.2M| uint16_t level = *pc++; 109| 10.2M| uint16_t idx = *pc++; 110| 10.2M| stack_ptr fridx = frame_get_level(jq, level); 111| 10.2M| struct frame* fr = stack_block(&jq->stk, fridx); 112| 10.2M| if (idx & ARG_NEWCLOSURE) { ------------------ | | 70| 10.2M|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (112:7): [True: 4.57M, False: 5.63M] ------------------ 113| | // A new closure closing the frame identified by level, and with 114| | // the bytecode body of the idx'th subfunction of that frame 115| 4.57M| int subfn_idx = idx & ~ARG_NEWCLOSURE; ------------------ | | 70| 4.57M|#define ARG_NEWCLOSURE 0x1000 ------------------ 116| 4.57M| assert(subfn_idx < fr->bc->nsubfunctions); ------------------ | Branch (116:5): [True: 0, False: 4.57M] | Branch (116:5): [True: 4.57M, False: 0] ------------------ 117| 4.57M| struct closure cl = {fr->bc->subfunctions[subfn_idx], 118| 4.57M| fridx}; 119| 4.57M| return cl; 120| 5.63M| } else { 121| | // A reference to a closure from the frame identified by level; copy 122| | // it as-is 123| 5.63M| int closure = idx; 124| 5.63M| assert(closure >= 0); ------------------ | Branch (124:5): [True: 0, False: 5.63M] | Branch (124:5): [True: 5.63M, False: 0] ------------------ 125| 5.63M| assert(closure < fr->bc->nclosures); ------------------ | Branch (125:5): [True: 0, False: 5.63M] | Branch (125:5): [True: 5.63M, False: 0] ------------------ 126| 5.63M| return fr->entries[closure].closure; 127| 5.63M| } 128| 10.2M|} execute.c:frame_push: 131| 8.67M| uint16_t* argdef, int nargs) { 132| 8.67M| stack_ptr new_frame_idx = stack_push_block(&jq->stk, jq->curr_frame, frame_size(callee.bc)); 133| 8.67M| struct frame* new_frame = stack_block(&jq->stk, new_frame_idx); 134| 8.67M| new_frame->bc = callee.bc; 135| 8.67M| new_frame->env = callee.env; 136| 8.67M| assert(nargs == new_frame->bc->nclosures); ------------------ | Branch (136:3): [True: 0, False: 8.67M] | Branch (136:3): [True: 8.67M, False: 0] ------------------ 137| 8.67M| union frame_entry* entries = new_frame->entries; 138| 10.2M| for (int i=0; iclosure = make_closure(jq, argdef + i * 2); 140| 1.53M| entries++; 141| 1.53M| } 142| 26.2M| for (int i=0; inlocals; i++) { ------------------ | Branch (142:17): [True: 17.5M, False: 8.67M] ------------------ 143| 17.5M| entries->localvar = jv_invalid(); 144| 17.5M| entries++; 145| 17.5M| } 146| 8.67M| jq->curr_frame = new_frame_idx; 147| 8.67M| return new_frame; 148| 8.67M|} execute.c:default_err_cb: 1048| 10|static void default_err_cb(void *data, jv msg) { 1049| 10| msg = jq_format_error(msg); 1050| 10| fprintf((FILE *)data, "%s\n", jv_string_value(msg)); 1051| 10| jv_free(msg); 1052| 10|} execute.c:jq_reset: 303| 21.8k|static void jq_reset(jq_state *jq) { 304| 46.1k| while (stack_restore(jq)) {} ------------------ | Branch (304:10): [True: 24.2k, False: 21.8k] ------------------ 305| | 306| 21.8k| assert(jq->stk_top == 0); ------------------ | Branch (306:3): [True: 0, False: 21.8k] | Branch (306:3): [True: 21.8k, False: 0] ------------------ 307| 21.8k| assert(jq->fork_top == 0); ------------------ | Branch (307:3): [True: 0, False: 21.8k] | Branch (307:3): [True: 21.8k, False: 0] ------------------ 308| 21.8k| assert(jq->curr_frame == 0); ------------------ | Branch (308:3): [True: 0, False: 21.8k] | Branch (308:3): [True: 21.8k, False: 0] ------------------ 309| 21.8k| stack_reset(&jq->stk); 310| 21.8k| jv_free(jq->error); 311| 21.8k| jq->error = jv_null(); 312| | 313| 21.8k| jq->halted = 0; 314| 21.8k| jv_free(jq->exit_code); 315| 21.8k| jq->exit_code = jv_invalid(); 316| 21.8k| jv_free(jq->error_message); 317| 21.8k| jq->error_message = jv_invalid(); 318| 21.8k| if (jv_get_kind(jq->path) != JV_KIND_INVALID) ------------------ | Branch (318:7): [True: 21.8k, False: 0] ------------------ 319| 21.8k| jv_free(jq->path); 320| 21.8k| jq->path = jv_null(); 321| 21.8k| jv_free(jq->value_at_path); 322| 21.8k| jq->value_at_path = jv_null(); 323| 21.8k| jq->subexp_nest = 0; 324| 21.8k|} execute.c:args2obj: 1217| 7.64k|{ 1218| 7.64k| if (jv_get_kind(args) == JV_KIND_OBJECT) ------------------ | Branch (1218:7): [True: 7.64k, False: 0] ------------------ 1219| 7.64k| return args; 1220| 7.64k| assert(jv_get_kind(args) == JV_KIND_ARRAY); ------------------ | Branch (1220:3): [True: 0, False: 0] | Branch (1220:3): [True: 0, False: 0] ------------------ 1221| 0| jv r = jv_object(); 1222| 0| jv kk = jv_string("name"); 1223| 0| jv vk = jv_string("value"); 1224| 0| jv_array_foreach(args, i, v) ------------------ | | 93| 0| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 0| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 0, False: 0] | | ------------------ | | 95| 0| for (jv x; \ | | 96| 0| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 0, False: 0] | | | Branch (96:10): [True: 0, False: 0] | | ------------------ | | 97| 0| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 0| i++) ------------------ 1225| 0| r = jv_object_set(r, jv_object_get(jv_copy(v), jv_copy(kk)), jv_object_get(v, jv_copy(vk))); 1226| 0| jv_free(args); 1227| 0| jv_free(kk); 1228| 0| jv_free(vk); 1229| 0| return r; 1230| 0|} execute.c:optimize: 1208| 49.8k|static struct bytecode *optimize(struct bytecode *bc) { 1209| 91.9k| for (int i=0; insubfunctions; i++) { ------------------ | Branch (1209:17): [True: 42.1k, False: 49.8k] ------------------ 1210| 42.1k| bc->subfunctions[i] = optimize(bc->subfunctions[i]); 1211| 42.1k| } 1212| 49.8k| return optimize_code(bc); 1213| 49.8k|} execute.c:optimize_code: 1190| 49.8k|static struct bytecode *optimize_code(struct bytecode *bc) { 1191| 49.8k| uint16_t *pc = bc->code; 1192| | // FIXME: Don't mutate bc->code... 1193| 706k| while (pc < bc->code + bc->codelen) { ------------------ | Branch (1193:10): [True: 657k, False: 49.8k] ------------------ 1194| 657k| switch (*pc) { 1195| 42.0k| case CALL_JQ: ------------------ | Branch (1195:5): [True: 42.0k, False: 615k] ------------------ 1196| 42.0k| *pc = tail_call_analyze(pc); 1197| 42.0k| break; 1198| | 1199| | // Other bytecode optimizations here. A peephole optimizer would 1200| | // fit right in. 1201| 615k| default: break; ------------------ | Branch (1201:5): [True: 615k, False: 42.0k] ------------------ 1202| 657k| } 1203| 657k| pc += bytecode_operation_length(pc); 1204| 657k| } 1205| 49.8k| return bc; 1206| 49.8k|} execute.c:tail_call_analyze: 1177| 42.0k|static uint16_t tail_call_analyze(uint16_t *pc) { 1178| 42.0k| assert(*pc == CALL_JQ); ------------------ | Branch (1178:3): [True: 0, False: 42.0k] | Branch (1178:3): [True: 42.0k, False: 0] ------------------ 1179| 42.0k| pc++; 1180| | // + 1 for the callee closure 1181| 61.9k| for (uint16_t nclosures = *pc++ + 1; nclosures > 0; pc++, nclosures--) { ------------------ | Branch (1181:40): [True: 54.3k, False: 7.58k] ------------------ 1182| 54.3k| if (*pc++ == 0) ------------------ | Branch (1182:9): [True: 34.4k, False: 19.9k] ------------------ 1183| 34.4k| return CALL_JQ; 1184| 54.3k| } 1185| 7.58k| if (ret_follows(pc)) ------------------ | Branch (1185:7): [True: 6.10k, False: 1.47k] ------------------ 1186| 6.10k| return TAIL_CALL_JQ; 1187| 1.47k| return CALL_JQ; 1188| 7.58k|} execute.c:ret_follows: 1145| 7.75k|static int ret_follows(uint16_t *pc) { 1146| 7.75k| if (*pc == RET) ------------------ | Branch (1146:7): [True: 6.10k, False: 1.64k] ------------------ 1147| 6.10k| return 1; 1148| 1.64k| if (*pc++ != JUMP) ------------------ | Branch (1148:7): [True: 1.47k, False: 171] ------------------ 1149| 1.47k| return 0; 1150| 171| return ret_follows(pc + *pc + 1); // FIXME, might be ironic 1151| 1.64k|} jv_get_kind: 102| 1.22G|jv_kind jv_get_kind(jv x) { 103| 1.22G| return JVP_KIND(x); ------------------ | | 90| 1.22G|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 89| 1.22G|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 77| 1.22G|#define KIND_MASK 0xF | | ------------------ ------------------ 104| 1.22G|} jv_kind_name: 106| 70.2k|const char* jv_kind_name(jv_kind k) { 107| 70.2k| switch (k) { ------------------ | Branch (107:11): [True: 70.2k, False: 0] ------------------ 108| 0| case JV_KIND_INVALID: return ""; ------------------ | Branch (108:3): [True: 0, False: 70.2k] ------------------ 109| 59| case JV_KIND_NULL: return "null"; ------------------ | Branch (109:3): [True: 59, False: 70.2k] ------------------ 110| 36| case JV_KIND_FALSE: return "boolean"; ------------------ | Branch (110:3): [True: 36, False: 70.2k] ------------------ 111| 223| case JV_KIND_TRUE: return "boolean"; ------------------ | Branch (111:3): [True: 223, False: 70.0k] ------------------ 112| 10.5k| case JV_KIND_NUMBER: return "number"; ------------------ | Branch (112:3): [True: 10.5k, False: 59.7k] ------------------ 113| 17.1k| case JV_KIND_STRING: return "string"; ------------------ | Branch (113:3): [True: 17.1k, False: 53.1k] ------------------ 114| 25.1k| case JV_KIND_ARRAY: return "array"; ------------------ | Branch (114:3): [True: 25.1k, False: 45.1k] ------------------ 115| 17.1k| case JV_KIND_OBJECT: return "object"; ------------------ | Branch (115:3): [True: 17.1k, False: 53.1k] ------------------ 116| 70.2k| } 117| 70.2k| assert(0 && "invalid kind"); ------------------ | Branch (117:3): [Folded, False: 0] | Branch (117:3): [True: 0, False: 0] | Branch (117:3): [Folded, False: 0] | Branch (117:3): [True: 0, False: 0] ------------------ 118| 0| return ""; 119| 0|} jv_true: 126| 834k|jv jv_true(void) { 127| 834k| return JV_TRUE; 128| 834k|} jv_false: 130| 431k|jv jv_false(void) { 131| 431k| return JV_FALSE; 132| 431k|} jv_null: 134| 17.4M|jv jv_null(void) { 135| 17.4M| return JV_NULL; 136| 17.4M|} jv_bool: 138| 4.17M|jv jv_bool(int x) { 139| 4.17M| return x ? JV_TRUE : JV_FALSE; ------------------ | Branch (139:10): [True: 1.88M, False: 2.29M] ------------------ 140| 4.17M|} jv_invalid_with_msg: 153| 839k|jv jv_invalid_with_msg(jv err) { 154| 839k| jvp_invalid* i = jv_mem_alloc(sizeof(jvp_invalid)); 155| 839k| i->refcnt = JV_REFCNT_INIT; 156| 839k| i->errmsg = err; 157| | 158| 839k| jv x = {JVP_FLAGS_INVALID_MSG, 0, 0, 0, {&i->refcnt}}; ------------------ | | 146| 839k|#define JVP_FLAGS_INVALID_MSG JVP_MAKE_FLAGS(JV_KIND_INVALID, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 839k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 839k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 839k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 159| 839k| return x; 160| 839k|} jv_invalid: 162| 36.5M|jv jv_invalid(void) { 163| 36.5M| return JV_INVALID; 164| 36.5M|} jv_invalid_get_msg: 166| 1.65M|jv jv_invalid_get_msg(jv inv) { 167| 1.65M| assert(JVP_HAS_KIND(inv, JV_KIND_INVALID)); ------------------ | Branch (167:3): [True: 0, False: 1.65M] | Branch (167:3): [True: 1.65M, False: 0] ------------------ 168| | 169| 1.65M| jv x; 170| 1.65M| if (JVP_HAS_FLAGS(inv, JVP_FLAGS_INVALID_MSG)) { ------------------ | | 92| 1.65M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 1.65M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 1.65M, False: 0] | | ------------------ ------------------ 171| 1.65M| x = jv_copy(((jvp_invalid*)inv.u.ptr)->errmsg); 172| 1.65M| } 173| 0| else { 174| 0| x = jv_null(); 175| 0| } 176| | 177| 1.65M| jv_free(inv); 178| 1.65M| return x; 179| 1.65M|} jv_invalid_has_msg: 181| 1.40M|int jv_invalid_has_msg(jv inv) { 182| 1.40M| assert(JVP_HAS_KIND(inv, JV_KIND_INVALID)); ------------------ | Branch (182:3): [True: 0, False: 1.40M] | Branch (182:3): [True: 1.40M, False: 0] ------------------ 183| 1.40M| int r = JVP_HAS_FLAGS(inv, JVP_FLAGS_INVALID_MSG); ------------------ | | 92| 1.40M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 1.40M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ ------------------ 184| 1.40M| jv_free(inv); 185| 1.40M| return r; 186| 1.40M|} jv_tsd_dec_ctx_fini: 491| 1|void jv_tsd_dec_ctx_fini(void) { 492| 1| jv_mem_free(pthread_getspecific(dec_ctx_key)); 493| | pthread_setspecific(dec_ctx_key, NULL); 494| 1|} jv_tsd_dec_ctx_init: 496| 1|void jv_tsd_dec_ctx_init(void) { 497| 1| if (pthread_key_create(&dec_ctx_key, jv_mem_free) != 0) { ------------------ | Branch (497:7): [True: 0, False: 1] ------------------ 498| 0| fprintf(stderr, "error: cannot create thread specific key"); 499| 0| abort(); 500| 0| } 501| 1| atexit(jv_tsd_dec_ctx_fini); 502| 1|} jv_number_get_literal: 658| 1.45M|const char* jv_number_get_literal(jv n) { 659| 1.45M| assert(JVP_HAS_KIND(n, JV_KIND_NUMBER)); ------------------ | Branch (659:3): [True: 0, False: 1.45M] | Branch (659:3): [True: 1.45M, False: 0] ------------------ 660| | 661| 1.45M| if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 2.90M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 1.45M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 1.45M, False: 1.68k] | | | Branch (92:50): [True: 1.45M, Folded] | | ------------------ ------------------ 662| 1.45M| return jvp_literal_number_literal(n); 663| 1.45M| } else { 664| | return NULL; 665| 1.68k| } 666| 1.45M|} jv_number_with_literal: 668| 7.84M|jv jv_number_with_literal(const char * literal) { 669| 7.84M| return jvp_literal_number_new(literal); 670| 7.84M|} jv_number: 673| 39.8M|jv jv_number(double x) { 674| 39.8M| jv j = { 675| 39.8M|#ifdef USE_DECNUM 676| 39.8M| JVP_FLAGS_NUMBER_NATIVE, ------------------ | | 205| 39.8M|#define JVP_FLAGS_NUMBER_NATIVE JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_NATIVE, 0)) | | ------------------ | | | | 87| 79.6M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 39.8M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 39.8M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | | | | Branch (87:61): [Folded, False: 39.8M] | | | | ------------------ | | ------------------ ------------------ 677| |#else 678| | JV_KIND_NUMBER, 679| |#endif 680| 39.8M| 0, 0, 0, {.number = x} 681| 39.8M| }; 682| 39.8M| return j; 683| 39.8M|} jv_number_value: 698| 105M|double jv_number_value(jv j) { 699| 105M| assert(JVP_HAS_KIND(j, JV_KIND_NUMBER)); ------------------ | Branch (699:3): [True: 0, False: 105M] | Branch (699:3): [True: 105M, False: 0] ------------------ 700| 105M|#ifdef USE_DECNUM 701| 105M| if (JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 211M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 105M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 36.3M, False: 69.4M] | | | Branch (92:50): [True: 105M, Folded] | | ------------------ ------------------ 702| 36.3M| jvp_literal_number* n = jvp_literal_number_ptr(j); 703| | 704| 36.3M| if (isnan(n->num_double)) { ------------------ | Branch (704:9): [True: 137k, False: 36.2M] ------------------ 705| 137k| n->num_double = jvp_literal_number_to_double(j); 706| 137k| } 707| | 708| 36.3M| return n->num_double; 709| 36.3M| } 710| 69.4M|#endif 711| 69.4M| return j.u.number; 712| 105M|} jvp_number_is_nan: 727| 24.5M|int jvp_number_is_nan(jv n) { 728| 24.5M| assert(JVP_HAS_KIND(n, JV_KIND_NUMBER)); ------------------ | Branch (728:3): [True: 0, False: 24.5M] | Branch (728:3): [True: 24.5M, False: 0] ------------------ 729| | 730| 24.5M|#ifdef USE_DECNUM 731| 24.5M| if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 49.1M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 24.5M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 14.6M, False: 9.94M] | | | Branch (92:50): [True: 24.5M, Folded] | | ------------------ ------------------ 732| 14.6M| decNumber *pdec = jvp_dec_number_ptr(n); 733| 14.6M| return decNumberIsNaN(pdec); ------------------ | | 172| 14.6M| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 14.6M| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 14.6M| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ 734| 14.6M| } 735| 9.94M|#endif 736| 9.94M| return isnan(n.u.number); 737| 24.5M|} jv_number_abs: 739| 567k|jv jv_number_abs(jv n) { 740| 567k| assert(JVP_HAS_KIND(n, JV_KIND_NUMBER)); ------------------ | Branch (740:3): [True: 0, False: 567k] | Branch (740:3): [True: 567k, False: 0] ------------------ 741| | 742| 567k|#ifdef USE_DECNUM 743| 567k| if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 1.13M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 567k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 567k, False: 481] | | | Branch (92:50): [True: 567k, Folded] | | ------------------ ------------------ 744| 567k| jvp_literal_number* m = jvp_literal_number_alloc(jvp_dec_number_ptr(n)->digits); 745| | 746| 567k| decNumberAbs(&m->num_decimal, jvp_dec_number_ptr(n), DEC_CONTEXT()); ------------------ | | 487| 567k|#define DEC_CONTEXT() tsd_dec_ctx_get(&dec_ctx_key) ------------------ 747| 567k| jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, 0, {&m->refcnt}}; ------------------ | | 206| 567k|#define JVP_FLAGS_NUMBER_LITERAL JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_DECIMAL, 1)) | | ------------------ | | | | 87| 1.13M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 567k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 567k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | | | | Branch (87:61): [True: 567k, Folded] | | | | ------------------ | | ------------------ ------------------ 748| 567k| return r; 749| 567k| } 750| 481|#endif 751| 481| return jv_number(fabs(jv_number_value(n))); 752| 567k|} jv_number_negate: 754| 1.25k|jv jv_number_negate(jv n) { 755| 1.25k| assert(JVP_HAS_KIND(n, JV_KIND_NUMBER)); ------------------ | Branch (755:3): [True: 0, False: 1.25k] | Branch (755:3): [True: 1.25k, False: 0] ------------------ 756| | 757| 1.25k|#ifdef USE_DECNUM 758| 1.25k| if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 2.50k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 1.25k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 1.04k, False: 212] | | | Branch (92:50): [True: 1.25k, Folded] | | ------------------ ------------------ 759| 1.04k| jvp_literal_number* m = jvp_literal_number_alloc(jvp_dec_number_ptr(n)->digits); 760| | 761| 1.04k| decNumberMinus(&m->num_decimal, jvp_dec_number_ptr(n), DEC_CONTEXT()); ------------------ | | 487| 1.04k|#define DEC_CONTEXT() tsd_dec_ctx_get(&dec_ctx_key) ------------------ 762| 1.04k| jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, 0, {&m->refcnt}}; ------------------ | | 206| 1.04k|#define JVP_FLAGS_NUMBER_LITERAL JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_DECIMAL, 1)) | | ------------------ | | | | 87| 2.08k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 1.04k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 1.04k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | | | | Branch (87:61): [True: 1.04k, Folded] | | | | ------------------ | | ------------------ ------------------ 763| 1.04k| return r; 764| 1.04k| } 765| 212|#endif 766| 212| return jv_number(-jv_number_value(n)); 767| 1.25k|} jvp_number_cmp: 769| 5.43M|int jvp_number_cmp(jv a, jv b) { 770| 5.43M| assert(JVP_HAS_KIND(a, JV_KIND_NUMBER)); ------------------ | Branch (770:3): [True: 0, False: 5.43M] | Branch (770:3): [True: 5.43M, False: 0] ------------------ 771| 5.43M| assert(JVP_HAS_KIND(b, JV_KIND_NUMBER)); ------------------ | Branch (771:3): [True: 0, False: 5.43M] | Branch (771:3): [True: 5.43M, False: 0] ------------------ 772| | 773| 5.43M|#ifdef USE_DECNUM 774| 5.43M| if (JVP_HAS_FLAGS(a, JVP_FLAGS_NUMBER_LITERAL) && JVP_HAS_FLAGS(b, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 10.8M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 5.43M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 2.67M, False: 2.75M] | | | Branch (92:50): [True: 5.43M, Folded] | | ------------------ ------------------ if (JVP_HAS_FLAGS(a, JVP_FLAGS_NUMBER_LITERAL) && JVP_HAS_FLAGS(b, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 5.35M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 2.67M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 1.79M, False: 887k] | | | Branch (92:50): [True: 2.67M, Folded] | | ------------------ ------------------ 775| 1.79M| struct { 776| 1.79M| decNumber number; 777| 1.79M| decNumberUnit units[1]; 778| 1.79M| } res; 779| | 780| 1.79M| decNumberCompare(&res.number, 781| 1.79M| jvp_dec_number_ptr(a), 782| 1.79M| jvp_dec_number_ptr(b), 783| 1.79M| DEC_CONTEXT() ------------------ | | 487| 1.79M|#define DEC_CONTEXT() tsd_dec_ctx_get(&dec_ctx_key) ------------------ 784| 1.79M| ); 785| 1.79M| if (decNumberIsZero(&res.number)) { ------------------ | | 177| 1.79M| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | ------------------ | | | Branch (177:37): [True: 816k, False: 973k] | | ------------------ | | 178| 1.79M| && (dn)->digits==1 \ | | ------------------ | | | Branch (178:40): [True: 816k, False: 0] | | ------------------ | | 179| 1.79M| && (((dn)->bits&DECSPECIAL)==0)) | | ------------------ | | | | 36| 816k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 32| 816k| #define DECINF 0x40 /* 1=Infinity */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 33| 816k| #define DECNAN 0x20 /* 1=NaN */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 34| 816k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | ------------------ | | ------------------ | | | Branch (179:40): [True: 816k, False: 0] | | ------------------ ------------------ 786| 816k| return 0; 787| 973k| } else if (decNumberIsNegative(&res.number)) { ------------------ | | 173| 973k| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 973k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 611k, False: 362k] | | ------------------ ------------------ 788| 611k| return -1; 789| 611k| } else { 790| 362k| return 1; 791| 362k| } 792| 1.79M| } 793| 3.64M|#endif 794| 3.64M| double da = jv_number_value(a), db = jv_number_value(b); 795| 3.64M| if (da < db) { ------------------ | Branch (795:7): [True: 980k, False: 2.66M] ------------------ 796| 980k| return -1; 797| 2.66M| } else if (da == db) { ------------------ | Branch (797:14): [True: 405k, False: 2.25M] ------------------ 798| 405k| return 0; 799| 2.25M| } else { 800| 2.25M| return 1; 801| 2.25M| } 802| 3.64M|} jv_array_sized: 982| 7.36M|jv jv_array_sized(int n) { 983| 7.36M| return jvp_array_new(n); 984| 7.36M|} jv_array: 986| 7.21M|jv jv_array(void) { 987| 7.21M| return jv_array_sized(16); 988| 7.21M|} jv_array_length: 990| 117M|int jv_array_length(jv j) { 991| 117M| assert(JVP_HAS_KIND(j, JV_KIND_ARRAY)); ------------------ | Branch (991:3): [True: 0, False: 117M] | Branch (991:3): [True: 117M, False: 0] ------------------ 992| 117M| int len = jvp_array_length(j); 993| 117M| jv_free(j); 994| 117M| return len; 995| 117M|} jv_array_get: 997| 81.0M|jv jv_array_get(jv j, int idx) { 998| 81.0M| assert(JVP_HAS_KIND(j, JV_KIND_ARRAY)); ------------------ | Branch (998:3): [True: 0, False: 81.0M] | Branch (998:3): [True: 81.0M, False: 0] ------------------ 999| 81.0M| jv* slot = jvp_array_read(j, idx); 1000| 81.0M| jv val; 1001| 81.0M| if (slot) { ------------------ | Branch (1001:7): [True: 80.6M, False: 473k] ------------------ 1002| 80.6M| val = jv_copy(*slot); 1003| 80.6M| } else { 1004| 473k| val = jv_invalid(); 1005| 473k| } 1006| 81.0M| jv_free(j); 1007| 81.0M| return val; 1008| 81.0M|} jv_array_set: 1010| 81.5M|jv jv_array_set(jv j, int idx, jv val) { 1011| 81.5M| assert(JVP_HAS_KIND(j, JV_KIND_ARRAY)); ------------------ | Branch (1011:3): [True: 0, False: 81.5M] | Branch (1011:3): [True: 81.5M, False: 0] ------------------ 1012| | 1013| 81.5M| if (idx < 0) ------------------ | Branch (1013:7): [True: 0, False: 81.5M] ------------------ 1014| 0| idx = jvp_array_length(j) + idx; 1015| 81.5M| if (idx < 0) { ------------------ | Branch (1015:7): [True: 0, False: 81.5M] ------------------ 1016| 0| jv_free(j); 1017| 0| jv_free(val); 1018| 0| return jv_invalid_with_msg(jv_string("Out of bounds negative array index")); 1019| 0| } 1020| 81.5M| if (idx > (INT_MAX >> 2) - jvp_array_offset(j)) { ------------------ | Branch (1020:7): [True: 0, False: 81.5M] ------------------ 1021| 0| jv_free(j); 1022| 0| jv_free(val); 1023| 0| return jv_invalid_with_msg(jv_string("Array index too large")); 1024| 0| } 1025| | // copy/free of val,j coalesced 1026| 81.5M| jv* slot = jvp_array_write(&j, idx); 1027| 81.5M| jv_free(*slot); 1028| 81.5M| *slot = val; 1029| 81.5M| return j; 1030| 81.5M|} jv_array_append: 1032| 76.4M|jv jv_array_append(jv j, jv val) { 1033| | // copy/free of val,j coalesced 1034| 76.4M| return jv_array_set(j, jv_array_length(jv_copy(j)), val); 1035| 76.4M|} jv_array_concat: 1037| 1.61M|jv jv_array_concat(jv a, jv b) { 1038| 1.61M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (1038:3): [True: 0, False: 1.61M] | Branch (1038:3): [True: 1.61M, False: 0] ------------------ 1039| 1.61M| assert(JVP_HAS_KIND(b, JV_KIND_ARRAY)); ------------------ | Branch (1039:3): [True: 0, False: 1.61M] | Branch (1039:3): [True: 1.61M, False: 0] ------------------ 1040| | 1041| | // FIXME: could be faster 1042| 33.9M| jv_array_foreach(b, i, elem) { ------------------ | | 93| 1.61M| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 3.23M| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 1.61M, False: 1.61M] | | ------------------ | | 95| 1.61M| for (jv x; \ | | 96| 35.6M| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 33.9M, False: 1.61M] | | | Branch (96:10): [True: 33.9M, False: 1.61M] | | ------------------ | | 97| 35.6M| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 33.9M| i++) ------------------ 1043| 33.9M| a = jv_array_append(a, elem); 1044| 33.9M| if (!jv_is_valid(a)) break; ------------------ | Branch (1044:9): [True: 0, False: 33.9M] ------------------ 1045| 33.9M| } 1046| 1.61M| jv_free(b); 1047| 1.61M| return a; 1048| 1.61M|} jv_array_slice: 1050| 8.09M|jv jv_array_slice(jv a, int start, int end) { 1051| 8.09M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (1051:3): [True: 0, False: 8.09M] | Branch (1051:3): [True: 8.09M, False: 0] ------------------ 1052| | // copy/free of a coalesced 1053| 8.09M| return jvp_array_slice(a, start, end); 1054| 8.09M|} jv_array_indexes: 1056| 59|jv jv_array_indexes(jv a, jv b) { 1057| 59| jv res = jv_array(); 1058| 59| int idx = -1; 1059| 59| int alen = jv_array_length(jv_copy(a)); 1060| 53.2k| for (int ai = 0; ai < alen; ++ai) { ------------------ | Branch (1060:20): [True: 53.2k, False: 59] ------------------ 1061| 54.7k| jv_array_foreach(b, bi, belem) { ------------------ | | 93| 53.2k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 106k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 53.2k, False: 53.2k] | | ------------------ | | 95| 53.2k| for (jv x; \ | | 96| 107k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 54.7k, False: 53.2k] | | | Branch (96:10): [True: 54.7k, False: 53.2k] | | ------------------ | | 97| 107k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 54.7k| i++) ------------------ 1062| 54.7k| int equal = jv_equal(jv_array_get(jv_copy(a), ai + bi), belem); 1063| 54.7k| if (equal < 0) { ------------------ | Branch (1063:11): [True: 0, False: 54.7k] ------------------ 1064| 0| jv_free(res); 1065| 0| jv_free(a); 1066| 0| jv_free(b); 1067| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 1068| 0| } 1069| 54.7k| if (!equal) ------------------ | Branch (1069:11): [True: 53.0k, False: 1.69k] ------------------ 1070| 53.0k| idx = -1; 1071| 1.69k| else if (bi == 0 && idx == -1) ------------------ | Branch (1071:16): [True: 1.24k, False: 442] | Branch (1071:27): [True: 1.24k, False: 0] ------------------ 1072| 1.24k| idx = ai; 1073| 54.7k| } 1074| 53.2k| if (idx > -1) ------------------ | Branch (1074:9): [True: 1.05k, False: 52.1k] ------------------ 1075| 1.05k| res = jv_array_append(res, jv_number(idx)); 1076| 53.2k| idx = -1; 1077| 53.2k| } 1078| 59| jv_free(a); 1079| 59| jv_free(b); 1080| 59| return res; 1081| 59|} jv_string_sized: 1312| 12.9M|jv jv_string_sized(const char* str, int len) { 1313| 12.9M| return 1314| 12.9M| jvp_utf8_is_valid(str, str+len) ? ------------------ | Branch (1314:5): [True: 12.8M, False: 89.7k] ------------------ 1315| 12.8M| jvp_string_new(str, len) : 1316| 12.9M| jvp_string_copy_replace_bad(str, len); 1317| 12.9M|} jv_string_empty: 1319| 50.5k|jv jv_string_empty(int len) { 1320| 50.5k| return jvp_string_empty_new(len); 1321| 50.5k|} jv_string: 1323| 10.3M|jv jv_string(const char* str) { 1324| 10.3M| return jv_string_sized(str, strlen(str)); 1325| 10.3M|} jv_string_length_bytes: 1327| 2.79M|int jv_string_length_bytes(jv j) { 1328| 2.79M| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1328:3): [True: 0, False: 2.79M] | Branch (1328:3): [True: 2.79M, False: 0] ------------------ 1329| 2.79M| int r = jvp_string_length(jvp_string_ptr(j)); 1330| 2.79M| jv_free(j); 1331| 2.79M| return r; 1332| 2.79M|} jv_string_length_codepoints: 1334| 101k|int jv_string_length_codepoints(jv j) { 1335| 101k| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1335:3): [True: 0, False: 101k] | Branch (1335:3): [True: 101k, False: 0] ------------------ 1336| 101k| const char* i = jv_string_value(j); 1337| 101k| const char* end = i + jv_string_length_bytes(jv_copy(j)); 1338| 101k| int c = 0, len = 0; 1339| 1.12G| while ((i = jvp_utf8_next(i, end, &c))) len++; ------------------ | Branch (1339:10): [True: 1.12G, False: 101k] ------------------ 1340| 101k| jv_free(j); 1341| 101k| return len; 1342| 101k|} jv_string_indexes: 1345| 19|jv jv_string_indexes(jv j, jv k) { 1346| 19| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1346:3): [True: 0, False: 19] | Branch (1346:3): [True: 19, False: 0] ------------------ 1347| 19| assert(JVP_HAS_KIND(k, JV_KIND_STRING)); ------------------ | Branch (1347:3): [True: 0, False: 19] | Branch (1347:3): [True: 19, False: 0] ------------------ 1348| 19| const char *jstr = jv_string_value(j); 1349| 19| const char *idxstr = jv_string_value(k); 1350| 19| const char *p, *lp; 1351| 19| int jlen = jv_string_length_bytes(jv_copy(j)); 1352| 19| int idxlen = jv_string_length_bytes(jv_copy(k)); 1353| 19| jv a = jv_array(); 1354| | 1355| 19| if (idxlen != 0) { ------------------ | Branch (1355:7): [True: 19, False: 0] ------------------ 1356| 19| int n = 0; 1357| 19| p = lp = jstr; 1358| 284| while ((p = _jq_memmem(p, (jstr + jlen) - p, idxstr, idxlen)) != NULL) { ------------------ | Branch (1358:12): [True: 265, False: 19] ------------------ 1359| 1.11k| while (lp < p) { ------------------ | Branch (1359:14): [True: 852, False: 265] ------------------ 1360| 852| lp += jvp_utf8_decode_length(*lp); 1361| 852| n++; 1362| 852| } 1363| | 1364| 265| a = jv_array_append(a, jv_number(n)); 1365| 265| if (!jv_is_valid(a)) break; ------------------ | Branch (1365:11): [True: 0, False: 265] ------------------ 1366| 265| p++; 1367| 265| } 1368| 19| } 1369| 19| jv_free(j); 1370| 19| jv_free(k); 1371| 19| return a; 1372| 19|} jv_string_repeat: 1374| 621|jv jv_string_repeat(jv j, int n) { 1375| 621| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1375:3): [True: 0, False: 621] | Branch (1375:3): [True: 621, False: 0] ------------------ 1376| 621| if (n < 0) { ------------------ | Branch (1376:7): [True: 0, False: 621] ------------------ 1377| 0| jv_free(j); 1378| 0| return jv_null(); 1379| 0| } 1380| 621| int len = jv_string_length_bytes(jv_copy(j)); 1381| 621| int64_t res_len = (int64_t)len * n; 1382| 621| if ((uint64_t)res_len >= INT_MAX - sizeof(jvp_string) / 2) { ------------------ | Branch (1382:7): [True: 2, False: 619] ------------------ 1383| 2| jv_free(j); 1384| 2| return jv_invalid_with_msg(jv_string("Repeat string result too long")); 1385| 2| } 1386| 619| if (res_len == 0) { ------------------ | Branch (1386:7): [True: 286, False: 333] ------------------ 1387| 286| jv_free(j); 1388| 286| return jv_string(""); 1389| 286| } 1390| 333| jv res = jv_string_empty(res_len); 1391| 333| res = jvp_string_append(res, jv_string_value(j), len); 1392| 666| for (int curr = len, grow; curr < res_len; curr += grow) { ------------------ | Branch (1392:30): [True: 333, False: 333] ------------------ 1393| 333| grow = MIN(res_len - curr, curr); ------------------ | | 49| 333| ({ __typeof__ (a) _a = (a); \ | | 50| 333| __typeof__ (b) _b = (b); \ | | 51| 333| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (51:4): [True: 0, False: 333] | | ------------------ ------------------ 1394| 333| res = jvp_string_append(res, jv_string_value(res), grow); 1395| 333| } 1396| 333| jv_free(j); 1397| 333| return res; 1398| 619|} jv_string_split: 1400| 7.66k|jv jv_string_split(jv j, jv sep) { 1401| 7.66k| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1401:3): [True: 0, False: 7.66k] | Branch (1401:3): [True: 7.66k, False: 0] ------------------ 1402| 7.66k| assert(JVP_HAS_KIND(sep, JV_KIND_STRING)); ------------------ | Branch (1402:3): [True: 0, False: 7.66k] | Branch (1402:3): [True: 7.66k, False: 0] ------------------ 1403| 7.66k| const char *jstr = jv_string_value(j); 1404| 7.66k| const char *jend = jstr + jv_string_length_bytes(jv_copy(j)); 1405| 7.66k| const char *sepstr = jv_string_value(sep); 1406| 7.66k| const char *p, *s; 1407| 7.66k| int seplen = jv_string_length_bytes(jv_copy(sep)); 1408| 7.66k| jv a = jv_array(); 1409| | 1410| 7.66k| assert(jv_get_refcnt(a) == 1); ------------------ | Branch (1410:3): [True: 0, False: 7.66k] | Branch (1410:3): [True: 7.66k, False: 0] ------------------ 1411| | 1412| 7.66k| if (seplen == 0) { ------------------ | Branch (1412:7): [True: 0, False: 7.66k] ------------------ 1413| 0| int c; 1414| 0| while ((jstr = jvp_utf8_next(jstr, jend, &c))) { ------------------ | Branch (1414:12): [True: 0, False: 0] ------------------ 1415| 0| a = jv_array_append(a, jv_string_append_codepoint(jv_string(""), c)); 1416| 0| if (!jv_is_valid(a)) break; ------------------ | Branch (1416:11): [True: 0, False: 0] ------------------ 1417| 0| } 1418| 7.66k| } else { 1419| 7.92k| for (p = jstr; p < jend; p = s + seplen) { ------------------ | Branch (1419:20): [True: 255, False: 7.66k] ------------------ 1420| 255| s = _jq_memmem(p, jend - p, sepstr, seplen); 1421| 255| if (s == NULL) ------------------ | Branch (1421:11): [True: 11, False: 244] ------------------ 1422| 11| s = jend; 1423| 255| a = jv_array_append(a, jv_string_sized(p, s - p)); 1424| 255| if (!jv_is_valid(a)) break; ------------------ | Branch (1424:11): [True: 0, False: 255] ------------------ 1425| | // Add an empty string to denote that j ends on a sep 1426| 255| if (s + seplen == jend && seplen != 0) ------------------ | Branch (1426:11): [True: 6, False: 249] | Branch (1426:33): [True: 6, False: 0] ------------------ 1427| 6| a = jv_array_append(a, jv_string("")); 1428| 255| } 1429| 7.66k| } 1430| 7.66k| jv_free(j); 1431| 7.66k| jv_free(sep); 1432| 7.66k| return a; 1433| 7.66k|} jv_string_explode: 1435| 97.0k|jv jv_string_explode(jv j) { 1436| 97.0k| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1436:3): [True: 0, False: 97.0k] | Branch (1436:3): [True: 97.0k, False: 0] ------------------ 1437| 97.0k| const char* i = jv_string_value(j); 1438| 97.0k| int len = jv_string_length_bytes(jv_copy(j)); 1439| 97.0k| const char* end = i + len; 1440| 97.0k| jv a = jv_array_sized(len); 1441| 97.0k| int c; 1442| 1.01M| while ((i = jvp_utf8_next(i, end, &c))) { ------------------ | Branch (1442:10): [True: 917k, False: 97.0k] ------------------ 1443| 917k| a = jv_array_append(a, jv_number(c)); 1444| 917k| if (!jv_is_valid(a)) break; ------------------ | Branch (1444:9): [True: 0, False: 917k] ------------------ 1445| 917k| } 1446| 97.0k| jv_free(j); 1447| 97.0k| return a; 1448| 97.0k|} jv_string_value: 1481| 10.0M|const char* jv_string_value(jv j) { 1482| 10.0M| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1482:3): [True: 0, False: 10.0M] | Branch (1482:3): [True: 10.0M, False: 0] ------------------ 1483| 10.0M| return jvp_string_ptr(j)->data; 1484| 10.0M|} jv_string_slice: 1486| 102k|jv jv_string_slice(jv j, int start, int end) { 1487| 102k| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1487:3): [True: 0, False: 102k] | Branch (1487:3): [True: 102k, False: 0] ------------------ 1488| 102k| const char *s = jv_string_value(j); 1489| 102k| int len = jv_string_length_bytes(jv_copy(j)); 1490| 102k| int i; 1491| 102k| const char *p, *e; 1492| 102k| int c; 1493| 102k| jv res; 1494| | 1495| 102k| jvp_clamp_slice_params(len, &start, &end); 1496| 102k| assert(0 <= start && start <= end && end <= len); ------------------ | Branch (1496:3): [True: 0, False: 102k] | Branch (1496:3): [True: 0, False: 0] | Branch (1496:3): [True: 0, False: 0] | Branch (1496:3): [True: 102k, False: 0] | Branch (1496:3): [True: 102k, False: 0] | Branch (1496:3): [True: 102k, False: 0] ------------------ 1497| | 1498| | /* Look for byte offset corresponding to start codepoints */ 1499| 365M| for (p = s, i = 0; i < start; i++) { ------------------ | Branch (1499:22): [True: 365M, False: 102k] ------------------ 1500| 365M| p = jvp_utf8_next(p, s + len, &c); 1501| 365M| if (p == NULL) { ------------------ | Branch (1501:9): [True: 0, False: 365M] ------------------ 1502| 0| jv_free(j); 1503| 0| return jv_string_empty(16); 1504| 0| } 1505| 365M| if (c == -1) { ------------------ | Branch (1505:9): [True: 0, False: 365M] ------------------ 1506| 0| jv_free(j); 1507| 0| return jv_invalid_with_msg(jv_string("Invalid UTF-8 string")); 1508| 0| } 1509| 365M| } 1510| | /* Look for byte offset corresponding to end codepoints */ 1511| 15.8M| for (e = p; e != NULL && i < end; i++) { ------------------ | Branch (1511:15): [True: 15.8M, False: 0] | Branch (1511:28): [True: 15.7M, False: 101k] ------------------ 1512| 15.7M| e = jvp_utf8_next(e, s + len, &c); 1513| 15.7M| if (e == NULL) { ------------------ | Branch (1513:9): [True: 1.37k, False: 15.7M] ------------------ 1514| 1.37k| e = s + len; 1515| 1.37k| break; 1516| 1.37k| } 1517| 15.7M| if (c == -1) { ------------------ | Branch (1517:9): [True: 0, False: 15.7M] ------------------ 1518| 0| jv_free(j); 1519| 0| return jv_invalid_with_msg(jv_string("Invalid UTF-8 string")); 1520| 0| } 1521| 15.7M| } 1522| | 1523| | /* 1524| | * NOTE: Ideally we should do here what jvp_array_slice() does instead 1525| | * of allocating a new string as we do! However, we assume NUL- 1526| | * terminated strings all over, and in the jv API, so for now we waste 1527| | * memory like a drunken navy programmer. There's probably nothing we 1528| | * can do about it. 1529| | */ 1530| 102k| res = jv_string_sized(p, e - p); 1531| 102k| jv_free(j); 1532| 102k| return res; 1533| 102k|} jv_string_concat: 1535| 1.19M|jv jv_string_concat(jv a, jv b) { 1536| 1.19M| a = jvp_string_append(a, jv_string_value(b), 1537| 1.19M| jvp_string_length(jvp_string_ptr(b))); 1538| 1.19M| jv_free(b); 1539| 1.19M| return a; 1540| 1.19M|} jv_string_append_buf: 1542| 13.8M|jv jv_string_append_buf(jv a, const char* buf, int len) { 1543| 13.8M| if (jvp_utf8_is_valid(buf, buf+len)) { ------------------ | Branch (1543:7): [True: 13.8M, False: 0] ------------------ 1544| 13.8M| a = jvp_string_append(a, buf, len); 1545| 13.8M| } else { 1546| 0| jv b = jvp_string_copy_replace_bad(buf, len); 1547| 0| a = jv_string_concat(a, b); 1548| 0| } 1549| 13.8M| return a; 1550| 13.8M|} jv_string_append_codepoint: 1552| 889k|jv jv_string_append_codepoint(jv a, uint32_t c) { 1553| 889k| char buf[5]; 1554| 889k| int len = jvp_utf8_encode(c, buf); 1555| 889k| a = jvp_string_append(a, buf, len); 1556| 889k| return a; 1557| 889k|} jv_string_append_str: 1559| 551k|jv jv_string_append_str(jv a, const char* str) { 1560| 551k| return jv_string_append_buf(a, str, strlen(str)); 1561| 551k|} jv_string_vfmt: 1563| 1.82M|jv jv_string_vfmt(const char* fmt, va_list ap) { 1564| 1.82M| int size = 1024; 1565| 1.82M| while (1) { ------------------ | Branch (1565:10): [True: 1.82M, Folded] ------------------ 1566| 1.82M| char* buf = jv_mem_alloc(size); 1567| 1.82M| va_list ap2; 1568| 1.82M| va_copy(ap2, ap); 1569| 1.82M| int n = vsnprintf(buf, size, fmt, ap2); 1570| 1.82M| va_end(ap2); 1571| | /* 1572| | * NOTE: here we support old vsnprintf()s that return -1 because the 1573| | * buffer is too small. 1574| | */ 1575| 1.82M| if (n >= 0 && n < size) { ------------------ | Branch (1575:9): [True: 1.82M, False: 0] | Branch (1575:19): [True: 1.82M, False: 167] ------------------ 1576| 1.82M| jv ret = jv_string_sized(buf, n); 1577| 1.82M| jv_mem_free(buf); 1578| 1.82M| return ret; 1579| 1.82M| } else { 1580| 167| jv_mem_free(buf); 1581| 167| size = (n > 0) ? /* standard */ (n * 2) : /* not standard */ (size * 2); ------------------ | Branch (1581:14): [True: 167, False: 0] ------------------ 1582| 167| } 1583| 1.82M| } 1584| 1.82M|} jv_string_fmt: 1586| 1.81M|jv jv_string_fmt(const char* fmt, ...) { 1587| 1.81M| va_list args; 1588| 1.81M| va_start(args, fmt); 1589| 1.81M| jv res = jv_string_vfmt(fmt, args); 1590| | va_end(args); 1591| 1.81M| return res; 1592| 1.81M|} jv_object: 1849| 1.39M|jv jv_object(void) { 1850| 1.39M| return jvp_object_new(8); 1851| 1.39M|} jv_object_get: 1853| 3.92M|jv jv_object_get(jv object, jv key) { 1854| 3.92M| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1854:3): [True: 0, False: 3.92M] | Branch (1854:3): [True: 3.92M, False: 0] ------------------ 1855| 3.92M| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1855:3): [True: 0, False: 3.92M] | Branch (1855:3): [True: 3.92M, False: 0] ------------------ 1856| 3.92M| jv* slot = jvp_object_read(object, key); 1857| 3.92M| jv val; 1858| 3.92M| if (slot) { ------------------ | Branch (1858:7): [True: 3.90M, False: 27.5k] ------------------ 1859| 3.90M| val = jv_copy(*slot); 1860| 3.90M| } else { 1861| 27.5k| val = jv_invalid(); 1862| 27.5k| } 1863| 3.92M| jv_free(object); 1864| 3.92M| jv_free(key); 1865| 3.92M| return val; 1866| 3.92M|} jv_object_set: 1878| 7.33M|jv jv_object_set(jv object, jv key, jv value) { 1879| 7.33M| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1879:3): [True: 0, False: 7.33M] | Branch (1879:3): [True: 7.33M, False: 0] ------------------ 1880| 7.33M| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1880:3): [True: 0, False: 7.33M] | Branch (1880:3): [True: 7.33M, False: 0] ------------------ 1881| | // copy/free of object, key, value coalesced 1882| 7.33M| jv* slot; 1883| 7.33M| if (!jvp_object_write(&object, key, &slot)) { ------------------ | Branch (1883:7): [True: 0, False: 7.33M] ------------------ 1884| 0| jv_free(object); 1885| 0| jv_free(value); 1886| 0| return jv_invalid_with_msg(jv_string("Object too big")); 1887| 0| } 1888| 7.33M| jv_free(*slot); 1889| 7.33M| *slot = value; 1890| 7.33M| return object; 1891| 7.33M|} jv_object_delete: 1893| 8|jv jv_object_delete(jv object, jv key) { 1894| 8| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1894:3): [True: 0, False: 8] | Branch (1894:3): [True: 8, False: 0] ------------------ 1895| 8| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1895:3): [True: 0, False: 8] | Branch (1895:3): [True: 8, False: 0] ------------------ 1896| 8| jvp_object_delete(&object, key); 1897| 8| jv_free(key); 1898| 8| return object; 1899| 8|} jv_object_length: 1901| 135k|int jv_object_length(jv object) { 1902| 135k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1902:3): [True: 0, False: 135k] | Branch (1902:3): [True: 135k, False: 0] ------------------ 1903| 135k| int n = jvp_object_length(object); 1904| 135k| jv_free(object); 1905| 135k| return n; 1906| 135k|} jv_object_merge: 1908| 53.7k|jv jv_object_merge(jv a, jv b) { 1909| 53.7k| assert(JVP_HAS_KIND(a, JV_KIND_OBJECT)); ------------------ | Branch (1909:3): [True: 0, False: 53.7k] | Branch (1909:3): [True: 53.7k, False: 0] ------------------ 1910| 71.6k| jv_object_foreach(b, k, v) { ------------------ | | 159| 107k| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (159:52): [True: 53.7k, False: 53.7k] | | ------------------ | | 160| 53.7k| for (jv k, v; \ | | 161| 125k| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (161:10): [True: 71.6k, False: 53.7k] | | | Branch (161:10): [True: 71.6k, False: 53.7k] | | ------------------ | | 162| 125k| (k = jv_object_iter_key(t, jv_i__), \ | | 163| 71.6k| v = jv_object_iter_value(t, jv_i__), \ | | 164| 71.6k| 1) \ | | 165| 125k| : 0; \ | | 166| 71.6k| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 1911| 71.6k| a = jv_object_set(a, k, v); 1912| 71.6k| if (!jv_is_valid(a)) break; ------------------ | Branch (1912:9): [True: 0, False: 71.6k] ------------------ 1913| 71.6k| } 1914| 53.7k| jv_free(b); 1915| 53.7k| return a; 1916| 53.7k|} jv_object_iter_valid: 1965| 2.29M|int jv_object_iter_valid(jv object, int i) { 1966| 2.29M| return i != ITER_FINISHED; 1967| 2.29M|} jv_object_iter: 1969| 115k|int jv_object_iter(jv object) { 1970| 115k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1970:3): [True: 0, False: 115k] | Branch (1970:3): [True: 115k, False: 0] ------------------ 1971| 115k| return jv_object_iter_next(object, -1); 1972| 115k|} jv_object_iter_next: 1974| 2.29M|int jv_object_iter_next(jv object, int iter) { 1975| 2.29M| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1975:3): [True: 0, False: 2.29M] | Branch (1975:3): [True: 2.29M, False: 0] ------------------ 1976| 2.29M| assert(iter != ITER_FINISHED); ------------------ | Branch (1976:3): [True: 0, False: 2.29M] | Branch (1976:3): [True: 2.29M, False: 0] ------------------ 1977| 2.29M| struct object_slot* slot; 1978| 3.27M| do { 1979| 3.27M| iter++; 1980| 3.27M| if (iter >= jvp_object_size(object)) ------------------ | Branch (1980:9): [True: 114k, False: 3.15M] ------------------ 1981| 114k| return ITER_FINISHED; 1982| 3.15M| slot = jvp_object_get_slot(object, iter); 1983| 3.15M| } while (jv_get_kind(slot->string) == JV_KIND_NULL); ------------------ | Branch (1983:12): [True: 976k, False: 2.18M] ------------------ 1984| 2.29M| assert(jv_get_kind(jvp_object_get_slot(object,iter)->string) ------------------ | Branch (1984:3): [True: 0, False: 2.18M] | Branch (1984:3): [True: 2.18M, False: 0] ------------------ 1985| 2.18M| == JV_KIND_STRING); 1986| 2.18M| return iter; 1987| 2.18M|} jv_object_iter_key: 1989| 2.18M|jv jv_object_iter_key(jv object, int iter) { 1990| 2.18M| jv s = jvp_object_get_slot(object, iter)->string; 1991| 2.18M| assert(JVP_HAS_KIND(s, JV_KIND_STRING)); ------------------ | Branch (1991:3): [True: 0, False: 2.18M] | Branch (1991:3): [True: 2.18M, False: 0] ------------------ 1992| 2.18M| return jv_copy(s); 1993| 2.18M|} jv_object_iter_value: 1995| 2.17M|jv jv_object_iter_value(jv object, int iter) { 1996| 2.17M| return jv_copy(jvp_object_get_slot(object, iter)->value); 1997| 2.17M|} jv_copy: 2002| 601M|jv jv_copy(jv j) { 2003| 601M| if (JVP_IS_ALLOCATED(j)) { ------------------ | | 95| 601M|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 466M, False: 134M] | | ------------------ ------------------ 2004| 466M| jvp_refcnt_inc(j.u.ptr); 2005| 466M| } 2006| 601M| return j; 2007| 601M|} jv_free: 2014| 553M|void jv_free(jv j) { 2015| 553M| jv* pending = NULL; 2016| 553M| size_t len = 0, cap = 0; 2017| 798M| while (1) { ------------------ | Branch (2017:10): [True: 798M, Folded] ------------------ 2018| 798M| switch (JVP_KIND(j)) { ------------------ | | 90| 798M|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 89| 798M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 77| 798M|#define KIND_MASK 0xF | | ------------------ | | | Branch (90:23): [True: 648M, False: 149M] | | ------------------ ------------------ 2019| 254M| case JV_KIND_ARRAY: ------------------ | Branch (2019:7): [True: 254M, False: 543M] ------------------ 2020| 254M| if (jvp_refcnt_dec(j.u.ptr)) { ------------------ | Branch (2020:13): [True: 12.1M, False: 242M] ------------------ 2021| 12.1M| jvp_array* arr = jvp_array_ptr(j); 2022| 12.1M| if (len + arr->length > cap) { ------------------ | Branch (2022:15): [True: 5.85M, False: 6.28M] ------------------ 2023| 5.85M| cap = (len + arr->length) * 2; 2024| 5.85M| pending = jv_mem_realloc(pending, cap * sizeof(jv)); 2025| 5.85M| } 2026| 250M| for (int i = 0; i < arr->length; i++) ------------------ | Branch (2026:27): [True: 238M, False: 12.1M] ------------------ 2027| 238M| pending[len++] = arr->elements[i]; 2028| 12.1M| jv_mem_free(arr); 2029| 12.1M| } 2030| 254M| break; 2031| 25.2M| case JV_KIND_OBJECT: ------------------ | Branch (2031:7): [True: 25.2M, False: 773M] ------------------ 2032| 25.2M| if (jvp_refcnt_dec(j.u.ptr)) { ------------------ | Branch (2032:13): [True: 2.43M, False: 22.8M] ------------------ 2033| 2.43M| int sz = jvp_object_size(j); 2034| 2.43M| if (len + sz > cap) { ------------------ | Branch (2034:15): [True: 1.85M, False: 571k] ------------------ 2035| 1.85M| cap = (len + sz) * 2; 2036| 1.85M| pending = jv_mem_realloc(pending, cap * sizeof(jv)); 2037| 1.85M| } 2038| 23.8M| for (int i = 0; i < sz; i++) { ------------------ | Branch (2038:27): [True: 21.4M, False: 2.43M] ------------------ 2039| 21.4M| struct object_slot* slot = jvp_object_get_slot(j, i); 2040| 21.4M| if (jv_get_kind(slot->string) != JV_KIND_NULL) { ------------------ | Branch (2040:17): [True: 5.55M, False: 15.8M] ------------------ 2041| 5.55M| jvp_string_free(slot->string); 2042| 5.55M| pending[len++] = slot->value; 2043| 5.55M| } 2044| 21.4M| } 2045| 2.43M| jv_mem_free(jvp_object_ptr(j)); 2046| 2.43M| } 2047| 25.2M| break; 2048| 38.6M| case JV_KIND_INVALID: ------------------ | Branch (2048:7): [True: 38.6M, False: 759M] ------------------ 2049| 38.6M| if (JVP_HAS_FLAGS(j, JVP_FLAGS_INVALID_MSG) && jvp_refcnt_dec(j.u.ptr)) { ------------------ | | 92| 77.3M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 38.6M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 2.49M, False: 36.1M] | | ------------------ ------------------ | Branch (2049:56): [True: 839k, False: 1.65M] ------------------ 2050| 839k| if (len + 1 > cap) { ------------------ | Branch (2050:15): [True: 839k, False: 0] ------------------ 2051| 839k| cap = (len + 1) * 2; 2052| 839k| pending = jv_mem_realloc(pending, cap * sizeof(jv)); 2053| 839k| } 2054| 839k| pending[len++] = ((jvp_invalid*)j.u.ptr)->errmsg; 2055| 839k| jv_mem_free(j.u.ptr); 2056| 839k| } 2057| 38.6M| break; 2058| 26.9M| case JV_KIND_STRING: ------------------ | Branch (2058:7): [True: 26.9M, False: 771M] ------------------ 2059| 26.9M| jvp_string_free(j); 2060| 26.9M| break; 2061| 303M| case JV_KIND_NUMBER: ------------------ | Branch (2061:7): [True: 303M, False: 495M] ------------------ 2062| 303M| jvp_number_free(j); 2063| 303M| break; 2064| 798M| } 2065| 798M| if (len == 0) break; ------------------ | Branch (2065:9): [True: 553M, False: 245M] ------------------ 2066| 245M| j = pending[--len]; 2067| 245M| } 2068| 553M| jv_mem_free(pending); 2069| 553M|} jv_get_refcnt: 2071| 7.66k|int jv_get_refcnt(jv j) { 2072| 7.66k| if (JVP_IS_ALLOCATED(j)) { ------------------ | | 95| 7.66k|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 7.66k, False: 0] | | ------------------ ------------------ 2073| 7.66k| return j.u.ptr->count; 2074| 7.66k| } else { 2075| 0| return 1; 2076| 0| } 2077| 7.66k|} jv_equal: 2127| 2.35M|int jv_equal(jv a, jv b) { 2128| 2.35M| return jvp_equal(a, b, 0); 2129| 2.35M|} jv_identical: 2131| 2.80M|int jv_identical(jv a, jv b) { 2132| 2.80M| int r; 2133| 2.80M| if (a.kind_flags != b.kind_flags ------------------ | Branch (2133:7): [True: 0, False: 2.80M] ------------------ 2134| 2.80M| || a.offset != b.offset ------------------ | Branch (2134:10): [True: 0, False: 2.80M] ------------------ 2135| 2.80M| || a.size != b.size) { ------------------ | Branch (2135:10): [True: 0, False: 2.80M] ------------------ 2136| 0| r = 0; 2137| 2.80M| } else { 2138| 2.80M| if (JVP_IS_ALLOCATED(a) /* b has the same flags */) { ------------------ | | 95| 2.80M|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 2.68M, False: 122k] | | ------------------ ------------------ 2139| 2.68M| r = a.u.ptr == b.u.ptr; 2140| 2.68M| } else { 2141| 122k| r = memcmp(&a.u.ptr, &b.u.ptr, sizeof(a.u)) == 0; 2142| 122k| } 2143| 2.80M| } 2144| 2.80M| jv_free(a); 2145| 2.80M| jv_free(b); 2146| 2.80M| return r; 2147| 2.80M|} jv_contains: 2183| 39|int jv_contains(jv a, jv b) { 2184| 39| return jvp_contains(a, b, 0); 2185| 39|} jv.c:jvp_literal_number_literal: 622| 1.45M|static const char* jvp_literal_number_literal(jv n) { 623| 1.45M| assert(JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (623:3): [True: 0, Folded] | Branch (623:3): [True: 0, False: 1.45M] | Branch (623:3): [True: 1.45M, Folded] | Branch (623:3): [True: 1.45M, False: 0] ------------------ 624| 1.45M| decNumber *pdec = jvp_dec_number_ptr(n); 625| 1.45M| jvp_literal_number* plit = jvp_literal_number_ptr(n); 626| | 627| 1.45M| if (decNumberIsNaN(pdec)) { ------------------ | | 172| 1.45M| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 1.45M| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 1.45M| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (172:36): [True: 0, False: 1.45M] | | ------------------ ------------------ 628| 0| return "null"; 629| 0| } 630| | 631| 1.45M| if (decNumberIsInfinite(pdec)) { ------------------ | | 171| 1.45M| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 1.45M| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 1.78k, False: 1.45M] | | ------------------ ------------------ 632| | // We cannot preserve the literal data of numbers outside the limited 633| | // range of exponent. Since `decNumberToString` returns "Infinity" 634| | // (or "-Infinity"), and to reduce stack allocations as possible, we 635| | // normalize infinities in the callers instead of printing the maximum 636| | // (or minimum) double here. 637| 1.78k| return NULL; 638| 1.78k| } 639| | 640| 1.45M| if (plit->literal_data == NULL) { ------------------ | Branch (640:7): [True: 1.45M, False: 1.12k] ------------------ 641| 1.45M| int len = jvp_dec_number_ptr(n)->digits + 15 /* 14 + NUL */; 642| 1.45M| plit->literal_data = jv_mem_alloc(len); 643| | 644| | // Preserve the actual precision as we have parsed it 645| | // don't do decNumberTrim(pdec); 646| | 647| 1.45M| decNumberToString(pdec, plit->literal_data); 648| 1.45M| } 649| | 650| 1.45M| return plit->literal_data; 651| 1.45M|} jv.c:jvp_literal_number_new: 572| 7.84M|static jv jvp_literal_number_new(const char * literal) { 573| 7.84M| size_t len = strlen(literal); 574| 7.84M| if (len > DEC_MAX_DIGITS) ------------------ | | 88| 7.84M| #define DEC_MAX_DIGITS 999999999 ------------------ | Branch (574:7): [True: 0, False: 7.84M] ------------------ 575| 0| return JV_INVALID; 576| 7.84M| jvp_literal_number* n = jvp_literal_number_alloc(len); 577| | 578| 7.84M| decContext *ctx = DEC_CONTEXT(); ------------------ | | 487| 7.84M|#define DEC_CONTEXT() tsd_dec_ctx_get(&dec_ctx_key) ------------------ 579| 7.84M| decContextClearStatus(ctx, DEC_Conversion_syntax); ------------------ | | 128| 7.84M| #define DEC_Conversion_syntax 0x00000001 ------------------ 580| 7.84M| decNumberFromString(&n->num_decimal, literal, ctx); 581| | 582| 7.84M| if (ctx->status & DEC_Conversion_syntax) { ------------------ | | 128| 7.84M| #define DEC_Conversion_syntax 0x00000001 ------------------ | Branch (582:7): [True: 11.7k, False: 7.83M] ------------------ 583| 11.7k| jv_mem_free(n); 584| 11.7k| return JV_INVALID; 585| 11.7k| } 586| 7.83M| if (decNumberIsNaN(&n->num_decimal)) { ------------------ | | 172| 7.83M| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 7.83M| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 7.83M| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (172:36): [True: 4.33k, False: 7.83M] | | ------------------ ------------------ 587| | // Reject NaN with payload. 588| 4.33k| if (n->num_decimal.digits > 1 || *n->num_decimal.lsu != 0) { ------------------ | Branch (588:9): [True: 438, False: 3.89k] | Branch (588:38): [True: 391, False: 3.50k] ------------------ 589| 829| jv_mem_free(n); 590| 829| return JV_INVALID; 591| 829| } 592| 3.50k| jv_mem_free(n); 593| 3.50k| return jv_number(NAN); 594| 4.33k| } 595| | 596| 7.83M| jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, 0, {&n->refcnt}}; ------------------ | | 206| 7.83M|#define JVP_FLAGS_NUMBER_LITERAL JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_DECIMAL, 1)) | | ------------------ | | | | 87| 15.6M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 7.83M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 7.83M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | | | | Branch (87:61): [True: 7.83M, Folded] | | | | ------------------ | | ------------------ ------------------ 597| 7.83M| return r; 598| 7.83M|} jv.c:jvp_literal_number_ptr: 547| 46.1M|static jvp_literal_number* jvp_literal_number_ptr(jv j) { 548| 46.1M| assert(JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (548:3): [True: 0, Folded] | Branch (548:3): [True: 0, False: 46.1M] | Branch (548:3): [True: 46.1M, Folded] | Branch (548:3): [True: 46.1M, False: 0] ------------------ 549| 46.1M| return (jvp_literal_number*)j.u.ptr; 550| 46.1M|} jv.c:jvp_literal_number_to_double: 600| 137k|static double jvp_literal_number_to_double(jv j) { 601| 137k| assert(JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (601:3): [True: 0, Folded] | Branch (601:3): [True: 0, False: 137k] | Branch (601:3): [True: 137k, Folded] | Branch (601:3): [True: 137k, False: 0] ------------------ 602| 137k| decContext dblCtx; 603| | 604| | // init as decimal64 but change digits to allow conversion to binary64 (double) 605| 137k| decContextDefault(&dblCtx, DEC_INIT_DECIMAL64); ------------------ | | 229| 137k| #define DEC_INIT_DECIMAL64 64 ------------------ 606| 137k| dblCtx.digits = DEC_NUMBER_DOUBLE_PRECISION; ------------------ | | 209| 137k|#define DEC_NUMBER_DOUBLE_PRECISION (17) ------------------ 607| | 608| 137k| decNumber *p_dec_number = jvp_dec_number_ptr(j); 609| 137k| decNumberDoublePrecision dec_double; 610| 137k| char literal[DEC_NUMBER_DOUBLE_PRECISION + DEC_NUMBER_STRING_GUARD + 1]; 611| | 612| | // reduce the number to the shortest possible form 613| | // that fits into the 64 bit floating point representation 614| 137k| decNumberReduce(&dec_double.number, p_dec_number, &dblCtx); 615| | 616| 137k| decNumberToString(&dec_double.number, literal); 617| | 618| 137k| char *end; 619| 137k| return jvp_strtod(tsd_dtoa_context_get(), literal, &end); 620| 137k|} jv.c:jvp_dec_number_ptr: 552| 22.4M|static decNumber* jvp_dec_number_ptr(jv j) { 553| 22.4M| assert(JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (553:3): [True: 0, Folded] | Branch (553:3): [True: 0, False: 22.4M] | Branch (553:3): [True: 22.4M, Folded] | Branch (553:3): [True: 22.4M, False: 0] ------------------ 554| 22.4M| return &(((jvp_literal_number*)j.u.ptr)->num_decimal); 555| 22.4M|} jv.c:jvp_literal_number_alloc: 557| 8.41M|static jvp_literal_number* jvp_literal_number_alloc(unsigned literal_length) { 558| | /* The number of units needed is ceil(DECNUMDIGITS/DECDPUN) */ 559| 8.41M| int units = ((literal_length+DECDPUN-1)/DECDPUN); ------------------ | | 43| 8.41M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ int units = ((literal_length+DECDPUN-1)/DECDPUN); ------------------ | | 43| 8.41M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 560| | 561| 8.41M| jvp_literal_number* n = jv_mem_alloc( 562| 8.41M| sizeof(jvp_literal_number) 563| 8.41M| + sizeof(decNumberUnit) * units 564| 8.41M| ); 565| | 566| 8.41M| n->refcnt = JV_REFCNT_INIT; 567| 8.41M| n->num_double = NAN; 568| | n->literal_data = NULL; 569| 8.41M| return n; 570| 8.41M|} jv.c:tsd_dec_ctx_get: 504| 10.2M|static decContext* tsd_dec_ctx_get(pthread_key_t *key) { 505| 10.2M| pthread_once(&dec_ctx_once, jv_tsd_dec_ctx_init); // cannot fail 506| 10.2M| decContext *ctx = (decContext*)pthread_getspecific(*key); 507| 10.2M| if (ctx) { ------------------ | Branch (507:7): [True: 10.2M, False: 1] ------------------ 508| 10.2M| return ctx; 509| 10.2M| } 510| | 511| 1| ctx = malloc(sizeof(decContext)); 512| 1| if (ctx) { ------------------ | Branch (512:7): [True: 1, False: 0] ------------------ 513| 1| if (key == &dec_ctx_key) ------------------ | Branch (513:9): [True: 1, False: 0] ------------------ 514| 1| { 515| 1| decContextDefault(ctx, DEC_INIT_BASE); ------------------ | | 227| 1| #define DEC_INIT_BASE 0 ------------------ 516| | // make sure (Int)D2U(rhs->exponent-lhs->exponent) does not overflow 517| 1| ctx->digits = MIN(DEC_MAX_DIGITS, ------------------ | | 49| 1| ({ __typeof__ (a) _a = (a); \ | | 50| 1| __typeof__ (b) _b = (b); \ | | 51| 1| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (51:4): [True: 0, False: 1] | | ------------------ ------------------ 518| 1| INT32_MAX - (DECDPUN - 1) - (ctx->emax - ctx->emin - 1)); 519| 1| ctx->traps = 0; /*no errors*/ 520| 1| } 521| 1| if (pthread_setspecific(*key, ctx) != 0) { ------------------ | Branch (521:9): [True: 0, False: 1] ------------------ 522| 0| fprintf(stderr, "error: cannot store thread specific data"); 523| 0| abort(); 524| 0| } 525| 1| } 526| 1| return ctx; 527| 1|} jv.c:jvp_array_new: 840| 7.36M|static jv jvp_array_new(unsigned size) { 841| 7.36M| jv r = {JVP_FLAGS_ARRAY, 0, 0, 0, {&jvp_array_alloc(size)->refcnt}}; ------------------ | | 813| 7.36M|#define JVP_FLAGS_ARRAY JVP_MAKE_FLAGS(JV_KIND_ARRAY, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 7.36M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 7.36M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 7.36M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 842| 7.36M| return r; 843| 7.36M|} jv.c:jvp_array_alloc: 832| 12.1M|static jvp_array* jvp_array_alloc(unsigned size) { 833| 12.1M| jvp_array* a = jv_mem_alloc(sizeof(jvp_array) + sizeof(jv) * size); 834| 12.1M| a->refcnt.count = 1; 835| 12.1M| a->length = 0; 836| 12.1M| a->alloc_length = size; 837| 12.1M| return a; 838| 12.1M|} jv.c:jvp_array_length: 845| 378M|static int jvp_array_length(jv a) { 846| 378M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (846:3): [True: 0, False: 378M] | Branch (846:3): [True: 378M, False: 0] ------------------ 847| 378M| return a.size; 848| 378M|} jv.c:jvp_array_read: 855| 81.9M|static jv* jvp_array_read(jv a, int i) { 856| 81.9M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (856:3): [True: 0, False: 81.9M] | Branch (856:3): [True: 81.9M, False: 0] ------------------ 857| 81.9M| if (i >= 0 && i < jvp_array_length(a)) { ------------------ | Branch (857:7): [True: 81.9M, False: 3.88k] | Branch (857:17): [True: 81.4M, False: 469k] ------------------ 858| 81.4M| jvp_array* array = jvp_array_ptr(a); 859| 81.4M| assert(i + jvp_array_offset(a) < array->length); ------------------ | Branch (859:5): [True: 0, False: 81.4M] | Branch (859:5): [True: 81.4M, False: 0] ------------------ 860| 81.4M| return &array->elements[i + jvp_array_offset(a)]; 861| 81.4M| } else { 862| 473k| return 0; 863| 473k| } 864| 81.9M|} jv.c:jvp_array_offset: 850| 487M|static int jvp_array_offset(jv a) { 851| 487M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (851:3): [True: 0, False: 487M] | Branch (851:3): [True: 487M, False: 0] ------------------ 852| 487M| return a.offset; 853| 487M|} jv.c:jvp_array_write: 866| 81.5M|static jv* jvp_array_write(jv* a, int i) { 867| 81.5M| assert(i >= 0); ------------------ | Branch (867:3): [True: 0, False: 81.5M] | Branch (867:3): [True: 81.5M, False: 0] ------------------ 868| 81.5M| jvp_array* array = jvp_array_ptr(*a); 869| | 870| 81.5M| int pos = i + jvp_array_offset(*a); 871| 81.5M| if (pos < array->alloc_length && jvp_refcnt_unshared(a->u.ptr)) { ------------------ | Branch (871:7): [True: 80.0M, False: 1.46M] | Branch (871:36): [True: 76.7M, False: 3.31M] ------------------ 872| | // use existing array space 873| 149M| for (int j = array->length; j <= pos; j++) { ------------------ | Branch (873:33): [True: 72.4M, False: 76.7M] ------------------ 874| 72.4M| array->elements[j] = JV_NULL; 875| 72.4M| } 876| 76.7M| array->length = imax(pos + 1, array->length); 877| 76.7M| a->size = imax(i + 1, a->size); 878| 76.7M| return &array->elements[pos]; 879| 76.7M| } else { 880| | // allocate a new array 881| 4.77M| int new_length = imax(i + 1, jvp_array_length(*a)); 882| 4.77M| jvp_array* new_array = jvp_array_alloc(ARRAY_SIZE_ROUND_UP(new_length)); ------------------ | | 812| 4.77M|#define ARRAY_SIZE_ROUND_UP(n) (((n)*3)/2) ------------------ 883| 4.77M| int j; 884| 166M| for (j = 0; j < jvp_array_length(*a); j++) { ------------------ | Branch (884:17): [True: 161M, False: 4.77M] ------------------ 885| 161M| new_array->elements[j] = 886| 161M| jv_copy(array->elements[j + jvp_array_offset(*a)]); 887| 161M| } 888| 9.55M| for (; j < new_length; j++) { ------------------ | Branch (888:12): [True: 4.77M, False: 4.77M] ------------------ 889| 4.77M| new_array->elements[j] = JV_NULL; 890| 4.77M| } 891| 4.77M| new_array->length = new_length; 892| 4.77M| jv_free(*a); 893| 4.77M| jv new_jv = {JVP_FLAGS_ARRAY, 0, 0, new_length, {&new_array->refcnt}}; ------------------ | | 813| 4.77M|#define JVP_FLAGS_ARRAY JVP_MAKE_FLAGS(JV_KIND_ARRAY, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 4.77M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 4.77M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 4.77M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 894| 4.77M| *a = new_jv; 895| 4.77M| return &new_array->elements[i]; 896| 4.77M| } 897| 81.5M|} jv.c:jvp_refcnt_unshared: 72| 104M|static int jvp_refcnt_unshared(jv_refcnt* c) { 73| 104M| assert(c->count > 0); ------------------ | Branch (73:3): [True: 0, False: 104M] | Branch (73:3): [True: 104M, False: 0] ------------------ 74| 104M| return c->count == 1; 75| 104M|} jv.c:imax: 815| 158M|static int imax(int a, int b) { 816| 158M| if (a>b) return a; ------------------ | Branch (816:7): [True: 149M, False: 8.54M] ------------------ 817| 8.54M| else return b; 818| 158M|} jv.c:jvp_array_slice: 953| 8.09M|static jv jvp_array_slice(jv a, int start, int end) { 954| 8.09M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (954:3): [True: 0, False: 8.09M] | Branch (954:3): [True: 8.09M, False: 0] ------------------ 955| 8.09M| int len = jvp_array_length(a); 956| 8.09M| jvp_clamp_slice_params(len, &start, &end); 957| 8.09M| assert(0 <= start && start <= end && end <= len); ------------------ | Branch (957:3): [True: 0, False: 8.09M] | Branch (957:3): [True: 0, False: 0] | Branch (957:3): [True: 0, False: 0] | Branch (957:3): [True: 8.09M, False: 0] | Branch (957:3): [True: 8.09M, False: 0] | Branch (957:3): [True: 8.09M, False: 0] ------------------ 958| | 959| | // FIXME: maybe slice should reallocate if the slice is small enough 960| 8.09M| if (start == end) { ------------------ | Branch (960:7): [True: 5.07M, False: 3.01M] ------------------ 961| 5.07M| jv_free(a); 962| 5.07M| return jv_array(); 963| 5.07M| } 964| | 965| 3.01M| if (a.offset + start >= 1 << (sizeof(a.offset) * CHAR_BIT)) { ------------------ | Branch (965:7): [True: 6, False: 3.01M] ------------------ 966| 6| jv r = jv_array_sized(end - start); 967| 18| for (int i = start; i < end; i++) ------------------ | Branch (967:25): [True: 12, False: 6] ------------------ 968| 12| r = jv_array_append(r, jv_array_get(jv_copy(a), i)); 969| 6| jv_free(a); 970| 6| return r; 971| 3.01M| } else { 972| 3.01M| a.offset += start; 973| 3.01M| a.size = end - start; 974| 3.01M| return a; 975| 3.01M| } 976| 3.01M|} jv.c:jvp_string_new: 1141| 12.8M|static jv jvp_string_new(const char* data, uint32_t length) { 1142| 12.8M| jvp_string* s = jvp_string_alloc(length); 1143| 12.8M| s->length_hashed = length << 1; 1144| 12.8M| if (data != NULL) ------------------ | Branch (1144:7): [True: 12.8M, False: 0] ------------------ 1145| 12.8M| memcpy(s->data, data, length); 1146| 12.8M| s->data[length] = 0; 1147| 12.8M| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&s->refcnt}}; ------------------ | | 1087| 12.8M|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 12.8M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 12.8M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 12.8M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1148| 12.8M| return r; 1149| 12.8M|} jv.c:jvp_string_alloc: 1104| 14.2M|static jvp_string* jvp_string_alloc(uint32_t size) { 1105| 14.2M| jvp_string* s = jv_mem_alloc(sizeof(jvp_string) + size + 1); 1106| 14.2M| s->refcnt.count = 1; 1107| 14.2M| s->alloc_length = size; 1108| 14.2M| return s; 1109| 14.2M|} jv.c:jvp_string_copy_replace_bad: 1112| 89.7k|static jv jvp_string_copy_replace_bad(const char* data, uint32_t length) { 1113| 89.7k| const char* end = data + length; 1114| 89.7k| const char* i = data; 1115| | 1116| | // worst case: all bad bytes, each becomes a 3-byte U+FFFD 1117| 89.7k| uint64_t maxlength = (uint64_t)length * 3 + 1; 1118| 89.7k| if (maxlength >= INT_MAX) { ------------------ | Branch (1118:7): [True: 0, False: 89.7k] ------------------ 1119| 0| return jv_invalid_with_msg(jv_string("String too long")); 1120| 0| } 1121| | 1122| 89.7k| jvp_string* s = jvp_string_alloc(maxlength); 1123| 89.7k| char* out = s->data; 1124| 89.7k| int c = 0; 1125| | 1126| 79.3M| while ((i = jvp_utf8_next(i, end, &c))) { ------------------ | Branch (1126:10): [True: 79.2M, False: 89.7k] ------------------ 1127| 79.2M| if (c == -1) { ------------------ | Branch (1127:9): [True: 46.4M, False: 32.7M] ------------------ 1128| 46.4M| c = 0xFFFD; // U+FFFD REPLACEMENT CHARACTER 1129| 46.4M| } 1130| 79.2M| out += jvp_utf8_encode(c, out); 1131| 79.2M| assert(out < s->data + maxlength); ------------------ | Branch (1131:5): [True: 0, False: 79.2M] | Branch (1131:5): [True: 79.2M, False: 0] ------------------ 1132| 79.2M| } 1133| 89.7k| length = out - s->data; 1134| 89.7k| s->data[length] = 0; 1135| 89.7k| s->length_hashed = length << 1; 1136| 89.7k| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&s->refcnt}}; ------------------ | | 1087| 89.7k|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 89.7k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 89.7k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 89.7k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1137| 89.7k| return r; 1138| 89.7k|} jv.c:jvp_string_empty_new: 1151| 50.5k|static jv jvp_string_empty_new(uint32_t length) { 1152| 50.5k| jvp_string* s = jvp_string_alloc(length); 1153| 50.5k| s->length_hashed = 0; 1154| 50.5k| memset(s->data, 0, length); 1155| 50.5k| s->data[length] = 0; 1156| 50.5k| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&s->refcnt}}; ------------------ | | 1087| 50.5k|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 50.5k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 50.5k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 50.5k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1157| 50.5k| return r; 1158| 50.5k|} jv.c:jvp_string_length: 1168| 73.7M|static uint32_t jvp_string_length(jvp_string* s) { 1169| 73.7M| return s->length_hashed >> 1; 1170| 73.7M|} jv.c:jvp_string_ptr: 1099| 111M|static jvp_string* jvp_string_ptr(jv a) { 1100| 111M| assert(JVP_HAS_KIND(a, JV_KIND_STRING)); ------------------ | Branch (1100:3): [True: 0, False: 111M] | Branch (1100:3): [True: 111M, False: 0] ------------------ 1101| 111M| return (jvp_string*)a.u.ptr; 1102| 111M|} jv.c:jvp_string_append: 1178| 15.9M|static jv jvp_string_append(jv string, const char* data, uint32_t len) { 1179| 15.9M| jvp_string* s = jvp_string_ptr(string); 1180| 15.9M| uint32_t currlen = jvp_string_length(s); 1181| 15.9M| if ((uint64_t)currlen + len >= INT_MAX - sizeof(jvp_string) / 2) { ------------------ | Branch (1181:7): [True: 0, False: 15.9M] ------------------ 1182| 0| jv_free(string); 1183| 0| return jv_invalid_with_msg(jv_string("String too long")); 1184| 0| } 1185| | 1186| 15.9M| if (jvp_refcnt_unshared(string.u.ptr) && ------------------ | Branch (1186:7): [True: 15.6M, False: 272k] ------------------ 1187| 15.6M| jvp_string_remaining_space(s) >= len) { ------------------ | Branch (1187:7): [True: 14.6M, False: 985k] ------------------ 1188| | // the next string fits at the end of a 1189| 14.6M| memcpy(s->data + currlen, data, len); 1190| 14.6M| s->data[currlen + len] = 0; 1191| 14.6M| s->length_hashed = (currlen + len) << 1; 1192| 14.6M| return string; 1193| 14.6M| } else { 1194| | // allocate a bigger buffer and copy 1195| 1.25M| uint32_t allocsz = (currlen + len) * 2; 1196| 1.25M| if (allocsz < 32) allocsz = 32; ------------------ | Branch (1196:9): [True: 1.08M, False: 176k] ------------------ 1197| 1.25M| jvp_string* news = jvp_string_alloc(allocsz); 1198| 1.25M| news->length_hashed = (currlen + len) << 1; 1199| 1.25M| memcpy(news->data, s->data, currlen); 1200| 1.25M| memcpy(news->data + currlen, data, len); 1201| 1.25M| news->data[currlen + len] = 0; 1202| 1.25M| jvp_string_free(string); 1203| 1.25M| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&news->refcnt}}; ------------------ | | 1087| 1.25M|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 1.25M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 1.25M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 1.25M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1204| 1.25M| return r; 1205| 1.25M| } 1206| 15.9M|} jv.c:jvp_string_remaining_space: 1172| 15.6M|static uint32_t jvp_string_remaining_space(jvp_string* s) { 1173| 15.6M| assert(s->alloc_length >= jvp_string_length(s)); ------------------ | Branch (1173:3): [True: 0, False: 15.6M] | Branch (1173:3): [True: 15.6M, False: 0] ------------------ 1174| 15.6M| uint32_t r = s->alloc_length - jvp_string_length(s); 1175| 15.6M| return r; 1176| 15.6M|} jv.c:jvp_string_hash: 1240| 33.9M|static uint32_t jvp_string_hash(jv jstr) { 1241| 33.9M| jvp_string* str = jvp_string_ptr(jstr); 1242| 33.9M| if (str->length_hashed & 1) ------------------ | Branch (1242:7): [True: 29.2M, False: 4.67M] ------------------ 1243| 29.2M| return str->hash; 1244| | 1245| | /* The following is based on MurmurHash3. 1246| | MurmurHash3 was written by Austin Appleby, and is placed 1247| | in the public domain. */ 1248| | 1249| 4.67M| const uint8_t* data = (const uint8_t*)str->data; 1250| 4.67M| int len = (int)jvp_string_length(str); 1251| 4.67M| const int nblocks = len / 4; 1252| | 1253| 4.67M| uint32_t h1 = jvp_hash_seed(); 1254| | 1255| 4.67M| const uint32_t c1 = 0xcc9e2d51; 1256| 4.67M| const uint32_t c2 = 0x1b873593; 1257| 4.67M| const uint32_t* blocks = (const uint32_t *)(data + nblocks*4); 1258| | 1259| 14.9M| for(int i = -nblocks; i; i++) { ------------------ | Branch (1259:25): [True: 10.2M, False: 4.67M] ------------------ 1260| 10.2M| uint32_t k1 = blocks[i]; //FIXME: endianness/alignment 1261| | 1262| 10.2M| k1 *= c1; 1263| 10.2M| k1 = rotl32(k1,15); 1264| 10.2M| k1 *= c2; 1265| | 1266| 10.2M| h1 ^= k1; 1267| 10.2M| h1 = rotl32(h1,13); 1268| 10.2M| h1 = h1*5+0xe6546b64; 1269| 10.2M| } 1270| | 1271| 4.67M| const uint8_t* tail = (const uint8_t*)(data + nblocks*4); 1272| | 1273| 4.67M| uint32_t k1 = 0; 1274| | 1275| 4.67M| switch(len & 3) { ------------------ | Branch (1275:10): [True: 3.20M, False: 1.46M] ------------------ 1276| 1.01M| case 3: k1 ^= tail[2] << 16; ------------------ | Branch (1276:3): [True: 1.01M, False: 3.65M] ------------------ 1277| 1.01M| JQ_FALLTHROUGH; ------------------ | | 14| 1.01M|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1278| 2.11M| case 2: k1 ^= tail[1] << 8; ------------------ | Branch (1278:3): [True: 1.09M, False: 3.57M] ------------------ 1279| 2.11M| JQ_FALLTHROUGH; ------------------ | | 14| 2.11M|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1280| 3.20M| case 1: k1 ^= tail[0]; ------------------ | Branch (1280:3): [True: 1.09M, False: 3.57M] ------------------ 1281| 3.20M| k1 *= c1; k1 = rotl32(k1,15); k1 *= c2; h1 ^= k1; 1282| 4.67M| } 1283| | 1284| 4.67M| h1 ^= len; 1285| | 1286| 4.67M| h1 ^= h1 >> 16; 1287| 4.67M| h1 *= 0x85ebca6b; 1288| 4.67M| h1 ^= h1 >> 13; 1289| 4.67M| h1 *= 0xc2b2ae35; 1290| 4.67M| h1 ^= h1 >> 16; 1291| | 1292| 4.67M| str->length_hashed |= 1; 1293| 4.67M| str->hash = h1; 1294| | 1295| 4.67M| return h1; 1296| 4.67M|} jv.c:jvp_hash_seed: 1231| 4.67M|static uint32_t jvp_hash_seed(void) { 1232| 4.67M| pthread_once(&hash_seed_once, jvp_hash_seed_init); 1233| 4.67M| return hash_seed; 1234| 4.67M|} jv.c:jvp_hash_seed_init: 1211| 1|static void jvp_hash_seed_init(void) { 1212| 1| uint32_t seed; 1213| |#if defined(HAVE_ARC4RANDOM) 1214| | seed = arc4random(); 1215| |#elif defined(HAVE_GETENTROPY) 1216| 1| if (getentropy(&seed, sizeof(seed)) != 0) ------------------ | Branch (1216:7): [True: 0, False: 1] ------------------ 1217| 0| seed = (uint32_t)getpid() ^ (uint32_t)time(NULL); 1218| |#else 1219| | int fd = open("/dev/urandom", O_RDONLY); 1220| | if (fd >= 0) { 1221| | if (read(fd, &seed, sizeof(seed)) != 4) 1222| | seed = (uint32_t)getpid() ^ (uint32_t)time(NULL); 1223| | close(fd); 1224| | } else { 1225| | seed = (uint32_t)getpid() ^ (uint32_t)time(NULL); 1226| | } 1227| |#endif 1228| 1| hash_seed = seed; 1229| 1|} jv.c:rotl32: 1236| 23.7M|static uint32_t rotl32 (uint32_t x, int8_t r){ 1237| 23.7M| return (x << r) | (x >> (32 - r)); 1238| 23.7M|} jv.c:jvp_clamp_slice_params: 918| 8.19M|{ 919| 8.19M| if (*pstart < 0) *pstart = len + *pstart; ------------------ | Branch (919:7): [True: 0, False: 8.19M] ------------------ 920| 8.19M| if (*pend < 0) *pend = len + *pend; ------------------ | Branch (920:7): [True: 0, False: 8.19M] ------------------ 921| | 922| 8.19M| if (*pstart < 0) *pstart = 0; ------------------ | Branch (922:7): [True: 0, False: 8.19M] ------------------ 923| 8.19M| if (*pstart > len) *pstart = len; ------------------ | Branch (923:7): [True: 0, False: 8.19M] ------------------ 924| 8.19M| if (*pend > len) *pend = len; ------------------ | Branch (924:7): [True: 0, False: 8.19M] ------------------ 925| 8.19M| if (*pend < *pstart) *pend = *pstart; ------------------ | Branch (925:7): [True: 0, False: 8.19M] ------------------ 926| 8.19M|} jv.c:jvp_object_new: 1615| 2.47M|static jv jvp_object_new(int size) { 1616| | // Allocates an object of (size) slots and (size*2) hash buckets. 1617| | 1618| | // size must be a power of two 1619| 2.47M| assert(size > 0 && (size & (size - 1)) == 0); ------------------ | Branch (1619:3): [True: 0, False: 2.47M] | Branch (1619:3): [True: 0, False: 0] | Branch (1619:3): [True: 2.47M, False: 0] | Branch (1619:3): [True: 2.47M, False: 0] ------------------ 1620| | 1621| 2.47M| jvp_object* obj = jv_mem_alloc(sizeof(jvp_object) + 1622| 2.47M| sizeof(struct object_slot) * size + 1623| 2.47M| sizeof(int) * (size * 2)); 1624| 2.47M| obj->refcnt.count = 1; 1625| 25.8M| for (int i=0; ielements[i].next = i - 1; 1627| 23.3M| obj->elements[i].string = JV_NULL; 1628| 23.3M| obj->elements[i].hash = 0; 1629| 23.3M| obj->elements[i].value = JV_NULL; 1630| 23.3M| } 1631| 2.47M| obj->next_free = 0; 1632| 2.47M| int* hashbuckets = (int*)(&obj->elements[size]); 1633| 49.2M| for (int i=0; irefcnt}}; ------------------ | | 1598| 2.47M|#define JVP_FLAGS_OBJECT JVP_MAKE_FLAGS(JV_KIND_OBJECT, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 2.47M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 2.47M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 2.47M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1637| 2.47M| return r; 1638| 2.47M|} jv.c:jvp_object_read: 1698| 3.95M|static jv* jvp_object_read(jv object, jv key) { 1699| 3.95M| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1699:3): [True: 0, False: 3.95M] | Branch (1699:3): [True: 3.95M, False: 0] ------------------ 1700| 3.95M| int* bucket = jvp_object_find_bucket(object, key); 1701| 3.95M| struct object_slot* slot = jvp_object_find_slot(object, key, bucket); 1702| 3.95M| if (slot == 0) return 0; ------------------ | Branch (1702:7): [True: 28.0k, False: 3.92M] ------------------ 1703| 3.92M| else return &slot->value; 1704| 3.95M|} jv.c:jvp_object_find_bucket: 1659| 13.3M|static int* jvp_object_find_bucket(jv object, jv key) { 1660| 13.3M| return jvp_object_buckets(object) + (jvp_object_mask(object) & jvp_string_hash(key)); 1661| 13.3M|} jv.c:jvp_object_buckets: 1655| 15.3M|static int* jvp_object_buckets(jv o) { 1656| 15.3M| return (int*)(&jvp_object_ptr(o)->elements[o.size]); 1657| 15.3M|} jv.c:jvp_object_mask: 1645| 13.3M|static uint32_t jvp_object_mask(jv o) { 1646| 13.3M| assert(JVP_HAS_KIND(o, JV_KIND_OBJECT)); ------------------ | Branch (1646:3): [True: 0, False: 13.3M] | Branch (1646:3): [True: 13.3M, False: 0] ------------------ 1647| 13.3M| return (o.size * 2) - 1; 1648| 13.3M|} jv.c:jvp_object_find_slot: 1673| 13.3M|static struct object_slot* jvp_object_find_slot(jv object, jv keystr, int* bucket) { 1674| 13.3M| uint32_t hash = jvp_string_hash(keystr); 1675| 13.3M| for (struct object_slot* curr = jvp_object_get_slot(object, *bucket); 1676| 14.4M| curr; ------------------ | Branch (1676:8): [True: 7.04M, False: 7.37M] ------------------ 1677| 13.3M| curr = jvp_object_next_slot(object, curr)) { 1678| 7.04M| if (curr->hash == hash && jvp_string_equal(keystr, curr->string)) { ------------------ | Branch (1678:9): [True: 5.93M, False: 1.11M] | Branch (1678:31): [True: 5.93M, False: 0] ------------------ 1679| 5.93M| return curr; 1680| 5.93M| } 1681| 7.04M| } 1682| 7.37M| return 0; 1683| 13.3M|} jv.c:jvp_string_equal: 1299| 5.97M|static int jvp_string_equal(jv a, jv b) { 1300| 5.97M| assert(JVP_HAS_KIND(a, JV_KIND_STRING)); ------------------ | Branch (1300:3): [True: 0, False: 5.97M] | Branch (1300:3): [True: 5.97M, False: 0] ------------------ 1301| 5.97M| assert(JVP_HAS_KIND(b, JV_KIND_STRING)); ------------------ | Branch (1301:3): [True: 0, False: 5.97M] | Branch (1301:3): [True: 5.97M, False: 0] ------------------ 1302| 5.97M| jvp_string* stra = jvp_string_ptr(a); 1303| 5.97M| jvp_string* strb = jvp_string_ptr(b); 1304| 5.97M| if (jvp_string_length(stra) != jvp_string_length(strb)) return 0; ------------------ | Branch (1304:7): [True: 15.7k, False: 5.96M] ------------------ 1305| 5.96M| return memcmp(stra->data, strb->data, jvp_string_length(stra)) == 0; 1306| 5.97M|} jv.c:jvp_object_next_slot: 1669| 1.11M|static struct object_slot* jvp_object_next_slot(jv object, struct object_slot* slot) { 1670| 1.11M| return jvp_object_get_slot(object, slot->next); 1671| 1.11M|} jv.c:jvp_object_write: 1755| 7.33M|static int jvp_object_write(jv* object, jv key, jv **valpp) { 1756| 7.33M| *object = jvp_object_unshare(*object); 1757| 7.33M| int* bucket = jvp_object_find_bucket(*object, key); 1758| 7.33M| struct object_slot* slot = jvp_object_find_slot(*object, key, bucket); 1759| 7.33M| if (slot) { ------------------ | Branch (1759:7): [True: 2.00M, False: 5.33M] ------------------ 1760| | // already has the key 1761| 2.00M| jvp_string_free(key); 1762| 2.00M| *valpp = &slot->value; 1763| 2.00M| return 1; 1764| 2.00M| } 1765| 5.33M| slot = jvp_object_add_slot(*object, key, bucket); 1766| 5.33M| if (slot) { ------------------ | Branch (1766:7): [True: 5.28M, False: 44.5k] ------------------ 1767| 5.28M| slot->value = jv_invalid(); 1768| 5.28M| } else { 1769| 44.5k| if (!jvp_object_rehash(object)) { ------------------ | Branch (1769:9): [True: 0, False: 44.5k] ------------------ 1770| 0| jvp_string_free(key); 1771| 0| *valpp = NULL; 1772| 0| return 0; 1773| 0| } 1774| 44.5k| bucket = jvp_object_find_bucket(*object, key); 1775| 44.5k| assert(!jvp_object_find_slot(*object, key, bucket)); ------------------ | Branch (1775:5): [True: 0, False: 44.5k] | Branch (1775:5): [True: 44.5k, False: 0] ------------------ 1776| 44.5k| slot = jvp_object_add_slot(*object, key, bucket); 1777| 44.5k| assert(slot); ------------------ | Branch (1777:5): [True: 0, False: 44.5k] | Branch (1777:5): [True: 44.5k, False: 0] ------------------ 1778| 44.5k| slot->value = jv_invalid(); 1779| 44.5k| } 1780| 5.33M| *valpp = &slot->value; 1781| 5.33M| return 1; 1782| 5.33M|} jv.c:jvp_object_unshare: 1729| 7.33M|static jv jvp_object_unshare(jv object) { 1730| 7.33M| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1730:3): [True: 0, False: 7.33M] | Branch (1730:3): [True: 7.33M, False: 0] ------------------ 1731| 7.33M| if (jvp_refcnt_unshared(object.u.ptr)) ------------------ | Branch (1731:7): [True: 6.30M, False: 1.03M] ------------------ 1732| 6.30M| return object; 1733| | 1734| 1.03M| jv new_object = jvp_object_new(jvp_object_size(object)); 1735| 1.03M| jvp_object_ptr(new_object)->next_free = jvp_object_ptr(object)->next_free; 1736| 9.31M| for (int i=0; istring) != JV_KIND_NULL) { ------------------ | Branch (1740:9): [True: 228k, False: 8.05M] ------------------ 1741| 228k| new_slot->string = jv_copy(old_slot->string); 1742| 228k| new_slot->value = jv_copy(old_slot->value); 1743| 228k| } 1744| 8.28M| } 1745| | 1746| 1.03M| int* old_buckets = jvp_object_buckets(object); 1747| 1.03M| int* new_buckets = jvp_object_buckets(new_object); 1748| 1.03M| memcpy(new_buckets, old_buckets, sizeof(int) * jvp_object_size(new_object)*2); 1749| | 1750| 1.03M| jv_free(object); 1751| 1.03M| assert(jvp_refcnt_unshared(new_object.u.ptr)); ------------------ | Branch (1751:3): [True: 0, False: 1.03M] | Branch (1751:3): [True: 1.03M, False: 0] ------------------ 1752| 1.03M| return new_object; 1753| 1.03M|} jv.c:jvp_object_add_slot: 1685| 7.34M|static struct object_slot* jvp_object_add_slot(jv object, jv key, int* bucket) { 1686| 7.34M| jvp_object* o = jvp_object_ptr(object); 1687| 7.34M| int newslot_idx = o->next_free; 1688| 7.34M| if (newslot_idx == jvp_object_size(object)) return 0; ------------------ | Branch (1688:7): [True: 44.5k, False: 7.29M] ------------------ 1689| 7.29M| struct object_slot* newslot = jvp_object_get_slot(object, newslot_idx); 1690| 7.29M| o->next_free++; 1691| 7.29M| newslot->next = *bucket; 1692| 7.29M| *bucket = newslot_idx; 1693| 7.29M| newslot->hash = jvp_string_hash(key); 1694| 7.29M| newslot->string = key; 1695| 7.29M| return newslot; 1696| 7.34M|} jv.c:jvp_object_rehash: 1706| 44.5k|static int jvp_object_rehash(jv *objectp) { 1707| 44.5k| jv object = *objectp; 1708| 44.5k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1708:3): [True: 0, False: 44.5k] | Branch (1708:3): [True: 44.5k, False: 0] ------------------ 1709| 44.5k| assert(jvp_refcnt_unshared(object.u.ptr)); ------------------ | Branch (1709:3): [True: 0, False: 44.5k] | Branch (1709:3): [True: 44.5k, False: 0] ------------------ 1710| 44.5k| int size = jvp_object_size(object); 1711| 44.5k| if (size > INT_MAX >> 2) ------------------ | Branch (1711:7): [True: 0, False: 44.5k] ------------------ 1712| 0| return 0; 1713| 44.5k| jv new_object = jvp_object_new(size * 2); 1714| 2.01M| for (int i=0; istring) == JV_KIND_NULL) continue; ------------------ | Branch (1716:9): [True: 0, False: 1.96M] ------------------ 1717| 1.96M| int* new_bucket = jvp_object_find_bucket(new_object, slot->string); 1718| 1.96M| assert(!jvp_object_find_slot(new_object, slot->string, new_bucket)); ------------------ | Branch (1718:5): [True: 0, False: 1.96M] | Branch (1718:5): [True: 1.96M, False: 0] ------------------ 1719| 1.96M| struct object_slot* new_slot = jvp_object_add_slot(new_object, slot->string, new_bucket); 1720| 1.96M| assert(new_slot); ------------------ | Branch (1720:5): [True: 0, False: 1.96M] | Branch (1720:5): [True: 1.96M, False: 0] ------------------ 1721| 1.96M| new_slot->value = slot->value; 1722| 1.96M| } 1723| | // references are transported, just drop the old table 1724| 44.5k| jv_mem_free(jvp_object_ptr(object)); 1725| 44.5k| *objectp = new_object; 1726| 44.5k| return 1; 1727| 44.5k|} jv.c:jvp_object_delete: 1784| 8|static int jvp_object_delete(jv* object, jv key) { 1785| 8| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1785:3): [True: 0, False: 8] | Branch (1785:3): [True: 8, False: 0] ------------------ 1786| 8| *object = jvp_object_unshare(*object); 1787| 8| int* bucket = jvp_object_find_bucket(*object, key); 1788| 8| int* prev_ptr = bucket; 1789| 8| uint32_t hash = jvp_string_hash(key); 1790| 8| for (struct object_slot* curr = jvp_object_get_slot(*object, *bucket); 1791| 11| curr; ------------------ | Branch (1791:8): [True: 4, False: 7] ------------------ 1792| 8| curr = jvp_object_next_slot(*object, curr)) { 1793| 4| if (hash == curr->hash && jvp_string_equal(key, curr->string)) { ------------------ | Branch (1793:9): [True: 1, False: 3] | Branch (1793:31): [True: 1, False: 0] ------------------ 1794| 1| *prev_ptr = curr->next; 1795| 1| jvp_string_free(curr->string); 1796| 1| curr->string = JV_NULL; 1797| 1| jv_free(curr->value); 1798| 1| return 1; 1799| 1| } 1800| 3| prev_ptr = &curr->next; 1801| 3| } 1802| 7| return 0; 1803| 8|} jv.c:jvp_object_length: 1805| 139k|static int jvp_object_length(jv object) { 1806| 139k| int n = 0; 1807| 3.50M| for (int i=0; istring) != JV_KIND_NULL) n++; ------------------ | Branch (1809:9): [True: 2.12M, False: 1.24M] ------------------ 1810| 3.36M| } 1811| 139k| return n; 1812| 139k|} jv.c:jvp_object_size: 1650| 95.4M|static int jvp_object_size(jv o) { 1651| 95.4M| assert(JVP_HAS_KIND(o, JV_KIND_OBJECT)); ------------------ | Branch (1651:3): [True: 0, False: 95.4M] | Branch (1651:3): [True: 95.4M, False: 0] ------------------ 1652| 95.4M| return o.size; 1653| 95.4M|} jv.c:jvp_object_get_slot: 1663| 74.7M|static struct object_slot* jvp_object_get_slot(jv object, int slot) { 1664| 74.7M| assert(slot == -1 || (slot >= 0 && slot < jvp_object_size(object))); ------------------ | Branch (1664:3): [True: 0, False: 0] | Branch (1664:3): [True: 0, False: 0] | Branch (1664:3): [True: 74.7M, False: 0] | Branch (1664:3): [True: 67.4M, False: 0] | Branch (1664:3): [True: 67.4M, False: 0] | Branch (1664:3): [True: 7.37M, False: 67.4M] ------------------ 1665| 74.7M| if (slot == -1) return 0; ------------------ | Branch (1665:7): [True: 7.37M, False: 67.4M] ------------------ 1666| 67.4M| else return &jvp_object_ptr(object)->elements[slot]; 1667| 74.7M|} jv.c:jvp_refcnt_inc: 63| 466M|static void jvp_refcnt_inc(jv_refcnt* c) { 64| 466M| c->count++; 65| 466M|} jv.c:jvp_refcnt_dec: 67| 504M|static int jvp_refcnt_dec(jv_refcnt* c) { 68| 504M| c->count--; 69| 504M| return c->count == 0; 70| 504M|} jv.c:jvp_array_ptr: 827| 175M|static jvp_array* jvp_array_ptr(jv a) { 828| 175M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (828:3): [True: 0, False: 175M] | Branch (828:3): [True: 175M, False: 0] ------------------ 829| 175M| return (jvp_array*)a.u.ptr; 830| 175M|} jv.c:jvp_string_free: 1161| 35.7M|static void jvp_string_free(jv js) { 1162| 35.7M| jvp_string* s = jvp_string_ptr(js); 1163| 35.7M| if (jvp_refcnt_dec(&s->refcnt)) { ------------------ | Branch (1163:7): [True: 14.2M, False: 21.5M] ------------------ 1164| 14.2M| jv_mem_free(s); 1165| 14.2M| } 1166| 35.7M|} jv.c:jvp_object_ptr: 1640| 94.6M|static jvp_object* jvp_object_ptr(jv o) { 1641| 94.6M| assert(JVP_HAS_KIND(o, JV_KIND_OBJECT)); ------------------ | Branch (1641:3): [True: 0, False: 94.6M] | Branch (1641:3): [True: 94.6M, False: 0] ------------------ 1642| 94.6M| return (jvp_object*)o.u.ptr; 1643| 94.6M|} jv.c:jvp_number_free: 685| 303M|static void jvp_number_free(jv j) { 686| 303M| assert(JVP_HAS_KIND(j, JV_KIND_NUMBER)); ------------------ | Branch (686:3): [True: 0, False: 303M] | Branch (686:3): [True: 303M, False: 0] ------------------ 687| 303M|#ifdef USE_DECNUM 688| 303M| if (JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL) && jvp_refcnt_dec(j.u.ptr)) { ------------------ | | 92| 606M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 303M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 186M, False: 116M] | | | Branch (92:50): [True: 303M, Folded] | | ------------------ ------------------ | Branch (688:53): [True: 8.39M, False: 178M] ------------------ 689| 8.39M| jvp_literal_number* n = jvp_literal_number_ptr(j); 690| 8.39M| if (n->literal_data) { ------------------ | Branch (690:9): [True: 1.45M, False: 6.94M] ------------------ 691| 1.45M| jv_mem_free(n->literal_data); 692| 1.45M| } 693| 8.39M| jv_mem_free(n); 694| 8.39M| } 695| 303M|#endif 696| 303M|} jv.c:jvp_equal: 2087| 2.81M|static int jvp_equal(jv a, jv b, int depth) { 2088| 2.81M| if (depth > MAX_EQUAL_DEPTH) { ------------------ | | 2084| 2.81M|#define MAX_EQUAL_DEPTH (10000) ------------------ | Branch (2088:7): [True: 0, False: 2.81M] ------------------ 2089| 0| jv_free(a); 2090| 0| jv_free(b); 2091| 0| return -1; 2092| 0| } 2093| 2.81M| int r; 2094| 2.81M| if (jv_get_kind(a) != jv_get_kind(b)) { ------------------ | Branch (2094:7): [True: 93.4k, False: 2.72M] ------------------ 2095| 93.4k| r = 0; 2096| 2.72M| } else if (JVP_IS_ALLOCATED(a) && ------------------ | | 95| 5.44M|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 1.43M, False: 1.28M] | | ------------------ ------------------ 2097| 1.43M| JVP_IS_ALLOCATED(b) && ------------------ | | 95| 4.15M|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 1.43M, False: 278] | | ------------------ ------------------ 2098| 1.43M| a.kind_flags == b.kind_flags && ------------------ | Branch (2098:14): [True: 1.43M, False: 0] ------------------ 2099| 1.43M| a.size == b.size && ------------------ | Branch (2099:14): [True: 1.43M, False: 261] ------------------ 2100| 1.43M| a.u.ptr == b.u.ptr) { ------------------ | Branch (2100:14): [True: 1.19M, False: 240k] ------------------ 2101| 1.19M| r = 1; 2102| 1.52M| } else { 2103| 1.52M| switch (jv_get_kind(a)) { 2104| 1.45M| case JV_KIND_NUMBER: ------------------ | Branch (2104:5): [True: 1.45M, False: 68.9k] ------------------ 2105| 1.45M| r = jvp_number_equal(a, b); 2106| 1.45M| break; 2107| 12.4k| case JV_KIND_ARRAY: ------------------ | Branch (2107:5): [True: 12.4k, False: 1.51M] ------------------ 2108| 12.4k| r = jvp_array_equal(a, b, depth + 1); 2109| 12.4k| break; 2110| 48.7k| case JV_KIND_STRING: ------------------ | Branch (2110:5): [True: 48.7k, False: 1.47M] ------------------ 2111| 48.7k| r = jvp_string_equal(a, b); 2112| 48.7k| break; 2113| 4.07k| case JV_KIND_OBJECT: ------------------ | Branch (2113:5): [True: 4.07k, False: 1.51M] ------------------ 2114| 4.07k| r = jvp_object_equal(a, b, depth + 1); 2115| 4.07k| break; 2116| 3.65k| default: ------------------ | Branch (2116:5): [True: 3.65k, False: 1.51M] ------------------ 2117| 3.65k| r = 1; 2118| 3.65k| break; 2119| 1.52M| } 2120| 1.52M| } 2121| 2.81M| jv_free(a); 2122| 2.81M| jv_free(b); 2123| 2.81M| return r; 2124| 2.81M|} jv.c:jvp_number_equal: 804| 1.45M|static int jvp_number_equal(jv a, jv b) { 805| 1.45M| return jvp_number_cmp(a, b) == 0; 806| 1.45M|} jv.c:jvp_array_equal: 901| 12.4k|static int jvp_array_equal(jv a, jv b, int depth) { 902| 12.4k| if (jvp_array_length(a) != jvp_array_length(b)) ------------------ | Branch (902:7): [True: 165, False: 12.2k] ------------------ 903| 165| return 0; 904| 12.2k| if (jvp_array_ptr(a) == jvp_array_ptr(b) && ------------------ | Branch (904:7): [True: 0, False: 12.2k] ------------------ 905| 0| jvp_array_offset(a) == jvp_array_offset(b)) ------------------ | Branch (905:7): [True: 0, False: 0] ------------------ 906| 0| return 1; 907| 444k| for (int i=0; istring) == JV_KIND_NULL) continue; ------------------ | Branch (1819:9): [True: 21.0k, False: 26.3k] ------------------ 1820| 26.3k| jv* slot2 = jvp_object_read(o2, slot->string); 1821| 26.3k| if (!slot2) return 0; ------------------ | Branch (1821:9): [True: 522, False: 25.7k] ------------------ 1822| | // FIXME: do less refcounting here 1823| 25.7k| int r = jvp_equal(jv_copy(slot->value), jv_copy(*slot2), depth); 1824| 25.7k| if (r <= 0) return r; ------------------ | Branch (1824:9): [True: 604, False: 25.1k] ------------------ 1825| 25.1k| len1++; 1826| 25.1k| } 1827| 2.95k| return len1 == len2; 1828| 4.07k|} jv.c:jvp_contains: 2153| 954|static int jvp_contains(jv a, jv b, int depth) { 2154| 954| if (depth > MAX_CONTAINS_DEPTH) { ------------------ | | 2150| 954|#define MAX_CONTAINS_DEPTH (10000) ------------------ | Branch (2154:7): [True: 0, False: 954] ------------------ 2155| 0| jv_free(a); 2156| 0| jv_free(b); 2157| 0| return -1; 2158| 0| } 2159| 954| int r = 1; 2160| 954| if (jv_get_kind(a) != jv_get_kind(b)) { ------------------ | Branch (2160:7): [True: 238, False: 716] ------------------ 2161| 238| r = 0; 2162| 716| } else if (JVP_HAS_KIND(a, JV_KIND_OBJECT)) { ------------------ | | 93| 716|#define JVP_HAS_KIND(j, kind) (JVP_KIND(j) == kind) | | ------------------ | | | | 90| 716|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 89| 716|#define JVP_FLAGS(j) ((j).kind_flags) | | | | ------------------ | | | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 77| 716|#define KIND_MASK 0xF | | | | ------------------ | | ------------------ | | | Branch (93:33): [True: 2, False: 714] | | ------------------ ------------------ 2163| 2| r = jvp_object_contains(a, b, depth + 1); 2164| 714| } else if (JVP_HAS_KIND(a, JV_KIND_ARRAY)) { ------------------ | | 93| 714|#define JVP_HAS_KIND(j, kind) (JVP_KIND(j) == kind) | | ------------------ | | | | 90| 714|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 89| 714|#define JVP_FLAGS(j) ((j).kind_flags) | | | | ------------------ | | | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 77| 714|#define KIND_MASK 0xF | | | | ------------------ | | ------------------ | | | Branch (93:33): [True: 35, False: 679] | | ------------------ ------------------ 2165| 35| r = jvp_array_contains(a, b, depth + 1); 2166| 679| } else if (JVP_HAS_KIND(a, JV_KIND_STRING)) { ------------------ | | 93| 679|#define JVP_HAS_KIND(j, kind) (JVP_KIND(j) == kind) | | ------------------ | | | | 90| 679|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 89| 679|#define JVP_FLAGS(j) ((j).kind_flags) | | | | ------------------ | | | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 77| 679|#define KIND_MASK 0xF | | | | ------------------ | | ------------------ | | | Branch (93:33): [True: 679, False: 0] | | ------------------ ------------------ 2167| 679| int b_len = jv_string_length_bytes(jv_copy(b)); 2168| 679| if (b_len != 0) { ------------------ | Branch (2168:9): [True: 295, False: 384] ------------------ 2169| 295| r = _jq_memmem(jv_string_value(a), jv_string_length_bytes(jv_copy(a)), 2170| 295| jv_string_value(b), b_len) != 0; 2171| 384| } else { 2172| 384| r = 1; 2173| 384| } 2174| 679| } else { 2175| 0| r = jv_equal(jv_copy(a), jv_copy(b)); 2176| 0| } 2177| 954| jv_free(a); 2178| 954| jv_free(b); 2179| 954| return r; 2180| 954|} jv.c:jvp_object_contains: 1830| 2|static int jvp_object_contains(jv a, jv b, int depth) { 1831| 2| assert(JVP_HAS_KIND(a, JV_KIND_OBJECT)); ------------------ | Branch (1831:3): [True: 0, False: 2] | Branch (1831:3): [True: 2, False: 0] ------------------ 1832| 2| assert(JVP_HAS_KIND(b, JV_KIND_OBJECT)); ------------------ | Branch (1832:3): [True: 0, False: 2] | Branch (1832:3): [True: 2, False: 0] ------------------ 1833| 2| int r = 1; 1834| | 1835| 2| jv_object_foreach(b, key, b_val) { ------------------ | | 159| 4| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (159:52): [True: 2, False: 2] | | ------------------ | | 160| 2| for (jv k, v; \ | | 161| 2| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (161:10): [True: 1, False: 1] | | | Branch (161:10): [True: 1, False: 1] | | ------------------ | | 162| 2| (k = jv_object_iter_key(t, jv_i__), \ | | 163| 1| v = jv_object_iter_value(t, jv_i__), \ | | 164| 1| 1) \ | | 165| 2| : 0; \ | | 166| 2| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 1836| 1| jv a_val = jv_object_get(jv_copy(a), key); 1837| | 1838| 1| r = jvp_contains(a_val, b_val, depth); 1839| | 1840| 1| if (r <= 0) break; ------------------ | Branch (1840:9): [True: 1, False: 0] ------------------ 1841| 1| } 1842| 2| return r; 1843| 2|} jv.c:jvp_array_contains: 931| 35|static int jvp_array_contains(jv a, jv b, int depth) { 932| 35| int r = 1; 933| 464| jv_array_foreach(b, bi, belem) { ------------------ | | 93| 35| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 70| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 35, False: 35] | | ------------------ | | 95| 35| for (jv x; \ | | 96| 471| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 464, False: 7] | | | Branch (96:10): [True: 464, False: 7] | | ------------------ | | 97| 471| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 436| i++) ------------------ 934| 464| int ri = 0; 935| 914| jv_array_foreach(a, ai, aelem) { ------------------ | | 93| 464| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 928| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 464, False: 464] | | ------------------ | | 95| 464| for (jv x; \ | | 96| 942| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 914, False: 28] | | | Branch (96:10): [True: 914, False: 28] | | ------------------ | | 97| 942| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 478| i++) ------------------ 936| 914| ri = jvp_contains(aelem, jv_copy(belem), depth); 937| 914| if (ri) break; ------------------ | Branch (937:11): [True: 436, False: 478] ------------------ 938| 914| } 939| 464| jv_free(belem); 940| 464| if (ri <= 0) { ------------------ | Branch (940:9): [True: 28, False: 436] ------------------ 941| 28| r = ri; 942| 28| break; 943| 28| } 944| 464| } 945| 35| return r; 946| 35|} jq_fuzz_fixed.cpp:_ZL11jv_is_valid2jv: 52| 14.2k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } execute.c:jv_is_valid: 52| 774M|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } jv.c:jv_is_valid: 52| 34.9M|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } jv_aux.c:jv_is_valid: 52| 33.6M|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } jv_parse.c:jv_is_valid: 52| 30.0M|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } linker.c:jv_is_valid: 52| 53.5k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } locfile.c:jv_is_valid: 52| 5|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } parser.c:jv_is_valid: 52| 1.30M|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } builtin.c:jv_is_valid: 52| 889k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } compile.c:jv_is_valid: 52| 15.2k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } jv_nomem_handler: 92| 20.3k|void jv_nomem_handler(jv_nomem_handler_f handler, void *data) { 93| 20.3k| pthread_once(&mem_once, tsd_init); // cannot fail 94| 20.3k| tsd_init_nomem_handler(); 95| | 96| 20.3k| struct nomem_handler *nomem_handler; 97| | 98| 20.3k| nomem_handler = pthread_getspecific(nomem_handler_key); 99| 20.3k| if (nomem_handler == NULL) { ------------------ | Branch (99:7): [True: 0, False: 20.3k] ------------------ 100| 0| handler(data); 101| 0| fprintf(stderr, "jq: error: cannot allocate memory\n"); 102| 0| abort(); 103| 0| } 104| 20.3k| nomem_handler->handler = handler; 105| 20.3k| nomem_handler->data = data; 106| 20.3k|} jv_mem_alloc: 141| 67.8M|void* jv_mem_alloc(size_t sz) { 142| 67.8M| void* p = malloc(sz); 143| 67.8M| if (!p) { ------------------ | Branch (143:7): [True: 0, False: 67.8M] ------------------ 144| 0| memory_exhausted(); 145| 0| } 146| 67.8M| return p; 147| 67.8M|} jv_mem_alloc_unguarded: 149| 7.65k|void* jv_mem_alloc_unguarded(size_t sz) { 150| 7.65k| return malloc(sz); 151| 7.65k|} jv_mem_calloc: 153| 124k|void* jv_mem_calloc(size_t nemb, size_t sz) { 154| 124k| assert(nemb > 0 && sz > 0); ------------------ | Branch (154:3): [True: 0, False: 124k] | Branch (154:3): [True: 0, False: 0] | Branch (154:3): [True: 124k, False: 0] | Branch (154:3): [True: 124k, False: 0] ------------------ 155| 124k| void* p = calloc(nemb, sz); 156| 124k| if (!p) { ------------------ | Branch (156:7): [True: 0, False: 124k] ------------------ 157| 0| memory_exhausted(); 158| 0| } 159| 124k| return p; 160| 124k|} jv_mem_free: 179| 648M|void jv_mem_free(void* p) { 180| 648M| free(p); 181| 648M|} jv_mem_realloc: 183| 8.57M|void* jv_mem_realloc(void* p, size_t sz) { 184| 8.57M| p = realloc(p, sz); 185| 8.57M| if (!p) { ------------------ | Branch (185:7): [True: 0, False: 8.57M] ------------------ 186| 0| memory_exhausted(); 187| 0| } 188| 8.57M| return p; 189| 8.57M|} jv_alloc.c:tsd_init: 70| 1|static void tsd_init(void) { 71| 1| if (pthread_key_create(&nomem_handler_key, tsd_fini_thread) != 0) { ------------------ | Branch (71:7): [True: 0, False: 1] ------------------ 72| 0| fprintf(stderr, "jq: error: cannot create thread specific key"); 73| 0| abort(); 74| 0| } 75| 1| if (atexit(tsd_fini) != 0) { ------------------ | Branch (75:7): [True: 0, False: 1] ------------------ 76| | fprintf(stderr, "jq: error: cannot set an exit handler"); 77| 0| abort(); 78| 0| } 79| 1|} jv_alloc.c:tsd_fini: 54| 1|static void tsd_fini(void) { 55| 1| struct nomem_handler *nomem_handler; 56| 1| nomem_handler = pthread_getspecific(nomem_handler_key); 57| 1| if (nomem_handler) { ------------------ | Branch (57:7): [True: 1, False: 0] ------------------ 58| | (void) pthread_setspecific(nomem_handler_key, NULL); 59| 1| free(nomem_handler); 60| 1| } 61| 1|} jv_alloc.c:tsd_init_nomem_handler: 82| 20.3k|{ 83| 20.3k| if (pthread_getspecific(nomem_handler_key) == NULL) { ------------------ | Branch (83:7): [True: 1, False: 20.3k] ------------------ 84| 1| struct nomem_handler *nomem_handler = calloc(1, sizeof(struct nomem_handler)); 85| 1| if (pthread_setspecific(nomem_handler_key, nomem_handler) != 0) { ------------------ | Branch (85:9): [True: 0, False: 1] ------------------ 86| | fprintf(stderr, "jq: error: cannot set thread specific data"); 87| 0| abort(); 88| 0| } 89| 1| } 90| 20.3k|} jv_get: 98| 12.7M|jv jv_get(jv t, jv k) { 99| 12.7M| jv v; 100| 12.7M| if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) { ------------------ | Branch (100:7): [True: 2.69M, False: 10.0M] | Branch (100:43): [True: 2.69M, False: 6] ------------------ 101| 2.69M| v = jv_object_get(t, k); 102| 2.69M| if (!jv_is_valid(v)) { ------------------ | Branch (102:9): [True: 4.57k, False: 2.68M] ------------------ 103| 4.57k| jv_free(v); 104| 4.57k| v = jv_null(); 105| 4.57k| } 106| 10.0M| } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) { ------------------ | Branch (106:14): [True: 9.97M, False: 104k] | Branch (106:49): [True: 9.53M, False: 434k] ------------------ 107| 9.53M| if (jvp_number_is_nan(k)) { ------------------ | Branch (107:9): [True: 0, False: 9.53M] ------------------ 108| 0| jv_free(t); 109| 0| v = jv_null(); 110| 9.53M| } else { 111| 9.53M| double didx = jv_number_value(k); 112| 9.53M| if (didx < INT_MIN) didx = INT_MIN; ------------------ | Branch (112:11): [True: 0, False: 9.53M] ------------------ 113| 9.53M| if (didx > INT_MAX) didx = INT_MAX; ------------------ | Branch (113:11): [True: 0, False: 9.53M] ------------------ 114| 9.53M| int idx = (int)didx; 115| 9.53M| if (idx < 0) ------------------ | Branch (115:11): [True: 42, False: 9.53M] ------------------ 116| 42| idx += jv_array_length(jv_copy(t)); 117| 9.53M| v = jv_array_get(t, idx); 118| 9.53M| if (!jv_is_valid(v)) { ------------------ | Branch (118:11): [True: 466k, False: 9.07M] ------------------ 119| 466k| jv_free(v); 120| 466k| v = jv_null(); 121| 466k| } 122| 9.53M| } 123| 9.53M| jv_free(k); 124| 9.53M| } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_OBJECT) { ------------------ | Branch (124:14): [True: 434k, False: 104k] | Branch (124:49): [True: 434k, False: 415] ------------------ 125| 434k| int start, end; 126| 434k| jv e = parse_slice(jv_copy(t), k, &start, &end); 127| 434k| if (jv_get_kind(e) == JV_KIND_TRUE) { ------------------ | Branch (127:9): [True: 434k, False: 1] ------------------ 128| 434k| v = jv_array_slice(t, start, end); 129| 434k| } else { 130| 1| jv_free(t); 131| 1| v = e; 132| 1| } 133| 434k| } else if (jv_get_kind(t) == JV_KIND_STRING && jv_get_kind(k) == JV_KIND_OBJECT) { ------------------ | Branch (133:14): [True: 99.9k, False: 4.80k] | Branch (133:50): [True: 99.7k, False: 221] ------------------ 134| 99.7k| int start, end; 135| 99.7k| jv e = parse_slice(jv_copy(t), k, &start, &end); 136| 99.7k| if (jv_get_kind(e) == JV_KIND_TRUE) { ------------------ | Branch (136:9): [True: 99.7k, False: 0] ------------------ 137| 99.7k| v = jv_string_slice(t, start, end); 138| 99.7k| } else { 139| 0| jv_free(t); 140| 0| v = e; 141| 0| } 142| 99.7k| } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_ARRAY) { ------------------ | Branch (142:14): [True: 415, False: 4.61k] | Branch (142:49): [True: 59, False: 356] ------------------ 143| 59| v = jv_array_indexes(t, k); 144| 4.96k| } else if (jv_get_kind(t) == JV_KIND_NULL && ------------------ | Branch (144:14): [True: 3.55k, False: 1.40k] ------------------ 145| 3.55k| (jv_get_kind(k) == JV_KIND_STRING || ------------------ | Branch (145:15): [True: 1.62k, False: 1.93k] ------------------ 146| 1.93k| jv_get_kind(k) == JV_KIND_NUMBER || ------------------ | Branch (146:15): [True: 1.93k, False: 2] ------------------ 147| 3.55k| jv_get_kind(k) == JV_KIND_OBJECT)) { ------------------ | Branch (147:15): [True: 1, False: 1] ------------------ 148| 3.55k| jv_free(t); 149| 3.55k| jv_free(k); 150| 3.55k| v = jv_null(); 151| 3.55k| } else { 152| 1.41k| char errbuf[30]; 153| 1.41k| v = jv_invalid_with_msg(jv_string_fmt( 154| 1.41k| "Cannot index %s with %s (%s)", 155| 1.41k| jv_kind_name(jv_get_kind(t)), 156| 1.41k| jv_kind_name(jv_get_kind(k)), 157| 1.41k| jv_dump_string_trunc(jv_copy(k), errbuf, sizeof(errbuf)))); 158| 1.41k| jv_free(t); 159| 1.41k| jv_free(k); 160| 1.41k| } 161| 12.7M| return v; 162| 12.7M|} jv_set: 164| 6.63M|jv jv_set(jv t, jv k, jv v) { 165| 6.63M| if (!jv_is_valid(v)) { ------------------ | Branch (165:7): [True: 1, False: 6.63M] ------------------ 166| 1| jv_free(t); 167| 1| jv_free(k); 168| 1| return v; 169| 1| } 170| 6.63M| int isnull = jv_get_kind(t) == JV_KIND_NULL; 171| 6.63M| if (jv_get_kind(k) == JV_KIND_STRING && ------------------ | Branch (171:7): [True: 1.95M, False: 4.67M] ------------------ 172| 1.95M| (jv_get_kind(t) == JV_KIND_OBJECT || isnull)) { ------------------ | Branch (172:8): [True: 1.95M, False: 1.55k] | Branch (172:44): [True: 1.55k, False: 0] ------------------ 173| 1.95M| if (isnull) t = jv_object(); ------------------ | Branch (173:9): [True: 1.55k, False: 1.95M] ------------------ 174| 1.95M| t = jv_object_set(t, k, v); 175| 4.67M| } else if (jv_get_kind(k) == JV_KIND_NUMBER && ------------------ | Branch (175:14): [True: 4.67M, False: 0] ------------------ 176| 4.67M| (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) { ------------------ | Branch (176:15): [True: 4.67M, False: 1.92k] | Branch (176:50): [True: 1.92k, False: 0] ------------------ 177| 4.67M| if (jvp_number_is_nan(k)) { ------------------ | Branch (177:9): [True: 0, False: 4.67M] ------------------ 178| 0| jv_free(t); 179| 0| jv_free(k); 180| 0| jv_free(v); 181| 0| t = jv_invalid_with_msg(jv_string("Cannot set array element at NaN index")); 182| 4.67M| } else { 183| 4.67M| double didx = jv_number_value(k); 184| 4.67M| if (didx < INT_MIN) didx = INT_MIN; ------------------ | Branch (184:11): [True: 0, False: 4.67M] ------------------ 185| 4.67M| if (didx > INT_MAX) didx = INT_MAX; ------------------ | Branch (185:11): [True: 0, False: 4.67M] ------------------ 186| 4.67M| if (isnull) t = jv_array(); ------------------ | Branch (186:11): [True: 1.92k, False: 4.67M] ------------------ 187| 4.67M| t = jv_array_set(t, (int)didx, v); 188| 4.67M| jv_free(k); 189| 4.67M| } 190| 4.67M| } else if (jv_get_kind(k) == JV_KIND_OBJECT && ------------------ | Branch (190:14): [True: 0, False: 0] ------------------ 191| 0| (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) { ------------------ | Branch (191:15): [True: 0, False: 0] | Branch (191:50): [True: 0, False: 0] ------------------ 192| 0| if (isnull) t = jv_array(); ------------------ | Branch (192:9): [True: 0, False: 0] ------------------ 193| 0| int start, end; 194| 0| jv e = parse_slice(jv_copy(t), k, &start, &end); 195| 0| if (jv_get_kind(e) == JV_KIND_TRUE) { ------------------ | Branch (195:9): [True: 0, False: 0] ------------------ 196| 0| if (jv_get_kind(v) == JV_KIND_ARRAY) { ------------------ | Branch (196:11): [True: 0, False: 0] ------------------ 197| 0| int array_len = jv_array_length(jv_copy(t)); 198| 0| assert(0 <= start && start <= end && end <= array_len); ------------------ | Branch (198:9): [True: 0, False: 0] | Branch (198:9): [True: 0, False: 0] | Branch (198:9): [True: 0, False: 0] | Branch (198:9): [True: 0, False: 0] | Branch (198:9): [True: 0, False: 0] | Branch (198:9): [True: 0, False: 0] ------------------ 199| 0| int slice_len = end - start; 200| 0| int insert_len = jv_array_length(jv_copy(v)); 201| 0| if (slice_len < insert_len) { ------------------ | Branch (201:13): [True: 0, False: 0] ------------------ 202| | // array is growing 203| 0| int shift = insert_len - slice_len; 204| 0| for (int i = array_len - 1; i >= end && jv_is_valid(t); i--) { ------------------ | Branch (204:39): [True: 0, False: 0] | Branch (204:51): [True: 0, False: 0] ------------------ 205| 0| t = jv_array_set(t, i + shift, jv_array_get(jv_copy(t), i)); 206| 0| } 207| 0| } else if (slice_len > insert_len) { ------------------ | Branch (207:20): [True: 0, False: 0] ------------------ 208| | // array is shrinking 209| 0| int shift = slice_len - insert_len; 210| 0| for (int i = end; i < array_len && jv_is_valid(t); i++) { ------------------ | Branch (210:29): [True: 0, False: 0] | Branch (210:46): [True: 0, False: 0] ------------------ 211| 0| t = jv_array_set(t, i - shift, jv_array_get(jv_copy(t), i)); 212| 0| } 213| 0| if (jv_is_valid(t)) ------------------ | Branch (213:15): [True: 0, False: 0] ------------------ 214| 0| t = jv_array_slice(t, 0, array_len - shift); 215| 0| } 216| 0| for (int i = 0; i < insert_len && jv_is_valid(t); i++) { ------------------ | Branch (216:25): [True: 0, False: 0] | Branch (216:43): [True: 0, False: 0] ------------------ 217| 0| t = jv_array_set(t, start + i, jv_array_get(jv_copy(v), i)); 218| 0| } 219| 0| jv_free(v); 220| 0| } else { 221| 0| jv_free(t); 222| 0| jv_free(v); 223| 0| t = jv_invalid_with_msg(jv_string_fmt("A slice of an array can only be assigned another array")); 224| 0| } 225| 0| } else { 226| 0| jv_free(t); 227| 0| jv_free(v); 228| 0| t = e; 229| 0| } 230| 0| } else if (jv_get_kind(k) == JV_KIND_OBJECT && jv_get_kind(t) == JV_KIND_STRING) { ------------------ | Branch (230:14): [True: 0, False: 0] | Branch (230:50): [True: 0, False: 0] ------------------ 231| 0| jv_free(t); 232| 0| jv_free(k); 233| 0| jv_free(v); 234| | /* Well, why not? We should implement this... */ 235| 0| t = jv_invalid_with_msg(jv_string_fmt("Cannot update string slices")); 236| 0| } else { 237| 0| jv err = jv_invalid_with_msg(jv_string_fmt("Cannot update field at %s index of %s", 238| 0| jv_kind_name(jv_get_kind(k)), 239| 0| jv_kind_name(jv_get_kind(t)))); 240| 0| jv_free(t); 241| 0| jv_free(k); 242| 0| jv_free(v); 243| 0| t = err; 244| 0| } 245| 6.63M| return t; 246| 6.63M|} jv_has: 248| 15.2k|jv jv_has(jv t, jv k) { 249| 15.2k| assert(jv_is_valid(t)); ------------------ | Branch (249:3): [True: 0, False: 15.2k] | Branch (249:3): [True: 15.2k, False: 0] ------------------ 250| 15.2k| assert(jv_is_valid(k)); ------------------ | Branch (250:3): [True: 0, False: 15.2k] | Branch (250:3): [True: 15.2k, False: 0] ------------------ 251| 15.2k| jv ret; 252| 15.2k| if (jv_get_kind(t) == JV_KIND_NULL) { ------------------ | Branch (252:7): [True: 200, False: 15.0k] ------------------ 253| 200| jv_free(t); 254| 200| jv_free(k); 255| 200| ret = jv_false(); 256| 15.0k| } else if (jv_get_kind(t) == JV_KIND_OBJECT && ------------------ | Branch (256:14): [True: 2.96k, False: 12.0k] ------------------ 257| 2.96k| jv_get_kind(k) == JV_KIND_STRING) { ------------------ | Branch (257:14): [True: 2.95k, False: 1] ------------------ 258| 2.95k| jv elem = jv_object_get(t, k); 259| 2.95k| ret = jv_bool(jv_is_valid(elem)); 260| 2.95k| jv_free(elem); 261| 12.0k| } else if (jv_get_kind(t) == JV_KIND_ARRAY && ------------------ | Branch (261:14): [True: 12.0k, False: 6] ------------------ 262| 12.0k| jv_get_kind(k) == JV_KIND_NUMBER) { ------------------ | Branch (262:14): [True: 12.0k, False: 5] ------------------ 263| 12.0k| if (jvp_number_is_nan(k)) { ------------------ | Branch (263:9): [True: 249, False: 11.8k] ------------------ 264| 249| jv_free(t); 265| 249| ret = jv_false(); 266| 11.8k| } else { 267| 11.8k| jv elem = jv_array_get(t, (int)jv_number_value(k)); 268| 11.8k| ret = jv_bool(jv_is_valid(elem)); 269| 11.8k| jv_free(elem); 270| 11.8k| } 271| 12.0k| jv_free(k); 272| 12.0k| } else { 273| 11| ret = jv_invalid_with_msg(jv_string_fmt("Cannot check whether %s has a %s key", 274| 11| jv_kind_name(jv_get_kind(t)), 275| 11| jv_kind_name(jv_get_kind(k)))); 276| 11| jv_free(t); 277| 11| jv_free(k); 278| 11| } 279| 15.2k| return ret; 280| 15.2k|} jv_setpath: 390| 5.03M|jv jv_setpath(jv root, jv path, jv value) { 391| 5.03M| if (jv_get_kind(path) != JV_KIND_ARRAY) { ------------------ | Branch (391:7): [True: 0, False: 5.03M] ------------------ 392| 0| jv_free(value); 393| 0| jv_free(root); 394| 0| jv_free(path); 395| 0| return jv_invalid_with_msg(jv_string("Path must be specified as an array")); 396| 0| } 397| 5.03M| if (jv_array_length(jv_copy(path)) > MAX_PATH_DEPTH) { ------------------ | | 387| 5.03M|#define MAX_PATH_DEPTH (10000) ------------------ | Branch (397:7): [True: 0, False: 5.03M] ------------------ 398| 0| jv_free(value); 399| 0| jv_free(root); 400| 0| jv_free(path); 401| 0| return jv_invalid_with_msg(jv_string("Path too deep")); 402| 0| } 403| 5.03M| if (!jv_is_valid(root)){ ------------------ | Branch (403:7): [True: 0, False: 5.03M] ------------------ 404| 0| jv_free(value); 405| 0| jv_free(path); 406| 0| return root; 407| 0| } 408| 5.03M| if (jv_array_length(jv_copy(path)) == 0) { ------------------ | Branch (408:7): [True: 1.71M, False: 3.31M] ------------------ 409| 1.71M| jv_free(path); 410| 1.71M| jv_free(root); 411| 1.71M| return value; 412| 1.71M| } 413| 3.31M| jv pathcurr = jv_array_get(jv_copy(path), 0); 414| 3.31M| jv pathrest = jv_array_slice(path, 1, jv_array_length(jv_copy(path))); 415| | 416| | /* 417| | * We need to be careful not to make extra copies since that leads to 418| | * quadratic behavior (e.g., when growing large data structures in a 419| | * reduction with `setpath/2`, i.e., with `|=`. 420| | */ 421| 3.31M| if (jv_get_kind(pathcurr) == JV_KIND_OBJECT) { ------------------ | Branch (421:7): [True: 0, False: 3.31M] ------------------ 422| | // Assignment to slice -- dunno yet how to avoid the extra copy 423| 0| return jv_set(root, pathcurr, 424| 0| jv_setpath(jv_get(jv_copy(root), jv_copy(pathcurr)), pathrest, value)); 425| 0| } 426| | 427| 3.31M| jv subroot = jv_get(jv_copy(root), jv_copy(pathcurr)); 428| 3.31M| if (!jv_is_valid(subroot)) { ------------------ | Branch (428:7): [True: 5, False: 3.31M] ------------------ 429| 5| jv_free(root); 430| 5| jv_free(pathcurr); 431| 5| jv_free(pathrest); 432| 5| jv_free(value); 433| 5| return subroot; 434| 5| } 435| | 436| | // To avoid the extra copy we drop the reference from `root` by setting that 437| | // to null first. 438| 3.31M| root = jv_set(root, jv_copy(pathcurr), jv_null()); 439| 3.31M| if (!jv_is_valid(root)) { ------------------ | Branch (439:7): [True: 0, False: 3.31M] ------------------ 440| 0| jv_free(subroot); 441| 0| jv_free(pathcurr); 442| 0| jv_free(pathrest); 443| 0| jv_free(value); 444| 0| return root; 445| 0| } 446| 3.31M| return jv_set(root, pathcurr, jv_setpath(subroot, pathrest, value)); 447| 3.31M|} jv_getpath: 449| 3.08M|jv jv_getpath(jv root, jv path) { 450| 3.08M| if (jv_get_kind(path) != JV_KIND_ARRAY) { ------------------ | Branch (450:7): [True: 0, False: 3.08M] ------------------ 451| 0| jv_free(root); 452| 0| jv_free(path); 453| 0| return jv_invalid_with_msg(jv_string("Path must be specified as an array")); 454| 0| } 455| 3.08M| if (jv_array_length(jv_copy(path)) > MAX_PATH_DEPTH) { ------------------ | | 387| 3.08M|#define MAX_PATH_DEPTH (10000) ------------------ | Branch (455:7): [True: 0, False: 3.08M] ------------------ 456| 0| jv_free(root); 457| 0| jv_free(path); 458| 0| return jv_invalid_with_msg(jv_string("Path too deep")); 459| 0| } 460| 3.08M| if (!jv_is_valid(root)) { ------------------ | Branch (460:7): [True: 1, False: 3.08M] ------------------ 461| 1| jv_free(path); 462| 1| return root; 463| 1| } 464| 3.08M| if (jv_array_length(jv_copy(path)) == 0) { ------------------ | Branch (464:7): [True: 1.25M, False: 1.83M] ------------------ 465| 1.25M| jv_free(path); 466| 1.25M| return root; 467| 1.25M| } 468| 1.83M| jv pathcurr = jv_array_get(jv_copy(path), 0); 469| 1.83M| jv pathrest = jv_array_slice(path, 1, jv_array_length(jv_copy(path))); 470| 1.83M| return jv_getpath(jv_get(root, pathcurr), pathrest); 471| 3.08M|} jv_delpaths: 522| 119k|jv jv_delpaths(jv object, jv paths) { 523| 119k| if (jv_get_kind(paths) != JV_KIND_ARRAY) { ------------------ | Branch (523:7): [True: 0, False: 119k] ------------------ 524| 0| jv_free(object); 525| 0| jv_free(paths); 526| 0| return jv_invalid_with_msg(jv_string("Paths must be specified as an array")); 527| 0| } 528| 119k| paths = jv_sort(paths, jv_copy(paths)); 529| 119k| jv_array_foreach(paths, i, elem) { ------------------ | | 93| 119k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 239k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 119k, False: 119k] | | ------------------ | | 95| 119k| for (jv x; \ | | 96| 169k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 49.4k, False: 119k] | | | Branch (96:10): [True: 49.4k, False: 119k] | | ------------------ | | 97| 169k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 119k| i++) ------------------ 530| 49.4k| if (jv_get_kind(elem) != JV_KIND_ARRAY) { ------------------ | Branch (530:9): [True: 0, False: 49.4k] ------------------ 531| 0| jv_free(object); 532| 0| jv_free(paths); 533| 0| jv err = jv_invalid_with_msg(jv_string_fmt("Path must be specified as array, not %s", 534| 0| jv_kind_name(jv_get_kind(elem)))); 535| 0| jv_free(elem); 536| 0| return err; 537| 0| } 538| 49.4k| if (jv_array_length(jv_copy(elem)) > MAX_PATH_DEPTH) { ------------------ | | 387| 49.4k|#define MAX_PATH_DEPTH (10000) ------------------ | Branch (538:9): [True: 0, False: 49.4k] ------------------ 539| 0| jv_free(object); 540| 0| jv_free(paths); 541| 0| jv_free(elem); 542| 0| return jv_invalid_with_msg(jv_string("Path too deep")); 543| 0| } 544| 49.4k| jv_free(elem); 545| 49.4k| } 546| 119k| if (jv_array_length(jv_copy(paths)) == 0) { ------------------ | Branch (546:7): [True: 119k, False: 66] ------------------ 547| | // nothing is being deleted 548| 119k| jv_free(paths); 549| 119k| return object; 550| 119k| } 551| 66| if (jv_array_length(jv_array_get(jv_copy(paths), 0)) == 0) { ------------------ | Branch (551:7): [True: 0, False: 66] ------------------ 552| | // everything is being deleted 553| 0| jv_free(paths); 554| 0| jv_free(object); 555| 0| return jv_null(); 556| 0| } 557| 66| return delpaths_sorted(object, paths, 0); 558| 66|} jv_keys_unsorted: 572| 12.3k|jv jv_keys_unsorted(jv x) { 573| 12.3k| if (jv_get_kind(x) != JV_KIND_OBJECT) ------------------ | Branch (573:7): [True: 14, False: 12.3k] ------------------ 574| 14| return jv_keys(x); 575| 12.3k| jv answer = jv_array_sized(jv_object_length(jv_copy(x))); 576| 1.72M| jv_object_foreach(x, key, value) { ------------------ | | 159| 24.6k| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (159:52): [True: 12.3k, False: 12.3k] | | ------------------ | | 160| 12.3k| for (jv k, v; \ | | 161| 1.73M| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (161:10): [True: 1.72M, False: 12.3k] | | | Branch (161:10): [True: 1.72M, False: 12.3k] | | ------------------ | | 162| 1.73M| (k = jv_object_iter_key(t, jv_i__), \ | | 163| 1.72M| v = jv_object_iter_value(t, jv_i__), \ | | 164| 1.72M| 1) \ | | 165| 1.73M| : 0; \ | | 166| 1.72M| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 577| 1.72M| answer = jv_array_append(answer, key); 578| 1.72M| jv_free(value); 579| 1.72M| } 580| 12.3k| jv_free(x); 581| 12.3k| return answer; 582| 12.3k|} jv_keys: 584| 39.8k|jv jv_keys(jv x) { 585| 39.8k| if (jv_get_kind(x) == JV_KIND_OBJECT) { ------------------ | Branch (585:7): [True: 39.8k, False: 18] ------------------ 586| 39.8k| int nkeys = jv_object_length(jv_copy(x)); 587| 39.8k| if (nkeys == 0) { ------------------ | Branch (587:9): [True: 7.02k, False: 32.8k] ------------------ 588| 7.02k| jv_free(x); 589| 7.02k| return jv_array(); 590| 7.02k| } 591| 32.8k| jv* keys = jv_mem_calloc(nkeys, sizeof(jv)); 592| 32.8k| int kidx = 0; 593| 366k| jv_object_foreach(x, key, value) { ------------------ | | 159| 65.6k| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (159:52): [True: 32.8k, False: 32.8k] | | ------------------ | | 160| 32.8k| for (jv k, v; \ | | 161| 398k| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (161:10): [True: 366k, False: 32.8k] | | | Branch (161:10): [True: 366k, False: 32.8k] | | ------------------ | | 162| 398k| (k = jv_object_iter_key(t, jv_i__), \ | | 163| 366k| v = jv_object_iter_value(t, jv_i__), \ | | 164| 366k| 1) \ | | 165| 398k| : 0; \ | | 166| 366k| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 594| 366k| keys[kidx++] = key; 595| 366k| jv_free(value); 596| 366k| } 597| 32.8k| qsort(keys, nkeys, sizeof(jv), string_cmp); 598| 32.8k| jv answer = jv_array_sized(nkeys); 599| 398k| for (int i = 0; i 0) { ------------------ | Branch (789:7): [True: 14, False: 1] ------------------ 790| 14| jv curr_key = entries[0].key; 791| 14| jv group = jv_array_append(jv_array(), entries[0].object); 792| 527| for (int i = 1; i < n; i++) { ------------------ | Branch (792:21): [True: 513, False: 14] ------------------ 793| 513| int equal = jv_equal(jv_copy(curr_key), jv_copy(entries[i].key)); 794| 513| if (equal < 0) { ------------------ | Branch (794:11): [True: 0, False: 513] ------------------ 795| 0| jv_free(curr_key); 796| 0| jv_free(group); 797| 0| sort_entry_array_free(entries, i, n); 798| 0| jv_free(ret); 799| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 800| 0| } 801| 513| if (equal) { ------------------ | Branch (801:11): [True: 513, False: 0] ------------------ 802| 513| jv_free(entries[i].key); 803| 513| } else { 804| 0| jv_free(curr_key); 805| 0| curr_key = entries[i].key; 806| 0| ret = jv_array_append(ret, group); 807| 0| group = jv_array(); 808| 0| } 809| 513| group = jv_array_append(group, entries[i].object); 810| 513| } 811| 14| jv_free(curr_key); 812| 14| ret = jv_array_append(ret, group); 813| 14| } 814| 15| jv_mem_free(entries); 815| 15| return ret; 816| 15|} jv_unique: 818| 613|jv jv_unique(jv objects, jv keys) { 819| 613| assert(jv_get_kind(objects) == JV_KIND_ARRAY); ------------------ | Branch (819:3): [True: 0, False: 613] | Branch (819:3): [True: 613, False: 0] ------------------ 820| 613| assert(jv_get_kind(keys) == JV_KIND_ARRAY); ------------------ | Branch (820:3): [True: 0, False: 613] | Branch (820:3): [True: 613, False: 0] ------------------ 821| 613| assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys))); ------------------ | Branch (821:3): [True: 0, False: 613] | Branch (821:3): [True: 613, False: 0] ------------------ 822| 613| int n = jv_array_length(jv_copy(objects)); 823| 613| int too_deep = 0; 824| 613| struct sort_entry* entries = sort_items(objects, keys, &too_deep); 825| 613| if (too_deep) ------------------ | Branch (825:7): [True: 0, False: 613] ------------------ 826| 0| return jv_invalid_with_msg(jv_string("Comparison too deep")); 827| 613| jv ret = jv_array(); 828| 613| jv curr_key = jv_invalid(); 829| 75.5k| for (int i = 0; i < n; i++) { ------------------ | Branch (829:19): [True: 74.9k, False: 613] ------------------ 830| 74.9k| int equal = jv_equal(jv_copy(curr_key), jv_copy(entries[i].key)); 831| 74.9k| if (equal < 0) { ------------------ | Branch (831:9): [True: 0, False: 74.9k] ------------------ 832| 0| jv_free(curr_key); 833| 0| sort_entry_array_free(entries, i, n); 834| 0| jv_free(ret); 835| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 836| 0| } 837| 74.9k| if (equal) { ------------------ | Branch (837:9): [True: 68.6k, False: 6.29k] ------------------ 838| 68.6k| jv_free(entries[i].key); 839| 68.6k| jv_free(entries[i].object); 840| 68.6k| } else { 841| 6.29k| jv_free(curr_key); 842| 6.29k| curr_key = entries[i].key; 843| 6.29k| ret = jv_array_append(ret, entries[i].object); 844| 6.29k| } 845| 74.9k| } 846| 613| jv_free(curr_key); 847| 613| jv_mem_free(entries); 848| 613| return ret; 849| 613|} jv_aux.c:parse_slice: 37| 534k|static jv parse_slice(jv j, jv slice, int* pstart, int* pend) { 38| | // Array slices 39| 534k| jv start_jv = jv_object_get(jv_copy(slice), jv_string("start")); 40| 534k| jv end_jv = jv_object_get(slice, jv_string("end")); 41| 534k| if (jv_get_kind(start_jv) == JV_KIND_NULL) { ------------------ | Branch (41:7): [True: 425, False: 533k] ------------------ 42| 425| jv_free(start_jv); 43| 425| start_jv = jv_number(0); 44| 425| } 45| 534k| int len; 46| 534k| if (jv_get_kind(j) == JV_KIND_ARRAY) { ------------------ | Branch (46:7): [True: 434k, False: 99.7k] ------------------ 47| 434k| len = jv_array_length(j); 48| 434k| } else if (jv_get_kind(j) == JV_KIND_STRING) { ------------------ | Branch (48:14): [True: 99.7k, False: 0] ------------------ 49| 99.7k| len = jv_string_length_codepoints(j); 50| 99.7k| } else { 51| | /* 52| | * XXX This should be dead code because callers shouldn't call this 53| | * function if `j' is neither an array nor a string. 54| | */ 55| 0| jv_free(j); 56| 0| jv_free(start_jv); 57| 0| jv_free(end_jv); 58| 0| return jv_invalid_with_msg(jv_string("Only arrays and strings can be sliced")); 59| 0| } 60| 534k| if (jv_get_kind(end_jv) == JV_KIND_NULL) { ------------------ | Branch (60:7): [True: 465k, False: 68.9k] ------------------ 61| 465k| jv_free(end_jv); 62| 465k| end_jv = jv_number(len); 63| 465k| } 64| 534k| if (jv_get_kind(start_jv) != JV_KIND_NUMBER || ------------------ | Branch (64:7): [True: 1, False: 534k] ------------------ 65| 534k| jv_get_kind(end_jv) != JV_KIND_NUMBER) { ------------------ | Branch (65:7): [True: 0, False: 534k] ------------------ 66| 1| jv_free(start_jv); 67| 1| jv_free(end_jv); 68| 1| return jv_invalid_with_msg(jv_string("Array/string slice indices must be integers")); 69| 1| } 70| | 71| 534k| double dstart = jv_number_value(start_jv); 72| 534k| double dend = jv_number_value(end_jv); 73| 534k| int start, end; 74| | 75| 534k| jv_free(start_jv); 76| 534k| jv_free(end_jv); 77| 534k| if (isnan(dstart)) dstart = 0; ------------------ | Branch (77:7): [True: 1, False: 534k] ------------------ 78| 534k| if (dstart < 0) dstart += len; ------------------ | Branch (78:7): [True: 27, False: 533k] ------------------ 79| 534k| if (dstart < 0) dstart = 0; ------------------ | Branch (79:7): [True: 7, False: 533k] ------------------ 80| 534k| if (dstart > len) dstart = len; ------------------ | Branch (80:7): [True: 2, False: 534k] ------------------ 81| 534k| start = dstart > INT_MAX ? INT_MAX : (int)dstart; // Rounds down ------------------ | Branch (81:11): [True: 0, False: 534k] ------------------ 82| | 83| 534k| if (isnan(dend)) dend = len; ------------------ | Branch (83:7): [True: 0, False: 534k] ------------------ 84| 534k| if (dend < 0) dend += len; ------------------ | Branch (84:7): [True: 0, False: 534k] ------------------ 85| 534k| if (dend < 0) dend = start; ------------------ | Branch (85:7): [True: 0, False: 534k] ------------------ 86| 534k| end = dend > INT_MAX ? INT_MAX : (int)dend; ------------------ | Branch (86:9): [True: 0, False: 534k] ------------------ 87| 534k| if (end > len) end = len; ------------------ | Branch (87:7): [True: 3, False: 534k] ------------------ 88| 534k| if (end < len) end += end < dend ? 1 : 0; // We round start down ------------------ | Branch (88:7): [True: 68.6k, False: 465k] | Branch (88:29): [True: 0, False: 68.6k] ------------------ 89| | // but round end up 90| | 91| 534k| if (end < start) end = start; ------------------ | Branch (91:7): [True: 0, False: 534k] ------------------ 92| 534k| assert(0 <= start && start <= end && end <= len); ------------------ | Branch (92:3): [True: 0, False: 534k] | Branch (92:3): [True: 0, False: 0] | Branch (92:3): [True: 0, False: 0] | Branch (92:3): [True: 534k, False: 0] | Branch (92:3): [True: 534k, False: 0] | Branch (92:3): [True: 534k, False: 0] ------------------ 93| 534k| *pstart = start; 94| 534k| *pend = end; 95| 534k| return jv_true(); 96| 534k|} jv_aux.c:delpaths_sorted: 474| 69|static jv delpaths_sorted(jv object, jv paths, int start) { 475| 69| jv delkeys = jv_array(); 476| 49.4k| for (int i=0; i start); ------------------ | Branch (477:5): [True: 0, False: 49.4k] | Branch (477:5): [True: 49.4k, False: 0] ------------------ 478| 49.4k| int delkey = jv_array_length(jv_array_get(jv_copy(paths), i)) == start + 1; 479| 49.4k| jv key = jv_array_get(jv_array_get(jv_copy(paths), i), start); 480| 49.4k| int j = i; 481| 49.4k| do 482| 49.4k| j++; 483| 49.4k| while (j < jv_array_length(jv_copy(paths)) && ------------------ | Branch (483:12): [True: 49.3k, False: 69] ------------------ 484| 49.3k| jv_equal(jv_copy(key), jv_array_get(jv_array_get(jv_copy(paths), j), start)) == 1); ------------------ | Branch (484:12): [True: 0, False: 49.3k] ------------------ 485| | // if i <= entry < j, then entry starts with key 486| 49.4k| if (delkey) { ------------------ | Branch (486:9): [True: 49.4k, False: 6] ------------------ 487| | // deleting this entire key, we don't care about any more specific deletions 488| 49.4k| delkeys = jv_array_append(delkeys, key); 489| 49.4k| } else { 490| | // deleting certain sub-parts of this key 491| 6| jv subobject = jv_get(jv_copy(object), jv_copy(key)); 492| 6| if (!jv_is_valid(subobject)) { ------------------ | Branch (492:11): [True: 2, False: 4] ------------------ 493| 2| jv_free(key); 494| 2| jv_free(object); 495| 2| object = subobject; 496| 2| break; 497| 4| } else if (jv_get_kind(subobject) == JV_KIND_NULL) { ------------------ | Branch (497:18): [True: 1, False: 3] ------------------ 498| 1| jv_free(key); 499| 1| jv_free(subobject); 500| 3| } else { 501| 3| jv newsubobject = delpaths_sorted(subobject, jv_array_slice(jv_copy(paths), i, j), start+1); 502| 3| if (!jv_is_valid(newsubobject)) { ------------------ | Branch (502:13): [True: 2, False: 1] ------------------ 503| 2| jv_free(key); 504| 2| jv_free(object); 505| 2| object = newsubobject; 506| 2| break; 507| 2| } 508| 1| object = jv_set(object, key, newsubobject); 509| 1| } 510| 2| if (!jv_is_valid(object)) break; ------------------ | Branch (510:11): [True: 0, False: 2] ------------------ 511| 2| } 512| 49.4k| i = j; 513| 49.4k| } 514| 69| jv_free(paths); 515| 69| if (jv_is_valid(object)) ------------------ | Branch (515:7): [True: 65, False: 4] ------------------ 516| 65| object = jv_dels(object, delkeys); 517| 4| else 518| 4| jv_free(delkeys); 519| 69| return object; 520| 69|} jv_aux.c:jv_dels: 283| 65|static jv jv_dels(jv t, jv keys) { 284| 65| assert(jv_get_kind(keys) == JV_KIND_ARRAY); ------------------ | Branch (284:3): [True: 0, False: 65] | Branch (284:3): [True: 65, False: 0] ------------------ 285| 65| assert(jv_is_valid(t)); ------------------ | Branch (285:3): [True: 0, False: 65] | Branch (285:3): [True: 65, False: 0] ------------------ 286| | 287| 65| if (jv_get_kind(t) == JV_KIND_NULL || jv_array_length(jv_copy(keys)) == 0) { ------------------ | Branch (287:7): [True: 2, False: 63] | Branch (287:41): [True: 2, False: 61] ------------------ 288| | // no change 289| 61| } else if (jv_get_kind(t) == JV_KIND_ARRAY) { ------------------ | Branch (289:14): [True: 52, False: 9] ------------------ 290| | // extract slices, they must be handled differently 291| 52| jv neg_keys = jv_array(); 292| 52| jv nonneg_keys = jv_array(); 293| 52| jv new_array = jv_array(); 294| 52| jv starts = jv_array(), ends = jv_array(); 295| 49.3k| jv_array_foreach(keys, i, key) { ------------------ | | 93| 52| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 103| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 52, False: 51] | | ------------------ | | 95| 52| for (jv x; \ | | 96| 49.4k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 49.3k, False: 51] | | | Branch (96:10): [True: 49.3k, False: 51] | | ------------------ | | 97| 49.4k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 49.3k| i++) ------------------ 296| 49.3k| if (jv_get_kind(key) == JV_KIND_NUMBER) { ------------------ | Branch (296:11): [True: 49.3k, False: 1] ------------------ 297| 49.3k| if (jvp_number_is_nan(key)) { ------------------ | Branch (297:13): [True: 0, False: 49.3k] ------------------ 298| 0| jv_free(key); 299| 49.3k| } else if (jv_number_value(key) < 0) { ------------------ | Branch (299:20): [True: 0, False: 49.3k] ------------------ 300| 0| neg_keys = jv_array_append(neg_keys, key); 301| 49.3k| } else { 302| 49.3k| nonneg_keys = jv_array_append(nonneg_keys, key); 303| 49.3k| } 304| 49.3k| } else if (jv_get_kind(key) == JV_KIND_OBJECT) { ------------------ | Branch (304:18): [True: 0, False: 1] ------------------ 305| 0| int start, end; 306| 0| jv e = parse_slice(jv_copy(t), key, &start, &end); 307| 0| if (jv_get_kind(e) == JV_KIND_TRUE) { ------------------ | Branch (307:13): [True: 0, False: 0] ------------------ 308| 0| starts = jv_array_append(starts, jv_number(start)); 309| 0| ends = jv_array_append(ends, jv_number(end)); 310| 0| } else { 311| 0| jv_free(new_array); 312| 0| new_array = e; 313| 0| goto arr_out; 314| 0| } 315| 1| } else { 316| 1| jv_free(new_array); 317| 1| new_array = jv_invalid_with_msg(jv_string_fmt("Cannot delete %s element of array", 318| 1| jv_kind_name(jv_get_kind(key)))); 319| 1| jv_free(key); 320| 1| goto arr_out; 321| 1| } 322| 49.3k| } 323| | 324| 51| int neg_idx = 0; 325| 51| int nonneg_idx = 0; 326| 51| int len = jv_array_length(jv_copy(t)); 327| 680k| for (int i = 0; i < len; ++i) { ------------------ | Branch (327:21): [True: 680k, False: 51] ------------------ 328| 680k| int del = 0; 329| 680k| while (neg_idx < jv_array_length(jv_copy(neg_keys))) { ------------------ | Branch (329:14): [True: 0, False: 680k] ------------------ 330| 0| int delidx = len + (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(neg_keys), neg_idx)); 331| 0| if (i == delidx) { ------------------ | Branch (331:13): [True: 0, False: 0] ------------------ 332| 0| del = 1; 333| 0| } 334| 0| if (i < delidx) { ------------------ | Branch (334:13): [True: 0, False: 0] ------------------ 335| 0| break; 336| 0| } 337| 0| neg_idx++; 338| 0| } 339| 729k| while (nonneg_idx < jv_array_length(jv_copy(nonneg_keys))) { ------------------ | Branch (339:14): [True: 729k, False: 473] ------------------ 340| 729k| int delidx = (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(nonneg_keys), nonneg_idx)); 341| 729k| if (i == delidx) { ------------------ | Branch (341:13): [True: 49.3k, False: 679k] ------------------ 342| 49.3k| del = 1; 343| 49.3k| } 344| 729k| if (i < delidx) { ------------------ | Branch (344:13): [True: 679k, False: 49.3k] ------------------ 345| 679k| break; 346| 679k| } 347| 49.3k| nonneg_idx++; 348| 49.3k| } 349| 680k| for (int sidx=0; !del && sidx MAX_CMP_DEPTH) { ------------------ | | 20| 4.53M|#define MAX_CMP_DEPTH (10000) ------------------ | Branch (619:7): [True: 0, False: 4.53M] ------------------ 620| 0| jv_free(a); 621| 0| jv_free(b); 622| 0| return INT_MIN; 623| 0| } 624| | 625| 4.53M| if (jv_get_kind(a) != jv_get_kind(b)) { ------------------ | Branch (625:7): [True: 33.0k, False: 4.49M] ------------------ 626| 33.0k| int r = (int)jv_get_kind(a) - (int)jv_get_kind(b); 627| 33.0k| jv_free(a); 628| 33.0k| jv_free(b); 629| 33.0k| return r; 630| 33.0k| } 631| 4.49M| int r = 0; 632| 4.49M| switch (jv_get_kind(a)) { 633| 0| default: ------------------ | Branch (633:3): [True: 0, False: 4.49M] ------------------ 634| 0| assert(0 && "invalid kind passed to jv_cmp"); ------------------ | Branch (634:5): [Folded, False: 0] | Branch (634:5): [True: 0, False: 0] | Branch (634:5): [Folded, False: 0] | Branch (634:5): [True: 0, False: 0] ------------------ 635| 1.66k| case JV_KIND_NULL: ------------------ | Branch (635:3): [True: 1.66k, False: 4.49M] ------------------ 636| 12.0k| case JV_KIND_FALSE: ------------------ | Branch (636:3): [True: 10.4k, False: 4.48M] ------------------ 637| 12.2k| case JV_KIND_TRUE: ------------------ | Branch (637:3): [True: 144, False: 4.49M] ------------------ 638| | // there's only one of each of these values 639| 12.2k| break; 640| | 641| 3.98M| case JV_KIND_NUMBER: { ------------------ | Branch (641:3): [True: 3.98M, False: 516k] ------------------ 642| 3.98M| if (jvp_number_is_nan(a)) { ------------------ | Branch (642:9): [True: 2.60k, False: 3.97M] ------------------ 643| 2.60k| r = jvp_cmp(jv_null(), jv_copy(b), depth); 644| 3.97M| } else if (jvp_number_is_nan(b)) { ------------------ | Branch (644:16): [True: 1.72k, False: 3.97M] ------------------ 645| 1.72k| r = jvp_cmp(jv_copy(a), jv_null(), depth); 646| 3.97M| } else { 647| 3.97M| r = jvp_number_cmp(a, b); 648| 3.97M| } 649| 3.98M| break; 650| 12.0k| } 651| | 652| 80.7k| case JV_KIND_STRING: { ------------------ | Branch (652:3): [True: 80.7k, False: 4.41M] ------------------ 653| 80.7k| r = string_cmp(&a, &b); 654| 80.7k| break; 655| 12.0k| } 656| | 657| 403k| case JV_KIND_ARRAY: { ------------------ | Branch (657:3): [True: 403k, False: 4.09M] ------------------ 658| | // Lexical ordering of arrays 659| 403k| int i = 0; 660| 1.15M| while (r == 0) { ------------------ | Branch (660:12): [True: 792k, False: 367k] ------------------ 661| 792k| int a_done = i >= jv_array_length(jv_copy(a)); 662| 792k| int b_done = i >= jv_array_length(jv_copy(b)); 663| 792k| if (a_done || b_done) { ------------------ | Branch (663:11): [True: 33.3k, False: 758k] | Branch (663:21): [True: 3.46k, False: 755k] ------------------ 664| 36.8k| r = b_done - a_done; //suddenly, logic 665| 36.8k| break; 666| 36.8k| } 667| 755k| jv xa = jv_array_get(jv_copy(a), i); 668| 755k| jv xb = jv_array_get(jv_copy(b), i); 669| 755k| r = jvp_cmp(xa, xb, depth + 1); 670| 755k| if (r == INT_MIN) ------------------ | Branch (670:11): [True: 0, False: 755k] ------------------ 671| 0| break; 672| 755k| i++; 673| 755k| } 674| 403k| break; 675| 12.0k| } 676| | 677| 19.9k| case JV_KIND_OBJECT: { ------------------ | Branch (677:3): [True: 19.9k, False: 4.47M] ------------------ 678| 19.9k| jv keys_a = jv_keys(jv_copy(a)); 679| 19.9k| jv keys_b = jv_keys(jv_copy(b)); 680| 19.9k| r = jvp_cmp(jv_copy(keys_a), keys_b, depth + 1); 681| 19.9k| if (r == 0) { ------------------ | Branch (681:9): [True: 9.90k, False: 10.0k] ------------------ 682| 51.3k| jv_array_foreach(keys_a, i, key) { ------------------ | | 93| 9.90k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 19.8k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 9.90k, False: 9.90k] | | ------------------ | | 95| 9.90k| for (jv x; \ | | 96| 59.0k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 51.3k, False: 7.70k] | | | Branch (96:10): [True: 51.3k, False: 7.70k] | | ------------------ | | 97| 59.0k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 49.1k| i++) ------------------ 683| 51.3k| jv xa = jv_object_get(jv_copy(a), jv_copy(key)); 684| 51.3k| jv xb = jv_object_get(jv_copy(b), key); 685| 51.3k| r = jvp_cmp(xa, xb, depth + 1); 686| 51.3k| if (r != 0) ------------------ | Branch (686:13): [True: 2.19k, False: 49.1k] ------------------ 687| 2.19k| break; 688| 51.3k| } 689| 9.90k| } 690| 19.9k| jv_free(keys_a); 691| 19.9k| break; 692| 12.0k| } 693| 4.49M| } 694| | 695| 4.49M| jv_free(a); 696| 4.49M| jv_free(b); 697| 4.49M| return r; 698| 4.49M|} jv_aux.c:sort_items: 732| 127k|static struct sort_entry* sort_items(jv objects, jv keys, int *too_deep) { 733| 127k| assert(jv_get_kind(objects) == JV_KIND_ARRAY); ------------------ | Branch (733:3): [True: 0, False: 127k] | Branch (733:3): [True: 127k, False: 0] ------------------ 734| 127k| assert(jv_get_kind(keys) == JV_KIND_ARRAY); ------------------ | Branch (734:3): [True: 0, False: 127k] | Branch (734:3): [True: 127k, False: 0] ------------------ 735| 127k| assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys))); ------------------ | Branch (735:3): [True: 0, False: 127k] | Branch (735:3): [True: 127k, False: 0] ------------------ 736| 127k| int n = jv_array_length(jv_copy(objects)); 737| 127k| *too_deep = 0; 738| 127k| if (n == 0) { ------------------ | Branch (738:7): [True: 120k, False: 7.45k] ------------------ 739| 120k| jv_free(objects); 740| 120k| jv_free(keys); 741| 120k| return NULL; 742| 120k| } 743| 7.45k| struct sort_entry* entries = jv_mem_calloc(n, sizeof(struct sort_entry)); 744| 143k| for (int i=0; ikey), jv_copy(b->key)); 724| 1.10M| if (r == INT_MIN) { ------------------ | Branch (724:7): [True: 0, False: 1.10M] ------------------ 725| 0| sort_cmp_state.too_deep = 1; 726| 0| return 0; 727| 0| } 728| | // comparing by index if r == 0 makes the sort stable 729| 1.10M| return r ? r : (a->index - b->index); ------------------ | Branch (729:10): [True: 731k, False: 375k] ------------------ 730| 1.10M|} jvp_dtoa_context_init: 522| 578k|void jvp_dtoa_context_init(struct dtoa_context* C) { 523| 578k| int i; 524| 5.20M| for (i=0; i<(int)(sizeof(C->freelist)/sizeof(C->freelist[0])); i++) { ------------------ | Branch (524:13): [True: 4.62M, False: 578k] ------------------ 525| 4.62M| C->freelist[i] = 0; 526| 4.62M| } 527| 578k| C->p5s = 0; 528| 578k|} jvp_dtoa_context_free: 569| 578k|void jvp_dtoa_context_free(struct dtoa_context* C) { 570| 578k| int k; 571| 578k| while (C->p5s) { ------------------ | Branch (571:10): [True: 7, False: 578k] ------------------ 572| 7| Bigint* p5 = C->p5s; 573| 7| C->p5s = p5->next; 574| 7| Bfree(C, p5); 575| 7| } 576| 5.20M| for (k=0; k<(int)(sizeof(C->freelist)/sizeof(C->freelist[0])); k++) { ------------------ | Branch (576:13): [True: 4.62M, False: 578k] ------------------ 577| 4.62M| while (C->freelist[k]) { ------------------ | Branch (577:12): [True: 31, False: 4.62M] ------------------ 578| 31| Bigint* v = C->freelist[k]; 579| 31| C->freelist[k] = v->next; 580| 31| FREE(v); ------------------ | | 200| 31|#define FREE jv_mem_free ------------------ 581| 31| } 582| 4.62M| } 583| 578k|} jvp_strtod: 2331| 137k|{ 2332| 137k| int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1; 2333| |#ifdef Honor_FLT_ROUNDS 2334| | int test_scale; 2335| |#endif 2336| 137k| int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign; 2337| 137k| CONST char *s, *s0, *s1; ------------------ | | 298| 137k|#define CONST const ------------------ 2338| 137k| double aadj, aadj1; 2339| 137k| Long L; ------------------ | | 193| 137k|#define Long int ------------------ 2340| 137k| U aadj2, adj, rv, rv0; 2341| 137k| ULong y, z; 2342| 137k| BCinfo bc; 2343| 137k| Bigint *bb=0, *bb1, *bd=0, *bd0, *bs=0, *delta=0; 2344| 137k|#ifdef Avoid_Underflow 2345| 137k| ULong Lsb, Lsb1; 2346| 137k|#endif 2347| |#ifdef SET_INEXACT 2348| | int oldinexact; 2349| |#endif 2350| 137k|#ifndef NO_STRTOD_BIGCOMP 2351| 137k| int req_bigcomp = 0; 2352| 137k|#endif 2353| |#ifdef Honor_FLT_ROUNDS /*{*/ 2354| |#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */ 2355| | bc.rounding = Flt_Rounds; 2356| |#else /*}{*/ 2357| | bc.rounding = 1; 2358| | switch(fegetround()) { 2359| | case FE_TOWARDZERO: bc.rounding = 0; break; 2360| | case FE_UPWARD: bc.rounding = 2; break; 2361| | case FE_DOWNWARD: bc.rounding = 3; 2362| | } 2363| |#endif /*}}*/ 2364| |#endif /*}*/ 2365| |#ifdef USE_LOCALE 2366| | CONST char *s2; 2367| |#endif 2368| | 2369| 137k| sign = nz0 = nz1 = nz = bc.dplen = bc.uflchk = 0; 2370| 137k| dval(&rv) = 0.; ------------------ | | 314| 137k|#define dval(x) (x)->d ------------------ 2371| 137k| switch(*(s = s00)) { 2372| 4.50k| case '-': ------------------ | Branch (2372:3): [True: 4.50k, False: 132k] ------------------ 2373| 4.50k| sign = 1; 2374| | /* no break */ 2375| 4.50k| JQ_FALLTHROUGH; ------------------ | | 14| 4.50k|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 2376| 4.50k| case '+': ------------------ | Branch (2376:3): [True: 0, False: 137k] ------------------ 2377| 4.50k| if (*++s) ------------------ | Branch (2377:8): [True: 4.50k, False: 0] ------------------ 2378| 4.50k| break; 2379| | /* no break */ 2380| 0| JQ_FALLTHROUGH; ------------------ | | 14| 0|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 2381| 0| case 0: ------------------ | Branch (2381:3): [True: 0, False: 137k] ------------------ 2382| 0| goto ret0; 2383| 132k| default: ------------------ | Branch (2383:3): [True: 132k, False: 4.50k] ------------------ 2384| 132k| break; 2385| 137k| } 2386| 137k| if (*s == '0') { ------------------ | Branch (2386:6): [True: 20.4k, False: 116k] ------------------ 2387| |#ifndef NO_HEX_FP /*{*/ 2388| | switch(s[1]) { 2389| | case 'x': 2390| | case 'X': 2391| |#ifdef Honor_FLT_ROUNDS 2392| | gethex(C, &s, &rv, bc.rounding, sign); 2393| |#else 2394| | gethex(C, &s, &rv, 1, sign); 2395| |#endif 2396| | goto ret; 2397| | } 2398| |#endif /*}*/ 2399| 20.4k| nz0 = 1; 2400| 20.4k| while(*++s == '0') ; ------------------ | Branch (2400:9): [True: 0, False: 20.4k] ------------------ 2401| 20.4k| if (!*s) ------------------ | Branch (2401:7): [True: 18.5k, False: 1.92k] ------------------ 2402| 18.5k| goto ret; 2403| 20.4k| } 2404| 118k| s0 = s; 2405| 118k| y = z = 0; 2406| 322k| for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++) ------------------ | Branch (2406:19): [True: 217k, False: 105k] | Branch (2406:38): [True: 203k, False: 13.5k] ------------------ 2407| 203k| if (nd < 9) ------------------ | Branch (2407:7): [True: 177k, False: 25.5k] ------------------ 2408| 177k| y = 10*y + c - '0'; 2409| 25.5k| else if (nd < 16) ------------------ | Branch (2409:12): [True: 24.0k, False: 1.46k] ------------------ 2410| 24.0k| z = 10*z + c - '0'; 2411| 118k| nd0 = nd; 2412| 118k| bc.dp0 = bc.dp1 = s - s0; 2413| 121k| for(s1 = s; s1 > s0 && *--s1 == '0'; ) ------------------ | Branch (2413:14): [True: 116k, False: 5.26k] | Branch (2413:25): [True: 2.66k, False: 113k] ------------------ 2414| 2.66k| ++nz1; 2415| |#ifdef USE_LOCALE 2416| | s1 = localeconv()->decimal_point; 2417| | if (c == *s1) { 2418| | c = '.'; 2419| | if (*++s1) { 2420| | s2 = s; 2421| | for(;;) { 2422| | if (*++s2 != *s1) { 2423| | c = 0; 2424| | break; 2425| | } 2426| | if (!*++s1) { 2427| | s = s2; 2428| | break; 2429| | } 2430| | } 2431| | } 2432| | } 2433| |#endif 2434| 118k| if (c == '.') { ------------------ | Branch (2434:6): [True: 20.5k, False: 98.1k] ------------------ 2435| 20.5k| c = *++s; 2436| 20.5k| bc.dp1 = s - s0; 2437| 20.5k| bc.dplen = bc.dp1 - bc.dp0; 2438| 20.5k| if (!nd) { ------------------ | Branch (2438:7): [True: 1.92k, False: 18.5k] ------------------ 2439| 4.24k| for(; c == '0'; c = *++s) ------------------ | Branch (2439:10): [True: 2.32k, False: 1.92k] ------------------ 2440| 2.32k| nz++; 2441| 1.92k| if (c > '0' && c <= '9') { ------------------ | Branch (2441:8): [True: 1.92k, False: 0] | Branch (2441:19): [True: 1.92k, False: 0] ------------------ 2442| 1.92k| bc.dp0 = s0 - s; 2443| 1.92k| bc.dp1 = bc.dp0 + bc.dplen; 2444| 1.92k| s0 = s; 2445| 1.92k| nf += nz; 2446| 1.92k| nz = 0; 2447| 1.92k| goto have_dig; 2448| 1.92k| } 2449| 0| goto dig_done; 2450| 1.92k| } 2451| 214k| for(; c >= '0' && c <= '9'; c = *++s) { ------------------ | Branch (2451:9): [True: 211k, False: 3.00k] | Branch (2451:21): [True: 193k, False: 17.5k] ------------------ 2452| 195k| have_dig: 2453| 195k| nz++; 2454| 195k| if (c -= '0') { ------------------ | Branch (2454:8): [True: 151k, False: 44.6k] ------------------ 2455| 151k| nf += nz; 2456| 185k| for(i = 1; i < nz; i++) ------------------ | Branch (2456:16): [True: 34.3k, False: 151k] ------------------ 2457| 34.3k| if (nd++ < 9) ------------------ | Branch (2457:10): [True: 23.0k, False: 11.3k] ------------------ 2458| 23.0k| y *= 10; 2459| 11.3k| else if (nd <= DBL_DIG + 1) ------------------ | Branch (2459:15): [True: 11.3k, False: 0] ------------------ 2460| 11.3k| z *= 10; 2461| 151k| if (nd++ < 9) ------------------ | Branch (2461:9): [True: 94.6k, False: 56.5k] ------------------ 2462| 94.6k| y = 10*y + c; 2463| 56.5k| else if (nd <= DBL_DIG + 1) ------------------ | Branch (2463:14): [True: 50.4k, False: 6.09k] ------------------ 2464| 50.4k| z = 10*z + c; 2465| 151k| nz = nz1 = 0; 2466| 151k| } 2467| 195k| } 2468| 18.5k| } 2469| 118k| dig_done: 2470| 118k| e = 0; 2471| 118k| if (c == 'e' || c == 'E') { ------------------ | Branch (2471:6): [True: 0, False: 118k] | Branch (2471:18): [True: 27.7k, False: 90.8k] ------------------ 2472| 27.7k| if (!nd && !nz && !nz0) { ------------------ | Branch (2472:7): [True: 0, False: 27.7k] | Branch (2472:14): [True: 0, False: 0] | Branch (2472:21): [True: 0, False: 0] ------------------ 2473| 0| goto ret0; 2474| 0| } 2475| 27.7k| s00 = s; 2476| 27.7k| esign = 0; 2477| 27.7k| switch(c = *++s) { ------------------ | Branch (2477:10): [True: 27.7k, False: 0] ------------------ 2478| 7.20k| case '-': ------------------ | Branch (2478:4): [True: 7.20k, False: 20.5k] ------------------ 2479| 7.20k| esign = 1; 2480| 7.20k| JQ_FALLTHROUGH; ------------------ | | 14| 7.20k|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 2481| 27.7k| case '+': ------------------ | Branch (2481:4): [True: 20.5k, False: 7.20k] ------------------ 2482| 27.7k| c = *++s; 2483| 27.7k| } 2484| 27.7k| if (c >= '0' && c <= '9') { ------------------ | Branch (2484:7): [True: 27.7k, False: 0] | Branch (2484:19): [True: 27.7k, False: 0] ------------------ 2485| 27.7k| while(c == '0') ------------------ | Branch (2485:10): [True: 0, False: 27.7k] ------------------ 2486| 0| c = *++s; 2487| 27.7k| if (c > '0' && c <= '9') { ------------------ | Branch (2487:8): [True: 27.7k, False: 0] | Branch (2487:19): [True: 27.7k, False: 0] ------------------ 2488| 27.7k| L = c - '0'; 2489| 27.7k| s1 = s; 2490| 64.2k| while((c = *++s) >= '0' && c <= '9') ------------------ | Branch (2490:11): [True: 36.5k, False: 27.7k] | Branch (2490:32): [True: 36.5k, False: 0] ------------------ 2491| 36.5k| L = 10*L + c - '0'; 2492| 27.7k| if (s - s1 > 8 || L > 19999) ------------------ | Branch (2492:9): [True: 0, False: 27.7k] | Branch (2492:23): [True: 0, False: 27.7k] ------------------ 2493| | /* Avoid confusion from exponents 2494| | * so large that e might overflow. 2495| | */ 2496| 0| e = 19999; /* safe for 16 bit ints */ 2497| 27.7k| else 2498| 27.7k| e = (int)L; 2499| 27.7k| if (esign) ------------------ | Branch (2499:9): [True: 7.20k, False: 20.5k] ------------------ 2500| 7.20k| e = -e; 2501| 27.7k| } 2502| 0| else 2503| 0| e = 0; 2504| 27.7k| } 2505| 0| else 2506| 0| s = s00; 2507| 27.7k| } 2508| 118k| if (!nd) { ------------------ | Branch (2508:6): [True: 3.33k, False: 115k] ------------------ 2509| 3.33k| if (!nz && !nz0) { ------------------ | Branch (2509:7): [True: 3.33k, False: 0] | Branch (2509:14): [True: 3.33k, False: 0] ------------------ 2510| 3.33k|#ifdef INFNAN_CHECK 2511| | /* Check for Nan and Infinity */ 2512| 3.33k| if (!bc.dplen) ------------------ | Branch (2512:8): [True: 3.33k, False: 0] ------------------ 2513| 3.33k| switch(c) { ------------------ | Branch (2513:12): [True: 3.33k, False: 0] ------------------ 2514| 0| case 'i': ------------------ | Branch (2514:6): [True: 0, False: 3.33k] ------------------ 2515| 3.33k| case 'I': ------------------ | Branch (2515:6): [True: 3.33k, False: 0] ------------------ 2516| 3.33k| if (match(C, &s,"nf")) { ------------------ | Branch (2516:9): [True: 3.33k, False: 0] ------------------ 2517| 3.33k| --s; 2518| 3.33k| if (!match(C, &s,"inity")) ------------------ | Branch (2518:10): [True: 0, False: 3.33k] ------------------ 2519| 0| ++s; 2520| 3.33k| word0(&rv) = 0x7ff00000; ------------------ | | 308| 3.33k|#define word0(x) (x)->L[1] ------------------ 2521| 3.33k| word1(&rv) = 0; ------------------ | | 309| 3.33k|#define word1(x) (x)->L[0] ------------------ 2522| 3.33k| goto ret; 2523| 3.33k| } 2524| 0| break; 2525| 0| case 'n': ------------------ | Branch (2525:6): [True: 0, False: 3.33k] ------------------ 2526| 0| case 'N': ------------------ | Branch (2526:6): [True: 0, False: 3.33k] ------------------ 2527| 0| if (match(C, &s, "an")) { ------------------ | Branch (2527:9): [True: 0, False: 0] ------------------ 2528| 0| word0(&rv) = NAN_WORD0; ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&rv) = NAN_WORD0; ------------------ | | 1425| 0|#define NAN_WORD0 0x7ff80000 ------------------ 2529| 0| word1(&rv) = NAN_WORD1; ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ word1(&rv) = NAN_WORD1; ------------------ | | 1429| 0|#define NAN_WORD1 0 ------------------ 2530| |#ifndef No_Hex_NaN 2531| | if (*s == '(') /*)*/ 2532| | hexnan(C, &rv, &s); 2533| |#endif 2534| 0| goto ret; 2535| 0| } 2536| 3.33k| } 2537| 0|#endif /* INFNAN_CHECK */ 2538| 0| ret0: 2539| 0| s = s00; 2540| 0| sign = 0; 2541| 0| } 2542| 0| goto ret; 2543| 3.33k| } 2544| 115k| bc.e0 = e1 = e -= nf; 2545| | 2546| | /* Now we have nd0 digits, starting at s0, followed by a 2547| | * decimal point, followed by nd-nd0 digits. The number we're 2548| | * after is the integer represented by those digits times 2549| | * 10**e */ 2550| | 2551| 115k| if (!nd0) ------------------ | Branch (2551:6): [True: 1.92k, False: 113k] ------------------ 2552| 1.92k| nd0 = nd; 2553| 115k| k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1; ------------------ | Branch (2553:6): [True: 105k, False: 10.1k] ------------------ 2554| 115k| dval(&rv) = y; ------------------ | | 314| 115k|#define dval(x) (x)->d ------------------ 2555| 115k| if (k > 9) { ------------------ | Branch (2555:6): [True: 16.7k, False: 98.4k] ------------------ 2556| |#ifdef SET_INEXACT 2557| | if (k > DBL_DIG) 2558| | oldinexact = get_inexact(); 2559| |#endif 2560| 16.7k| dval(&rv) = tens[k - 9] * dval(&rv) + z; ------------------ | | 314| 16.7k|#define dval(x) (x)->d ------------------ dval(&rv) = tens[k - 9] * dval(&rv) + z; ------------------ | | 314| 16.7k|#define dval(x) (x)->d ------------------ 2561| 16.7k| } 2562| 115k| bd0 = 0; 2563| 115k| if (nd <= DBL_DIG ------------------ | Branch (2563:6): [True: 105k, False: 10.1k] ------------------ 2564| 105k|#ifndef RND_PRODQUOT 2565| 105k|#ifndef Honor_FLT_ROUNDS 2566| 105k| && Flt_Rounds == 1 ------------------ | | 380| 105k|#define Flt_Rounds FLT_ROUNDS ------------------ | Branch (2566:6): [True: 105k, False: 0] ------------------ 2567| 115k|#endif 2568| 115k|#endif 2569| 115k| ) { 2570| 105k| if (!e) ------------------ | Branch (2570:7): [True: 82.0k, False: 23.1k] ------------------ 2571| 82.0k| goto ret; 2572| 23.1k|#ifndef ROUND_BIASED_without_Round_Up 2573| 23.1k| if (e > 0) { ------------------ | Branch (2573:7): [True: 13.8k, False: 9.27k] ------------------ 2574| 13.8k| if (e <= Ten_pmax) { ------------------ | | 360| 13.8k|#define Ten_pmax 22 ------------------ | Branch (2574:8): [True: 4.64k, False: 9.22k] ------------------ 2575| |#ifdef VAX 2576| | goto vax_ovfl_check; 2577| |#else 2578| |#ifdef Honor_FLT_ROUNDS 2579| | /* round correctly FLT_ROUNDS = 2 or 3 */ 2580| | if (sign) { 2581| | rv.d = -rv.d; 2582| | sign = 0; 2583| | } 2584| |#endif 2585| 4.64k| /* rv = */ rounded_product(dval(&rv), tens[e]); ------------------ | | 474| 4.64k|#define rounded_product(a,b) a *= b ------------------ 2586| 4.64k| goto ret; 2587| 4.64k|#endif 2588| 4.64k| } 2589| 9.22k| i = DBL_DIG - nd; 2590| 9.22k| if (e <= Ten_pmax + i) { ------------------ | | 360| 9.22k|#define Ten_pmax 22 ------------------ | Branch (2590:8): [True: 970, False: 8.25k] ------------------ 2591| | /* A fancier test would sometimes let us do 2592| | * this for larger i values. 2593| | */ 2594| |#ifdef Honor_FLT_ROUNDS 2595| | /* round correctly FLT_ROUNDS = 2 or 3 */ 2596| | if (sign) { 2597| | rv.d = -rv.d; 2598| | sign = 0; 2599| | } 2600| |#endif 2601| 970| e -= i; 2602| 970| dval(&rv) *= tens[i]; ------------------ | | 314| 970|#define dval(x) (x)->d ------------------ 2603| |#ifdef VAX 2604| | /* VAX exponent range is so narrow we must 2605| | * worry about overflow here... 2606| | */ 2607| | vax_ovfl_check: 2608| | word0(&rv) -= P*Exp_msk1; 2609| | /* rv = */ rounded_product(dval(&rv), tens[e]); 2610| | if ((word0(&rv) & Exp_mask) 2611| | > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) 2612| | goto ovfl; 2613| | word0(&rv) += P*Exp_msk1; 2614| |#else 2615| 970| /* rv = */ rounded_product(dval(&rv), tens[e]); ------------------ | | 474| 970|#define rounded_product(a,b) a *= b ------------------ 2616| 970|#endif 2617| 970| goto ret; 2618| 970| } 2619| 9.22k| } 2620| 9.27k|#ifndef Inaccurate_Divide 2621| 9.27k| else if (e >= -Ten_pmax) { ------------------ | | 360| 9.27k|#define Ten_pmax 22 ------------------ | Branch (2621:12): [True: 2.20k, False: 7.06k] ------------------ 2622| |#ifdef Honor_FLT_ROUNDS 2623| | /* round correctly FLT_ROUNDS = 2 or 3 */ 2624| | if (sign) { 2625| | rv.d = -rv.d; 2626| | sign = 0; 2627| | } 2628| |#endif 2629| 2.20k| /* rv = */ rounded_quotient(dval(&rv), tens[-e]); ------------------ | | 475| 2.20k|#define rounded_quotient(a,b) a /= b ------------------ 2630| 2.20k| goto ret; 2631| 2.20k| } 2632| 23.1k|#endif 2633| 23.1k|#endif /* ROUND_BIASED_without_Round_Up */ 2634| 23.1k| } 2635| 25.4k| e1 += nd - k; 2636| | 2637| 25.4k|#ifdef IEEE_Arith 2638| |#ifdef SET_INEXACT 2639| | bc.inexact = 1; 2640| | if (k <= DBL_DIG) 2641| | oldinexact = get_inexact(); 2642| |#endif 2643| 25.4k|#ifdef Avoid_Underflow 2644| 25.4k| bc.scale = 0; 2645| 25.4k|#endif 2646| |#ifdef Honor_FLT_ROUNDS 2647| | if (bc.rounding >= 2) { 2648| | if (sign) 2649| | bc.rounding = bc.rounding == 2 ? 0 : 2; 2650| | else 2651| | if (bc.rounding != 2) 2652| | bc.rounding = 0; 2653| | } 2654| |#endif 2655| 25.4k|#endif /*IEEE_Arith*/ 2656| | 2657| | /* Get starting approximation = rv * 10**e1 */ 2658| | 2659| 25.4k| if (e1 > 0) { ------------------ | Branch (2659:6): [True: 16.3k, False: 9.06k] ------------------ 2660| 16.3k| if ((i = e1 & 15)) ------------------ | Branch (2660:7): [True: 15.3k, False: 996] ------------------ 2661| 15.3k| dval(&rv) *= tens[i]; ------------------ | | 314| 15.3k|#define dval(x) (x)->d ------------------ 2662| 16.3k| if (e1 &= ~15) { ------------------ | Branch (2662:7): [True: 8.61k, False: 7.77k] ------------------ 2663| 8.61k| if (e1 > DBL_MAX_10_EXP) { ------------------ | Branch (2663:8): [True: 1.36k, False: 7.24k] ------------------ 2664| 2.26k| ovfl: 2665| | /* Can't trust HUGE_VAL */ 2666| 2.26k|#ifdef IEEE_Arith 2667| |#ifdef Honor_FLT_ROUNDS 2668| | switch(bc.rounding) { 2669| | case 0: /* toward 0 */ 2670| | case 3: /* toward -infinity */ 2671| | word0(&rv) = Big0; 2672| | word1(&rv) = Big1; 2673| | break; 2674| | default: 2675| | word0(&rv) = Exp_mask; 2676| | word1(&rv) = 0; 2677| | } 2678| |#else /*Honor_FLT_ROUNDS*/ 2679| 2.26k| word0(&rv) = Exp_mask; ------------------ | | 308| 2.26k|#define word0(x) (x)->L[1] ------------------ word0(&rv) = Exp_mask; ------------------ | | 349| 2.26k|#define Exp_mask 0x7ff00000 ------------------ 2680| 2.26k| word1(&rv) = 0; ------------------ | | 309| 2.26k|#define word1(x) (x)->L[0] ------------------ 2681| 2.26k|#endif /*Honor_FLT_ROUNDS*/ 2682| |#ifdef SET_INEXACT 2683| | /* set overflow bit */ 2684| | dval(&rv0) = 1e300; 2685| | dval(&rv0) *= dval(&rv0); 2686| |#endif 2687| |#else /*IEEE_Arith*/ 2688| | word0(&rv) = Big0; 2689| | word1(&rv) = Big1; 2690| |#endif /*IEEE_Arith*/ 2691| 3.75k| range_err: 2692| 3.75k| if (bd0) { ------------------ | Branch (2692:9): [True: 234, False: 3.52k] ------------------ 2693| 234| Bfree(C, bb); 2694| 234| Bfree(C, bd); 2695| 234| Bfree(C, bs); 2696| 234| Bfree(C, bd0); 2697| 234| Bfree(C, delta); 2698| 234| } 2699| |#ifndef NO_ERRNO 2700| | errno = ERANGE; 2701| |#endif 2702| 3.75k| goto ret; 2703| 2.26k| } 2704| 7.24k| e1 >>= 4; 2705| 25.0k| for(j = 0; e1 > 1; j++, e1 >>= 1) ------------------ | Branch (2705:15): [True: 17.8k, False: 7.24k] ------------------ 2706| 17.8k| if (e1 & 1) ------------------ | Branch (2706:9): [True: 7.75k, False: 10.0k] ------------------ 2707| 7.75k| dval(&rv) *= bigtens[j]; ------------------ | | 314| 7.75k|#define dval(x) (x)->d ------------------ 2708| | /* The last multiplication could overflow. */ 2709| 7.24k| word0(&rv) -= P*Exp_msk1; ------------------ | | 308| 7.24k|#define word0(x) (x)->L[1] ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 350| 7.24k|#define P 53 ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 347| 7.24k|#define Exp_msk1 0x100000 ------------------ 2710| 7.24k| dval(&rv) *= bigtens[j]; ------------------ | | 314| 7.24k|#define dval(x) (x)->d ------------------ 2711| 7.24k| if ((z = word0(&rv) & Exp_mask) ------------------ | | 308| 7.24k|#define word0(x) (x)->L[1] ------------------ if ((z = word0(&rv) & Exp_mask) ------------------ | | 349| 7.24k|#define Exp_mask 0x7ff00000 ------------------ | Branch (2711:8): [True: 661, False: 6.58k] ------------------ 2712| 7.24k| > Exp_msk1*(DBL_MAX_EXP+Bias-P)) ------------------ | | 347| 7.24k|#define Exp_msk1 0x100000 ------------------ > Exp_msk1*(DBL_MAX_EXP+Bias-P)) ------------------ | | 352| 7.24k|#define Bias 1023 ------------------ > Exp_msk1*(DBL_MAX_EXP+Bias-P)) ------------------ | | 350| 7.24k|#define P 53 ------------------ 2713| 661| goto ovfl; 2714| 6.58k| if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) { ------------------ | | 347| 6.58k|#define Exp_msk1 0x100000 ------------------ if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) { ------------------ | | 352| 6.58k|#define Bias 1023 ------------------ if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) { ------------------ | | 350| 6.58k|#define P 53 ------------------ | Branch (2714:8): [True: 234, False: 6.34k] ------------------ 2715| | /* set to largest number */ 2716| | /* (Can't trust DBL_MAX) */ 2717| 234| word0(&rv) = Big0; ------------------ | | 308| 234|#define word0(x) (x)->L[1] ------------------ word0(&rv) = Big0; ------------------ | | 478| 234|#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 359| 234|#define Frac_mask1 0xfffff | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 347| 234|#define Exp_msk1 0x100000 | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 352| 234|#define Bias 1023 | | ------------------ ------------------ 2718| 234| word1(&rv) = Big1; ------------------ | | 309| 234|#define word1(x) (x)->L[0] ------------------ word1(&rv) = Big1; ------------------ | | 479| 234|#define Big1 0xffffffff ------------------ 2719| 234| } 2720| 6.34k| else 2721| 6.34k| word0(&rv) += P*Exp_msk1; ------------------ | | 308| 6.34k|#define word0(x) (x)->L[1] ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 350| 6.34k|#define P 53 ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 347| 6.34k|#define Exp_msk1 0x100000 ------------------ 2722| 6.58k| } 2723| 16.3k| } 2724| 9.06k| else if (e1 < 0) { ------------------ | Branch (2724:11): [True: 7.99k, False: 1.06k] ------------------ 2725| 7.99k| e1 = -e1; 2726| 7.99k| if ((i = e1 & 15)) ------------------ | Branch (2726:7): [True: 7.44k, False: 545] ------------------ 2727| 7.44k| dval(&rv) /= tens[i]; ------------------ | | 314| 7.44k|#define dval(x) (x)->d ------------------ 2728| 7.99k| if (e1 >>= 4) { ------------------ | Branch (2728:7): [True: 7.40k, False: 591] ------------------ 2729| 7.40k| if (e1 >= 1 << n_bigtens) ------------------ | | 1375| 7.40k|#define n_bigtens 5 ------------------ | Branch (2729:8): [True: 0, False: 7.40k] ------------------ 2730| 0| goto undfl; 2731| 7.40k|#ifdef Avoid_Underflow 2732| 7.40k| if (e1 & Scale_Bit) ------------------ | | 1374| 7.40k|#define Scale_Bit 0x10 ------------------ | Branch (2732:8): [True: 5.98k, False: 1.41k] ------------------ 2733| 5.98k| bc.scale = 2*P; ------------------ | | 350| 5.98k|#define P 53 ------------------ 2734| 40.1k| for(j = 0; e1 > 0; j++, e1 >>= 1) ------------------ | Branch (2734:15): [True: 32.7k, False: 7.40k] ------------------ 2735| 32.7k| if (e1 & 1) ------------------ | Branch (2735:9): [True: 16.3k, False: 16.3k] ------------------ 2736| 16.3k| dval(&rv) *= tinytens[j]; ------------------ | | 314| 16.3k|#define dval(x) (x)->d ------------------ 2737| 7.40k| if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask) ------------------ | | 350| 5.98k|#define P 53 ------------------ if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask) ------------------ | | 308| 5.98k|#define word0(x) (x)->L[1] ------------------ if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask) ------------------ | | 349| 5.98k|#define Exp_mask 0x7ff00000 ------------------ | Branch (2737:8): [True: 5.98k, False: 1.41k] | Branch (2737:20): [True: 5.36k, False: 622] ------------------ 2738| 5.98k| >> Exp_shift)) > 0) { ------------------ | | 345| 5.98k|#define Exp_shift 20 ------------------ 2739| | /* scaled rv is denormal; clear j low bits */ 2740| 5.36k| if (j >= 32) { ------------------ | Branch (2740:9): [True: 4.25k, False: 1.10k] ------------------ 2741| 4.25k| if (j > 54) ------------------ | Branch (2741:10): [True: 1.49k, False: 2.76k] ------------------ 2742| 1.49k| goto undfl; 2743| 2.76k| word1(&rv) = 0; ------------------ | | 309| 2.76k|#define word1(x) (x)->L[0] ------------------ 2744| 2.76k| if (j >= 53) ------------------ | Branch (2744:10): [True: 641, False: 2.12k] ------------------ 2745| 641| word0(&rv) = (P+2)*Exp_msk1; ------------------ | | 308| 641|#define word0(x) (x)->L[1] ------------------ word0(&rv) = (P+2)*Exp_msk1; ------------------ | | 350| 641|#define P 53 ------------------ word0(&rv) = (P+2)*Exp_msk1; ------------------ | | 347| 641|#define Exp_msk1 0x100000 ------------------ 2746| 2.12k| else 2747| 2.12k| word0(&rv) &= 0xffffffff << (j-32); ------------------ | | 308| 2.12k|#define word0(x) (x)->L[1] ------------------ 2748| 2.76k| } 2749| 1.10k| else 2750| 1.10k| word1(&rv) &= 0xffffffff << j; ------------------ | | 309| 1.10k|#define word1(x) (x)->L[0] ------------------ 2751| 5.36k| } 2752| |#else 2753| | for(j = 0; e1 > 1; j++, e1 >>= 1) 2754| | if (e1 & 1) 2755| | dval(&rv) *= tinytens[j]; 2756| | /* The last multiplication could underflow. */ 2757| | dval(&rv0) = dval(&rv); 2758| | dval(&rv) *= tinytens[j]; 2759| | if (!dval(&rv)) { 2760| | dval(&rv) = 2.*dval(&rv0); 2761| | dval(&rv) *= tinytens[j]; 2762| |#endif 2763| 5.91k| if (!dval(&rv)) { ------------------ | | 314| 5.91k|#define dval(x) (x)->d ------------------ | Branch (2763:9): [True: 0, False: 5.91k] ------------------ 2764| 1.49k| undfl: 2765| 1.49k| dval(&rv) = 0.; ------------------ | | 314| 1.49k|#define dval(x) (x)->d ------------------ 2766| 1.49k| goto range_err; 2767| 0| } 2768| |#ifndef Avoid_Underflow 2769| | word0(&rv) = Tiny0; 2770| | word1(&rv) = Tiny1; 2771| | /* The refinement below will clean 2772| | * this approximation up. 2773| | */ 2774| | } 2775| |#endif 2776| 5.91k| } 2777| 7.99k| } 2778| | 2779| | /* Now the hard part -- adjusting rv to the correct value.*/ 2780| | 2781| | /* Put digits into bd: true value = bd * 10^e */ 2782| | 2783| 21.9k| bc.nd = nd - nz1; 2784| 21.9k|#ifndef NO_STRTOD_BIGCOMP 2785| 21.9k| bc.nd0 = nd0; /* Only needed if nd > strtod_diglim, but done here */ 2786| | /* to silence an erroneous warning about bc.nd0 */ 2787| | /* possibly not being initialized. */ 2788| 21.9k| if (nd > strtod_diglim) { ------------------ | | 323| 21.9k|#define strtod_diglim STRTOD_DIGLIM | | ------------------ | | | | 317| 21.9k|#define STRTOD_DIGLIM 40 | | ------------------ ------------------ | Branch (2788:6): [True: 0, False: 21.9k] ------------------ 2789| | /* ASSERT(strtod_diglim >= 18); 18 == one more than the */ 2790| | /* minimum number of decimal digits to distinguish double values */ 2791| | /* in IEEE arithmetic. */ 2792| 0| i = j = 18; 2793| 0| if (i > nd0) ------------------ | Branch (2793:7): [True: 0, False: 0] ------------------ 2794| 0| j += bc.dplen; 2795| 0| for(;;) { 2796| 0| if (--j < bc.dp1 && j >= bc.dp0) ------------------ | Branch (2796:8): [True: 0, False: 0] | Branch (2796:24): [True: 0, False: 0] ------------------ 2797| 0| j = bc.dp0 - 1; 2798| 0| if (s0[j] != '0') ------------------ | Branch (2798:8): [True: 0, False: 0] ------------------ 2799| 0| break; 2800| 0| --i; 2801| 0| } 2802| 0| e += nd - i; 2803| 0| nd = i; 2804| 0| if (nd0 > nd) ------------------ | Branch (2804:7): [True: 0, False: 0] ------------------ 2805| 0| nd0 = nd; 2806| 0| if (nd < 9) { /* must recompute y */ ------------------ | Branch (2806:7): [True: 0, False: 0] ------------------ 2807| 0| y = 0; 2808| 0| for(i = 0; i < nd0; ++i) ------------------ | Branch (2808:15): [True: 0, False: 0] ------------------ 2809| 0| y = 10*y + s0[i] - '0'; 2810| 0| for(j = bc.dp1; i < nd; ++i) ------------------ | Branch (2810:20): [True: 0, False: 0] ------------------ 2811| 0| y = 10*y + s0[j++] - '0'; 2812| 0| } 2813| 0| } 2814| 21.9k|#endif 2815| 21.9k| bd0 = s2b(C, s0, nd0, nd, y, bc.dplen); 2816| | 2817| 27.2k| for(;;) { 2818| 27.2k| bd = Balloc(C, bd0->k); 2819| 27.2k| Bcopy(bd, bd0); ------------------ | | 586| 27.2k|#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ | | 587| 27.2k|y->wds*sizeof(Long) + 2*sizeof(int)) ------------------ 2820| 27.2k| bb = d2b(C, &rv, &bbe, &bbbits); /* rv = bb * 2^bbe */ 2821| 27.2k| bs = i2b(C, 1); 2822| | 2823| 27.2k| if (e >= 0) { ------------------ | Branch (2823:7): [True: 17.4k, False: 9.77k] ------------------ 2824| 17.4k| bb2 = bb5 = 0; 2825| 17.4k| bd2 = bd5 = e; 2826| 17.4k| } 2827| 9.77k| else { 2828| 9.77k| bb2 = bb5 = -e; 2829| 9.77k| bd2 = bd5 = 0; 2830| 9.77k| } 2831| 27.2k| if (bbe >= 0) ------------------ | Branch (2831:7): [True: 17.4k, False: 9.74k] ------------------ 2832| 17.4k| bb2 += bbe; 2833| 9.74k| else 2834| 9.74k| bd2 -= bbe; 2835| 27.2k| bs2 = bb2; 2836| |#ifdef Honor_FLT_ROUNDS 2837| | if (bc.rounding != 1) 2838| | bs2++; 2839| |#endif 2840| 27.2k|#ifdef Avoid_Underflow 2841| 27.2k| Lsb = LSB; ------------------ | | 364| 27.2k|#define LSB 1 ------------------ 2842| 27.2k| Lsb1 = 0; 2843| 27.2k| j = bbe - bc.scale; 2844| 27.2k| i = j + bbbits - 1; /* logb(rv) */ 2845| 27.2k| j = P + 1 - bbbits; ------------------ | | 350| 27.2k|#define P 53 ------------------ 2846| 27.2k| if (i < Emin) { /* denormal */ ------------------ | | 354| 27.2k|#define Emin (-1022) ------------------ | Branch (2846:7): [True: 6.37k, False: 20.8k] ------------------ 2847| 6.37k| i = Emin - i; ------------------ | | 354| 6.37k|#define Emin (-1022) ------------------ 2848| 6.37k| j -= i; 2849| 6.37k| if (i < 32) ------------------ | Branch (2849:8): [True: 2.09k, False: 4.27k] ------------------ 2850| 2.09k| Lsb <<= i; 2851| 4.27k| else if (i < 52) ------------------ | Branch (2851:13): [True: 3.62k, False: 648] ------------------ 2852| 3.62k| Lsb1 = Lsb << (i-32); 2853| 648| else 2854| 648| Lsb1 = Exp_mask; ------------------ | | 349| 648|#define Exp_mask 0x7ff00000 ------------------ 2855| 6.37k| } 2856| |#else /*Avoid_Underflow*/ 2857| |#ifdef Sudden_Underflow 2858| |#ifdef IBM 2859| | j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3); 2860| |#else 2861| | j = P + 1 - bbbits; 2862| |#endif 2863| |#else /*Sudden_Underflow*/ 2864| | j = bbe; 2865| | i = j + bbbits - 1; /* logb(rv) */ 2866| | if (i < Emin) /* denormal */ 2867| | j += P - Emin; 2868| | else 2869| | j = P + 1 - bbbits; 2870| |#endif /*Sudden_Underflow*/ 2871| |#endif /*Avoid_Underflow*/ 2872| 27.2k| bb2 += j; 2873| 27.2k| bd2 += j; 2874| 27.2k|#ifdef Avoid_Underflow 2875| 27.2k| bd2 += bc.scale; 2876| 27.2k|#endif 2877| 27.2k| i = bb2 < bd2 ? bb2 : bd2; ------------------ | Branch (2877:7): [True: 9.50k, False: 17.7k] ------------------ 2878| 27.2k| if (i > bs2) ------------------ | Branch (2878:7): [True: 10.4k, False: 16.8k] ------------------ 2879| 10.4k| i = bs2; 2880| 27.2k| if (i > 0) { ------------------ | Branch (2880:7): [True: 26.7k, False: 514] ------------------ 2881| 26.7k| bb2 -= i; 2882| 26.7k| bd2 -= i; 2883| 26.7k| bs2 -= i; 2884| 26.7k| } 2885| 27.2k| if (bb5 > 0) { ------------------ | Branch (2885:7): [True: 9.77k, False: 17.4k] ------------------ 2886| 9.77k| bs = pow5mult(C, bs, bb5); 2887| 9.77k| bb1 = mult(C, bs, bb); 2888| 9.77k| Bfree(C, bb); 2889| 9.77k| bb = bb1; 2890| 9.77k| } 2891| 27.2k| if (bb2 > 0) ------------------ | Branch (2891:7): [True: 27.2k, False: 0] ------------------ 2892| 27.2k| bb = lshift(C, bb, bb2); 2893| 27.2k| if (bd5 > 0) ------------------ | Branch (2893:7): [True: 14.5k, False: 12.6k] ------------------ 2894| 14.5k| bd = pow5mult(C, bd, bd5); 2895| 27.2k| if (bd2 > 0) ------------------ | Branch (2895:7): [True: 10.4k, False: 16.8k] ------------------ 2896| 10.4k| bd = lshift(C, bd, bd2); 2897| 27.2k| if (bs2 > 0) ------------------ | Branch (2897:7): [True: 15.6k, False: 11.5k] ------------------ 2898| 15.6k| bs = lshift(C, bs, bs2); 2899| 27.2k| delta = diff(C, bb, bd); 2900| 27.2k| bc.dsign = delta->sign; 2901| 27.2k| delta->sign = 0; 2902| 27.2k| i = cmp(C, delta, bs); 2903| 27.2k|#ifndef NO_STRTOD_BIGCOMP /*{*/ 2904| 27.2k| if (bc.nd > nd && i <= 0) { ------------------ | Branch (2904:7): [True: 0, False: 27.2k] | Branch (2904:21): [True: 0, False: 0] ------------------ 2905| 0| if (bc.dsign) { ------------------ | Branch (2905:8): [True: 0, False: 0] ------------------ 2906| | /* Must use bigcomp(C, ). */ 2907| 0| req_bigcomp = 1; 2908| 0| break; 2909| 0| } 2910| |#ifdef Honor_FLT_ROUNDS 2911| | if (bc.rounding != 1) { 2912| | if (i < 0) { 2913| | req_bigcomp = 1; 2914| | break; 2915| | } 2916| | } 2917| | else 2918| |#endif 2919| 0| i = -1; /* Discarded digits make delta smaller. */ 2920| 0| } 2921| 27.2k|#endif /*}*/ 2922| |#ifdef Honor_FLT_ROUNDS /*{*/ 2923| | if (bc.rounding != 1) { 2924| | if (i < 0) { 2925| | /* Error is less than an ulp */ 2926| | if (!delta->x[0] && delta->wds <= 1) { 2927| | /* exact */ 2928| |#ifdef SET_INEXACT 2929| | bc.inexact = 0; 2930| |#endif 2931| | break; 2932| | } 2933| | if (bc.rounding) { 2934| | if (bc.dsign) { 2935| | adj.d = 1.; 2936| | goto apply_adj; 2937| | } 2938| | } 2939| | else if (!bc.dsign) { 2940| | adj.d = -1.; 2941| | if (!word1(&rv) 2942| | && !(word0(&rv) & Frac_mask)) { 2943| | y = word0(&rv) & Exp_mask; 2944| | test_scale = y; 2945| |#ifdef Avoid_Underflow 2946| | test_scale = (!bc.scale || y > 2*P*Exp_msk1); 2947| |#endif 2948| | if (test_scale) { 2949| | delta = lshift(C, delta,Log2P); 2950| | if (cmp(C, delta, bs) <= 0) 2951| | adj.d = -0.5; 2952| | } 2953| | } 2954| | apply_adj: 2955| |#ifdef Avoid_Underflow /*{*/ 2956| | if (bc.scale && (y = word0(&rv) & Exp_mask) 2957| | <= 2*P*Exp_msk1) 2958| | word0(&adj) += (2*P+1)*Exp_msk1 - y; 2959| |#else 2960| |#ifdef Sudden_Underflow 2961| | if ((word0(&rv) & Exp_mask) <= 2962| | P*Exp_msk1) { 2963| | word0(&rv) += P*Exp_msk1; 2964| | dval(&rv) += adj.d*ulp(C, dval(&rv)); 2965| | word0(&rv) -= P*Exp_msk1; 2966| | } 2967| | else 2968| |#endif /*Sudden_Underflow*/ 2969| |#endif /*Avoid_Underflow}*/ 2970| | dval(&rv) += adj.d*ulp(C, &rv); 2971| | } 2972| | break; 2973| | } 2974| | adj.d = ratio(C, delta, bs); 2975| | if (adj.d < 1.) 2976| | adj.d = 1.; 2977| | if (adj.d <= 0x7ffffffe) { 2978| | /* adj = rounding ? ceil(adj) : floor(adj); */ 2979| | y = adj.d; 2980| | if (y != adj.d) { 2981| | if (!((bc.rounding>>1) ^ bc.dsign)) 2982| | y++; 2983| | adj.d = y; 2984| | } 2985| | } 2986| |#ifdef Avoid_Underflow /*{*/ 2987| | if (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1) 2988| | word0(&adj) += (2*P+1)*Exp_msk1 - y; 2989| |#else 2990| |#ifdef Sudden_Underflow 2991| | if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) { 2992| | word0(&rv) += P*Exp_msk1; 2993| | adj.d *= ulp(C, dval(&rv)); 2994| | if (bc.dsign) 2995| | dval(&rv) += adj.d; 2996| | else 2997| | dval(&rv) -= adj.d; 2998| | word0(&rv) -= P*Exp_msk1; 2999| | goto cont; 3000| | } 3001| |#endif /*Sudden_Underflow*/ 3002| |#endif /*Avoid_Underflow}*/ 3003| | adj.d *= ulp(C, &rv); 3004| | if (bc.dsign) { 3005| | if (word0(&rv) == Big0 && word1(&rv) == Big1) 3006| | goto ovfl; 3007| | dval(&rv) += adj.d; 3008| | } 3009| | else 3010| | dval(&rv) -= adj.d; 3011| | goto cont; 3012| | } 3013| |#endif /*}Honor_FLT_ROUNDS*/ 3014| | 3015| 27.2k| if (i < 0) { ------------------ | Branch (3015:7): [True: 11.0k, False: 16.1k] ------------------ 3016| | /* Error is less than half an ulp -- check for 3017| | * special case of mantissa a power of two. 3018| | */ 3019| 11.0k| if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask ------------------ | | 309| 19.5k|#define word1(x) (x)->L[0] | | ------------------ | | | Branch (309:18): [True: 5.94k, False: 2.56k] | | ------------------ ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask ------------------ | | 308| 2.56k|#define word0(x) (x)->L[1] ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask ------------------ | | 362| 13.6k|#define Bndry_mask 0xfffff ------------------ | Branch (3019:8): [True: 2.53k, False: 8.50k] | Branch (3019:34): [True: 1.51k, False: 1.05k] ------------------ 3020| 1.05k|#ifdef IEEE_Arith /*{*/ 3021| 1.05k|#ifdef Avoid_Underflow 3022| 1.05k| || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 308| 1.05k|#define word0(x) (x)->L[1] ------------------ || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 349| 1.05k|#define Exp_mask 0x7ff00000 ------------------ || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 350| 1.05k|#define P 53 ------------------ || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 347| 1.05k|#define Exp_msk1 0x100000 ------------------ | Branch (3022:8): [True: 235, False: 815] ------------------ 3023| |#else 3024| | || (word0(&rv) & Exp_mask) <= Exp_msk1 3025| |#endif 3026| 11.0k|#endif /*}*/ 3027| 11.0k| ) { 3028| |#ifdef SET_INEXACT 3029| | if (!delta->x[0] && delta->wds <= 1) 3030| | bc.inexact = 0; 3031| |#endif 3032| 10.2k| break; 3033| 10.2k| } 3034| 815| if (!delta->x[0] && delta->wds <= 1) { ------------------ | Branch (3034:8): [True: 233, False: 582] | Branch (3034:24): [True: 0, False: 233] ------------------ 3035| | /* exact result */ 3036| |#ifdef SET_INEXACT 3037| | bc.inexact = 0; 3038| |#endif 3039| 0| break; 3040| 0| } 3041| 815| delta = lshift(C, delta,Log2P); ------------------ | | 366| 815|#define Log2P 1 ------------------ 3042| 815| if (cmp(C, delta, bs) > 0) ------------------ | Branch (3042:8): [True: 467, False: 348] ------------------ 3043| 467| goto drop_down; 3044| 348| break; 3045| 815| } 3046| 16.1k| if (i == 0) { ------------------ | Branch (3046:7): [True: 3.27k, False: 12.9k] ------------------ 3047| | /* exactly half-way between */ 3048| 3.27k| if (bc.dsign) { ------------------ | Branch (3048:8): [True: 1.90k, False: 1.36k] ------------------ 3049| 1.90k| if ((word0(&rv) & Bndry_mask1) == Bndry_mask1 ------------------ | | 308| 1.90k|#define word0(x) (x)->L[1] ------------------ if ((word0(&rv) & Bndry_mask1) == Bndry_mask1 ------------------ | | 363| 1.90k|#define Bndry_mask1 0xfffff ------------------ if ((word0(&rv) & Bndry_mask1) == Bndry_mask1 ------------------ | | 363| 3.81k|#define Bndry_mask1 0xfffff ------------------ | Branch (3049:9): [True: 1.01k, False: 894] ------------------ 3050| 1.01k| && word1(&rv) == ( ------------------ | | 309| 1.01k|#define word1(x) (x)->L[0] ------------------ | Branch (3050:10): [True: 0, False: 1.01k] ------------------ 3051| 1.01k|#ifdef Avoid_Underflow 3052| 1.01k| (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1) ------------------ | | 349| 0|#define Exp_mask 0x7ff00000 ------------------ (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1) ------------------ | | 350| 0|#define P 53 ------------------ (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1) ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ | Branch (3052:5): [True: 0, False: 1.01k] | Branch (3052:17): [True: 0, False: 0] ------------------ 3053| 1.01k| ? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) : ------------------ | | 350| 0|#define P 53 ------------------ ? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) : ------------------ | | 345| 0|#define Exp_shift 20 ------------------ 3054| 1.01k|#endif 3055| 1.01k| 0xffffffff)) { 3056| | /*boundary case -- increment exponent*/ 3057| 0| if (word0(&rv) == Big0 && word1(&rv) == Big1) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ if (word0(&rv) == Big0 && word1(&rv) == Big1) ------------------ | | 478| 0|#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 359| 0|#define Frac_mask1 0xfffff | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 347| 0|#define Exp_msk1 0x100000 | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 352| 0|#define Bias 1023 | | ------------------ ------------------ if (word0(&rv) == Big0 && word1(&rv) == Big1) ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ if (word0(&rv) == Big0 && word1(&rv) == Big1) ------------------ | | 479| 0|#define Big1 0xffffffff ------------------ | Branch (3057:10): [True: 0, False: 0] | Branch (3057:32): [True: 0, False: 0] ------------------ 3058| 0| goto ovfl; 3059| 0| word0(&rv) = (word0(&rv) & Exp_mask) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&rv) = (word0(&rv) & Exp_mask) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&rv) = (word0(&rv) & Exp_mask) ------------------ | | 349| 0|#define Exp_mask 0x7ff00000 ------------------ 3060| 0| + Exp_msk1 ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ 3061| |#ifdef IBM 3062| | | Exp_msk1 >> 4 3063| |#endif 3064| 0| ; 3065| 0| word1(&rv) = 0; ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ 3066| 0|#ifdef Avoid_Underflow 3067| 0| bc.dsign = 0; 3068| 0|#endif 3069| 0| break; 3070| 0| } 3071| 1.90k| } 3072| 1.36k| else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) { ------------------ | | 308| 1.36k|#define word0(x) (x)->L[1] ------------------ else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) { ------------------ | | 362| 1.36k|#define Bndry_mask 0xfffff ------------------ else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) { ------------------ | | 309| 394|#define word1(x) (x)->L[0] ------------------ | Branch (3072:13): [True: 394, False: 970] | Branch (3072:43): [True: 0, False: 394] ------------------ 3073| 467| drop_down: 3074| | /* boundary case -- decrement exponent */ 3075| |#ifdef Sudden_Underflow /*{{*/ 3076| | L = word0(&rv) & Exp_mask; 3077| |#ifdef IBM 3078| | if (L < Exp_msk1) 3079| |#else 3080| |#ifdef Avoid_Underflow 3081| | if (L <= (bc.scale ? (2*P+1)*Exp_msk1 : Exp_msk1)) 3082| |#else 3083| | if (L <= Exp_msk1) 3084| |#endif /*Avoid_Underflow*/ 3085| |#endif /*IBM*/ 3086| | { 3087| | if (bc.nd >nd) { 3088| | bc.uflchk = 1; 3089| | break; 3090| | } 3091| | goto undfl; 3092| | } 3093| | L -= Exp_msk1; 3094| |#else /*Sudden_Underflow}{*/ 3095| 467|#ifdef Avoid_Underflow 3096| 467| if (bc.scale) { ------------------ | Branch (3096:9): [True: 0, False: 467] ------------------ 3097| 0| L = word0(&rv) & Exp_mask; ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ L = word0(&rv) & Exp_mask; ------------------ | | 349| 0|#define Exp_mask 0x7ff00000 ------------------ 3098| 0| if (L <= (2*P+1)*Exp_msk1) { ------------------ | | 350| 0|#define P 53 ------------------ if (L <= (2*P+1)*Exp_msk1) { ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ | Branch (3098:10): [True: 0, False: 0] ------------------ 3099| 0| if (L > (P+2)*Exp_msk1) ------------------ | | 350| 0|#define P 53 ------------------ if (L > (P+2)*Exp_msk1) ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ | Branch (3099:11): [True: 0, False: 0] ------------------ 3100| | /* round even ==> */ 3101| | /* accept rv */ 3102| 0| break; 3103| | /* rv = smallest denormal */ 3104| 0| if (bc.nd >nd) { ------------------ | Branch (3104:11): [True: 0, False: 0] ------------------ 3105| 0| bc.uflchk = 1; 3106| 0| break; 3107| 0| } 3108| 0| goto undfl; 3109| 0| } 3110| 0| } 3111| 467|#endif /*Avoid_Underflow*/ 3112| 467| L = (word0(&rv) & Exp_mask) - Exp_msk1; ------------------ | | 308| 467|#define word0(x) (x)->L[1] ------------------ L = (word0(&rv) & Exp_mask) - Exp_msk1; ------------------ | | 349| 467|#define Exp_mask 0x7ff00000 ------------------ L = (word0(&rv) & Exp_mask) - Exp_msk1; ------------------ | | 347| 467|#define Exp_msk1 0x100000 ------------------ 3113| 467|#endif /*Sudden_Underflow}}*/ 3114| 467| word0(&rv) = L | Bndry_mask1; ------------------ | | 308| 467|#define word0(x) (x)->L[1] ------------------ word0(&rv) = L | Bndry_mask1; ------------------ | | 363| 467|#define Bndry_mask1 0xfffff ------------------ 3115| 467| word1(&rv) = 0xffffffff; ------------------ | | 309| 467|#define word1(x) (x)->L[0] ------------------ 3116| |#ifdef IBM 3117| | goto cont; 3118| |#else 3119| 467|#ifndef NO_STRTOD_BIGCOMP 3120| 467| if (bc.nd > nd) ------------------ | Branch (3120:9): [True: 0, False: 467] ------------------ 3121| 0| goto cont; 3122| 467|#endif 3123| 467| break; 3124| 467|#endif 3125| 467| } 3126| 3.27k|#ifndef ROUND_BIASED 3127| 3.27k|#ifdef Avoid_Underflow 3128| 3.27k| if (Lsb1) { ------------------ | Branch (3128:8): [True: 0, False: 3.27k] ------------------ 3129| 0| if (!(word0(&rv) & Lsb1)) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ | Branch (3129:9): [True: 0, False: 0] ------------------ 3130| 0| break; 3131| 0| } 3132| 3.27k| else if (!(word1(&rv) & Lsb)) ------------------ | | 309| 3.27k|#define word1(x) (x)->L[0] ------------------ | Branch (3132:13): [True: 2.66k, False: 608] ------------------ 3133| 2.66k| break; 3134| |#else 3135| | if (!(word1(&rv) & LSB)) 3136| | break; 3137| |#endif 3138| 608|#endif 3139| 608| if (bc.dsign) ------------------ | Branch (3139:8): [True: 234, False: 374] ------------------ 3140| 234|#ifdef Avoid_Underflow 3141| 234| dval(&rv) += sulp(C, &rv, &bc); ------------------ | | 314| 234|#define dval(x) (x)->d ------------------ 3142| |#else 3143| | dval(&rv) += ulp(C, &rv); 3144| |#endif 3145| 374|#ifndef ROUND_BIASED 3146| 374| else { 3147| 374|#ifdef Avoid_Underflow 3148| 374| dval(&rv) -= sulp(C, &rv, &bc); ------------------ | | 314| 374|#define dval(x) (x)->d ------------------ 3149| |#else 3150| | dval(&rv) -= ulp(C, &rv); 3151| |#endif 3152| 374|#ifndef Sudden_Underflow 3153| 374| if (!dval(&rv)) { ------------------ | | 314| 374|#define dval(x) (x)->d ------------------ | Branch (3153:9): [True: 0, False: 374] ------------------ 3154| 0| if (bc.nd >nd) { ------------------ | Branch (3154:10): [True: 0, False: 0] ------------------ 3155| 0| bc.uflchk = 1; 3156| 0| break; 3157| 0| } 3158| 0| goto undfl; 3159| 0| } 3160| 374|#endif 3161| 374| } 3162| 608|#ifdef Avoid_Underflow 3163| 608| bc.dsign = 1 - bc.dsign; 3164| 608|#endif 3165| 608|#endif 3166| 608| break; 3167| 608| } 3168| 12.9k| if ((aadj = ratio(C, delta, bs)) <= 2.) { ------------------ | Branch (3168:7): [True: 7.86k, False: 5.05k] ------------------ 3169| 7.86k| if (bc.dsign) ------------------ | Branch (3169:8): [True: 4.63k, False: 3.23k] ------------------ 3170| 4.63k| aadj = aadj1 = 1.; 3171| 3.23k| else if (word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 309| 6.46k|#define word1(x) (x)->L[0] | | ------------------ | | | Branch (309:18): [True: 2.54k, False: 685] | | ------------------ ------------------ else if (word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 308| 685|#define word0(x) (x)->L[1] ------------------ else if (word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 362| 685|#define Bndry_mask 0xfffff ------------------ | Branch (3171:27): [True: 269, False: 416] ------------------ 3172| 2.81k|#ifndef Sudden_Underflow 3173| 2.81k| if (word1(&rv) == Tiny1 && !word0(&rv)) { ------------------ | | 309| 2.81k|#define word1(x) (x)->L[0] ------------------ if (word1(&rv) == Tiny1 && !word0(&rv)) { ------------------ | | 368| 5.63k|#define Tiny1 1 ------------------ if (word1(&rv) == Tiny1 && !word0(&rv)) { ------------------ | | 308| 88|#define word0(x) (x)->L[1] ------------------ | Branch (3173:9): [True: 88, False: 2.72k] | Branch (3173:32): [True: 0, False: 88] ------------------ 3174| 0| if (bc.nd >nd) { ------------------ | Branch (3174:10): [True: 0, False: 0] ------------------ 3175| 0| bc.uflchk = 1; 3176| 0| break; 3177| 0| } 3178| 0| goto undfl; 3179| 0| } 3180| 2.81k|#endif 3181| 2.81k| aadj = 1.; 3182| 2.81k| aadj1 = -1.; 3183| 2.81k| } 3184| 416| else { 3185| | /* special case -- power of FLT_RADIX to be */ 3186| | /* rounded down... */ 3187| | 3188| 416| if (aadj < 2./FLT_RADIX) ------------------ | Branch (3188:9): [True: 0, False: 416] ------------------ 3189| 0| aadj = 1./FLT_RADIX; 3190| 416| else 3191| 416| aadj *= 0.5; 3192| 416| aadj1 = -aadj; 3193| 416| } 3194| 7.86k| } 3195| 5.05k| else { 3196| 5.05k| aadj *= 0.5; 3197| 5.05k| aadj1 = bc.dsign ? aadj : -aadj; ------------------ | Branch (3197:12): [True: 3.43k, False: 1.62k] ------------------ 3198| |#ifdef Check_FLT_ROUNDS 3199| | switch(bc.rounding) { 3200| | case 2: /* towards +infinity */ 3201| | aadj1 -= 0.5; 3202| | break; 3203| | case 0: /* towards 0 */ 3204| | case 3: /* towards -infinity */ 3205| | aadj1 += 0.5; 3206| | } 3207| |#else 3208| 5.05k| if (Flt_Rounds == 0) ------------------ | | 380| 5.05k|#define Flt_Rounds FLT_ROUNDS ------------------ | Branch (3208:8): [True: 0, False: 5.05k] ------------------ 3209| 0| aadj1 += 0.5; 3210| 5.05k|#endif /*Check_FLT_ROUNDS*/ 3211| 5.05k| } 3212| 12.9k| y = word0(&rv) & Exp_mask; ------------------ | | 308| 12.9k|#define word0(x) (x)->L[1] ------------------ y = word0(&rv) & Exp_mask; ------------------ | | 349| 12.9k|#define Exp_mask 0x7ff00000 ------------------ 3213| | 3214| | /* Check for overflow */ 3215| | 3216| 12.9k| if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) { ------------------ | | 347| 12.9k|#define Exp_msk1 0x100000 ------------------ if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) { ------------------ | | 352| 12.9k|#define Bias 1023 ------------------ | Branch (3216:7): [True: 1.36k, False: 11.5k] ------------------ 3217| 1.36k| dval(&rv0) = dval(&rv); ------------------ | | 314| 1.36k|#define dval(x) (x)->d ------------------ dval(&rv0) = dval(&rv); ------------------ | | 314| 1.36k|#define dval(x) (x)->d ------------------ 3218| 1.36k| word0(&rv) -= P*Exp_msk1; ------------------ | | 308| 1.36k|#define word0(x) (x)->L[1] ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 350| 1.36k|#define P 53 ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 347| 1.36k|#define Exp_msk1 0x100000 ------------------ 3219| 1.36k| adj.d = aadj1 * ulp(C, &rv); 3220| 1.36k| dval(&rv) += adj.d; ------------------ | | 314| 1.36k|#define dval(x) (x)->d ------------------ 3221| 1.36k| if ((word0(&rv) & Exp_mask) >= ------------------ | | 308| 1.36k|#define word0(x) (x)->L[1] ------------------ if ((word0(&rv) & Exp_mask) >= ------------------ | | 349| 1.36k|#define Exp_mask 0x7ff00000 ------------------ | Branch (3221:8): [True: 234, False: 1.12k] ------------------ 3222| 1.36k| Exp_msk1*(DBL_MAX_EXP+Bias-P)) { ------------------ | | 347| 1.36k|#define Exp_msk1 0x100000 ------------------ Exp_msk1*(DBL_MAX_EXP+Bias-P)) { ------------------ | | 352| 1.36k|#define Bias 1023 ------------------ Exp_msk1*(DBL_MAX_EXP+Bias-P)) { ------------------ | | 350| 1.36k|#define P 53 ------------------ 3223| 234| if (word0(&rv0) == Big0 && word1(&rv0) == Big1) ------------------ | | 308| 234|#define word0(x) (x)->L[1] ------------------ if (word0(&rv0) == Big0 && word1(&rv0) == Big1) ------------------ | | 478| 468|#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 359| 234|#define Frac_mask1 0xfffff | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 347| 234|#define Exp_msk1 0x100000 | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 352| 234|#define Bias 1023 | | ------------------ ------------------ if (word0(&rv0) == Big0 && word1(&rv0) == Big1) ------------------ | | 309| 234|#define word1(x) (x)->L[0] ------------------ if (word0(&rv0) == Big0 && word1(&rv0) == Big1) ------------------ | | 479| 234|#define Big1 0xffffffff ------------------ | Branch (3223:9): [True: 234, False: 0] | Branch (3223:32): [True: 234, False: 0] ------------------ 3224| 234| goto ovfl; 3225| 0| word0(&rv) = Big0; ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&rv) = Big0; ------------------ | | 478| 0|#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 359| 0|#define Frac_mask1 0xfffff | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 347| 0|#define Exp_msk1 0x100000 | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 352| 0|#define Bias 1023 | | ------------------ ------------------ 3226| 0| word1(&rv) = Big1; ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ word1(&rv) = Big1; ------------------ | | 479| 0|#define Big1 0xffffffff ------------------ 3227| 0| goto cont; 3228| 234| } 3229| 1.12k| else 3230| 1.12k| word0(&rv) += P*Exp_msk1; ------------------ | | 308| 1.12k|#define word0(x) (x)->L[1] ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 350| 1.12k|#define P 53 ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 347| 1.12k|#define Exp_msk1 0x100000 ------------------ 3231| 1.36k| } 3232| 11.5k| else { 3233| 11.5k|#ifdef Avoid_Underflow 3234| 11.5k| if (bc.scale && y <= 2*P*Exp_msk1) { ------------------ | | 350| 3.44k|#define P 53 ------------------ if (bc.scale && y <= 2*P*Exp_msk1) { ------------------ | | 347| 3.44k|#define Exp_msk1 0x100000 ------------------ | Branch (3234:8): [True: 3.44k, False: 8.11k] | Branch (3234:20): [True: 2.91k, False: 531] ------------------ 3235| 2.91k| if (aadj <= 0x7fffffff) { ------------------ | Branch (3235:9): [True: 2.91k, False: 0] ------------------ 3236| 2.91k| if ((z = aadj) <= 0) ------------------ | Branch (3236:10): [True: 416, False: 2.49k] ------------------ 3237| 416| z = 1; 3238| 2.91k| aadj = z; 3239| 2.91k| aadj1 = bc.dsign ? aadj : -aadj; ------------------ | Branch (3239:14): [True: 2.49k, False: 418] ------------------ 3240| 2.91k| } 3241| 2.91k| dval(&aadj2) = aadj1; ------------------ | | 314| 2.91k|#define dval(x) (x)->d ------------------ 3242| 2.91k| word0(&aadj2) += (2*P+1)*Exp_msk1 - y; ------------------ | | 308| 2.91k|#define word0(x) (x)->L[1] ------------------ word0(&aadj2) += (2*P+1)*Exp_msk1 - y; ------------------ | | 350| 2.91k|#define P 53 ------------------ word0(&aadj2) += (2*P+1)*Exp_msk1 - y; ------------------ | | 347| 2.91k|#define Exp_msk1 0x100000 ------------------ 3243| 2.91k| aadj1 = dval(&aadj2); ------------------ | | 314| 2.91k|#define dval(x) (x)->d ------------------ 3244| 2.91k| adj.d = aadj1 * ulp(C, &rv); 3245| 2.91k| dval(&rv) += adj.d; ------------------ | | 314| 2.91k|#define dval(x) (x)->d ------------------ 3246| 2.91k| if (rv.d == 0.) ------------------ | Branch (3246:9): [True: 416, False: 2.49k] ------------------ 3247| |#ifdef NO_STRTOD_BIGCOMP 3248| | goto undfl; 3249| |#else 3250| 416| { 3251| 416| if (bc.nd > nd) ------------------ | Branch (3251:10): [True: 0, False: 416] ------------------ 3252| 0| bc.dsign = 1; 3253| 416| break; 3254| 416| } 3255| 2.91k|#endif 3256| 2.91k| } 3257| 8.64k| else { 3258| 8.64k| adj.d = aadj1 * ulp(C, &rv); 3259| 8.64k| dval(&rv) += adj.d; ------------------ | | 314| 8.64k|#define dval(x) (x)->d ------------------ 3260| 8.64k| } 3261| |#else 3262| |#ifdef Sudden_Underflow 3263| | if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) { 3264| | dval(&rv0) = dval(&rv); 3265| | word0(&rv) += P*Exp_msk1; 3266| | adj.d = aadj1 * ulp(C, &rv); 3267| | dval(&rv) += adj.d; 3268| |#ifdef IBM 3269| | if ((word0(&rv) & Exp_mask) < P*Exp_msk1) 3270| |#else 3271| | if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) 3272| |#endif 3273| | { 3274| | if (word0(&rv0) == Tiny0 3275| | && word1(&rv0) == Tiny1) { 3276| | if (bc.nd >nd) { 3277| | bc.uflchk = 1; 3278| | break; 3279| | } 3280| | goto undfl; 3281| | } 3282| | word0(&rv) = Tiny0; 3283| | word1(&rv) = Tiny1; 3284| | goto cont; 3285| | } 3286| | else 3287| | word0(&rv) -= P*Exp_msk1; 3288| | } 3289| | else { 3290| | adj.d = aadj1 * ulp(C, &rv); 3291| | dval(&rv) += adj.d; 3292| | } 3293| |#else /*Sudden_Underflow*/ 3294| | /* Compute adj so that the IEEE rounding rules will 3295| | * correctly round rv + adj in some half-way cases. 3296| | * If rv * ulp(C, rv) is denormalized (i.e., 3297| | * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid 3298| | * trouble from bits lost to denormalization; 3299| | * example: 1.2e-307 . 3300| | */ 3301| | if (y <= (P-1)*Exp_msk1 && aadj > 1.) { 3302| | aadj1 = (double)(int)(aadj + 0.5); 3303| | if (!bc.dsign) 3304| | aadj1 = -aadj1; 3305| | } 3306| | adj.d = aadj1 * ulp(C, &rv); 3307| | dval(&rv) += adj.d; 3308| |#endif /*Sudden_Underflow*/ 3309| |#endif /*Avoid_Underflow*/ 3310| 11.5k| } 3311| 12.2k| z = word0(&rv) & Exp_mask; ------------------ | | 308| 12.2k|#define word0(x) (x)->L[1] ------------------ z = word0(&rv) & Exp_mask; ------------------ | | 349| 12.2k|#define Exp_mask 0x7ff00000 ------------------ 3312| 12.2k|#ifndef SET_INEXACT 3313| 12.2k| if (bc.nd == nd) { ------------------ | Branch (3313:7): [True: 12.2k, False: 0] ------------------ 3314| 12.2k|#ifdef Avoid_Underflow 3315| 12.2k| if (!bc.scale) ------------------ | Branch (3315:7): [True: 9.24k, False: 3.02k] ------------------ 3316| 9.24k|#endif 3317| 9.24k| if (y == z) { ------------------ | Branch (3317:7): [True: 8.93k, False: 311] ------------------ 3318| | /* Can we stop now? */ 3319| 8.93k| L = (Long)aadj; 3320| 8.93k| aadj -= L; 3321| | /* The tolerances below are conservative. */ 3322| 8.93k| if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 309| 13.2k|#define word1(x) (x)->L[0] | | ------------------ | | | Branch (309:18): [True: 4.23k, False: 88] | | ------------------ ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 308| 88|#define word0(x) (x)->L[1] ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 362| 88|#define Bndry_mask 0xfffff ------------------ | Branch (3322:8): [True: 4.61k, False: 4.32k] | Branch (3322:34): [True: 88, False: 0] ------------------ 3323| 8.93k| if (aadj < .4999999 || aadj > .5000001) ------------------ | Branch (3323:9): [True: 5.62k, False: 3.30k] | Branch (3323:28): [True: 1.34k, False: 1.96k] ------------------ 3324| 6.96k| break; 3325| 8.93k| } 3326| 0| else if (aadj < .4999999/FLT_RADIX) ------------------ | Branch (3326:13): [True: 0, False: 0] ------------------ 3327| 0| break; 3328| 8.93k| } 3329| 12.2k| } 3330| 5.30k|#endif 3331| 5.30k| cont: 3332| 5.30k| Bfree(C, bb); 3333| 5.30k| Bfree(C, bd); 3334| 5.30k| Bfree(C, bs); 3335| 5.30k| Bfree(C, delta); 3336| 5.30k| } 3337| 21.6k| Bfree(C, bb); 3338| 21.6k| Bfree(C, bd); 3339| 21.6k| Bfree(C, bs); 3340| 21.6k| Bfree(C, bd0); 3341| 21.6k| Bfree(C, delta); 3342| 21.6k|#ifndef NO_STRTOD_BIGCOMP 3343| 21.6k| if (req_bigcomp) { ------------------ | Branch (3343:6): [True: 0, False: 21.6k] ------------------ 3344| 0| bd0 = 0; 3345| 0| bc.e0 += nz1; 3346| 0| bigcomp(C, &rv, s0, &bc); 3347| 0| y = word0(&rv) & Exp_mask; ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ y = word0(&rv) & Exp_mask; ------------------ | | 349| 0|#define Exp_mask 0x7ff00000 ------------------ 3348| 0| if (y == Exp_mask) ------------------ | | 349| 0|#define Exp_mask 0x7ff00000 ------------------ | Branch (3348:7): [True: 0, False: 0] ------------------ 3349| 0| goto ovfl; 3350| 0| if (y == 0 && rv.d == 0.) ------------------ | Branch (3350:7): [True: 0, False: 0] | Branch (3350:17): [True: 0, False: 0] ------------------ 3351| 0| goto undfl; 3352| 0| } 3353| 21.6k|#endif 3354| |#ifdef SET_INEXACT 3355| | if (bc.inexact) { 3356| | if (!oldinexact) { 3357| | word0(&rv0) = Exp_1 + (70 << Exp_shift); 3358| | word1(&rv0) = 0; 3359| | dval(&rv0) += 1.; 3360| | } 3361| | } 3362| | else if (!oldinexact) 3363| | clear_inexact(); 3364| |#endif 3365| 21.6k|#ifdef Avoid_Underflow 3366| 21.6k| if (bc.scale) { ------------------ | Branch (3366:6): [True: 4.49k, False: 17.1k] ------------------ 3367| 4.49k| word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 308| 4.49k|#define word0(x) (x)->L[1] ------------------ word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 355| 4.49k|#define Exp_1 0x3ff00000 ------------------ word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 350| 4.49k|#define P 53 ------------------ word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 347| 4.49k|#define Exp_msk1 0x100000 ------------------ 3368| 4.49k| word1(&rv0) = 0; ------------------ | | 309| 4.49k|#define word1(x) (x)->L[0] ------------------ 3369| 4.49k| dval(&rv) *= dval(&rv0); ------------------ | | 314| 4.49k|#define dval(x) (x)->d ------------------ dval(&rv) *= dval(&rv0); ------------------ | | 314| 4.49k|#define dval(x) (x)->d ------------------ 3370| |#ifndef NO_ERRNO 3371| | /* try to avoid the bug of testing an 8087 register value */ 3372| |#ifdef IEEE_Arith 3373| | if (!(word0(&rv) & Exp_mask)) 3374| |#else 3375| | if (word0(&rv) == 0 && word1(&rv) == 0) 3376| |#endif 3377| | errno = ERANGE; 3378| |#endif 3379| 4.49k| } 3380| 21.6k|#endif /* Avoid_Underflow */ 3381| |#ifdef SET_INEXACT 3382| | if (bc.inexact && !(word0(&rv) & Exp_mask)) { 3383| | /* set underflow bit */ 3384| | dval(&rv0) = 1e-300; 3385| | dval(&rv0) *= dval(&rv0); 3386| | } 3387| |#endif 3388| 137k| ret: 3389| 137k| if (se) ------------------ | Branch (3389:6): [True: 137k, False: 0] ------------------ 3390| 137k| *se = (char *)s; 3391| 137k| return sign ? -dval(&rv) : dval(&rv); ------------------ | | 314| 4.50k|#define dval(x) (x)->d ------------------ return sign ? -dval(&rv) : dval(&rv); ------------------ | | 314| 132k|#define dval(x) (x)->d ------------------ | Branch (3391:9): [True: 4.50k, False: 132k] ------------------ 3392| 21.6k| } jvp_freedtoa: 3430| 3.47k|{ 3431| 3.47k| Bigint *b = (Bigint *)((int *)s - 1); 3432| 3.47k| b->maxwds = 1 << (b->k = *(int*)b); 3433| 3.47k| Bfree(C, b); 3434| 3.47k| } jvp_dtoa: 3473| 3.47k|{ 3474| | /* Arguments ndigits, decpt, sign are similar to those 3475| | of ecvt and fcvt; trailing zeros are suppressed from 3476| | the returned string. If not null, *rve is set to point 3477| | to the end of the return value. If d is +-Infinity or NaN, 3478| | then *decpt is set to 9999. 3479| | 3480| | mode: 3481| | 0 ==> shortest string that yields d when read in 3482| | and rounded to nearest. 3483| | 1 ==> like 0, but with Steele & White stopping rule; 3484| | e.g. with IEEE P754 arithmetic , mode 0 gives 3485| | 1e23 whereas mode 1 gives 9.999999999999999e22. 3486| | 2 ==> max(1,ndigits) significant digits. This gives a 3487| | return value similar to that of ecvt, except 3488| | that trailing zeros are suppressed. 3489| | 3 ==> through ndigits past the decimal point. This 3490| | gives a return value similar to that from fcvt, 3491| | except that trailing zeros are suppressed, and 3492| | ndigits can be negative. 3493| | 4,5 ==> similar to 2 and 3, respectively, but (in 3494| | round-nearest mode) with the tests of mode 0 to 3495| | possibly return a shorter string that rounds to d. 3496| | With IEEE arithmetic and compilation with 3497| | -DHonor_FLT_ROUNDS, modes 4 and 5 behave the same 3498| | as modes 2 and 3 when FLT_ROUNDS != 1. 3499| | 6-9 ==> Debugging modes similar to mode - 4: don't try 3500| | fast floating-point estimate (if applicable). 3501| | 3502| | Values of mode other than 0-9 are treated as mode 0. 3503| | 3504| | Sufficient space is allocated to the return value 3505| | to hold the suppressed trailing zeros. 3506| | */ 3507| | 3508| 3.47k| int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1, 3509| 3.47k| j, j1=0, k, k0, k_check, leftright, m2, m5, s2, s5, 3510| 3.47k| spec_case, try_quick; 3511| 3.47k| Long L; ------------------ | | 193| 3.47k|#define Long int ------------------ 3512| 3.47k|#ifndef Sudden_Underflow 3513| 3.47k| int denorm; 3514| 3.47k| ULong x; 3515| 3.47k|#endif 3516| 3.47k| Bigint *b, *b1, *delta, *mlo, *mhi, *S; 3517| 3.47k| U d2, eps, u; 3518| 3.47k| double ds; 3519| 3.47k| char *s, *s0; 3520| 3.47k|#ifndef No_leftright 3521| 3.47k|#ifdef IEEE_Arith 3522| 3.47k| U eps1; 3523| 3.47k|#endif 3524| 3.47k|#endif 3525| |#ifdef SET_INEXACT 3526| | int inexact, oldinexact; 3527| |#endif 3528| |#ifdef Honor_FLT_ROUNDS /*{*/ 3529| | int Rounding; 3530| |#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */ 3531| | Rounding = Flt_Rounds; 3532| |#else /*}{*/ 3533| | Rounding = 1; 3534| | switch(fegetround()) { 3535| | case FE_TOWARDZERO: Rounding = 0; break; 3536| | case FE_UPWARD: Rounding = 2; break; 3537| | case FE_DOWNWARD: Rounding = 3; 3538| | } 3539| |#endif /*}}*/ 3540| |#endif /*}*/ 3541| | 3542| | 3543| 3.47k| u.d = dd; 3544| 3.47k| if (word0(&u) & Sign_bit) { ------------------ | | 308| 3.47k|#define word0(x) (x)->L[1] ------------------ if (word0(&u) & Sign_bit) { ------------------ | | 365| 3.47k|#define Sign_bit 0x80000000 ------------------ | Branch (3544:6): [True: 496, False: 2.97k] ------------------ 3545| | /* set sign for everything, including 0's and NaNs */ 3546| 496| *sign = 1; 3547| 496| word0(&u) &= ~Sign_bit; /* clear sign bit */ ------------------ | | 308| 496|#define word0(x) (x)->L[1] ------------------ word0(&u) &= ~Sign_bit; /* clear sign bit */ ------------------ | | 365| 496|#define Sign_bit 0x80000000 ------------------ 3548| 496| } 3549| 2.97k| else 3550| 2.97k| *sign = 0; 3551| | 3552| 3.47k|#if defined(IEEE_Arith) + defined(VAX) 3553| 3.47k|#ifdef IEEE_Arith 3554| 3.47k| if ((word0(&u) & Exp_mask) == Exp_mask) ------------------ | | 308| 3.47k|#define word0(x) (x)->L[1] ------------------ if ((word0(&u) & Exp_mask) == Exp_mask) ------------------ | | 349| 3.47k|#define Exp_mask 0x7ff00000 ------------------ if ((word0(&u) & Exp_mask) == Exp_mask) ------------------ | | 349| 3.47k|#define Exp_mask 0x7ff00000 ------------------ | Branch (3554:6): [True: 0, False: 3.47k] ------------------ 3555| |#else 3556| | if (word0(&u) == 0x8000) 3557| |#endif 3558| 0| { 3559| | /* Infinity or NaN */ 3560| 0| *decpt = 9999; 3561| 0|#ifdef IEEE_Arith 3562| 0| if (!word1(&u) && !(word0(&u) & 0xfffff)) ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ if (!word1(&u) && !(word0(&u) & 0xfffff)) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ | Branch (3562:7): [True: 0, False: 0] | Branch (3562:21): [True: 0, False: 0] ------------------ 3563| 0| return nrv_alloc(C, "Infinity", rve, 8); 3564| 0|#endif 3565| 0| return nrv_alloc(C, "NaN", rve, 3); 3566| 0| } 3567| 3.47k|#endif 3568| |#ifdef IBM 3569| | dval(&u) += 0; /* normalize */ 3570| |#endif 3571| 3.47k| if (!dval(&u)) { ------------------ | | 314| 3.47k|#define dval(x) (x)->d ------------------ | Branch (3571:6): [True: 110, False: 3.36k] ------------------ 3572| 110| *decpt = 1; 3573| 110| return nrv_alloc(C, "0", rve, 1); 3574| 110| } 3575| | 3576| |#ifdef SET_INEXACT 3577| | try_quick = oldinexact = get_inexact(); 3578| | inexact = 1; 3579| |#endif 3580| |#ifdef Honor_FLT_ROUNDS 3581| | if (Rounding >= 2) { 3582| | if (*sign) 3583| | Rounding = Rounding == 2 ? 0 : 2; 3584| | else 3585| | if (Rounding != 2) 3586| | Rounding = 0; 3587| | } 3588| |#endif 3589| | 3590| 3.36k| b = d2b(C, &u, &be, &bbits); 3591| |#ifdef Sudden_Underflow 3592| | i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)); 3593| |#else 3594| 3.36k| if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 308| 3.36k|#define word0(x) (x)->L[1] ------------------ if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 346| 3.36k|#define Exp_shift1 20 ------------------ if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 349| 3.36k|#define Exp_mask 0x7ff00000 ------------------ if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 346| 3.36k|#define Exp_shift1 20 ------------------ | Branch (3594:6): [True: 3.27k, False: 93] ------------------ 3595| 3.27k|#endif 3596| 3.27k| dval(&d2) = dval(&u); ------------------ | | 314| 3.27k|#define dval(x) (x)->d ------------------ dval(&d2) = dval(&u); ------------------ | | 314| 3.27k|#define dval(x) (x)->d ------------------ 3597| 3.27k| word0(&d2) &= Frac_mask1; ------------------ | | 308| 3.27k|#define word0(x) (x)->L[1] ------------------ word0(&d2) &= Frac_mask1; ------------------ | | 359| 3.27k|#define Frac_mask1 0xfffff ------------------ 3598| 3.27k| word0(&d2) |= Exp_11; ------------------ | | 308| 3.27k|#define word0(x) (x)->L[1] ------------------ word0(&d2) |= Exp_11; ------------------ | | 356| 3.27k|#define Exp_11 0x3ff00000 ------------------ 3599| |#ifdef IBM 3600| | if (j = 11 - hi0bits(C, word0(&d2) & Frac_mask)) 3601| | dval(&d2) /= 1 << j; 3602| |#endif 3603| | 3604| | /* log(x) ~=~ log(1.5) + (x-1.5)/1.5 3605| | * log10(x) = log(x) / log(10) 3606| | * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10)) 3607| | * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2) 3608| | * 3609| | * This suggests computing an approximation k to log10(d) by 3610| | * 3611| | * k = (i - Bias)*0.301029995663981 3612| | * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 ); 3613| | * 3614| | * We want k to be too large rather than too small. 3615| | * The error in the first-order Taylor series approximation 3616| | * is in our favor, so we just round up the constant enough 3617| | * to compensate for any error in the multiplication of 3618| | * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077, 3619| | * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14, 3620| | * adding 1e-13 to the constant term more than suffices. 3621| | * Hence we adjust the constant term to 0.1760912590558. 3622| | * (We could get a more accurate k by invoking log10, 3623| | * but this is probably not worthwhile.) 3624| | */ 3625| | 3626| 3.27k| i -= Bias; ------------------ | | 352| 3.27k|#define Bias 1023 ------------------ 3627| |#ifdef IBM 3628| | i <<= 2; 3629| | i += j; 3630| |#endif 3631| 3.27k|#ifndef Sudden_Underflow 3632| 3.27k| denorm = 0; 3633| 3.27k| } 3634| 93| else { 3635| | /* d is denormalized */ 3636| | 3637| 93| i = bbits + be + (Bias + (P-1) - 1); ------------------ | | 352| 93|#define Bias 1023 ------------------ i = bbits + be + (Bias + (P-1) - 1); ------------------ | | 350| 93|#define P 53 ------------------ 3638| 93| x = i > 32 ? word0(&u) << (64 - i) | word1(&u) >> (i - 32) ------------------ | | 308| 52|#define word0(x) (x)->L[1] ------------------ x = i > 32 ? word0(&u) << (64 - i) | word1(&u) >> (i - 32) ------------------ | | 309| 52|#define word1(x) (x)->L[0] ------------------ | Branch (3638:7): [True: 52, False: 41] ------------------ 3639| 93| : word1(&u) << (32 - i); ------------------ | | 309| 41|#define word1(x) (x)->L[0] ------------------ 3640| 93| dval(&d2) = x; ------------------ | | 314| 93|#define dval(x) (x)->d ------------------ 3641| 93| word0(&d2) -= 31*Exp_msk1; /* adjust exponent */ ------------------ | | 308| 93|#define word0(x) (x)->L[1] ------------------ word0(&d2) -= 31*Exp_msk1; /* adjust exponent */ ------------------ | | 347| 93|#define Exp_msk1 0x100000 ------------------ 3642| 93| i -= (Bias + (P-1) - 1) + 1; ------------------ | | 352| 93|#define Bias 1023 ------------------ i -= (Bias + (P-1) - 1) + 1; ------------------ | | 350| 93|#define P 53 ------------------ 3643| 93| denorm = 1; 3644| 93| } 3645| 3.36k|#endif 3646| 3.36k| ds = (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981; ------------------ | | 314| 3.36k|#define dval(x) (x)->d ------------------ 3647| 3.36k| k = (int)ds; 3648| 3.36k| if (ds < 0. && ds != k) ------------------ | Branch (3648:6): [True: 236, False: 3.12k] | Branch (3648:17): [True: 236, False: 0] ------------------ 3649| 236| k--; /* want k = floor(ds) */ 3650| 3.36k| k_check = 1; 3651| 3.36k| if (k >= 0 && k <= Ten_pmax) { ------------------ | | 360| 3.12k|#define Ten_pmax 22 ------------------ | Branch (3651:6): [True: 3.12k, False: 236] | Branch (3651:16): [True: 968, False: 2.16k] ------------------ 3652| 968| if (dval(&u) < tens[k]) ------------------ | | 314| 968|#define dval(x) (x)->d ------------------ | Branch (3652:7): [True: 54, False: 914] ------------------ 3653| 54| k--; 3654| 968| k_check = 0; 3655| 968| } 3656| 3.36k| j = bbits - i - 1; 3657| 3.36k| if (j >= 0) { ------------------ | Branch (3657:6): [True: 781, False: 2.58k] ------------------ 3658| 781| b2 = 0; 3659| 781| s2 = j; 3660| 781| } 3661| 2.58k| else { 3662| 2.58k| b2 = -j; 3663| 2.58k| s2 = 0; 3664| 2.58k| } 3665| 3.36k| if (k >= 0) { ------------------ | Branch (3665:6): [True: 3.10k, False: 261] ------------------ 3666| 3.10k| b5 = 0; 3667| 3.10k| s5 = k; 3668| 3.10k| s2 += k; 3669| 3.10k| } 3670| 261| else { 3671| 261| b2 -= k; 3672| 261| b5 = -k; 3673| 261| s5 = 0; 3674| 261| } 3675| 3.36k| if (mode < 0 || mode > 9) ------------------ | Branch (3675:6): [True: 0, False: 3.36k] | Branch (3675:18): [True: 0, False: 3.36k] ------------------ 3676| 0| mode = 0; 3677| | 3678| 3.36k|#ifndef SET_INEXACT 3679| |#ifdef Check_FLT_ROUNDS 3680| | try_quick = Rounding == 1; 3681| |#else 3682| 3.36k| try_quick = 1; 3683| 3.36k|#endif 3684| 3.36k|#endif /*SET_INEXACT*/ 3685| | 3686| 3.36k| if (mode > 5) { ------------------ | Branch (3686:6): [True: 0, False: 3.36k] ------------------ 3687| 0| mode -= 4; 3688| 0| try_quick = 0; 3689| 0| } 3690| 3.36k| leftright = 1; 3691| 3.36k| ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */ 3692| | /* silence erroneous "gcc -Wall" warning. */ 3693| 3.36k| switch(mode) { ------------------ | Branch (3693:9): [True: 3.36k, False: 0] ------------------ 3694| 3.36k| case 0: ------------------ | Branch (3694:3): [True: 3.36k, False: 0] ------------------ 3695| 3.36k| case 1: ------------------ | Branch (3695:3): [True: 0, False: 3.36k] ------------------ 3696| 3.36k| i = 18; 3697| 3.36k| ndigits = 0; 3698| 3.36k| break; 3699| 0| case 2: ------------------ | Branch (3699:3): [True: 0, False: 3.36k] ------------------ 3700| 0| leftright = 0; 3701| | /* no break */ 3702| 0| JQ_FALLTHROUGH; ------------------ | | 14| 0|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 3703| 0| case 4: ------------------ | Branch (3703:3): [True: 0, False: 3.36k] ------------------ 3704| 0| if (ndigits <= 0) ------------------ | Branch (3704:8): [True: 0, False: 0] ------------------ 3705| 0| ndigits = 1; 3706| 0| ilim = ilim1 = i = ndigits; 3707| 0| break; 3708| 0| case 3: ------------------ | Branch (3708:3): [True: 0, False: 3.36k] ------------------ 3709| 0| leftright = 0; 3710| | /* no break */ 3711| 0| JQ_FALLTHROUGH; ------------------ | | 14| 0|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 3712| 0| case 5: ------------------ | Branch (3712:3): [True: 0, False: 3.36k] ------------------ 3713| 0| i = ndigits + k + 1; 3714| 0| ilim = i; 3715| 0| ilim1 = i - 1; 3716| 0| if (i <= 0) ------------------ | Branch (3716:8): [True: 0, False: 0] ------------------ 3717| 0| i = 1; 3718| 3.36k| } 3719| 3.36k| s = s0 = rv_alloc(C, i); 3720| | 3721| |#ifdef Honor_FLT_ROUNDS 3722| | if (mode > 1 && Rounding != 1) 3723| | leftright = 0; 3724| |#endif 3725| | 3726| 3.36k| if (ilim >= 0 && ilim <= Quick_max && try_quick) { ------------------ | | 369| 3.36k|#define Quick_max 14 ------------------ | Branch (3726:6): [True: 0, False: 3.36k] | Branch (3726:19): [True: 0, False: 0] | Branch (3726:40): [True: 0, False: 0] ------------------ 3727| | 3728| | /* Try to get by with floating-point arithmetic. */ 3729| | 3730| 0| i = 0; 3731| 0| dval(&d2) = dval(&u); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ dval(&d2) = dval(&u); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3732| 0| k0 = k; 3733| 0| ilim0 = ilim; 3734| 0| ieps = 2; /* conservative */ 3735| 0| if (k > 0) { ------------------ | Branch (3735:7): [True: 0, False: 0] ------------------ 3736| 0| ds = tens[k&0xf]; 3737| 0| j = k >> 4; 3738| 0| if (j & Bletch) { ------------------ | | 361| 0|#define Bletch 0x10 ------------------ | Branch (3738:8): [True: 0, False: 0] ------------------ 3739| | /* prevent overflows */ 3740| 0| j &= Bletch - 1; ------------------ | | 361| 0|#define Bletch 0x10 ------------------ 3741| 0| dval(&u) /= bigtens[n_bigtens-1]; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ dval(&u) /= bigtens[n_bigtens-1]; ------------------ | | 1375| 0|#define n_bigtens 5 ------------------ 3742| 0| ieps++; 3743| 0| } 3744| 0| for(; j; j >>= 1, i++) ------------------ | Branch (3744:10): [True: 0, False: 0] ------------------ 3745| 0| if (j & 1) { ------------------ | Branch (3745:9): [True: 0, False: 0] ------------------ 3746| 0| ieps++; 3747| 0| ds *= bigtens[i]; 3748| 0| } 3749| 0| dval(&u) /= ds; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3750| 0| } 3751| 0| else if ((j1 = -k)) { ------------------ | Branch (3751:12): [True: 0, False: 0] ------------------ 3752| 0| dval(&u) *= tens[j1 & 0xf]; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3753| 0| for(j = j1 >> 4; j; j >>= 1, i++) ------------------ | Branch (3753:21): [True: 0, False: 0] ------------------ 3754| 0| if (j & 1) { ------------------ | Branch (3754:9): [True: 0, False: 0] ------------------ 3755| 0| ieps++; 3756| 0| dval(&u) *= bigtens[i]; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3757| 0| } 3758| 0| } 3759| 0| if (k_check && dval(&u) < 1. && ilim > 0) { ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3759:7): [True: 0, False: 0] | Branch (3759:18): [True: 0, False: 0] | Branch (3759:35): [True: 0, False: 0] ------------------ 3760| 0| if (ilim1 <= 0) ------------------ | Branch (3760:8): [True: 0, False: 0] ------------------ 3761| 0| goto fast_failed; 3762| 0| ilim = ilim1; 3763| 0| k--; 3764| 0| dval(&u) *= 10.; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3765| 0| ieps++; 3766| 0| } 3767| 0| dval(&eps) = ieps*dval(&u) + 7.; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ dval(&eps) = ieps*dval(&u) + 7.; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3768| 0| word0(&eps) -= (P-1)*Exp_msk1; ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&eps) -= (P-1)*Exp_msk1; ------------------ | | 350| 0|#define P 53 ------------------ word0(&eps) -= (P-1)*Exp_msk1; ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ 3769| 0| if (ilim == 0) { ------------------ | Branch (3769:7): [True: 0, False: 0] ------------------ 3770| 0| S = mhi = 0; 3771| 0| dval(&u) -= 5.; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3772| 0| if (dval(&u) > dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ if (dval(&u) > dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3772:8): [True: 0, False: 0] ------------------ 3773| 0| goto one_digit; 3774| 0| if (dval(&u) < -dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ if (dval(&u) < -dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3774:8): [True: 0, False: 0] ------------------ 3775| 0| goto no_digits; 3776| 0| goto fast_failed; 3777| 0| } 3778| 0|#ifndef No_leftright 3779| 0| if (leftright) { ------------------ | Branch (3779:7): [True: 0, False: 0] ------------------ 3780| | /* Use Steele & White method of only 3781| | * generating digits needed. 3782| | */ 3783| 0| dval(&eps) = 0.5/tens[ilim-1] - dval(&eps); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ dval(&eps) = 0.5/tens[ilim-1] - dval(&eps); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3784| 0|#ifdef IEEE_Arith 3785| 0| if (k0 < 0 && j1 >= 307) { ------------------ | Branch (3785:8): [True: 0, False: 0] | Branch (3785:18): [True: 0, False: 0] ------------------ 3786| 0| eps1.d = 1.01e256; /* 1.01 allows roundoff in the next few lines */ 3787| 0| word0(&eps1) -= Exp_msk1 * (Bias+P-1); ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&eps1) -= Exp_msk1 * (Bias+P-1); ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ word0(&eps1) -= Exp_msk1 * (Bias+P-1); ------------------ | | 352| 0|#define Bias 1023 ------------------ word0(&eps1) -= Exp_msk1 * (Bias+P-1); ------------------ | | 350| 0|#define P 53 ------------------ 3788| 0| dval(&eps1) *= tens[j1 & 0xf]; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3789| 0| for(i = 0, j = (j1-256) >> 4; j; j >>= 1, i++) ------------------ | Branch (3789:35): [True: 0, False: 0] ------------------ 3790| 0| if (j & 1) ------------------ | Branch (3790:10): [True: 0, False: 0] ------------------ 3791| 0| dval(&eps1) *= bigtens[i]; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3792| 0| if (eps.d < eps1.d) ------------------ | Branch (3792:9): [True: 0, False: 0] ------------------ 3793| 0| eps.d = eps1.d; 3794| 0| } 3795| 0|#endif 3796| 0| for(i = 0;;) { 3797| 0| L = dval(&u); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3798| 0| dval(&u) -= L; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3799| 0| *s++ = '0' + (int)L; 3800| 0| if (1. - dval(&u) < dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ if (1. - dval(&u) < dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3800:9): [True: 0, False: 0] ------------------ 3801| 0| goto bump_up; 3802| 0| if (dval(&u) < dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ if (dval(&u) < dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3802:9): [True: 0, False: 0] ------------------ 3803| 0| goto ret1; 3804| 0| if (++i >= ilim) ------------------ | Branch (3804:9): [True: 0, False: 0] ------------------ 3805| 0| break; 3806| 0| dval(&eps) *= 10.; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3807| 0| dval(&u) *= 10.; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3808| 0| } 3809| 0| } 3810| 0| else { 3811| 0|#endif 3812| | /* Generate ilim digits, then fix them up. */ 3813| 0| dval(&eps) *= tens[ilim-1]; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3814| 0| for(i = 1;; i++, dval(&u) *= 10.) { ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3815| 0| L = (Long)(dval(&u)); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3816| 0| if (!(dval(&u) -= L)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3816:9): [True: 0, False: 0] ------------------ 3817| 0| ilim = i; 3818| 0| *s++ = '0' + (int)L; 3819| 0| if (i == ilim) { ------------------ | Branch (3819:9): [True: 0, False: 0] ------------------ 3820| 0| if (dval(&u) > 0.5 + dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ if (dval(&u) > 0.5 + dval(&eps)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3820:10): [True: 0, False: 0] ------------------ 3821| 0| goto bump_up; 3822| 0| else if (dval(&u) < 0.5 - dval(&eps)) { ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ else if (dval(&u) < 0.5 - dval(&eps)) { ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3822:15): [True: 0, False: 0] ------------------ 3823| 0| while(*--s == '0'); ------------------ | Branch (3823:13): [True: 0, False: 0] ------------------ 3824| 0| s++; 3825| 0| goto ret1; 3826| 0| } 3827| 0| break; 3828| 0| } 3829| 0| } 3830| 0|#ifndef No_leftright 3831| 0| } 3832| 0|#endif 3833| 0| fast_failed: 3834| 0| s = s0; 3835| 0| dval(&u) = dval(&d2); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ dval(&u) = dval(&d2); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3836| 0| k = k0; 3837| 0| ilim = ilim0; 3838| 0| } 3839| | 3840| | /* Do we have a "small" integer? */ 3841| | 3842| 3.36k| if (be >= 0 && k <= Int_max) { ------------------ | | 370| 2.99k|#define Int_max 14 ------------------ | Branch (3842:6): [True: 2.99k, False: 368] | Branch (3842:17): [True: 710, False: 2.28k] ------------------ 3843| | /* Yes. */ 3844| 710| ds = tens[k]; 3845| 710| if (ndigits < 0 && ilim <= 0) { ------------------ | Branch (3845:7): [True: 0, False: 710] | Branch (3845:22): [True: 0, False: 0] ------------------ 3846| 0| S = mhi = 0; 3847| 0| if (ilim < 0 || dval(&u) <= 5*ds) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3847:8): [True: 0, False: 0] | Branch (3847:20): [True: 0, False: 0] ------------------ 3848| 0| goto no_digits; 3849| 0| goto one_digit; 3850| 0| } 3851| 1.27k| for(i = 1;; i++, dval(&u) *= 10.) { ------------------ | | 314| 560|#define dval(x) (x)->d ------------------ 3852| 1.27k| L = (Long)(dval(&u) / ds); ------------------ | | 314| 1.27k|#define dval(x) (x)->d ------------------ 3853| 1.27k| dval(&u) -= L*ds; ------------------ | | 314| 1.27k|#define dval(x) (x)->d ------------------ 3854| |#ifdef Check_FLT_ROUNDS 3855| | /* If FLT_ROUNDS == 2, L will usually be high by 1 */ 3856| | if (dval(&u) < 0) { 3857| | L--; 3858| | dval(&u) += ds; 3859| | } 3860| |#endif 3861| 1.27k| *s++ = '0' + (int)L; 3862| 1.27k| if (!dval(&u)) { ------------------ | | 314| 1.27k|#define dval(x) (x)->d ------------------ | Branch (3862:8): [True: 710, False: 560] ------------------ 3863| |#ifdef SET_INEXACT 3864| | inexact = 0; 3865| |#endif 3866| 710| break; 3867| 710| } 3868| 560| if (i == ilim) { ------------------ | Branch (3868:8): [True: 0, False: 560] ------------------ 3869| |#ifdef Honor_FLT_ROUNDS 3870| | if (mode > 1) 3871| | switch(Rounding) { 3872| | case 0: goto ret1; 3873| | case 2: goto bump_up; 3874| | } 3875| |#endif 3876| 0| dval(&u) += dval(&u); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ dval(&u) += dval(&u); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3877| |#ifdef ROUND_BIASED 3878| | if (dval(&u) >= ds) 3879| |#else 3880| 0| if (dval(&u) > ds || (dval(&u) == ds && L & 1)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ if (dval(&u) > ds || (dval(&u) == ds && L & 1)) ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ | Branch (3880:9): [True: 0, False: 0] | Branch (3880:27): [True: 0, False: 0] | Branch (3880:45): [True: 0, False: 0] ------------------ 3881| 0|#endif 3882| 0| { 3883| 0| bump_up: 3884| 0| while(*--s == '9') ------------------ | Branch (3884:12): [True: 0, False: 0] ------------------ 3885| 0| if (s == s0) { ------------------ | Branch (3885:11): [True: 0, False: 0] ------------------ 3886| 0| k++; 3887| 0| *s = '0'; 3888| 0| break; 3889| 0| } 3890| 0| ++*s++; 3891| 0| } 3892| 0| break; 3893| 0| } 3894| 560| } 3895| 710| goto ret1; 3896| 710| } 3897| | 3898| 2.65k| m2 = b2; 3899| 2.65k| m5 = b5; 3900| 2.65k| mhi = mlo = 0; 3901| 2.65k| if (leftright) { ------------------ | Branch (3901:6): [True: 2.65k, False: 0] ------------------ 3902| 2.65k| i = 3903| 2.65k|#ifndef Sudden_Underflow 3904| 2.65k| denorm ? be + (Bias + (P-1) - 1 + 1) : ------------------ | | 352| 93|#define Bias 1023 ------------------ denorm ? be + (Bias + (P-1) - 1 + 1) : ------------------ | | 350| 93|#define P 53 ------------------ | Branch (3904:4): [True: 93, False: 2.56k] ------------------ 3905| 2.65k|#endif 3906| |#ifdef IBM 3907| | 1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3); 3908| |#else 3909| 2.65k| 1 + P - bbits; ------------------ | | 350| 2.56k|#define P 53 ------------------ 3910| 2.65k|#endif 3911| 2.65k| b2 += i; 3912| 2.65k| s2 += i; 3913| 2.65k| mhi = i2b(C, 1); 3914| 2.65k| } 3915| 2.65k| if (m2 > 0 && s2 > 0) { ------------------ | Branch (3915:6): [True: 2.54k, False: 112] | Branch (3915:16): [True: 2.54k, False: 0] ------------------ 3916| 2.54k| i = m2 < s2 ? m2 : s2; ------------------ | Branch (3916:7): [True: 380, False: 2.16k] ------------------ 3917| 2.54k| b2 -= i; 3918| 2.54k| m2 -= i; 3919| 2.54k| s2 -= i; 3920| 2.54k| } 3921| 2.65k| if (b5 > 0) { ------------------ | Branch (3921:6): [True: 261, False: 2.39k] ------------------ 3922| 261| if (leftright) { ------------------ | Branch (3922:7): [True: 261, False: 0] ------------------ 3923| 261| if (m5 > 0) { ------------------ | Branch (3923:8): [True: 261, False: 0] ------------------ 3924| 261| mhi = pow5mult(C, mhi, m5); 3925| 261| b1 = mult(C, mhi, b); 3926| 261| Bfree(C, b); 3927| 261| b = b1; 3928| 261| } 3929| 261| if ((j = b5 - m5)) ------------------ | Branch (3929:8): [True: 0, False: 261] ------------------ 3930| 0| b = pow5mult(C, b, j); 3931| 261| } 3932| 0| else 3933| 0| b = pow5mult(C, b, b5); 3934| 261| } 3935| 2.65k| S = i2b(C, 1); 3936| 2.65k| if (s5 > 0) ------------------ | Branch (3936:6): [True: 2.37k, False: 276] ------------------ 3937| 2.37k| S = pow5mult(C, S, s5); 3938| | 3939| | /* Check for special case that d is a normalized power of 2. */ 3940| | 3941| 2.65k| spec_case = 0; 3942| 2.65k| if ((mode < 2 || leftright) ------------------ | Branch (3942:7): [True: 2.65k, False: 0] | Branch (3942:19): [True: 0, False: 0] ------------------ 3943| |#ifdef Honor_FLT_ROUNDS 3944| | && Rounding == 1 3945| |#endif 3946| 2.65k| ) { 3947| 2.65k| if (!word1(&u) && !(word0(&u) & Bndry_mask) ------------------ | | 309| 5.31k|#define word1(x) (x)->L[0] ------------------ if (!word1(&u) && !(word0(&u) & Bndry_mask) ------------------ | | 308| 43|#define word0(x) (x)->L[1] ------------------ if (!word1(&u) && !(word0(&u) & Bndry_mask) ------------------ | | 362| 43|#define Bndry_mask 0xfffff ------------------ | Branch (3947:7): [True: 43, False: 2.61k] | Branch (3947:21): [True: 11, False: 32] ------------------ 3948| 11|#ifndef Sudden_Underflow 3949| 11| && word0(&u) & (Exp_mask & ~Exp_msk1) ------------------ | | 308| 11|#define word0(x) (x)->L[1] ------------------ && word0(&u) & (Exp_mask & ~Exp_msk1) ------------------ | | 349| 11|#define Exp_mask 0x7ff00000 ------------------ && word0(&u) & (Exp_mask & ~Exp_msk1) ------------------ | | 347| 11|#define Exp_msk1 0x100000 ------------------ | Branch (3949:7): [True: 11, False: 0] ------------------ 3950| 2.65k|#endif 3951| 2.65k| ) { 3952| | /* The special case */ 3953| 11| b2 += Log2P; ------------------ | | 366| 11|#define Log2P 1 ------------------ 3954| 11| s2 += Log2P; ------------------ | | 366| 11|#define Log2P 1 ------------------ 3955| 11| spec_case = 1; 3956| 11| } 3957| 2.65k| } 3958| | 3959| | /* Arrange for convenient computation of quotients: 3960| | * shift left if necessary so divisor has 4 leading 0 bits. 3961| | * 3962| | * Perhaps we should just compute leading 28 bits of S once 3963| | * and for all and pass them and a shift to quorem, so it 3964| | * can do shifts and ors to compute the numerator for q. 3965| | */ 3966| 2.65k| i = dshift(C, S, s2); 3967| 2.65k| b2 += i; 3968| 2.65k| m2 += i; 3969| 2.65k| s2 += i; 3970| 2.65k| if (b2 > 0) ------------------ | Branch (3970:6): [True: 2.65k, False: 0] ------------------ 3971| 2.65k| b = lshift(C, b, b2); 3972| 2.65k| if (s2 > 0) ------------------ | Branch (3972:6): [True: 2.64k, False: 10] ------------------ 3973| 2.64k| S = lshift(C, S, s2); 3974| 2.65k| if (k_check) { ------------------ | Branch (3974:6): [True: 2.39k, False: 258] ------------------ 3975| 2.39k| if (cmp(C, b,S) < 0) { ------------------ | Branch (3975:7): [True: 28, False: 2.36k] ------------------ 3976| 28| k--; 3977| 28| b = multadd(C, b, 10, 0); /* we botched the k estimate */ 3978| 28| if (leftright) ------------------ | Branch (3978:8): [True: 28, False: 0] ------------------ 3979| 28| mhi = multadd(C, mhi, 10, 0); 3980| 28| ilim = ilim1; 3981| 28| } 3982| 2.39k| } 3983| 2.65k| if (ilim <= 0 && (mode == 3 || mode == 5)) { ------------------ | Branch (3983:6): [True: 2.65k, False: 0] | Branch (3983:20): [True: 0, False: 2.65k] | Branch (3983:33): [True: 0, False: 2.65k] ------------------ 3984| 0| if (ilim < 0 || cmp(C, b,S = multadd(C, S,5,0)) <= 0) { ------------------ | Branch (3984:7): [True: 0, False: 0] | Branch (3984:19): [True: 0, False: 0] ------------------ 3985| | /* no digits, fcvt style */ 3986| 0| no_digits: 3987| 0| k = -1 - ndigits; 3988| 0| goto ret; 3989| 0| } 3990| 0| one_digit: 3991| 0| *s++ = '1'; 3992| 0| k++; 3993| 0| goto ret; 3994| 0| } 3995| 2.65k| if (leftright) { ------------------ | Branch (3995:6): [True: 2.65k, False: 0] ------------------ 3996| 2.65k| if (m2 > 0) ------------------ | Branch (3996:7): [True: 2.64k, False: 9] ------------------ 3997| 2.64k| mhi = lshift(C, mhi, m2); 3998| | 3999| | /* Compute mlo -- check for special case 4000| | * that d is a normalized power of 2. 4001| | */ 4002| | 4003| 2.65k| mlo = mhi; 4004| 2.65k| if (spec_case) { ------------------ | Branch (4004:7): [True: 11, False: 2.64k] ------------------ 4005| 11| mhi = Balloc(C, mhi->k); 4006| 11| Bcopy(mhi, mlo); ------------------ | | 586| 11|#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ | | 587| 11|y->wds*sizeof(Long) + 2*sizeof(int)) ------------------ 4007| 11| mhi = lshift(C, mhi, Log2P); ------------------ | | 366| 11|#define Log2P 1 ------------------ 4008| 11| } 4009| | 4010| 40.0k| for(i = 1;;i++) { 4011| 40.0k| dig = quorem(C, b,S) + '0'; 4012| | /* Do we yet have the shortest decimal string 4013| | * that will round to d? 4014| | */ 4015| 40.0k| j = cmp(C, b, mlo); 4016| 40.0k| delta = diff(C, S, mhi); 4017| 40.0k| j1 = delta->sign ? 1 : cmp(C, b, delta); ------------------ | Branch (4017:9): [True: 139, False: 39.9k] ------------------ 4018| 40.0k| Bfree(C, delta); 4019| 40.0k|#ifndef ROUND_BIASED 4020| 40.0k| if (j1 == 0 && mode != 1 && !(word1(&u) & 1) ------------------ | | 309| 63|#define word1(x) (x)->L[0] ------------------ | Branch (4020:8): [True: 63, False: 39.9k] | Branch (4020:19): [True: 63, False: 0] | Branch (4020:32): [True: 24, False: 39] ------------------ 4021| |#ifdef Honor_FLT_ROUNDS 4022| | && Rounding >= 1 4023| |#endif 4024| 40.0k| ) { 4025| 24| if (dig == '9') ------------------ | Branch (4025:9): [True: 1, False: 23] ------------------ 4026| 1| goto round_9_up; 4027| 23| if (j > 0) ------------------ | Branch (4027:9): [True: 5, False: 18] ------------------ 4028| 5| dig++; 4029| |#ifdef SET_INEXACT 4030| | else if (!b->x[0] && b->wds <= 1) 4031| | inexact = 0; 4032| |#endif 4033| 23| *s++ = dig; 4034| 23| goto ret; 4035| 24| } 4036| 40.0k|#endif 4037| 40.0k| if (j < 0 || (j == 0 && mode != 1 ------------------ | Branch (4037:8): [True: 2.38k, False: 37.6k] | Branch (4037:18): [True: 46, False: 37.5k] | Branch (4037:28): [True: 46, False: 0] ------------------ 4038| 46|#ifndef ROUND_BIASED 4039| 46| && !(word1(&u) & 1) ------------------ | | 309| 46|#define word1(x) (x)->L[0] ------------------ | Branch (4039:11): [True: 5, False: 41] ------------------ 4040| 37.6k|#endif 4041| 37.6k| )) { 4042| 2.38k| if (!b->x[0] && b->wds <= 1) { ------------------ | Branch (4042:9): [True: 102, False: 2.28k] | Branch (4042:21): [True: 61, False: 41] ------------------ 4043| |#ifdef SET_INEXACT 4044| | inexact = 0; 4045| |#endif 4046| 61| goto accept_dig; 4047| 61| } 4048| |#ifdef Honor_FLT_ROUNDS 4049| | if (mode > 1) 4050| | switch(Rounding) { 4051| | case 0: goto accept_dig; 4052| | case 2: goto keep_dig; 4053| | } 4054| |#endif /*Honor_FLT_ROUNDS*/ 4055| 2.32k| if (j1 > 0) { ------------------ | Branch (4055:9): [True: 2.05k, False: 267] ------------------ 4056| 2.05k| b = lshift(C, b, 1); 4057| 2.05k| j1 = cmp(C, b, S); 4058| |#ifdef ROUND_BIASED 4059| | if (j1 >= 0 /*)*/ 4060| |#else 4061| 2.05k| if ((j1 > 0 || (j1 == 0 && dig & 1)) ------------------ | Branch (4061:11): [True: 102, False: 1.95k] | Branch (4061:22): [True: 4, False: 1.95k] | Branch (4061:33): [True: 2, False: 2] ------------------ 4062| 104|#endif 4063| 104| && dig++ == '9') ------------------ | Branch (4063:9): [True: 1, False: 103] ------------------ 4064| 1| goto round_9_up; 4065| 2.05k| } 4066| 2.38k| accept_dig: 4067| 2.38k| *s++ = dig; 4068| 2.38k| goto ret; 4069| 2.32k| } 4070| 37.6k| if (j1 > 0) { ------------------ | Branch (4070:8): [True: 246, False: 37.3k] ------------------ 4071| |#ifdef Honor_FLT_ROUNDS 4072| | if (!Rounding) 4073| | goto accept_dig; 4074| |#endif 4075| 246| if (dig == '9') { /* possible if i == 1 */ ------------------ | Branch (4075:9): [True: 9, False: 237] ------------------ 4076| 11| round_9_up: 4077| 11| *s++ = '9'; 4078| 11| goto roundoff; 4079| 9| } 4080| 237| *s++ = dig + 1; 4081| 237| goto ret; 4082| 246| } 4083| |#ifdef Honor_FLT_ROUNDS 4084| | keep_dig: 4085| |#endif 4086| 37.3k| *s++ = dig; 4087| 37.3k| if (i == ilim) ------------------ | Branch (4087:8): [True: 0, False: 37.3k] ------------------ 4088| 0| break; 4089| 37.3k| b = multadd(C, b, 10, 0); 4090| 37.3k| if (mlo == mhi) ------------------ | Branch (4090:8): [True: 37.2k, False: 113] ------------------ 4091| 37.2k| mlo = mhi = multadd(C, mhi, 10, 0); 4092| 113| else { 4093| 113| mlo = multadd(C, mlo, 10, 0); 4094| 113| mhi = multadd(C, mhi, 10, 0); 4095| 113| } 4096| 37.3k| } 4097| 2.65k| } 4098| 0| else 4099| 0| for(i = 1;; i++) { 4100| 0| *s++ = dig = quorem(C, b,S) + '0'; 4101| 0| if (!b->x[0] && b->wds <= 1) { ------------------ | Branch (4101:8): [True: 0, False: 0] | Branch (4101:20): [True: 0, False: 0] ------------------ 4102| |#ifdef SET_INEXACT 4103| | inexact = 0; 4104| |#endif 4105| 0| goto ret; 4106| 0| } 4107| 0| if (i >= ilim) ------------------ | Branch (4107:8): [True: 0, False: 0] ------------------ 4108| 0| break; 4109| 0| b = multadd(C, b, 10, 0); 4110| 0| } 4111| | 4112| | /* Round off last digit */ 4113| | 4114| |#ifdef Honor_FLT_ROUNDS 4115| | switch(Rounding) { 4116| | case 0: goto trimzeros; 4117| | case 2: goto roundoff; 4118| | } 4119| |#endif 4120| 0| b = lshift(C, b, 1); 4121| 0| j = cmp(C, b, S); 4122| |#ifdef ROUND_BIASED 4123| | if (j >= 0) 4124| |#else 4125| 0| if (j > 0 || (j == 0 && dig & 1)) ------------------ | Branch (4125:6): [True: 0, False: 0] | Branch (4125:16): [True: 0, False: 0] | Branch (4125:26): [True: 0, False: 0] ------------------ 4126| 0|#endif 4127| 0| { 4128| 11| roundoff: 4129| 11| while(*--s == '9') ------------------ | Branch (4129:9): [True: 11, False: 0] ------------------ 4130| 11| if (s == s0) { ------------------ | Branch (4130:8): [True: 11, False: 0] ------------------ 4131| 11| k++; 4132| 11| *s++ = '1'; 4133| 11| goto ret; 4134| 11| } 4135| 0| ++*s++; 4136| 0| } 4137| 0| else { 4138| |#ifdef Honor_FLT_ROUNDS 4139| | trimzeros: 4140| |#endif 4141| 0| while(*--s == '0'); ------------------ | Branch (4141:9): [True: 0, False: 0] ------------------ 4142| 0| s++; 4143| 0| } 4144| 2.65k| ret: 4145| 2.65k| Bfree(C, S); 4146| 2.65k| if (mhi) { ------------------ | Branch (4146:6): [True: 2.65k, False: 0] ------------------ 4147| 2.65k| if (mlo && mlo != mhi) ------------------ | Branch (4147:7): [True: 2.65k, False: 0] | Branch (4147:14): [True: 11, False: 2.64k] ------------------ 4148| 11| Bfree(C, mlo); 4149| 2.65k| Bfree(C, mhi); 4150| 2.65k| } 4151| 3.36k| ret1: 4152| |#ifdef SET_INEXACT 4153| | if (inexact) { 4154| | if (!oldinexact) { 4155| | word0(&u) = Exp_1 + (70 << Exp_shift); 4156| | word1(&u) = 0; 4157| | dval(&u) += 1.; 4158| | } 4159| | } 4160| | else if (!oldinexact) 4161| | clear_inexact(); 4162| |#endif 4163| 3.36k| Bfree(C, b); 4164| 3.36k| *s = 0; 4165| 3.36k| *decpt = k + 1; 4166| 3.36k| if (rve) ------------------ | Branch (4166:6): [True: 3.36k, False: 0] ------------------ 4167| 3.36k| *rve = s; 4168| 3.36k| return s0; 4169| 2.65k| } jvp_dtoa_fmt: 4207| 3.47k|{ 4208| 3.47k| register int i, k; 4209| 3.47k| register char *s; 4210| 3.47k| int decpt, j, sign; 4211| 3.47k| char *b0, *s0, *se; 4212| | 4213| 3.47k| b0 = b; 4214| |#ifdef IGNORE_ZERO_SIGN 4215| | if (!x) { 4216| | *b++ = '0'; 4217| | *b = 0; 4218| | goto done; 4219| | } 4220| |#endif 4221| 3.47k| s = s0 = jvp_dtoa(C, x, 0, 0, &decpt, &sign, &se); 4222| 3.47k| if (sign) ------------------ | Branch (4222:6): [True: 496, False: 2.97k] ------------------ 4223| 496| *b++ = '-'; 4224| 3.47k| if (decpt == 9999) /* Infinity or Nan */ { ------------------ | Branch (4224:6): [True: 0, False: 3.47k] ------------------ 4225| 0| while((*b++ = *s++)); ------------------ | Branch (4225:9): [True: 0, False: 0] ------------------ 4226| 0| goto done0; 4227| 0| } 4228| 3.47k| if (decpt <= -4 || decpt > se - s + 15) { ------------------ | Branch (4228:6): [True: 146, False: 3.32k] | Branch (4228:21): [True: 2.10k, False: 1.22k] ------------------ 4229| 2.25k| *b++ = *s++; 4230| 2.25k| if (*s) { ------------------ | Branch (4230:7): [True: 2.12k, False: 123] ------------------ 4231| 2.12k| *b++ = '.'; 4232| 34.4k| while((*b = *s++)) ------------------ | Branch (4232:10): [True: 32.3k, False: 2.12k] ------------------ 4233| 32.3k| b++; 4234| 2.12k| } 4235| 2.25k| *b++ = 'e'; 4236| | /* sprintf(b, "%+.2d", decpt - 1); */ 4237| 2.25k| if (--decpt < 0) { ------------------ | Branch (4237:7): [True: 146, False: 2.10k] ------------------ 4238| 146| *b++ = '-'; 4239| 146| decpt = -decpt; 4240| 146| } 4241| 2.10k| else 4242| 2.10k| *b++ = '+'; 4243| 4.35k| for(j = 2, k = 10; 10*k <= decpt; j++, k *= 10); ------------------ | Branch (4243:22): [True: 2.10k, False: 2.25k] ------------------ 4244| 6.60k| for(;;) { 4245| 6.60k| i = decpt / k; 4246| 6.60k| *b++ = i + '0'; 4247| 6.60k| if (--j <= 0) ------------------ | Branch (4247:8): [True: 2.25k, False: 4.35k] ------------------ 4248| 2.25k| break; 4249| 4.35k| decpt -= i*k; 4250| 4.35k| decpt *= 10; 4251| 4.35k| } 4252| 2.25k| *b = 0; 4253| 2.25k| } 4254| 1.22k| else if (decpt <= 0) { ------------------ | Branch (4254:11): [True: 115, False: 1.10k] ------------------ 4255| 115| *b++ = '0'; 4256| 115| *b++ = '.'; 4257| 145| for(; decpt < 0; decpt++) ------------------ | Branch (4257:9): [True: 30, False: 115] ------------------ 4258| 30| *b++ = '0'; 4259| 1.43k| while((*b++ = *s++)); ------------------ | Branch (4259:9): [True: 1.31k, False: 115] ------------------ 4260| 115| } 4261| 1.10k| else { 4262| 6.62k| while((*b = *s++)) { ------------------ | Branch (4262:9): [True: 5.52k, False: 1.10k] ------------------ 4263| 5.52k| b++; 4264| 5.52k| if (--decpt == 0 && *s) ------------------ | Branch (4264:8): [True: 736, False: 4.78k] | Branch (4264:24): [True: 107, False: 629] ------------------ 4265| 107| *b++ = '.'; 4266| 5.52k| } 4267| 2.36k| for(; decpt > 0; decpt--) ------------------ | Branch (4267:9): [True: 1.25k, False: 1.10k] ------------------ 4268| 1.25k| *b++ = '0'; 4269| 1.10k| *b = 0; 4270| 1.10k| } 4271| 3.47k| done0: 4272| 3.47k| jvp_freedtoa(C, s0); 4273| 3.47k| goto done; 4274| 3.47k| done: 4275| 3.47k| return b0; 4276| 3.47k| } jv_dtoa.c:Bfree: 553| 315k|{ 554| 315k| if (v) { ------------------ | Branch (554:6): [True: 315k, False: 0] ------------------ 555| 315k| if (v->k > Kmax) ------------------ | | 3| 315k|#define Kmax 7 ------------------ | Branch (555:7): [True: 0, False: 315k] ------------------ 556| 0|#ifdef FREE 557| 0| FREE((void*)v); ------------------ | | 200| 0|#define FREE jv_mem_free ------------------ 558| |#else 559| | free((void*)v); 560| |#endif 561| 315k| else { 562| 315k| v->next = C->freelist[v->k]; 563| 315k| C->freelist[v->k] = v; 564| 315k| } 565| 315k| } 566| 315k| } jv_dtoa.c:match: 1435| 6.66k|{ 1436| 6.66k| int c, d; 1437| 6.66k| CONST char *s = *sp; ------------------ | | 298| 6.66k|#define CONST const ------------------ 1438| | 1439| 29.9k| while((d = *t++)) { ------------------ | Branch (1439:8): [True: 23.3k, False: 6.66k] ------------------ 1440| 23.3k| if ((c = *++s) >= 'A' && c <= 'Z') ------------------ | Branch (1440:7): [True: 23.3k, False: 0] | Branch (1440:28): [True: 0, False: 23.3k] ------------------ 1441| 0| c += 'a' - 'A'; 1442| 23.3k| if (c != d) ------------------ | Branch (1442:7): [True: 0, False: 23.3k] ------------------ 1443| 0| return 0; 1444| 23.3k| } 1445| 6.66k| *sp = s + 1; 1446| 6.66k| return 1; 1447| 6.66k| } jv_dtoa.c:s2b: 645| 21.9k|{ 646| 21.9k| Bigint *b; 647| 21.9k| int i, k; 648| 21.9k| Long x, y; ------------------ | | 193| 21.9k|#define Long int ------------------ 649| | 650| 21.9k| x = (nd + 8) / 9; 651| 33.9k| for(k = 0, y = 1; x > y; y <<= 1, k++) ; ------------------ | Branch (651:20): [True: 12.0k, False: 21.9k] ------------------ 652| 21.9k|#ifdef Pack_32 653| 21.9k| b = Balloc(C, k); 654| 21.9k| b->x[0] = y9; 655| 21.9k| b->wds = 1; 656| |#else 657| | b = Balloc(C, k+1); 658| | b->x[0] = y9 & 0xffff; 659| | b->wds = (b->x[1] = y9 >> 16) ? 2 : 1; 660| |#endif 661| | 662| 21.9k| i = 9; 663| 21.9k| if (9 < nd0) { ------------------ | Branch (663:6): [True: 2.89k, False: 19.0k] ------------------ 664| 2.89k| s += 9; 665| 21.6k| do b = multadd(C, b, 10, *s++ - '0'); 666| 21.6k| while(++i < nd0); ------------------ | Branch (666:10): [True: 18.7k, False: 2.89k] ------------------ 667| 2.89k| s += dplen; 668| 2.89k| } 669| 19.0k| else 670| 19.0k| s += dplen + 9; 671| 80.7k| for(; i < nd; i++) ------------------ | Branch (671:8): [True: 58.7k, False: 21.9k] ------------------ 672| 58.7k| b = multadd(C, b, 10, *s++ - '0'); 673| 21.9k| return b; 674| 21.9k| } jv_dtoa.c:Balloc: 532| 315k|{ 533| 315k| int x; 534| 315k| Bigint *rv; 535| | 536| | /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */ 537| | /* but this case seems very unlikely. */ 538| 315k| if (k <= Kmax && (rv = C->freelist[k])) ------------------ | | 3| 631k|#define Kmax 7 ------------------ | Branch (538:6): [True: 315k, False: 0] | Branch (538:19): [True: 315k, False: 31] ------------------ 539| 315k| C->freelist[k] = rv->next; 540| 31| else { 541| 31| x = 1 << k; 542| 31| rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong)); ------------------ | | 199| 31|#define MALLOC jv_mem_alloc ------------------ 543| 31| rv->k = k; 544| 31| rv->maxwds = x; 545| 31| } 546| 315k| rv->sign = rv->wds = 0; 547| 315k| return rv; 548| 315k| } jv_dtoa.c:d2b: 1187| 30.5k|{ 1188| 30.5k| Bigint *b; 1189| 30.5k| int de, k; 1190| 30.5k| ULong *x, y, z; 1191| 30.5k|#ifndef Sudden_Underflow 1192| 30.5k| int i; 1193| 30.5k|#endif 1194| |#ifdef VAX 1195| | ULong d0, d1; 1196| | d0 = word0(d) >> 16 | word0(d) << 16; 1197| | d1 = word1(d) >> 16 | word1(d) << 16; 1198| |#else 1199| 30.5k|#define d0 word0(d) 1200| 30.5k|#define d1 word1(d) 1201| 30.5k|#endif 1202| | 1203| 30.5k|#ifdef Pack_32 1204| 30.5k| b = Balloc(C, 1); 1205| |#else 1206| | b = Balloc(C, 2); 1207| |#endif 1208| 30.5k| x = b->x; 1209| | 1210| 30.5k| z = d0 & Frac_mask; ------------------ | | 1199| 30.5k|#define d0 word0(d) | | ------------------ | | | | 308| 30.5k|#define word0(x) (x)->L[1] | | ------------------ ------------------ z = d0 & Frac_mask; ------------------ | | 358| 30.5k|#define Frac_mask 0xfffff ------------------ 1211| 30.5k| d0 &= 0x7fffffff; /* clear sign bit, which we ignore */ ------------------ | | 1199| 30.5k|#define d0 word0(d) | | ------------------ | | | | 308| 30.5k|#define word0(x) (x)->L[1] | | ------------------ ------------------ 1212| |#ifdef Sudden_Underflow 1213| | de = (int)(d0 >> Exp_shift); 1214| |#ifndef IBM 1215| | z |= Exp_msk11; 1216| |#endif 1217| |#else 1218| 30.5k| if ((de = (int)(d0 >> Exp_shift))) ------------------ | | 1199| 30.5k|#define d0 word0(d) | | ------------------ | | | | 308| 30.5k|#define word0(x) (x)->L[1] | | ------------------ ------------------ if ((de = (int)(d0 >> Exp_shift))) ------------------ | | 345| 30.5k|#define Exp_shift 20 ------------------ | Branch (1218:6): [True: 30.5k, False: 93] ------------------ 1219| 30.5k| z |= Exp_msk1; ------------------ | | 347| 30.5k|#define Exp_msk1 0x100000 ------------------ 1220| 30.5k|#endif 1221| 30.5k|#ifdef Pack_32 1222| 30.5k| if ((y = d1)) { ------------------ | | 1200| 30.5k|#define d1 word1(d) | | ------------------ | | | | 309| 30.5k|#define word1(x) (x)->L[0] | | ------------------ ------------------ | Branch (1222:6): [True: 24.3k, False: 6.28k] ------------------ 1223| 24.3k| if ((k = lo0bits(C, &y))) { ------------------ | Branch (1223:7): [True: 12.4k, False: 11.9k] ------------------ 1224| 12.4k| x[0] = y | z << (32 - k); 1225| 12.4k| z >>= k; 1226| 12.4k| } 1227| 11.9k| else 1228| 11.9k| x[0] = y; 1229| 24.3k|#ifndef Sudden_Underflow 1230| 24.3k| i = 1231| 24.3k|#endif 1232| 24.3k| b->wds = (x[1] = z) ? 2 : 1; ------------------ | Branch (1232:16): [True: 22.9k, False: 1.36k] ------------------ 1233| 24.3k| } 1234| 6.28k| else { 1235| 6.28k| k = lo0bits(C, &z); 1236| 6.28k| x[0] = z; 1237| 6.28k|#ifndef Sudden_Underflow 1238| 6.28k| i = 1239| 6.28k|#endif 1240| 6.28k| b->wds = 1; 1241| 6.28k| k += 32; 1242| 6.28k| } 1243| |#else 1244| | if (y = d1) { 1245| | if (k = lo0bits(C, &y)) 1246| | if (k >= 16) { 1247| | x[0] = y | z << 32 - k & 0xffff; 1248| | x[1] = z >> k - 16 & 0xffff; 1249| | x[2] = z >> k; 1250| | i = 2; 1251| | } 1252| | else { 1253| | x[0] = y & 0xffff; 1254| | x[1] = y >> 16 | z << 16 - k & 0xffff; 1255| | x[2] = z >> k & 0xffff; 1256| | x[3] = z >> k+16; 1257| | i = 3; 1258| | } 1259| | else { 1260| | x[0] = y & 0xffff; 1261| | x[1] = y >> 16; 1262| | x[2] = z & 0xffff; 1263| | x[3] = z >> 16; 1264| | i = 3; 1265| | } 1266| | } 1267| | else { 1268| |#ifdef DEBUG 1269| | if (!z) 1270| | Bug("Zero passed to d2b"); 1271| |#endif 1272| | k = lo0bits(C, &z); 1273| | if (k >= 16) { 1274| | x[0] = z; 1275| | i = 0; 1276| | } 1277| | else { 1278| | x[0] = z & 0xffff; 1279| | x[1] = z >> 16; 1280| | i = 1; 1281| | } 1282| | k += 32; 1283| | } 1284| | while(!x[i]) 1285| | --i; 1286| | b->wds = i + 1; 1287| |#endif 1288| 30.5k|#ifndef Sudden_Underflow 1289| 30.5k| if (de) { ------------------ | Branch (1289:6): [True: 30.5k, False: 93] ------------------ 1290| 30.5k|#endif 1291| |#ifdef IBM 1292| | *e = (de - Bias - (P-1) << 2) + k; 1293| | *bits = 4*P + 8 - k - hi0bits(C, word0(d) & Frac_mask); 1294| |#else 1295| 30.5k| *e = de - Bias - (P-1) + k; ------------------ | | 352| 30.5k|#define Bias 1023 ------------------ *e = de - Bias - (P-1) + k; ------------------ | | 350| 30.5k|#define P 53 ------------------ 1296| 30.5k| *bits = P - k; ------------------ | | 350| 30.5k|#define P 53 ------------------ 1297| 30.5k|#endif 1298| 30.5k|#ifndef Sudden_Underflow 1299| 30.5k| } 1300| 93| else { 1301| 93| *e = de - Bias - (P-1) + 1 + k; ------------------ | | 352| 93|#define Bias 1023 ------------------ *e = de - Bias - (P-1) + 1 + k; ------------------ | | 350| 93|#define P 53 ------------------ 1302| 93|#ifdef Pack_32 1303| 93| *bits = 32*i - hi0bits(C, x[i-1]); 1304| |#else 1305| | *bits = (i+2)*16 - hi0bits(C, x[i]); 1306| |#endif 1307| 93| } 1308| 30.5k|#endif 1309| 30.5k| return b; 1310| 30.5k| } jv_dtoa.c:lo0bits: 709| 30.5k|{ 710| 30.5k| int k; 711| 30.5k| ULong x = *y; 712| | 713| 30.5k| if (x & 7) { ------------------ | Branch (713:6): [True: 20.5k, False: 10.0k] ------------------ 714| 20.5k| if (x & 1) ------------------ | Branch (714:7): [True: 12.3k, False: 8.17k] ------------------ 715| 12.3k| return 0; 716| 8.17k| if (x & 2) { ------------------ | Branch (716:7): [True: 6.13k, False: 2.03k] ------------------ 717| 6.13k| *y = x >> 1; 718| 6.13k| return 1; 719| 6.13k| } 720| 2.03k| *y = x >> 2; 721| 2.03k| return 2; 722| 8.17k| } 723| 10.0k| k = 0; 724| 10.0k| if (!(x & 0xffff)) { ------------------ | Branch (724:6): [True: 4.65k, False: 5.39k] ------------------ 725| 4.65k| k = 16; 726| 4.65k| x >>= 16; 727| 4.65k| } 728| 10.0k| if (!(x & 0xff)) { ------------------ | Branch (728:6): [True: 3.11k, False: 6.93k] ------------------ 729| 3.11k| k += 8; 730| 3.11k| x >>= 8; 731| 3.11k| } 732| 10.0k| if (!(x & 0xf)) { ------------------ | Branch (732:6): [True: 5.06k, False: 4.98k] ------------------ 733| 5.06k| k += 4; 734| 5.06k| x >>= 4; 735| 5.06k| } 736| 10.0k| if (!(x & 0x3)) { ------------------ | Branch (736:6): [True: 5.09k, False: 4.95k] ------------------ 737| 5.09k| k += 2; 738| 5.09k| x >>= 2; 739| 5.09k| } 740| 10.0k| if (!(x & 1)) { ------------------ | Branch (740:6): [True: 5.00k, False: 5.04k] ------------------ 741| 5.00k| k++; 742| 5.00k| x >>= 1; 743| 5.00k| if (!x) ------------------ | Branch (743:7): [True: 0, False: 5.00k] ------------------ 744| 0| return 32; 745| 5.00k| } 746| 10.0k| *y = x; 747| 10.0k| return k; 748| 10.0k| } jv_dtoa.c:hi0bits: 679| 28.5k|{ 680| 28.5k| int k = 0; 681| | 682| 28.5k| if (!(x & 0xffff0000)) { ------------------ | Branch (682:6): [True: 16.2k, False: 12.3k] ------------------ 683| 16.2k| k = 16; 684| 16.2k| x <<= 16; 685| 16.2k| } 686| 28.5k| if (!(x & 0xff000000)) { ------------------ | Branch (686:6): [True: 12.8k, False: 15.7k] ------------------ 687| 12.8k| k += 8; 688| 12.8k| x <<= 8; 689| 12.8k| } 690| 28.5k| if (!(x & 0xf0000000)) { ------------------ | Branch (690:6): [True: 18.0k, False: 10.5k] ------------------ 691| 18.0k| k += 4; 692| 18.0k| x <<= 4; 693| 18.0k| } 694| 28.5k| if (!(x & 0xc0000000)) { ------------------ | Branch (694:6): [True: 12.3k, False: 16.2k] ------------------ 695| 12.3k| k += 2; 696| 12.3k| x <<= 2; 697| 12.3k| } 698| 28.5k| if (!(x & 0x80000000)) { ------------------ | Branch (698:6): [True: 12.2k, False: 16.3k] ------------------ 699| 12.2k| k++; 700| 12.2k| if (!(x & 0x40000000)) ------------------ | Branch (700:7): [True: 0, False: 12.2k] ------------------ 701| 0| return 32; 702| 12.2k| } 703| 28.5k| return k; 704| 28.5k| } jv_dtoa.c:i2b: 753| 32.5k|{ 754| 32.5k| Bigint *b; 755| | 756| 32.5k| b = Balloc(C, 1); 757| 32.5k| b->x[0] = i; 758| 32.5k| b->wds = 1; 759| 32.5k| return b; 760| 32.5k| } jv_dtoa.c:pow5mult: 872| 26.9k|{ 873| 26.9k| Bigint *b1, *p5, *p51; 874| 26.9k| int i; 875| 26.9k| static const int p05[3] = { 5, 25, 125 }; 876| | 877| 26.9k| if ((i = k & 3)) ------------------ | Branch (877:6): [True: 19.5k, False: 7.41k] ------------------ 878| 19.5k| b = multadd(C, b, p05[i-1], 0); 879| | 880| 26.9k| if (!(k >>= 2)) ------------------ | Branch (880:6): [True: 6.64k, False: 20.3k] ------------------ 881| 6.64k| return b; 882| 20.3k| if (!(p5 = C->p5s)) { ------------------ | Branch (882:6): [True: 1, False: 20.3k] ------------------ 883| | /* first time */ 884| 1| p5 = C->p5s = i2b(C, 625); 885| 1| p5->next = 0; 886| 1| } 887| 113k| for(;;) { 888| 113k| if (k & 1) { ------------------ | Branch (888:7): [True: 58.1k, False: 55.0k] ------------------ 889| 58.1k| b1 = mult(C, b, p5); 890| 58.1k| Bfree(C, b); 891| 58.1k| b = b1; 892| 58.1k| } 893| 113k| if (!(k >>= 1)) ------------------ | Branch (893:7): [True: 20.3k, False: 92.8k] ------------------ 894| 20.3k| break; 895| 92.8k| if (!(p51 = p5->next)) { ------------------ | Branch (895:7): [True: 6, False: 92.8k] ------------------ 896| 6| p51 = p5->next = mult(C, p5,p5); 897| 6| p51->next = 0; 898| 6| } 899| 92.8k| p5 = p51; 900| 92.8k| } 901| 20.3k| return b; 902| 26.9k| } jv_dtoa.c:mult: 765| 68.1k|{ 766| 68.1k| Bigint *c; 767| 68.1k| int k, wa, wb, wc; 768| 68.1k| ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0; 769| 68.1k| ULong y; 770| 68.1k|#ifdef ULLong 771| 68.1k| ULLong carry, z; ------------------ | | 506| 68.1k|#define ULLong unsigned Llong ------------------ 772| |#else 773| | ULong carry, z; 774| |#ifdef Pack_32 775| | ULong z2; 776| |#endif 777| |#endif 778| | 779| 68.1k| if (a->wds < b->wds) { ------------------ | Branch (779:6): [True: 35.5k, False: 32.6k] ------------------ 780| 35.5k| c = a; 781| 35.5k| a = b; 782| 35.5k| b = c; 783| 35.5k| } 784| 68.1k| k = a->k; 785| 68.1k| wa = a->wds; 786| 68.1k| wb = b->wds; 787| 68.1k| wc = wa + wb; 788| 68.1k| if (wc > a->maxwds) ------------------ | Branch (788:6): [True: 29.7k, False: 38.4k] ------------------ 789| 29.7k| k++; 790| 68.1k| c = Balloc(C, k); 791| 730k| for(x = c->x, xa = x + wc; x < xa; x++) ------------------ | Branch (791:29): [True: 662k, False: 68.1k] ------------------ 792| 662k| *x = 0; 793| 68.1k| xa = a->x; 794| 68.1k| xae = xa + wa; 795| 68.1k| xb = b->x; 796| 68.1k| xbe = xb + wb; 797| 68.1k| xc0 = c->x; 798| 68.1k|#ifdef ULLong 799| 207k| for(; xb < xbe; xc0++) { ------------------ | Branch (799:8): [True: 138k, False: 68.1k] ------------------ 800| 138k| if ((y = *xb++)) { ------------------ | Branch (800:7): [True: 138k, False: 261] ------------------ 801| 138k| x = xa; 802| 138k| xc = xc0; 803| 138k| carry = 0; 804| 1.50M| do { 805| 1.50M| z = *x++ * (ULLong)y + *xc + carry; 806| 1.50M| carry = z >> 32; 807| 1.50M| *xc++ = z & FFFFFFFF; ------------------ | | 489| 1.50M|#define FFFFFFFF 0xffffffffUL ------------------ 808| 1.50M| } 809| 1.50M| while(x < xae); ------------------ | Branch (809:11): [True: 1.36M, False: 138k] ------------------ 810| 138k| *xc = carry; 811| 138k| } 812| 138k| } 813| |#else 814| |#ifdef Pack_32 815| | for(; xb < xbe; xb++, xc0++) { 816| | if (y = *xb & 0xffff) { 817| | x = xa; 818| | xc = xc0; 819| | carry = 0; 820| | do { 821| | z = (*x & 0xffff) * y + (*xc & 0xffff) + carry; 822| | carry = z >> 16; 823| | z2 = (*x++ >> 16) * y + (*xc >> 16) + carry; 824| | carry = z2 >> 16; 825| | Storeinc(xc, z2, z); 826| | } 827| | while(x < xae); 828| | *xc = carry; 829| | } 830| | if (y = *xb >> 16) { 831| | x = xa; 832| | xc = xc0; 833| | carry = 0; 834| | z2 = *xc; 835| | do { 836| | z = (*x & 0xffff) * y + (*xc >> 16) + carry; 837| | carry = z >> 16; 838| | Storeinc(xc, z, z2); 839| | z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry; 840| | carry = z2 >> 16; 841| | } 842| | while(x < xae); 843| | *xc = z2; 844| | } 845| | } 846| |#else 847| | for(; xb < xbe; xc0++) { 848| | if (y = *xb++) { 849| | x = xa; 850| | xc = xc0; 851| | carry = 0; 852| | do { 853| | z = *x++ * y + *xc + carry; 854| | carry = z >> 16; 855| | *xc++ = z & 0xffff; 856| | } 857| | while(x < xae); 858| | *xc = carry; 859| | } 860| | } 861| |#endif 862| |#endif 863| 114k| for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ; ------------------ | Branch (863:33): [True: 114k, False: 0] | Branch (863:43): [True: 46.6k, False: 68.1k] ------------------ 864| 68.1k| c->wds = wc; 865| 68.1k| return c; 866| 68.1k| } jv_dtoa.c:lshift: 907| 64.1k|{ 908| 64.1k| int i, k1, n, n1; 909| 64.1k| Bigint *b1; 910| 64.1k| ULong *x, *x1, *xe, z; 911| | 912| 64.1k|#ifdef Pack_32 913| 64.1k| n = k >> 5; 914| |#else 915| | n = k >> 4; 916| |#endif 917| 64.1k| k1 = b->k; 918| 64.1k| n1 = n + b->wds + 1; 919| 169k| for(i = b->maxwds; n1 > i; i <<= 1) ------------------ | Branch (919:21): [True: 105k, False: 64.1k] ------------------ 920| 105k| k1++; 921| 64.1k| b1 = Balloc(C, k1); 922| 64.1k| x1 = b1->x; 923| 452k| for(i = 0; i < n; i++) ------------------ | Branch (923:13): [True: 388k, False: 64.1k] ------------------ 924| 388k| *x1++ = 0; 925| 64.1k| x = b->x; 926| 64.1k| xe = x + b->wds; 927| 64.1k|#ifdef Pack_32 928| 64.1k| if (k &= 0x1f) { ------------------ | Branch (928:6): [True: 63.3k, False: 853] ------------------ 929| 63.3k| k1 = 32 - k; 930| 63.3k| z = 0; 931| 355k| do { 932| 355k| *x1++ = *x << k | z; 933| 355k| z = *x++ >> k1; 934| 355k| } 935| 355k| while(x < xe); ------------------ | Branch (935:10): [True: 291k, False: 63.3k] ------------------ 936| 63.3k| if ((*x1 = z)) ------------------ | Branch (936:7): [True: 8.14k, False: 55.1k] ------------------ 937| 8.14k| ++n1; 938| 63.3k| } 939| |#else 940| | if (k &= 0xf) { 941| | k1 = 16 - k; 942| | z = 0; 943| | do { 944| | *x1++ = *x << k & 0xffff | z; 945| | z = *x++ >> k1; 946| | } 947| | while(x < xe); 948| | if (*x1 = z) 949| | ++n1; 950| | } 951| |#endif 952| 853| else do 953| 1.88k| *x1++ = *x++; 954| 1.88k| while(x < xe); ------------------ | Branch (954:9): [True: 1.03k, False: 853] ------------------ 955| 64.1k| b1->wds = n1 - 1; 956| 64.1k| Bfree(C, b); 957| 64.1k| return b1; 958| 64.1k| } jv_dtoa.c:diff: 993| 67.2k|{ 994| 67.2k| Bigint *c; 995| 67.2k| int i, wa, wb; 996| 67.2k| ULong *xa, *xae, *xb, *xbe, *xc; 997| 67.2k|#ifdef ULLong 998| 67.2k| ULLong borrow, y; ------------------ | | 506| 67.2k|#define ULLong unsigned Llong ------------------ 999| |#else 1000| | ULong borrow, y; 1001| |#ifdef Pack_32 1002| | ULong z; 1003| |#endif 1004| |#endif 1005| | 1006| 67.2k| i = cmp(C, a,b); 1007| 67.2k| if (!i) { ------------------ | Branch (1007:6): [True: 864, False: 66.4k] ------------------ 1008| 864| c = Balloc(C, 0); 1009| 864| c->wds = 1; 1010| 864| c->x[0] = 0; 1011| 864| return c; 1012| 864| } 1013| 66.4k| if (i < 0) { ------------------ | Branch (1013:6): [True: 12.6k, False: 53.7k] ------------------ 1014| 12.6k| c = a; 1015| 12.6k| a = b; 1016| 12.6k| b = c; 1017| 12.6k| i = 1; 1018| 12.6k| } 1019| 53.7k| else 1020| 53.7k| i = 0; 1021| 66.4k| c = Balloc(C, a->k); 1022| 66.4k| c->sign = i; 1023| 66.4k| wa = a->wds; 1024| 66.4k| xa = a->x; 1025| 66.4k| xae = xa + wa; 1026| 66.4k| wb = b->wds; 1027| 66.4k| xb = b->x; 1028| 66.4k| xbe = xb + wb; 1029| 66.4k| xc = c->x; 1030| 66.4k| borrow = 0; 1031| 66.4k|#ifdef ULLong 1032| 1.05M| do { 1033| 1.05M| y = (ULLong)*xa++ - *xb++ - borrow; 1034| 1.05M| borrow = y >> 32 & (ULong)1; 1035| 1.05M| *xc++ = y & FFFFFFFF; ------------------ | | 489| 1.05M|#define FFFFFFFF 0xffffffffUL ------------------ 1036| 1.05M| } 1037| 1.05M| while(xb < xbe); ------------------ | Branch (1037:9): [True: 984k, False: 66.4k] ------------------ 1038| 85.9k| while(xa < xae) { ------------------ | Branch (1038:8): [True: 19.4k, False: 66.4k] ------------------ 1039| 19.4k| y = *xa++ - borrow; 1040| 19.4k| borrow = y >> 32 & (ULong)1; 1041| 19.4k| *xc++ = y & FFFFFFFF; ------------------ | | 489| 19.4k|#define FFFFFFFF 0xffffffffUL ------------------ 1042| 19.4k| } 1043| |#else 1044| |#ifdef Pack_32 1045| | do { 1046| | y = (*xa & 0xffff) - (*xb & 0xffff) - borrow; 1047| | borrow = (y & 0x10000) >> 16; 1048| | z = (*xa++ >> 16) - (*xb++ >> 16) - borrow; 1049| | borrow = (z & 0x10000) >> 16; 1050| | Storeinc(xc, z, y); 1051| | } 1052| | while(xb < xbe); 1053| | while(xa < xae) { 1054| | y = (*xa & 0xffff) - borrow; 1055| | borrow = (y & 0x10000) >> 16; 1056| | z = (*xa++ >> 16) - borrow; 1057| | borrow = (z & 0x10000) >> 16; 1058| | Storeinc(xc, z, y); 1059| | } 1060| |#else 1061| | do { 1062| | y = *xa++ - *xb++ - borrow; 1063| | borrow = (y & 0x10000) >> 16; 1064| | *xc++ = y & 0xffff; 1065| | } 1066| | while(xb < xbe); 1067| | while(xa < xae) { 1068| | y = *xa++ - borrow; 1069| | borrow = (y & 0x10000) >> 16; 1070| | *xc++ = y & 0xffff; 1071| | } 1072| |#endif 1073| |#endif 1074| 97.4k| while(!*--xc) ------------------ | Branch (1074:8): [True: 31.0k, False: 66.4k] ------------------ 1075| 31.0k| wa--; 1076| 66.4k| c->wds = wa; 1077| 66.4k| return c; 1078| 67.2k| } jv_dtoa.c:cmp: 963| 219k|{ 964| 219k| ULong *xa, *xa0, *xb, *xb0; 965| 219k| int i, j; 966| | 967| 219k| i = a->wds; 968| 219k| j = b->wds; 969| |#ifdef DEBUG 970| | if (i > 1 && !a->x[i-1]) 971| | Bug("cmp called with a->x[a->wds-1] == 0"); 972| | if (j > 1 && !b->x[j-1]) 973| | Bug("cmp called with b->x[b->wds-1] == 0"); 974| |#endif 975| 219k| if (i -= j) ------------------ | Branch (975:6): [True: 41.4k, False: 178k] ------------------ 976| 41.4k| return i; 977| 178k| xa0 = a->x; 978| 178k| xa = xa0 + j; 979| 178k| xb0 = b->x; 980| 178k| xb = xb0 + j; 981| 205k| for(;;) { 982| 205k| if (*--xa != *--xb) ------------------ | Branch (982:7): [True: 173k, False: 32.2k] ------------------ 983| 173k| return *xa < *xb ? -1 : 1; ------------------ | Branch (983:11): [True: 103k, False: 69.8k] ------------------ 984| 32.2k| if (xa <= xa0) ------------------ | Branch (984:7): [True: 4.32k, False: 27.8k] ------------------ 985| 4.32k| break; 986| 32.2k| } 987| 4.32k| return 0; 988| 178k| } jv_dtoa.c:sulp: 2109| 608|{ 2110| 608| U u; 2111| 608| double rv; 2112| 608| int i; 2113| | 2114| 608| rv = ulp(C, x); 2115| 608| if (!bc->scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0) ------------------ | | 350| 0|#define P 53 ------------------ if (!bc->scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ if (!bc->scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0) ------------------ | | 349| 0|#define Exp_mask 0x7ff00000 ------------------ if (!bc->scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0) ------------------ | | 345| 0|#define Exp_shift 20 ------------------ | Branch (2115:6): [True: 608, False: 0] | Branch (2115:20): [True: 0, False: 0] ------------------ 2116| 608| return rv; /* Is there an example where i <= 0 ? */ 2117| 0| word0(&u) = Exp_1 + (i << Exp_shift); ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&u) = Exp_1 + (i << Exp_shift); ------------------ | | 355| 0|#define Exp_1 0x3ff00000 ------------------ word0(&u) = Exp_1 + (i << Exp_shift); ------------------ | | 345| 0|#define Exp_shift 20 ------------------ 2118| 0| word1(&u) = 0; ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ 2119| 0| return rv * u.d; 2120| 608| } jv_dtoa.c:ratio: 1317| 12.9k|{ 1318| 12.9k| U da, db; 1319| 12.9k| int k, ka, kb; 1320| | 1321| 12.9k| dval(&da) = b2d(C, a, &ka); ------------------ | | 314| 12.9k|#define dval(x) (x)->d ------------------ 1322| 12.9k| dval(&db) = b2d(C, b, &kb); ------------------ | | 314| 12.9k|#define dval(x) (x)->d ------------------ 1323| 12.9k|#ifdef Pack_32 1324| 12.9k| k = ka - kb + 32*(a->wds - b->wds); 1325| |#else 1326| | k = ka - kb + 16*(a->wds - b->wds); 1327| |#endif 1328| |#ifdef IBM 1329| | if (k > 0) { 1330| | word0(&da) += (k >> 2)*Exp_msk1; 1331| | if (k &= 3) 1332| | dval(&da) *= 1 << k; 1333| | } 1334| | else { 1335| | k = -k; 1336| | word0(&db) += (k >> 2)*Exp_msk1; 1337| | if (k &= 3) 1338| | dval(&db) *= 1 << k; 1339| | } 1340| |#else 1341| 12.9k| if (k > 0) ------------------ | Branch (1341:6): [True: 6.71k, False: 6.20k] ------------------ 1342| 6.71k| word0(&da) += k*Exp_msk1; ------------------ | | 308| 6.71k|#define word0(x) (x)->L[1] ------------------ word0(&da) += k*Exp_msk1; ------------------ | | 347| 6.71k|#define Exp_msk1 0x100000 ------------------ 1343| 6.20k| else { 1344| 6.20k| k = -k; 1345| 6.20k| word0(&db) += k*Exp_msk1; ------------------ | | 308| 6.20k|#define word0(x) (x)->L[1] ------------------ word0(&db) += k*Exp_msk1; ------------------ | | 347| 6.20k|#define Exp_msk1 0x100000 ------------------ 1346| 6.20k| } 1347| 12.9k|#endif 1348| 12.9k| return dval(&da) / dval(&db); ------------------ | | 314| 12.9k|#define dval(x) (x)->d ------------------ return dval(&da) / dval(&db); ------------------ | | 314| 12.9k|#define dval(x) (x)->d ------------------ 1349| 12.9k| } jv_dtoa.c:b2d: 1121| 25.8k|{ 1122| 25.8k| ULong *xa, *xa0, w, y, z; 1123| 25.8k| int k; 1124| 25.8k| U d; 1125| |#ifdef VAX 1126| | ULong d0, d1; 1127| |#else 1128| 25.8k|#define d0 word0(&d) 1129| 25.8k|#define d1 word1(&d) 1130| 25.8k|#endif 1131| | 1132| 25.8k| xa0 = a->x; 1133| 25.8k| xa = xa0 + a->wds; 1134| 25.8k| y = *--xa; 1135| |#ifdef DEBUG 1136| | if (!y) Bug("zero y in b2d"); 1137| |#endif 1138| 25.8k| k = hi0bits(C, y); 1139| 25.8k| *e = 32 - k; 1140| 25.8k|#ifdef Pack_32 1141| 25.8k| if (k < Ebits) { ------------------ | | 357| 25.8k|#define Ebits 11 ------------------ | Branch (1141:6): [True: 7.14k, False: 18.7k] ------------------ 1142| 7.14k| d0 = Exp_1 | y >> (Ebits - k); ------------------ | | 1128| 7.14k|#define d0 word0(&d) | | ------------------ | | | | 308| 7.14k|#define word0(x) (x)->L[1] | | ------------------ ------------------ d0 = Exp_1 | y >> (Ebits - k); ------------------ | | 355| 7.14k|#define Exp_1 0x3ff00000 ------------------ d0 = Exp_1 | y >> (Ebits - k); ------------------ | | 357| 7.14k|#define Ebits 11 ------------------ 1143| 7.14k| w = xa > xa0 ? *--xa : 0; ------------------ | Branch (1143:7): [True: 5.67k, False: 1.46k] ------------------ 1144| 7.14k| d1 = y << ((32-Ebits) + k) | w >> (Ebits - k); ------------------ | | 1129| 7.14k|#define d1 word1(&d) | | ------------------ | | | | 309| 7.14k|#define word1(x) (x)->L[0] | | ------------------ ------------------ d1 = y << ((32-Ebits) + k) | w >> (Ebits - k); ------------------ | | 357| 7.14k|#define Ebits 11 ------------------ d1 = y << ((32-Ebits) + k) | w >> (Ebits - k); ------------------ | | 357| 7.14k|#define Ebits 11 ------------------ 1145| 7.14k| goto ret_d; 1146| 7.14k| } 1147| 18.7k| z = xa > xa0 ? *--xa : 0; ------------------ | Branch (1147:6): [True: 11.7k, False: 6.90k] ------------------ 1148| 18.7k| if (k -= Ebits) { ------------------ | | 357| 18.7k|#define Ebits 11 ------------------ | Branch (1148:6): [True: 17.9k, False: 786] ------------------ 1149| 17.9k| d0 = Exp_1 | y << k | z >> (32 - k); ------------------ | | 1128| 17.9k|#define d0 word0(&d) | | ------------------ | | | | 308| 17.9k|#define word0(x) (x)->L[1] | | ------------------ ------------------ d0 = Exp_1 | y << k | z >> (32 - k); ------------------ | | 355| 17.9k|#define Exp_1 0x3ff00000 ------------------ 1150| 17.9k| y = xa > xa0 ? *--xa : 0; ------------------ | Branch (1150:7): [True: 10.1k, False: 7.81k] ------------------ 1151| 17.9k| d1 = z << k | y >> (32 - k); ------------------ | | 1129| 17.9k|#define d1 word1(&d) | | ------------------ | | | | 309| 17.9k|#define word1(x) (x)->L[0] | | ------------------ ------------------ 1152| 17.9k| } 1153| 786| else { 1154| 786| d0 = Exp_1 | y; ------------------ | | 1128| 786|#define d0 word0(&d) | | ------------------ | | | | 308| 786|#define word0(x) (x)->L[1] | | ------------------ ------------------ d0 = Exp_1 | y; ------------------ | | 355| 786|#define Exp_1 0x3ff00000 ------------------ 1155| 786| d1 = z; ------------------ | | 1129| 786|#define d1 word1(&d) | | ------------------ | | | | 309| 786|#define word1(x) (x)->L[0] | | ------------------ ------------------ 1156| 786| } 1157| |#else 1158| | if (k < Ebits + 16) { 1159| | z = xa > xa0 ? *--xa : 0; 1160| | d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k; 1161| | w = xa > xa0 ? *--xa : 0; 1162| | y = xa > xa0 ? *--xa : 0; 1163| | d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k; 1164| | goto ret_d; 1165| | } 1166| | z = xa > xa0 ? *--xa : 0; 1167| | w = xa > xa0 ? *--xa : 0; 1168| | k -= Ebits + 16; 1169| | d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k; 1170| | y = xa > xa0 ? *--xa : 0; 1171| | d1 = w << k + 16 | y << k; 1172| |#endif 1173| 25.8k| ret_d: 1174| |#ifdef VAX 1175| | word0(&d) = d0 >> 16 | d0 << 16; 1176| | word1(&d) = d1 >> 16 | d1 << 16; 1177| |#else 1178| 25.8k|#undef d0 1179| 25.8k|#undef d1 1180| 25.8k|#endif 1181| 25.8k| return dval(&d); ------------------ | | 314| 25.8k|#define dval(x) (x)->d ------------------ 1182| 18.7k| } jv_dtoa.c:ulp: 1083| 13.5k|{ 1084| 13.5k| Long L; ------------------ | | 193| 13.5k|#define Long int ------------------ 1085| 13.5k| U u; 1086| | 1087| 13.5k| L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 308| 13.5k|#define word0(x) (x)->L[1] ------------------ L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 349| 13.5k|#define Exp_mask 0x7ff00000 ------------------ L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 350| 13.5k|#define P 53 ------------------ L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 347| 13.5k|#define Exp_msk1 0x100000 ------------------ 1088| |#ifndef Avoid_Underflow 1089| |#ifndef Sudden_Underflow 1090| | if (L > 0) { 1091| |#endif 1092| |#endif 1093| |#ifdef IBM 1094| | L |= Exp_msk1 >> 4; 1095| |#endif 1096| 13.5k| word0(&u) = L; ------------------ | | 308| 13.5k|#define word0(x) (x)->L[1] ------------------ 1097| 13.5k| word1(&u) = 0; ------------------ | | 309| 13.5k|#define word1(x) (x)->L[0] ------------------ 1098| |#ifndef Avoid_Underflow 1099| |#ifndef Sudden_Underflow 1100| | } 1101| | else { 1102| | L = -L >> Exp_shift; 1103| | if (L < Exp_shift) { 1104| | word0(&u) = 0x80000 >> L; 1105| | word1(&u) = 0; 1106| | } 1107| | else { 1108| | word0(&u) = 0; 1109| | L -= Exp_shift; 1110| | word1(&u) = L >= 31 ? 1 : 1 << 31 - L; 1111| | } 1112| | } 1113| |#endif 1114| |#endif 1115| 13.5k| return dval(&u); ------------------ | | 314| 13.5k|#define dval(x) (x)->d ------------------ 1116| 13.5k| } jv_dtoa.c:nrv_alloc: 3412| 110|{ 3413| 110| char *rv, *t; 3414| | 3415| 110| t = rv = rv_alloc(C, n); 3416| 220| while((*t = *s++)) t++; ------------------ | Branch (3416:8): [True: 110, False: 110] ------------------ 3417| 110| if (rve) ------------------ | Branch (3417:6): [True: 110, False: 0] ------------------ 3418| 110| *rve = t; 3419| 110| return rv; 3420| 110| } jv_dtoa.c:rv_alloc: 3396| 3.47k|{ 3397| 3.47k| int j, k, *r; 3398| | 3399| 3.47k| j = sizeof(ULong); 3400| 3.47k| for(k = 0; 3401| 3.47k| (int)(sizeof(Bigint) - sizeof(ULong) - sizeof(int)) + j <= i; ------------------ | Branch (3401:13): [True: 0, False: 3.47k] ------------------ 3402| 3.47k| j <<= 1) 3403| 0| k++; 3404| 3.47k| r = (int*)Balloc(C, k); 3405| 3.47k| *r = k; 3406| 3.47k| return 3407| 3.47k| (char *)(r+1); 3408| 3.47k| } jv_dtoa.c:dshift: 1978| 2.65k|{ 1979| 2.65k| int rv = hi0bits(C, b->x[b->wds-1]) - 4; 1980| 2.65k| if (p2 > 0) ------------------ | Branch (1980:6): [True: 495, False: 2.16k] ------------------ 1981| 495| rv -= p2; 1982| 2.65k| return rv & kmask; ------------------ | | 1518| 2.65k|#define kmask 31 ------------------ 1983| 2.65k| } jv_dtoa.c:multadd: 592| 174k|{ 593| 174k| int i, wds; 594| 174k|#ifdef ULLong 595| 174k| ULong *x; 596| 174k| ULLong carry, y; ------------------ | | 506| 174k|#define ULLong unsigned Llong ------------------ 597| |#else 598| | ULong carry, *x, y; 599| |#ifdef Pack_32 600| | ULong xi, z; 601| |#endif 602| |#endif 603| 174k| Bigint *b1; 604| | 605| 174k| wds = b->wds; 606| 174k| x = b->x; 607| 174k| i = 0; 608| 174k| carry = a; 609| 1.61M| do { 610| 1.61M|#ifdef ULLong 611| 1.61M| y = *x * (ULLong)m + carry; 612| 1.61M| carry = y >> 32; 613| 1.61M| *x++ = y & FFFFFFFF; ------------------ | | 489| 1.61M|#define FFFFFFFF 0xffffffffUL ------------------ 614| |#else 615| |#ifdef Pack_32 616| | xi = *x; 617| | y = (xi & 0xffff) * m + carry; 618| | z = (xi >> 16) * m + (y >> 16); 619| | carry = z >> 16; 620| | *x++ = (z << 16) + (y & 0xffff); 621| |#else 622| | y = *x * m + carry; 623| | carry = y >> 16; 624| | *x++ = y & 0xffff; 625| |#endif 626| |#endif 627| 1.61M| } 628| 1.61M| while(++i < wds); ------------------ | Branch (628:9): [True: 1.43M, False: 174k] ------------------ 629| 174k| if (carry) { ------------------ | Branch (629:6): [True: 14.8k, False: 160k] ------------------ 630| 14.8k| if (wds >= b->maxwds) { ------------------ | Branch (630:7): [True: 356, False: 14.4k] ------------------ 631| 356| b1 = Balloc(C, b->k+1); 632| 356| Bcopy(b1, b); ------------------ | | 586| 356|#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ | | 587| 356|y->wds*sizeof(Long) + 2*sizeof(int)) ------------------ 633| 356| Bfree(C, b); 634| 356| b = b1; 635| 356| } 636| 14.8k| b->x[wds++] = carry; 637| 14.8k| b->wds = wds; 638| 14.8k| } 639| 174k| return b; 640| 174k| } jv_dtoa.c:quorem: 1988| 40.0k|{ 1989| 40.0k| int n; 1990| 40.0k| ULong *bx, *bxe, q, *sx, *sxe; 1991| 40.0k|#ifdef ULLong 1992| 40.0k| ULLong borrow, carry, y, ys; ------------------ | | 506| 40.0k|#define ULLong unsigned Llong ------------------ 1993| |#else 1994| | ULong borrow, carry, y, ys; 1995| |#ifdef Pack_32 1996| | ULong si, z, zs; 1997| |#endif 1998| |#endif 1999| | 2000| 40.0k| n = S->wds; 2001| |#ifdef DEBUG 2002| | /*debug*/ if (b->wds > n) 2003| | /*debug*/ Bug("oversize b in quorem"); 2004| |#endif 2005| 40.0k| if (b->wds < n) ------------------ | Branch (2005:6): [True: 200, False: 39.8k] ------------------ 2006| 200| return 0; 2007| 39.8k| sx = S->x; 2008| 39.8k| sxe = sx + --n; 2009| 39.8k| bx = b->x; 2010| 39.8k| bxe = bx + n; 2011| 39.8k| q = *bxe / (*sxe + 1); /* ensure q <= true quotient */ 2012| |#ifdef DEBUG 2013| |#ifdef NO_STRTOD_BIGCOMP 2014| | /*debug*/ if (q > 9) 2015| |#else 2016| | /* An oversized q is possible when quorem is called from bigcomp and */ 2017| | /* the input is near, e.g., twice the smallest denormalized number. */ 2018| | /*debug*/ if (q > 15) 2019| |#endif 2020| | /*debug*/ Bug("oversized quotient in quorem"); 2021| |#endif 2022| 39.8k| if (q) { ------------------ | Branch (2022:6): [True: 37.9k, False: 1.91k] ------------------ 2023| 37.9k| borrow = 0; 2024| 37.9k| carry = 0; 2025| 766k| do { 2026| 766k|#ifdef ULLong 2027| 766k| ys = *sx++ * (ULLong)q + carry; 2028| 766k| carry = ys >> 32; 2029| 766k| y = *bx - (ys & FFFFFFFF) - borrow; ------------------ | | 489| 766k|#define FFFFFFFF 0xffffffffUL ------------------ 2030| 766k| borrow = y >> 32 & (ULong)1; 2031| 766k| *bx++ = y & FFFFFFFF; ------------------ | | 489| 766k|#define FFFFFFFF 0xffffffffUL ------------------ 2032| |#else 2033| |#ifdef Pack_32 2034| | si = *sx++; 2035| | ys = (si & 0xffff) * q + carry; 2036| | zs = (si >> 16) * q + (ys >> 16); 2037| | carry = zs >> 16; 2038| | y = (*bx & 0xffff) - (ys & 0xffff) - borrow; 2039| | borrow = (y & 0x10000) >> 16; 2040| | z = (*bx >> 16) - (zs & 0xffff) - borrow; 2041| | borrow = (z & 0x10000) >> 16; 2042| | Storeinc(bx, z, y); 2043| |#else 2044| | ys = *sx++ * q + carry; 2045| | carry = ys >> 16; 2046| | y = *bx - (ys & 0xffff) - borrow; 2047| | borrow = (y & 0x10000) >> 16; 2048| | *bx++ = y & 0xffff; 2049| |#endif 2050| |#endif 2051| 766k| } 2052| 766k| while(sx <= sxe); ------------------ | Branch (2052:10): [True: 728k, False: 37.9k] ------------------ 2053| 37.9k| if (!*bxe) { ------------------ | Branch (2053:7): [True: 43, False: 37.8k] ------------------ 2054| 43| bx = b->x; 2055| 43| while(--bxe > bx && !*bxe) ------------------ | Branch (2055:10): [True: 37, False: 6] | Branch (2055:24): [True: 0, False: 37] ------------------ 2056| 0| --n; 2057| 43| b->wds = n; 2058| 43| } 2059| 37.9k| } 2060| 39.8k| if (cmp(C, b, S) >= 0) { ------------------ | Branch (2060:6): [True: 298, False: 39.5k] ------------------ 2061| 298| q++; 2062| 298| borrow = 0; 2063| 298| carry = 0; 2064| 298| bx = b->x; 2065| 298| sx = S->x; 2066| 2.20k| do { 2067| 2.20k|#ifdef ULLong 2068| 2.20k| ys = *sx++ + carry; 2069| 2.20k| carry = ys >> 32; 2070| 2.20k| y = *bx - (ys & FFFFFFFF) - borrow; ------------------ | | 489| 2.20k|#define FFFFFFFF 0xffffffffUL ------------------ 2071| 2.20k| borrow = y >> 32 & (ULong)1; 2072| 2.20k| *bx++ = y & FFFFFFFF; ------------------ | | 489| 2.20k|#define FFFFFFFF 0xffffffffUL ------------------ 2073| |#else 2074| |#ifdef Pack_32 2075| | si = *sx++; 2076| | ys = (si & 0xffff) + carry; 2077| | zs = (si >> 16) + (ys >> 16); 2078| | carry = zs >> 16; 2079| | y = (*bx & 0xffff) - (ys & 0xffff) - borrow; 2080| | borrow = (y & 0x10000) >> 16; 2081| | z = (*bx >> 16) - (zs & 0xffff) - borrow; 2082| | borrow = (z & 0x10000) >> 16; 2083| | Storeinc(bx, z, y); 2084| |#else 2085| | ys = *sx++ + carry; 2086| | carry = ys >> 16; 2087| | y = *bx - (ys & 0xffff) - borrow; 2088| | borrow = (y & 0x10000) >> 16; 2089| | *bx++ = y & 0xffff; 2090| |#endif 2091| |#endif 2092| 2.20k| } 2093| 2.20k| while(sx <= sxe); ------------------ | Branch (2093:10): [True: 1.90k, False: 298] ------------------ 2094| 298| bx = b->x; 2095| 298| bxe = bx + n; 2096| 298| if (!*bxe) { ------------------ | Branch (2096:7): [True: 277, False: 21] ------------------ 2097| 281| while(--bxe > bx && !*bxe) ------------------ | Branch (2097:10): [True: 129, False: 152] | Branch (2097:24): [True: 4, False: 125] ------------------ 2098| 4| --n; 2099| 277| b->wds = n; 2100| 277| } 2101| 298| } 2102| 39.8k| return q; 2103| 40.0k| } tsd_dtoa_context_get: 39| 717k|inline struct dtoa_context *tsd_dtoa_context_get(void) { 40| 717k| pthread_once(&dtoa_ctx_once, jv_tsd_dtoa_ctx_init); // cannot fail 41| 717k| struct dtoa_context *ctx = (struct dtoa_context*)pthread_getspecific(dtoa_ctx_key); 42| 717k| if (!ctx) { ------------------ | Branch (42:7): [True: 1, False: 717k] ------------------ 43| 1| ctx = jv_mem_alloc(sizeof(struct dtoa_context)); 44| 1| jvp_dtoa_context_init(ctx); 45| 1| if (pthread_setspecific(dtoa_ctx_key, ctx) != 0) { ------------------ | Branch (45:9): [True: 0, False: 1] ------------------ 46| 0| jv_mem_free(ctx); 47| 0| fprintf(stderr, "error: cannot set thread specific data"); 48| 0| abort(); 49| 0| } 50| 1| } 51| 717k| return ctx; 52| 717k|} jv_dtoa_tsd.c:jv_tsd_dtoa_ctx_init: 31| 1|void jv_tsd_dtoa_ctx_init(void) { 32| 1| if (pthread_key_create(&dtoa_ctx_key, tsd_dtoa_ctx_dtor) != 0) { ------------------ | Branch (32:7): [True: 0, False: 1] ------------------ 33| 0| fprintf(stderr, "error: cannot create thread specific key"); 34| 0| abort(); 35| 0| } 36| 1| atexit(jv_tsd_dtoa_ctx_fini); 37| 1|} jv_dtoa_tsd.c:tsd_dtoa_ctx_dtor: 12| 1|static void tsd_dtoa_ctx_dtor(void *ctx) { 13| 1| if (ctx) { ------------------ | Branch (13:7): [True: 1, False: 0] ------------------ 14| 1| jvp_dtoa_context_free((struct dtoa_context *)ctx); 15| 1| jv_mem_free(ctx); 16| 1| } 17| 1|} jv_dtoa_tsd.c:jv_tsd_dtoa_ctx_fini: 22| 1|void jv_tsd_dtoa_ctx_fini(void) { 23| 1| struct dtoa_context *ctx = pthread_getspecific(dtoa_ctx_key); 24| 1| tsd_dtoa_ctx_dtor(ctx); 25| | pthread_setspecific(dtoa_ctx_key, NULL); 26| 1|} jv_parser_set_buf: 735| 578k|void jv_parser_set_buf(struct jv_parser* p, const char* buf, int length, int is_partial) { 736| 578k| assert((p->curr_buf == 0 || p->curr_buf_pos == p->curr_buf_length) ------------------ | Branch (736:3): [True: 578k, False: 0] | Branch (736:3): [True: 0, False: 0] | Branch (736:3): [True: 0, False: 0] | Branch (736:3): [True: 578k, False: 0] | Branch (736:3): [True: 0, False: 0] | Branch (736:3): [True: 578k, False: 0] ------------------ 737| 578k| && "previous buffer not exhausted"); 738| 1.15M| while (length > 0 && p->bom_strip_position < sizeof(UTF8_BOM)) { ------------------ | Branch (738:10): [True: 1.15M, False: 483] | Branch (738:24): [True: 577k, False: 577k] ------------------ 739| 577k| if ((unsigned char)*buf == UTF8_BOM[p->bom_strip_position]) { ------------------ | Branch (739:9): [True: 20, False: 577k] ------------------ 740| | // matched a BOM character 741| 20| buf++; 742| 20| length--; 743| 20| p->bom_strip_position++; 744| 577k| } else { 745| 577k| if (p->bom_strip_position == 0) { ------------------ | Branch (745:11): [True: 577k, False: 14] ------------------ 746| | // no BOM in this document 747| 577k| p->bom_strip_position = sizeof(UTF8_BOM); 748| 577k| } else { 749| | // malformed BOM (prefix present, rest missing) 750| 14| p->bom_strip_position = 0xff; 751| 14| } 752| 577k| } 753| 577k| } 754| 578k| p->curr_buf = buf; 755| 578k| p->curr_buf_length = length; 756| 578k| p->curr_buf_pos = 0; 757| 578k| p->curr_buf_is_partial = is_partial; 758| 578k|} jv_parser_next: 772| 1.15M|jv jv_parser_next(struct jv_parser* p) { 773| 1.15M| if (p->eof) ------------------ | Branch (773:7): [True: 570k, False: 584k] ------------------ 774| 570k| return jv_invalid(); 775| 584k| if (!p->curr_buf) ------------------ | Branch (775:7): [True: 0, False: 584k] ------------------ 776| 0| return jv_invalid(); // Need a buffer 777| 584k| if (p->bom_strip_position == 0xff) { ------------------ | Branch (777:7): [True: 14, False: 584k] ------------------ 778| 14| if (!(p->flags & JV_PARSE_SEQ)) ------------------ | Branch (778:9): [True: 14, False: 0] ------------------ 779| 14| return jv_invalid_with_msg(jv_string("Malformed BOM")); 780| 0| p->st =JV_PARSER_WAITING_FOR_RS; 781| 0| parser_reset(p); 782| 0| } 783| 584k| jv value = jv_invalid(); 784| 584k| if ((p->flags & JV_PARSE_STREAMING) && stream_check_done(p, &value)) ------------------ | Branch (784:7): [True: 0, False: 584k] | Branch (784:42): [True: 0, False: 0] ------------------ 785| 0| return value; 786| 584k| char ch; 787| 584k| presult msg = 0; 788| 150M| while (!msg && p->curr_buf_pos < p->curr_buf_length) { ------------------ | Branch (788:10): [True: 150M, False: 6.93k] | Branch (788:18): [True: 150M, False: 578k] ------------------ 789| 150M| ch = p->curr_buf[p->curr_buf_pos++]; 790| 150M| if (p->st == JV_PARSER_WAITING_FOR_RS) { ------------------ | Branch (790:9): [True: 0, False: 150M] ------------------ 791| 0| if (ch == '\n') { ------------------ | Branch (791:11): [True: 0, False: 0] ------------------ 792| 0| p->line++; 793| 0| p->column = 0; 794| 0| } else { 795| 0| p->column++; 796| 0| } 797| 0| if (ch == '\036') ------------------ | Branch (797:11): [True: 0, False: 0] ------------------ 798| 0| p->st = JV_PARSER_NORMAL; 799| 0| continue; // need to resync, wait for RS 800| 0| } 801| 150M| msg = scan(p, ch, &value); 802| 150M| } 803| 584k| if (msg == OK) { ------------------ | Branch (803:7): [True: 6.65k, False: 578k] ------------------ 804| 6.65k| return value; 805| 578k| } else if (msg) { ------------------ | Branch (805:14): [True: 279, False: 578k] ------------------ 806| 279| jv_free(value); 807| 279| if (ch != '\036' && (p->flags & JV_PARSE_SEQ)) { ------------------ | Branch (807:9): [True: 279, False: 0] | Branch (807:25): [True: 0, False: 279] ------------------ 808| | // Skip to the next RS 809| 0| p->st = JV_PARSER_WAITING_FOR_RS; 810| 0| value = make_error(p, "%s at line %d, column %d (need RS to resync)", msg, p->line, p->column); 811| 0| parser_reset(p); 812| 0| return value; 813| 0| } 814| 279| value = make_error(p, "%s at line %d, column %d", msg, p->line, p->column); 815| 279| parser_reset(p); 816| 279| if (!(p->flags & JV_PARSE_SEQ)) { ------------------ | Branch (816:9): [True: 279, False: 0] ------------------ 817| | // We're not parsing a JSON text sequence; throw this buffer away. 818| | // XXX We should fail permanently here. 819| 279| p->curr_buf = 0; 820| 279| p->curr_buf_pos = 0; 821| 279| } // Else ch must be RS; don't clear buf so we can start parsing again after this ch 822| 279| return value; 823| 578k| } else if (p->curr_buf_is_partial) { ------------------ | Branch (823:14): [True: 0, False: 578k] ------------------ 824| 0| assert(p->curr_buf_pos == p->curr_buf_length); ------------------ | Branch (824:5): [True: 0, False: 0] | Branch (824:5): [True: 0, False: 0] ------------------ 825| | // need another buffer 826| 0| return jv_invalid(); 827| 578k| } else { 828| | // at EOF 829| 578k| p->eof = 1; 830| 578k| assert(p->curr_buf_pos == p->curr_buf_length); ------------------ | Branch (830:5): [True: 0, False: 578k] | Branch (830:5): [True: 578k, False: 0] ------------------ 831| 578k| jv_free(value); 832| 578k| if (p->st == JV_PARSER_WAITING_FOR_RS) ------------------ | Branch (832:9): [True: 0, False: 578k] ------------------ 833| 0| return make_error(p, "Unfinished abandoned text at EOF at line %d, column %d", p->line, p->column); 834| 578k| if (p->st != JV_PARSER_NORMAL) { ------------------ | Branch (834:9): [True: 71, False: 577k] ------------------ 835| 71| value = make_error(p, "Unfinished string at EOF at line %d, column %d", p->line, p->column); 836| 71| parser_reset(p); 837| 71| p->st = JV_PARSER_WAITING_FOR_RS; 838| 71| return value; 839| 71| } 840| 577k| if ((msg = check_literal(p))) { ------------------ | Branch (840:9): [True: 414, False: 577k] ------------------ 841| 414| value = make_error(p, "%s at EOF at line %d, column %d", msg, p->line, p->column); 842| 414| parser_reset(p); 843| 414| p->st = JV_PARSER_WAITING_FOR_RS; 844| 414| return value; 845| 414| } 846| 577k| if (((p->flags & JV_PARSE_STREAMING) && p->stacklen != 0) || ------------------ | Branch (846:10): [True: 0, False: 577k] | Branch (846:45): [True: 0, False: 0] ------------------ 847| 577k| (!(p->flags & JV_PARSE_STREAMING) && p->stackpos != 0)) { ------------------ | Branch (847:10): [True: 577k, False: 0] | Branch (847:46): [True: 179, False: 577k] ------------------ 848| 179| value = make_error(p, "Unfinished JSON term at EOF at line %d, column %d", p->line, p->column); 849| 179| parser_reset(p); 850| 179| p->st = JV_PARSER_WAITING_FOR_RS; 851| 179| return value; 852| 179| } 853| | // p->next is either invalid (nothing here, but no syntax error) 854| | // or valid (this is the value). either way it's the thing to return 855| 577k| if ((p->flags & JV_PARSE_STREAMING) && jv_is_valid(p->next)) { ------------------ | Branch (855:9): [True: 0, False: 577k] | Branch (855:44): [True: 0, False: 0] ------------------ 856| 0| value = JV_ARRAY(jv_copy(p->path), p->next); // except in streaming mode we've got to make it [path,value] ------------------ | | 111| 0| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | ------------------ | | | | 109| 0|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 111| 0| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 101| 0|#define JV_ARRAY_2(e1,e2) (jv_array_append(JV_ARRAY_1(e1),e2)) | | | | | | | | ------------------ | | | | | | | | | | 100| 0|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 857| 577k| } else { 858| 577k| value = p->next; 859| 577k| } 860| 577k| p->next = jv_invalid(); 861| 577k| if ((p->flags & JV_PARSE_SEQ) && !p->last_ch_was_ws && jv_get_kind(value) == JV_KIND_NUMBER) { ------------------ | Branch (861:9): [True: 0, False: 577k] | Branch (861:38): [True: 0, False: 0] | Branch (861:60): [True: 0, False: 0] ------------------ 862| 0| jv_free(value); 863| 0| return make_error(p, "Potentially truncated top-level numeric value at EOF at line %d, column %d", p->line, p->column); 864| 0| } 865| 577k| return value; 866| 577k| } 867| 584k|} jv_parse_sized_custom_flags: 869| 578k|jv jv_parse_sized_custom_flags(const char* string, int length, int flags) { 870| 578k| struct jv_parser parser; 871| 578k| parser_init(&parser, flags); 872| 578k| jv_parser_set_buf(&parser, string, length, 0); 873| 578k| jv value = jv_parser_next(&parser); 874| 578k| if (jv_is_valid(value)) { ------------------ | Branch (874:7): [True: 576k, False: 1.39k] ------------------ 875| 576k| jv next = jv_parser_next(&parser); 876| 576k| if (jv_is_valid(next)) { ------------------ | Branch (876:9): [True: 39, False: 576k] ------------------ 877| | // multiple JSON values, we only wanted one 878| 39| jv_free(value); 879| 39| jv_free(next); 880| 39| value = jv_invalid_with_msg(jv_string("Unexpected extra JSON values")); 881| 576k| } else if (jv_invalid_has_msg(jv_copy(next))) { ------------------ | Branch (881:16): [True: 82, False: 576k] ------------------ 882| | // parser error after the first JSON value 883| 82| jv_free(value); 884| 82| value = next; 885| 576k| } else { 886| | // a single valid JSON value 887| 576k| jv_free(next); 888| 576k| } 889| 576k| } else if (jv_invalid_has_msg(jv_copy(value))) { ------------------ | Branch (889:14): [True: 875, False: 516] ------------------ 890| | // parse error, we'll return it 891| 875| } else { 892| | // no value at all 893| 516| jv_free(value); 894| 516| value = jv_invalid_with_msg(jv_string("Expected JSON value")); 895| 516| } 896| 578k| parser_free(&parser); 897| | 898| 578k| if (!jv_is_valid(value) && jv_invalid_has_msg(jv_copy(value))) { ------------------ | Branch (898:7): [True: 1.51k, False: 576k] | Branch (898:30): [True: 1.51k, False: 0] ------------------ 899| 1.51k| jv msg = jv_invalid_get_msg(value); 900| 1.51k| value = jv_invalid_with_msg(jv_string_fmt("%s (while parsing '%.*s')", 901| 1.51k| jv_string_value(msg), 902| 1.51k| length, 903| 1.51k| string)); 904| 1.51k| jv_free(msg); 905| 1.51k| } 906| 578k| return value; 907| 578k|} jv_parse_sized: 909| 578k|jv jv_parse_sized(const char* string, int length) { 910| 578k| return jv_parse_sized_custom_flags(string, length, 0); 911| 578k|} jv_parse: 913| 14.2k|jv jv_parse(const char* string) { 914| 14.2k| return jv_parse_sized(string, strlen(string)); 915| 14.2k|} jv_parse.c:parser_init: 70| 578k|static void parser_init(struct jv_parser* p, int flags) { 71| 578k| p->flags = flags; 72| 578k| if ((p->flags & JV_PARSE_STREAMING)) { ------------------ | Branch (72:7): [True: 0, False: 578k] ------------------ 73| 0| p->path = jv_array(); 74| 578k| } else { 75| 578k| p->path = jv_invalid(); 76| 578k| p->flags &= ~(JV_PARSE_STREAM_ERRORS); 77| 578k| } 78| 578k| p->stack = 0; 79| 578k| p->stacklen = p->stackpos = 0; 80| 578k| p->last_seen = JV_LAST_NONE; 81| 578k| p->output = jv_invalid(); 82| 578k| p->next = jv_invalid(); 83| 578k| p->tokenlen = 256; 84| 578k| p->tokenbuf = jv_mem_alloc(p->tokenlen); 85| 578k| p->tokenpos = 0; 86| 578k| if ((p->flags & JV_PARSE_SEQ)) ------------------ | Branch (86:7): [True: 0, False: 578k] ------------------ 87| 0| p->st = JV_PARSER_WAITING_FOR_RS; 88| 578k| else 89| 578k| p->st = JV_PARSER_NORMAL; 90| 578k| p->eof = 0; 91| 578k| p->curr_buf = 0; 92| 578k| p->curr_buf_length = p->curr_buf_pos = p->curr_buf_is_partial = 0; 93| 578k| p->bom_strip_position = 0; 94| 578k| p->last_ch_was_ws = 0; 95| 578k| p->line = 1; 96| 578k| p->column = 0; 97| 578k| jvp_dtoa_context_init(&p->dtoa); 98| 578k|} jv_parse.c:parser_free: 118| 578k|static void parser_free(struct jv_parser* p) { 119| 578k| parser_reset(p); 120| 578k| jv_free(p->path); 121| 578k| jv_free(p->output); 122| 578k| jv_mem_free(p->stack); 123| 578k| jv_mem_free(p->tokenbuf); 124| 578k| jvp_dtoa_context_free(&p->dtoa); 125| 578k|} jv_parse.c:parser_reset: 100| 579k|static void parser_reset(struct jv_parser* p) { 101| 579k| if ((p->flags & JV_PARSE_STREAMING)) { ------------------ | Branch (101:7): [True: 0, False: 579k] ------------------ 102| 0| jv_free(p->path); 103| 0| p->path = jv_array(); 104| 0| p->stacklen = 0; 105| 0| } 106| 579k| p->last_seen = JV_LAST_NONE; 107| 579k| jv_free(p->output); 108| 579k| p->output = jv_invalid(); 109| 579k| jv_free(p->next); 110| 579k| p->next = jv_invalid(); 111| 758k| for (int i=0; istackpos; i++) ------------------ | Branch (111:17): [True: 179k, False: 579k] ------------------ 112| 179k| jv_free(p->stack[i]); 113| 579k| p->stackpos = 0; 114| 579k| p->tokenpos = 0; 115| 579k| p->st = JV_PARSER_NORMAL; 116| 579k|} jv_parse.c:scan: 649| 150M|static pfunc scan(struct jv_parser* p, char ch, jv* out) { 650| 150M| p->column++; 651| 150M| if (ch == '\n') { ------------------ | Branch (651:7): [True: 3.39k, False: 150M] ------------------ 652| 3.39k| p->line++; 653| 3.39k| p->column = 0; 654| 3.39k| } 655| 150M| if ((p->flags & JV_PARSE_SEQ) ------------------ | Branch (655:7): [True: 0, False: 150M] ------------------ 656| 0| && ch == '\036' /* ASCII RS; see draft-ietf-json-sequence-07 */) { ------------------ | Branch (656:10): [True: 0, False: 0] ------------------ 657| 0| if (check_truncation(p)) { ------------------ | | 644| 0| (((p)->flags & JV_PARSE_STREAMING) ? stream_seq_check_truncation((p)) : seq_check_truncation((p))) | | ------------------ | | | Branch (644:4): [True: 0, False: 0] | | | Branch (644:5): [True: 0, False: 0] | | ------------------ ------------------ 658| 0| if (check_literal(p) == 0 && is_top_num(p)) ------------------ | | 647| 0| (((p)->flags & JV_PARSE_STREAMING) ? stream_is_top_num((p)) : parse_is_top_num((p))) | | ------------------ | | | Branch (647:4): [True: 0, False: 0] | | | Branch (647:5): [True: 0, False: 0] | | ------------------ ------------------ | Branch (658:11): [True: 0, False: 0] ------------------ 659| 0| return "Potentially truncated top-level numeric value"; 660| 0| return "Truncated value"; 661| 0| } 662| 0| TRY(check_literal(p)); ------------------ | | 18| 0|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 0] | | | Branch (18:74): [Folded, False: 0] | | ------------------ ------------------ 663| 0| if (p->st == JV_PARSER_NORMAL && check_done(p, out)) ------------------ | | 638| 0| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (638:4): [True: 0, False: 0] | | | Branch (638:5): [True: 0, False: 0] | | ------------------ ------------------ | Branch (663:9): [True: 0, False: 0] ------------------ 664| 0| return OK; 665| | // shouldn't happen? 666| 0| assert(!jv_is_valid(*out)); ------------------ | Branch (666:5): [True: 0, False: 0] | Branch (666:5): [True: 0, False: 0] ------------------ 667| 0| parser_reset(p); 668| 0| jv_free(*out); 669| 0| *out = jv_invalid(); 670| 0| return OK; 671| 0| } 672| 150M| presult answer = 0; 673| 150M| p->last_ch_was_ws = 0; 674| 150M| if (p->st == JV_PARSER_NORMAL) { ------------------ | Branch (674:7): [True: 58.2M, False: 91.7M] ------------------ 675| 58.2M| chclass cls = classify(ch); 676| 58.2M| if (cls == WHITESPACE) ------------------ | Branch (676:9): [True: 5.94k, False: 58.2M] ------------------ 677| 5.94k| p->last_ch_was_ws = 1; 678| 58.2M| if (cls != LITERAL) { ------------------ | Branch (678:9): [True: 8.99M, False: 49.2M] ------------------ 679| 8.99M| TRY(check_literal(p)); ------------------ | | 18| 8.99M|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 87, False: 8.99M] | | | Branch (18:74): [Folded, False: 8.99M] | | ------------------ ------------------ 680| 8.99M| if (check_done(p, out)) answer = OK; ------------------ | | 638| 8.99M| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (638:4): [True: 147, False: 8.99M] | | | Branch (638:5): [True: 0, False: 8.99M] | | ------------------ ------------------ 681| 8.99M| } 682| 58.2M| switch (cls) { ------------------ | Branch (682:13): [True: 58.2M, False: 0] ------------------ 683| 49.2M| case LITERAL: ------------------ | Branch (683:5): [True: 49.2M, False: 8.99M] ------------------ 684| 49.2M| TRY(tokenadd(p, ch)); ------------------ | | 18| 49.2M|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 49.2M] | | | Branch (18:74): [Folded, False: 49.2M] | | ------------------ ------------------ 685| 49.2M| break; 686| 49.2M| case WHITESPACE: ------------------ | Branch (686:5): [True: 5.93k, False: 58.2M] ------------------ 687| 5.93k| break; 688| 127k| case QUOTE: ------------------ | Branch (688:5): [True: 127k, False: 58.1M] ------------------ 689| 127k| p->st = JV_PARSER_STRING; 690| 127k| break; 691| 8.85M| case STRUCTURE: ------------------ | Branch (691:5): [True: 8.85M, False: 49.3M] ------------------ 692| 8.85M| TRY(token(p, ch)); ------------------ | | 18| 17.7M|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:37): [True: 0, False: 8.85M] | | | Branch (18:45): [True: 90, False: 8.85M] | | | Branch (18:74): [Folded, False: 8.85M] | | ------------------ ------------------ 693| 8.85M| break; 694| 8.85M| case INVALID: ------------------ | Branch (694:5): [True: 0, False: 58.2M] ------------------ 695| 0| return "Invalid character"; 696| 58.2M| } 697| 58.2M| if (check_done(p, out)) answer = OK; ------------------ | | 638| 58.2M| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (638:4): [True: 4.67k, False: 58.2M] | | | Branch (638:5): [True: 0, False: 58.2M] | | ------------------ ------------------ 698| 91.7M| } else { 699| 91.7M| if (ch == '"' && p->st == JV_PARSER_STRING) { ------------------ | Branch (699:9): [True: 128k, False: 91.6M] | Branch (699:22): [True: 127k, False: 846] ------------------ 700| 127k| TRY(found_string(p)); ------------------ | | 18| 127k|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 102, False: 127k] | | | Branch (18:74): [Folded, False: 127k] | | ------------------ ------------------ 701| 127k| p->st = JV_PARSER_NORMAL; 702| 127k| if (check_done(p, out)) answer = OK; ------------------ | | 638| 127k| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (638:4): [True: 1.84k, False: 125k] | | | Branch (638:5): [True: 0, False: 127k] | | ------------------ ------------------ 703| 91.6M| } else { 704| 91.6M| TRY(tokenadd(p, ch)); ------------------ | | 18| 91.6M|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 91.6M] | | | Branch (18:74): [Folded, False: 91.6M] | | ------------------ ------------------ 705| 91.6M| if (ch == '\\' && p->st == JV_PARSER_STRING) { ------------------ | Branch (705:11): [True: 3.71M, False: 87.9M] | Branch (705:25): [True: 3.70M, False: 5.38k] ------------------ 706| 3.70M| p->st = JV_PARSER_STRING_ESCAPE; 707| 87.9M| } else { 708| 87.9M| p->st = JV_PARSER_STRING; 709| 87.9M| } 710| 91.6M| } 711| 91.7M| } 712| 150M| return answer; 713| 150M|} jv_parse.c:parse_check_done: 588| 67.3M|static int parse_check_done(struct jv_parser* p, jv* out) { 589| 67.3M| if (p->stackpos == 0 && jv_is_valid(p->next)) { ------------------ | Branch (589:7): [True: 11.3M, False: 55.9M] | Branch (589:27): [True: 6.66k, False: 11.3M] ------------------ 590| 6.66k| *out = p->next; 591| 6.66k| p->next = jv_invalid(); 592| 6.66k| return 1; 593| 67.3M| } else { 594| 67.3M| return 0; 595| 67.3M| } 596| 67.3M|} jv_parse.c:classify: 564| 58.2M|static chclass classify(char c) { 565| 58.2M| switch (c) { 566| 712| case ' ': ------------------ | Branch (566:3): [True: 712, False: 58.2M] ------------------ 567| 2.12k| case '\t': ------------------ | Branch (567:3): [True: 1.40k, False: 58.2M] ------------------ 568| 2.55k| case '\r': ------------------ | Branch (568:3): [True: 432, False: 58.2M] ------------------ 569| 5.94k| case '\n': ------------------ | Branch (569:3): [True: 3.39k, False: 58.2M] ------------------ 570| 5.94k| return WHITESPACE; 571| 127k| case '"': ------------------ | Branch (571:3): [True: 127k, False: 58.1M] ------------------ 572| 127k| return QUOTE; 573| 615k| case '[': ------------------ | Branch (573:3): [True: 615k, False: 57.6M] ------------------ 574| 8.08M| case ',': ------------------ | Branch (574:3): [True: 7.46M, False: 50.7M] ------------------ 575| 8.56M| case ']': ------------------ | Branch (575:3): [True: 486k, False: 57.7M] ------------------ 576| 8.69M| case '{': ------------------ | Branch (576:3): [True: 129k, False: 58.1M] ------------------ 577| 8.77M| case ':': ------------------ | Branch (577:3): [True: 80.2k, False: 58.1M] ------------------ 578| 8.85M| case '}': ------------------ | Branch (578:3): [True: 81.7k, False: 58.1M] ------------------ 579| 8.85M| return STRUCTURE; 580| 49.2M| default: ------------------ | Branch (580:3): [True: 49.2M, False: 8.99M] ------------------ 581| 49.2M| return LITERAL; 582| 58.2M| } 583| 58.2M|} jv_parse.c:tokenadd: 423| 140M|static pfunc tokenadd(struct jv_parser* p, char c) { 424| 140M| assert(p->tokenpos <= p->tokenlen); ------------------ | Branch (424:3): [True: 0, False: 140M] | Branch (424:3): [True: 140M, False: 0] ------------------ 425| 140M| if (p->tokenpos >= (p->tokenlen - 1)) { ------------------ | Branch (425:7): [True: 5.64k, False: 140M] ------------------ 426| 5.64k| if (p->tokenlen > INT_MAX / 2) ------------------ | Branch (426:9): [True: 0, False: 5.64k] ------------------ 427| 0| return "Token too long"; 428| 5.64k| p->tokenlen *= 2; 429| 5.64k| p->tokenbuf = jv_mem_realloc(p->tokenbuf, p->tokenlen); 430| 5.64k| } 431| 140M| assert(p->tokenpos < p->tokenlen); ------------------ | Branch (431:3): [True: 0, False: 140M] | Branch (431:3): [True: 140M, False: 0] ------------------ 432| 140M| p->tokenbuf[p->tokenpos++] = c; 433| 140M| return 0; 434| 140M|} jv_parse.c:parse_token: 158| 8.85M|static pfunc parse_token(struct jv_parser* p, char ch) { 159| 8.85M| switch (ch) { ------------------ | Branch (159:11): [True: 8.85M, False: 0] ------------------ 160| 615k| case '[': ------------------ | Branch (160:3): [True: 615k, False: 8.24M] ------------------ 161| 615k| if (p->stackpos >= MAX_PARSING_DEPTH) return "Exceeds depth limit for parsing"; ------------------ | | 15| 615k|#define MAX_PARSING_DEPTH (10000) ------------------ | Branch (161:9): [True: 3, False: 615k] ------------------ 162| 615k| if (jv_is_valid(p->next)) return "Expected separator between values"; ------------------ | Branch (162:9): [True: 9, False: 615k] ------------------ 163| 615k| push(p, jv_array()); 164| 615k| break; 165| | 166| 129k| case '{': ------------------ | Branch (166:3): [True: 129k, False: 8.72M] ------------------ 167| 129k| if (p->stackpos >= MAX_PARSING_DEPTH) return "Exceeds depth limit for parsing"; ------------------ | | 15| 129k|#define MAX_PARSING_DEPTH (10000) ------------------ | Branch (167:9): [True: 1, False: 129k] ------------------ 168| 129k| if (jv_is_valid(p->next)) return "Expected separator between values"; ------------------ | Branch (168:9): [True: 2, False: 129k] ------------------ 169| 129k| push(p, jv_object()); 170| 129k| break; 171| | 172| 80.1k| case ':': ------------------ | Branch (172:3): [True: 80.1k, False: 8.77M] ------------------ 173| 80.1k| if (!jv_is_valid(p->next)) ------------------ | Branch (173:9): [True: 14, False: 80.1k] ------------------ 174| 14| return "Expected string key before ':'"; 175| 80.1k| if (p->stackpos == 0 || jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_OBJECT) ------------------ | Branch (175:9): [True: 0, False: 80.1k] | Branch (175:29): [True: 5, False: 80.1k] ------------------ 176| 5| return "':' not as part of an object"; 177| 80.1k| if (jv_get_kind(p->next) != JV_KIND_STRING) ------------------ | Branch (177:9): [True: 3, False: 80.1k] ------------------ 178| 3| return "Object keys must be strings"; 179| 80.1k| push(p, p->next); 180| 80.1k| p->next = jv_invalid(); 181| 80.1k| break; 182| | 183| 7.46M| case ',': ------------------ | Branch (183:3): [True: 7.46M, False: 1.39M] ------------------ 184| 7.46M| if (!jv_is_valid(p->next)) ------------------ | Branch (184:9): [True: 20, False: 7.46M] ------------------ 185| 20| return "Expected value before ','"; 186| 7.46M| if (p->stackpos == 0) ------------------ | Branch (186:9): [True: 0, False: 7.46M] ------------------ 187| 0| return "',' not as part of an object or array"; 188| 7.46M| if (jv_get_kind(p->stack[p->stackpos-1]) == JV_KIND_ARRAY) { ------------------ | Branch (188:9): [True: 7.39M, False: 67.4k] ------------------ 189| 7.39M| p->stack[p->stackpos-1] = jv_array_append(p->stack[p->stackpos-1], p->next); 190| 7.39M| p->next = jv_invalid(); 191| 7.39M| } else if (jv_get_kind(p->stack[p->stackpos-1]) == JV_KIND_STRING) { ------------------ | Branch (191:16): [True: 67.4k, False: 3] ------------------ 192| 67.4k| assert(p->stackpos > 1 && jv_get_kind(p->stack[p->stackpos-2]) == JV_KIND_OBJECT); ------------------ | Branch (192:7): [True: 0, False: 67.4k] | Branch (192:7): [True: 0, False: 0] | Branch (192:7): [True: 67.4k, False: 0] | Branch (192:7): [True: 67.4k, False: 0] ------------------ 193| 67.4k| p->stack[p->stackpos-2] = jv_object_set(p->stack[p->stackpos-2], 194| 67.4k| p->stack[p->stackpos-1], p->next); 195| 67.4k| p->stackpos--; 196| 67.4k| p->next = jv_invalid(); 197| 67.4k| } else { 198| | // this case hits on input like {"a", "b"} 199| 3| return "Objects must consist of key:value pairs"; 200| 3| } 201| 7.46M| break; 202| | 203| 7.46M| case ']': ------------------ | Branch (203:3): [True: 486k, False: 8.37M] ------------------ 204| 486k| if (p->stackpos == 0 || jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_ARRAY) ------------------ | Branch (204:9): [True: 11, False: 486k] | Branch (204:29): [True: 2, False: 486k] ------------------ 205| 13| return "Unmatched ']'"; 206| 486k| if (jv_is_valid(p->next)) { ------------------ | Branch (206:9): [True: 483k, False: 3.10k] ------------------ 207| 483k| p->stack[p->stackpos-1] = jv_array_append(p->stack[p->stackpos-1], p->next); 208| 483k| p->next = jv_invalid(); 209| 483k| } else { 210| 3.10k| if (jv_array_length(jv_copy(p->stack[p->stackpos-1])) != 0) { ------------------ | Branch (210:11): [True: 1, False: 3.10k] ------------------ 211| | // this case hits on input like [1,2,3,] 212| 1| return "Expected another array element"; 213| 1| } 214| 3.10k| } 215| 486k| jv_free(p->next); 216| 486k| p->next = p->stack[--p->stackpos]; 217| 486k| break; 218| | 219| 81.7k| case '}': ------------------ | Branch (219:3): [True: 81.7k, False: 8.77M] ------------------ 220| 81.7k| if (p->stackpos == 0) ------------------ | Branch (220:9): [True: 5, False: 81.7k] ------------------ 221| 5| return "Unmatched '}'"; 222| 81.7k| if (jv_is_valid(p->next)) { ------------------ | Branch (222:9): [True: 10.4k, False: 71.3k] ------------------ 223| 10.4k| if (jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_STRING) ------------------ | Branch (223:11): [True: 8, False: 10.4k] ------------------ 224| 8| return "Objects must consist of key:value pairs"; 225| 10.4k| assert(p->stackpos > 1 && jv_get_kind(p->stack[p->stackpos-2]) == JV_KIND_OBJECT); ------------------ | Branch (225:7): [True: 0, False: 10.4k] | Branch (225:7): [True: 0, False: 0] | Branch (225:7): [True: 10.4k, False: 0] | Branch (225:7): [True: 10.4k, False: 0] ------------------ 226| 10.4k| p->stack[p->stackpos-2] = jv_object_set(p->stack[p->stackpos-2], 227| 10.4k| p->stack[p->stackpos-1], p->next); 228| 10.4k| p->stackpos--; 229| 10.4k| p->next = jv_invalid(); 230| 71.3k| } else { 231| 71.3k| if (jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_OBJECT) ------------------ | Branch (231:11): [True: 2, False: 71.3k] ------------------ 232| 2| return "Unmatched '}'"; 233| 71.3k| if (jv_object_length(jv_copy(p->stack[p->stackpos-1])) != 0) ------------------ | Branch (233:11): [True: 1, False: 71.3k] ------------------ 234| 1| return "Expected another key-value pair"; 235| 71.3k| } 236| 81.7k| jv_free(p->next); 237| 81.7k| p->next = p->stack[--p->stackpos]; 238| 81.7k| break; 239| 8.85M| } 240| 8.85M| return 0; 241| 8.85M|} jv_parse.c:push: 148| 825k|static void push(struct jv_parser* p, jv v) { 149| 825k| assert(p->stackpos <= p->stacklen); ------------------ | Branch (149:3): [True: 0, False: 825k] | Branch (149:3): [True: 825k, False: 0] ------------------ 150| 825k| if (p->stackpos == p->stacklen) { ------------------ | Branch (150:7): [True: 5.78k, False: 820k] ------------------ 151| 5.78k| p->stacklen = p->stacklen * 2 + 10; 152| 5.78k| p->stack = jv_mem_realloc(p->stack, p->stacklen * sizeof(jv)); 153| 5.78k| } 154| 825k| assert(p->stackpos < p->stacklen); ------------------ | Branch (154:3): [True: 0, False: 825k] | Branch (154:3): [True: 825k, False: 0] ------------------ 155| 825k| p->stack[p->stackpos++] = v; 156| 825k|} jv_parse.c:found_string: 451| 127k|static pfunc found_string(struct jv_parser* p) { 452| 127k| char* in = p->tokenbuf; 453| 127k| char* out = p->tokenbuf; 454| 127k| char* end = p->tokenbuf + p->tokenpos; 455| | 456| 69.2M| while (in < end) { ------------------ | Branch (456:10): [True: 69.1M, False: 127k] ------------------ 457| 69.1M| char c = *in++; 458| 69.1M| if (c == '\\') { ------------------ | Branch (458:9): [True: 3.70M, False: 65.4M] ------------------ 459| 3.70M| if (in >= end) ------------------ | Branch (459:11): [True: 0, False: 3.70M] ------------------ 460| 0| return "Expected escape character at end of string"; 461| 3.70M| c = *in++; 462| 3.70M| switch (c) { 463| 5.31k| case '\\': ------------------ | Branch (463:7): [True: 5.31k, False: 3.70M] ------------------ 464| 6.14k| case '"': ------------------ | Branch (464:7): [True: 827, False: 3.70M] ------------------ 465| 6.34k| case '/': *out++ = c; break; ------------------ | Branch (465:7): [True: 196, False: 3.70M] ------------------ 466| 1.31k| case 'b': *out++ = '\b'; break; ------------------ | Branch (466:7): [True: 1.31k, False: 3.70M] ------------------ 467| 859| case 'f': *out++ = '\f'; break; ------------------ | Branch (467:7): [True: 859, False: 3.70M] ------------------ 468| 698| case 't': *out++ = '\t'; break; ------------------ | Branch (468:7): [True: 698, False: 3.70M] ------------------ 469| 1.05k| case 'n': *out++ = '\n'; break; ------------------ | Branch (469:7): [True: 1.05k, False: 3.70M] ------------------ 470| 597| case 'r': *out++ = '\r'; break; ------------------ | Branch (470:7): [True: 597, False: 3.70M] ------------------ 471| | 472| 3.69M| case 'u': ------------------ | Branch (472:7): [True: 3.69M, False: 10.8k] ------------------ 473| | /* ahh, the complicated case */ 474| 3.69M| if (in + 4 > end) ------------------ | Branch (474:13): [True: 1, False: 3.69M] ------------------ 475| 1| return "Invalid \\uXXXX escape"; 476| 3.69M| int hexvalue = unhex4(in); 477| 3.69M| if (hexvalue < 0) ------------------ | Branch (477:13): [True: 22, False: 3.69M] ------------------ 478| 22| return "Invalid characters in \\uXXXX escape"; 479| 3.69M| unsigned long codepoint = (unsigned long)hexvalue; 480| 3.69M| in += 4; 481| 3.69M| if (0xD800 <= codepoint && codepoint <= 0xDBFF) { ------------------ | Branch (481:13): [True: 829, False: 3.69M] | Branch (481:36): [True: 421, False: 408] ------------------ 482| | /* who thought UTF-16 surrogate pairs were a good idea? */ 483| 421| if (in + 6 > end || in[0] != '\\' || in[1] != 'u') ------------------ | Branch (483:15): [True: 11, False: 410] | Branch (483:31): [True: 5, False: 405] | Branch (483:48): [True: 6, False: 399] ------------------ 484| 22| return "Invalid \\uXXXX\\uXXXX surrogate pair escape"; 485| 399| unsigned long surrogate = unhex4(in+2); 486| 399| if (!(0xDC00 <= surrogate && surrogate <= 0xDFFF)) ------------------ | Branch (486:17): [True: 387, False: 12] | Branch (486:40): [True: 373, False: 14] ------------------ 487| 26| return "Invalid \\uXXXX\\uXXXX surrogate pair escape"; 488| 373| in += 6; 489| 373| codepoint = 0x10000 + (((codepoint - 0xD800) << 10) 490| 373| |(surrogate - 0xDC00)); 491| 373| } 492| 3.69M| if (codepoint > 0x10FFFF) ------------------ | Branch (492:13): [True: 0, False: 3.69M] ------------------ 493| 0| codepoint = 0xFFFD; // U+FFFD REPLACEMENT CHARACTER 494| 3.69M| out += jvp_utf8_encode(codepoint, out); 495| 3.69M| break; 496| | 497| 8| default: ------------------ | Branch (497:7): [True: 8, False: 3.70M] ------------------ 498| 8| return "Invalid escape"; 499| 3.70M| } 500| 65.4M| } else { 501| 65.4M| if (!(c & ~0x1F)) ------------------ | Branch (501:11): [True: 16, False: 65.4M] ------------------ 502| 16| return "Invalid string: control characters from U+0000 through U+001F must be escaped"; 503| 65.4M| *out++ = c; 504| 65.4M| } 505| 69.1M| } 506| 127k| TRY(value(p, jv_string_sized(p->tokenbuf, out - p->tokenbuf))); ------------------ | | 18| 127k|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 7, False: 127k] | | | Branch (18:74): [Folded, False: 127k] | | ------------------ ------------------ 507| 127k| p->tokenpos = 0; 508| 127k| return 0; 509| 127k|} jv_parse.c:unhex4: 436| 3.69M|static int unhex4(char* hex) { 437| 3.69M| int r = 0; 438| 18.4M| for (int i=0; i<4; i++) { ------------------ | Branch (438:17): [True: 14.7M, False: 3.69M] ------------------ 439| 14.7M| char c = *hex++; 440| 14.7M| int n; 441| 14.7M| if ('0' <= c && c <= '9') n = c - '0'; ------------------ | Branch (441:9): [True: 14.7M, False: 13] | Branch (441:21): [True: 11.0M, False: 3.69M] ------------------ 442| 3.69M| else if ('a' <= c && c <= 'f') n = c - 'a' + 10; ------------------ | Branch (442:14): [True: 3.69M, False: 1.38k] | Branch (442:26): [True: 3.69M, False: 8] ------------------ 443| 1.39k| else if ('A' <= c && c <= 'F') n = c - 'A' + 10; ------------------ | Branch (443:14): [True: 1.37k, False: 19] | Branch (443:26): [True: 1.35k, False: 16] ------------------ 444| 35| else return -1; 445| 14.7M| r <<= 4; 446| 14.7M| r |= n; 447| 14.7M| } 448| 3.69M| return r; 449| 3.69M|} jv_parse.c:value: 127| 8.04M|static pfunc value(struct jv_parser* p, jv val) { 128| 8.04M| if ((p->flags & JV_PARSE_STREAMING)) { ------------------ | Branch (128:7): [True: 0, False: 8.04M] ------------------ 129| 0| if (jv_is_valid(p->next) || p->last_seen == JV_LAST_VALUE) { ------------------ | Branch (129:9): [True: 0, False: 0] | Branch (129:33): [True: 0, False: 0] ------------------ 130| 0| jv_free(val); 131| 0| return "Expected separator between values"; 132| 0| } 133| 0| if (p->stacklen > 0) ------------------ | Branch (133:9): [True: 0, False: 0] ------------------ 134| 0| p->last_seen = JV_LAST_VALUE; 135| 0| else 136| 0| p->last_seen = JV_LAST_NONE; 137| 8.04M| } else { 138| 8.04M| if (jv_is_valid(p->next)) { ------------------ | Branch (138:9): [True: 14, False: 8.04M] ------------------ 139| 14| jv_free(val); 140| 14| return "Expected separator between values"; 141| 14| } 142| 8.04M| } 143| 8.04M| jv_free(p->next); 144| 8.04M| p->next = val; 145| 8.04M| return 0; 146| 8.04M|} jv_parse.c:make_error: 762| 943|static jv make_error(struct jv_parser* p, const char *fmt, ...) { 763| 943| va_list ap; 764| 943| va_start(ap, fmt); 765| 943| jv e = jv_string_vfmt(fmt, ap); 766| 943| va_end(ap); 767| 943| if ((p->flags & JV_PARSE_STREAM_ERRORS)) ------------------ | Branch (767:7): [True: 0, False: 943] ------------------ 768| 0| return JV_ARRAY(e, jv_copy(p->path)); ------------------ | | 111| 0| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | ------------------ | | | | 109| 0|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 111| 0| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 101| 0|#define JV_ARRAY_2(e1,e2) (jv_array_append(JV_ARRAY_1(e1),e2)) | | | | | | | | ------------------ | | | | | | | | | | 100| 0|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 769| 943| return jv_invalid_with_msg(e); 770| 943|} jv_parse.c:check_literal: 511| 9.57M|static pfunc check_literal(struct jv_parser* p) { 512| 9.57M| if (p->tokenpos == 0) return 0; ------------------ | Branch (512:7): [True: 1.65M, False: 7.92M] ------------------ 513| | 514| 7.92M| const char* pattern = 0; 515| 7.92M| int plen; 516| 7.92M| jv v; 517| 7.92M| switch (p->tokenbuf[0]) { ------------------ | Branch (517:11): [True: 88.4k, False: 7.83M] ------------------ 518| 188| case 't': pattern = "true"; plen = 4; v = jv_true(); break; ------------------ | Branch (518:3): [True: 188, False: 7.92M] ------------------ 519| 83.9k| case 'f': pattern = "false"; plen = 5; v = jv_false(); break; ------------------ | Branch (519:3): [True: 83.9k, False: 7.83M] ------------------ 520| 1| case '\'': ------------------ | Branch (520:3): [True: 1, False: 7.92M] ------------------ 521| 1| return "Invalid string literal; expected \", but got '"; 522| 4.29k| case 'n': ------------------ | Branch (522:3): [True: 4.29k, False: 7.91M] ------------------ 523| | // if it starts with 'n', it could be a literal "nan" 524| 4.29k| if (p->tokenpos > 1 && p->tokenbuf[1] == 'u') { ------------------ | Branch (524:9): [True: 4.29k, False: 2] | Branch (524:28): [True: 1.94k, False: 2.34k] ------------------ 525| 1.94k| pattern = "null"; plen = 4; v = jv_null(); 526| 1.94k| } 527| 7.92M| } 528| 7.92M| if (pattern) { ------------------ | Branch (528:7): [True: 86.0k, False: 7.83M] ------------------ 529| 86.0k| if (p->tokenpos != plen) return "Invalid literal"; ------------------ | Branch (529:9): [True: 60, False: 86.0k] ------------------ 530| 513k| for (int i=0; itokenbuf[i] != pattern[i]) ------------------ | Branch (531:11): [True: 9, False: 427k] ------------------ 532| 9| return "Invalid literal"; 533| 86.0k| TRY(value(p, v)); ------------------ | | 18| 86.0k|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 1, False: 86.0k] | | | Branch (18:74): [Folded, False: 86.0k] | | ------------------ ------------------ 534| 7.83M| } else { 535| | // FIXME: better parser 536| 7.83M| p->tokenbuf[p->tokenpos] = 0; 537| 7.83M|#ifdef USE_DECNUM 538| 7.83M| jv number = jv_number_with_literal(p->tokenbuf); 539| 7.83M| if (jv_get_kind(number) == JV_KIND_INVALID) { ------------------ | Branch (539:9): [True: 424, False: 7.83M] ------------------ 540| 424| return "Invalid numeric literal"; 541| 424| } 542| 7.83M| TRY(value(p, number)); ------------------ | | 18| 7.83M|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 6, False: 7.83M] | | | Branch (18:74): [Folded, False: 7.83M] | | ------------------ ------------------ 543| |#else 544| | char *end = 0; 545| | double d = jvp_strtod(&p->dtoa, p->tokenbuf, &end); 546| | if (end == 0 || *end != 0) { 547| | return "Invalid numeric literal"; 548| | } 549| | TRY(value(p, jv_number(d))); 550| |#endif 551| 7.83M| } 552| 7.91M| p->tokenpos = 0; 553| 7.91M| return 0; 554| 7.92M|} jv_dump_string: 405| 580k|jv jv_dump_string(jv x, int flags) { 406| 580k| jv s = jv_string(""); 407| 580k| jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, 0, &s); 408| 580k| return s; 409| 580k|} jv_dump_string_trunc: 411| 22.6k|char *jv_dump_string_trunc(jv x, char *outbuf, size_t bufsize) { 412| 22.6k| assert(bufsize > 0); ------------------ | Branch (412:3): [True: 0, False: 22.6k] | Branch (412:3): [True: 22.6k, False: 0] ------------------ 413| 22.6k| if (jv_get_kind(x) == JV_KIND_STRING && ------------------ | Branch (413:7): [True: 16.6k, False: 6.06k] ------------------ 414| 16.6k| (size_t)jv_string_length_bytes(jv_copy(x)) > bufsize) { ------------------ | Branch (414:7): [True: 2.63k, False: 13.9k] ------------------ 415| 2.63k| x = jv_string_slice(x, 0, bufsize); 416| 2.63k| } 417| 22.6k| x = jv_dump_string(x, 0); 418| 22.6k| const char *str = jv_string_value(x); 419| 22.6k| const size_t len = strlen(str); 420| 22.6k| if (len > bufsize - 1 && bufsize >= 8) { ------------------ | Branch (420:7): [True: 4.74k, False: 17.9k] | Branch (420:28): [True: 4.74k, False: 0] ------------------ 421| 4.74k| char delim = 0; 422| 4.74k| switch (str[0]) { ------------------ | Branch (422:13): [True: 4.51k, False: 231] ------------------ 423| 3.86k| case '"': delim = '"'; break; ------------------ | Branch (423:5): [True: 3.86k, False: 884] ------------------ 424| 377| case '[': delim = ']'; break; ------------------ | Branch (424:5): [True: 377, False: 4.36k] ------------------ 425| 276| case '{': delim = '}'; break; ------------------ | Branch (425:5): [True: 276, False: 4.47k] ------------------ 426| 4.74k| } 427| 4.74k| size_t l = bufsize - (delim ? 5 : 4); // "...", delim (if any), '\0' ------------------ | Branch (427:27): [True: 4.51k, False: 231] ------------------ 428| 4.74k| const char *s = jvp_utf8_backtrack(str + l, str, NULL); 429| 4.74k| if (s) l = s - str; ------------------ | Branch (429:9): [True: 4.74k, False: 0] ------------------ 430| 4.74k| memcpy(outbuf, str, l); 431| 4.74k| outbuf[l++] = '.'; 432| 4.74k| outbuf[l++] = '.'; 433| 4.74k| outbuf[l++] = '.'; 434| 4.74k| if (delim) outbuf[l++] = delim; ------------------ | Branch (434:9): [True: 4.51k, False: 231] ------------------ 435| 4.74k| outbuf[l] = '\0'; 436| 17.9k| } else { 437| 17.9k| size_t l = MIN(len, bufsize - 1); ------------------ | | 49| 17.9k| ({ __typeof__ (a) _a = (a); \ | | 50| 17.9k| __typeof__ (b) _b = (b); \ | | 51| 17.9k| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (51:4): [True: 17.7k, False: 184] | | ------------------ ------------------ 438| 17.9k| memcpy(outbuf, str, l); 439| 17.9k| outbuf[l] = '\0'; 440| 17.9k| } 441| 22.6k| jv_free(x); 442| 22.6k| return outbuf; 443| 22.6k|} jv_print.c:jv_dump_term: 219| 1.51M|static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FILE* F, jv* S) { 220| 1.51M| char buf[JVP_DTOA_FMT_MAX_LEN]; 221| 1.51M| const char* color = 0; 222| 1.51M| double refcnt = (flags & JV_PRINT_REFCOUNT) ? jv_get_refcnt(x) - 1 : -1; ------------------ | Branch (222:19): [True: 0, False: 1.51M] ------------------ 223| 1.51M| if ((flags & JV_PRINT_COLOR) && jv_get_kind(x) != JV_KIND_INVALID) { ------------------ | Branch (223:7): [True: 0, False: 1.51M] | Branch (223:35): [True: 0, False: 0] ------------------ 224| 0| color = colors[(int)jv_get_kind(x) - 1]; 225| 0| put_str(color, F, S, flags & JV_PRINT_ISATTY); 226| 0| } 227| 1.51M| if (indent > MAX_PRINT_DEPTH) { ------------------ | | 21| 1.51M|#define MAX_PRINT_DEPTH (10000) ------------------ | Branch (227:7): [True: 0, False: 1.51M] ------------------ 228| 0| put_str("", F, S, flags & JV_PRINT_ISATTY); 229| 1.51M| } else switch (jv_get_kind(x)) { 230| 0| default: ------------------ | Branch (230:3): [True: 0, False: 1.51M] ------------------ 231| 0| case JV_KIND_INVALID: ------------------ | Branch (231:3): [True: 0, False: 1.51M] ------------------ 232| 0| if (flags & JV_PRINT_INVALID) { ------------------ | Branch (232:9): [True: 0, False: 0] ------------------ 233| 0| jv msg = jv_invalid_get_msg(jv_copy(x)); 234| 0| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (234:11): [True: 0, False: 0] ------------------ 235| 0| put_str("', F, S, flags & JV_PRINT_ISATTY); 238| 0| } else { 239| 0| put_str("", F, S, flags & JV_PRINT_ISATTY); 240| 0| } 241| 0| } else { 242| 0| assert(0 && "Invalid value"); ------------------ | Branch (242:7): [Folded, False: 0] | Branch (242:7): [True: 0, False: 0] | Branch (242:7): [Folded, False: 0] | Branch (242:7): [True: 0, False: 0] ------------------ 243| 0| } 244| 0| break; 245| 521| case JV_KIND_NULL: ------------------ | Branch (245:3): [True: 521, False: 1.51M] ------------------ 246| 521| put_str("null", F, S, flags & JV_PRINT_ISATTY); 247| 521| break; 248| 3.25k| case JV_KIND_FALSE: ------------------ | Branch (248:3): [True: 3.25k, False: 1.50M] ------------------ 249| 3.25k| put_str("false", F, S, flags & JV_PRINT_ISATTY); 250| 3.25k| break; 251| 274| case JV_KIND_TRUE: ------------------ | Branch (251:3): [True: 274, False: 1.51M] ------------------ 252| 274| put_str("true", F, S, flags & JV_PRINT_ISATTY); 253| 274| break; 254| 1.45M| case JV_KIND_NUMBER: { ------------------ | Branch (254:3): [True: 1.45M, False: 55.5k] ------------------ 255| 1.45M| if (jvp_number_is_nan(x)) { ------------------ | Branch (255:9): [True: 234, False: 1.45M] ------------------ 256| 234| jv_dump_term(C, jv_null(), flags, indent, F, S); 257| 1.45M| } else { 258| 1.45M|#ifdef USE_DECNUM 259| 1.45M| const char * literal_data = jv_number_get_literal(x); 260| 1.45M| if (literal_data) { ------------------ | Branch (260:11): [True: 1.45M, False: 3.47k] ------------------ 261| 1.45M| put_str(literal_data, F, S, flags & JV_PRINT_ISATTY); 262| 1.45M| } else { 263| 3.47k|#endif 264| 3.47k| double d = jv_number_value(x); 265| 3.47k| if (d != d) { ------------------ | Branch (265:13): [True: 0, False: 3.47k] ------------------ 266| | // JSON doesn't have NaN, so we'll render it as "null" 267| 0| put_str("null", F, S, flags & JV_PRINT_ISATTY); 268| 3.47k| } else { 269| | // Normalise infinities to something we can print in valid JSON 270| 3.47k| if (d > DBL_MAX) d = DBL_MAX; ------------------ | Branch (270:15): [True: 1.56k, False: 1.90k] ------------------ 271| 3.47k| if (d < -DBL_MAX) d = -DBL_MAX; ------------------ | Branch (271:15): [True: 307, False: 3.16k] ------------------ 272| 3.47k| put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY); 273| 3.47k| } 274| 3.47k| } 275| 1.45M|#ifdef USE_DECNUM 276| 1.45M| } 277| 1.45M|#endif 278| 1.45M| break; 279| 0| } 280| 17.8k| case JV_KIND_STRING: ------------------ | Branch (280:3): [True: 17.8k, False: 1.49M] ------------------ 281| 17.8k| jvp_dump_string(x, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY); 282| 17.8k| if (flags & JV_PRINT_REFCOUNT) ------------------ | Branch (282:9): [True: 0, False: 17.8k] ------------------ 283| 0| put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY); 284| 17.8k| break; 285| 21.7k| case JV_KIND_ARRAY: { ------------------ | Branch (285:3): [True: 21.7k, False: 1.48M] ------------------ 286| 21.7k| if (jv_array_length(jv_copy(x)) == 0) { ------------------ | Branch (286:9): [True: 900, False: 20.8k] ------------------ 287| 900| put_str("[]", F, S, flags & JV_PRINT_ISATTY); 288| 900| break; 289| 900| } 290| 20.8k| put_char('[', F, S, flags & JV_PRINT_ISATTY); 291| 926k| jv_array_foreach(x, i, elem) { ------------------ | | 93| 20.8k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 41.6k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 20.8k, False: 20.8k] | | ------------------ | | 95| 20.8k| for (jv x; \ | | 96| 947k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 926k, False: 20.8k] | | | Branch (96:10): [True: 926k, False: 20.8k] | | ------------------ | | 97| 947k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 926k| i++) ------------------ 292| 926k| if (i!=0) { ------------------ | Branch (292:11): [True: 906k, False: 20.8k] ------------------ 293| 906k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (293:13): [True: 0, False: 906k] ------------------ 294| 906k| put_char(',', F, S, flags & JV_PRINT_ISATTY); 295| 906k| } 296| 926k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 26| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 24| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (296:11): [True: 0, False: 926k] ------------------ 297| 926k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (297:11): [True: 0, False: 926k] ------------------ 298| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 299| 0| put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY); 300| 0| } 301| 926k| jv_dump_term(C, elem, flags, indent + 1, F, S); 302| 926k| } 303| 20.8k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (303:9): [True: 0, False: 20.8k] ------------------ 304| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 305| 0| put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY); 306| 0| } 307| 20.8k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (307:9): [True: 0, False: 20.8k] ------------------ 308| 20.8k| put_char(']', F, S, flags & JV_PRINT_ISATTY); 309| 20.8k| if (flags & JV_PRINT_REFCOUNT) ------------------ | Branch (309:9): [True: 0, False: 20.8k] ------------------ 310| 0| put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY); 311| 20.8k| break; 312| 21.7k| } 313| 11.9k| case JV_KIND_OBJECT: { ------------------ | Branch (313:3): [True: 11.9k, False: 1.49M] ------------------ 314| 11.9k| if (jv_object_length(jv_copy(x)) == 0) { ------------------ | Branch (314:9): [True: 10.8k, False: 1.02k] ------------------ 315| 10.8k| put_str("{}", F, S, flags & JV_PRINT_ISATTY); 316| 10.8k| break; 317| 10.8k| } 318| 1.02k| put_char('{', F, S, flags & JV_PRINT_ISATTY); 319| 1.02k| int first = 1; 320| 1.02k| int i = 0; 321| 1.02k| jv keyset = jv_null(); 322| 3.83k| while (1) { ------------------ | Branch (322:12): [True: 3.83k, Folded] ------------------ 323| 3.83k| jv key, value; 324| 3.83k| if (flags & JV_PRINT_SORTED) { ------------------ | Branch (324:11): [True: 0, False: 3.83k] ------------------ 325| 0| if (first) { ------------------ | Branch (325:13): [True: 0, False: 0] ------------------ 326| 0| keyset = jv_keys(jv_copy(x)); 327| 0| i = 0; 328| 0| } else { 329| 0| i++; 330| 0| } 331| 0| if (i >= jv_array_length(jv_copy(keyset))) { ------------------ | Branch (331:13): [True: 0, False: 0] ------------------ 332| 0| jv_free(keyset); 333| 0| break; 334| 0| } 335| 0| key = jv_array_get(jv_copy(keyset), i); 336| 0| value = jv_object_get(jv_copy(x), jv_copy(key)); 337| 3.83k| } else { 338| 3.83k| if (first) { ------------------ | Branch (338:13): [True: 1.02k, False: 2.80k] ------------------ 339| 1.02k| i = jv_object_iter(x); 340| 2.80k| } else { 341| 2.80k| i = jv_object_iter_next(x, i); 342| 2.80k| } 343| 3.83k| if (!jv_object_iter_valid(x, i)) break; ------------------ | Branch (343:13): [True: 1.02k, False: 2.80k] ------------------ 344| 2.80k| key = jv_object_iter_key(x, i); 345| 2.80k| value = jv_object_iter_value(x, i); 346| 2.80k| } 347| | 348| 2.80k| if (!first) { ------------------ | Branch (348:11): [True: 1.77k, False: 1.02k] ------------------ 349| 1.77k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (349:13): [True: 0, False: 1.77k] ------------------ 350| 1.77k| put_char(',', F, S, flags & JV_PRINT_ISATTY); 351| 1.77k| } 352| 2.80k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 26| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 24| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (352:11): [True: 0, False: 2.80k] ------------------ 353| 2.80k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (353:11): [True: 0, False: 2.80k] ------------------ 354| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 355| 0| put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY); 356| 0| } 357| | 358| 2.80k| first = 0; 359| 2.80k| if (color) put_str(FIELD_COLOR, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 37| 0|#define FIELD_COLOR (colors[7]) ------------------ | Branch (359:11): [True: 0, False: 2.80k] ------------------ 360| 2.80k| jvp_dump_string(key, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY); 361| 2.80k| jv_free(key); 362| 2.80k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 26| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 24| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (362:11): [True: 0, False: 2.80k] ------------------ 363| | 364| 2.80k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (364:11): [True: 0, False: 2.80k] ------------------ 365| 2.80k| put_char(':', F, S, flags & JV_PRINT_ISATTY); 366| 2.80k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 26| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 24| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (366:11): [True: 0, False: 2.80k] ------------------ 367| 2.80k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (367:11): [True: 0, False: 2.80k] ------------------ 368| 0| put_char(' ', F, S, flags & JV_PRINT_ISATTY); 369| 0| } 370| | 371| 2.80k| jv_dump_term(C, value, flags, indent + 1, F, S); 372| 2.80k| } 373| 1.02k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (373:9): [True: 0, False: 1.02k] ------------------ 374| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 375| 0| put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY); 376| 0| } 377| 1.02k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (377:9): [True: 0, False: 1.02k] ------------------ 378| 1.02k| put_char('}', F, S, flags & JV_PRINT_ISATTY); 379| 1.02k| if (flags & JV_PRINT_REFCOUNT) ------------------ | Branch (379:9): [True: 0, False: 1.02k] ------------------ 380| 0| put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY); 381| 1.02k| } 382| 1.51M| } 383| 1.51M| jv_free(x); 384| 1.51M| if (color) { ------------------ | Branch (384:7): [True: 0, False: 1.51M] ------------------ 385| 0| put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 26| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 24| 0|#define ESC "\033" | | ------------------ ------------------ 386| 0| } 387| 1.51M|} jv_print.c:put_str: 129| 9.96M|static void put_str(const char* s, FILE* fout, jv* strout, int T) { 130| 9.96M| put_buf(s, strlen(s), fout, strout, T); 131| 9.96M|} jv_print.c:put_buf: 98| 12.2M|static void put_buf(const char *s, int len, FILE *fout, jv *strout, int is_tty) { 99| 12.2M| if (strout) { ------------------ | Branch (99:7): [True: 12.2M, False: 0] ------------------ 100| 12.2M| *strout = jv_string_append_buf(*strout, s, len); 101| 12.2M| } else { 102| |#ifdef WIN32 103| | /* See util.h */ 104| | if (is_tty) { 105| | wchar_t *ws; 106| | size_t wl; 107| | if (len == -1) 108| | len = strlen(s); 109| | wl = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0); 110| | ws = jv_mem_calloc(wl + 1, sizeof(*ws)); 111| | if (!ws) 112| | return; 113| | wl = MultiByteToWideChar(CP_UTF8, 0, s, len, ws, wl + 1); 114| | ws[wl] = 0; 115| | WriteConsoleW((HANDLE)_get_osfhandle(fileno(fout)), ws, wl, NULL, NULL); 116| | free(ws); 117| | } else 118| | fwrite(s, 1, len, fout); 119| |#else 120| 0| fwrite(s, 1, len, fout); 121| 0|#endif 122| 0| } 123| 12.2M|} jv_print.c:jvp_dump_string: 144| 20.7k|static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S, int T) { 145| 20.7k| assert(jv_get_kind(str) == JV_KIND_STRING); ------------------ | Branch (145:3): [True: 0, False: 20.7k] | Branch (145:3): [True: 20.7k, False: 0] ------------------ 146| 20.7k| const char* i = jv_string_value(str); 147| 20.7k| const char* end = i + jv_string_length_bytes(jv_copy(str)); 148| 20.7k| const char* cstart; 149| 20.7k| int c = 0; 150| 20.7k| char buf[32]; 151| 20.7k| put_char('"', F, S, T); 152| 9.84M| while ((i = jvp_utf8_next((cstart = i), end, &c))) { ------------------ | Branch (152:10): [True: 9.82M, False: 20.7k] ------------------ 153| 9.82M| assert(c != -1); ------------------ | Branch (153:5): [True: 0, False: 9.82M] | Branch (153:5): [True: 9.82M, False: 0] ------------------ 154| 9.82M| int unicode_escape = 0; 155| 9.82M| if (0x20 <= c && c <= 0x7E) { ------------------ | Branch (155:9): [True: 9.81M, False: 7.96k] | Branch (155:22): [True: 389k, False: 9.42M] ------------------ 156| | // printable ASCII 157| 389k| if (c == '"' || c == '\\') { ------------------ | Branch (157:11): [True: 329, False: 388k] | Branch (157:23): [True: 448, False: 388k] ------------------ 158| 777| put_char('\\', F, S, T); 159| 777| } 160| 389k| put_char(c, F, S, T); 161| 9.43M| } else if (c < 0x20 || c == 0x7F) { ------------------ | Branch (161:16): [True: 7.96k, False: 9.42M] | Branch (161:28): [True: 8.48M, False: 941k] ------------------ 162| | // ASCII control character 163| 8.49M| switch (c) { 164| 675| case '\b': ------------------ | Branch (164:7): [True: 675, False: 8.49M] ------------------ 165| 675| put_char('\\', F, S, T); 166| 675| put_char('b', F, S, T); 167| 675| break; 168| 629| case '\t': ------------------ | Branch (168:7): [True: 629, False: 8.49M] ------------------ 169| 629| put_char('\\', F, S, T); 170| 629| put_char('t', F, S, T); 171| 629| break; 172| 288| case '\r': ------------------ | Branch (172:7): [True: 288, False: 8.49M] ------------------ 173| 288| put_char('\\', F, S, T); 174| 288| put_char('r', F, S, T); 175| 288| break; 176| 238| case '\n': ------------------ | Branch (176:7): [True: 238, False: 8.49M] ------------------ 177| 238| put_char('\\', F, S, T); 178| 238| put_char('n', F, S, T); 179| 238| break; 180| 368| case '\f': ------------------ | Branch (180:7): [True: 368, False: 8.49M] ------------------ 181| 368| put_char('\\', F, S, T); 182| 368| put_char('f', F, S, T); 183| 368| break; 184| 8.49M| default: ------------------ | Branch (184:7): [True: 8.49M, False: 2.19k] ------------------ 185| 8.49M| unicode_escape = 1; 186| 8.49M| break; 187| 8.49M| } 188| 8.49M| } else { 189| 941k| if (ascii_only) { ------------------ | Branch (189:11): [True: 0, False: 941k] ------------------ 190| 0| unicode_escape = 1; 191| 941k| } else { 192| 941k| put_buf(cstart, i - cstart, F, S, T); 193| 941k| } 194| 941k| } 195| 9.82M| if (unicode_escape) { ------------------ | Branch (195:9): [True: 8.49M, False: 1.33M] ------------------ 196| 8.49M| if (c <= 0xffff) { ------------------ | Branch (196:11): [True: 8.49M, False: 0] ------------------ 197| 8.49M| snprintf(buf, sizeof(buf), "\\u%04x", c); 198| 8.49M| } else { 199| 0| c -= 0x10000; 200| 0| snprintf(buf, sizeof(buf), "\\u%04x\\u%04x", 201| 0| 0xD800 | ((c & 0xffc00) >> 10), 202| 0| 0xDC00 | (c & 0x003ff)); 203| 0| } 204| 8.49M| put_str(buf, F, S, T); 205| 8.49M| } 206| 9.82M| } 207| 20.7k| assert(c != -1); ------------------ | Branch (207:3): [True: 0, False: 20.7k] | Branch (207:3): [True: 20.7k, False: 0] ------------------ 208| 20.7k| put_char('"', F, S, T); 209| 20.7k|} jv_print.c:put_char: 125| 1.38M|static void put_char(char c, FILE* fout, jv* strout, int T) { 126| 1.38M| put_buf(&c, 1, fout, strout, T); 127| 1.38M|} jvp_utf8_backtrack: 11| 4.74k|const char* jvp_utf8_backtrack(const char* start, const char* min, int *missing_bytes) { 12| 4.74k| assert(min <= start); ------------------ | Branch (12:3): [True: 0, False: 4.74k] | Branch (12:3): [True: 4.74k, False: 0] ------------------ 13| 4.74k| if (min == start) { ------------------ | Branch (13:7): [True: 0, False: 4.74k] ------------------ 14| 0| return min; 15| 0| } 16| 4.74k| int length = 0; 17| 4.74k| int seen = 1; 18| 6.57k| while ((length = utf8_coding_length[(unsigned char)*start]) == UTF8_CONTINUATION_BYTE) { ------------------ | | 1| 6.57k|#define UTF8_CONTINUATION_BYTE ((unsigned char)255) ------------------ | Branch (18:10): [True: 1.83k, False: 4.74k] ------------------ 19| 1.83k| if (start == min) break; ------------------ | Branch (19:9): [True: 0, False: 1.83k] ------------------ 20| 1.83k| start--; 21| 1.83k| seen++; 22| 1.83k| } 23| 4.74k| if (length == 0 || length == UTF8_CONTINUATION_BYTE || length - seen < 0) { ------------------ | | 1| 9.49k|#define UTF8_CONTINUATION_BYTE ((unsigned char)255) ------------------ | Branch (23:7): [True: 0, False: 4.74k] | Branch (23:22): [True: 0, False: 4.74k] | Branch (23:58): [True: 0, False: 4.74k] ------------------ 24| 0| return NULL; 25| 0| } 26| 4.74k| if (missing_bytes) *missing_bytes = length - seen; ------------------ | Branch (26:7): [True: 0, False: 4.74k] ------------------ 27| 4.74k| return start; 28| 4.74k|} jvp_utf8_next: 30| 1.79G|const char* jvp_utf8_next(const char* in, const char* end, int* codepoint_ret) { 31| 1.79G| assert(in <= end); ------------------ | Branch (31:3): [True: 0, False: 1.79G] | Branch (31:3): [True: 1.79G, False: 0] ------------------ 32| 1.79G| if (in == end) { ------------------ | Branch (32:7): [True: 26.9M, False: 1.76G] ------------------ 33| 26.9M| return 0; 34| 26.9M| } 35| 1.76G| int codepoint = -1; 36| 1.76G| unsigned char first = (unsigned char)in[0]; 37| 1.76G| int length = utf8_coding_length[first]; 38| 1.76G| if ((first & 0x80) == 0) { ------------------ | Branch (38:7): [True: 524M, False: 1.24G] ------------------ 39| | /* Fast-path for ASCII */ 40| 524M| codepoint = first; 41| 524M| length = 1; 42| 1.24G| } else if (length == 0 || length == UTF8_CONTINUATION_BYTE) { ------------------ | | 1| 1.24G|#define UTF8_CONTINUATION_BYTE ((unsigned char)255) ------------------ | Branch (42:14): [True: 2.82M, False: 1.24G] | Branch (42:29): [True: 42.7M, False: 1.19G] ------------------ 43| | /* Bad single byte - either an invalid byte or an out-of-place continuation byte */ 44| 45.6M| length = 1; 45| 1.19G| } else if (length > end - in) { ------------------ | Branch (45:14): [True: 24.8k, False: 1.19G] ------------------ 46| | /* String ends before UTF8 sequence ends */ 47| 24.8k| length = end - in; 48| 1.19G| } else { 49| 1.19G| codepoint = ((unsigned)in[0]) & utf8_coding_bits[first]; 50| 3.59G| for (int i=1; i 0x10FFFF) { ------------------ | Branch (68:9): [True: 396, False: 1.19G] ------------------ 69| | /* Outside Unicode range */ 70| 396| codepoint = -1; 71| 396| } 72| 1.19G| } 73| 1.76G| assert(length > 0); ------------------ | Branch (73:3): [True: 0, False: 1.76G] | Branch (73:3): [True: 1.76G, False: 0] ------------------ 74| 1.76G| *codepoint_ret = codepoint; 75| 1.76G| return in + length; 76| 1.76G|} jvp_utf8_is_valid: 78| 26.7M|int jvp_utf8_is_valid(const char* in, const char* end) { 79| 26.7M| int codepoint; 80| 201M| while ((in = jvp_utf8_next(in, end, &codepoint))) { ------------------ | Branch (80:10): [True: 175M, False: 26.6M] ------------------ 81| 175M| if (codepoint == -1) return 0; ------------------ | Branch (81:9): [True: 89.7k, False: 175M] ------------------ 82| 175M| } 83| 26.6M| return 1; 84| 26.7M|} jvp_utf8_decode_length: 87| 899M|int jvp_utf8_decode_length(char startchar) { 88| 899M| if ((startchar & 0x80) == 0) return 1; // 0___ ____ ------------------ | Branch (88:6): [True: 255M, False: 643M] ------------------ 89| 643M| else if ((startchar & 0xE0) == 0xC0) return 2; // 110_ ____ ------------------ | Branch (89:11): [True: 104k, False: 643M] ------------------ 90| 643M| else if ((startchar & 0xF0) == 0xE0) return 3; // 1110 ____ ------------------ | Branch (90:11): [True: 643M, False: 76.2k] ------------------ 91| 76.2k| else return 4; // 1111 ____ 92| 899M|} jvp_utf8_encode_length: 94| 83.8M|int jvp_utf8_encode_length(int codepoint) { 95| 83.8M| if (codepoint <= 0x7F) return 1; ------------------ | Branch (95:7): [True: 37.1M, False: 46.7M] ------------------ 96| 46.7M| else if (codepoint <= 0x7FF) return 2; ------------------ | Branch (96:12): [True: 41.9k, False: 46.6M] ------------------ 97| 46.6M| else if (codepoint <= 0xFFFF) return 3; ------------------ | Branch (97:12): [True: 46.6M, False: 8.07k] ------------------ 98| 8.07k| else return 4; 99| 83.8M|} jvp_utf8_encode: 101| 83.8M|int jvp_utf8_encode(int codepoint, char* out) { 102| 83.8M| assert(codepoint >= 0 && codepoint <= 0x10FFFF); ------------------ | Branch (102:3): [True: 0, False: 83.8M] | Branch (102:3): [True: 0, False: 0] | Branch (102:3): [True: 83.8M, False: 0] | Branch (102:3): [True: 83.8M, False: 0] ------------------ 103| 83.8M| char* start = out; 104| 83.8M| if (codepoint <= 0x7F) { ------------------ | Branch (104:7): [True: 37.1M, False: 46.7M] ------------------ 105| 37.1M| *out++ = codepoint; 106| 46.7M| } else if (codepoint <= 0x7FF) { ------------------ | Branch (106:14): [True: 41.9k, False: 46.6M] ------------------ 107| 41.9k| *out++ = 0xC0 + ((codepoint & 0x7C0) >> 6); 108| 41.9k| *out++ = 0x80 + ((codepoint & 0x03F)); 109| 46.6M| } else if(codepoint <= 0xFFFF) { ------------------ | Branch (109:13): [True: 46.6M, False: 8.07k] ------------------ 110| 46.6M| *out++ = 0xE0 + ((codepoint & 0xF000) >> 12); 111| 46.6M| *out++ = 0x80 + ((codepoint & 0x0FC0) >> 6); 112| 46.6M| *out++ = 0x80 + ((codepoint & 0x003F)); 113| 46.6M| } else { 114| 8.07k| *out++ = 0xF0 + ((codepoint & 0x1C0000) >> 18); 115| 8.07k| *out++ = 0x80 + ((codepoint & 0x03F000) >> 12); 116| 8.07k| *out++ = 0x80 + ((codepoint & 0x000FC0) >> 6); 117| 8.07k| *out++ = 0x80 + ((codepoint & 0x00003F)); 118| 8.07k| } 119| 83.8M| assert(out - start == jvp_utf8_encode_length(codepoint)); ------------------ | Branch (119:3): [True: 0, False: 83.8M] | Branch (119:3): [True: 83.8M, False: 0] ------------------ 120| 83.8M| return out - start; 121| 83.8M|} jq_yylex: 1079| 21.2M|{ 1080| 21.2M| yy_state_type yy_current_state; 1081| 21.2M| char *yy_cp, *yy_bp; 1082| 21.2M| int yy_act; 1083| 21.2M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1084| | 1085| 21.2M| yylval = yylval_param; ------------------ | | 886| 21.2M| # define yylval yyg->yylval_r ------------------ 1086| | 1087| 21.2M| yylloc = yylloc_param; ------------------ | | 888| 21.2M| # define yylloc yyg->yylloc_r ------------------ 1088| | 1089| 21.2M| if ( !yyg->yy_init ) ------------------ | Branch (1089:7): [True: 15.3k, False: 21.2M] ------------------ 1090| 15.3k| { 1091| 15.3k| yyg->yy_init = 1; 1092| | 1093| |#ifdef YY_USER_INIT 1094| | YY_USER_INIT; 1095| |#endif 1096| | 1097| 15.3k| if ( ! yyg->yy_start ) ------------------ | Branch (1097:8): [True: 15.3k, False: 0] ------------------ 1098| 15.3k| yyg->yy_start = 1; /* first start state */ 1099| | 1100| 15.3k| if ( ! yyin ) ------------------ | | 356| 15.3k|#define yyin yyg->yyin_r ------------------ | Branch (1100:8): [True: 15.3k, False: 0] ------------------ 1101| 15.3k| yyin = stdin; ------------------ | | 356| 15.3k|#define yyin yyg->yyin_r ------------------ 1102| | 1103| 15.3k| if ( ! yyout ) ------------------ | | 357| 15.3k|#define yyout yyg->yyout_r ------------------ | Branch (1103:8): [True: 15.3k, False: 0] ------------------ 1104| 15.3k| yyout = stdout; ------------------ | | 357| 15.3k|#define yyout yyg->yyout_r ------------------ 1105| | 1106| 15.3k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 502| 15.3k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 15.3k, False: 0] | | ------------------ | | 503| 15.3k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 15.3k| : NULL) ------------------ | Branch (1106:8): [True: 0, False: 15.3k] ------------------ 1107| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack jq_yyensure_buffer_stack ------------------ 1108| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1109| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer jq_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 0|#define YY_BUF_SIZE 16384 ------------------ 1110| 0| } 1111| | 1112| 15.3k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 15.3k|#define yy_load_buffer_state jq_yy_load_buffer_state ------------------ 1113| 15.3k| } 1114| | 1115| 21.2M| { 1116| 21.2M|#line 39 "src/lexer.l" 1117| | 1118| | 1119| 21.2M|#line 1120 "src/lexer.c" 1120| | 1121| 38.6M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1121:23): [True: 38.6M, Folded] ------------------ 1122| 38.6M| { 1123| 38.6M| yy_cp = yyg->yy_c_buf_p; 1124| | 1125| | /* Support of yytext. */ 1126| 38.6M| *yy_cp = yyg->yy_hold_char; 1127| | 1128| | /* yy_bp points to the position in yy_ch_buf of the start of 1129| | * the current run. 1130| | */ 1131| 38.6M| yy_bp = yy_cp; 1132| | 1133| 38.6M| yy_current_state = yyg->yy_start; 1134| 38.6M|yy_match: 1135| 38.6M| do 1136| 95.7M| { 1137| 95.7M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 95.7M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1138| 95.7M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1138:9): [True: 56.7M, False: 39.0M] ------------------ 1139| 56.7M| { 1140| 56.7M| yyg->yy_last_accepting_state = yy_current_state; 1141| 56.7M| yyg->yy_last_accepting_cpos = yy_cp; 1142| 56.7M| } 1143| 173M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1143:12): [True: 77.3M, False: 95.7M] ------------------ 1144| 77.3M| { 1145| 77.3M| yy_current_state = (int) yy_def[yy_current_state]; 1146| 77.3M| if ( yy_current_state >= 171 ) ------------------ | Branch (1146:10): [True: 40.5M, False: 36.7M] ------------------ 1147| 40.5M| yy_c = yy_meta[yy_c]; 1148| 77.3M| } 1149| 95.7M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1150| 95.7M| ++yy_cp; 1151| 95.7M| } 1152| 95.7M| while ( yy_base[yy_current_state] != 341 ); ------------------ | Branch (1152:11): [True: 57.1M, False: 38.6M] ------------------ 1153| | 1154| 38.6M|yy_find_action: 1155| 38.6M| yy_act = yy_accept[yy_current_state]; 1156| 38.6M| if ( yy_act == 0 ) ------------------ | Branch (1156:8): [True: 21.5M, False: 17.1M] ------------------ 1157| 21.5M| { /* have to back up */ 1158| 21.5M| yy_cp = yyg->yy_last_accepting_cpos; 1159| 21.5M| yy_current_state = yyg->yy_last_accepting_state; 1160| 21.5M| yy_act = yy_accept[yy_current_state]; 1161| 21.5M| } 1162| | 1163| 38.6M| YY_DO_BEFORE_ACTION; ------------------ | | 571| 38.6M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 560| 38.6M|#define yytext_ptr yytext_r | | ------------------ | | 572| 38.6M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 38.6M|#define yyleng yyg->yyleng_r | | ------------------ | | 573| 38.6M| yyg->yy_hold_char = *yy_cp; \ | | 574| 38.6M| *yy_cp = '\0'; \ | | 575| 38.6M| yyg->yy_c_buf_p = yy_cp; ------------------ 1164| | 1165| 38.6M|do_action: /* This label is used only to access EOF actions. */ 1166| | 1167| 38.6M| switch ( yy_act ) 1168| 38.6M| { /* beginning of action switch */ 1169| 0| case 0: /* must back up */ ------------------ | Branch (1169:4): [True: 0, False: 38.6M] ------------------ 1170| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1171| 0| *yy_cp = yyg->yy_hold_char; 1172| 0| yy_cp = yyg->yy_last_accepting_cpos; 1173| 0| yy_current_state = yyg->yy_last_accepting_state; 1174| 0| goto yy_find_action; 1175| | 1176| 160k|case 1: ------------------ | Branch (1176:1): [True: 160k, False: 38.4M] ------------------ 1177| 160k|YY_RULE_SETUP ------------------ | | 1074| 160k| YY_USER_ACTION | | ------------------ | | | | 811| 160k| do { \ | | | | 812| 160k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 160k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 160k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 160k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 160k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 160k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 160k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 160k] | | | | ------------------ | | ------------------ ------------------ 1178| 160k|#line 41 "src/lexer.l" 1179| 160k|{ yy_push_state(IN_COMMENT, yyscanner); } ------------------ | | 832| 160k|#define IN_COMMENT 6 ------------------ 1180| 160k| YY_BREAK ------------------ | | 1070| 160k|#define YY_BREAK /*LINTED*/break; ------------------ 1181| | 1182| 7.18M|case 2: ------------------ | Branch (1182:1): [True: 7.18M, False: 31.4M] ------------------ 1183| |/* rule 2 can match eol */ 1184| 7.18M|YY_RULE_SETUP ------------------ | | 1074| 7.18M| YY_USER_ACTION | | ------------------ | | | | 811| 7.18M| do { \ | | | | 812| 7.18M| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 7.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 7.18M|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 7.18M| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 7.18M|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 7.18M| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 7.18M|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 7.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 7.18M| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 7.18M] | | | | ------------------ | | ------------------ ------------------ 1185| 7.18M|#line 43 "src/lexer.l" 1186| 7.18M|{ } 1187| 7.18M| YY_BREAK ------------------ | | 1070| 7.18M|#define YY_BREAK /*LINTED*/break; ------------------ 1188| 160k|case 3: ------------------ | Branch (1188:1): [True: 160k, False: 38.4M] ------------------ 1189| |/* rule 3 can match eol */ 1190| 160k|YY_RULE_SETUP ------------------ | | 1074| 160k| YY_USER_ACTION | | ------------------ | | | | 811| 160k| do { \ | | | | 812| 160k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 160k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 160k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 160k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 160k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 160k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 160k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 160k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 160k] | | | | ------------------ | | ------------------ ------------------ 1191| 160k|#line 44 "src/lexer.l" 1192| 160k|{ yy_pop_state(yyscanner); } 1193| 160k| YY_BREAK ------------------ | | 1070| 160k|#define YY_BREAK /*LINTED*/break; ------------------ 1194| | 1195| 0|case YY_STATE_EOF(IN_COMMENT): ------------------ | | 377| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 0|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ | Branch (1195:1): [True: 0, False: 38.6M] ------------------ 1196| 0|#line 46 "src/lexer.l" 1197| 0|{ yy_pop_state(yyscanner); } 1198| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1199| 45.8k|case 4: ------------------ | Branch (1199:1): [True: 45.8k, False: 38.5M] ------------------ 1200| 45.8k|YY_RULE_SETUP ------------------ | | 1074| 45.8k| YY_USER_ACTION | | ------------------ | | | | 811| 45.8k| do { \ | | | | 812| 45.8k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 45.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 45.8k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 45.8k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 45.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 45.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 45.8k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 45.8k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 45.8k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 45.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 45.8k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 45.8k] | | | | ------------------ | | ------------------ ------------------ 1201| 45.8k|#line 48 "src/lexer.l" 1202| 45.8k|{ return NEQ; } ------------------ | | 139| 45.8k|#define NEQ 267 ------------------ 1203| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1204| 290k|case 5: ------------------ | Branch (1204:1): [True: 290k, False: 38.3M] ------------------ 1205| 290k|YY_RULE_SETUP ------------------ | | 1074| 290k| YY_USER_ACTION | | ------------------ | | | | 811| 290k| do { \ | | | | 812| 290k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 290k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 290k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 290k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 290k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 290k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 290k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 290k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 290k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 290k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 290k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 290k] | | | | ------------------ | | ------------------ ------------------ 1206| 290k|#line 49 "src/lexer.l" 1207| 290k|{ return EQ; } ------------------ | | 138| 290k|#define EQ 266 ------------------ 1208| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1209| 291k|case 6: ------------------ | Branch (1209:1): [True: 291k, False: 38.3M] ------------------ 1210| 291k|YY_RULE_SETUP ------------------ | | 1074| 291k| YY_USER_ACTION | | ------------------ | | | | 811| 291k| do { \ | | | | 812| 291k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 291k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 291k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 291k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 291k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 291k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 291k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 291k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 291k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 291k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 291k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 291k] | | | | ------------------ | | ------------------ ------------------ 1211| 291k|#line 50 "src/lexer.l" 1212| 291k|{ return AS; } ------------------ | | 141| 291k|#define AS 269 ------------------ 1213| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1214| 0|case 7: ------------------ | Branch (1214:1): [True: 0, False: 38.6M] ------------------ 1215| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1216| 0|#line 51 "src/lexer.l" 1217| 0|{ return IMPORT; } ------------------ | | 144| 0|#define IMPORT 272 ------------------ 1218| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1219| 0|case 8: ------------------ | Branch (1219:1): [True: 0, False: 38.6M] ------------------ 1220| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1221| 0|#line 52 "src/lexer.l" 1222| 0|{ return INCLUDE; } ------------------ | | 145| 0|#define INCLUDE 273 ------------------ 1223| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1224| 0|case 9: ------------------ | Branch (1224:1): [True: 0, False: 38.6M] ------------------ 1225| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1226| 0|#line 53 "src/lexer.l" 1227| 0|{ return MODULE; } ------------------ | | 143| 0|#define MODULE 271 ------------------ 1228| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1229| 864k|case 10: ------------------ | Branch (1229:1): [True: 864k, False: 37.7M] ------------------ 1230| 864k|YY_RULE_SETUP ------------------ | | 1074| 864k| YY_USER_ACTION | | ------------------ | | | | 811| 864k| do { \ | | | | 812| 864k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 864k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 864k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 864k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 864k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 864k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 864k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 864k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 864k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 864k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 864k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 864k] | | | | ------------------ | | ------------------ ------------------ 1231| 864k|#line 54 "src/lexer.l" 1232| 864k|{ return DEF; } ------------------ | | 142| 864k|#define DEF 270 ------------------ 1233| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1234| 237k|case 11: ------------------ | Branch (1234:1): [True: 237k, False: 38.3M] ------------------ 1235| 237k|YY_RULE_SETUP ------------------ | | 1074| 237k| YY_USER_ACTION | | ------------------ | | | | 811| 237k| do { \ | | | | 812| 237k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 237k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 237k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 237k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 237k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 237k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 237k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 237k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 237k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 237k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 237k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 237k] | | | | ------------------ | | ------------------ ------------------ 1236| 237k|#line 55 "src/lexer.l" 1237| 237k|{ return IF; } ------------------ | | 146| 237k|#define IF 274 ------------------ 1238| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1239| 329k|case 12: ------------------ | Branch (1239:1): [True: 329k, False: 38.3M] ------------------ 1240| 329k|YY_RULE_SETUP ------------------ | | 1074| 329k| YY_USER_ACTION | | ------------------ | | | | 811| 329k| do { \ | | | | 812| 329k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 329k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 329k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 329k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 329k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 329k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 329k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 329k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 329k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 329k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 329k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 329k] | | | | ------------------ | | ------------------ ------------------ 1241| 329k|#line 56 "src/lexer.l" 1242| 329k|{ return THEN; } ------------------ | | 147| 329k|#define THEN 275 ------------------ 1243| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1244| 222k|case 13: ------------------ | Branch (1244:1): [True: 222k, False: 38.4M] ------------------ 1245| 222k|YY_RULE_SETUP ------------------ | | 1074| 222k| YY_USER_ACTION | | ------------------ | | | | 811| 222k| do { \ | | | | 812| 222k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 222k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 222k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 222k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 222k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 222k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 222k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 222k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 222k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 222k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 222k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 222k] | | | | ------------------ | | ------------------ ------------------ 1246| 222k|#line 57 "src/lexer.l" 1247| 222k|{ return ELSE; } ------------------ | | 148| 222k|#define ELSE 276 ------------------ 1248| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1249| 91.7k|case 14: ------------------ | Branch (1249:1): [True: 91.7k, False: 38.5M] ------------------ 1250| 91.7k|YY_RULE_SETUP ------------------ | | 1074| 91.7k| YY_USER_ACTION | | ------------------ | | | | 811| 91.7k| do { \ | | | | 812| 91.7k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 91.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 91.7k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 91.7k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 91.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 91.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 91.7k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 91.7k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 91.7k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 91.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 91.7k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 91.7k] | | | | ------------------ | | ------------------ ------------------ 1251| 91.7k|#line 58 "src/lexer.l" 1252| 91.7k|{ return ELSE_IF; } ------------------ | | 149| 91.7k|#define ELSE_IF 277 ------------------ 1253| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1254| 107k|case 15: ------------------ | Branch (1254:1): [True: 107k, False: 38.5M] ------------------ 1255| 107k|YY_RULE_SETUP ------------------ | | 1074| 107k| YY_USER_ACTION | | ------------------ | | | | 811| 107k| do { \ | | | | 812| 107k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 107k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 107k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 107k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 107k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 107k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 107k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 107k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 107k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 107k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 107k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 107k] | | | | ------------------ | | ------------------ ------------------ 1256| 107k|#line 59 "src/lexer.l" 1257| 107k|{ return AND; } ------------------ | | 153| 107k|#define AND 281 ------------------ 1258| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1259| 22.9k|case 16: ------------------ | Branch (1259:1): [True: 22.9k, False: 38.6M] ------------------ 1260| 22.9k|YY_RULE_SETUP ------------------ | | 1074| 22.9k| YY_USER_ACTION | | ------------------ | | | | 811| 22.9k| do { \ | | | | 812| 22.9k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 22.9k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 22.9k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 22.9k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 22.9k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 22.9k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 22.9k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 22.9k] | | | | ------------------ | | ------------------ ------------------ 1261| 22.9k|#line 60 "src/lexer.l" 1262| 22.9k|{ return OR; } ------------------ | | 154| 22.9k|#define OR 282 ------------------ 1263| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1264| 244k|case 17: ------------------ | Branch (1264:1): [True: 244k, False: 38.3M] ------------------ 1265| 244k|YY_RULE_SETUP ------------------ | | 1074| 244k| YY_USER_ACTION | | ------------------ | | | | 811| 244k| do { \ | | | | 812| 244k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 244k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 244k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 244k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 244k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 244k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 244k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 244k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 244k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 244k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 244k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 244k] | | | | ------------------ | | ------------------ ------------------ 1266| 244k|#line 61 "src/lexer.l" 1267| 244k|{ return END; } ------------------ | | 152| 244k|#define END 280 ------------------ 1268| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1269| 92.4k|case 18: ------------------ | Branch (1269:1): [True: 92.4k, False: 38.5M] ------------------ 1270| 92.4k|YY_RULE_SETUP ------------------ | | 1074| 92.4k| YY_USER_ACTION | | ------------------ | | | | 811| 92.4k| do { \ | | | | 812| 92.4k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 92.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 92.4k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 92.4k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 92.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 92.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 92.4k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 92.4k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 92.4k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 92.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 92.4k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 92.4k] | | | | ------------------ | | ------------------ ------------------ 1271| 92.4k|#line 62 "src/lexer.l" 1272| 92.4k|{ return REDUCE; } ------------------ | | 150| 92.4k|#define REDUCE 278 ------------------ 1273| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1274| 30.5k|case 19: ------------------ | Branch (1274:1): [True: 30.5k, False: 38.6M] ------------------ 1275| 30.5k|YY_RULE_SETUP ------------------ | | 1074| 30.5k| YY_USER_ACTION | | ------------------ | | | | 811| 30.5k| do { \ | | | | 812| 30.5k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 30.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 30.5k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 30.5k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 30.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 30.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 30.5k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 30.5k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 30.5k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 30.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 30.5k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 30.5k] | | | | ------------------ | | ------------------ ------------------ 1276| 30.5k|#line 63 "src/lexer.l" 1277| 30.5k|{ return FOREACH; } ------------------ | | 151| 30.5k|#define FOREACH 279 ------------------ 1278| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1279| 61.2k|case 20: ------------------ | Branch (1279:1): [True: 61.2k, False: 38.5M] ------------------ 1280| 61.2k|YY_RULE_SETUP ------------------ | | 1074| 61.2k| YY_USER_ACTION | | ------------------ | | | | 811| 61.2k| do { \ | | | | 812| 61.2k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 61.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 61.2k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 61.2k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 61.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 61.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 61.2k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 61.2k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 61.2k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 61.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 61.2k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 61.2k] | | | | ------------------ | | ------------------ ------------------ 1281| 61.2k|#line 64 "src/lexer.l" 1282| 61.2k|{ return DEFINEDOR; } ------------------ | | 140| 61.2k|#define DEFINEDOR 268 ------------------ 1283| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1284| 7.65k|case 21: ------------------ | Branch (1284:1): [True: 7.65k, False: 38.6M] ------------------ 1285| 7.65k|YY_RULE_SETUP ------------------ | | 1074| 7.65k| YY_USER_ACTION | | ------------------ | | | | 811| 7.65k| do { \ | | | | 812| 7.65k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 7.65k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 7.65k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 7.65k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 7.65k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 7.65k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 7.65k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 7.65k] | | | | ------------------ | | ------------------ ------------------ 1286| 7.65k|#line 65 "src/lexer.l" 1287| 7.65k|{ return TRY; } ------------------ | | 155| 7.65k|#define TRY 283 ------------------ 1288| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1289| 7.64k|case 22: ------------------ | Branch (1289:1): [True: 7.64k, False: 38.6M] ------------------ 1290| 7.64k|YY_RULE_SETUP ------------------ | | 1074| 7.64k| YY_USER_ACTION | | ------------------ | | | | 811| 7.64k| do { \ | | | | 812| 7.64k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 7.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 7.64k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 7.64k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 7.64k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 7.64k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 7.64k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 7.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 7.64k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 7.64k] | | | | ------------------ | | ------------------ ------------------ 1291| 7.64k|#line 66 "src/lexer.l" 1292| 7.64k|{ return CATCH; } ------------------ | | 156| 7.64k|#define CATCH 284 ------------------ 1293| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1294| 22.9k|case 23: ------------------ | Branch (1294:1): [True: 22.9k, False: 38.6M] ------------------ 1295| 22.9k|YY_RULE_SETUP ------------------ | | 1074| 22.9k| YY_USER_ACTION | | ------------------ | | | | 811| 22.9k| do { \ | | | | 812| 22.9k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 22.9k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 22.9k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 22.9k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 22.9k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 22.9k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 22.9k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 22.9k] | | | | ------------------ | | ------------------ ------------------ 1296| 22.9k|#line 67 "src/lexer.l" 1297| 22.9k|{ return LABEL; } ------------------ | | 157| 22.9k|#define LABEL 285 ------------------ 1298| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1299| 22.9k|case 24: ------------------ | Branch (1299:1): [True: 22.9k, False: 38.6M] ------------------ 1300| 22.9k|YY_RULE_SETUP ------------------ | | 1074| 22.9k| YY_USER_ACTION | | ------------------ | | | | 811| 22.9k| do { \ | | | | 812| 22.9k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 22.9k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 22.9k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 22.9k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 22.9k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 22.9k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 22.9k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 22.9k] | | | | ------------------ | | ------------------ ------------------ 1301| 22.9k|#line 68 "src/lexer.l" 1302| 22.9k|{ return BREAK; } ------------------ | | 158| 22.9k|#define BREAK 286 ------------------ 1303| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1304| 0|case 25: ------------------ | Branch (1304:1): [True: 0, False: 38.6M] ------------------ 1305| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1306| 0|#line 69 "src/lexer.l" 1307| 0|{ return LOC; } ------------------ | | 159| 0|#define LOC 287 ------------------ 1308| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1309| 7.73k|case 26: ------------------ | Branch (1309:1): [True: 7.73k, False: 38.6M] ------------------ 1310| 7.73k|YY_RULE_SETUP ------------------ | | 1074| 7.73k| YY_USER_ACTION | | ------------------ | | | | 811| 7.73k| do { \ | | | | 812| 7.73k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 7.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 7.73k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 7.73k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 7.73k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 7.73k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 7.73k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 7.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 7.73k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 7.73k] | | | | ------------------ | | ------------------ ------------------ 1311| 7.73k|#line 70 "src/lexer.l" 1312| 7.73k|{ return SETPIPE; } ------------------ | | 160| 7.73k|#define SETPIPE 288 ------------------ 1313| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1314| 7.65k|case 27: ------------------ | Branch (1314:1): [True: 7.65k, False: 38.6M] ------------------ 1315| 7.65k|YY_RULE_SETUP ------------------ | | 1074| 7.65k| YY_USER_ACTION | | ------------------ | | | | 811| 7.65k| do { \ | | | | 812| 7.65k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 7.65k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 7.65k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 7.65k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 7.65k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 7.65k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 7.65k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 7.65k] | | | | ------------------ | | ------------------ ------------------ 1316| 7.65k|#line 71 "src/lexer.l" 1317| 7.65k|{ return SETPLUS; } ------------------ | | 161| 7.65k|#define SETPLUS 289 ------------------ 1318| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1319| 0|case 28: ------------------ | Branch (1319:1): [True: 0, False: 38.6M] ------------------ 1320| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1321| 0|#line 72 "src/lexer.l" 1322| 0|{ return SETMINUS; } ------------------ | | 162| 0|#define SETMINUS 290 ------------------ 1323| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1324| 0|case 29: ------------------ | Branch (1324:1): [True: 0, False: 38.6M] ------------------ 1325| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1326| 0|#line 73 "src/lexer.l" 1327| 0|{ return SETMULT; } ------------------ | | 163| 0|#define SETMULT 291 ------------------ 1328| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1329| 0|case 30: ------------------ | Branch (1329:1): [True: 0, False: 38.6M] ------------------ 1330| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1331| 0|#line 74 "src/lexer.l" 1332| 0|{ return SETDIV; } ------------------ | | 164| 0|#define SETDIV 292 ------------------ 1333| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1334| 0|case 31: ------------------ | Branch (1334:1): [True: 0, False: 38.6M] ------------------ 1335| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1336| 0|#line 75 "src/lexer.l" 1337| 0|{ return SETMOD; } ------------------ | | 137| 0|#define SETMOD 265 ------------------ 1338| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1339| 0|case 32: ------------------ | Branch (1339:1): [True: 0, False: 38.6M] ------------------ 1340| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1341| 0|#line 76 "src/lexer.l" 1342| 0|{ return SETDEFINEDOR; } ------------------ | | 165| 0|#define SETDEFINEDOR 293 ------------------ 1343| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1344| 38.2k|case 33: ------------------ | Branch (1344:1): [True: 38.2k, False: 38.5M] ------------------ 1345| 38.2k|YY_RULE_SETUP ------------------ | | 1074| 38.2k| YY_USER_ACTION | | ------------------ | | | | 811| 38.2k| do { \ | | | | 812| 38.2k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 38.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 38.2k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 38.2k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 38.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 38.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 38.2k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 38.2k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 38.2k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 38.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 38.2k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 38.2k] | | | | ------------------ | | ------------------ ------------------ 1346| 38.2k|#line 77 "src/lexer.l" 1347| 38.2k|{ return LESSEQ; } ------------------ | | 166| 38.2k|#define LESSEQ 294 ------------------ 1348| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1349| 21|case 34: ------------------ | Branch (1349:1): [True: 21, False: 38.6M] ------------------ 1350| 21|YY_RULE_SETUP ------------------ | | 1074| 21| YY_USER_ACTION | | ------------------ | | | | 811| 21| do { \ | | | | 812| 21| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 21|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 21| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 21|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 21| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 21|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 21| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 21] | | | | ------------------ | | ------------------ ------------------ 1351| 21|#line 78 "src/lexer.l" 1352| 21|{ return GREATEREQ; } ------------------ | | 167| 21|#define GREATEREQ 295 ------------------ 1353| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1354| 17|case 35: ------------------ | Branch (1354:1): [True: 17, False: 38.6M] ------------------ 1355| 17|YY_RULE_SETUP ------------------ | | 1074| 17| YY_USER_ACTION | | ------------------ | | | | 811| 17| do { \ | | | | 812| 17| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 17| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 17|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 17| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 17| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 17| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 17|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 17| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 17|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 17| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 17| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 17] | | | | ------------------ | | ------------------ ------------------ 1356| 17|#line 79 "src/lexer.l" 1357| 17|{ return REC; } ------------------ | | 136| 17|#define REC 264 ------------------ 1358| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1359| 22|case 36: ------------------ | Branch (1359:1): [True: 22, False: 38.6M] ------------------ 1360| 22|YY_RULE_SETUP ------------------ | | 1074| 22| YY_USER_ACTION | | ------------------ | | | | 811| 22| do { \ | | | | 812| 22| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 22| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 22|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 22| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 22| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 22|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 22| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 22|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 22| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 22| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 22] | | | | ------------------ | | ------------------ ------------------ 1361| 22|#line 80 "src/lexer.l" 1362| 22|{ return ALTERNATION; } ------------------ | | 168| 22|#define ALTERNATION 296 ------------------ 1363| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1364| 5.11M|case 37: ------------------ | Branch (1364:1): [True: 5.11M, False: 33.5M] ------------------ 1365| 5.11M|YY_RULE_SETUP ------------------ | | 1074| 5.11M| YY_USER_ACTION | | ------------------ | | | | 811| 5.11M| do { \ | | | | 812| 5.11M| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 5.11M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 5.11M|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 5.11M| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 5.11M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 5.11M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 5.11M|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 5.11M| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 5.11M|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 5.11M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 5.11M| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 5.11M] | | | | ------------------ | | ------------------ ------------------ 1366| 5.11M|#line 81 "src/lexer.l" 1367| 5.11M|{ return yytext[0];} ------------------ | | 360| 5.11M|#define yytext yyg->yytext_r ------------------ 1368| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1369| 2.79M|case 38: ------------------ | Branch (1369:1): [True: 2.79M, False: 35.8M] ------------------ 1370| 2.79M|YY_RULE_SETUP ------------------ | | 1074| 2.79M| YY_USER_ACTION | | ------------------ | | | | 811| 2.79M| do { \ | | | | 812| 2.79M| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 2.79M|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 2.79M| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 2.79M|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 2.79M| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 2.79M|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 2.79M| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 2.79M] | | | | ------------------ | | ------------------ ------------------ 1371| 2.79M|#line 83 "src/lexer.l" 1372| 2.79M|{ 1373| 2.79M| return enter(yytext[0], YY_START, yyscanner); ------------------ | | 360| 2.79M|#define yytext yyg->yytext_r ------------------ return enter(yytext[0], YY_START, yyscanner); ------------------ | | 374| 2.79M|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 1374| 0|} 1375| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1376| 2.79M|case 39: ------------------ | Branch (1376:1): [True: 2.79M, False: 35.8M] ------------------ 1377| 2.79M|YY_RULE_SETUP ------------------ | | 1074| 2.79M| YY_USER_ACTION | | ------------------ | | | | 811| 2.79M| do { \ | | | | 812| 2.79M| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 2.79M|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 2.79M| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 2.79M|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 2.79M| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 2.79M|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 2.79M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 2.79M| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 2.79M] | | | | ------------------ | | ------------------ ------------------ 1378| 2.79M|#line 87 "src/lexer.l" 1379| 2.79M|{ 1380| 2.79M| return try_exit(yytext[0], YY_START, yyscanner); ------------------ | | 360| 2.79M|#define yytext yyg->yytext_r ------------------ return try_exit(yytext[0], YY_START, yyscanner); ------------------ | | 374| 2.79M|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 1381| 0|} 1382| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1383| 229|case 40: ------------------ | Branch (1383:1): [True: 229, False: 38.6M] ------------------ 1384| 229|YY_RULE_SETUP ------------------ | | 1074| 229| YY_USER_ACTION | | ------------------ | | | | 811| 229| do { \ | | | | 812| 229| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 229| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 229|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 229| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 229| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 229| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 229|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 229| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 229|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 229| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 229| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 229] | | | | ------------------ | | ------------------ ------------------ 1385| 229|#line 91 "src/lexer.l" 1386| 229|{ 1387| 229| yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 886| 229| # define yylval yyg->yylval_r ------------------ yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 360| 229|#define yytext yyg->yytext_r ------------------ yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 359| 229|#define yyleng yyg->yyleng_r ------------------ yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 135| 229|#define FORMAT 263 ------------------ 1388| 0|} 1389| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1390| 554k|case 41: ------------------ | Branch (1390:1): [True: 554k, False: 38.0M] ------------------ 1391| 554k|YY_RULE_SETUP ------------------ | | 1074| 554k| YY_USER_ACTION | | ------------------ | | | | 811| 554k| do { \ | | | | 812| 554k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 554k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 554k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 554k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 554k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 554k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 554k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 554k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 554k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 554k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 554k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 554k] | | | | ------------------ | | ------------------ ------------------ 1392| 554k|#line 95 "src/lexer.l" 1393| 554k|{ 1394| 554k| yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 886| 554k| # define yylval yyg->yylval_r ------------------ yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 360| 554k|#define yytext yyg->yytext_r ------------------ yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 359| 554k|#define yyleng yyg->yyleng_r ------------------ yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 134| 554k|#define LITERAL 262 ------------------ 1395| 0|} 1396| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1397| 395k|case 42: ------------------ | Branch (1397:1): [True: 395k, False: 38.2M] ------------------ 1398| 395k|YY_RULE_SETUP ------------------ | | 1074| 395k| YY_USER_ACTION | | ------------------ | | | | 811| 395k| do { \ | | | | 812| 395k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 395k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 395k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 395k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 395k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 395k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 395k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 395k] | | | | ------------------ | | ------------------ ------------------ 1399| 395k|#line 99 "src/lexer.l" 1400| 395k|{ 1401| 395k| yy_push_state(IN_QQSTRING, yyscanner); ------------------ | | 831| 395k|#define IN_QQSTRING 5 ------------------ 1402| 395k| return QQSTRING_START; ------------------ | | 169| 395k|#define QQSTRING_START 297 ------------------ 1403| 0|} 1404| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1405| | 1406| 804|case 43: ------------------ | Branch (1406:1): [True: 804, False: 38.6M] ------------------ 1407| 804|YY_RULE_SETUP ------------------ | | 1074| 804| YY_USER_ACTION | | ------------------ | | | | 811| 804| do { \ | | | | 812| 804| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 804| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 804|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 804| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 804| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 804| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 804|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 804| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 804|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 804| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 804| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 804] | | | | ------------------ | | ------------------ ------------------ 1408| 804|#line 105 "src/lexer.l" 1409| 804|{ 1410| 804| return enter(QQSTRING_INTERP_START, YY_START, yyscanner); ------------------ | | 171| 804|#define QQSTRING_INTERP_START 299 ------------------ return enter(QQSTRING_INTERP_START, YY_START, yyscanner); ------------------ | | 374| 804|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 1411| 0| } 1412| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1413| 395k|case 44: ------------------ | Branch (1413:1): [True: 395k, False: 38.2M] ------------------ 1414| 395k|YY_RULE_SETUP ------------------ | | 1074| 395k| YY_USER_ACTION | | ------------------ | | | | 811| 395k| do { \ | | | | 812| 395k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 395k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 395k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 395k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 395k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 395k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 395k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 395k] | | | | ------------------ | | ------------------ ------------------ 1415| 395k|#line 108 "src/lexer.l" 1416| 395k|{ 1417| 395k| yy_pop_state(yyscanner); 1418| 395k| return QQSTRING_END; ------------------ | | 173| 395k|#define QQSTRING_END 301 ------------------ 1419| 0| } 1420| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1421| 40|case 45: ------------------ | Branch (1421:1): [True: 40, False: 38.6M] ------------------ 1422| |/* rule 45 can match eol */ 1423| 40|YY_RULE_SETUP ------------------ | | 1074| 40| YY_USER_ACTION | | ------------------ | | | | 811| 40| do { \ | | | | 812| 40| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 40| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 40|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 40| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 40| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 40| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 40|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 40| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 40|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 40| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 40| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 40] | | | | ------------------ | | ------------------ ------------------ 1424| 40|#line 112 "src/lexer.l" 1425| 40|{ 1426| | /* pass escapes to the json parser */ 1427| 40| jv escapes = jv_string_fmt("\"%.*s\"", (int)yyleng, yytext); ------------------ | | 359| 40|#define yyleng yyg->yyleng_r ------------------ jv escapes = jv_string_fmt("\"%.*s\"", (int)yyleng, yytext); ------------------ | | 360| 40|#define yytext yyg->yytext_r ------------------ 1428| 40| yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length_bytes(jv_copy(escapes))); ------------------ | | 886| 40| # define yylval yyg->yylval_r ------------------ 1429| 40| jv_free(escapes); 1430| 40| return QQSTRING_TEXT; ------------------ | | 170| 40|#define QQSTRING_TEXT 298 ------------------ 1431| 0| } 1432| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1433| 364k|case 46: ------------------ | Branch (1433:1): [True: 364k, False: 38.2M] ------------------ 1434| |/* rule 46 can match eol */ 1435| 364k|YY_RULE_SETUP ------------------ | | 1074| 364k| YY_USER_ACTION | | ------------------ | | | | 811| 364k| do { \ | | | | 812| 364k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 364k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 364k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 364k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 364k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 364k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 364k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 364k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 364k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 364k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 364k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 364k] | | | | ------------------ | | ------------------ ------------------ 1436| 364k|#line 119 "src/lexer.l" 1437| 364k|{ 1438| 364k| yylval->literal = jv_string_sized(yytext, yyleng); ------------------ | | 886| 364k| # define yylval yyg->yylval_r ------------------ yylval->literal = jv_string_sized(yytext, yyleng); ------------------ | | 360| 364k|#define yytext yyg->yytext_r ------------------ yylval->literal = jv_string_sized(yytext, yyleng); ------------------ | | 359| 364k|#define yyleng yyg->yyleng_r ------------------ 1439| 364k| return QQSTRING_TEXT; ------------------ | | 170| 364k|#define QQSTRING_TEXT 298 ------------------ 1440| 0| } 1441| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1442| 0|case 47: ------------------ | Branch (1442:1): [True: 0, False: 38.6M] ------------------ 1443| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1444| 0|#line 123 "src/lexer.l" 1445| 0|{ 1446| 0| return INVALID_CHARACTER; ------------------ | | 130| 0|#define INVALID_CHARACTER 258 ------------------ 1447| 0| } 1448| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1449| | 1450| 3.81M|case 48: ------------------ | Branch (1450:1): [True: 3.81M, False: 34.8M] ------------------ 1451| 3.81M|YY_RULE_SETUP ------------------ | | 1074| 3.81M| YY_USER_ACTION | | ------------------ | | | | 811| 3.81M| do { \ | | | | 812| 3.81M| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 3.81M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 3.81M|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 3.81M| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 3.81M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 3.81M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 3.81M|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 3.81M| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 3.81M|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 3.81M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 3.81M| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 3.81M] | | | | ------------------ | | ------------------ ------------------ 1452| 3.81M|#line 129 "src/lexer.l" 1453| 3.81M|{ yylval->literal = jv_string(yytext); return IDENT;} ------------------ | | 886| 3.81M| # define yylval yyg->yylval_r ------------------ { yylval->literal = jv_string(yytext); return IDENT;} ------------------ | | 360| 3.81M|#define yytext yyg->yytext_r ------------------ { yylval->literal = jv_string(yytext); return IDENT;} ------------------ | | 131| 3.81M|#define IDENT 259 ------------------ 1454| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1455| 230k|case 49: ------------------ | Branch (1455:1): [True: 230k, False: 38.4M] ------------------ 1456| 230k|YY_RULE_SETUP ------------------ | | 1074| 230k| YY_USER_ACTION | | ------------------ | | | | 811| 230k| do { \ | | | | 812| 230k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 230k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 230k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 230k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 230k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 230k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 230k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 230k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 230k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 230k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 230k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 230k] | | | | ------------------ | | ------------------ ------------------ 1457| 230k|#line 130 "src/lexer.l" 1458| 230k|{ yylval->literal = jv_string(yytext+1); return FIELD;} ------------------ | | 886| 230k| # define yylval yyg->yylval_r ------------------ { yylval->literal = jv_string(yytext+1); return FIELD;} ------------------ | | 360| 230k|#define yytext yyg->yytext_r ------------------ { yylval->literal = jv_string(yytext+1); return FIELD;} ------------------ | | 132| 230k|#define FIELD 260 ------------------ 1459| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1460| 1.76M|case 50: ------------------ | Branch (1460:1): [True: 1.76M, False: 36.8M] ------------------ 1461| 1.76M|YY_RULE_SETUP ------------------ | | 1074| 1.76M| YY_USER_ACTION | | ------------------ | | | | 811| 1.76M| do { \ | | | | 812| 1.76M| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1.76M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1.76M|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1.76M| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.76M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.76M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1.76M|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1.76M| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1.76M|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1.76M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1.76M| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1.76M] | | | | ------------------ | | ------------------ ------------------ 1462| 1.76M|#line 131 "src/lexer.l" 1463| 1.76M|{ yylval->literal = jv_string(yytext+1); return BINDING;} ------------------ | | 886| 1.76M| # define yylval yyg->yylval_r ------------------ { yylval->literal = jv_string(yytext+1); return BINDING;} ------------------ | | 360| 1.76M|#define yytext yyg->yytext_r ------------------ { yylval->literal = jv_string(yytext+1); return BINDING;} ------------------ | | 133| 1.76M|#define BINDING 261 ------------------ 1464| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1465| 9.82M|case 51: ------------------ | Branch (1465:1): [True: 9.82M, False: 28.8M] ------------------ 1466| |/* rule 51 can match eol */ 1467| 9.82M|YY_RULE_SETUP ------------------ | | 1074| 9.82M| YY_USER_ACTION | | ------------------ | | | | 811| 9.82M| do { \ | | | | 812| 9.82M| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 9.82M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 9.82M|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 9.82M| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 9.82M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 9.82M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 9.82M|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 9.82M| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 9.82M|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 9.82M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 9.82M| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 9.82M] | | | | ------------------ | | ------------------ ------------------ 1468| 9.82M|#line 133 "src/lexer.l" 1469| 9.82M|{} 1470| 9.82M| YY_BREAK ------------------ | | 1070| 9.82M|#define YY_BREAK /*LINTED*/break; ------------------ 1471| 0|case 52: ------------------ | Branch (1471:1): [True: 0, False: 38.6M] ------------------ 1472| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1473| 0|#line 135 "src/lexer.l" 1474| 0|{ return INVALID_CHARACTER; } ------------------ | | 130| 0|#define INVALID_CHARACTER 258 ------------------ 1475| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1476| 0|case 53: ------------------ | Branch (1476:1): [True: 0, False: 38.6M] ------------------ 1477| 0|YY_RULE_SETUP ------------------ | | 1074| 0| YY_USER_ACTION | | ------------------ | | | | 811| 0| do { \ | | | | 812| 0| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 0|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 0| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 0|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 0| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 0|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 0| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1478| 0|#line 137 "src/lexer.l" 1479| 0|YY_FATAL_ERROR( "flex scanner jammed" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1480| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1481| 0|#line 1482 "src/lexer.c" 1482| 15.3k|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 15.3k|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ | Branch (1482:1): [True: 15.3k, False: 38.6M] ------------------ 1483| 15.3k|case YY_STATE_EOF(IN_PAREN): ------------------ | | 377| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 15.3k|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ | Branch (1483:1): [True: 0, False: 38.6M] ------------------ 1484| 15.3k|case YY_STATE_EOF(IN_BRACKET): ------------------ | | 377| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 15.3k|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ | Branch (1484:1): [True: 0, False: 38.6M] ------------------ 1485| 15.3k|case YY_STATE_EOF(IN_BRACE): ------------------ | | 377| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 15.3k|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ | Branch (1485:1): [True: 0, False: 38.6M] ------------------ 1486| 15.3k|case YY_STATE_EOF(IN_QQINTERP): ------------------ | | 377| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 15.3k|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ | Branch (1486:1): [True: 0, False: 38.6M] ------------------ 1487| 15.3k|case YY_STATE_EOF(IN_QQSTRING): ------------------ | | 377| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 15.3k|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ | Branch (1487:1): [True: 0, False: 38.6M] ------------------ 1488| 15.3k| yyterminate(); ------------------ | | 1033| 15.3k|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 15.3k|#define YY_NULL 0 | | ------------------ ------------------ 1489| | 1490| 24.8k| case YY_END_OF_BUFFER: ------------------ | | 577| 24.8k|#define YY_END_OF_BUFFER 54 ------------------ | Branch (1490:2): [True: 24.8k, False: 38.6M] ------------------ 1491| 24.8k| { 1492| | /* Amount of text matched not including the EOB char. */ 1493| 24.8k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 560| 24.8k|#define yytext_ptr yytext_r ------------------ 1494| | 1495| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1496| 24.8k| *yy_cp = yyg->yy_hold_char; 1497| 24.8k| YY_RESTORE_YY_MORE_OFFSET 1498| | 1499| 24.8k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 508| 24.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 479| 24.8k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1499:8): [True: 15.3k, False: 9.53k] ------------------ 1500| 15.3k| { 1501| | /* We're scanning a new file or input source. It's 1502| | * possible that this happened because the user 1503| | * just pointed yyin at a new source and called 1504| | * yylex(). If so, then we have to assure 1505| | * consistency between YY_CURRENT_BUFFER and our 1506| | * globals. Here is the right place to do so, because 1507| | * this is the first action (other than possibly a 1508| | * back-up) that will match for the new input source. 1509| | */ 1510| 15.3k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 15.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1511| 15.3k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 508| 15.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 15.3k|#define yyin yyg->yyin_r ------------------ 1512| 15.3k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 508| 15.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 480| 15.3k|#define YY_BUFFER_NORMAL 1 ------------------ 1513| 15.3k| } 1514| | 1515| | /* Note that here we test for yy_c_buf_p "<=" to the position 1516| | * of the first EOB in the buffer, since yy_c_buf_p will 1517| | * already have been incremented past the NUL character 1518| | * (since all states make transitions on EOB to the 1519| | * end-of-buffer state). Contrast this with the test 1520| | * in input(). 1521| | */ 1522| 24.8k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 508| 24.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1522:8): [True: 0, False: 24.8k] ------------------ 1523| 0| { /* This was really a NUL. */ 1524| 0| yy_state_type yy_next_state; 1525| | 1526| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 1527| | 1528| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1529| | 1530| | /* Okay, we're now positioned to make the NUL 1531| | * transition. We couldn't have 1532| | * yy_get_previous_state() go ahead and do it 1533| | * for us because it doesn't know how to deal 1534| | * with the possibility of jamming (and we don't 1535| | * want to build jamming into it because then it 1536| | * will run more slowly). 1537| | */ 1538| | 1539| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1540| | 1541| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 798| 0|#define YY_MORE_ADJ 0 ------------------ 1542| | 1543| 0| if ( yy_next_state ) ------------------ | Branch (1543:9): [True: 0, False: 0] ------------------ 1544| 0| { 1545| | /* Consume the NUL. */ 1546| 0| yy_cp = ++yyg->yy_c_buf_p; 1547| 0| yy_current_state = yy_next_state; 1548| 0| goto yy_match; 1549| 0| } 1550| | 1551| 0| else 1552| 0| { 1553| 0| yy_cp = yyg->yy_c_buf_p; 1554| 0| goto yy_find_action; 1555| 0| } 1556| 0| } 1557| | 1558| 24.8k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1558:17): [True: 24.8k, False: 0] ------------------ 1559| 24.8k| { 1560| 15.3k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 15.3k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1560:4): [True: 15.3k, False: 9.53k] ------------------ 1561| 15.3k| { 1562| 15.3k| yyg->yy_did_buffer_switch_on_eof = 0; 1563| | 1564| 15.3k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 15.3k|#define yywrap jq_yywrap | | ------------------ | | | | 554| 15.3k|#define jq_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (554:30): [True: 15.3k, Folded] | | | | ------------------ | | ------------------ ------------------ 1565| 15.3k| { 1566| | /* Note: because we've taken care in 1567| | * yy_get_next_buffer() to have set up 1568| | * yytext, we can now set up 1569| | * yy_c_buf_p so that if some total 1570| | * hoser (like flex itself) wants to 1571| | * call the scanner after we return the 1572| | * YY_NULL, it'll still work - another 1573| | * YY_NULL will get returned. 1574| | */ 1575| 15.3k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 15.3k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 798| 15.3k|#define YY_MORE_ADJ 0 ------------------ 1576| | 1577| 15.3k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 15.3k|#define YY_END_OF_BUFFER 54 | | ------------------ ------------------ 1578| 15.3k| goto do_action; 1579| 15.3k| } 1580| | 1581| 0| else 1582| 0| { 1583| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1583:11): [True: 0, False: 0] ------------------ 1584| 0| YY_NEW_FILE; ------------------ | | 379| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart jq_yyrestart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 1585| 0| } 1586| 0| break; 1587| 15.3k| } 1588| | 1589| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1589:4): [True: 0, False: 24.8k] ------------------ 1590| 0| yyg->yy_c_buf_p = 1591| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 1592| | 1593| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1594| | 1595| 0| yy_cp = yyg->yy_c_buf_p; 1596| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 798| 0|#define YY_MORE_ADJ 0 ------------------ 1597| 0| goto yy_match; 1598| | 1599| 9.53k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 9.53k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1599:4): [True: 9.53k, False: 15.3k] ------------------ 1600| 9.53k| yyg->yy_c_buf_p = 1601| 9.53k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 508| 9.53k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1602| | 1603| 9.53k| yy_current_state = yy_get_previous_state( yyscanner ); 1604| | 1605| 9.53k| yy_cp = yyg->yy_c_buf_p; 1606| 9.53k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 9.53k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 798| 9.53k|#define YY_MORE_ADJ 0 ------------------ 1607| 9.53k| goto yy_find_action; 1608| 24.8k| } 1609| 0| break; 1610| 24.8k| } 1611| | 1612| 0| default: ------------------ | Branch (1612:2): [True: 0, False: 38.6M] ------------------ 1613| 0| YY_FATAL_ERROR( ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1614| 38.6M| "fatal flex scanner internal error--no action found" ); 1615| 38.6M| } /* end of action switch */ 1616| 38.6M| } /* end of scanning one token */ 1617| 21.2M| } /* end of user's declarations */ 1618| 21.2M|} /* end of yylex */ jq_yy_switch_to_buffer: 1927| 15.3k|{ 1928| 15.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1929| | 1930| | /* TODO. We should be able to replace this entire function body 1931| | * with 1932| | * yypop_buffer_state(); 1933| | * yypush_buffer_state(new_buffer); 1934| | */ 1935| 15.3k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 15.3k|#define yyensure_buffer_stack jq_yyensure_buffer_stack ------------------ 1936| 15.3k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 502| 15.3k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 15.3k, False: 0] | | ------------------ | | 503| 15.3k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 15.3k| : NULL) ------------------ | Branch (1936:7): [True: 0, False: 15.3k] ------------------ 1937| 0| return; 1938| | 1939| 15.3k| if ( YY_CURRENT_BUFFER ) ------------------ | | 502| 15.3k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 15.3k] | | | Branch (502:29): [True: 15.3k, False: 0] | | ------------------ | | 503| 15.3k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 15.3k| : NULL) ------------------ 1940| 0| { 1941| | /* Flush out information for old buffer. */ 1942| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 1943| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1944| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1945| 0| } 1946| | 1947| 15.3k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 508| 15.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1948| 15.3k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 15.3k|#define yy_load_buffer_state jq_yy_load_buffer_state ------------------ 1949| | 1950| | /* We don't actually know whether we did this switch during 1951| | * EOF (yywrap()) processing, but the only time this flag 1952| | * is looked at is after yywrap() is called, so it's safe 1953| | * to go ahead and always set it. 1954| | */ 1955| 15.3k| yyg->yy_did_buffer_switch_on_eof = 1; 1956| 15.3k|} jq_yy_delete_buffer: 2002| 15.3k|{ 2003| 15.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2004| | 2005| 15.3k| if ( ! b ) ------------------ | Branch (2005:7): [True: 0, False: 15.3k] ------------------ 2006| 0| return; 2007| | 2008| 15.3k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 502| 15.3k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 15.3k, False: 0] | | ------------------ | | 503| 15.3k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 15.3k| : NULL) ------------------ | Branch (2008:7): [True: 15.3k, False: 0] ------------------ 2009| 15.3k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 508| 15.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2010| | 2011| 15.3k| if ( b->yy_is_our_buffer ) ------------------ | Branch (2011:7): [True: 15.3k, False: 0] ------------------ 2012| 15.3k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 15.3k|#define yyfree jq_yyfree ------------------ 2013| | 2014| 15.3k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 15.3k|#define yyfree jq_yyfree ------------------ 2015| 15.3k|} jq_yy_scan_buffer: 2182| 15.3k|{ 2183| 15.3k| YY_BUFFER_STATE b; 2184| | 2185| 15.3k| if ( size < 2 || ------------------ | Branch (2185:7): [True: 0, False: 15.3k] ------------------ 2186| 15.3k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 380| 30.6k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2186:7): [True: 0, False: 15.3k] ------------------ 2187| 15.3k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 380| 15.3k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2187:7): [True: 0, False: 15.3k] ------------------ 2188| | /* They forgot to leave room for the EOB's. */ 2189| 0| return NULL; 2190| | 2191| 15.3k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 15.3k|#define yyalloc jq_yyalloc ------------------ 2192| 15.3k| if ( ! b ) ------------------ | Branch (2192:7): [True: 0, False: 15.3k] ------------------ 2193| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2194| | 2195| 15.3k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2196| 15.3k| b->yy_buf_pos = b->yy_ch_buf = base; 2197| 15.3k| b->yy_is_our_buffer = 0; 2198| 15.3k| b->yy_input_file = NULL; 2199| 15.3k| b->yy_n_chars = b->yy_buf_size; 2200| 15.3k| b->yy_is_interactive = 0; 2201| 15.3k| b->yy_at_bol = 1; 2202| 15.3k| b->yy_fill_buffer = 0; 2203| 15.3k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 479| 15.3k|#define YY_BUFFER_NEW 0 ------------------ 2204| | 2205| 15.3k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 15.3k|#define yy_switch_to_buffer jq_yy_switch_to_buffer ------------------ 2206| | 2207| 15.3k| return b; 2208| 15.3k|} jq_yy_scan_bytes: 2232| 15.3k|{ 2233| 15.3k| YY_BUFFER_STATE b; 2234| 15.3k| char *buf; 2235| 15.3k| yy_size_t n; 2236| 15.3k| int i; 2237| | 2238| | /* Get memory for full buffer, including space for trailing EOB's. */ 2239| 15.3k| n = (yy_size_t) (_yybytes_len + 2); 2240| 15.3k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 236| 15.3k|#define yyalloc jq_yyalloc ------------------ 2241| 15.3k| if ( ! buf ) ------------------ | Branch (2241:7): [True: 0, False: 15.3k] ------------------ 2242| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2243| | 2244| 73.8M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (2244:15): [True: 73.8M, False: 15.3k] ------------------ 2245| 73.8M| buf[i] = yybytes[i]; 2246| | 2247| 15.3k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 15.3k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2248| | 2249| 15.3k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 15.3k|#define yy_scan_buffer jq_yy_scan_buffer ------------------ 2250| 15.3k| if ( ! b ) ------------------ | Branch (2250:7): [True: 0, False: 15.3k] ------------------ 2251| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2252| | 2253| | /* It's okay to grow etc. this buffer, and we should throw it 2254| | * away when we're done. 2255| | */ 2256| 15.3k| b->yy_is_our_buffer = 1; 2257| | 2258| 15.3k| return b; 2259| 15.3k|} jq_yyget_extra: 2337| 38.5M|{ 2338| 38.5M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2339| 38.5M| return yyextra; ------------------ | | 358| 38.5M|#define yyextra yyg->yyextra_r ------------------ 2340| 38.5M|} jq_yyset_extra: 2410| 38.6M|{ 2411| 38.6M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2412| 38.6M| yyextra = user_defined ; ------------------ | | 358| 38.6M|#define yyextra yyg->yyextra_r ------------------ 2413| 38.6M|} jq_yylex_init_extra: 2535| 15.3k|{ 2536| 15.3k| struct yyguts_t dummy_yyguts; 2537| | 2538| 15.3k| yyset_extra (yy_user_defined, &dummy_yyguts); ------------------ | | 140| 15.3k|#define yyset_extra jq_yyset_extra ------------------ 2539| | 2540| 15.3k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2540:9): [True: 0, False: 15.3k] ------------------ 2541| 0| errno = EINVAL; 2542| 0| return 1; 2543| 0| } 2544| | 2545| 15.3k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); ------------------ | | 236| 15.3k|#define yyalloc jq_yyalloc ------------------ 2546| | 2547| 15.3k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2547:9): [True: 0, False: 15.3k] ------------------ 2548| 0| errno = ENOMEM; 2549| 0| return 1; 2550| 0| } 2551| | 2552| | /* By setting to 0xAA, we expose bugs in 2553| | yy_init_globals. Leave at 0x00 for releases. */ 2554| 15.3k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2555| | 2556| 15.3k| yyset_extra (yy_user_defined, *ptr_yy_globals); ------------------ | | 140| 15.3k|#define yyset_extra jq_yyset_extra ------------------ 2557| | 2558| 15.3k| return yy_init_globals ( *ptr_yy_globals ); 2559| 15.3k|} jq_yylex_destroy: 2596| 15.3k|{ 2597| 15.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2598| | 2599| | /* Pop the buffer stack, destroying each element. */ 2600| 15.3k| while(YY_CURRENT_BUFFER){ ------------------ | | 502| 15.3k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 15.3k] | | | Branch (502:29): [True: 15.3k, False: 0] | | ------------------ | | 503| 15.3k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 15.3k| : NULL) ------------------ 2601| 0| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 0|#define yy_delete_buffer jq_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 502| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 0, False: 0] | | ------------------ | | 503| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 0| : NULL) ------------------ 2602| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2603| 0| yypop_buffer_state(yyscanner); ------------------ | | 80| 0|#define yypop_buffer_state jq_yypop_buffer_state ------------------ 2604| 0| } 2605| | 2606| | /* Destroy the stack itself. */ 2607| 15.3k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 15.3k|#define yyfree jq_yyfree ------------------ 2608| 15.3k| yyg->yy_buffer_stack = NULL; 2609| | 2610| | /* Destroy the start condition stack. */ 2611| 15.3k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 15.3k|#define yyfree jq_yyfree ------------------ 2612| 15.3k| yyg->yy_start_stack = NULL; 2613| | 2614| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2615| | * yylex() is called, initialization will occur. */ 2616| 15.3k| yy_init_globals( yyscanner); 2617| | 2618| | /* Destroy the main struct (reentrant only). */ 2619| 15.3k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 15.3k|#define yyfree jq_yyfree ------------------ 2620| | yyscanner = NULL; 2621| 15.3k| return 0; 2622| 15.3k|} jq_yyalloc: 2701| 74.8k|void* yyalloc(size_t sz, void* extra) { 2702| 74.8k| return jv_mem_alloc(sz); 2703| 74.8k|} jq_yyfree: 2707| 76.5k|void yyfree(void* p, void* extra) { 2708| 76.5k| jv_mem_free(p); 2709| 76.5k|} lexer.c:yy_get_next_buffer: 1628| 24.8k|{ 1629| 24.8k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1630| 24.8k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 508| 24.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1631| 24.8k| char *source = yyg->yytext_ptr; ------------------ | | 560| 24.8k|#define yytext_ptr yytext_r ------------------ 1632| 24.8k| int number_to_move, i; 1633| 24.8k| int ret_val; 1634| | 1635| 24.8k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 508| 24.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1635:7): [True: 0, False: 24.8k] ------------------ 1636| 0| YY_FATAL_ERROR( ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1637| 24.8k| "fatal flex scanner internal error--end of buffer missed" ); 1638| | 1639| 24.8k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 508| 24.8k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1639:7): [True: 24.8k, False: 0] ------------------ 1640| 24.8k| { /* Don't try to fill the buffer, so this is an EOF. */ 1641| 24.8k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 560| 24.8k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 798| 24.8k|#define YY_MORE_ADJ 0 ------------------ | Branch (1641:8): [True: 15.3k, False: 9.53k] ------------------ 1642| 15.3k| { 1643| | /* We matched a single character, the EOB, so 1644| | * treat this as a final EOF. 1645| | */ 1646| 15.3k| return EOB_ACT_END_OF_FILE; ------------------ | | 410| 15.3k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1647| 15.3k| } 1648| | 1649| 9.53k| else 1650| 9.53k| { 1651| | /* We matched some text prior to the EOB, first 1652| | * process it. 1653| | */ 1654| 9.53k| return EOB_ACT_LAST_MATCH; ------------------ | | 411| 9.53k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1655| 9.53k| } 1656| 24.8k| } 1657| | 1658| | /* Try to read more data. */ 1659| | 1660| | /* First move last chars to start of buffer. */ 1661| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 1662| | 1663| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1663:15): [True: 0, False: 0] ------------------ 1664| 0| *(dest++) = *(source++); 1665| | 1666| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 491| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1666:7): [True: 0, False: 0] ------------------ 1667| | /* don't do the read, it's not guaranteed to return an EOF, 1668| | * just force an EOF 1669| | */ 1670| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1671| | 1672| 0| else 1673| 0| { 1674| 0| int num_to_read = 1675| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1676| | 1677| 0| while ( num_to_read <= 0 ) ------------------ | Branch (1677:11): [True: 0, False: 0] ------------------ 1678| 0| { /* Not enough room in the buffer - grow it. */ 1679| | 1680| | /* just a shorter name for the current buffer */ 1681| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1682| | 1683| 0| int yy_c_buf_p_offset = 1684| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1685| | 1686| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (1686:9): [True: 0, False: 0] ------------------ 1687| 0| { 1688| 0| int new_size = b->yy_buf_size * 2; 1689| | 1690| 0| if ( new_size <= 0 ) ------------------ | Branch (1690:10): [True: 0, False: 0] ------------------ 1691| 0| b->yy_buf_size += b->yy_buf_size / 8; 1692| 0| else 1693| 0| b->yy_buf_size *= 2; 1694| | 1695| 0| b->yy_ch_buf = (char *) 1696| | /* Include room in for 2 EOB chars. */ 1697| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 0|#define yyrealloc jq_yyrealloc ------------------ 1698| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1699| 0| } 1700| 0| else 1701| | /* Can't grow it, we don't own it. */ 1702| 0| b->yy_ch_buf = NULL; 1703| | 1704| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (1704:9): [True: 0, False: 0] ------------------ 1705| 0| YY_FATAL_ERROR( ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1706| 0| "fatal error - scanner input buffer overflow" ); 1707| | 1708| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1709| | 1710| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1711| 0| number_to_move - 1; 1712| | 1713| 0| } 1714| | 1715| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 980| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1715:8): [True: 0, False: 0] ------------------ 1716| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 980| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 1717| | 1718| | /* Read in more data. */ 1719| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 997| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (997:7): [True: 0, False: 0] | | ------------------ | | 998| 0| { \ | | 999| 0| int c = '*'; \ | | 1000| 0| int n; \ | | 1001| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (1001:16): [True: 0, False: 0] | | ------------------ | | 1002| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1002:9): [True: 0, False: 0] | | | Branch (1002:38): [True: 0, False: 0] | | ------------------ | | 1003| 0| buf[n] = (char) c; \ | | 1004| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (1004:8): [True: 0, False: 0] | | ------------------ | | 1005| 0| buf[n++] = (char) c; \ | | 1006| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1006:8): [True: 0, False: 0] | | | Branch (1006:20): [True: 0, False: 0] | | ------------------ | | 1007| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 1008| 0| result = n; \ | | 1009| 0| } \ | | 1010| 0| else \ | | 1011| 0| { \ | | 1012| 0| errno=0; \ | | 1013| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1013:11): [True: 0, False: 0] | | | Branch (1013:78): [True: 0, False: 0] | | ------------------ | | 1014| 0| { \ | | 1015| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1015:8): [True: 0, False: 0] | | ------------------ | | 1016| 0| { \ | | 1017| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 1018| 0| break; \ | | 1019| 0| } \ | | 1020| 0| errno=0; \ | | 1021| 0| clearerr(yyin); \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | 1022| 0| } \ | | 1023| 0| }\ ------------------ 1720| 0| yyg->yy_n_chars, num_to_read ); 1721| | 1722| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1723| 0| } 1724| | 1725| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1725:7): [True: 0, False: 0] ------------------ 1726| 0| { 1727| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 798| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1727:8): [True: 0, False: 0] ------------------ 1728| 0| { 1729| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1730| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart jq_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 1731| 0| } 1732| | 1733| 0| else 1734| 0| { 1735| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1736| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1737| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 491| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1738| 0| } 1739| 0| } 1740| | 1741| 0| else 1742| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1743| | 1744| 0| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1744:6): [True: 0, False: 0] ------------------ 1745| | /* Extend the array by 50%, plus the number we really need. */ 1746| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1747| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 242| 0|#define yyrealloc jq_yyrealloc ------------------ 1748| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1749| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1749:8): [True: 0, False: 0] ------------------ 1750| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1751| | /* "- 2" to take care of EOB's */ 1752| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1753| 0| } 1754| | 1755| 0| yyg->yy_n_chars += number_to_move; 1756| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1757| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1758| | 1759| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1760| | 1761| 0| return ret_val; 1762| 0|} lexer.c:yy_get_previous_state: 1767| 9.53k|{ 1768| 9.53k| yy_state_type yy_current_state; 1769| 9.53k| char *yy_cp; 1770| 9.53k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1771| | 1772| 9.53k| yy_current_state = yyg->yy_start; 1773| | 1774| 29.8k| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 560| 9.53k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 798| 9.53k|#define YY_MORE_ADJ 0 ------------------ | Branch (1774:47): [True: 20.2k, False: 9.53k] ------------------ 1775| 20.2k| { 1776| 20.2k| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 346| 20.2k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1776:19): [True: 20.2k, False: 0] ------------------ 1777| 20.2k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1777:8): [True: 10.7k, False: 9.53k] ------------------ 1778| 10.7k| { 1779| 10.7k| yyg->yy_last_accepting_state = yy_current_state; 1780| 10.7k| yyg->yy_last_accepting_cpos = yy_cp; 1781| 10.7k| } 1782| 29.1k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1782:11): [True: 8.83k, False: 20.2k] ------------------ 1783| 8.83k| { 1784| 8.83k| yy_current_state = (int) yy_def[yy_current_state]; 1785| 8.83k| if ( yy_current_state >= 171 ) ------------------ | Branch (1785:9): [True: 8.83k, False: 0] ------------------ 1786| 8.83k| yy_c = yy_meta[yy_c]; 1787| 8.83k| } 1788| 20.2k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1789| 20.2k| } 1790| | 1791| 9.53k| return yy_current_state; 1792| 9.53k|} lexer.c:jq_yy_load_buffer_state: 1959| 30.6k|{ 1960| 30.6k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1961| 30.6k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 30.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1962| 30.6k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 560| 30.6k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 508| 30.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1963| 30.6k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 30.6k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 508| 30.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1964| 30.6k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1965| 30.6k|} lexer.c:jq_yyensure_buffer_stack: 2132| 15.3k|{ 2133| 15.3k| yy_size_t num_to_alloc; 2134| 15.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2135| | 2136| 15.3k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2136:6): [True: 15.3k, False: 0] ------------------ 2137| | 2138| | /* First allocation is just for 2 elements, since we don't know if this 2139| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2140| | * immediate realloc on the next call. 2141| | */ 2142| 15.3k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2143| 15.3k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 15.3k|#define yyalloc jq_yyalloc ------------------ 2144| 15.3k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2145| 15.3k| , yyscanner); 2146| 15.3k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2146:8): [True: 0, False: 15.3k] ------------------ 2147| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2148| | 2149| 15.3k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2150| | 2151| 15.3k| yyg->yy_buffer_stack_max = num_to_alloc; 2152| 15.3k| yyg->yy_buffer_stack_top = 0; 2153| 15.3k| return; 2154| 15.3k| } 2155| | 2156| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2156:6): [True: 0, False: 0] ------------------ 2157| | 2158| | /* Increase the buffer to prepare for a possible push. */ 2159| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2160| | 2161| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2162| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 242| 0|#define yyrealloc jq_yyrealloc ------------------ 2163| 0| (yyg->yy_buffer_stack, 2164| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2165| 0| , yyscanner); 2166| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2166:8): [True: 0, False: 0] ------------------ 2167| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2168| | 2169| | /* zero only the new slots.*/ 2170| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2171| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2172| 0| } 2173| 0|} lexer.c:yy_push_state: 2262| 3.35M|{ 2263| 3.35M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2264| 3.35M| if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) ------------------ | Branch (2264:7): [True: 13.6k, False: 3.33M] ------------------ 2265| 13.6k| { 2266| 13.6k| yy_size_t new_size; 2267| | 2268| 13.6k| yyg->yy_start_stack_depth += YY_START_STACK_INCR; ------------------ | | 1038| 13.6k|#define YY_START_STACK_INCR 25 ------------------ 2269| 13.6k| new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int ); 2270| | 2271| 13.6k| if ( ! yyg->yy_start_stack ) ------------------ | Branch (2271:8): [True: 13.6k, False: 0] ------------------ 2272| 13.6k| yyg->yy_start_stack = (int *) yyalloc( new_size , yyscanner ); ------------------ | | 236| 13.6k|#define yyalloc jq_yyalloc ------------------ 2273| | 2274| 0| else 2275| 0| yyg->yy_start_stack = (int *) yyrealloc( ------------------ | | 242| 0|#define yyrealloc jq_yyrealloc ------------------ 2276| 0| (void *) yyg->yy_start_stack, new_size , yyscanner ); 2277| | 2278| 13.6k| if ( ! yyg->yy_start_stack ) ------------------ | Branch (2278:8): [True: 0, False: 13.6k] ------------------ 2279| 0| YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2280| 13.6k| } 2281| | 2282| 3.35M| yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START; ------------------ | | 374| 3.35M|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 2283| | 2284| 3.35M| BEGIN(_new_state); ------------------ | | 369| 3.35M|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ 2285| 3.35M|} lexer.c:yy_pop_state: 2288| 3.35M|{ 2289| 3.35M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2290| 3.35M| if ( --yyg->yy_start_stack_ptr < 0 ) ------------------ | Branch (2290:7): [True: 0, False: 3.35M] ------------------ 2291| 0| YY_FATAL_ERROR( "start-condition stack underflow" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2292| | 2293| 3.35M| BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]); ------------------ | | 369| 3.35M|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ 2294| 3.35M|} lexer.c:yy_init_globals: 2562| 30.6k|{ 2563| 30.6k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2564| | /* Initialization is the same as for the non-reentrant scanner. 2565| | * This function is called from yylex_destroy(), so don't allocate here. 2566| | */ 2567| | 2568| 30.6k| yyg->yy_buffer_stack = NULL; 2569| 30.6k| yyg->yy_buffer_stack_top = 0; 2570| 30.6k| yyg->yy_buffer_stack_max = 0; 2571| 30.6k| yyg->yy_c_buf_p = NULL; 2572| 30.6k| yyg->yy_init = 0; 2573| 30.6k| yyg->yy_start = 0; 2574| | 2575| 30.6k| yyg->yy_start_stack_ptr = 0; 2576| 30.6k| yyg->yy_start_stack_depth = 0; 2577| 30.6k| yyg->yy_start_stack = NULL; 2578| | 2579| |/* Defined in main.c */ 2580| |#ifdef YY_STDINIT 2581| | yyin = stdin; 2582| | yyout = stdout; 2583| |#else 2584| 30.6k| yyin = NULL; ------------------ | | 356| 30.6k|#define yyin yyg->yyin_r ------------------ 2585| 30.6k| yyout = NULL; ------------------ | | 357| 30.6k|#define yyout yyg->yyout_r ------------------ 2586| 30.6k|#endif 2587| | 2588| | /* For future reference: Set errno on error, since we are called by 2589| | * yylex_init() 2590| | */ 2591| 30.6k| return 0; 2592| 30.6k|} lexer.c:try_exit: 2661| 2.79M|static int try_exit(int c, int state, yyscan_t yyscanner) { 2662| 2.79M| char match = 0; 2663| 2.79M| int ret; 2664| 2.79M| switch (state) { 2665| 1.91M| case IN_PAREN: match = ret = ')'; break; ------------------ | | 827| 1.91M|#define IN_PAREN 1 ------------------ | Branch (2665:3): [True: 1.91M, False: 878k] ------------------ 2666| 785k| case IN_BRACKET: match = ret = ']'; break; ------------------ | | 828| 785k|#define IN_BRACKET 2 ------------------ | Branch (2666:3): [True: 785k, False: 2.00M] ------------------ 2667| 91.9k| case IN_BRACE: match = ret = '}'; break; ------------------ | | 829| 91.9k|#define IN_BRACE 3 ------------------ | Branch (2667:3): [True: 91.9k, False: 2.70M] ------------------ 2668| | 2669| 804| case IN_QQINTERP: ------------------ | | 830| 804|#define IN_QQINTERP 4 ------------------ | Branch (2669:3): [True: 804, False: 2.79M] ------------------ 2670| 804| match = ')'; 2671| 804| ret = QQSTRING_INTERP_END; ------------------ | | 172| 804|#define QQSTRING_INTERP_END 300 ------------------ 2672| 804| break; 2673| | 2674| 0| default: ------------------ | Branch (2674:3): [True: 0, False: 2.79M] ------------------ 2675| | // may not be the best error to give 2676| 0| return INVALID_CHARACTER; ------------------ | | 130| 0|#define INVALID_CHARACTER 258 ------------------ 2677| 2.79M| } 2678| 2.79M| assert(match); ------------------ | Branch (2678:3): [True: 0, False: 2.79M] | Branch (2678:3): [True: 2.79M, False: 0] ------------------ 2679| 2.79M| if (match == c) { ------------------ | Branch (2679:7): [True: 2.79M, False: 0] ------------------ 2680| 2.79M| yy_pop_state(yyscanner); 2681| 2.79M| return ret; 2682| 2.79M| } else { 2683| | // FIXME: should we pop? Give a better error at least 2684| 0| return INVALID_CHARACTER; ------------------ | | 130| 0|#define INVALID_CHARACTER 258 ------------------ 2685| 0| } 2686| 2.79M|} lexer.c:enter: 2688| 2.79M|static int enter(int c, int currstate, yyscan_t yyscanner) { 2689| 2.79M| int state = 0; 2690| 2.79M| switch (c) { ------------------ | Branch (2690:11): [True: 2.79M, False: 0] ------------------ 2691| 1.91M| case '(': state = IN_PAREN; break; ------------------ | | 827| 1.91M|#define IN_PAREN 1 ------------------ | Branch (2691:3): [True: 1.91M, False: 878k] ------------------ 2692| 785k| case '[': state = IN_BRACKET; break; ------------------ | | 828| 785k|#define IN_BRACKET 2 ------------------ | Branch (2692:3): [True: 785k, False: 2.00M] ------------------ 2693| 91.9k| case '{': state = IN_BRACE; break; ------------------ | | 829| 91.9k|#define IN_BRACE 3 ------------------ | Branch (2693:3): [True: 91.9k, False: 2.70M] ------------------ 2694| 804| case QQSTRING_INTERP_START: state = IN_QQINTERP; break; ------------------ | | 171| 804|#define QQSTRING_INTERP_START 299 ------------------ case QQSTRING_INTERP_START: state = IN_QQINTERP; break; ------------------ | | 830| 804|#define IN_QQINTERP 4 ------------------ | Branch (2694:3): [True: 804, False: 2.79M] ------------------ 2695| 2.79M| } 2696| 2.79M| assert(state); ------------------ | Branch (2696:3): [True: 0, False: 2.79M] | Branch (2696:3): [True: 2.79M, False: 0] ------------------ 2697| 2.79M| yy_push_state(state, yyscanner); 2698| 2.79M| return c; 2699| 2.79M|} load_program: 435| 7.65k|int load_program(jq_state *jq, struct locfile* src, block *out_block) { 436| 7.65k| int nerrors = 0; 437| 7.65k| block program; 438| 7.65k| struct lib_loading_state lib_state = {0,0}; 439| 7.65k| nerrors = jq_parse(src, &program); 440| 7.65k| if (nerrors) ------------------ | Branch (440:7): [True: 5, False: 7.64k] ------------------ 441| 5| return nerrors; 442| | 443| 7.64k| if (!block_has_main(program)) { ------------------ | Branch (443:7): [True: 0, False: 7.64k] ------------------ 444| 0| jq_report_error(jq, jv_string("jq: error: Top-level program not given (try \".\")")); 445| 0| block_free(program); 446| 0| return 1; 447| 0| } 448| | 449| 7.64k| jv home = get_home(); 450| 7.64k| if (jv_is_valid(home)) { ------------------ | Branch (450:7): [True: 7.64k, False: 0] ------------------ 451| | /* Import ~/.jq as a library named "" found in $HOME or %USERPROFILE% */ 452| 7.64k| block import = gen_import_meta(gen_import(jv_string(""), jv_invalid(), 0), 453| 7.64k| gen_const(JV_OBJECT( ------------------ | | 207| 7.64k| JV_OBJECT_IDX(__VA_ARGS__, \ | | ------------------ | | | | 205| 7.64k|#define JV_OBJECT_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,NAME,...) NAME | | | | ------------------ | | | | | | 211| 7.64k| JV_OBJECT_6, JV_OBJECT_5, JV_OBJECT_4, JV_OBJECT_3, \ | | | | | | ------------------ | | | | | | | | 180| 7.64k|#define JV_OBJECT_4(k1,v1,k2,v2) (jv_object_set(JV_OBJECT_2((k1),(v1)),(k2),(v2))) | | | | | | | | ------------------ | | | | | | | | | | 178| 7.64k|#define JV_OBJECT_2(k1,v1) (jv_object_set(jv_object(),(k1),(v1))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 208| 7.64k| JV_OBJECT_18, JV_OBJECT_17, JV_OBJECT_16, JV_OBJECT_15, \ | | 209| 7.64k| JV_OBJECT_14, JV_OBJECT_13, JV_OBJECT_12, JV_OBJECT_11, \ | | 210| 7.64k| JV_OBJECT_10, JV_OBJECT_9, JV_OBJECT_8, JV_OBJECT_7, \ | | 211| 7.64k| JV_OBJECT_6, JV_OBJECT_5, JV_OBJECT_4, JV_OBJECT_3, \ | | 212| 7.64k| JV_OBJECT_2, JV_OBJECT_1)(__VA_ARGS__) ------------------ 454| 7.64k| jv_string("optional"), jv_true(), 455| 7.64k| jv_string("search"), home))); 456| 7.64k| program = BLOCK(import, program); ------------------ | | 102| 7.64k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.64k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.64k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 7.64k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 457| 7.64k| } else { // silently ignore if home dir not determined 458| 0| jv_free(home); 459| 0| } 460| | 461| 7.64k| nerrors = process_dependencies(jq, jq_get_jq_origin(jq), jq_get_prog_origin(jq), &program, &lib_state); 462| 7.64k| block libs = gen_noop(); 463| 7.64k| for (uint64_t i = 0; i < lib_state.ct; ++i) { ------------------ | Branch (463:24): [True: 0, False: 7.64k] ------------------ 464| 0| free(lib_state.entries[i].name); 465| 0| if (nerrors == 0 && !block_is_const(lib_state.entries[i].def)) ------------------ | Branch (465:9): [True: 0, False: 0] | Branch (465:25): [True: 0, False: 0] ------------------ 466| 0| libs = block_join(libs, lib_state.entries[i].def); 467| 0| else 468| 0| block_free(lib_state.entries[i].def); 469| 0| } 470| 7.64k| free(lib_state.entries); 471| 7.64k| if (nerrors) ------------------ | Branch (471:7): [True: 0, False: 7.64k] ------------------ 472| 0| block_free(program); 473| 7.64k| else 474| 7.64k| *out_block = block_drop_unreferenced(block_join(libs, program)); 475| | 476| 7.64k| return nerrors; 477| 7.64k|} linker.c:find_lib: 144| 7.64k|static jv find_lib(jq_state *jq, jv rel_path, jv search, const char *suffix, jv jq_origin, jv lib_origin) { 145| 7.64k| if (!jv_is_valid(rel_path)) { ------------------ | Branch (145:7): [True: 0, False: 7.64k] ------------------ 146| 0| jv_free(search); 147| 0| jv_free(jq_origin); 148| 0| jv_free(lib_origin); 149| 0| return rel_path; 150| 0| } 151| 7.64k| if (jv_get_kind(rel_path) != JV_KIND_STRING) { ------------------ | Branch (151:7): [True: 0, False: 7.64k] ------------------ 152| 0| jv_free(rel_path); 153| 0| jv_free(search); 154| 0| jv_free(jq_origin); 155| 0| jv_free(lib_origin); 156| 0| return jv_invalid_with_msg(jv_string_fmt("Module path must be a string")); 157| 0| } 158| 7.64k| if (jv_get_kind(search) != JV_KIND_ARRAY) { ------------------ | Branch (158:7): [True: 0, False: 7.64k] ------------------ 159| 0| jv_free(rel_path); 160| 0| jv_free(search); 161| 0| jv_free(jq_origin); 162| 0| jv_free(lib_origin); 163| 0| return jv_invalid_with_msg(jv_string_fmt("Module search path must be an array")); 164| 0| } 165| | 166| 7.64k| struct stat st; 167| 7.64k| int ret; 168| | 169| | // Ideally we should cache this somewhere 170| 7.64k| search = build_lib_search_chain(jq, search, jq_origin, lib_origin); 171| 7.64k| jv err = jv_array_get(jv_copy(search), 1); 172| 7.64k| search = jv_array_get(search, 0); 173| | 174| 7.64k| jv bname = jv_basename(jv_copy(rel_path)); 175| | 176| 7.64k| jv_array_foreach(search, i, spath) { ------------------ | | 93| 7.64k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 15.2k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 7.64k, False: 7.64k] | | ------------------ | | 95| 7.64k| for (jv x; \ | | 96| 15.2k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 7.64k, False: 7.64k] | | | Branch (96:10): [True: 7.64k, False: 7.64k] | | ------------------ | | 97| 15.2k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 7.64k| i++) ------------------ 177| 7.64k| if (jv_get_kind(spath) == JV_KIND_NULL) { ------------------ | Branch (177:9): [True: 0, False: 7.64k] ------------------ 178| 0| jv_free(spath); 179| 0| break; 180| 0| } 181| 7.64k| if (jv_get_kind(spath) != JV_KIND_STRING || ------------------ | Branch (181:9): [True: 0, False: 7.64k] ------------------ 182| 7.64k| strcmp(jv_string_value(spath), "") == 0) { ------------------ | Branch (182:9): [True: 0, False: 7.64k] ------------------ 183| 0| jv_free(spath); 184| 0| continue; /* XXX report non-strings in search path?? */ 185| 0| } 186| | // Try ${search_dir}/${rel_path}.jq 187| 7.64k| jv testpath = jq_realpath(jv_string_fmt("%s/%s%s", 188| 7.64k| jv_string_value(spath), 189| 7.64k| jv_string_value(rel_path), 190| 7.64k| suffix)); 191| 7.64k| ret = stat(jv_string_value(testpath),&st); 192| 7.64k| if (ret == -1 && errno == ENOENT) { ------------------ | Branch (192:9): [True: 7.64k, False: 0] | Branch (192:22): [True: 7.64k, False: 0] ------------------ 193| 7.64k| jv_free(testpath); 194| | // Try ${search_dir}/$(dirname ${rel_path})/jq/main.jq 195| 7.64k| testpath = jq_realpath(jv_string_fmt("%s/%s/%s%s", 196| 7.64k| jv_string_value(spath), 197| 7.64k| jv_string_value(rel_path), 198| 7.64k| "jq/main", 199| 7.64k| suffix)); 200| 7.64k| ret = stat(jv_string_value(testpath),&st); 201| 7.64k| } 202| 7.64k| if (ret == -1 && errno == ENOENT) { ------------------ | Branch (202:9): [True: 7.64k, False: 0] | Branch (202:22): [True: 7.64k, False: 0] ------------------ 203| 7.64k| jv_free(testpath); 204| | // Try ${search_dir}/${rel_path}/$(basename ${rel_path}).jq 205| 7.64k| testpath = jq_realpath(jv_string_fmt("%s/%s/%s%s", 206| 7.64k| jv_string_value(spath), 207| 7.64k| jv_string_value(rel_path), 208| 7.64k| jv_string_value(bname), 209| 7.64k| suffix)); 210| 7.64k| ret = stat(jv_string_value(testpath),&st); 211| 7.64k| } 212| 7.64k| if (ret == 0) { ------------------ | Branch (212:9): [True: 0, False: 7.64k] ------------------ 213| 0| jv_free(err); 214| 0| jv_free(rel_path); 215| 0| jv_free(search); 216| 0| jv_free(bname); 217| 0| jv_free(spath); 218| 0| return testpath; 219| 0| } 220| 7.64k| jv_free(testpath); 221| 7.64k| jv_free(spath); 222| 7.64k| } 223| 7.64k| jv output; 224| 7.64k| if (!jv_is_valid(err)) { ------------------ | Branch (224:7): [True: 0, False: 7.64k] ------------------ 225| 0| err = jv_invalid_get_msg(err); 226| 0| output = jv_invalid_with_msg(jv_string_fmt("module not found: %s (%s)", 227| 0| jv_string_value(rel_path), 228| 0| jv_string_value(err))); 229| 7.64k| } else { 230| 7.64k| output = jv_invalid_with_msg(jv_string_fmt("module not found: %s", 231| 7.64k| jv_string_value(rel_path))); 232| 7.64k| } 233| 7.64k| jv_free(err); 234| 7.64k| jv_free(rel_path); 235| 7.64k| jv_free(search); 236| 7.64k| jv_free(bname); 237| 7.64k| return output; 238| 7.64k|} linker.c:build_lib_search_chain: 54| 7.64k|static jv build_lib_search_chain(jq_state *jq, jv search_path, jv jq_origin, jv lib_origin) { 55| 7.64k| assert(jv_get_kind(search_path) == JV_KIND_ARRAY); ------------------ | Branch (55:3): [True: 0, False: 7.64k] | Branch (55:3): [True: 7.64k, False: 0] ------------------ 56| 7.64k| jv expanded = jv_array(); 57| 7.64k| jv expanded_elt; 58| 7.64k| jv err = jv_null(); 59| 7.64k| jv_array_foreach(search_path, i, path) { ------------------ | | 93| 7.64k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 15.2k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 7.64k, False: 7.64k] | | ------------------ | | 95| 7.64k| for (jv x; \ | | 96| 15.2k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 7.64k, False: 7.64k] | | | Branch (96:10): [True: 7.64k, False: 7.64k] | | ------------------ | | 97| 15.2k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 7.64k| i++) ------------------ 60| 7.64k| if (jv_get_kind(path) != JV_KIND_STRING) { ------------------ | Branch (60:9): [True: 0, False: 7.64k] ------------------ 61| 0| jv_free(path); 62| 0| continue; 63| 0| } 64| 7.64k| path = expand_path(path); 65| 7.64k| if (!jv_is_valid(path)) { ------------------ | Branch (65:9): [True: 0, False: 7.64k] ------------------ 66| 0| jv_free(err); 67| 0| err = path; 68| 0| path = jv_null(); 69| 0| continue; 70| 0| } 71| 7.64k| if (strcmp(".",jv_string_value(path)) == 0) { ------------------ | Branch (71:9): [True: 0, False: 7.64k] ------------------ 72| 0| expanded_elt = jv_copy(path); 73| 7.64k| } else if (strncmp("$ORIGIN/",jv_string_value(path),sizeof("$ORIGIN/") - 1) == 0) { ------------------ | Branch (73:16): [True: 0, False: 7.64k] ------------------ 74| 0| expanded_elt = jv_string_fmt("%s/%s", 75| 0| jv_string_value(jq_origin), 76| 0| jv_string_value(path) + sizeof ("$ORIGIN/") - 1); 77| 7.64k| } else if (jv_get_kind(lib_origin) == JV_KIND_STRING && ------------------ | Branch (77:16): [True: 0, False: 7.64k] ------------------ 78| 0| path_is_relative(jv_copy(path))) { ------------------ | Branch (78:16): [True: 0, False: 0] ------------------ 79| 0| expanded_elt = jv_string_fmt("%s/%s", 80| 0| jv_string_value(lib_origin), 81| 0| jv_string_value(path)); 82| 7.64k| } else { 83| 7.64k| expanded_elt = path; 84| 7.64k| path = jv_invalid(); 85| 7.64k| } 86| 7.64k| expanded = jv_array_append(expanded, expanded_elt); 87| 7.64k| jv_free(path); 88| 7.64k| } 89| 7.64k| jv_free(jq_origin); 90| 7.64k| jv_free(lib_origin); 91| 7.64k| jv_free(search_path); 92| 7.64k| return JV_ARRAY(expanded, err); ------------------ | | 111| 7.64k| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | ------------------ | | | | 109| 7.64k|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 111| 7.64k| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 101| 7.64k|#define JV_ARRAY_2(e1,e2) (jv_array_append(JV_ARRAY_1(e1),e2)) | | | | | | | | ------------------ | | | | | | | | | | 100| 7.64k|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 93| 7.64k|} linker.c:jv_basename: 133| 7.64k|static jv jv_basename(jv name) { 134| 7.64k| const char *s = jv_string_value(name); 135| 7.64k| const char *p = strrchr(s, '/'); 136| 7.64k| if (!p) ------------------ | Branch (136:7): [True: 7.64k, False: 0] ------------------ 137| 7.64k| return name; 138| 0| jv res = jv_string_fmt("%s", p); 139| 0| jv_free(name); 140| 0| return res; 141| 7.64k|} linker.c:validate_relpath: 98| 7.64k|static jv validate_relpath(jv name) { 99| 7.64k| const char *s = jv_string_value(name); 100| 7.64k| if (strlen(s) != (size_t)jv_string_length_bytes(jv_copy(name))) { ------------------ | Branch (100:7): [True: 0, False: 7.64k] ------------------ 101| 0| jv_free(name); 102| 0| return jv_invalid_with_msg(jv_string("Module path contains a NUL byte")); 103| 0| } 104| 7.64k| if (strchr(s, '\\')) { ------------------ | Branch (104:7): [True: 0, False: 7.64k] ------------------ 105| 0| jv res = jv_invalid_with_msg(jv_string_fmt("Modules must be named by relative paths using '/', not '\\' (%s)", s)); 106| 0| jv_free(name); 107| 0| return res; 108| 0| } 109| 7.64k| jv components = jv_string_split(jv_copy(name), jv_string("/")); 110| 7.64k| jv_array_foreach(components, i, x) { ------------------ | | 93| 7.64k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 94| 15.2k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (94:8): [True: 7.64k, False: 7.64k] | | ------------------ | | 95| 7.64k| for (jv x; \ | | 96| 7.64k| i < jv_len__ ? \ | | ------------------ | | | Branch (96:10): [True: 0, False: 7.64k] | | | Branch (96:10): [True: 0, False: 7.64k] | | ------------------ | | 97| 7.64k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 98| 7.64k| i++) ------------------ 111| 0| if (!strcmp(jv_string_value(x), "..")) { ------------------ | Branch (111:9): [True: 0, False: 0] ------------------ 112| 0| jv_free(x); 113| 0| jv_free(components); 114| 0| jv res = jv_invalid_with_msg(jv_string_fmt("Relative paths to modules may not traverse to parent directories (%s)", s)); 115| 0| jv_free(name); 116| 0| return res; 117| 0| } 118| 0| if (i > 0 && jv_equal(jv_copy(x), jv_array_get(jv_copy(components), i - 1))) { ------------------ | Branch (118:9): [True: 0, False: 0] | Branch (118:18): [True: 0, False: 0] ------------------ 119| 0| jv_free(x); 120| 0| jv_free(components); 121| 0| jv res = jv_invalid_with_msg(jv_string_fmt("module names must not have equal consecutive components: %s", 122| 0| jv_string_value(name))); 123| 0| jv_free(name); 124| 0| return res; 125| 0| } 126| 0| jv_free(x); 127| 0| } 128| 7.64k| jv_free(components); 129| 7.64k| return name; 130| 7.64k|} linker.c:process_dependencies: 252| 7.64k|static int process_dependencies(jq_state *jq, jv jq_origin, jv lib_origin, block *src_block, struct lib_loading_state *lib_state) { 253| 7.64k| jv deps = block_take_imports(src_block); 254| 7.64k| block bk = *src_block; 255| 7.64k| int nerrors = 0; 256| | 257| | // XXX This is a backward jv_array_foreach because bindings go in reverse 258| 15.2k| for (int i = jv_array_length(jv_copy(deps)); i > 0; ) { ------------------ | Branch (258:48): [True: 7.64k, False: 7.64k] ------------------ 259| 7.64k| i--; 260| 7.64k| jv dep = jv_array_get(jv_copy(deps), i); 261| | 262| 7.64k| const char *as_str = NULL; 263| 7.64k| int is_data = jv_get_kind(jv_object_get(jv_copy(dep), jv_string("is_data"))) == JV_KIND_TRUE; 264| 7.64k| int raw = 0; 265| 7.64k| jv v = jv_object_get(jv_copy(dep), jv_string("raw")); 266| 7.64k| if (jv_get_kind(v) == JV_KIND_TRUE) ------------------ | Branch (266:9): [True: 0, False: 7.64k] ------------------ 267| 0| raw = 1; 268| 7.64k| int optional = 0; 269| 7.64k| if (jv_get_kind(jv_object_get(jv_copy(dep), jv_string("optional"))) == JV_KIND_TRUE) ------------------ | Branch (269:9): [True: 7.64k, False: 0] ------------------ 270| 7.64k| optional = 1; 271| 7.64k| jv_free(v); 272| 7.64k| jv relpath = validate_relpath(jv_object_get(jv_copy(dep), jv_string("relpath"))); 273| 7.64k| jv as = jv_object_get(jv_copy(dep), jv_string("as")); 274| 7.64k| assert(!jv_is_valid(as) || jv_get_kind(as) == JV_KIND_STRING); ------------------ | Branch (274:5): [True: 7.64k, False: 0] | Branch (274:5): [True: 0, False: 0] | Branch (274:5): [True: 7.64k, False: 0] | Branch (274:5): [True: 0, False: 0] ------------------ 275| 7.64k| if (jv_get_kind(as) == JV_KIND_STRING) ------------------ | Branch (275:9): [True: 0, False: 7.64k] ------------------ 276| 0| as_str = jv_string_value(as); 277| 7.64k| jv search = default_search(jq, jv_object_get(dep, jv_string("search"))); 278| | // dep is now freed; do not reuse 279| | 280| | // find_lib does a lot of work that could be cached... 281| 7.64k| jv resolved = find_lib(jq, relpath, search, is_data ? ".json" : ".jq", jv_copy(jq_origin), jv_copy(lib_origin)); ------------------ | Branch (281:49): [True: 0, False: 7.64k] ------------------ 282| | // XXX ...move the rest of this into a callback. 283| 7.64k| if (!jv_is_valid(resolved)) { ------------------ | Branch (283:9): [True: 7.64k, False: 0] ------------------ 284| 7.64k| jv_free(as); 285| 7.64k| if (optional) { ------------------ | Branch (285:11): [True: 7.64k, False: 0] ------------------ 286| 7.64k| jv_free(resolved); 287| 7.64k| continue; 288| 7.64k| } 289| 0| jv emsg = jv_invalid_get_msg(resolved); 290| 0| jq_report_error(jq, jv_string_fmt("jq: error: %s\n",jv_string_value(emsg))); 291| 0| jv_free(emsg); 292| 0| jv_free(deps); 293| 0| jv_free(jq_origin); 294| 0| jv_free(lib_origin); 295| 0| return 1; 296| 7.64k| } 297| | 298| 0| if (is_data) { ------------------ | Branch (298:9): [True: 0, False: 0] ------------------ 299| | // Can't reuse data libs because the wrong name is bound 300| 0| block dep_def_block; 301| 0| nerrors += load_library(jq, resolved, is_data, raw, optional, as_str, &dep_def_block, lib_state); 302| 0| if (nerrors == 0) { ------------------ | Branch (302:11): [True: 0, False: 0] ------------------ 303| | // Bind as both $data::data and $data for backward compatibility vs common sense 304| 0| bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, as_str); 305| 0| bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, NULL); 306| 0| } 307| 0| } else { 308| 0| uint64_t state_idx = 0; 309| 0| for (; state_idx < lib_state->ct; ++state_idx) { ------------------ | Branch (309:14): [True: 0, False: 0] ------------------ 310| 0| if (strcmp(lib_state->entries[state_idx].name, jv_string_value(resolved)) == 0) ------------------ | Branch (310:13): [True: 0, False: 0] ------------------ 311| 0| break; 312| 0| } 313| | 314| 0| if (state_idx < lib_state->ct) { // Found ------------------ | Branch (314:11): [True: 0, False: 0] ------------------ 315| 0| if (lib_state->entries[state_idx].loading) { ------------------ | Branch (315:13): [True: 0, False: 0] ------------------ 316| 0| jq_report_error(jq, jv_string_fmt("jq: error: circular import of %s\n", 317| 0| jv_string_value(resolved))); 318| 0| jv_free(resolved); 319| 0| jv_free(as); 320| 0| jv_free(deps); 321| 0| jv_free(jq_origin); 322| 0| jv_free(lib_origin); 323| 0| return 1; 324| 0| } 325| 0| jv_free(resolved); 326| | // Bind the library to the program 327| 0| bk = block_bind_library(lib_state->entries[state_idx].def, bk, OP_IS_CALL_PSEUDO, as_str); 328| 0| } else { // Not found. Add it to the table before binding. 329| 0| block dep_def_block = gen_noop(); 330| 0| nerrors += load_library(jq, resolved, is_data, raw, optional, as_str, &dep_def_block, lib_state); 331| | // resolved has been freed 332| 0| if (nerrors == 0) { ------------------ | Branch (332:13): [True: 0, False: 0] ------------------ 333| | // Bind the library to the program 334| 0| bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, as_str); 335| 0| } 336| 0| } 337| 0| } 338| | 339| 0| jv_free(as); 340| 0| } 341| 7.64k| jv_free(lib_origin); 342| 7.64k| jv_free(jq_origin); 343| 7.64k| jv_free(deps); 344| 7.64k| return nerrors; 345| 7.64k|} linker.c:default_search: 240| 7.64k|static jv default_search(jq_state *jq, jv value) { 241| 7.64k| if (!jv_is_valid(value)) { ------------------ | Branch (241:7): [True: 0, False: 7.64k] ------------------ 242| | // dependent didn't say; prepend . to system search path listj 243| 0| jv_free(value); 244| 0| return jv_array_concat(JV_ARRAY(jv_string(".")), jq_get_lib_dirs(jq)); ------------------ | | 111| 0| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | ------------------ | | | | 109| 0|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 111| 0| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 100| 0|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 245| 0| } 246| 7.64k| if (jv_get_kind(value) != JV_KIND_ARRAY) ------------------ | Branch (246:7): [True: 7.64k, False: 0] ------------------ 247| 7.64k| return JV_ARRAY(value); ------------------ | | 111| 7.64k| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | ------------------ | | | | 109| 7.64k|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 111| 7.64k| JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 100| 7.64k|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 248| 0| return value; 249| 7.64k|} locfile_init: 12| 15.3k|struct locfile* locfile_init(jq_state *jq, const char *fname, const char* data, int length) { 13| 15.3k| struct locfile* l = jv_mem_alloc(sizeof(struct locfile)); 14| 15.3k| l->jq = jq; 15| 15.3k| l->fname = jv_string(fname); 16| 15.3k| l->data = jv_mem_alloc(length); 17| 15.3k| memcpy((char*)l->data,data,length); 18| 15.3k| l->length = length; 19| 15.3k| l->nlines = 1; 20| 15.3k| l->refct = 1; 21| 73.8M| for (int i=0; inlines++; ------------------ | Branch (22:9): [True: 1.86M, False: 71.9M] ------------------ 23| 73.8M| } 24| 15.3k| l->linemap = jv_mem_calloc(l->nlines + 1, sizeof(int)); 25| 15.3k| l->linemap[0] = 0; 26| 15.3k| int line = 1; 27| 73.8M| for (int i=0; ilinemap[line] = i+1; // at start of line, not of \n 30| 1.86M| line++; 31| 1.86M| } 32| 73.8M| } 33| 15.3k| l->linemap[l->nlines] = length+1; // virtual last \n 34| 15.3k| return l; 35| 15.3k|} locfile_retain: 37| 4.06M|struct locfile* locfile_retain(struct locfile* l) { 38| 4.06M| l->refct++; 39| 4.06M| return l; 40| 4.06M|} locfile_free: 41| 4.07M|void locfile_free(struct locfile* l) { 42| 4.07M| if (--(l->refct) == 0) { ------------------ | Branch (42:7): [True: 15.3k, False: 4.06M] ------------------ 43| 15.3k| jv_free(l->fname); 44| 15.3k| jv_mem_free(l->linemap); 45| 15.3k| jv_mem_free((char*)l->data); 46| 15.3k| jv_mem_free(l); 47| 15.3k| } 48| 4.07M|} locfile_get_line: 50| 5|int locfile_get_line(struct locfile* l, int pos) { 51| 5| assert(pos < l->length); ------------------ | Branch (51:3): [True: 0, False: 5] | Branch (51:3): [True: 5, False: 0] ------------------ 52| 5| int line = 1; 53| 5| while (l->linemap[line] <= pos) line++; // == if pos at start (before, never ==, because pos never on \n) ------------------ | Branch (53:10): [True: 0, False: 5] ------------------ 54| 5| assert(line-1 < l->nlines); ------------------ | Branch (54:3): [True: 0, False: 5] | Branch (54:3): [True: 5, False: 0] ------------------ 55| 5| return line-1; 56| 5|} locfile_locate: 63| 5|void locfile_locate(struct locfile* l, location loc, const char* fmt, ...) { 64| 5| va_list fmtargs; 65| 5| va_start(fmtargs, fmt); 66| | 67| 5| jv m1 = jv_string_vfmt(fmt, fmtargs); 68| 5| va_end(fmtargs); 69| 5| if (!jv_is_valid(m1)) { ------------------ | Branch (69:7): [True: 0, False: 5] ------------------ 70| 0| jq_report_error(l->jq, m1); 71| 0| return; 72| 0| } 73| 5| if (loc.start == -1) { ------------------ | Branch (73:7): [True: 0, False: 5] ------------------ 74| 0| jq_report_error(l->jq, jv_string_fmt("jq: error: %s", jv_string_value(m1))); 75| 0| jv_free(m1); 76| 0| return; 77| 0| } 78| | 79| 5| int startline = locfile_get_line(l, loc.start); 80| 5| int offset = l->linemap[startline]; 81| 5| int end = MIN(loc.end, MAX(l->linemap[startline+1] - 1, loc.start + 1)); ------------------ | | 49| 5| ({ __typeof__ (a) _a = (a); \ | | 50| 10| __typeof__ (b) _b = (b); \ | | ------------------ | | | Branch (50:25): [True: 5, False: 0] | | ------------------ | | 51| 5| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (51:4): [True: 5, False: 0] | | ------------------ ------------------ 82| 5| jv underline = jv_string_repeat(jv_string("^"), end - loc.start); 83| 5| jv m2 = jv_string_fmt("%s at %s, line %d, column %d:\n %.*s\n %*s", 84| 5| jv_string_value(m1), jv_string_value(l->fname), 85| 5| startline + 1, loc.start - offset + 1, 86| 5| locfile_line_length(l, startline), l->data + offset, 87| 5| end - offset, jv_string_value(underline)); 88| 5| jv_free(m1); 89| 5| jv_free(underline); 90| 5| jq_report_error(l->jq, m2); 91| 5| return; 92| 5|} locfile.c:locfile_line_length: 58| 5|static int locfile_line_length(struct locfile* l, int line) { 59| 5| assert(line < l->nlines); ------------------ | Branch (59:3): [True: 0, False: 5] | Branch (59:3): [True: 5, False: 0] ------------------ 60| 5| return l->linemap[line+1] - l->linemap[line] -1; // -1 to omit \n 61| 5|} yyerror: 407| 5| struct locfile* locations, struct lexer_param* lexer_param_ptr, const char *s){ 408| 5| (*errors)++; 409| 5| locfile_locate(locations, *loc, "jq: error: %s", s); 410| 5|} yylex: 413| 21.2M| struct locfile* locations, struct lexer_param* lexer_param_ptr) { 414| 21.2M| yyscan_t lexer = lexer_param_ptr->lexer; 415| 21.2M| int tok = jq_yylex(yylval, yylloc, lexer); 416| 21.2M| if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) { ------------------ | | 203| 42.5M|#define LITERAL 262 ------------------ if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) { ------------------ | | 239| 20.7M|#define QQSTRING_TEXT 298 ------------------ | Branch (416:8): [True: 554k, False: 20.7M] | Branch (416:26): [True: 364k, False: 20.3M] | Branch (416:51): [True: 5, False: 918k] ------------------ 417| 5| jv msg = jv_invalid_get_msg(jv_copy(yylval->literal)); 418| 5| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (418:9): [True: 5, False: 0] ------------------ 419| 5| FAIL(*yylloc, jv_string_value(msg)); ------------------ | | 400| 5| do { \ | | 401| 5| location l = loc; \ | | 402| 5| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 5| /*YYERROR*/; \ | | 404| 5| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 5] | | ------------------ ------------------ 420| 5| } else { 421| 0| FAIL(*yylloc, "Invalid literal"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 422| 0| } 423| 5| jv_free(msg); 424| 5| jv_free(yylval->literal); 425| 5| yylval->literal = jv_null(); 426| 5| } 427| 21.2M| return tok; 428| 21.2M|} yyparse: 2221| 15.3k|{ 2222| |/* Lookahead token kind. */ 2223| 15.3k|int yychar; 2224| | 2225| | 2226| |/* The semantic value of the lookahead symbol. */ 2227| |/* Default value used for initialization, for pacifying older GCCs 2228| | or non-GCC compilers. */ 2229| 15.3k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 715| 15.3k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2230| 15.3k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 715| 15.3k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2231| | 2232| |/* Location data for the lookahead symbol. */ 2233| 15.3k|static YYLTYPE yyloc_default 2234| |# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 2235| | = { 1, 1, 1, 1 } 2236| |# endif 2237| 15.3k|; 2238| 15.3k|YYLTYPE yylloc = yyloc_default; ------------------ | | 122| 15.3k|#define YYLTYPE location ------------------ 2239| | 2240| | /* Number of syntax errors so far. */ 2241| 15.3k| int yynerrs = 0; 2242| | 2243| 15.3k| yy_state_fast_t yystate = 0; 2244| | /* Number of tokens to shift before error messages enabled. */ 2245| 15.3k| int yyerrstatus = 0; 2246| | 2247| | /* Refer to the stacks through separate pointers, to allow yyoverflow 2248| | to reallocate them elsewhere. */ 2249| | 2250| | /* Their size. */ 2251| 15.3k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 622| 15.3k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1692| 15.3k|# define YYINITDEPTH 200 ------------------ 2252| | 2253| | /* The state stack: array, bottom, top. */ 2254| 15.3k| yy_state_t yyssa[YYINITDEPTH]; 2255| 15.3k| yy_state_t *yyss = yyssa; 2256| 15.3k| yy_state_t *yyssp = yyss; 2257| | 2258| | /* The semantic value stack: array, bottom, top. */ 2259| 15.3k| YYSTYPE yyvsa[YYINITDEPTH]; 2260| 15.3k| YYSTYPE *yyvs = yyvsa; 2261| 15.3k| YYSTYPE *yyvsp = yyvs; 2262| | 2263| | /* The location stack: array, bottom, top. */ 2264| 15.3k| YYLTYPE yylsa[YYINITDEPTH]; ------------------ | | 122| 15.3k|#define YYLTYPE location ------------------ 2265| 15.3k| YYLTYPE *yyls = yylsa; ------------------ | | 122| 15.3k|#define YYLTYPE location ------------------ 2266| 15.3k| YYLTYPE *yylsp = yyls; ------------------ | | 122| 15.3k|#define YYLTYPE location ------------------ 2267| | 2268| 15.3k| int yyn; 2269| | /* The return value of yyparse. */ 2270| 15.3k| int yyresult; 2271| | /* Lookahead symbol kind. */ 2272| 15.3k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 2273| | /* The variables used to return semantic value and location from the 2274| | action routines. */ 2275| 15.3k| YYSTYPE yyval; 2276| 15.3k| YYLTYPE yyloc; ------------------ | | 122| 15.3k|#define YYLTYPE location ------------------ 2277| | 2278| | /* The locations where the error started and ended. */ 2279| 15.3k| YYLTYPE yyerror_range[3]; ------------------ | | 122| 15.3k|#define YYLTYPE location ------------------ 2280| | 2281| | /* Buffer for error messages, and its allocated size. */ 2282| 15.3k| char yymsgbuf[128]; 2283| 15.3k| char *yymsg = yymsgbuf; 2284| 15.3k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 622| 15.3k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 2285| | 2286| 15.3k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 2287| | 2288| | /* The number of symbols on the RHS of the reduced rule. 2289| | Keep to zero when no symbol should be popped. */ 2290| 15.3k| int yylen = 0; 2291| | 2292| 15.3k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1683| 15.3k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2293| | 2294| 15.3k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 195| 15.3k|#define YYEMPTY -2 ------------------ 2295| | 2296| 15.3k| yylsp[0] = yylloc; 2297| 15.3k| goto yysetstate; 2298| | 2299| | 2300| |/*------------------------------------------------------------. 2301| || yynewstate -- push a new state, which is found in yystate. | 2302| |`------------------------------------------------------------*/ 2303| 50.9M|yynewstate: 2304| | /* In all cases, when you get here, the value and location stacks 2305| | have just been pushed. So pushing a state here evens the stacks. */ 2306| 50.9M| yyssp++; 2307| | 2308| | 2309| |/*--------------------------------------------------------------------. 2310| || yysetstate -- set current state (the top of the stack) to yystate. | 2311| |`--------------------------------------------------------------------*/ 2312| 50.9M|yysetstate: 2313| 50.9M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1683| 50.9M|# define YYDPRINTF(Args) ((void) 0) ------------------ 2314| 50.9M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 738| 50.9M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (738:31): [Folded, False: 50.9M] | | | Branch (738:37): [True: 0, False: 0] | | | Branch (738:37): [True: 0, False: 0] | | ------------------ ------------------ 2315| 50.9M| YY_IGNORE_USELESS_CAST_BEGIN 2316| 50.9M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 89| 50.9M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2317| 50.9M| YY_IGNORE_USELESS_CAST_END 2318| 50.9M| YY_STACK_PRINT (yyss, yyssp); 2319| | 2320| 50.9M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (2320:7): [True: 0, False: 50.9M] ------------------ 2321| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 2322| | YYNOMEM; 2323| |#else 2324| 0| { 2325| | /* Get the current used size of the three stacks, in elements. */ 2326| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 622| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 2327| | 2328| |# if defined yyoverflow 2329| | { 2330| | /* Give user a chance to reallocate the stack. Use copies of 2331| | these so that the &'s don't force the real ones into 2332| | memory. */ 2333| | yy_state_t *yyss1 = yyss; 2334| | YYSTYPE *yyvs1 = yyvs; 2335| | YYLTYPE *yyls1 = yyls; 2336| | 2337| | /* Each stack pointer address is followed by the size of the 2338| | data in use in that stack, in bytes. This used to be a 2339| | conditional around just the two extra args, but that might 2340| | be undefined if yyoverflow is a macro. */ 2341| | yyoverflow (YY_("memory exhausted"), 2342| | &yyss1, yysize * YYSIZEOF (*yyssp), 2343| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 2344| | &yyls1, yysize * YYSIZEOF (*yylsp), 2345| | &yystacksize); 2346| | yyss = yyss1; 2347| | yyvs = yyvs1; 2348| | yyls = yyls1; 2349| | } 2350| |# else /* defined YYSTACK_RELOCATE */ 2351| | /* Extend the stack our own way. */ 2352| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1703| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (2352:11): [True: 0, False: 0] ------------------ 2353| 0| YYNOMEM; ------------------ | | 1445| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 2354| 0| yystacksize *= 2; 2355| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1703| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (2355:11): [True: 0, False: 0] ------------------ 2356| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1703| 0|# define YYMAXDEPTH 10000 ------------------ 2357| | 2358| 0| { 2359| 0| yy_state_t *yyss1 = yyss; 2360| 0| union yyalloc *yyptr = 2361| 0| YY_CAST (union yyalloc *, ------------------ | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2362| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 2363| 0| if (! yyptr) ------------------ | Branch (2363:13): [True: 0, False: 0] ------------------ 2364| 0| YYNOMEM; ------------------ | | 1445| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 2365| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 838| 0| do \ | | 839| 0| { \ | | 840| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 622| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 841| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 856| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 842| 0| Stack = &yyptr->Stack_alloc; \ | | 843| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 821| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 844| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 845| 0| } \ | | 846| 0| while (0) | | ------------------ | | | Branch (846:12): [Folded, False: 0] | | ------------------ ------------------ 2366| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 838| 0| do \ | | 839| 0| { \ | | 840| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 622| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 841| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 856| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 842| 0| Stack = &yyptr->Stack_alloc; \ | | 843| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 821| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 844| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 845| 0| } \ | | 846| 0| while (0) | | ------------------ | | | Branch (846:12): [Folded, False: 0] | | ------------------ ------------------ 2367| 0| YYSTACK_RELOCATE (yyls_alloc, yyls); ------------------ | | 838| 0| do \ | | 839| 0| { \ | | 840| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 622| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 841| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 856| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 842| 0| Stack = &yyptr->Stack_alloc; \ | | 843| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 821| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 844| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 655| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 845| 0| } \ | | 846| 0| while (0) | | ------------------ | | | Branch (846:12): [Folded, False: 0] | | ------------------ ------------------ 2368| 0|# undef YYSTACK_RELOCATE 2369| 0| if (yyss1 != yyssa) ------------------ | Branch (2369:13): [True: 0, False: 0] ------------------ 2370| 0| YYSTACK_FREE (yyss1); ------------------ | | 780| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 0|#define YYFREE jv_mem_free | | ------------------ ------------------ 2371| 0| } 2372| 0|# endif 2373| | 2374| 0| yyssp = yyss + yysize - 1; 2375| 0| yyvsp = yyvs + yysize - 1; 2376| 0| yylsp = yyls + yysize - 1; 2377| | 2378| 0| YY_IGNORE_USELESS_CAST_BEGIN 2379| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 1683| 0|# define YYDPRINTF(Args) ((void) 0) ------------------ 2380| 0| YY_CAST (long, yystacksize))); 2381| 0| YY_IGNORE_USELESS_CAST_END 2382| | 2383| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (2383:11): [True: 0, False: 0] ------------------ 2384| 0| YYABORT; ------------------ | | 1443| 0|#define YYABORT goto yyabortlab ------------------ 2385| 0| } 2386| 50.9M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 2387| | 2388| | 2389| 50.9M| if (yystate == YYFINAL) ------------------ | | 871| 50.9M|#define YYFINAL 31 ------------------ | Branch (2389:7): [True: 15.3k, False: 50.9M] ------------------ 2390| 15.3k| YYACCEPT; ------------------ | | 1442| 15.3k|#define YYACCEPT goto yyacceptlab ------------------ 2391| | 2392| 50.9M| goto yybackup; 2393| | 2394| | 2395| |/*-----------. 2396| || yybackup. | 2397| |`-----------*/ 2398| 50.9M|yybackup: 2399| | /* Do appropriate processing given the current state. Read a 2400| | lookahead token if we need one and don't already have one. */ 2401| | 2402| | /* First try to decide what to do without reference to lookahead token. */ 2403| 50.9M| yyn = yypact[yystate]; 2404| 50.9M| if (yypact_value_is_default (yyn)) ------------------ | | 997| 50.9M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 994| 50.9M|#define YYPACT_NINF (-146) | | ------------------ | | | Branch (997:3): [True: 11.0M, False: 39.9M] | | ------------------ ------------------ 2405| 11.0M| goto yydefault; 2406| | 2407| | /* Not known => get a lookahead token if don't already have one. */ 2408| | 2409| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 2410| 39.9M| if (yychar == YYEMPTY) ------------------ | | 195| 39.9M|#define YYEMPTY -2 ------------------ | Branch (2410:7): [True: 21.2M, False: 18.6M] ------------------ 2411| 21.2M| { 2412| 21.2M| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1683| 21.2M|# define YYDPRINTF(Args) ((void) 0) ------------------ 2413| 21.2M| yychar = yylex (&yylval, &yylloc, answer, errors, locations, lexer_param_ptr); 2414| 21.2M| } 2415| | 2416| 39.9M| if (yychar <= YYEOF) ------------------ | | 196| 39.9M|#define YYEOF 0 ------------------ | Branch (2416:7): [True: 48.7k, False: 39.8M] ------------------ 2417| 48.7k| { 2418| 48.7k| yychar = YYEOF; ------------------ | | 196| 48.7k|#define YYEOF 0 ------------------ 2419| 48.7k| yytoken = YYSYMBOL_YYEOF; 2420| 48.7k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1683| 48.7k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2421| 48.7k| } 2422| 39.8M| else if (yychar == YYerror) ------------------ | | 197| 39.8M|#define YYerror 256 ------------------ | Branch (2422:12): [True: 0, False: 39.8M] ------------------ 2423| 0| { 2424| | /* The scanner already issued an error message, process directly 2425| | to error recovery. But do not keep the error token as 2426| | lookahead, it is too special and may lead us to an endless 2427| | loop in error recovery. */ 2428| 0| yychar = YYUNDEF; ------------------ | | 198| 0|#define YYUNDEF 257 ------------------ 2429| 0| yytoken = YYSYMBOL_YYerror; 2430| 0| yyerror_range[1] = yylloc; 2431| 0| goto yyerrlab1; 2432| 0| } 2433| 39.8M| else 2434| 39.8M| { 2435| 39.8M| yytoken = YYTRANSLATE (yychar); ------------------ | | 891| 39.8M| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 885| 39.8M|#define YYMAXUTOK 303 | | ------------------ | | | Branch (891:4): [True: 39.8M, False: 0] | | | Branch (891:18): [True: 39.8M, False: 0] | | ------------------ | | 892| 39.8M| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 89| 39.8M|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 893| 39.8M| : YYSYMBOL_YYUNDEF) ------------------ 2436| 39.8M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2437| 39.8M| } 2438| | 2439| | /* If the proper action on seeing token YYTOKEN is to reduce or to 2440| | detect an error, take that action. */ 2441| 39.9M| yyn += yytoken; 2442| 39.9M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 873| 39.8M|#define YYLAST 1226 ------------------ | Branch (2442:7): [True: 7.65k, False: 39.8M] | Branch (2442:18): [True: 30.6k, False: 39.8M] | Branch (2442:34): [True: 17.7M, False: 22.1M] ------------------ 2443| 17.7M| goto yydefault; 2444| 22.1M| yyn = yytable[yyn]; 2445| 22.1M| if (yyn <= 0) ------------------ | Branch (2445:7): [True: 824k, False: 21.2M] ------------------ 2446| 824k| { 2447| 824k| if (yytable_value_is_error (yyn)) ------------------ | | 1002| 824k| ((Yyn) == YYTABLE_NINF) | | ------------------ | | | | 999| 824k|#define YYTABLE_NINF (-154) | | ------------------ | | | Branch (1002:3): [True: 0, False: 824k] | | ------------------ ------------------ 2448| 0| goto yyerrlab; 2449| 824k| yyn = -yyn; 2450| 824k| goto yyreduce; 2451| 824k| } 2452| | 2453| | /* Count tokens shifted since error; after three, turn off error 2454| | status. */ 2455| 21.2M| if (yyerrstatus) ------------------ | Branch (2455:7): [True: 0, False: 21.2M] ------------------ 2456| 0| yyerrstatus--; 2457| | 2458| | /* Shift the lookahead token. */ 2459| 21.2M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2460| 21.2M| yystate = yyn; 2461| 21.2M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2462| 21.2M| *++yyvsp = yylval; 2463| 21.2M| YY_IGNORE_MAYBE_UNINITIALIZED_END 2464| 21.2M| *++yylsp = yylloc; 2465| | 2466| | /* Discard the shifted token. */ 2467| 21.2M| yychar = YYEMPTY; ------------------ | | 195| 21.2M|#define YYEMPTY -2 ------------------ 2468| 21.2M| goto yynewstate; 2469| | 2470| | 2471| |/*-----------------------------------------------------------. 2472| || yydefault -- do the default action for the current state. | 2473| |`-----------------------------------------------------------*/ 2474| 28.8M|yydefault: 2475| 28.8M| yyn = yydefact[yystate]; 2476| 28.8M| if (yyn == 0) ------------------ | Branch (2476:7): [True: 0, False: 28.8M] ------------------ 2477| 0| goto yyerrlab; 2478| 28.8M| goto yyreduce; 2479| | 2480| | 2481| |/*-----------------------------. 2482| || yyreduce -- do a reduction. | 2483| |`-----------------------------*/ 2484| 29.6M|yyreduce: 2485| | /* yyn is the number of a rule to reduce with. */ 2486| 29.6M| yylen = yyr2[yyn]; 2487| | 2488| | /* If YYLEN is nonzero, implement the default value of the action: 2489| | '$$ = $1'. 2490| | 2491| | Otherwise, the following line sets YYVAL to garbage. 2492| | This behavior is undocumented and Bison 2493| | users should not rely upon it. Assigning to YYVAL 2494| | unconditionally makes the parser a bit smaller, and it avoids a 2495| | GCC warning that YYVAL may be used uninitialized. */ 2496| 29.6M| yyval = yyvsp[1-yylen]; 2497| | 2498| | /* Default location. */ 2499| 29.6M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 124| 29.6M| do { \ | | 125| 29.6M| if (N) { \ | | ------------------ | | | Branch (125:9): [True: 29.1M, False: 464k] | | ------------------ | | 126| 29.1M| (Loc).start = YYRHSLOC(Rhs, 1).start; \ | | ------------------ | | | | 1495| 29.1M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 127| 29.1M| (Loc).end = YYRHSLOC(Rhs, N).end; \ | | ------------------ | | | | 1495| 29.1M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 128| 29.1M| } else { \ | | 129| 464k| (Loc).start = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1495| 464k|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 130| 464k| (Loc).end = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1495| 464k|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 131| 464k| } \ | | 132| 29.6M| } while (0) | | ------------------ | | | Branch (132:12): [Folded, False: 29.6M] | | ------------------ ------------------ 2500| 29.6M| yyerror_range[1] = yyloc; 2501| 29.6M| YY_REDUCE_PRINT (yyn); 2502| 29.6M| switch (yyn) 2503| 29.6M| { 2504| 7.65k| case 2: /* TopLevel: Module Imports Query */ ------------------ | Branch (2504:3): [True: 7.65k, False: 29.6M] ------------------ 2505| 7.65k|#line 282 "src/parser.y" 2506| 7.65k| { 2507| 7.65k| *answer = BLOCK((yyvsp[-2].blk), (yyvsp[-1].blk), gen_op_simple(TOP), (yyvsp[0].blk)); ------------------ | | 102| 7.65k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.65k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.65k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 7.65k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 7.65k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 7.65k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2508| 7.65k|} 2509| 7.65k|#line 2510 "src/parser.c" 2510| 7.65k| break; 2511| | 2512| 7.64k| case 3: /* TopLevel: Module Imports FuncDefs */ ------------------ | Branch (2512:3): [True: 7.64k, False: 29.6M] ------------------ 2513| 7.64k|#line 285 "src/parser.y" 2514| 7.64k| { 2515| 7.64k| *answer = BLOCK((yyvsp[-2].blk), (yyvsp[-1].blk), (yyvsp[0].blk)); ------------------ | | 102| 7.64k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.64k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.64k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 7.64k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 7.64k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2516| 7.64k|} 2517| 7.64k|#line 2518 "src/parser.c" 2518| 7.64k| break; 2519| | 2520| 15.3k| case 4: /* Module: %empty */ ------------------ | Branch (2520:3): [True: 15.3k, False: 29.6M] ------------------ 2521| 15.3k|#line 290 "src/parser.y" 2522| 15.3k| { 2523| 15.3k| (yyval.blk) = gen_noop(); 2524| 15.3k|} 2525| 15.3k|#line 2526 "src/parser.c" 2526| 15.3k| break; 2527| | 2528| 0| case 5: /* Module: "module" Query ';' */ ------------------ | Branch (2528:3): [True: 0, False: 29.6M] ------------------ 2529| 0|#line 293 "src/parser.y" 2530| 0| { 2531| 0| if (!block_is_const((yyvsp[-1].blk))) { ------------------ | Branch (2531:7): [True: 0, False: 0] ------------------ 2532| 0| FAIL((yylsp[-1]), "Module metadata must be constant"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 2533| 0| (yyval.blk) = gen_noop(); 2534| 0| block_free((yyvsp[-1].blk)); 2535| 0| } else if (block_const_kind((yyvsp[-1].blk)) != JV_KIND_OBJECT) { ------------------ | Branch (2535:14): [True: 0, False: 0] ------------------ 2536| 0| FAIL((yylsp[-1]), "Module metadata must be an object"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 2537| 0| (yyval.blk) = gen_noop(); 2538| 0| block_free((yyvsp[-1].blk)); 2539| 0| } else { 2540| 0| (yyval.blk) = gen_module((yyvsp[-1].blk)); 2541| 0| } 2542| 0|} 2543| 0|#line 2544 "src/parser.c" 2544| 0| break; 2545| | 2546| 15.3k| case 6: /* Imports: %empty */ ------------------ | Branch (2546:3): [True: 15.3k, False: 29.6M] ------------------ 2547| 15.3k|#line 308 "src/parser.y" 2548| 15.3k| { 2549| 15.3k| (yyval.blk) = gen_noop(); 2550| 15.3k|} 2551| 15.3k|#line 2552 "src/parser.c" 2552| 15.3k| break; 2553| | 2554| 0| case 7: /* Imports: Import Imports */ ------------------ | Branch (2554:3): [True: 0, False: 29.6M] ------------------ 2555| 0|#line 311 "src/parser.y" 2556| 0| { 2557| 0| (yyval.blk) = BLOCK((yyvsp[-1].blk), (yyvsp[0].blk)); ------------------ | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 0|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 0|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2558| 0|} 2559| 0|#line 2560 "src/parser.c" 2560| 0| break; 2561| | 2562| 7.64k| case 8: /* FuncDefs: %empty */ ------------------ | Branch (2562:3): [True: 7.64k, False: 29.6M] ------------------ 2563| 7.64k|#line 316 "src/parser.y" 2564| 7.64k| { 2565| 7.64k| (yyval.blk) = gen_noop(); 2566| 7.64k|} 2567| 7.64k|#line 2568 "src/parser.c" 2568| 7.64k| break; 2569| | 2570| 810k| case 9: /* FuncDefs: FuncDef FuncDefs */ ------------------ | Branch (2570:3): [True: 810k, False: 28.8M] ------------------ 2571| 810k|#line 319 "src/parser.y" 2572| 810k| { 2573| 810k| (yyval.blk) = block_join((yyvsp[-1].blk), (yyvsp[0].blk)); 2574| 810k|} 2575| 810k|#line 2576 "src/parser.c" 2576| 810k| break; 2577| | 2578| 53.8k| case 10: /* Query: FuncDef Query */ ------------------ | Branch (2578:3): [True: 53.8k, False: 29.5M] ------------------ 2579| 53.8k|#line 325 "src/parser.y" 2580| 53.8k| { 2581| 53.8k| (yyval.blk) = block_bind_referenced((yyvsp[-1].blk), (yyvsp[0].blk), OP_IS_CALL_PSEUDO); 2582| 53.8k|} 2583| 53.8k|#line 2584 "src/parser.c" 2584| 53.8k| break; 2585| | 2586| 168k| case 11: /* Query: Expr "as" Patterns '|' Query */ ------------------ | Branch (2586:3): [True: 168k, False: 29.4M] ------------------ 2587| 168k|#line 328 "src/parser.y" 2588| 168k| { 2589| 168k| (yyval.blk) = gen_destructure((yyvsp[-4].blk), (yyvsp[-2].blk), (yyvsp[0].blk)); 2590| 168k|} 2591| 168k|#line 2592 "src/parser.c" 2592| 168k| break; 2593| | 2594| 22.9k| case 12: /* Query: "label" BINDING '|' Query */ ------------------ | Branch (2594:3): [True: 22.9k, False: 29.6M] ------------------ 2595| 22.9k|#line 331 "src/parser.y" 2596| 22.9k| { 2597| 22.9k| jv v = jv_string_fmt("*label-%s", jv_string_value((yyvsp[-2].literal))); 2598| 22.9k| (yyval.blk) = gen_location((yyloc), locations, gen_label(jv_string_value(v), (yyvsp[0].blk))); 2599| 22.9k| jv_free((yyvsp[-2].literal)); 2600| 22.9k| jv_free(v); 2601| 22.9k|} 2602| 22.9k|#line 2603 "src/parser.c" 2603| 22.9k| break; 2604| | 2605| 774k| case 13: /* Query: Query '|' Query */ ------------------ | Branch (2605:3): [True: 774k, False: 28.8M] ------------------ 2606| 774k|#line 337 "src/parser.y" 2607| 774k| { 2608| 774k| (yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk)); 2609| 774k|} 2610| 774k|#line 2611 "src/parser.c" 2611| 774k| break; 2612| | 2613| 139k| case 14: /* Query: Query ',' Query */ ------------------ | Branch (2613:3): [True: 139k, False: 29.4M] ------------------ 2614| 139k|#line 340 "src/parser.y" 2615| 139k| { 2616| 139k| (yyval.blk) = gen_both((yyvsp[-2].blk), (yyvsp[0].blk)); 2617| 139k|} 2618| 139k|#line 2619 "src/parser.c" 2619| 139k| break; 2620| | 2621| 5.14M| case 15: /* Query: Expr */ ------------------ | Branch (2621:3): [True: 5.14M, False: 24.4M] ------------------ 2622| 5.14M|#line 343 "src/parser.y" 2623| 5.14M| { 2624| 5.14M| (yyval.blk) = (yyvsp[0].blk); 2625| 5.14M|} 2626| 5.14M|#line 2627 "src/parser.c" 2627| 5.14M| break; 2628| | 2629| 61.2k| case 16: /* Expr: Expr "//" Expr */ ------------------ | Branch (2629:3): [True: 61.2k, False: 29.5M] ------------------ 2630| 61.2k|#line 349 "src/parser.y" 2631| 61.2k| { 2632| 61.2k| (yyval.blk) = gen_definedor((yyvsp[-2].blk), (yyvsp[0].blk)); 2633| 61.2k|} 2634| 61.2k|#line 2635 "src/parser.c" 2635| 61.2k| break; 2636| | 2637| 15.3k| case 17: /* Expr: Expr '=' Expr */ ------------------ | Branch (2637:3): [True: 15.3k, False: 29.6M] ------------------ 2638| 15.3k|#line 352 "src/parser.y" 2639| 15.3k| { 2640| 15.3k| (yyval.blk) = gen_call("_assign", BLOCK(gen_lambda((yyvsp[-2].blk)), gen_lambda((yyvsp[0].blk)))); ------------------ | | 102| 15.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 15.3k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 15.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 15.3k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2641| 15.3k|} 2642| 15.3k|#line 2643 "src/parser.c" 2643| 15.3k| break; 2644| | 2645| 22.9k| case 18: /* Expr: Expr "or" Expr */ ------------------ | Branch (2645:3): [True: 22.9k, False: 29.6M] ------------------ 2646| 22.9k|#line 355 "src/parser.y" 2647| 22.9k| { 2648| 22.9k| (yyval.blk) = gen_or((yyvsp[-2].blk), (yyvsp[0].blk)); 2649| 22.9k|} 2650| 22.9k|#line 2651 "src/parser.c" 2651| 22.9k| break; 2652| | 2653| 107k| case 19: /* Expr: Expr "and" Expr */ ------------------ | Branch (2653:3): [True: 107k, False: 29.5M] ------------------ 2654| 107k|#line 358 "src/parser.y" 2655| 107k| { 2656| 107k| (yyval.blk) = gen_and((yyvsp[-2].blk), (yyvsp[0].blk)); 2657| 107k|} 2658| 107k|#line 2659 "src/parser.c" 2659| 107k| break; 2660| | 2661| 0| case 20: /* Expr: Expr "//=" Expr */ ------------------ | Branch (2661:3): [True: 0, False: 29.6M] ------------------ 2662| 0|#line 361 "src/parser.y" 2663| 0| { 2664| 0| (yyval.blk) = gen_definedor_assign((yyvsp[-2].blk), (yyvsp[0].blk)); 2665| 0|} 2666| 0|#line 2667 "src/parser.c" 2667| 0| break; 2668| | 2669| 7.73k| case 21: /* Expr: Expr "|=" Expr */ ------------------ | Branch (2669:3): [True: 7.73k, False: 29.6M] ------------------ 2670| 7.73k|#line 364 "src/parser.y" 2671| 7.73k| { 2672| 7.73k| (yyval.blk) = gen_call("_modify", BLOCK(gen_lambda((yyvsp[-2].blk)), gen_lambda((yyvsp[0].blk)))); ------------------ | | 102| 7.73k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.73k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.73k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 7.73k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2673| 7.73k|} 2674| 7.73k|#line 2675 "src/parser.c" 2675| 7.73k| break; 2676| | 2677| 184k| case 22: /* Expr: Expr '+' Expr */ ------------------ | Branch (2677:3): [True: 184k, False: 29.4M] ------------------ 2678| 184k|#line 367 "src/parser.y" 2679| 184k| { 2680| 184k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '+'); 2681| 184k|} 2682| 184k|#line 2683 "src/parser.c" 2683| 184k| break; 2684| | 2685| 7.65k| case 23: /* Expr: Expr "+=" Expr */ ------------------ | Branch (2685:3): [True: 7.65k, False: 29.6M] ------------------ 2686| 7.65k|#line 370 "src/parser.y" 2687| 7.65k| { 2688| 7.65k| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '+'); 2689| 7.65k|} 2690| 7.65k|#line 2691 "src/parser.c" 2691| 7.65k| break; 2692| | 2693| 53.6k| case 24: /* Expr: Expr '-' Expr */ ------------------ | Branch (2693:3): [True: 53.6k, False: 29.5M] ------------------ 2694| 53.6k|#line 373 "src/parser.y" 2695| 53.6k| { 2696| 53.6k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '-'); 2697| 53.6k|} 2698| 53.6k|#line 2699 "src/parser.c" 2699| 53.6k| break; 2700| | 2701| 0| case 25: /* Expr: Expr "-=" Expr */ ------------------ | Branch (2701:3): [True: 0, False: 29.6M] ------------------ 2702| 0|#line 376 "src/parser.y" 2703| 0| { 2704| 0| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '-'); 2705| 0|} 2706| 0|#line 2707 "src/parser.c" 2707| 0| break; 2708| | 2709| 271| case 26: /* Expr: Expr '*' Expr */ ------------------ | Branch (2709:3): [True: 271, False: 29.6M] ------------------ 2710| 271|#line 379 "src/parser.y" 2711| 271| { 2712| 271| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '*'); 2713| 271|} 2714| 271|#line 2715 "src/parser.c" 2715| 271| break; 2716| | 2717| 0| case 27: /* Expr: Expr "*=" Expr */ ------------------ | Branch (2717:3): [True: 0, False: 29.6M] ------------------ 2718| 0|#line 382 "src/parser.y" 2719| 0| { 2720| 0| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '*'); 2721| 0|} 2722| 0|#line 2723 "src/parser.c" 2723| 0| break; 2724| | 2725| 1.64k| case 28: /* Expr: Expr '/' Expr */ ------------------ | Branch (2725:3): [True: 1.64k, False: 29.6M] ------------------ 2726| 1.64k|#line 385 "src/parser.y" 2727| 1.64k| { 2728| 1.64k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '/'); 2729| 1.64k|} 2730| 1.64k|#line 2731 "src/parser.c" 2731| 1.64k| break; 2732| | 2733| 0| case 29: /* Expr: Expr '%' Expr */ ------------------ | Branch (2733:3): [True: 0, False: 29.6M] ------------------ 2734| 0|#line 388 "src/parser.y" 2735| 0| { 2736| 0| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '%'); 2737| 0|} 2738| 0|#line 2739 "src/parser.c" 2739| 0| break; 2740| | 2741| 0| case 30: /* Expr: Expr "/=" Expr */ ------------------ | Branch (2741:3): [True: 0, False: 29.6M] ------------------ 2742| 0|#line 391 "src/parser.y" 2743| 0| { 2744| 0| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '/'); 2745| 0|} 2746| 0|#line 2747 "src/parser.c" 2747| 0| break; 2748| | 2749| 0| case 31: /* Expr: Expr "%=" Expr */ ------------------ | Branch (2749:3): [True: 0, False: 29.6M] ------------------ 2750| 0|#line 394 "src/parser.y" 2751| 0| { 2752| 0| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '%'); 2753| 0|} 2754| 0|#line 2755 "src/parser.c" 2755| 0| break; 2756| | 2757| 290k| case 32: /* Expr: Expr "==" Expr */ ------------------ | Branch (2757:3): [True: 290k, False: 29.3M] ------------------ 2758| 290k|#line 397 "src/parser.y" 2759| 290k| { 2760| 290k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), EQ); ------------------ | | 207| 290k|#define EQ 266 ------------------ 2761| 290k|} 2762| 290k|#line 2763 "src/parser.c" 2763| 290k| break; 2764| | 2765| 45.8k| case 33: /* Expr: Expr "!=" Expr */ ------------------ | Branch (2765:3): [True: 45.8k, False: 29.5M] ------------------ 2766| 45.8k|#line 400 "src/parser.y" 2767| 45.8k| { 2768| 45.8k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), NEQ); ------------------ | | 208| 45.8k|#define NEQ 267 ------------------ 2769| 45.8k|} 2770| 45.8k|#line 2771 "src/parser.c" 2771| 45.8k| break; 2772| | 2773| 46.0k| case 34: /* Expr: Expr '<' Expr */ ------------------ | Branch (2773:3): [True: 46.0k, False: 29.5M] ------------------ 2774| 46.0k|#line 403 "src/parser.y" 2775| 46.0k| { 2776| 46.0k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '<'); 2777| 46.0k|} 2778| 46.0k|#line 2779 "src/parser.c" 2779| 46.0k| break; 2780| | 2781| 107k| case 35: /* Expr: Expr '>' Expr */ ------------------ | Branch (2781:3): [True: 107k, False: 29.5M] ------------------ 2782| 107k|#line 406 "src/parser.y" 2783| 107k| { 2784| 107k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '>'); 2785| 107k|} 2786| 107k|#line 2787 "src/parser.c" 2787| 107k| break; 2788| | 2789| 38.2k| case 36: /* Expr: Expr "<=" Expr */ ------------------ | Branch (2789:3): [True: 38.2k, False: 29.5M] ------------------ 2790| 38.2k|#line 409 "src/parser.y" 2791| 38.2k| { 2792| 38.2k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), LESSEQ); ------------------ | | 235| 38.2k|#define LESSEQ 294 ------------------ 2793| 38.2k|} 2794| 38.2k|#line 2795 "src/parser.c" 2795| 38.2k| break; 2796| | 2797| 21| case 37: /* Expr: Expr ">=" Expr */ ------------------ | Branch (2797:3): [True: 21, False: 29.6M] ------------------ 2798| 21|#line 412 "src/parser.y" 2799| 21| { 2800| 21| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), GREATEREQ); ------------------ | | 236| 21|#define GREATEREQ 295 ------------------ 2801| 21|} 2802| 21|#line 2803 "src/parser.c" 2803| 21| break; 2804| | 2805| 6.53M| case 38: /* Expr: Term */ ------------------ | Branch (2805:3): [True: 6.53M, False: 23.0M] ------------------ 2806| 6.53M|#line 415 "src/parser.y" 2807| 6.53M| { 2808| 6.53M| (yyval.blk) = (yyvsp[0].blk); 2809| 6.53M|} 2810| 6.53M|#line 2811 "src/parser.c" 2811| 6.53M| break; 2812| | 2813| 0| case 39: /* Import: ImportWhat ';' */ ------------------ | Branch (2813:3): [True: 0, False: 29.6M] ------------------ 2814| 0|#line 421 "src/parser.y" 2815| 0| { 2816| 0| (yyval.blk) = (yyvsp[-1].blk); 2817| 0|} 2818| 0|#line 2819 "src/parser.c" 2819| 0| break; 2820| | 2821| 0| case 40: /* Import: ImportWhat Query ';' */ ------------------ | Branch (2821:3): [True: 0, False: 29.6M] ------------------ 2822| 0|#line 424 "src/parser.y" 2823| 0| { 2824| 0| if (!block_is_const((yyvsp[-1].blk))) { ------------------ | Branch (2824:7): [True: 0, False: 0] ------------------ 2825| 0| FAIL((yylsp[-1]), "Module metadata must be constant"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 2826| 0| (yyval.blk) = gen_noop(); 2827| 0| block_free((yyvsp[-2].blk)); 2828| 0| block_free((yyvsp[-1].blk)); 2829| 0| } else if (block_const_kind((yyvsp[-1].blk)) != JV_KIND_OBJECT) { ------------------ | Branch (2829:14): [True: 0, False: 0] ------------------ 2830| 0| FAIL((yylsp[-1]), "Module metadata must be an object"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 2831| 0| (yyval.blk) = gen_noop(); 2832| 0| block_free((yyvsp[-2].blk)); 2833| 0| block_free((yyvsp[-1].blk)); 2834| 0| } else { 2835| 0| (yyval.blk) = gen_import_meta((yyvsp[-2].blk), (yyvsp[-1].blk)); 2836| 0| } 2837| 0|} 2838| 0|#line 2839 "src/parser.c" 2839| 0| break; 2840| | 2841| 0| case 41: /* ImportWhat: "import" ImportFrom "as" BINDING */ ------------------ | Branch (2841:3): [True: 0, False: 29.6M] ------------------ 2842| 0|#line 441 "src/parser.y" 2843| 0| { 2844| 0| (yyval.blk) = gen_import(block_const((yyvsp[-2].blk)), (yyvsp[0].literal), 1); 2845| 0| block_free((yyvsp[-2].blk)); 2846| 0|} 2847| 0|#line 2848 "src/parser.c" 2848| 0| break; 2849| | 2850| 0| case 42: /* ImportWhat: "import" ImportFrom "as" IDENT */ ------------------ | Branch (2850:3): [True: 0, False: 29.6M] ------------------ 2851| 0|#line 445 "src/parser.y" 2852| 0| { 2853| 0| (yyval.blk) = gen_import(block_const((yyvsp[-2].blk)), (yyvsp[0].literal), 0); 2854| 0| block_free((yyvsp[-2].blk)); 2855| 0|} 2856| 0|#line 2857 "src/parser.c" 2857| 0| break; 2858| | 2859| 0| case 43: /* ImportWhat: "include" ImportFrom */ ------------------ | Branch (2859:3): [True: 0, False: 29.6M] ------------------ 2860| 0|#line 449 "src/parser.y" 2861| 0| { 2862| 0| (yyval.blk) = gen_import(block_const((yyvsp[0].blk)), jv_invalid(), 0); 2863| 0| block_free((yyvsp[0].blk)); 2864| 0|} 2865| 0|#line 2866 "src/parser.c" 2866| 0| break; 2867| | 2868| 0| case 44: /* ImportFrom: String */ ------------------ | Branch (2868:3): [True: 0, False: 29.6M] ------------------ 2869| 0|#line 455 "src/parser.y" 2870| 0| { 2871| 0| if (!block_is_const((yyvsp[0].blk))) { ------------------ | Branch (2871:7): [True: 0, False: 0] ------------------ 2872| 0| FAIL((yylsp[0]), "Import path must be constant"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 2873| 0| (yyval.blk) = gen_const(jv_string("")); 2874| 0| block_free((yyvsp[0].blk)); 2875| 0| } else { 2876| 0| (yyval.blk) = (yyvsp[0].blk); 2877| 0| } 2878| 0|} 2879| 0|#line 2880 "src/parser.c" 2880| 0| break; 2881| | 2882| 321k| case 45: /* FuncDef: "def" IDENT ':' Query ';' */ ------------------ | Branch (2882:3): [True: 321k, False: 29.3M] ------------------ 2883| 321k|#line 466 "src/parser.y" 2884| 321k| { 2885| 321k| (yyval.blk) = gen_function(jv_string_value((yyvsp[-3].literal)), gen_noop(), (yyvsp[-1].blk)); 2886| 321k| jv_free((yyvsp[-3].literal)); 2887| 321k|} 2888| 321k|#line 2889 "src/parser.c" 2889| 321k| break; 2890| | 2891| 543k| case 46: /* FuncDef: "def" IDENT '(' Params ')' ':' Query ';' */ ------------------ | Branch (2891:3): [True: 543k, False: 29.0M] ------------------ 2892| 543k|#line 471 "src/parser.y" 2893| 543k| { 2894| 543k| (yyval.blk) = gen_function(jv_string_value((yyvsp[-6].literal)), (yyvsp[-4].blk), (yyvsp[-1].blk)); 2895| 543k| jv_free((yyvsp[-6].literal)); 2896| 543k|} 2897| 543k|#line 2898 "src/parser.c" 2898| 543k| break; 2899| | 2900| 543k| case 47: /* Params: Param */ ------------------ | Branch (2900:3): [True: 543k, False: 29.0M] ------------------ 2901| 543k|#line 477 "src/parser.y" 2902| 543k| { 2903| 543k| (yyval.blk) = (yyvsp[0].blk); 2904| 543k|} 2905| 543k|#line 2906 "src/parser.c" 2906| 543k| break; 2907| | 2908| 244k| case 48: /* Params: Params ';' Param */ ------------------ | Branch (2908:3): [True: 244k, False: 29.3M] ------------------ 2909| 244k|#line 480 "src/parser.y" 2910| 244k| { 2911| 244k| (yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk)); ------------------ | | 102| 244k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 244k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 244k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 244k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2912| 244k|} 2913| 244k|#line 2914 "src/parser.c" 2914| 244k| break; 2915| | 2916| 282k| case 49: /* Param: BINDING */ ------------------ | Branch (2916:3): [True: 282k, False: 29.3M] ------------------ 2917| 282k|#line 485 "src/parser.y" 2918| 282k| { 2919| 282k| (yyval.blk) = gen_param_regular(jv_string_value((yyvsp[0].literal))); 2920| 282k| jv_free((yyvsp[0].literal)); 2921| 282k|} 2922| 282k|#line 2923 "src/parser.c" 2923| 282k| break; 2924| | 2925| 505k| case 50: /* Param: IDENT */ ------------------ | Branch (2925:3): [True: 505k, False: 29.1M] ------------------ 2926| 505k|#line 489 "src/parser.y" 2927| 505k| { 2928| 505k| (yyval.blk) = gen_param(jv_string_value((yyvsp[0].literal))); 2929| 505k| jv_free((yyvsp[0].literal)); 2930| 505k|} 2931| 505k|#line 2932 "src/parser.c" 2932| 505k| break; 2933| | 2934| 67| case 51: /* StringStart: FORMAT QQSTRING_START */ ------------------ | Branch (2934:3): [True: 67, False: 29.6M] ------------------ 2935| 67|#line 496 "src/parser.y" 2936| 67| { 2937| 67| (yyval.literal) = (yyvsp[-1].literal); 2938| 67|} 2939| 67|#line 2940 "src/parser.c" 2940| 67| break; 2941| | 2942| 395k| case 52: /* StringStart: QQSTRING_START */ ------------------ | Branch (2942:3): [True: 395k, False: 29.2M] ------------------ 2943| 395k|#line 499 "src/parser.y" 2944| 395k| { 2945| 395k| (yyval.literal) = jv_string("text"); 2946| 395k|} 2947| 395k|#line 2948 "src/parser.c" 2948| 395k| break; 2949| | 2950| 395k| case 53: /* String: StringStart QQString QQSTRING_END */ ------------------ | Branch (2950:3): [True: 395k, False: 29.2M] ------------------ 2951| 395k|#line 505 "src/parser.y" 2952| 395k| { 2953| 395k| (yyval.blk) = (yyvsp[-1].blk); 2954| 395k| jv_free((yyvsp[-2].literal)); 2955| 395k|} 2956| 395k|#line 2957 "src/parser.c" 2957| 395k| break; 2958| | 2959| 395k| case 54: /* QQString: %empty */ ------------------ | Branch (2959:3): [True: 395k, False: 29.2M] ------------------ 2960| 395k|#line 512 "src/parser.y" 2961| 395k| { 2962| 395k| (yyval.blk) = gen_const(jv_string("")); 2963| 395k|} 2964| 395k|#line 2965 "src/parser.c" 2965| 395k| break; 2966| | 2967| 364k| case 55: /* QQString: QQString QQSTRING_TEXT */ ------------------ | Branch (2967:3): [True: 364k, False: 29.2M] ------------------ 2968| 364k|#line 515 "src/parser.y" 2969| 364k| { 2970| 364k| (yyval.blk) = gen_binop((yyvsp[-1].blk), gen_const((yyvsp[0].literal)), '+'); 2971| 364k|} 2972| 364k|#line 2973 "src/parser.c" 2973| 364k| break; 2974| | 2975| 804| case 56: /* QQString: QQString QQSTRING_INTERP_START Query QQSTRING_INTERP_END */ ------------------ | Branch (2975:3): [True: 804, False: 29.6M] ------------------ 2976| 804|#line 518 "src/parser.y" 2977| 804| { 2978| 804| (yyval.blk) = gen_binop((yyvsp[-3].blk), gen_format((yyvsp[-1].blk), jv_copy((yyvsp[-4].literal))), '+'); 2979| 804|} 2980| 804|#line 2981 "src/parser.c" 2981| 804| break; 2982| | 2983| 91.7k| case 57: /* ElseBody: "elif" Query "then" Query ElseBody */ ------------------ | Branch (2983:3): [True: 91.7k, False: 29.5M] ------------------ 2984| 91.7k|#line 524 "src/parser.y" 2985| 91.7k| { 2986| 91.7k| (yyval.blk) = gen_cond((yyvsp[-3].blk), (yyvsp[-1].blk), (yyvsp[0].blk)); 2987| 91.7k|} 2988| 91.7k|#line 2989 "src/parser.c" 2989| 91.7k| break; 2990| | 2991| 222k| case 58: /* ElseBody: "else" Query "end" */ ------------------ | Branch (2991:3): [True: 222k, False: 29.4M] ------------------ 2992| 222k|#line 527 "src/parser.y" 2993| 222k| { 2994| 222k| (yyval.blk) = (yyvsp[-1].blk); 2995| 222k|} 2996| 222k|#line 2997 "src/parser.c" 2997| 222k| break; 2998| | 2999| 15.2k| case 59: /* ElseBody: "end" */ ------------------ | Branch (2999:3): [True: 15.2k, False: 29.6M] ------------------ 3000| 15.2k|#line 530 "src/parser.y" 3001| 15.2k| { 3002| 15.2k| (yyval.blk) = gen_noop(); 3003| 15.2k|} 3004| 15.2k|#line 3005 "src/parser.c" 3005| 15.2k| break; 3006| | 3007| 793k| case 60: /* Term: '.' */ ------------------ | Branch (3007:3): [True: 793k, False: 28.8M] ------------------ 3008| 793k|#line 536 "src/parser.y" 3009| 793k| { 3010| 793k| (yyval.blk) = gen_noop(); 3011| 793k|} 3012| 793k|#line 3013 "src/parser.c" 3013| 793k| break; 3014| | 3015| 17| case 61: /* Term: ".." */ ------------------ | Branch (3015:3): [True: 17, False: 29.6M] ------------------ 3016| 17|#line 539 "src/parser.y" 3017| 17| { 3018| 17| (yyval.blk) = gen_call("recurse", gen_noop()); 3019| 17|} 3020| 17|#line 3021 "src/parser.c" 3021| 17| break; 3022| | 3023| 22.9k| case 62: /* Term: "break" BINDING */ ------------------ | Branch (3023:3): [True: 22.9k, False: 29.6M] ------------------ 3024| 22.9k|#line 542 "src/parser.y" 3025| 22.9k| { 3026| 22.9k| jv v = jv_string_fmt("*label-%s", jv_string_value((yyvsp[0].literal))); // impossible symbol 3027| 22.9k| (yyval.blk) = gen_location((yyloc), locations, 3028| 22.9k| BLOCK(gen_op_unbound(LOADV, jv_string_value(v)), ------------------ | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 22.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3029| 22.9k| gen_call("error", gen_noop()))); 3030| 22.9k| jv_free(v); 3031| 22.9k| jv_free((yyvsp[0].literal)); 3032| 22.9k|} 3033| 22.9k|#line 3034 "src/parser.c" 3034| 22.9k| break; 3035| | 3036| 0| case 63: /* Term: "break" error */ ------------------ | Branch (3036:3): [True: 0, False: 29.6M] ------------------ 3037| 0|#line 550 "src/parser.y" 3038| 0| { 3039| 0| FAIL((yyloc), "break requires a label to break to"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3040| 0| (yyval.blk) = gen_noop(); 3041| 0|} 3042| 0|#line 3043 "src/parser.c" 3043| 0| break; 3044| | 3045| 0| case 64: /* Term: Term FIELD '?' */ ------------------ | Branch (3045:3): [True: 0, False: 29.6M] ------------------ 3046| 0|#line 554 "src/parser.y" 3047| 0| { 3048| 0| (yyval.blk) = gen_index_opt((yyvsp[-2].blk), gen_const((yyvsp[-1].literal))); 3049| 0|} 3050| 0|#line 3051 "src/parser.c" 3051| 0| break; 3052| | 3053| 13| case 65: /* Term: FIELD '?' */ ------------------ | Branch (3053:3): [True: 13, False: 29.6M] ------------------ 3054| 13|#line 557 "src/parser.y" 3055| 13| { 3056| 13| (yyval.blk) = gen_index_opt(gen_noop(), gen_const((yyvsp[-1].literal))); 3057| 13|} 3058| 13|#line 3059 "src/parser.c" 3059| 13| break; 3060| | 3061| 0| case 66: /* Term: Term '.' String '?' */ ------------------ | Branch (3061:3): [True: 0, False: 29.6M] ------------------ 3062| 0|#line 560 "src/parser.y" 3063| 0| { 3064| 0| (yyval.blk) = gen_index_opt((yyvsp[-3].blk), (yyvsp[-1].blk)); 3065| 0|} 3066| 0|#line 3067 "src/parser.c" 3067| 0| break; 3068| | 3069| 0| case 67: /* Term: '.' String '?' */ ------------------ | Branch (3069:3): [True: 0, False: 29.6M] ------------------ 3070| 0|#line 563 "src/parser.y" 3071| 0| { 3072| 0| (yyval.blk) = gen_index_opt(gen_noop(), (yyvsp[-1].blk)); 3073| 0|} 3074| 0|#line 3075 "src/parser.c" 3075| 0| break; 3076| | 3077| 10| case 68: /* Term: Term FIELD */ ------------------ | Branch (3077:3): [True: 10, False: 29.6M] ------------------ 3078| 10|#line 566 "src/parser.y" 3079| 10| { 3080| 10| (yyval.blk) = gen_index((yyvsp[-1].blk), gen_const((yyvsp[0].literal))); 3081| 10|} 3082| 10|#line 3083 "src/parser.c" 3083| 10| break; 3084| | 3085| 230k| case 69: /* Term: FIELD */ ------------------ | Branch (3085:3): [True: 230k, False: 29.4M] ------------------ 3086| 230k|#line 569 "src/parser.y" 3087| 230k| { 3088| 230k| (yyval.blk) = gen_index(gen_noop(), gen_const((yyvsp[0].literal))); 3089| 230k|} 3090| 230k|#line 3091 "src/parser.c" 3091| 230k| break; 3092| | 3093| 0| case 70: /* Term: Term '.' String */ ------------------ | Branch (3093:3): [True: 0, False: 29.6M] ------------------ 3094| 0|#line 572 "src/parser.y" 3095| 0| { 3096| 0| (yyval.blk) = gen_index((yyvsp[-2].blk), (yyvsp[0].blk)); 3097| 0|} 3098| 0|#line 3099 "src/parser.c" 3099| 0| break; 3100| | 3101| 0| case 71: /* Term: '.' String */ ------------------ | Branch (3101:3): [True: 0, False: 29.6M] ------------------ 3102| 0|#line 575 "src/parser.y" 3103| 0| { 3104| 0| (yyval.blk) = gen_index(gen_noop(), (yyvsp[0].blk)); 3105| 0|} 3106| 0|#line 3107 "src/parser.c" 3107| 0| break; 3108| | 3109| 0| case 72: /* Term: '.' error */ ------------------ | Branch (3109:3): [True: 0, False: 29.6M] ------------------ 3110| 0|#line 578 "src/parser.y" 3111| 0| { 3112| 0| FAIL((yyloc), "try .[\"field\"] instead of .field for unusually named fields"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3113| 0| (yyval.blk) = gen_noop(); 3114| 0|} 3115| 0|#line 3116 "src/parser.c" 3116| 0| break; 3117| | 3118| 0| case 73: /* Term: '.' IDENT error */ ------------------ | Branch (3118:3): [True: 0, False: 29.6M] ------------------ 3119| 0|#line 582 "src/parser.y" 3120| 0| { 3121| 0| jv_free((yyvsp[-1].literal)); 3122| 0| FAIL((yyloc), "try .[\"field\"] instead of .field for unusually named fields"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3123| 0| (yyval.blk) = gen_noop(); 3124| 0|} 3125| 0|#line 3126 "src/parser.c" 3126| 0| break; 3127| | 3128| 2| case 74: /* Term: Term '[' Query ']' '?' */ ------------------ | Branch (3128:3): [True: 2, False: 29.6M] ------------------ 3129| 2|#line 588 "src/parser.y" 3130| 2| { 3131| 2| (yyval.blk) = gen_index_opt((yyvsp[-4].blk), (yyvsp[-2].blk)); 3132| 2|} 3133| 2|#line 3134 "src/parser.c" 3134| 2| break; 3135| | 3136| 291k| case 75: /* Term: Term '[' Query ']' */ ------------------ | Branch (3136:3): [True: 291k, False: 29.3M] ------------------ 3137| 291k|#line 591 "src/parser.y" 3138| 291k| { 3139| 291k| (yyval.blk) = gen_index((yyvsp[-3].blk), (yyvsp[-1].blk)); 3140| 291k|} 3141| 291k|#line 3142 "src/parser.c" 3142| 291k| break; 3143| | 3144| 0| case 76: /* Term: Term '.' '[' Query ']' '?' */ ------------------ | Branch (3144:3): [True: 0, False: 29.6M] ------------------ 3145| 0|#line 594 "src/parser.y" 3146| 0| { 3147| 0| (yyval.blk) = gen_index_opt((yyvsp[-5].blk), (yyvsp[-2].blk)); 3148| 0|} 3149| 0|#line 3150 "src/parser.c" 3150| 0| break; 3151| | 3152| 0| case 77: /* Term: Term '.' '[' Query ']' */ ------------------ | Branch (3152:3): [True: 0, False: 29.6M] ------------------ 3153| 0|#line 597 "src/parser.y" 3154| 0| { 3155| 0| (yyval.blk) = gen_index((yyvsp[-4].blk), (yyvsp[-1].blk)); 3156| 0|} 3157| 0|#line 3158 "src/parser.c" 3158| 0| break; 3159| | 3160| 22.9k| case 78: /* Term: Term '[' ']' '?' */ ------------------ | Branch (3160:3): [True: 22.9k, False: 29.6M] ------------------ 3161| 22.9k|#line 600 "src/parser.y" 3162| 22.9k| { 3163| 22.9k| (yyval.blk) = block_join((yyvsp[-3].blk), gen_op_simple(EACH_OPT)); 3164| 22.9k|} 3165| 22.9k|#line 3166 "src/parser.c" 3166| 22.9k| break; 3167| | 3168| 146k| case 79: /* Term: Term '[' ']' */ ------------------ | Branch (3168:3): [True: 146k, False: 29.4M] ------------------ 3169| 146k|#line 603 "src/parser.y" 3170| 146k| { 3171| 146k| (yyval.blk) = block_join((yyvsp[-2].blk), gen_op_simple(EACH)); 3172| 146k|} 3173| 146k|#line 3174 "src/parser.c" 3174| 146k| break; 3175| | 3176| 0| case 80: /* Term: Term '.' '[' ']' '?' */ ------------------ | Branch (3176:3): [True: 0, False: 29.6M] ------------------ 3177| 0|#line 606 "src/parser.y" 3178| 0| { 3179| 0| (yyval.blk) = block_join((yyvsp[-4].blk), gen_op_simple(EACH_OPT)); 3180| 0|} 3181| 0|#line 3182 "src/parser.c" 3182| 0| break; 3183| | 3184| 0| case 81: /* Term: Term '.' '[' ']' */ ------------------ | Branch (3184:3): [True: 0, False: 29.6M] ------------------ 3185| 0|#line 609 "src/parser.y" 3186| 0| { 3187| 0| (yyval.blk) = block_join((yyvsp[-3].blk), gen_op_simple(EACH)); 3188| 0|} 3189| 0|#line 3190 "src/parser.c" 3190| 0| break; 3191| | 3192| 0| case 82: /* Term: Term '[' Query ':' Query ']' '?' */ ------------------ | Branch (3192:3): [True: 0, False: 29.6M] ------------------ 3193| 0|#line 612 "src/parser.y" 3194| 0| { 3195| 0| (yyval.blk) = gen_slice_index((yyvsp[-6].blk), (yyvsp[-4].blk), (yyvsp[-2].blk), INDEX_OPT); 3196| 0|} 3197| 0|#line 3198 "src/parser.c" 3198| 0| break; 3199| | 3200| 0| case 83: /* Term: Term '[' Query ':' ']' '?' */ ------------------ | Branch (3200:3): [True: 0, False: 29.6M] ------------------ 3201| 0|#line 615 "src/parser.y" 3202| 0| { 3203| 0| (yyval.blk) = gen_slice_index((yyvsp[-5].blk), (yyvsp[-3].blk), gen_const(jv_null()), INDEX_OPT); 3204| 0|} 3205| 0|#line 3206 "src/parser.c" 3206| 0| break; 3207| | 3208| 0| case 84: /* Term: Term '[' ':' Query ']' '?' */ ------------------ | Branch (3208:3): [True: 0, False: 29.6M] ------------------ 3209| 0|#line 618 "src/parser.y" 3210| 0| { 3211| 0| (yyval.blk) = gen_slice_index((yyvsp[-5].blk), gen_const(jv_null()), (yyvsp[-2].blk), INDEX_OPT); 3212| 0|} 3213| 0|#line 3214 "src/parser.c" 3214| 0| break; 3215| | 3216| 7.65k| case 85: /* Term: Term '[' Query ':' Query ']' */ ------------------ | Branch (3216:3): [True: 7.65k, False: 29.6M] ------------------ 3217| 7.65k|#line 621 "src/parser.y" 3218| 7.65k| { 3219| 7.65k| (yyval.blk) = gen_slice_index((yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk), INDEX); 3220| 7.65k|} 3221| 7.65k|#line 3222 "src/parser.c" 3222| 7.65k| break; 3223| | 3224| 38.2k| case 86: /* Term: Term '[' Query ':' ']' */ ------------------ | Branch (3224:3): [True: 38.2k, False: 29.5M] ------------------ 3225| 38.2k|#line 624 "src/parser.y" 3226| 38.2k| { 3227| 38.2k| (yyval.blk) = gen_slice_index((yyvsp[-4].blk), (yyvsp[-2].blk), gen_const(jv_null()), INDEX); 3228| 38.2k|} 3229| 38.2k|#line 3230 "src/parser.c" 3230| 38.2k| break; 3231| | 3232| 7.65k| case 87: /* Term: Term '[' ':' Query ']' */ ------------------ | Branch (3232:3): [True: 7.65k, False: 29.6M] ------------------ 3233| 7.65k|#line 627 "src/parser.y" 3234| 7.65k| { 3235| 7.65k| (yyval.blk) = gen_slice_index((yyvsp[-4].blk), gen_const(jv_null()), (yyvsp[-1].blk), INDEX); 3236| 7.65k|} 3237| 7.65k|#line 3238 "src/parser.c" 3238| 7.65k| break; 3239| | 3240| 229| case 88: /* Term: Term '?' */ ------------------ | Branch (3240:3): [True: 229, False: 29.6M] ------------------ 3241| 229|#line 630 "src/parser.y" 3242| 229| { 3243| 229| (yyval.blk) = gen_try((yyvsp[-1].blk), gen_op_simple(BACKTRACK)); 3244| 229|} 3245| 229|#line 3246 "src/parser.c" 3246| 229| break; 3247| | 3248| 554k| case 89: /* Term: LITERAL */ ------------------ | Branch (3248:3): [True: 554k, False: 29.0M] ------------------ 3249| 554k|#line 633 "src/parser.y" 3250| 554k| { 3251| 554k| (yyval.blk) = gen_const((yyvsp[0].literal)); 3252| 554k|} 3253| 554k|#line 3254 "src/parser.c" 3254| 554k| break; 3255| | 3256| 395k| case 90: /* Term: String */ ------------------ | Branch (3256:3): [True: 395k, False: 29.2M] ------------------ 3257| 395k|#line 636 "src/parser.y" 3258| 395k| { 3259| 395k| (yyval.blk) = (yyvsp[0].blk); 3260| 395k|} 3261| 395k|#line 3262 "src/parser.c" 3262| 395k| break; 3263| | 3264| 162| case 91: /* Term: FORMAT */ ------------------ | Branch (3264:3): [True: 162, False: 29.6M] ------------------ 3265| 162|#line 639 "src/parser.y" 3266| 162| { 3267| 162| (yyval.blk) = gen_format(gen_noop(), (yyvsp[0].literal)); 3268| 162|} 3269| 162|#line 3270 "src/parser.c" 3270| 162| break; 3271| | 3272| 30.6k| case 92: /* Term: '-' Term */ ------------------ | Branch (3272:3): [True: 30.6k, False: 29.6M] ------------------ 3273| 30.6k|#line 642 "src/parser.y" 3274| 30.6k| { 3275| 30.6k| (yyval.blk) = BLOCK((yyvsp[0].blk), gen_call("_negate", gen_noop())); ------------------ | | 102| 30.6k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 30.6k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 30.6k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 30.6k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3276| 30.6k|} 3277| 30.6k|#line 3278 "src/parser.c" 3278| 30.6k| break; 3279| | 3280| 298k| case 93: /* Term: '(' Query ')' */ ------------------ | Branch (3280:3): [True: 298k, False: 29.3M] ------------------ 3281| 298k|#line 645 "src/parser.y" 3282| 298k| { 3283| 298k| (yyval.blk) = (yyvsp[-1].blk); 3284| 298k|} 3285| 298k|#line 3286 "src/parser.c" 3286| 298k| break; 3287| | 3288| 240k| case 94: /* Term: '[' Query ']' */ ------------------ | Branch (3288:3): [True: 240k, False: 29.3M] ------------------ 3289| 240k|#line 648 "src/parser.y" 3290| 240k| { 3291| 240k| (yyval.blk) = gen_collect((yyvsp[-1].blk)); 3292| 240k|} 3293| 240k|#line 3294 "src/parser.c" 3294| 240k| break; 3295| | 3296| 30.5k| case 95: /* Term: '[' ']' */ ------------------ | Branch (3296:3): [True: 30.5k, False: 29.6M] ------------------ 3297| 30.5k|#line 651 "src/parser.y" 3298| 30.5k| { 3299| 30.5k| (yyval.blk) = gen_const(jv_array()); 3300| 30.5k|} 3301| 30.5k|#line 3302 "src/parser.c" 3302| 30.5k| break; 3303| | 3304| 84.2k| case 96: /* Term: '{' DictPairs '}' */ ------------------ | Branch (3304:3): [True: 84.2k, False: 29.5M] ------------------ 3305| 84.2k|#line 654 "src/parser.y" 3306| 84.2k| { 3307| 84.2k| block o = gen_const_object((yyvsp[-1].blk)); 3308| 84.2k| if (o.first != NULL) ------------------ | Branch (3308:7): [True: 45.9k, False: 38.2k] ------------------ 3309| 45.9k| (yyval.blk) = o; 3310| 38.2k| else 3311| 38.2k| (yyval.blk) = BLOCK(gen_subexp(gen_const(jv_object())), (yyvsp[-1].blk), gen_op_simple(POP)); ------------------ | | 102| 38.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 38.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 38.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 38.2k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 38.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3312| 84.2k|} 3313| 84.2k|#line 3314 "src/parser.c" 3314| 84.2k| break; 3315| | 3316| 92.4k| case 97: /* Term: "reduce" Expr "as" Patterns '(' Query ';' Query ')' */ ------------------ | Branch (3316:3): [True: 92.4k, False: 29.5M] ------------------ 3317| 92.4k|#line 661 "src/parser.y" 3318| 92.4k| { 3319| 92.4k| (yyval.blk) = gen_reduce((yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk)); 3320| 92.4k|} 3321| 92.4k|#line 3322 "src/parser.c" 3322| 92.4k| break; 3323| | 3324| 22.9k| case 98: /* Term: "foreach" Expr "as" Patterns '(' Query ';' Query ';' Query ')' */ ------------------ | Branch (3324:3): [True: 22.9k, False: 29.6M] ------------------ 3325| 22.9k|#line 664 "src/parser.y" 3326| 22.9k| { 3327| 22.9k| (yyval.blk) = gen_foreach((yyvsp[-9].blk), (yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk)); 3328| 22.9k|} 3329| 22.9k|#line 3330 "src/parser.c" 3330| 22.9k| break; 3331| | 3332| 7.64k| case 99: /* Term: "foreach" Expr "as" Patterns '(' Query ';' Query ')' */ ------------------ | Branch (3332:3): [True: 7.64k, False: 29.6M] ------------------ 3333| 7.64k|#line 667 "src/parser.y" 3334| 7.64k| { 3335| 7.64k| (yyval.blk) = gen_foreach((yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk), gen_noop()); 3336| 7.64k|} 3337| 7.64k|#line 3338 "src/parser.c" 3338| 7.64k| break; 3339| | 3340| 237k| case 100: /* Term: "if" Query "then" Query ElseBody */ ------------------ | Branch (3340:3): [True: 237k, False: 29.3M] ------------------ 3341| 237k|#line 670 "src/parser.y" 3342| 237k| { 3343| 237k| (yyval.blk) = gen_cond((yyvsp[-3].blk), (yyvsp[-1].blk), (yyvsp[0].blk)); 3344| 237k|} 3345| 237k|#line 3346 "src/parser.c" 3346| 237k| break; 3347| | 3348| 0| case 101: /* Term: "if" Query "then" error */ ------------------ | Branch (3348:3): [True: 0, False: 29.6M] ------------------ 3349| 0|#line 673 "src/parser.y" 3350| 0| { 3351| 0| FAIL((yyloc), "Possibly unterminated 'if' statement"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3352| 0| (yyval.blk) = (yyvsp[-2].blk); 3353| 0|} 3354| 0|#line 3355 "src/parser.c" 3355| 0| break; 3356| | 3357| 7.64k| case 102: /* Term: "try" Expr "catch" Expr */ ------------------ | Branch (3357:3): [True: 7.64k, False: 29.6M] ------------------ 3358| 7.64k|#line 677 "src/parser.y" 3359| 7.64k| { 3360| 7.64k| (yyval.blk) = gen_try((yyvsp[-2].blk), (yyvsp[0].blk)); 3361| 7.64k|} 3362| 7.64k|#line 3363 "src/parser.c" 3363| 7.64k| break; 3364| | 3365| 0| case 103: /* Term: "try" Expr "catch" error */ ------------------ | Branch (3365:3): [True: 0, False: 29.6M] ------------------ 3366| 0|#line 680 "src/parser.y" 3367| 0| { 3368| 0| FAIL((yyloc), "Possibly unterminated 'try' statement"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3369| 0| (yyval.blk) = (yyvsp[-2].blk); 3370| 0|} 3371| 0|#line 3372 "src/parser.c" 3372| 0| break; 3373| | 3374| 11| case 104: /* Term: "try" Expr */ ------------------ | Branch (3374:3): [True: 11, False: 29.6M] ------------------ 3375| 11|#line 684 "src/parser.y" 3376| 11| { 3377| 11| (yyval.blk) = gen_try((yyvsp[0].blk), gen_op_simple(BACKTRACK)); 3378| 11|} 3379| 11|#line 3380 "src/parser.c" 3380| 11| break; 3381| | 3382| 22.9k| case 105: /* Term: '$' '$' '$' BINDING */ ------------------ | Branch (3382:3): [True: 22.9k, False: 29.6M] ------------------ 3383| 22.9k|#line 702 "src/parser.y" 3384| 22.9k| { 3385| 22.9k| (yyval.blk) = gen_location((yyloc), locations, gen_op_unbound(LOADVN, jv_string_value((yyvsp[0].literal)))); 3386| 22.9k| jv_free((yyvsp[0].literal)); 3387| 22.9k|} 3388| 22.9k|#line 3389 "src/parser.c" 3389| 22.9k| break; 3390| | 3391| 1.11M| case 106: /* Term: BINDING */ ------------------ | Branch (3391:3): [True: 1.11M, False: 28.5M] ------------------ 3392| 1.11M|#line 706 "src/parser.y" 3393| 1.11M| { 3394| 1.11M| (yyval.blk) = gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[0].literal)))); 3395| 1.11M| jv_free((yyvsp[0].literal)); 3396| 1.11M|} 3397| 1.11M|#line 3398 "src/parser.c" 3398| 1.11M| break; 3399| | 3400| 0| case 107: /* Term: "$__loc__" */ ------------------ | Branch (3400:3): [True: 0, False: 29.6M] ------------------ 3401| 0|#line 710 "src/parser.y" 3402| 0| { 3403| 0| (yyval.blk) = gen_loc_object(&(yyloc), locations); 3404| 0|} 3405| 0|#line 3406 "src/parser.c" 3406| 0| break; 3407| | 3408| 1.45M| case 108: /* Term: IDENT */ ------------------ | Branch (3408:3): [True: 1.45M, False: 28.1M] ------------------ 3409| 1.45M|#line 713 "src/parser.y" 3410| 1.45M| { 3411| 1.45M| const char *s = jv_string_value((yyvsp[0].literal)); 3412| 1.45M| if (strcmp(s, "false") == 0) ------------------ | Branch (3412:7): [True: 22.9k, False: 1.43M] ------------------ 3413| 22.9k| (yyval.blk) = gen_const(jv_false()); 3414| 1.43M| else if (strcmp(s, "true") == 0) ------------------ | Branch (3414:12): [True: 15.3k, False: 1.41M] ------------------ 3415| 15.3k| (yyval.blk) = gen_const(jv_true()); 3416| 1.41M| else if (strcmp(s, "null") == 0) ------------------ | Branch (3416:12): [True: 160k, False: 1.25M] ------------------ 3417| 160k| (yyval.blk) = gen_const(jv_null()); 3418| 1.25M| else 3419| 1.25M| (yyval.blk) = gen_location((yyloc), locations, gen_call(s, gen_noop())); 3420| 1.45M| jv_free((yyvsp[0].literal)); 3421| 1.45M|} 3422| 1.45M|#line 3423 "src/parser.c" 3423| 1.45M| break; 3424| | 3425| 929k| case 109: /* Term: IDENT '(' Args ')' */ ------------------ | Branch (3425:3): [True: 929k, False: 28.7M] ------------------ 3426| 929k|#line 725 "src/parser.y" 3427| 929k| { 3428| 929k| (yyval.blk) = gen_call(jv_string_value((yyvsp[-3].literal)), (yyvsp[-1].blk)); 3429| 929k| (yyval.blk) = gen_location((yylsp[-3]), locations, (yyval.blk)); 3430| 929k| jv_free((yyvsp[-3].literal)); 3431| 929k|} 3432| 929k|#line 3433 "src/parser.c" 3433| 929k| break; 3434| | 3435| 0| case 110: /* Term: '(' error ')' */ ------------------ | Branch (3435:3): [True: 0, False: 29.6M] ------------------ 3436| 0|#line 730 "src/parser.y" 3437| 0| { (yyval.blk) = gen_noop(); } 3438| 0|#line 3439 "src/parser.c" 3439| 0| break; 3440| | 3441| 0| case 111: /* Term: '[' error ']' */ ------------------ | Branch (3441:3): [True: 0, False: 29.6M] ------------------ 3442| 0|#line 731 "src/parser.y" 3443| 0| { (yyval.blk) = gen_noop(); } 3444| 0|#line 3445 "src/parser.c" 3445| 0| break; 3446| | 3447| 0| case 112: /* Term: Term '[' error ']' */ ------------------ | Branch (3447:3): [True: 0, False: 29.6M] ------------------ 3448| 0|#line 732 "src/parser.y" 3449| 0| { (yyval.blk) = (yyvsp[-3].blk); } 3450| 0|#line 3451 "src/parser.c" 3451| 0| break; 3452| | 3453| 0| case 113: /* Term: '{' error '}' */ ------------------ | Branch (3453:3): [True: 0, False: 29.6M] ------------------ 3454| 0|#line 733 "src/parser.y" 3455| 0| { (yyval.blk) = gen_noop(); } 3456| 0|#line 3457 "src/parser.c" 3457| 0| break; 3458| | 3459| 929k| case 114: /* Args: Arg */ ------------------ | Branch (3459:3): [True: 929k, False: 28.7M] ------------------ 3460| 929k|#line 736 "src/parser.y" 3461| 929k| { 3462| 929k| (yyval.blk) = (yyvsp[0].blk); 3463| 929k|} 3464| 929k|#line 3465 "src/parser.c" 3465| 929k| break; 3466| | 3467| 368k| case 115: /* Args: Args ';' Arg */ ------------------ | Branch (3467:3): [True: 368k, False: 29.2M] ------------------ 3468| 368k|#line 739 "src/parser.y" 3469| 368k| { 3470| 368k| (yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk)); ------------------ | | 102| 368k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 368k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 368k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 368k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3471| 368k|} 3472| 368k|#line 3473 "src/parser.c" 3473| 368k| break; 3474| | 3475| 1.29M| case 116: /* Arg: Query */ ------------------ | Branch (3475:3): [True: 1.29M, False: 28.3M] ------------------ 3476| 1.29M|#line 744 "src/parser.y" 3477| 1.29M| { 3478| 1.29M| (yyval.blk) = gen_lambda((yyvsp[0].blk)); 3479| 1.29M|} 3480| 1.29M|#line 3481 "src/parser.c" 3481| 1.29M| break; 3482| | 3483| 0| case 117: /* RepPatterns: RepPatterns "?//" Pattern */ ------------------ | Branch (3483:3): [True: 0, False: 29.6M] ------------------ 3484| 0|#line 749 "src/parser.y" 3485| 0| { 3486| 0| (yyval.blk) = BLOCK((yyvsp[-2].blk), gen_destructure_alt((yyvsp[0].blk))); ------------------ | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 0|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 0|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3487| 0|} 3488| 0|#line 3489 "src/parser.c" 3489| 0| break; 3490| | 3491| 22| case 118: /* RepPatterns: Pattern */ ------------------ | Branch (3491:3): [True: 22, False: 29.6M] ------------------ 3492| 22|#line 752 "src/parser.y" 3493| 22| { 3494| 22| (yyval.blk) = gen_destructure_alt((yyvsp[0].blk)); 3495| 22|} 3496| 22|#line 3497 "src/parser.c" 3497| 22| break; 3498| | 3499| 22| case 119: /* Patterns: RepPatterns "?//" Pattern */ ------------------ | Branch (3499:3): [True: 22, False: 29.6M] ------------------ 3500| 22|#line 757 "src/parser.y" 3501| 22| { 3502| 22| (yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk)); ------------------ | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 22|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 22| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 22|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3503| 22|} 3504| 22|#line 3505 "src/parser.c" 3505| 22| break; 3506| | 3507| 291k| case 120: /* Patterns: Pattern */ ------------------ | Branch (3507:3): [True: 291k, False: 29.3M] ------------------ 3508| 291k|#line 760 "src/parser.y" 3509| 291k| { 3510| 291k| (yyval.blk) = (yyvsp[0].blk); 3511| 291k|} 3512| 291k|#line 3513 "src/parser.c" 3513| 291k| break; 3514| | 3515| 284k| case 121: /* Pattern: BINDING */ ------------------ | Branch (3515:3): [True: 284k, False: 29.3M] ------------------ 3516| 284k|#line 765 "src/parser.y" 3517| 284k| { 3518| 284k| (yyval.blk) = gen_op_unbound(STOREV, jv_string_value((yyvsp[0].literal))); 3519| 284k| jv_free((yyvsp[0].literal)); 3520| 284k|} 3521| 284k|#line 3522 "src/parser.c" 3522| 284k| break; 3523| | 3524| 46| case 122: /* Pattern: '[' ArrayPats ']' */ ------------------ | Branch (3524:3): [True: 46, False: 29.6M] ------------------ 3525| 46|#line 769 "src/parser.y" 3526| 46| { 3527| 46| (yyval.blk) = BLOCK((yyvsp[-1].blk), gen_op_simple(POP)); ------------------ | | 102| 46| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 46|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 46| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 46|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3528| 46|} 3529| 46|#line 3530 "src/parser.c" 3530| 46| break; 3531| | 3532| 7.71k| case 123: /* Pattern: '{' ObjPats '}' */ ------------------ | Branch (3532:3): [True: 7.71k, False: 29.6M] ------------------ 3533| 7.71k|#line 772 "src/parser.y" 3534| 7.71k| { 3535| 7.71k| (yyval.blk) = BLOCK((yyvsp[-1].blk), gen_op_simple(POP)); ------------------ | | 102| 7.71k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.71k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.71k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 7.71k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3536| 7.71k|} 3537| 7.71k|#line 3538 "src/parser.c" 3538| 7.71k| break; 3539| | 3540| 46| case 124: /* ArrayPats: Pattern */ ------------------ | Branch (3540:3): [True: 46, False: 29.6M] ------------------ 3541| 46|#line 777 "src/parser.y" 3542| 46| { 3543| 46| (yyval.blk) = gen_array_matcher(gen_noop(), (yyvsp[0].blk)); 3544| 46|} 3545| 46|#line 3546 "src/parser.c" 3546| 46| break; 3547| | 3548| 26| case 125: /* ArrayPats: ArrayPats ',' Pattern */ ------------------ | Branch (3548:3): [True: 26, False: 29.6M] ------------------ 3549| 26|#line 780 "src/parser.y" 3550| 26| { 3551| 26| (yyval.blk) = gen_array_matcher((yyvsp[-2].blk), (yyvsp[0].blk)); 3552| 26|} 3553| 26|#line 3554 "src/parser.c" 3554| 26| break; 3555| | 3556| 7.71k| case 126: /* ObjPats: ObjPat */ ------------------ | Branch (3556:3): [True: 7.71k, False: 29.6M] ------------------ 3557| 7.71k|#line 785 "src/parser.y" 3558| 7.71k| { 3559| 7.71k| (yyval.blk) = (yyvsp[0].blk); 3560| 7.71k|} 3561| 7.71k|#line 3562 "src/parser.c" 3562| 7.71k| break; 3563| | 3564| 7.72k| case 127: /* ObjPats: ObjPats ',' ObjPat */ ------------------ | Branch (3564:3): [True: 7.72k, False: 29.6M] ------------------ 3565| 7.72k|#line 788 "src/parser.y" 3566| 7.72k| { 3567| 7.72k| (yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk)); ------------------ | | 102| 7.72k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.72k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.72k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 7.72k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3568| 7.72k|} 3569| 7.72k|#line 3570 "src/parser.c" 3570| 7.72k| break; 3571| | 3572| 15.4k| case 128: /* ObjPat: BINDING */ ------------------ | Branch (3572:3): [True: 15.4k, False: 29.6M] ------------------ 3573| 15.4k|#line 793 "src/parser.y" 3574| 15.4k| { 3575| 15.4k| (yyval.blk) = gen_object_matcher(gen_const((yyvsp[0].literal)), gen_op_unbound(STOREV, jv_string_value((yyvsp[0].literal)))); 3576| 15.4k|} 3577| 15.4k|#line 3578 "src/parser.c" 3578| 15.4k| break; 3579| | 3580| 0| case 129: /* ObjPat: BINDING ':' Pattern */ ------------------ | Branch (3580:3): [True: 0, False: 29.6M] ------------------ 3581| 0|#line 796 "src/parser.y" 3582| 0| { 3583| 0| (yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), BLOCK(gen_op_simple(DUP), gen_op_unbound(STOREV, jv_string_value((yyvsp[-2].literal))), (yyvsp[0].blk))); ------------------ | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 0|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 0|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 0|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3584| 0|} 3585| 0|#line 3586 "src/parser.c" 3586| 0| break; 3587| | 3588| 37| case 130: /* ObjPat: IDENT ':' Pattern */ ------------------ | Branch (3588:3): [True: 37, False: 29.6M] ------------------ 3589| 37|#line 799 "src/parser.y" 3590| 37| { 3591| 37| (yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3592| 37|} 3593| 37|#line 3594 "src/parser.c" 3594| 37| break; 3595| | 3596| 0| case 131: /* ObjPat: Keyword ':' Pattern */ ------------------ | Branch (3596:3): [True: 0, False: 29.6M] ------------------ 3597| 0|#line 802 "src/parser.y" 3598| 0| { 3599| 0| (yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3600| 0|} 3601| 0|#line 3602 "src/parser.c" 3602| 0| break; 3603| | 3604| 0| case 132: /* ObjPat: String ':' Pattern */ ------------------ | Branch (3604:3): [True: 0, False: 29.6M] ------------------ 3605| 0|#line 805 "src/parser.y" 3606| 0| { 3607| 0| (yyval.blk) = gen_object_matcher((yyvsp[-2].blk), (yyvsp[0].blk)); 3608| 0|} 3609| 0|#line 3610 "src/parser.c" 3610| 0| break; 3611| | 3612| 0| case 133: /* ObjPat: '(' Query ')' ':' Pattern */ ------------------ | Branch (3612:3): [True: 0, False: 29.6M] ------------------ 3613| 0|#line 808 "src/parser.y" 3614| 0| { 3615| 0| jv msg = check_object_key((yyvsp[-3].blk)); 3616| 0| if (jv_is_valid(msg)) { ------------------ | Branch (3616:7): [True: 0, False: 0] ------------------ 3617| 0| FAIL((yylsp[-3]), jv_string_value(msg)); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3618| 0| } 3619| 0| jv_free(msg); 3620| 0| (yyval.blk) = gen_object_matcher((yyvsp[-3].blk), (yyvsp[0].blk)); 3621| 0|} 3622| 0|#line 3623 "src/parser.c" 3623| 0| break; 3624| | 3625| 0| case 134: /* ObjPat: error ':' Pattern */ ------------------ | Branch (3625:3): [True: 0, False: 29.6M] ------------------ 3626| 0|#line 816 "src/parser.y" 3627| 0| { 3628| 0| FAIL((yyloc), "May need parentheses around object key expression"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3629| 0| (yyval.blk) = (yyvsp[0].blk); 3630| 0|} 3631| 0|#line 3632 "src/parser.c" 3632| 0| break; 3633| | 3634| 0| case 135: /* Keyword: "as" */ ------------------ | Branch (3634:3): [True: 0, False: 29.6M] ------------------ 3635| 0|#line 822 "src/parser.y" 3636| 0| { 3637| 0| (yyval.literal) = jv_string("as"); 3638| 0|} 3639| 0|#line 3640 "src/parser.c" 3640| 0| break; 3641| | 3642| 0| case 136: /* Keyword: "def" */ ------------------ | Branch (3642:3): [True: 0, False: 29.6M] ------------------ 3643| 0|#line 825 "src/parser.y" 3644| 0| { 3645| 0| (yyval.literal) = jv_string("def"); 3646| 0|} 3647| 0|#line 3648 "src/parser.c" 3648| 0| break; 3649| | 3650| 0| case 137: /* Keyword: "module" */ ------------------ | Branch (3650:3): [True: 0, False: 29.6M] ------------------ 3651| 0|#line 828 "src/parser.y" 3652| 0| { 3653| 0| (yyval.literal) = jv_string("module"); 3654| 0|} 3655| 0|#line 3656 "src/parser.c" 3656| 0| break; 3657| | 3658| 0| case 138: /* Keyword: "import" */ ------------------ | Branch (3658:3): [True: 0, False: 29.6M] ------------------ 3659| 0|#line 831 "src/parser.y" 3660| 0| { 3661| 0| (yyval.literal) = jv_string("import"); 3662| 0|} 3663| 0|#line 3664 "src/parser.c" 3664| 0| break; 3665| | 3666| 0| case 139: /* Keyword: "include" */ ------------------ | Branch (3666:3): [True: 0, False: 29.6M] ------------------ 3667| 0|#line 834 "src/parser.y" 3668| 0| { 3669| 0| (yyval.literal) = jv_string("include"); 3670| 0|} 3671| 0|#line 3672 "src/parser.c" 3672| 0| break; 3673| | 3674| 0| case 140: /* Keyword: "if" */ ------------------ | Branch (3674:3): [True: 0, False: 29.6M] ------------------ 3675| 0|#line 837 "src/parser.y" 3676| 0| { 3677| 0| (yyval.literal) = jv_string("if"); 3678| 0|} 3679| 0|#line 3680 "src/parser.c" 3680| 0| break; 3681| | 3682| 0| case 141: /* Keyword: "then" */ ------------------ | Branch (3682:3): [True: 0, False: 29.6M] ------------------ 3683| 0|#line 840 "src/parser.y" 3684| 0| { 3685| 0| (yyval.literal) = jv_string("then"); 3686| 0|} 3687| 0|#line 3688 "src/parser.c" 3688| 0| break; 3689| | 3690| 0| case 142: /* Keyword: "else" */ ------------------ | Branch (3690:3): [True: 0, False: 29.6M] ------------------ 3691| 0|#line 843 "src/parser.y" 3692| 0| { 3693| 0| (yyval.literal) = jv_string("else"); 3694| 0|} 3695| 0|#line 3696 "src/parser.c" 3696| 0| break; 3697| | 3698| 0| case 143: /* Keyword: "elif" */ ------------------ | Branch (3698:3): [True: 0, False: 29.6M] ------------------ 3699| 0|#line 846 "src/parser.y" 3700| 0| { 3701| 0| (yyval.literal) = jv_string("elif"); 3702| 0|} 3703| 0|#line 3704 "src/parser.c" 3704| 0| break; 3705| | 3706| 0| case 144: /* Keyword: "reduce" */ ------------------ | Branch (3706:3): [True: 0, False: 29.6M] ------------------ 3707| 0|#line 849 "src/parser.y" 3708| 0| { 3709| 0| (yyval.literal) = jv_string("reduce"); 3710| 0|} 3711| 0|#line 3712 "src/parser.c" 3712| 0| break; 3713| | 3714| 0| case 145: /* Keyword: "foreach" */ ------------------ | Branch (3714:3): [True: 0, False: 29.6M] ------------------ 3715| 0|#line 852 "src/parser.y" 3716| 0| { 3717| 0| (yyval.literal) = jv_string("foreach"); 3718| 0|} 3719| 0|#line 3720 "src/parser.c" 3720| 0| break; 3721| | 3722| 7.64k| case 146: /* Keyword: "end" */ ------------------ | Branch (3722:3): [True: 7.64k, False: 29.6M] ------------------ 3723| 7.64k|#line 855 "src/parser.y" 3724| 7.64k| { 3725| 7.64k| (yyval.literal) = jv_string("end"); 3726| 7.64k|} 3727| 7.64k|#line 3728 "src/parser.c" 3728| 7.64k| break; 3729| | 3730| 0| case 147: /* Keyword: "and" */ ------------------ | Branch (3730:3): [True: 0, False: 29.6M] ------------------ 3731| 0|#line 858 "src/parser.y" 3732| 0| { 3733| 0| (yyval.literal) = jv_string("and"); 3734| 0|} 3735| 0|#line 3736 "src/parser.c" 3736| 0| break; 3737| | 3738| 0| case 148: /* Keyword: "or" */ ------------------ | Branch (3738:3): [True: 0, False: 29.6M] ------------------ 3739| 0|#line 861 "src/parser.y" 3740| 0| { 3741| 0| (yyval.literal) = jv_string("or"); 3742| 0|} 3743| 0|#line 3744 "src/parser.c" 3744| 0| break; 3745| | 3746| 0| case 149: /* Keyword: "try" */ ------------------ | Branch (3746:3): [True: 0, False: 29.6M] ------------------ 3747| 0|#line 864 "src/parser.y" 3748| 0| { 3749| 0| (yyval.literal) = jv_string("try"); 3750| 0|} 3751| 0|#line 3752 "src/parser.c" 3752| 0| break; 3753| | 3754| 0| case 150: /* Keyword: "catch" */ ------------------ | Branch (3754:3): [True: 0, False: 29.6M] ------------------ 3755| 0|#line 867 "src/parser.y" 3756| 0| { 3757| 0| (yyval.literal) = jv_string("catch"); 3758| 0|} 3759| 0|#line 3760 "src/parser.c" 3760| 0| break; 3761| | 3762| 0| case 151: /* Keyword: "label" */ ------------------ | Branch (3762:3): [True: 0, False: 29.6M] ------------------ 3763| 0|#line 870 "src/parser.y" 3764| 0| { 3765| 0| (yyval.literal) = jv_string("label"); 3766| 0|} 3767| 0|#line 3768 "src/parser.c" 3768| 0| break; 3769| | 3770| 0| case 152: /* Keyword: "break" */ ------------------ | Branch (3770:3): [True: 0, False: 29.6M] ------------------ 3771| 0|#line 873 "src/parser.y" 3772| 0| { 3773| 0| (yyval.literal) = jv_string("break"); 3774| 0|} 3775| 0|#line 3776 "src/parser.c" 3776| 0| break; 3777| | 3778| 30.5k| case 153: /* DictPairs: %empty */ ------------------ | Branch (3778:3): [True: 30.5k, False: 29.6M] ------------------ 3779| 30.5k|#line 879 "src/parser.y" 3780| 30.5k| { 3781| 30.5k| (yyval.blk) = gen_noop(); 3782| 30.5k|} 3783| 30.5k|#line 3784 "src/parser.c" 3784| 30.5k| break; 3785| | 3786| 53.6k| case 154: /* DictPairs: DictPair */ ------------------ | Branch (3786:3): [True: 53.6k, False: 29.5M] ------------------ 3787| 53.6k|#line 882 "src/parser.y" 3788| 53.6k| { 3789| 53.6k| (yyval.blk) = (yyvsp[0].blk); 3790| 53.6k|} 3791| 53.6k|#line 3792 "src/parser.c" 3792| 53.6k| break; 3793| | 3794| 38.3k| case 155: /* DictPairs: DictPair ',' DictPairs */ ------------------ | Branch (3794:3): [True: 38.3k, False: 29.5M] ------------------ 3795| 38.3k|#line 885 "src/parser.y" 3796| 38.3k| { 3797| 38.3k| (yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk)); 3798| 38.3k|} 3799| 38.3k|#line 3800 "src/parser.c" 3800| 38.3k| break; 3801| | 3802| 61.2k| case 156: /* DictPair: IDENT ':' DictExpr */ ------------------ | Branch (3802:3): [True: 61.2k, False: 29.5M] ------------------ 3803| 61.2k|#line 890 "src/parser.y" 3804| 61.2k| { 3805| 61.2k| (yyval.blk) = gen_dictpair(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3806| 61.2k|} 3807| 61.2k|#line 3808 "src/parser.c" 3808| 61.2k| break; 3809| | 3810| 7.64k| case 157: /* DictPair: Keyword ':' DictExpr */ ------------------ | Branch (3810:3): [True: 7.64k, False: 29.6M] ------------------ 3811| 7.64k|#line 893 "src/parser.y" 3812| 7.64k| { 3813| 7.64k| (yyval.blk) = gen_dictpair(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3814| 7.64k|} 3815| 7.64k|#line 3816 "src/parser.c" 3816| 7.64k| break; 3817| | 3818| 44| case 158: /* DictPair: String ':' DictExpr */ ------------------ | Branch (3818:3): [True: 44, False: 29.6M] ------------------ 3819| 44|#line 896 "src/parser.y" 3820| 44| { 3821| 44| (yyval.blk) = gen_dictpair((yyvsp[-2].blk), (yyvsp[0].blk)); 3822| 44|} 3823| 44|#line 3824 "src/parser.c" 3824| 44| break; 3825| | 3826| 0| case 159: /* DictPair: String */ ------------------ | Branch (3826:3): [True: 0, False: 29.6M] ------------------ 3827| 0|#line 899 "src/parser.y" 3828| 0| { 3829| 0| (yyval.blk) = gen_dictpair((yyvsp[0].blk), BLOCK(gen_op_simple(POP), gen_op_simple(DUP2), ------------------ | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 0|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 0| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 0|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 0|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 0|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3830| 0| gen_op_simple(DUP2), gen_op_simple(INDEX))); 3831| 0|} 3832| 0|#line 3833 "src/parser.c" 3833| 0| break; 3834| | 3835| 0| case 160: /* DictPair: BINDING ':' DictExpr */ ------------------ | Branch (3835:3): [True: 0, False: 29.6M] ------------------ 3836| 0|#line 903 "src/parser.y" 3837| 0| { 3838| 0| (yyval.blk) = gen_dictpair(gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[-2].literal)))), 3839| 0| (yyvsp[0].blk)); 3840| 0| jv_free((yyvsp[-2].literal)); 3841| 0|} 3842| 0|#line 3843 "src/parser.c" 3843| 0| break; 3844| | 3845| 72| case 161: /* DictPair: BINDING */ ------------------ | Branch (3845:3): [True: 72, False: 29.6M] ------------------ 3846| 72|#line 908 "src/parser.y" 3847| 72| { 3848| 72| (yyval.blk) = gen_dictpair(gen_const((yyvsp[0].literal)), 3849| 72| gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[0].literal))))); 3850| 72|} 3851| 72|#line 3852 "src/parser.c" 3852| 72| break; 3853| | 3854| 3| case 162: /* DictPair: IDENT */ ------------------ | Branch (3854:3): [True: 3, False: 29.6M] ------------------ 3855| 3|#line 912 "src/parser.y" 3856| 3| { 3857| 3| (yyval.blk) = gen_dictpair(gen_const(jv_copy((yyvsp[0].literal))), 3858| 3| gen_index(gen_noop(), gen_const((yyvsp[0].literal)))); 3859| 3|} 3860| 3|#line 3861 "src/parser.c" 3861| 3| break; 3862| | 3863| 0| case 163: /* DictPair: "$__loc__" */ ------------------ | Branch (3863:3): [True: 0, False: 29.6M] ------------------ 3864| 0|#line 916 "src/parser.y" 3865| 0| { 3866| 0| (yyval.blk) = gen_dictpair(gen_const(jv_string("__loc__")), 3867| 0| gen_loc_object(&(yyloc), locations)); 3868| 0|} 3869| 0|#line 3870 "src/parser.c" 3870| 0| break; 3871| | 3872| 0| case 164: /* DictPair: Keyword */ ------------------ | Branch (3872:3): [True: 0, False: 29.6M] ------------------ 3873| 0|#line 920 "src/parser.y" 3874| 0| { 3875| 0| (yyval.blk) = gen_dictpair(gen_const(jv_copy((yyvsp[0].literal))), 3876| 0| gen_index(gen_noop(), gen_const((yyvsp[0].literal)))); 3877| 0|} 3878| 0|#line 3879 "src/parser.c" 3879| 0| break; 3880| | 3881| 22.9k| case 165: /* DictPair: '(' Query ')' ':' DictExpr */ ------------------ | Branch (3881:3): [True: 22.9k, False: 29.6M] ------------------ 3882| 22.9k|#line 924 "src/parser.y" 3883| 22.9k| { 3884| 22.9k| jv msg = check_object_key((yyvsp[-3].blk)); 3885| 22.9k| if (jv_is_valid(msg)) { ------------------ | Branch (3885:7): [True: 0, False: 22.9k] ------------------ 3886| 0| FAIL((yylsp[-3]), jv_string_value(msg)); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3887| 0| } 3888| 22.9k| jv_free(msg); 3889| 22.9k| (yyval.blk) = gen_dictpair((yyvsp[-3].blk), (yyvsp[0].blk)); 3890| 22.9k|} 3891| 22.9k|#line 3892 "src/parser.c" 3892| 22.9k| break; 3893| | 3894| 0| case 166: /* DictPair: error ':' DictExpr */ ------------------ | Branch (3894:3): [True: 0, False: 29.6M] ------------------ 3895| 0|#line 932 "src/parser.y" 3896| 0| { 3897| 0| FAIL((yylsp[-2]), "May need parentheses around object key expression"); ------------------ | | 400| 0| do { \ | | 401| 0| location l = loc; \ | | 402| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 403| 0| /*YYERROR*/; \ | | 404| 0| } while (0) | | ------------------ | | | Branch (404:12): [Folded, False: 0] | | ------------------ ------------------ 3898| 0| (yyval.blk) = (yyvsp[0].blk); 3899| 0|} 3900| 0|#line 3901 "src/parser.c" 3901| 0| break; 3902| | 3903| 0| case 167: /* DictExpr: DictExpr '|' DictExpr */ ------------------ | Branch (3903:3): [True: 0, False: 29.6M] ------------------ 3904| 0|#line 938 "src/parser.y" 3905| 0| { 3906| 0| (yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk)); 3907| 0|} 3908| 0|#line 3909 "src/parser.c" 3909| 0| break; 3910| | 3911| 91.8k| case 168: /* DictExpr: Expr */ ------------------ | Branch (3911:3): [True: 91.8k, False: 29.5M] ------------------ 3912| 91.8k|#line 941 "src/parser.y" 3913| 91.8k| { 3914| 91.8k| (yyval.blk) = (yyvsp[0].blk); 3915| 91.8k|} 3916| 91.8k|#line 3917 "src/parser.c" 3917| 91.8k| break; 3918| | 3919| | 3920| 0|#line 3921 "src/parser.c" 3921| | 3922| 0| default: break; ------------------ | Branch (3922:7): [True: 0, False: 29.6M] ------------------ 3923| 29.6M| } 3924| | /* User semantic actions sometimes alter yychar, and that requires 3925| | that yytoken be updated with the new translation. We take the 3926| | approach of translating immediately before every use of yytoken. 3927| | One alternative is translating here after every semantic action, 3928| | but that translation would be missed if the semantic action invokes 3929| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 3930| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 3931| | incorrect destructor might then be invoked immediately. In the 3932| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 3933| | to an incorrect destructor call or verbose syntax error message 3934| | before the lookahead is translated. */ 3935| 29.6M| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 3936| | 3937| 29.6M| YYPOPSTACK (yylen); ------------------ | | 2286| 29.6M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 3938| 29.6M| yylen = 0; 3939| | 3940| 29.6M| *++yyvsp = yyval; 3941| 29.6M| *++yylsp = yyloc; 3942| | 3943| | /* Now 'shift' the result of the reduction. Determine what state 3944| | that goes to, based on the state we popped back to and the rule 3945| | number reduced by. */ 3946| 29.6M| { 3947| 29.6M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 876| 29.6M|#define YYNTOKENS 70 ------------------ 3948| 29.6M| const int yyi = yypgoto[yylhs] + *yyssp; 3949| 29.6M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 873| 55.7M|#define YYLAST 1226 ------------------ | Branch (3949:16): [True: 26.1M, False: 3.47M] | Branch (3949:28): [True: 26.1M, False: 0] | Branch (3949:45): [True: 10.2M, False: 15.9M] ------------------ 3950| 29.6M| ? yytable[yyi] 3951| 29.6M| : yydefgoto[yylhs]); 3952| 29.6M| } 3953| | 3954| 29.6M| goto yynewstate; 3955| | 3956| | 3957| |/*--------------------------------------. 3958| || yyerrlab -- here on detecting error. | 3959| |`--------------------------------------*/ 3960| 0|yyerrlab: 3961| | /* Make sure we have latest lookahead translation. See comments at 3962| | user semantic actions for why this is necessary. */ 3963| 0| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 195| 0|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 891| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 885| 0|#define YYMAXUTOK 303 | | ------------------ | | | Branch (891:4): [True: 0, False: 0] | | | Branch (891:18): [True: 0, False: 0] | | ------------------ | | 892| 0| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 893| 0| : YYSYMBOL_YYUNDEF) ------------------ | Branch (3963:13): [True: 0, False: 0] ------------------ 3964| | /* If not already recovering from an error, report this error. */ 3965| 0| if (!yyerrstatus) ------------------ | Branch (3965:7): [True: 0, False: 0] ------------------ 3966| 0| { 3967| 0| ++yynerrs; 3968| 0| { 3969| 0| yypcontext_t yyctx 3970| 0| = {yyssp, yytoken, &yylloc}; 3971| 0| char const *yymsgp = YY_("syntax error"); ------------------ | | 672| 0|# define YY_(Msgid) Msgid ------------------ 3972| 0| int yysyntax_error_status; 3973| 0| yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 3974| 0| if (yysyntax_error_status == 0) ------------------ | Branch (3974:13): [True: 0, False: 0] ------------------ 3975| 0| yymsgp = yymsg; 3976| 0| else if (yysyntax_error_status == -1) ------------------ | Branch (3976:18): [True: 0, False: 0] ------------------ 3977| 0| { 3978| 0| if (yymsg != yymsgbuf) ------------------ | Branch (3978:17): [True: 0, False: 0] ------------------ 3979| 0| YYSTACK_FREE (yymsg); ------------------ | | 780| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 0|#define YYFREE jv_mem_free | | ------------------ ------------------ 3980| 0| yymsg = YY_CAST (char *, ------------------ | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 3981| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 3982| 0| if (yymsg) ------------------ | Branch (3982:17): [True: 0, False: 0] ------------------ 3983| 0| { 3984| 0| yysyntax_error_status 3985| 0| = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 3986| 0| yymsgp = yymsg; 3987| 0| } 3988| 0| else 3989| 0| { 3990| 0| yymsg = yymsgbuf; 3991| 0| yymsg_alloc = sizeof yymsgbuf; 3992| 0| yysyntax_error_status = YYENOMEM; 3993| 0| } 3994| 0| } 3995| 0| yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, yymsgp); 3996| 0| if (yysyntax_error_status == YYENOMEM) ------------------ | Branch (3996:13): [True: 0, False: 0] ------------------ 3997| 0| YYNOMEM; ------------------ | | 1445| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 3998| 0| } 3999| 0| } 4000| | 4001| 0| yyerror_range[1] = yylloc; 4002| 0| if (yyerrstatus == 3) ------------------ | Branch (4002:7): [True: 0, False: 0] ------------------ 4003| 0| { 4004| | /* If just tried and failed to reuse lookahead token after an 4005| | error, discard it. */ 4006| | 4007| 0| if (yychar <= YYEOF) ------------------ | | 196| 0|#define YYEOF 0 ------------------ | Branch (4007:11): [True: 0, False: 0] ------------------ 4008| 0| { 4009| | /* Return failure if at end of input. */ 4010| 0| if (yychar == YYEOF) ------------------ | | 196| 0|#define YYEOF 0 ------------------ | Branch (4010:15): [True: 0, False: 0] ------------------ 4011| 0| YYABORT; ------------------ | | 1443| 0|#define YYABORT goto yyabortlab ------------------ 4012| 0| } 4013| 0| else 4014| 0| { 4015| 0| yydestruct ("Error: discarding", 4016| 0| yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr); 4017| 0| yychar = YYEMPTY; ------------------ | | 195| 0|#define YYEMPTY -2 ------------------ 4018| 0| } 4019| 0| } 4020| | 4021| | /* Else will try to reuse lookahead token after shifting the error 4022| | token. */ 4023| 0| goto yyerrlab1; 4024| | 4025| | 4026| |/*---------------------------------------------------. 4027| || yyerrorlab -- error raised explicitly by YYERROR. | 4028| |`---------------------------------------------------*/ 4029| 0|yyerrorlab: 4030| | /* Pacify compilers when the user code never invokes YYERROR and the 4031| | label yyerrorlab therefore never appears in user code. */ 4032| 0| if (0) ------------------ | Branch (4032:7): [Folded, False: 0] ------------------ 4033| 0| YYERROR; ------------------ | | 1444| 0|#define YYERROR goto yyerrorlab ------------------ 4034| 0| ++yynerrs; 4035| | 4036| | /* Do not reclaim the symbols of the rule whose action triggered 4037| | this YYERROR. */ 4038| 0| YYPOPSTACK (yylen); ------------------ | | 2286| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4039| 0| yylen = 0; 4040| 0| YY_STACK_PRINT (yyss, yyssp); 4041| 0| yystate = *yyssp; 4042| 0| goto yyerrlab1; 4043| | 4044| | 4045| |/*-------------------------------------------------------------. 4046| || yyerrlab1 -- common code for both syntax error and YYERROR. | 4047| |`-------------------------------------------------------------*/ 4048| 0|yyerrlab1: 4049| 0| yyerrstatus = 3; /* Each real token shifted decrements this. */ 4050| | 4051| | /* Pop stack until we find a state that shifts the error token. */ 4052| 0| for (;;) 4053| 0| { 4054| 0| yyn = yypact[yystate]; 4055| 0| if (!yypact_value_is_default (yyn)) ------------------ | | 997| 0| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 994| 0|#define YYPACT_NINF (-146) | | ------------------ ------------------ | Branch (4055:11): [True: 0, False: 0] ------------------ 4056| 0| { 4057| 0| yyn += YYSYMBOL_YYerror; 4058| 0| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 873| 0|#define YYLAST 1226 ------------------ | Branch (4058:15): [True: 0, False: 0] | Branch (4058:27): [True: 0, False: 0] | Branch (4058:44): [True: 0, False: 0] ------------------ 4059| 0| { 4060| 0| yyn = yytable[yyn]; 4061| 0| if (0 < yyn) ------------------ | Branch (4061:19): [True: 0, False: 0] ------------------ 4062| 0| break; 4063| 0| } 4064| 0| } 4065| | 4066| | /* Pop the current state because it cannot handle the error token. */ 4067| 0| if (yyssp == yyss) ------------------ | Branch (4067:11): [True: 0, False: 0] ------------------ 4068| 0| YYABORT; ------------------ | | 1443| 0|#define YYABORT goto yyabortlab ------------------ 4069| | 4070| 0| yyerror_range[1] = *yylsp; 4071| 0| yydestruct ("Error: popping", 4072| 0| YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, answer, errors, locations, lexer_param_ptr); ------------------ | | 957| 0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 4073| 0| YYPOPSTACK (1); ------------------ | | 2286| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4074| 0| yystate = *yyssp; 4075| 0| YY_STACK_PRINT (yyss, yyssp); 4076| 0| } 4077| | 4078| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 4079| 0| *++yyvsp = yylval; 4080| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 4081| | 4082| 0| yyerror_range[2] = yylloc; 4083| 0| ++yylsp; 4084| 0| YYLLOC_DEFAULT (*yylsp, yyerror_range, 2); ------------------ | | 124| 0| do { \ | | 125| 0| if (N) { \ | | ------------------ | | | Branch (125:9): [True: 0, Folded] | | ------------------ | | 126| 0| (Loc).start = YYRHSLOC(Rhs, 1).start; \ | | ------------------ | | | | 1495| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 127| 0| (Loc).end = YYRHSLOC(Rhs, N).end; \ | | ------------------ | | | | 1495| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 128| 0| } else { \ | | 129| 0| (Loc).start = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1495| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 130| 0| (Loc).end = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1495| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 131| 0| } \ | | 132| 0| } while (0) | | ------------------ | | | Branch (132:12): [Folded, False: 0] | | ------------------ ------------------ 4085| | 4086| | /* Shift the error token. */ 4087| 0| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 4088| | 4089| 0| yystate = yyn; 4090| 0| goto yynewstate; 4091| | 4092| | 4093| |/*-------------------------------------. 4094| || yyacceptlab -- YYACCEPT comes here. | 4095| |`-------------------------------------*/ 4096| 15.3k|yyacceptlab: 4097| 15.3k| yyresult = 0; 4098| 15.3k| goto yyreturnlab; 4099| | 4100| | 4101| |/*-----------------------------------. 4102| || yyabortlab -- YYABORT comes here. | 4103| |`-----------------------------------*/ 4104| 0|yyabortlab: 4105| 0| yyresult = 1; 4106| 0| goto yyreturnlab; 4107| | 4108| | 4109| |/*-----------------------------------------------------------. 4110| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 4111| |`-----------------------------------------------------------*/ 4112| 0|yyexhaustedlab: 4113| 0| yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("memory exhausted")); ------------------ | | 672| 0|# define YY_(Msgid) Msgid ------------------ 4114| 0| yyresult = 2; 4115| 0| goto yyreturnlab; 4116| | 4117| | 4118| |/*----------------------------------------------------------. 4119| || yyreturnlab -- parsing is finished, clean up and return. | 4120| |`----------------------------------------------------------*/ 4121| 15.3k|yyreturnlab: 4122| 15.3k| if (yychar != YYEMPTY) ------------------ | | 195| 15.3k|#define YYEMPTY -2 ------------------ | Branch (4122:7): [True: 0, False: 15.3k] ------------------ 4123| 0| { 4124| | /* Make sure we have latest lookahead translation. See comments at 4125| | user semantic actions for why this is necessary. */ 4126| 0| yytoken = YYTRANSLATE (yychar); ------------------ | | 891| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 885| 0|#define YYMAXUTOK 303 | | ------------------ | | | Branch (891:4): [True: 0, False: 0] | | | Branch (891:18): [True: 0, False: 0] | | ------------------ | | 892| 0| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 893| 0| : YYSYMBOL_YYUNDEF) ------------------ 4127| 0| yydestruct ("Cleanup: discarding lookahead", 4128| 0| yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr); 4129| 0| } 4130| | /* Do not reclaim the symbols of the rule whose action triggered 4131| | this YYABORT or YYACCEPT. */ 4132| 15.3k| YYPOPSTACK (yylen); ------------------ | | 2286| 15.3k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4133| 15.3k| YY_STACK_PRINT (yyss, yyssp); 4134| 45.9k| while (yyssp != yyss) ------------------ | Branch (4134:10): [True: 30.6k, False: 15.3k] ------------------ 4135| 30.6k| { 4136| 30.6k| yydestruct ("Cleanup: popping", 4137| 30.6k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, answer, errors, locations, lexer_param_ptr); ------------------ | | 957| 30.6k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 89| 30.6k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 4138| 30.6k| YYPOPSTACK (1); ------------------ | | 2286| 30.6k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4139| 30.6k| } 4140| 15.3k|#ifndef yyoverflow 4141| 15.3k| if (yyss != yyssa) ------------------ | Branch (4141:7): [True: 0, False: 15.3k] ------------------ 4142| 0| YYSTACK_FREE (yyss); ------------------ | | 780| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 0|#define YYFREE jv_mem_free | | ------------------ ------------------ 4143| 15.3k|#endif 4144| 15.3k| if (yymsg != yymsgbuf) ------------------ | Branch (4144:7): [True: 0, False: 15.3k] ------------------ 4145| 0| YYSTACK_FREE (yymsg); ------------------ | | 780| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 0|#define YYFREE jv_mem_free | | ------------------ ------------------ 4146| 15.3k| return yyresult; 4147| 0|} jq_parse: 4152| 15.3k|int jq_parse(struct locfile* locations, block* answer) { 4153| 15.3k| struct lexer_param scanner; 4154| 15.3k| YY_BUFFER_STATE buf; 4155| 15.3k| jq_yylex_init_extra(0, &scanner.lexer); 4156| 15.3k| buf = jq_yy_scan_bytes(locations->data, locations->length, scanner.lexer); 4157| 15.3k| int errors = 0; 4158| 15.3k| *answer = gen_noop(); 4159| 15.3k| yyparse(answer, &errors, locations, &scanner); 4160| 15.3k| jq_yy_delete_buffer(buf, scanner.lexer); 4161| 15.3k| jq_yylex_destroy(scanner.lexer); 4162| 15.3k| if (errors > 0) { ------------------ | Branch (4162:7): [True: 5, False: 15.2k] ------------------ 4163| 5| block_free(*answer); 4164| 5| *answer = gen_noop(); 4165| 5| } 4166| 15.3k| return errors; 4167| 15.3k|} jq_parse_library: 4169| 7.64k|int jq_parse_library(struct locfile* locations, block* answer) { 4170| 7.64k| int errs = jq_parse(locations, answer); 4171| 7.64k| if (errs) return errs; ------------------ | Branch (4171:7): [True: 0, False: 7.64k] ------------------ 4172| 7.64k| if (block_has_main(*answer)) { ------------------ | Branch (4172:7): [True: 0, False: 7.64k] ------------------ 4173| 0| locfile_locate(locations, UNKNOWN_LOCATION, "jq: error: library should only have function definitions, not a main expression"); 4174| 0| return 1; 4175| 0| } 4176| 7.64k| assert(block_has_only_binders_and_imports(*answer, OP_IS_CALL_PSEUDO)); ------------------ | Branch (4176:3): [True: 0, False: 7.64k] | Branch (4176:3): [True: 7.64k, False: 0] ------------------ 4177| 7.64k| return 0; 4178| 7.64k|} parser.c:gen_binop: 492| 1.14M|static block gen_binop(block a, block b, int op) { 493| 1.14M| block folded = constant_fold(a, b, op); 494| 1.14M| if (!block_is_noop(folded)) ------------------ | Branch (494:7): [True: 364k, False: 776k] ------------------ 495| 364k| return folded; 496| | 497| 776k| const char* funcname = 0; 498| 776k| switch (op) { ------------------ | Branch (498:11): [True: 776k, False: 0] ------------------ 499| 193k| case '+': funcname = "_plus"; break; ------------------ | Branch (499:3): [True: 193k, False: 583k] ------------------ 500| 53.6k| case '-': funcname = "_minus"; break; ------------------ | Branch (500:3): [True: 53.6k, False: 723k] ------------------ 501| 271| case '*': funcname = "_multiply"; break; ------------------ | Branch (501:3): [True: 271, False: 776k] ------------------ 502| 1.64k| case '/': funcname = "_divide"; break; ------------------ | Branch (502:3): [True: 1.64k, False: 775k] ------------------ 503| 0| case '%': funcname = "_mod"; break; ------------------ | Branch (503:3): [True: 0, False: 776k] ------------------ 504| 290k| case EQ: funcname = "_equal"; break; ------------------ | | 207| 290k|#define EQ 266 ------------------ | Branch (504:3): [True: 290k, False: 485k] ------------------ 505| 45.8k| case NEQ: funcname = "_notequal"; break; ------------------ | | 208| 45.8k|#define NEQ 267 ------------------ | Branch (505:3): [True: 45.8k, False: 730k] ------------------ 506| 46.0k| case '<': funcname = "_less"; break; ------------------ | Branch (506:3): [True: 46.0k, False: 730k] ------------------ 507| 107k| case '>': funcname = "_greater"; break; ------------------ | Branch (507:3): [True: 107k, False: 669k] ------------------ 508| 38.2k| case LESSEQ: funcname = "_lesseq"; break; ------------------ | | 235| 38.2k|#define LESSEQ 294 ------------------ | Branch (508:3): [True: 38.2k, False: 738k] ------------------ 509| 21| case GREATEREQ: funcname = "_greatereq"; break; ------------------ | | 236| 21|#define GREATEREQ 295 ------------------ | Branch (509:3): [True: 21, False: 776k] ------------------ 510| 776k| } 511| 776k| assert(funcname); ------------------ | Branch (511:3): [True: 0, False: 776k] | Branch (511:3): [True: 776k, False: 0] ------------------ 512| | 513| 776k| return gen_call(funcname, BLOCK(gen_lambda(a), gen_lambda(b))); ------------------ | | 102| 776k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 776k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 776k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 776k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 514| 776k|} parser.c:constant_fold: 461| 1.14M|static block constant_fold(block a, block b, int op) { 462| 1.14M| if (!block_is_single(a) || !block_is_const(a) || ------------------ | Branch (462:7): [True: 332k, False: 809k] | Branch (462:30): [True: 405k, False: 403k] ------------------ 463| 403k| !block_is_single(b) || !block_is_const(b)) ------------------ | Branch (463:7): [True: 23.6k, False: 379k] | Branch (463:30): [True: 15.3k, False: 364k] ------------------ 464| 776k| return gen_noop(); 465| | 466| 364k| jv jv_a = block_const(a); 467| 364k| block_free(a); 468| 364k| jv jv_b = block_const(b); 469| 364k| block_free(b); 470| | 471| 364k| jv res = jv_invalid(); 472| 364k| switch (op) { ------------------ | Branch (472:11): [True: 364k, False: 0] ------------------ 473| 364k| case '+': res = binop_plus(jv_a, jv_b); break; ------------------ | Branch (473:3): [True: 364k, False: 0] ------------------ 474| 0| case '-': res = binop_minus(jv_a, jv_b); break; ------------------ | Branch (474:3): [True: 0, False: 364k] ------------------ 475| 0| case '*': res = binop_multiply(jv_a, jv_b); break; ------------------ | Branch (475:3): [True: 0, False: 364k] ------------------ 476| 0| case '/': res = binop_divide(jv_a, jv_b); break; ------------------ | Branch (476:3): [True: 0, False: 364k] ------------------ 477| 0| case '%': res = binop_mod(jv_a, jv_b); break; ------------------ | Branch (477:3): [True: 0, False: 364k] ------------------ 478| 0| case EQ: res = binop_equal(jv_a, jv_b); break; ------------------ | | 207| 0|#define EQ 266 ------------------ | Branch (478:3): [True: 0, False: 364k] ------------------ 479| 0| case NEQ: res = binop_notequal(jv_a, jv_b); break; ------------------ | | 208| 0|#define NEQ 267 ------------------ | Branch (479:3): [True: 0, False: 364k] ------------------ 480| 0| case '<': res = binop_less(jv_a, jv_b); break; ------------------ | Branch (480:3): [True: 0, False: 364k] ------------------ 481| 0| case '>': res = binop_greater(jv_a, jv_b); break; ------------------ | Branch (481:3): [True: 0, False: 364k] ------------------ 482| 0| case LESSEQ: res = binop_lesseq(jv_a, jv_b); break; ------------------ | | 235| 0|#define LESSEQ 294 ------------------ | Branch (482:3): [True: 0, False: 364k] ------------------ 483| 0| case GREATEREQ: res = binop_greatereq(jv_a, jv_b); break; ------------------ | | 236| 0|#define GREATEREQ 295 ------------------ | Branch (483:3): [True: 0, False: 364k] ------------------ 484| 364k| } 485| | 486| 364k| if (jv_is_valid(res)) ------------------ | Branch (486:7): [True: 364k, False: 0] ------------------ 487| 364k| return gen_const(res); 488| | 489| 0| return gen_error(jv_invalid_get_msg(res)); 490| 364k|} parser.c:gen_update: 529| 7.65k|static block gen_update(block object, block val, int optype) { 530| 7.65k| block tmp = gen_op_var_fresh(STOREV, "tmp"); 531| 7.65k| return BLOCK(gen_op_simple(DUP), ------------------ | | 102| 7.65k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 7.65k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 7.65k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 7.65k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 7.65k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 7.65k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 532| 7.65k| val, 533| 7.65k| tmp, 534| 7.65k| gen_call("_modify", BLOCK(gen_lambda(object), 535| 7.65k| gen_lambda(gen_binop(gen_noop(), 536| 7.65k| gen_op_bound(LOADV, tmp), 537| 7.65k| optype))))); 538| 7.65k|} parser.c:gen_format: 516| 966|static block gen_format(block a, jv fmt) { 517| 966| return BLOCK(a, gen_call("format", gen_lambda(gen_const(fmt)))); ------------------ | | 102| 966| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 966|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 966| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 966|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 518| 966|} parser.c:gen_index_opt: 446| 15|static block gen_index_opt(block obj, block key) { 447| 15| return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX_OPT)); ------------------ | | 102| 15| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 15|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 15| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 15|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 15|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 448| 15|} parser.c:gen_index: 442| 521k|static block gen_index(block obj, block key) { 443| 521k| return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX)); ------------------ | | 102| 521k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 521k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 521k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 521k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 521k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 444| 521k|} parser.c:gen_slice_index: 450| 53.5k|static block gen_slice_index(block obj, block start, block end, opcode idx_op) { 451| 53.5k| block key = BLOCK(gen_subexp(gen_const(jv_object())), ------------------ | | 102| 53.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 53.5k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 53.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 97| 53.5k|#define BLOCK_7(b1,b2,b3,b4,b5,b6,b7) (block_join(BLOCK_6(b1,b2,b3,b4,b5,b6),(b7))) | | | | | | | | ------------------ | | | | | | | | | | 96| 53.5k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 95| 53.5k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 94| 53.5k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 93| 53.5k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 92| 53.5k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 452| 53.5k| gen_subexp(gen_const(jv_string("start"))), 453| 53.5k| gen_subexp(start), 454| 53.5k| gen_op_simple(INSERT), 455| 53.5k| gen_subexp(gen_const(jv_string("end"))), 456| 53.5k| gen_subexp(end), 457| 53.5k| gen_op_simple(INSERT)); 458| 53.5k| return BLOCK(key, obj, gen_op_simple(idx_op)); ------------------ | | 102| 53.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 53.5k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 53.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 53.5k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 53.5k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 459| 53.5k|} parser.c:check_object_key: 432| 22.9k|static jv check_object_key(block k) { 433| 22.9k| if (block_is_const(k) && block_const_kind(k) != JV_KIND_STRING) { ------------------ | Branch (433:7): [True: 0, False: 22.9k] | Branch (433:28): [True: 0, False: 0] ------------------ 434| 0| char errbuf[30]; 435| 0| return jv_string_fmt("Cannot use %s (%s) as object key", 436| 0| jv_kind_name(block_const_kind(k)), 437| 0| jv_dump_string_trunc(block_const(k), errbuf, sizeof(errbuf))); 438| 0| } 439| 22.9k| return jv_invalid(); 440| 22.9k|} parser.c:yydestruct: 1986| 30.6k|{ 1987| 30.6k| YY_USE (yyvaluep); ------------------ | | 695| 30.6k|# define YY_USE(E) ((void) (E)) ------------------ 1988| 30.6k| YY_USE (yylocationp); ------------------ | | 695| 30.6k|# define YY_USE(E) ((void) (E)) ------------------ 1989| 30.6k| YY_USE (answer); ------------------ | | 695| 30.6k|# define YY_USE(E) ((void) (E)) ------------------ 1990| 30.6k| YY_USE (errors); ------------------ | | 695| 30.6k|# define YY_USE(E) ((void) (E)) ------------------ 1991| 30.6k| YY_USE (locations); ------------------ | | 695| 30.6k|# define YY_USE(E) ((void) (E)) ------------------ 1992| 30.6k| YY_USE (lexer_param_ptr); ------------------ | | 695| 30.6k|# define YY_USE(E) ((void) (E)) ------------------ 1993| 30.6k| if (!yymsg) ------------------ | Branch (1993:7): [True: 0, False: 30.6k] ------------------ 1994| 0| yymsg = "Deleting"; 1995| 30.6k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1996| | 1997| 30.6k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1998| 30.6k| switch (yykind) 1999| 30.6k| { 2000| 0| case YYSYMBOL_IDENT: /* IDENT */ ------------------ | Branch (2000:5): [True: 0, False: 30.6k] ------------------ 2001| 0|#line 37 "src/parser.y" 2002| 0| { jv_free(((*yyvaluep).literal)); } 2003| 0|#line 2004 "src/parser.c" 2004| 0| break; 2005| | 2006| 0| case YYSYMBOL_FIELD: /* FIELD */ ------------------ | Branch (2006:5): [True: 0, False: 30.6k] ------------------ 2007| 0|#line 37 "src/parser.y" 2008| 0| { jv_free(((*yyvaluep).literal)); } 2009| 0|#line 2010 "src/parser.c" 2010| 0| break; 2011| | 2012| 0| case YYSYMBOL_BINDING: /* BINDING */ ------------------ | Branch (2012:5): [True: 0, False: 30.6k] ------------------ 2013| 0|#line 37 "src/parser.y" 2014| 0| { jv_free(((*yyvaluep).literal)); } 2015| 0|#line 2016 "src/parser.c" 2016| 0| break; 2017| | 2018| 0| case YYSYMBOL_LITERAL: /* LITERAL */ ------------------ | Branch (2018:5): [True: 0, False: 30.6k] ------------------ 2019| 0|#line 37 "src/parser.y" 2020| 0| { jv_free(((*yyvaluep).literal)); } 2021| 0|#line 2022 "src/parser.c" 2022| 0| break; 2023| | 2024| 0| case YYSYMBOL_FORMAT: /* FORMAT */ ------------------ | Branch (2024:5): [True: 0, False: 30.6k] ------------------ 2025| 0|#line 37 "src/parser.y" 2026| 0| { jv_free(((*yyvaluep).literal)); } 2027| 0|#line 2028 "src/parser.c" 2028| 0| break; 2029| | 2030| 0| case YYSYMBOL_QQSTRING_TEXT: /* QQSTRING_TEXT */ ------------------ | Branch (2030:5): [True: 0, False: 30.6k] ------------------ 2031| 0|#line 37 "src/parser.y" 2032| 0| { jv_free(((*yyvaluep).literal)); } 2033| 0|#line 2034 "src/parser.c" 2034| 0| break; 2035| | 2036| 0| case YYSYMBOL_Module: /* Module */ ------------------ | Branch (2036:5): [True: 0, False: 30.6k] ------------------ 2037| 0|#line 38 "src/parser.y" 2038| 0| { block_free(((*yyvaluep).blk)); } 2039| 0|#line 2040 "src/parser.c" 2040| 0| break; 2041| | 2042| 0| case YYSYMBOL_Imports: /* Imports */ ------------------ | Branch (2042:5): [True: 0, False: 30.6k] ------------------ 2043| 0|#line 38 "src/parser.y" 2044| 0| { block_free(((*yyvaluep).blk)); } 2045| 0|#line 2046 "src/parser.c" 2046| 0| break; 2047| | 2048| 0| case YYSYMBOL_FuncDefs: /* FuncDefs */ ------------------ | Branch (2048:5): [True: 0, False: 30.6k] ------------------ 2049| 0|#line 38 "src/parser.y" 2050| 0| { block_free(((*yyvaluep).blk)); } 2051| 0|#line 2052 "src/parser.c" 2052| 0| break; 2053| | 2054| 0| case YYSYMBOL_Query: /* Query */ ------------------ | Branch (2054:5): [True: 0, False: 30.6k] ------------------ 2055| 0|#line 38 "src/parser.y" 2056| 0| { block_free(((*yyvaluep).blk)); } 2057| 0|#line 2058 "src/parser.c" 2058| 0| break; 2059| | 2060| 0| case YYSYMBOL_Expr: /* Expr */ ------------------ | Branch (2060:5): [True: 0, False: 30.6k] ------------------ 2061| 0|#line 38 "src/parser.y" 2062| 0| { block_free(((*yyvaluep).blk)); } 2063| 0|#line 2064 "src/parser.c" 2064| 0| break; 2065| | 2066| 0| case YYSYMBOL_Import: /* Import */ ------------------ | Branch (2066:5): [True: 0, False: 30.6k] ------------------ 2067| 0|#line 38 "src/parser.y" 2068| 0| { block_free(((*yyvaluep).blk)); } 2069| 0|#line 2070 "src/parser.c" 2070| 0| break; 2071| | 2072| 0| case YYSYMBOL_ImportWhat: /* ImportWhat */ ------------------ | Branch (2072:5): [True: 0, False: 30.6k] ------------------ 2073| 0|#line 38 "src/parser.y" 2074| 0| { block_free(((*yyvaluep).blk)); } 2075| 0|#line 2076 "src/parser.c" 2076| 0| break; 2077| | 2078| 0| case YYSYMBOL_ImportFrom: /* ImportFrom */ ------------------ | Branch (2078:5): [True: 0, False: 30.6k] ------------------ 2079| 0|#line 38 "src/parser.y" 2080| 0| { block_free(((*yyvaluep).blk)); } 2081| 0|#line 2082 "src/parser.c" 2082| 0| break; 2083| | 2084| 0| case YYSYMBOL_FuncDef: /* FuncDef */ ------------------ | Branch (2084:5): [True: 0, False: 30.6k] ------------------ 2085| 0|#line 38 "src/parser.y" 2086| 0| { block_free(((*yyvaluep).blk)); } 2087| 0|#line 2088 "src/parser.c" 2088| 0| break; 2089| | 2090| 0| case YYSYMBOL_Params: /* Params */ ------------------ | Branch (2090:5): [True: 0, False: 30.6k] ------------------ 2091| 0|#line 38 "src/parser.y" 2092| 0| { block_free(((*yyvaluep).blk)); } 2093| 0|#line 2094 "src/parser.c" 2094| 0| break; 2095| | 2096| 0| case YYSYMBOL_Param: /* Param */ ------------------ | Branch (2096:5): [True: 0, False: 30.6k] ------------------ 2097| 0|#line 38 "src/parser.y" 2098| 0| { block_free(((*yyvaluep).blk)); } 2099| 0|#line 2100 "src/parser.c" 2100| 0| break; 2101| | 2102| 0| case YYSYMBOL_StringStart: /* StringStart */ ------------------ | Branch (2102:5): [True: 0, False: 30.6k] ------------------ 2103| 0|#line 37 "src/parser.y" 2104| 0| { jv_free(((*yyvaluep).literal)); } 2105| 0|#line 2106 "src/parser.c" 2106| 0| break; 2107| | 2108| 0| case YYSYMBOL_String: /* String */ ------------------ | Branch (2108:5): [True: 0, False: 30.6k] ------------------ 2109| 0|#line 38 "src/parser.y" 2110| 0| { block_free(((*yyvaluep).blk)); } 2111| 0|#line 2112 "src/parser.c" 2112| 0| break; 2113| | 2114| 0| case YYSYMBOL_QQString: /* QQString */ ------------------ | Branch (2114:5): [True: 0, False: 30.6k] ------------------ 2115| 0|#line 38 "src/parser.y" 2116| 0| { block_free(((*yyvaluep).blk)); } 2117| 0|#line 2118 "src/parser.c" 2118| 0| break; 2119| | 2120| 0| case YYSYMBOL_ElseBody: /* ElseBody */ ------------------ | Branch (2120:5): [True: 0, False: 30.6k] ------------------ 2121| 0|#line 38 "src/parser.y" 2122| 0| { block_free(((*yyvaluep).blk)); } 2123| 0|#line 2124 "src/parser.c" 2124| 0| break; 2125| | 2126| 0| case YYSYMBOL_Term: /* Term */ ------------------ | Branch (2126:5): [True: 0, False: 30.6k] ------------------ 2127| 0|#line 38 "src/parser.y" 2128| 0| { block_free(((*yyvaluep).blk)); } 2129| 0|#line 2130 "src/parser.c" 2130| 0| break; 2131| | 2132| 0| case YYSYMBOL_Args: /* Args */ ------------------ | Branch (2132:5): [True: 0, False: 30.6k] ------------------ 2133| 0|#line 38 "src/parser.y" 2134| 0| { block_free(((*yyvaluep).blk)); } 2135| 0|#line 2136 "src/parser.c" 2136| 0| break; 2137| | 2138| 0| case YYSYMBOL_Arg: /* Arg */ ------------------ | Branch (2138:5): [True: 0, False: 30.6k] ------------------ 2139| 0|#line 38 "src/parser.y" 2140| 0| { block_free(((*yyvaluep).blk)); } 2141| 0|#line 2142 "src/parser.c" 2142| 0| break; 2143| | 2144| 0| case YYSYMBOL_RepPatterns: /* RepPatterns */ ------------------ | Branch (2144:5): [True: 0, False: 30.6k] ------------------ 2145| 0|#line 38 "src/parser.y" 2146| 0| { block_free(((*yyvaluep).blk)); } 2147| 0|#line 2148 "src/parser.c" 2148| 0| break; 2149| | 2150| 0| case YYSYMBOL_Patterns: /* Patterns */ ------------------ | Branch (2150:5): [True: 0, False: 30.6k] ------------------ 2151| 0|#line 38 "src/parser.y" 2152| 0| { block_free(((*yyvaluep).blk)); } 2153| 0|#line 2154 "src/parser.c" 2154| 0| break; 2155| | 2156| 0| case YYSYMBOL_Pattern: /* Pattern */ ------------------ | Branch (2156:5): [True: 0, False: 30.6k] ------------------ 2157| 0|#line 38 "src/parser.y" 2158| 0| { block_free(((*yyvaluep).blk)); } 2159| 0|#line 2160 "src/parser.c" 2160| 0| break; 2161| | 2162| 0| case YYSYMBOL_ArrayPats: /* ArrayPats */ ------------------ | Branch (2162:5): [True: 0, False: 30.6k] ------------------ 2163| 0|#line 38 "src/parser.y" 2164| 0| { block_free(((*yyvaluep).blk)); } 2165| 0|#line 2166 "src/parser.c" 2166| 0| break; 2167| | 2168| 0| case YYSYMBOL_ObjPats: /* ObjPats */ ------------------ | Branch (2168:5): [True: 0, False: 30.6k] ------------------ 2169| 0|#line 38 "src/parser.y" 2170| 0| { block_free(((*yyvaluep).blk)); } 2171| 0|#line 2172 "src/parser.c" 2172| 0| break; 2173| | 2174| 0| case YYSYMBOL_ObjPat: /* ObjPat */ ------------------ | Branch (2174:5): [True: 0, False: 30.6k] ------------------ 2175| 0|#line 38 "src/parser.y" 2176| 0| { block_free(((*yyvaluep).blk)); } 2177| 0|#line 2178 "src/parser.c" 2178| 0| break; 2179| | 2180| 0| case YYSYMBOL_Keyword: /* Keyword */ ------------------ | Branch (2180:5): [True: 0, False: 30.6k] ------------------ 2181| 0|#line 37 "src/parser.y" 2182| 0| { jv_free(((*yyvaluep).literal)); } 2183| 0|#line 2184 "src/parser.c" 2184| 0| break; 2185| | 2186| 0| case YYSYMBOL_DictPairs: /* DictPairs */ ------------------ | Branch (2186:5): [True: 0, False: 30.6k] ------------------ 2187| 0|#line 38 "src/parser.y" 2188| 0| { block_free(((*yyvaluep).blk)); } 2189| 0|#line 2190 "src/parser.c" 2190| 0| break; 2191| | 2192| 0| case YYSYMBOL_DictPair: /* DictPair */ ------------------ | Branch (2192:5): [True: 0, False: 30.6k] ------------------ 2193| 0|#line 38 "src/parser.y" 2194| 0| { block_free(((*yyvaluep).blk)); } 2195| 0|#line 2196 "src/parser.c" 2196| 0| break; 2197| | 2198| 0| case YYSYMBOL_DictExpr: /* DictExpr */ ------------------ | Branch (2198:5): [True: 0, False: 30.6k] ------------------ 2199| 0|#line 38 "src/parser.y" 2200| 0| { block_free(((*yyvaluep).blk)); } 2201| 0|#line 2202 "src/parser.c" 2202| 0| break; 2203| | 2204| 30.6k| default: ------------------ | Branch (2204:7): [True: 30.6k, False: 0] ------------------ 2205| 30.6k| break; 2206| 30.6k| } 2207| 30.6k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2208| 30.6k|} expand_path: 83| 7.64k|jv expand_path(jv path) { 84| 7.64k| assert(jv_get_kind(path) == JV_KIND_STRING); ------------------ | Branch (84:3): [True: 0, False: 7.64k] | Branch (84:3): [True: 7.64k, False: 0] ------------------ 85| 7.64k| const char *pstr = jv_string_value(path); 86| 7.64k| jv ret = path; 87| 7.64k| if (jv_string_length_bytes(jv_copy(path)) > 1 && pstr[0] == '~' && pstr[1] == '/') { ------------------ | Branch (87:7): [True: 7.64k, False: 0] | Branch (87:52): [True: 0, False: 7.64k] | Branch (87:70): [True: 0, False: 0] ------------------ 88| 0| jv home = get_home(); 89| 0| if (jv_is_valid(home)) { ------------------ | Branch (89:9): [True: 0, False: 0] ------------------ 90| 0| ret = jv_string_fmt("%s/%s",jv_string_value(home),pstr+2); 91| 0| jv_free(home); 92| 0| } else { 93| 0| jv emsg = jv_invalid_get_msg(home); 94| 0| ret = jv_invalid_with_msg(jv_string_fmt("Could not expand %s. (%s)", pstr, jv_string_value(emsg))); 95| 0| jv_free(emsg); 96| 0| } 97| 0| jv_free(path); 98| 0| } 99| 7.64k| return ret; 100| 7.64k|} get_home: 102| 7.64k|jv get_home(void) { 103| 7.64k| jv ret; 104| 7.64k| char *home = getenv("HOME"); 105| 7.64k| if (!home) { ------------------ | Branch (105:7): [True: 0, False: 7.64k] ------------------ 106| 0|#ifndef WIN32 107| 0| ret = jv_invalid_with_msg(jv_string("Could not find home directory.")); 108| |#else 109| | home = getenv("USERPROFILE"); 110| | if (!home) { 111| | home = getenv("HOMEPATH"); 112| | if (!home) { 113| | ret = jv_invalid_with_msg(jv_string("Could not find home directory.")); 114| | } else { 115| | const char *hd = getenv("HOMEDRIVE"); 116| | if (!hd) hd = ""; 117| | ret = jv_string_fmt("%s%s",hd,home); 118| | } 119| | } else { 120| | ret = jv_string(home); 121| | } 122| |#endif 123| 7.64k| } else { 124| 7.64k| ret = jv_string(home); 125| 7.64k| } 126| 7.64k| return ret; 127| 7.64k|} jq_realpath: 130| 22.9k|jv jq_realpath(jv path) { 131| 22.9k| int path_max; 132| 22.9k| char *buf = NULL; 133| 22.9k|#ifdef _PC_PATH_MAX 134| 22.9k| path_max = pathconf(jv_string_value(path),_PC_PATH_MAX); 135| |#else 136| | path_max = PATH_MAX; 137| |#endif 138| 22.9k| if (path_max > 0) { ------------------ | Branch (138:7): [True: 22.9k, False: 0] ------------------ 139| 22.9k| buf = jv_mem_alloc(path_max); 140| 22.9k| } 141| |#ifdef WIN32 142| | char *tmp = _fullpath(buf, jv_string_value(path), path_max); 143| |#else 144| 22.9k| char *tmp = realpath(jv_string_value(path), buf); 145| 22.9k|#endif 146| 22.9k| if (tmp == NULL) { ------------------ | Branch (146:7): [True: 22.9k, False: 0] ------------------ 147| 22.9k| free(buf); 148| 22.9k| return path; 149| 22.9k| } 150| 0| jv_free(path); 151| 0| path = jv_string(tmp); 152| 0| free(tmp); 153| 0| return path; 154| 22.9k|} _jq_memmem: 157| 834| const void *needle, size_t needlelen) { 158| 834|#ifdef HAVE_MEMMEM 159| 834| return (const void*)memmem(haystack, haystacklen, needle, needlelen); 160| |#else 161| | const char *h = haystack; 162| | const char *n = needle; 163| | size_t hi, hi2, ni; 164| | 165| | if (haystacklen < needlelen || haystacklen == 0) 166| | return NULL; 167| | for (hi = 0; hi < (haystacklen - needlelen + 1); hi++) { 168| | for (ni = 0, hi2 = hi; ni < needlelen; ni++, hi2++) { 169| | if (h[hi2] != n[ni]) 170| | goto not_this; 171| | } 172| | 173| | return &h[hi]; 174| | 175| |not_this: 176| | continue; 177| | } 178| | return NULL; 179| |#endif /* !HAVE_MEMMEM */ 180| 834|} LLVMFuzzerTestOneInput: 263| 7.65k|extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) { 264| 7.65k| FuzzedDataProvider fdp(data, size); 265| 7.65k| std::string parse_payload1 = fdp.ConsumeRandomLengthString(); 266| 7.65k| std::string parse_payload2 = fdp.ConsumeRandomLengthString(); 267| | 268| 7.65k| int idx = fdp.ConsumeIntegralInRange( 269| 7.65k| 0, (sizeof(jq_progs) / sizeof(char *)) - 1); 270| | 271| 7.65k| jq_state *jq = NULL; 272| 7.65k| jq = jq_init(); 273| 7.65k| if (jq != NULL) { ------------------ | Branch (273:7): [True: 7.65k, False: 0] ------------------ 274| 7.65k| jq_set_attr(jq, jv_string("JQ_ORIGIN"), jv_string("/tmp/")); 275| | 276| 7.65k| if (jq_compile(jq, jq_progs[idx])) { ------------------ | Branch (276:9): [True: 7.64k, False: 5] ------------------ 277| | // Process to jv_parse and then jv_next 278| 7.64k| jv input = jv_parse(parse_payload1.c_str()); 279| 7.64k| if (jv_is_valid(input)) { ------------------ | Branch (279:11): [True: 6.55k, False: 1.09k] ------------------ 280| 6.55k| jq_start(jq, input, 0); 281| 6.55k| jv next = jv_parse(parse_payload2.c_str()); 282| 6.55k| if (jv_is_valid(next)) { ------------------ | Branch (282:13): [True: 6.14k, False: 413] ------------------ 283| 6.14k| jv actual = jq_next(jq); 284| 6.14k| jv_free(actual); 285| 6.14k| } 286| 6.55k| jv_free(next); 287| 6.55k| } else { 288| | // Only free if input is invalid as otherwise jq_teardown 289| | // frees it. 290| 1.09k| jv_free(input); 291| 1.09k| } 292| 7.64k| } 293| 7.65k| } 294| 7.65k| jq_teardown(&jq); 295| | 296| 7.65k| return 0; 297| 7.65k|} decContextClearStatus: 54| 7.84M|decContext *decContextClearStatus(decContext *context, uInt mask) { 55| 7.84M| context->status&=~mask; 56| 7.84M| return context; 57| 7.84M| } // decContextClearStatus decContextDefault: 72| 137k|decContext * decContextDefault(decContext *context, Int kind) { 73| | // set defaults... 74| 137k| context->digits=9; // 9 digits 75| 137k| context->emax=DEC_MAX_EMAX; // 9-digit exponents ------------------ | | 90| 137k| #define DEC_MAX_EMAX 999999999 ------------------ 76| 137k| context->emin=DEC_MIN_EMIN; // .. balanced ------------------ | | 93| 137k| #define DEC_MIN_EMIN -999999999 ------------------ 77| 137k| context->round=DEC_ROUND_HALF_UP; // 0.5 rises 78| 137k| context->traps=DEC_Errors; // all but informational ------------------ | | 183| 137k| #define DEC_Errors (DEC_IEEE_754_Division_by_zero | \ | | ------------------ | | | | 167| 137k| #define DEC_IEEE_754_Division_by_zero (DEC_Division_by_zero) | | | | ------------------ | | | | | | 129| 137k| #define DEC_Division_by_zero 0x00000002 | | | | ------------------ | | ------------------ | | 184| 137k| DEC_IEEE_754_Invalid_operation | \ | | ------------------ | | | | 173| 137k| #define DEC_IEEE_754_Invalid_operation (DEC_Conversion_syntax | \ | | | | ------------------ | | | | | | 128| 137k| #define DEC_Conversion_syntax 0x00000001 | | | | ------------------ | | | | 174| 137k| DEC_Division_impossible | \ | | | | ------------------ | | | | | | 130| 137k| #define DEC_Division_impossible 0x00000004 | | | | ------------------ | | | | 175| 137k| DEC_Division_undefined | \ | | | | ------------------ | | | | | | 131| 137k| #define DEC_Division_undefined 0x00000008 | | | | ------------------ | | | | 176| 137k| DEC_Insufficient_storage | \ | | | | ------------------ | | | | | | 132| 137k| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ | | | | ------------------ | | | | 177| 137k| DEC_Invalid_context | \ | | | | ------------------ | | | | | | 134| 137k| #define DEC_Invalid_context 0x00000040 | | | | ------------------ | | | | 178| 137k| DEC_Invalid_operation) | | | | ------------------ | | | | | | 135| 137k| #define DEC_Invalid_operation 0x00000080 | | | | ------------------ | | ------------------ | | 185| 137k| DEC_IEEE_754_Overflow | DEC_IEEE_754_Underflow) | | ------------------ | | | | 179| 137k| #define DEC_IEEE_754_Overflow (DEC_Overflow) | | | | ------------------ | | | | | | 139| 137k| #define DEC_Overflow 0x00000200 | | | | ------------------ | | ------------------ | | DEC_IEEE_754_Overflow | DEC_IEEE_754_Underflow) | | ------------------ | | | | 180| 137k| #define DEC_IEEE_754_Underflow (DEC_Underflow) | | | | ------------------ | | | | | | 143| 137k| #define DEC_Underflow 0x00002000 | | | | ------------------ | | ------------------ ------------------ 79| 137k| context->status=0; // cleared 80| 137k| context->clamp=0; // no clamping 81| | #if DECSUBSET 82| | context->extended=0; // cleared 83| | #endif 84| 137k| switch (kind) { 85| 1| case DEC_INIT_BASE: ------------------ | | 227| 1| #define DEC_INIT_BASE 0 ------------------ | Branch (85:5): [True: 1, False: 137k] ------------------ 86| | // [use defaults] 87| 1| break; 88| 0| case DEC_INIT_DECIMAL32: ------------------ | | 228| 0| #define DEC_INIT_DECIMAL32 32 ------------------ | Branch (88:5): [True: 0, False: 137k] ------------------ 89| 0| context->digits=7; // digits 90| 0| context->emax=96; // Emax 91| 0| context->emin=-95; // Emin 92| 0| context->round=DEC_ROUND_HALF_EVEN; // 0.5 to nearest even 93| 0| context->traps=0; // no traps set 94| 0| context->clamp=1; // clamp exponents 95| | #if DECSUBSET 96| | context->extended=1; // set 97| | #endif 98| 0| break; 99| 137k| case DEC_INIT_DECIMAL64: ------------------ | | 229| 137k| #define DEC_INIT_DECIMAL64 64 ------------------ | Branch (99:5): [True: 137k, False: 1] ------------------ 100| 137k| context->digits=16; // digits 101| 137k| context->emax=384; // Emax 102| 137k| context->emin=-383; // Emin 103| 137k| context->round=DEC_ROUND_HALF_EVEN; // 0.5 to nearest even 104| 137k| context->traps=0; // no traps set 105| 137k| context->clamp=1; // clamp exponents 106| | #if DECSUBSET 107| | context->extended=1; // set 108| | #endif 109| 137k| break; 110| 0| case DEC_INIT_DECIMAL128: ------------------ | | 230| 0| #define DEC_INIT_DECIMAL128 128 ------------------ | Branch (110:5): [True: 0, False: 137k] ------------------ 111| 0| context->digits=34; // digits 112| 0| context->emax=6144; // Emax 113| 0| context->emin=-6143; // Emin 114| 0| context->round=DEC_ROUND_HALF_EVEN; // 0.5 to nearest even 115| 0| context->traps=0; // no traps set 116| 0| context->clamp=1; // clamp exponents 117| | #if DECSUBSET 118| | context->extended=1; // set 119| | #endif 120| 0| break; 121| | 122| 0| default: // invalid Kind ------------------ | Branch (122:5): [True: 0, False: 137k] ------------------ 123| | // use defaults, and .. 124| 0| decContextSetStatus(context, DEC_Invalid_operation); // trap ------------------ | | 135| 0| #define DEC_Invalid_operation 0x00000080 ------------------ 125| 137k| } 126| | 127| 137k| return context;} // decContextDefault decContextSetStatus: 211| 80.5k|decContext * decContextSetStatus(decContext *context, uInt status) { 212| 80.5k| context->status|=status; 213| 80.5k| if (status & context->traps) raise(SIGFPE); ------------------ | Branch (213:7): [True: 0, False: 80.5k] ------------------ 214| 80.5k| return context;} // decContextSetStatus decNumberToString: 448| 1.58M|char * decNumberToString(const decNumber *dn, char *string){ 449| 1.58M| decToString(dn, string, 0); 450| 1.58M| return string; 451| 1.58M| } // DecNumberToString decNumberFromString: 479| 7.84M| decContext *set) { 480| 7.84M| Int exponent=0; // working exponent [assume 0] ------------------ | | 92| 7.84M| #define Int int32_t ------------------ 481| 7.84M| uByte bits=0; // working flags [assume +ve] ------------------ | | 89| 7.84M| #define uByte uint8_t ------------------ 482| 7.84M| Unit *res; // where result will be built ------------------ | | 94| 7.84M| #define Unit decNumberUnit | | ------------------ | | | | 59| 7.84M| #define decNumberUnit uint16_t | | ------------------ ------------------ 483| 7.84M| Unit resbuff[SD2U(DECBUFFER+9)];// local buffer in case need temporary ------------------ | | 94| 7.84M| #define Unit decNumberUnit | | ------------------ | | | | 59| 7.84M| #define decNumberUnit uint16_t | | ------------------ ------------------ 484| | // [+9 allows for ln() constants] 485| 7.84M| Unit *allocres=NULL; // -> allocated result, iff allocated ------------------ | | 94| 7.84M| #define Unit decNumberUnit | | ------------------ | | | | 59| 7.84M| #define decNumberUnit uint16_t | | ------------------ ------------------ 486| 7.84M| Int d=0; // count of digits found in decimal part ------------------ | | 92| 7.84M| #define Int int32_t ------------------ 487| 7.84M| const char *dotchar=NULL; // where dot was found 488| 7.84M| const char *cfirst=chars; // -> first character of decimal part 489| 7.84M| const char *last=NULL; // -> last digit of decimal part 490| 7.84M| const char *c; // work 491| 7.84M| Unit *up; // .. ------------------ | | 94| 7.84M| #define Unit decNumberUnit | | ------------------ | | | | 59| 7.84M| #define decNumberUnit uint16_t | | ------------------ ------------------ 492| 7.84M| #if DECDPUN>1 493| 7.84M| Int cut, out; // .. ------------------ | | 92| 7.84M| #define Int int32_t ------------------ 494| 7.84M| #endif 495| 7.84M| Int residue; // rounding residue ------------------ | | 92| 7.84M| #define Int int32_t ------------------ 496| 7.84M| uInt status=0; // error code ------------------ | | 93| 7.84M| #define uInt uint32_t ------------------ 497| | 498| | #if DECCHECK 499| | if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set)) 500| | return decNumberZero(dn); 501| | #endif 502| | 503| 7.84M| do { // status & malloc protection 504| 44.4M| for (c=chars;; c++) { // -> input character 505| 44.4M| if (*c>='0' && *c<='9') { // test for Arabic digit ------------------ | Branch (505:11): [True: 36.8M, False: 7.60M] | Branch (505:22): [True: 36.2M, False: 570k] ------------------ 506| 36.2M| last=c; 507| 36.2M| d++; // count of real digits 508| 36.2M| continue; // still in decimal part 509| 36.2M| } 510| 8.17M| if (*c=='.' && dotchar==NULL) { // first '.' ------------------ | Branch (510:11): [True: 317k, False: 7.86M] | Branch (510:22): [True: 316k, False: 295] ------------------ 511| 316k| dotchar=c; // record offset into decimal part 512| 316k| if (c==cfirst) cfirst++; // first digit must follow ------------------ | Branch (512:13): [True: 4.74k, False: 312k] ------------------ 513| 316k| continue;} 514| 7.86M| if (c==chars) { // first in string... ------------------ | Branch (514:11): [True: 29.0k, False: 7.83M] ------------------ 515| 29.0k| if (*c=='-') { // valid - sign ------------------ | Branch (515:13): [True: 13.7k, False: 15.2k] ------------------ 516| 13.7k| cfirst++; 517| 13.7k| bits=DECNEG; ------------------ | | 31| 13.7k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 518| 13.7k| continue;} 519| 15.2k| if (*c=='+') { // valid + sign ------------------ | Branch (519:13): [True: 324, False: 14.9k] ------------------ 520| 324| cfirst++; 521| 324| continue;} 522| 15.2k| } 523| | // *c is not a digit, or a valid +, -, or '.' 524| 7.84M| break; 525| 7.86M| } // c 526| | 527| 7.84M| if (last==NULL) { // no digits yet ------------------ | Branch (527:9): [True: 15.1k, False: 7.83M] ------------------ 528| 15.1k| status=DEC_Conversion_syntax;// assume the worst ------------------ | | 128| 15.1k| #define DEC_Conversion_syntax 0x00000001 ------------------ 529| 15.1k| if (*c=='\0') break; // and no more to come... ------------------ | Branch (529:11): [True: 634, False: 14.5k] ------------------ 530| | #if DECSUBSET 531| | // if subset then infinities and NaNs are not allowed 532| | if (!set->extended) break; // hopeless 533| | #endif 534| | // Infinities and NaNs are possible, here 535| 14.5k| if (dotchar!=NULL) break; // .. unless had a dot ------------------ | Branch (535:11): [True: 120, False: 14.4k] ------------------ 536| 14.4k| decNumberZero(dn); // be optimistic 537| 14.4k| if (decBiStr(c, "infinity", "INFINITY") ------------------ | Branch (537:11): [True: 213, False: 14.1k] ------------------ 538| 14.1k| || decBiStr(c, "inf", "INF")) { ------------------ | Branch (538:11): [True: 1.04k, False: 13.1k] ------------------ 539| 1.25k| dn->bits=bits | DECINF; ------------------ | | 32| 1.25k| #define DECINF 0x40 /* 1=Infinity */ ------------------ 540| 1.25k| status=0; // is OK 541| 1.25k| break; // all done 542| 1.25k| } 543| | // a NaN expected 544| | // 2003.09.10 NaNs are now permitted to have a sign 545| 13.1k| dn->bits=bits | DECNAN; // assume simple NaN ------------------ | | 33| 13.1k| #define DECNAN 0x20 /* 1=NaN */ ------------------ 546| 13.1k| if (*c=='s' || *c=='S') { // looks like an sNaN ------------------ | Branch (546:11): [True: 380, False: 12.7k] | Branch (546:22): [True: 195, False: 12.5k] ------------------ 547| 575| c++; 548| 575| dn->bits=bits | DECSNAN; ------------------ | | 34| 575| #define DECSNAN 0x10 /* 1=sNaN */ ------------------ 549| 575| } 550| 13.1k| if (*c!='n' && *c!='N') break; // check caseless "NaN" ------------------ | Branch (550:11): [True: 10.7k, False: 2.37k] | Branch (550:22): [True: 1.81k, False: 8.95k] ------------------ 551| 11.3k| c++; 552| 11.3k| if (*c!='a' && *c!='A') break; // .. ------------------ | Branch (552:11): [True: 2.33k, False: 8.99k] | Branch (552:22): [True: 691, False: 1.64k] ------------------ 553| 10.6k| c++; 554| 10.6k| if (*c!='n' && *c!='N') break; // .. ------------------ | Branch (554:11): [True: 7.95k, False: 2.67k] | Branch (554:22): [True: 1.31k, False: 6.64k] ------------------ 555| 9.32k| c++; 556| | // now either nothing, or nnnn payload, expected 557| | // -> start of integer and skip leading 0s [including plain 0] 558| 10.8k| for (cfirst=c; *cfirst=='0';) cfirst++; ------------------ | Branch (558:22): [True: 1.50k, False: 9.32k] ------------------ 559| 9.32k| if (*cfirst=='\0') { // "NaN" or "sNaN", maybe with all 0s ------------------ | Branch (559:11): [True: 3.50k, False: 5.81k] ------------------ 560| 3.50k| status=0; // it's good 561| 3.50k| break; // .. 562| 3.50k| } 563| | // something other than 0s; setup last and d as usual [no dots] 564| 82.3k| for (c=cfirst;; c++, d++) { 565| 82.3k| if (*c<'0' || *c>'9') break; // test for Arabic digit ------------------ | Branch (565:13): [True: 5.16k, False: 77.1k] | Branch (565:23): [True: 653, False: 76.5k] ------------------ 566| 76.5k| last=c; 567| 76.5k| } 568| 5.81k| if (*c!='\0') break; // not all digits ------------------ | Branch (568:11): [True: 4.98k, False: 829] ------------------ 569| 829| if (d>set->digits-1) { ------------------ | Branch (569:11): [True: 0, False: 829] ------------------ 570| | // [NB: payload in a decNumber can be full length unless 571| | // clamped, in which case can only be digits-1] 572| 0| if (set->clamp) break; ------------------ | Branch (572:13): [True: 0, False: 0] ------------------ 573| 0| if (d>set->digits) break; ------------------ | Branch (573:13): [True: 0, False: 0] ------------------ 574| 0| } // too many digits? 575| | // good; drop through to convert the integer to coefficient 576| 829| status=0; // syntax is OK 577| 829| bits=dn->bits; // for copy-back 578| 829| } // last==NULL 579| | 580| 7.83M| else if (*c!='\0') { // more to process... ------------------ | Branch (580:15): [True: 557k, False: 7.27M] ------------------ 581| | // had some digits; exponent is only valid sequence now 582| 557k| Flag nege; // 1=negative exponent ------------------ | | 87| 557k| #define Flag uint8_t ------------------ 583| 557k| const char *firstexp; // -> first significant exponent digit 584| 557k| status=DEC_Conversion_syntax;// assume the worst ------------------ | | 128| 557k| #define DEC_Conversion_syntax 0x00000001 ------------------ 585| 557k| uInt expa=0; // accumulator for exponent ------------------ | | 93| 557k| #define uInt uint32_t ------------------ 586| 557k| if (*c!='e' && *c!='E') break; ------------------ | Branch (586:11): [True: 85.2k, False: 472k] | Branch (586:22): [True: 1.51k, False: 83.7k] ------------------ 587| | /* Found 'e' or 'E' -- now process explicit exponent */ 588| | // 1998.07.11: sign no longer required 589| 556k| nege=0; 590| 556k| c++; // to (possible) sign 591| 556k| if (*c=='-') {nege=1; c++;} ------------------ | Branch (591:11): [True: 17.4k, False: 538k] ------------------ 592| 538k| else if (*c=='+') c++; ------------------ | Branch (592:17): [True: 1.25k, False: 537k] ------------------ 593| 556k| if (*c=='\0') break; ------------------ | Branch (593:11): [True: 367, False: 555k] ------------------ 594| | 595| 557k| for (; *c=='0' && *(c+1)!='\0';) c++; // strip insignificant zeros ------------------ | Branch (595:14): [True: 1.82k, False: 555k] | Branch (595:25): [True: 1.51k, False: 306] ------------------ 596| 555k| firstexp=c; // save exponent digit place 597| 3.24M| for (; ;c++) { 598| 3.24M| if (*c<'0' || *c>'9') break; // not a digit ------------------ | Branch (598:13): [True: 555k, False: 2.68M] | Branch (598:23): [True: 18, False: 2.68M] ------------------ 599| 2.68M| expa=X10(expa)+(Int)*c-(Int)'0'; ------------------ | | 163| 2.68M| #define X10(i) (((i)<<1)+((i)<<3)) ------------------ 600| 2.68M| } // c 601| | // if not now on a '\0', *c must not be a digit 602| 555k| if (*c!='\0') break; ------------------ | Branch (602:11): [True: 321, False: 555k] ------------------ 603| | 604| | // (this next test must be after the syntax checks) 605| | // if it was too long the exponent may have wrapped, so check 606| | // carefully and set it to a certain overflow if wrap possible 607| 555k| if (c>=firstexp+9+1) { ------------------ | Branch (607:11): [True: 50.9k, False: 504k] ------------------ 608| 50.9k| if (c>firstexp+9+1 || *firstexp>'1') expa=DECNUMMAXE*2; ------------------ | | 183| 44.6k| #define DECNUMMAXE 999999999 /* maximum adjusted exponent ditto */ ------------------ | Branch (608:13): [True: 2.79k, False: 48.1k] | Branch (608:31): [True: 41.8k, False: 6.30k] ------------------ 609| | // [up to 1999999999 is OK, for example 1E-1000000998] 610| 50.9k| } 611| 555k| exponent=(Int)expa; // save exponent 612| 555k| if (nege) exponent=-exponent; // was negative ------------------ | Branch (612:11): [True: 17.4k, False: 538k] ------------------ 613| 555k| status=0; // is OK 614| 555k| } // stuff after digits 615| | 616| | // Here when whole string has been inspected; syntax is good 617| | // cfirst->first digit (never dot), last->last digit (ditto) 618| | 619| | // strip leading zeros/dot [leave final 0 if all 0's] 620| 7.83M| if (*cfirst=='0') { // [cfirst has stepped over .] ------------------ | Branch (620:9): [True: 1.63M, False: 6.19M] ------------------ 621| 4.25M| for (c=cfirst; cextended) { 629| | decNumberZero(dn); // clean result 630| | break; // [could be return] 631| | } 632| | #endif 633| 1.63M| } // at least one leading 0 634| | 635| | // Handle decimal point... 636| 7.83M| if (dotchar!=NULL && dotchardigits) res=dn->lsu; // fits into supplied decNumber ------------------ | Branch (642:9): [True: 7.83M, False: 0] ------------------ 643| 0| else { // rounding needed 644| 0| Int needbytes=D2U(d)*sizeof(Unit);// bytes needed ------------------ | | 92| 0| #define Int int32_t ------------------ Int needbytes=D2U(d)*sizeof(Unit);// bytes needed ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 645| 0| res=resbuff; // assume use local buffer 646| 0| if (needbytes>(Int)sizeof(resbuff)) { // too big for local ------------------ | Branch (646:11): [True: 0, False: 0] ------------------ 647| 0| allocres=(Unit *)malloc(needbytes); 648| 0| if (allocres==NULL) {status|=DEC_Insufficient_storage; break;} ------------------ | | 132| 0| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ ------------------ | Branch (648:13): [True: 0, False: 0] ------------------ 649| 0| res=allocres; 650| 0| } 651| 0| } 652| | // res now -> number lsu, buffer, or allocated storage for Unit array 653| | 654| | // Place the coefficient into the selected Unit array 655| | // [this is often 70% of the cost of this function when DECDPUN>1] 656| 7.83M| #if DECDPUN>1 657| 7.83M| out=0; // accumulator 658| 7.83M| up=res+D2U(d)-1; // -> msu ------------------ | | 264| 7.83M| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 7.83M| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 8.15k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 8.15k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 7.82M, False: 8.15k] | | ------------------ ------------------ 659| 7.83M| cut=d-(up-res)*DECDPUN; // digits in top unit ------------------ | | 43| 7.83M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 660| 33.9M| for (c=cfirst;; c++) { // along the digits 661| 33.9M| if (*c=='.') continue; // ignore '.' [don't decrement cut] ------------------ | Branch (661:11): [True: 31.9k, False: 33.8M] ------------------ 662| 33.8M| out=X10(out)+(Int)*c-(Int)'0'; ------------------ | | 163| 33.8M| #define X10(i) (((i)<<1)+((i)<<3)) ------------------ 663| 33.8M| if (c==last) break; // done [never get to trailing '.'] ------------------ | Branch (663:11): [True: 7.83M, False: 26.0M] ------------------ 664| 26.0M| cut--; 665| 26.0M| if (cut>0) continue; // more for this unit ------------------ | Branch (665:11): [True: 17.9M, False: 8.12M] ------------------ 666| 8.12M| *up=(Unit)out; // write unit 667| 8.12M| up--; // prepare for unit below.. 668| 8.12M| cut=DECDPUN; // .. ------------------ | | 43| 8.12M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 669| 8.12M| out=0; // .. 670| 8.12M| } // c 671| 7.83M| *up=(Unit)out; // write lsu 672| | 673| | #else 674| | // DECDPUN==1 675| | up=res; // -> lsu 676| | for (c=last; c>=cfirst; c--) { // over each character, from least 677| | if (*c=='.') continue; // ignore . [don't step up] 678| | *up=(Unit)((Int)*c-(Int)'0'); 679| | up++; 680| | } // c 681| | #endif 682| | 683| 7.83M| dn->bits=bits; 684| 7.83M| dn->exponent=exponent; 685| 7.83M| dn->digits=d; 686| | 687| | // if not in number (too long) shorten into the number 688| 7.83M| if (d>set->digits) { ------------------ | Branch (688:9): [True: 0, False: 7.83M] ------------------ 689| 0| residue=0; 690| 0| decSetCoeff(dn, set, res, d, &residue, &status); 691| | // always check for overflow or subnormal and round as needed 692| 0| decFinalize(dn, set, &residue, &status); 693| 0| } 694| 7.83M| else { // no rounding, but may still have overflow or subnormal 695| | // [these tests are just for performance; finalize repeats them] 696| 7.83M| if ((dn->exponent-1emin-dn->digits) ------------------ | Branch (696:11): [True: 7.35k, False: 7.82M] ------------------ 697| 7.82M| || (dn->exponent-1>set->emax-set->digits)) { ------------------ | Branch (697:11): [True: 44.2k, False: 7.77M] ------------------ 698| 51.6k| residue=0; 699| 51.6k| decFinalize(dn, set, &residue, &status); 700| 51.6k| } 701| 7.83M| } 702| | // decNumberShow(dn); 703| 7.83M| } while(0); // [for break] ------------------ | Branch (703:13): [Folded, False: 7.83M] ------------------ 704| | 705| 7.84M| if (allocres!=NULL) free(allocres); // drop any storage used ------------------ | Branch (705:7): [True: 0, False: 7.84M] ------------------ 706| 7.84M| if (status!=0) decStatus(dn, status, set); ------------------ | Branch (706:7): [True: 61.7k, False: 7.78M] ------------------ 707| 7.84M| return dn; 708| 7.84M| } /* decNumberFromString */ decNumberAbs: 730| 567k| decContext *set) { 731| 567k| decNumber dzero; // for 0 732| 567k| uInt status=0; // accumulator ------------------ | | 93| 567k| #define uInt uint32_t ------------------ 733| | 734| | #if DECCHECK 735| | if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 736| | #endif 737| | 738| 567k| decNumberZero(&dzero); // set 0 739| 567k| dzero.exponent=rhs->exponent; // [no coefficient expansion] 740| 567k| decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status); ------------------ | | 31| 567k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 741| 567k| if (status!=0) decStatus(res, status, set); ------------------ | Branch (741:7): [True: 1.24k, False: 565k] ------------------ 742| | #if DECCHECK 743| | decCheckInexact(res, set); 744| | #endif 745| 567k| return res; 746| 567k| } // decNumberAbs decNumberCompare: 856| 1.79M| const decNumber *rhs, decContext *set) { 857| 1.79M| uInt status=0; // accumulator ------------------ | | 93| 1.79M| #define uInt uint32_t ------------------ 858| 1.79M| decCompareOp(res, lhs, rhs, set, COMPARE, &status); ------------------ | | 184| 1.79M|#define COMPARE 0x01 // Compare operators ------------------ 859| 1.79M| if (status!=0) decStatus(res, status, set); ------------------ | Branch (859:7): [True: 0, False: 1.79M] ------------------ 860| 1.79M| return res; 861| 1.79M| } // decNumberCompare decNumberMinus: 1629| 1.04k| decContext *set) { 1630| 1.04k| decNumber dzero; 1631| 1.04k| uInt status=0; // accumulator ------------------ | | 93| 1.04k| #define uInt uint32_t ------------------ 1632| | 1633| | #if DECCHECK 1634| | if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 1635| | #endif 1636| | 1637| 1.04k| decNumberZero(&dzero); // make 0 1638| 1.04k| dzero.exponent=rhs->exponent; // [no coefficient expansion] 1639| 1.04k| decAddOp(res, &dzero, rhs, set, DECNEG, &status); ------------------ | | 31| 1.04k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 1640| 1.04k| if (status!=0) decStatus(res, status, set); ------------------ | Branch (1640:7): [True: 277, False: 763] ------------------ 1641| | #if DECCHECK 1642| | decCheckInexact(res, set); 1643| | #endif 1644| 1.04k| return res; 1645| 1.04k| } // decNumberMinus decNumberReduce: 2310| 137k| decContext *set) { 2311| | #if DECSUBSET 2312| | decNumber *allocrhs=NULL; // non-NULL if rounded rhs allocated 2313| | #endif 2314| 137k| uInt status=0; // as usual ------------------ | | 93| 137k| #define uInt uint32_t ------------------ 2315| 137k| Int residue=0; // as usual ------------------ | | 92| 137k| #define Int int32_t ------------------ 2316| 137k| Int dropped; // work ------------------ | | 92| 137k| #define Int int32_t ------------------ 2317| | 2318| | #if DECCHECK 2319| | if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2320| | #endif 2321| | 2322| 137k| do { // protect allocated storage 2323| | #if DECSUBSET 2324| | if (!set->extended) { 2325| | // reduce operand and set lostDigits status, as needed 2326| | if (rhs->digits>set->digits) { 2327| | allocrhs=decRoundOperand(rhs, set, &status); 2328| | if (allocrhs==NULL) break; 2329| | rhs=allocrhs; 2330| | } 2331| | } 2332| | #endif 2333| | // [following code does not require input rounding] 2334| | 2335| | // Infinities copy through; NaNs need usual treatment 2336| 137k| if (decNumberIsNaN(rhs)) { ------------------ | | 172| 137k| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 137k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 137k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (172:36): [True: 0, False: 137k] | | ------------------ ------------------ 2337| 0| decNaNs(res, rhs, NULL, set, &status); 2338| 0| break; 2339| 0| } 2340| | 2341| | // reduce result to the requested length and copy to result 2342| 137k| decCopyFit(res, rhs, set, &residue, &status); // copy & round 2343| 137k| decFinish(res, set, &residue, &status); // cleanup/set flags ------------------ | | 267| 137k|#define decFinish(a,b,c,d) decFinalize(a,b,c,d) ------------------ 2344| 137k| decTrim(res, set, 1, 0, &dropped); // normalize in place 2345| | // [may clamp] 2346| 137k| } while(0); // end protected ------------------ | Branch (2346:13): [Folded, False: 137k] ------------------ 2347| | 2348| | #if DECSUBSET 2349| | if (allocrhs !=NULL) free(allocrhs); // .. 2350| | #endif 2351| 137k| if (status!=0) decStatus(res, status, set);// then report status ------------------ | Branch (2351:7): [True: 17.2k, False: 119k] ------------------ 2352| 137k| return res; 2353| 137k| } // decNumberReduce decNumberZero: 3588| 2.42M|decNumber * decNumberZero(decNumber *dn) { 3589| | 3590| | #if DECCHECK 3591| | if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 3592| | #endif 3593| | 3594| 2.42M| dn->bits=0; 3595| 2.42M| dn->exponent=0; 3596| 2.42M| dn->digits=1; 3597| 2.42M| dn->lsu[0]=0; 3598| 2.42M| return dn; 3599| 2.42M| } // decNumberZero decNumber.c:decToString: 3621| 1.58M|static void decToString(const decNumber *dn, char *string, Flag eng) { 3622| 1.58M| Int exp=dn->exponent; // local copy ------------------ | | 92| 1.58M| #define Int int32_t ------------------ 3623| 1.58M| Int e; // E-part value ------------------ | | 92| 1.58M| #define Int int32_t ------------------ 3624| 1.58M| Int pre; // digits before the '.' ------------------ | | 92| 1.58M| #define Int int32_t ------------------ 3625| 1.58M| Int cut; // for counting digits in a Unit ------------------ | | 92| 1.58M| #define Int int32_t ------------------ 3626| 1.58M| char *c=string; // work [output pointer] 3627| 1.58M| const Unit *up=dn->lsu+D2U(dn->digits)-1; // -> msu [input pointer] ------------------ | | 264| 1.58M| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.58M| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 592| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 592| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.58M, False: 592] | | ------------------ ------------------ 3628| 1.58M| uInt u, pow; // work ------------------ | | 93| 1.58M| #define uInt uint32_t ------------------ 3629| | 3630| | #if DECCHECK 3631| | if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) { 3632| | strcpy(string, "?"); 3633| | return;} 3634| | #endif 3635| | 3636| 1.58M| if (decNumberIsNegative(dn)) { // Negatives get a minus ------------------ | | 173| 1.58M| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 1.58M| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 5.58k, False: 1.58M] | | ------------------ ------------------ 3637| 5.58k| *c='-'; 3638| 5.58k| c++; 3639| 5.58k| } 3640| 1.58M| if (dn->bits&DECSPECIAL) { // Is a special value ------------------ | | 36| 1.58M| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 32| 1.58M| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 33| 1.58M| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 34| 1.58M| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ | Branch (3640:7): [True: 3.33k, False: 1.58M] ------------------ 3641| 3.33k| if (decNumberIsInfinite(dn)) { ------------------ | | 171| 3.33k| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 3.33k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 3.33k, False: 0] | | ------------------ ------------------ 3642| 3.33k| strcpy(c, "Inf"); 3643| 3.33k| strcpy(c+3, "inity"); 3644| 3.33k| return;} 3645| | // a NaN 3646| 0| if (dn->bits&DECSNAN) { // signalling NaN ------------------ | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ ------------------ | Branch (3646:9): [True: 0, False: 0] ------------------ 3647| 0| *c='s'; 3648| 0| c++; 3649| 0| } 3650| 0| strcpy(c, "NaN"); 3651| 0| c+=3; // step past 3652| | // if not a clean non-zero coefficient, that's all there is in a 3653| | // NaN string 3654| 0| if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return; ------------------ | Branch (3654:9): [True: 0, False: 0] | Branch (3654:20): [True: 0, False: 0] | Branch (3654:35): [True: 0, False: 0] ------------------ 3655| | // [drop through to add integer] 3656| 0| } 3657| | 3658| | // calculate how many digits in msu, and hence first cut 3659| 1.58M| cut=MSUDIGITS(dn->digits); // [faster than remainder] ------------------ | | 271| 1.58M| #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 264| 1.58M| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 249| 1.58M| #define DECMAXD2U 49 | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 592| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 592| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | | Branch (264:21): [True: 1.58M, False: 592] | | | | ------------------ | | ------------------ | | #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 43| 1.58M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ ------------------ 3660| 1.58M| cut--; // power of ten for digit 3661| | 3662| 1.58M| if (exp==0) { // simple integer [common fastpath] ------------------ | Branch (3662:7): [True: 1.43M, False: 150k] ------------------ 3663| 3.11M| for (;up>=dn->lsu; up--) { // each Unit from msu ------------------ | Branch (3663:11): [True: 1.68M, False: 1.43M] ------------------ 3664| 1.68M| u=*up; // contains DECDPUN digits to lay out 3665| 3.90M| for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow); ------------------ | | 288| 2.21M| #define TODIGIT(u, cut, c, pow) { \ | | 289| 2.21M| *(c)='0'; \ | | 290| 2.21M| pow=DECPOWERS[cut]*2; \ | | 291| 2.21M| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 958k, False: 1.26M] | | ------------------ | | 292| 958k| pow*=4; \ | | 293| 958k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 53.9k, False: 904k] | | ------------------ | | 294| 958k| pow/=2; \ | | 295| 958k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 868k, False: 89.4k] | | ------------------ | | 296| 958k| pow/=2; \ | | 297| 958k| } \ | | 298| 2.21M| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 862k, False: 1.35M] | | ------------------ | | 299| 2.21M| pow/=2; \ | | 300| 2.21M| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 939k, False: 1.27M] | | ------------------ | | 301| 2.21M| } ------------------ | Branch (3665:14): [True: 2.21M, False: 1.68M] ------------------ 3666| 1.68M| cut=DECDPUN-1; // next Unit has all digits ------------------ | | 43| 1.68M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3667| 1.68M| } 3668| 1.43M| *c='\0'; // terminate the string 3669| 1.43M| return;} 3670| | 3671| | /* non-0 exponent -- assume plain form */ 3672| 150k| pre=dn->digits+exp; // digits before '.' 3673| 150k| e=0; // no E 3674| 150k| if ((exp>0) || (pre<-5)) { // need exponential form ------------------ | Branch (3674:7): [True: 23.4k, False: 126k] | Branch (3674:18): [True: 8.72k, False: 118k] ------------------ 3675| 32.2k| e=exp+dn->digits-1; // calculate E value 3676| 32.2k| pre=1; // assume one digit before '.' 3677| 32.2k| if (eng && (e!=0)) { // engineering: may need to adjust ------------------ | Branch (3677:9): [True: 0, False: 32.2k] | Branch (3677:16): [True: 0, False: 0] ------------------ 3678| 0| Int adj; // adjustment ------------------ | | 92| 0| #define Int int32_t ------------------ 3679| | // The C remainder operator is undefined for negative numbers, so 3680| | // a positive remainder calculation must be used here 3681| 0| if (e<0) { ------------------ | Branch (3681:11): [True: 0, False: 0] ------------------ 3682| 0| adj=(-e)%3; 3683| 0| if (adj!=0) adj=3-adj; ------------------ | Branch (3683:13): [True: 0, False: 0] ------------------ 3684| 0| } 3685| 0| else { // e>0 3686| 0| adj=e%3; 3687| 0| } 3688| 0| e=e-adj; 3689| | // if dealing with zero still produce an exponent which is a 3690| | // multiple of three, as expected, but there will only be the 3691| | // one zero before the E, still. Otherwise note the padding. 3692| 0| if (!ISZERO(dn)) pre+=adj; ------------------ | | 255| 0| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 0| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 0, False: 0] | | | | ------------------ | | | | 178| 0| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 0, False: 0] | | | | ------------------ | | | | 179| 0| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 0| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 0| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3693| 0| else { // is zero 3694| 0| if (adj!=0) { // 0.00Esnn needed ------------------ | Branch (3694:13): [True: 0, False: 0] ------------------ 3695| 0| e=e+3; 3696| 0| pre=-(2-adj); 3697| 0| } 3698| 0| } // zero 3699| 0| } // eng 3700| 32.2k| } // need exponent 3701| | 3702| | /* lay out the digits of the coefficient, adding 0s and . as needed */ 3703| 150k| u=*up; 3704| 150k| if (pre>0) { // xxx.xxx or xx00 (engineering) form ------------------ | Branch (3704:7): [True: 39.6k, False: 110k] ------------------ 3705| 39.6k| Int n=pre; ------------------ | | 92| 39.6k| #define Int int32_t ------------------ 3706| 1.13M| for (; pre>0; pre--, c++, cut--) { ------------------ | Branch (3706:12): [True: 1.09M, False: 39.6k] ------------------ 3707| 1.09M| if (cut<0) { // need new Unit ------------------ | Branch (3707:11): [True: 352k, False: 743k] ------------------ 3708| 352k| if (up==dn->lsu) break; // out of input digits (pre>digits) ------------------ | Branch (3708:13): [True: 0, False: 352k] ------------------ 3709| 352k| up--; 3710| 352k| cut=DECDPUN-1; ------------------ | | 43| 352k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3711| 352k| u=*up; 3712| 352k| } 3713| 1.09M| TODIGIT(u, cut, c, pow); ------------------ | | 288| 1.09M| #define TODIGIT(u, cut, c, pow) { \ | | 289| 1.09M| *(c)='0'; \ | | 290| 1.09M| pow=DECPOWERS[cut]*2; \ | | 291| 1.09M| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 153k, False: 941k] | | ------------------ | | 292| 153k| pow*=4; \ | | 293| 153k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 132k, False: 21.6k] | | ------------------ | | 294| 153k| pow/=2; \ | | 295| 153k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 15.9k, False: 137k] | | ------------------ | | 296| 153k| pow/=2; \ | | 297| 153k| } \ | | 298| 1.09M| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 13.5k, False: 1.08M] | | ------------------ | | 299| 1.09M| pow/=2; \ | | 300| 1.09M| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 148k, False: 947k] | | ------------------ | | 301| 1.09M| } ------------------ 3714| 1.09M| } 3715| 39.6k| if (ndigits) { // more to come, after '.' ------------------ | Branch (3715:9): [True: 27.0k, False: 12.6k] ------------------ 3716| 27.0k| *c='.'; c++; 3717| 2.37M| for (;; c++, cut--) { 3718| 2.37M| if (cut<0) { // need new Unit ------------------ | Branch (3718:13): [True: 801k, False: 1.57M] ------------------ 3719| 801k| if (up==dn->lsu) break; // out of input digits ------------------ | Branch (3719:15): [True: 27.0k, False: 774k] ------------------ 3720| 774k| up--; 3721| 774k| cut=DECDPUN-1; ------------------ | | 43| 774k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3722| 774k| u=*up; 3723| 774k| } 3724| 2.34M| TODIGIT(u, cut, c, pow); ------------------ | | 288| 2.34M| #define TODIGIT(u, cut, c, pow) { \ | | 289| 2.34M| *(c)='0'; \ | | 290| 2.34M| pow=DECPOWERS[cut]*2; \ | | 291| 2.34M| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 445k, False: 1.90M] | | ------------------ | | 292| 445k| pow*=4; \ | | 293| 445k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 324k, False: 121k] | | ------------------ | | 294| 445k| pow/=2; \ | | 295| 445k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 77.8k, False: 368k] | | ------------------ | | 296| 445k| pow/=2; \ | | 297| 445k| } \ | | 298| 2.34M| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 100k, False: 2.24M] | | ------------------ | | 299| 2.34M| pow/=2; \ | | 300| 2.34M| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 405k, False: 1.94M] | | ------------------ | | 301| 2.34M| } ------------------ 3725| 2.34M| } 3726| 27.0k| } 3727| 12.6k| else for (; pre>0; pre--, c++) *c='0'; // 0 padding (for engineering) needed ------------------ | Branch (3727:18): [True: 0, False: 12.6k] ------------------ 3728| 39.6k| } 3729| 110k| else { // 0.xxx or 0.000xxx form 3730| 110k| *c='0'; c++; 3731| 110k| *c='.'; c++; 3732| 113k| for (; pre<0; pre++, c++) *c='0'; // add any 0's after '.' ------------------ | Branch (3732:12): [True: 2.45k, False: 110k] ------------------ 3733| 229k| for (; ; c++, cut--) { 3734| 229k| if (cut<0) { // need new Unit ------------------ | Branch (3734:11): [True: 112k, False: 116k] ------------------ 3735| 112k| if (up==dn->lsu) break; // out of input digits ------------------ | Branch (3735:13): [True: 110k, False: 2.33k] ------------------ 3736| 2.33k| up--; 3737| 2.33k| cut=DECDPUN-1; ------------------ | | 43| 2.33k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3738| 2.33k| u=*up; 3739| 2.33k| } 3740| 118k| TODIGIT(u, cut, c, pow); ------------------ | | 288| 118k| #define TODIGIT(u, cut, c, pow) { \ | | 289| 118k| *(c)='0'; \ | | 290| 118k| pow=DECPOWERS[cut]*2; \ | | 291| 118k| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 8.19k, False: 110k] | | ------------------ | | 292| 8.19k| pow*=4; \ | | 293| 8.19k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 4.82k, False: 3.36k] | | ------------------ | | 294| 8.19k| pow/=2; \ | | 295| 8.19k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 2.22k, False: 5.97k] | | ------------------ | | 296| 8.19k| pow/=2; \ | | 297| 8.19k| } \ | | 298| 118k| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 3.01k, False: 115k] | | ------------------ | | 299| 118k| pow/=2; \ | | 300| 118k| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 114k, False: 4.39k] | | ------------------ | | 301| 118k| } ------------------ 3741| 118k| } 3742| 110k| } 3743| | 3744| | /* Finally add the E-part, if needed. It will never be 0, has a 3745| | base maximum and minimum of +999999999 through -999999999, but 3746| | could range down to -1999999998 for anormal numbers */ 3747| 150k| if (e!=0) { ------------------ | Branch (3747:7): [True: 32.2k, False: 118k] ------------------ 3748| 32.2k| Flag had=0; // 1=had non-zero ------------------ | | 87| 32.2k| #define Flag uint8_t ------------------ 3749| 32.2k| *c='E'; c++; 3750| 32.2k| *c='+'; c++; // assume positive 3751| 32.2k| u=e; // .. 3752| 32.2k| if (e<0) { ------------------ | Branch (3752:9): [True: 8.72k, False: 23.4k] ------------------ 3753| 8.72k| *(c-1)='-'; // oops, need - 3754| 8.72k| u=-e; // uInt, please 3755| 8.72k| } 3756| | // lay out the exponent [_itoa or equivalent is not ANSI C] 3757| 354k| for (cut=9; cut>=0; cut--) { ------------------ | Branch (3757:17): [True: 322k, False: 32.2k] ------------------ 3758| 322k| TODIGIT(u, cut, c, pow); ------------------ | | 288| 322k| #define TODIGIT(u, cut, c, pow) { \ | | 289| 322k| *(c)='0'; \ | | 290| 322k| pow=DECPOWERS[cut]*2; \ | | 291| 322k| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 67.3k, False: 254k] | | ------------------ | | 292| 67.3k| pow*=4; \ | | 293| 67.3k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 22.8k, False: 44.4k] | | ------------------ | | 294| 67.3k| pow/=2; \ | | 295| 67.3k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 21.7k, False: 45.5k] | | ------------------ | | 296| 67.3k| pow/=2; \ | | 297| 67.3k| } \ | | 298| 322k| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 36.8k, False: 285k] | | ------------------ | | 299| 322k| pow/=2; \ | | 300| 322k| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 52.8k, False: 269k] | | ------------------ | | 301| 322k| } ------------------ 3759| 322k| if (*c=='0' && !had) continue; // skip leading zeros ------------------ | Branch (3759:11): [True: 237k, False: 85.0k] | Branch (3759:22): [True: 231k, False: 5.66k] ------------------ 3760| 90.6k| had=1; // had non-0 3761| 90.6k| c++; // step for next 3762| 90.6k| } // cut 3763| 32.2k| } 3764| 150k| *c='\0'; // terminate the string (all paths) 3765| 150k| return; 3766| 1.58M| } // decToString decNumber.c:decAddOp: 3805| 568k| uByte negate, uInt *status) { 3806| | #if DECSUBSET 3807| | decNumber *alloclhs=NULL; // non-NULL if rounded lhs allocated 3808| | decNumber *allocrhs=NULL; // .., rhs 3809| | #endif 3810| 568k| Int rhsshift; // working shift (in Units) ------------------ | | 92| 568k| #define Int int32_t ------------------ 3811| 568k| Int maxdigits; // longest logical length ------------------ | | 92| 568k| #define Int int32_t ------------------ 3812| 568k| Int mult; // multiplier ------------------ | | 92| 568k| #define Int int32_t ------------------ 3813| 568k| Int residue; // rounding accumulator ------------------ | | 92| 568k| #define Int int32_t ------------------ 3814| 568k| uByte bits; // result bits ------------------ | | 89| 568k| #define uByte uint8_t ------------------ 3815| 568k| Flag diffsign; // non-0 if arguments have different sign ------------------ | | 87| 568k| #define Flag uint8_t ------------------ 3816| 568k| Unit *acc; // accumulator for result ------------------ | | 94| 568k| #define Unit decNumberUnit | | ------------------ | | | | 59| 568k| #define decNumberUnit uint16_t | | ------------------ ------------------ 3817| 568k| Unit accbuff[SD2U(DECBUFFER*2+20)]; // local buffer [*2+20 reduces many ------------------ | | 94| 568k| #define Unit decNumberUnit | | ------------------ | | | | 59| 568k| #define decNumberUnit uint16_t | | ------------------ ------------------ 3818| | // allocations when called from 3819| | // other operations, notable exp] 3820| 568k| Unit *allocacc=NULL; // -> allocated acc buffer, iff allocated ------------------ | | 94| 568k| #define Unit decNumberUnit | | ------------------ | | | | 59| 568k| #define decNumberUnit uint16_t | | ------------------ ------------------ 3821| 568k| Int reqdigits=set->digits; // local copy; requested DIGITS ------------------ | | 92| 568k| #define Int int32_t ------------------ 3822| 568k| Int padding; // work ------------------ | | 92| 568k| #define Int int32_t ------------------ 3823| | 3824| | #if DECCHECK 3825| | if (decCheckOperands(res, lhs, rhs, set)) return res; 3826| | #endif 3827| | 3828| 568k| do { // protect allocated storage 3829| | #if DECSUBSET 3830| | if (!set->extended) { 3831| | // reduce operands and set lostDigits status, as needed 3832| | if (lhs->digits>reqdigits) { 3833| | alloclhs=decRoundOperand(lhs, set, status); 3834| | if (alloclhs==NULL) break; 3835| | lhs=alloclhs; 3836| | } 3837| | if (rhs->digits>reqdigits) { 3838| | allocrhs=decRoundOperand(rhs, set, status); 3839| | if (allocrhs==NULL) break; 3840| | rhs=allocrhs; 3841| | } 3842| | } 3843| | #endif 3844| | // [following code does not require input rounding] 3845| | 3846| | // note whether signs differ [used all paths] 3847| 568k| diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG); ------------------ | | 31| 568k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 3848| | 3849| | // handle infinities and NaNs 3850| 568k| if (SPECIALARGS) { // a special bit set ------------------ | | 276| 568k|#define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL) | | ------------------ | | | | 36| 568k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 32| 568k| #define DECINF 0x40 /* 1=Infinity */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 33| 568k| #define DECNAN 0x20 /* 1=NaN */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 34| 568k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | ------------------ | | ------------------ | | | Branch (276:21): [True: 506, False: 567k] | | ------------------ ------------------ 3851| 506| if (SPECIALARGS & (DECSNAN | DECNAN)) // a NaN ------------------ | | 276| 506|#define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL) | | ------------------ | | | | 36| 506| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 32| 506| #define DECINF 0x40 /* 1=Infinity */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 33| 506| #define DECNAN 0x20 /* 1=NaN */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 34| 506| #define DECSNAN 0x10 /* 1=sNaN */ | | | | ------------------ | | ------------------ ------------------ if (SPECIALARGS & (DECSNAN | DECNAN)) // a NaN ------------------ | | 34| 506| #define DECSNAN 0x10 /* 1=sNaN */ ------------------ if (SPECIALARGS & (DECSNAN | DECNAN)) // a NaN ------------------ | | 33| 506| #define DECNAN 0x20 /* 1=NaN */ ------------------ | Branch (3851:11): [True: 0, False: 506] ------------------ 3852| 0| decNaNs(res, lhs, rhs, set, status); 3853| 506| else { // one or two infinities 3854| 506| if (decNumberIsInfinite(lhs)) { // LHS is infinity ------------------ | | 171| 506| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 506| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 0, False: 506] | | ------------------ ------------------ 3855| | // two infinities with different signs is invalid 3856| 0| if (decNumberIsInfinite(rhs) && diffsign) { ------------------ | | 171| 0| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 0| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3856:43): [True: 0, False: 0] ------------------ 3857| 0| *status|=DEC_Invalid_operation; ------------------ | | 135| 0| #define DEC_Invalid_operation 0x00000080 ------------------ 3858| 0| break; 3859| 0| } 3860| 0| bits=lhs->bits & DECNEG; // get sign from LHS ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 3861| 0| } 3862| 506| else bits=(rhs->bits^negate) & DECNEG;// RHS must be Infinity ------------------ | | 31| 506| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 3863| 506| bits|=DECINF; ------------------ | | 32| 506| #define DECINF 0x40 /* 1=Infinity */ ------------------ 3864| 506| decNumberZero(res); 3865| 506| res->bits=bits; // set +/- infinity 3866| 506| } // an infinity 3867| 506| break; 3868| 506| } 3869| | 3870| | // Quick exit for add 0s; return the non-0, modified as need be 3871| 567k| if (ISZERO(lhs)) { ------------------ | | 255| 567k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 567k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 567k, False: 0] | | | | ------------------ | | | | 178| 567k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 567k, False: 0] | | | | ------------------ | | | | 179| 567k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 567k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 567k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 567k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 567k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 567k, False: 0] | | | | ------------------ | | ------------------ ------------------ 3872| 567k| Int adjust; // work ------------------ | | 92| 567k| #define Int int32_t ------------------ 3873| 567k| Int lexp=lhs->exponent; // save in case LHS==RES ------------------ | | 92| 567k| #define Int int32_t ------------------ 3874| 567k| bits=lhs->bits; // .. 3875| 567k| residue=0; // clear accumulator 3876| 567k| decCopyFit(res, rhs, set, &residue, status); // copy (as needed) 3877| 567k| res->bits^=negate; // flip if rhs was negated 3878| | #if DECSUBSET 3879| | if (set->extended) { // exponents on zeros count 3880| | #endif 3881| | // exponent will be the lower of the two 3882| 567k| adjust=lexp-res->exponent; // adjustment needed [if -ve] 3883| 567k| if (ISZERO(res)) { // both 0: special IEEE 754 rules ------------------ | | 255| 567k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 567k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 4.61k, False: 562k] | | | | ------------------ | | | | 178| 567k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 3.89k, False: 723] | | | | ------------------ | | | | 179| 567k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 3.89k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 3.89k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 3.89k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 3.89k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 3.89k, False: 0] | | | | ------------------ | | ------------------ ------------------ 3884| 3.89k| if (adjust<0) res->exponent=lexp; // set exponent ------------------ | Branch (3884:15): [True: 0, False: 3.89k] ------------------ 3885| | // 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0 3886| 3.89k| if (diffsign) { ------------------ | Branch (3886:15): [True: 0, False: 3.89k] ------------------ 3887| 0| if (set->round!=DEC_ROUND_FLOOR) res->bits=0; ------------------ | Branch (3887:17): [True: 0, False: 0] ------------------ 3888| 0| else res->bits=DECNEG; // preserve 0 sign ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 3889| 0| } 3890| 3.89k| } 3891| 563k| else { // non-0 res 3892| 563k| if (adjust<0) { // 0-padding needed ------------------ | Branch (3892:15): [True: 0, False: 563k] ------------------ 3893| 0| if ((res->digits-adjust)>set->digits) { ------------------ | Branch (3893:17): [True: 0, False: 0] ------------------ 3894| 0| adjust=res->digits-set->digits; // to fit exactly 3895| 0| *status|=DEC_Rounded; // [but exact] ------------------ | | 141| 0| #define DEC_Rounded 0x00000800 ------------------ 3896| 0| } 3897| 0| res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 3898| 0| res->exponent+=adjust; // set the exponent. 3899| 0| } 3900| 563k| } // non-0 res 3901| | #if DECSUBSET 3902| | } // extended 3903| | #endif 3904| 567k| decFinish(res, set, &residue, status); // clean and finalize ------------------ | | 267| 567k|#define decFinish(a,b,c,d) decFinalize(a,b,c,d) ------------------ 3905| 567k| break;} 3906| | 3907| 0| if (ISZERO(rhs)) { // [lhs is non-zero] ------------------ | | 255| 0| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 0| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 0, False: 0] | | | | ------------------ | | | | 178| 0| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 0, False: 0] | | | | ------------------ | | | | 179| 0| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 0| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 0| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3908| 0| Int adjust; // work ------------------ | | 92| 0| #define Int int32_t ------------------ 3909| 0| Int rexp=rhs->exponent; // save in case RHS==RES ------------------ | | 92| 0| #define Int int32_t ------------------ 3910| 0| bits=rhs->bits; // be clean 3911| 0| residue=0; // clear accumulator 3912| 0| decCopyFit(res, lhs, set, &residue, status); // copy (as needed) 3913| | #if DECSUBSET 3914| | if (set->extended) { // exponents on zeros count 3915| | #endif 3916| | // exponent will be the lower of the two 3917| | // [0-0 case handled above] 3918| 0| adjust=rexp-res->exponent; // adjustment needed [if -ve] 3919| 0| if (adjust<0) { // 0-padding needed ------------------ | Branch (3919:13): [True: 0, False: 0] ------------------ 3920| 0| if ((res->digits-adjust)>set->digits) { ------------------ | Branch (3920:15): [True: 0, False: 0] ------------------ 3921| 0| adjust=res->digits-set->digits; // to fit exactly 3922| 0| *status|=DEC_Rounded; // [but exact] ------------------ | | 141| 0| #define DEC_Rounded 0x00000800 ------------------ 3923| 0| } 3924| 0| res->digits=decShiftToMost(res->lsu, res->digits, -adjust); 3925| 0| res->exponent+=adjust; // set the exponent. 3926| 0| } 3927| | #if DECSUBSET 3928| | } // extended 3929| | #endif 3930| 0| decFinish(res, set, &residue, status); // clean and finalize ------------------ | | 267| 0|#define decFinish(a,b,c,d) decFinalize(a,b,c,d) ------------------ 3931| 0| break;} 3932| | 3933| | // [NB: both fastpath and mainpath code below assume these cases 3934| | // (notably 0-0) have already been handled] 3935| | 3936| | // calculate the padding needed to align the operands 3937| 0| padding=rhs->exponent-lhs->exponent; 3938| | 3939| | // Fastpath cases where the numbers are aligned and normal, the RHS 3940| | // is all in one unit, no operand rounding is needed, and no carry, 3941| | // lengthening, or borrow is needed 3942| 0| if (padding==0 ------------------ | Branch (3942:9): [True: 0, False: 0] ------------------ 3943| 0| && rhs->digits<=DECDPUN ------------------ | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (3943:12): [True: 0, False: 0] ------------------ 3944| 0| && rhs->exponent>=set->emin // [some normals drop through] ------------------ | Branch (3944:12): [True: 0, False: 0] ------------------ 3945| 0| && rhs->exponent<=set->emax-set->digits+1 // [could clamp] ------------------ | Branch (3945:12): [True: 0, False: 0] ------------------ 3946| 0| && rhs->digits<=reqdigits ------------------ | Branch (3946:12): [True: 0, False: 0] ------------------ 3947| 0| && lhs->digits<=reqdigits) { ------------------ | Branch (3947:12): [True: 0, False: 0] ------------------ 3948| 0| Int partial=*lhs->lsu; ------------------ | | 92| 0| #define Int int32_t ------------------ 3949| 0| if (!diffsign) { // adding ------------------ | Branch (3949:11): [True: 0, False: 0] ------------------ 3950| 0| partial+=*rhs->lsu; 3951| 0| if ((partial<=DECDPUNMAX) // result fits in unit ------------------ | | 209| 0| #define DECDPUNMAX 999 ------------------ | Branch (3951:13): [True: 0, False: 0] ------------------ 3952| 0| && (lhs->digits>=DECDPUN || // .. and no digits-count change ------------------ | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (3952:14): [True: 0, False: 0] ------------------ 3953| 0| partial<(Int)powers[lhs->digits])) { // .. ------------------ | | 177| 0|#define powers DECPOWERS // old internal name ------------------ | Branch (3953:14): [True: 0, False: 0] ------------------ 3954| 0| if (res!=lhs) decNumberCopy(res, lhs); // not in place ------------------ | Branch (3954:15): [True: 0, False: 0] ------------------ 3955| 0| *res->lsu=(Unit)partial; // [copy could have overwritten RHS] 3956| 0| break; 3957| 0| } 3958| | // else drop out for careful add 3959| 0| } 3960| 0| else { // signs differ 3961| 0| partial-=*rhs->lsu; 3962| 0| if (partial>0) { // no borrow needed, and non-0 result ------------------ | Branch (3962:13): [True: 0, False: 0] ------------------ 3963| 0| if (res!=lhs) decNumberCopy(res, lhs); // not in place ------------------ | Branch (3963:15): [True: 0, False: 0] ------------------ 3964| 0| *res->lsu=(Unit)partial; 3965| | // this could have reduced digits [but result>0] 3966| 0| res->digits=decGetDigits(res->lsu, D2U(res->digits)); ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 3967| 0| break; 3968| 0| } 3969| | // else drop out for careful subtract 3970| 0| } 3971| 0| } 3972| | 3973| | // Now align (pad) the lhs or rhs so they can be added or 3974| | // subtracted, as necessary. If one number is much larger than 3975| | // the other (that is, if in plain form there is a least one 3976| | // digit between the lowest digit of one and the highest of the 3977| | // other) padding with up to DIGITS-1 trailing zeros may be 3978| | // needed; then apply rounding (as exotic rounding modes may be 3979| | // affected by the residue). 3980| 0| rhsshift=0; // rhs shift to left (padding) in Units 3981| 0| bits=lhs->bits; // assume sign is that of LHS 3982| 0| mult=1; // likely multiplier 3983| | 3984| | // [if padding==0 the operands are aligned; no padding is needed] 3985| 0| if (padding!=0) { ------------------ | Branch (3985:9): [True: 0, False: 0] ------------------ 3986| | // some padding needed; always pad the RHS, as any required 3987| | // padding can then be effected by a simple combination of 3988| | // shifts and a multiply 3989| 0| Flag swapped=0; ------------------ | | 87| 0| #define Flag uint8_t ------------------ 3990| 0| if (padding<0) { // LHS needs the padding ------------------ | Branch (3990:11): [True: 0, False: 0] ------------------ 3991| 0| const decNumber *t; 3992| 0| padding=-padding; // will be +ve 3993| 0| bits=(uByte)(rhs->bits^negate); // assumed sign is now that of RHS 3994| 0| t=lhs; lhs=rhs; rhs=t; 3995| 0| swapped=1; 3996| 0| } 3997| | 3998| | // If, after pad, rhs would be longer than lhs by digits+1 or 3999| | // more then lhs cannot affect the answer, except as a residue, 4000| | // so only need to pad up to a length of DIGITS+1. 4001| 0| if (rhs->digits+padding > lhs->digits+reqdigits+1) { ------------------ | Branch (4001:11): [True: 0, False: 0] ------------------ 4002| | // The RHS is sufficient 4003| | // for residue use the relative sign indication... 4004| 0| Int shift=reqdigits-rhs->digits; // left shift needed ------------------ | | 92| 0| #define Int int32_t ------------------ 4005| 0| residue=1; // residue for rounding 4006| 0| if (diffsign) residue=-residue; // signs differ ------------------ | Branch (4006:13): [True: 0, False: 0] ------------------ 4007| | // copy, shortening if necessary 4008| 0| decCopyFit(res, rhs, set, &residue, status); 4009| | // if it was already shorter, then need to pad with zeros 4010| 0| if (shift>0) { ------------------ | Branch (4010:13): [True: 0, False: 0] ------------------ 4011| 0| res->digits=decShiftToMost(res->lsu, res->digits, shift); 4012| 0| res->exponent-=shift; // adjust the exponent. 4013| 0| } 4014| | // flip the result sign if unswapped and rhs was negated 4015| 0| if (!swapped) res->bits^=negate; ------------------ | Branch (4015:13): [True: 0, False: 0] ------------------ 4016| 0| decFinish(res, set, &residue, status); // done ------------------ | | 267| 0|#define decFinish(a,b,c,d) decFinalize(a,b,c,d) ------------------ 4017| 0| break;} 4018| | 4019| | // LHS digits may affect result 4020| 0| rhsshift=D2U(padding+1)-1; // this much by Unit shift .. ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 4021| 0| mult=powers[padding-(rhsshift*DECDPUN)]; // .. this by multiplication ------------------ | | 177| 0|#define powers DECPOWERS // old internal name ------------------ mult=powers[padding-(rhsshift*DECDPUN)]; // .. this by multiplication ------------------ | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 4022| 0| } // padding needed 4023| | 4024| 0| if (diffsign) mult=-mult; // signs differ ------------------ | Branch (4024:9): [True: 0, False: 0] ------------------ 4025| | 4026| | // determine the longer operand 4027| 0| maxdigits=rhs->digits+padding; // virtual length of RHS 4028| 0| if (lhs->digits>maxdigits) maxdigits=lhs->digits; ------------------ | Branch (4028:9): [True: 0, False: 0] ------------------ 4029| | 4030| | // Decide on the result buffer to use; if possible place directly 4031| | // into result. 4032| 0| acc=res->lsu; // assume add direct to result 4033| | // If destructive overlap, or the number is too long, or a carry or 4034| | // borrow to DIGITS+1 might be possible, a buffer must be used. 4035| | // [Might be worth more sophisticated tests when maxdigits==reqdigits] 4036| 0| if ((maxdigits>=reqdigits) // is, or could be, too large ------------------ | Branch (4036:9): [True: 0, False: 0] ------------------ 4037| 0| || (res==rhs && rhsshift>0)) { // destructive overlap ------------------ | Branch (4037:10): [True: 0, False: 0] | Branch (4037:22): [True: 0, False: 0] ------------------ 4038| | // buffer needed, choose it; units for maxdigits digits will be 4039| | // needed, +1 Unit for carry or borrow 4040| 0| Int need=D2U(maxdigits)+1; ------------------ | | 92| 0| #define Int int32_t ------------------ Int need=D2U(maxdigits)+1; ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 4041| 0| acc=accbuff; // assume use local buffer 4042| 0| if (need*sizeof(Unit)>sizeof(accbuff)) { ------------------ | Branch (4042:11): [True: 0, False: 0] ------------------ 4043| | // printf("malloc add %ld %ld\n", need, sizeof(accbuff)); 4044| 0| allocacc=(Unit *)malloc(need*sizeof(Unit)); 4045| 0| if (allocacc==NULL) { // hopeless -- abandon ------------------ | Branch (4045:13): [True: 0, False: 0] ------------------ 4046| 0| *status|=DEC_Insufficient_storage; ------------------ | | 132| 0| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ ------------------ 4047| 0| break;} 4048| 0| acc=allocacc; 4049| 0| } 4050| 0| } 4051| | 4052| 0| res->bits=(uByte)(bits&DECNEG); // it's now safe to overwrite.. ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 4053| 0| res->exponent=lhs->exponent; // .. operands (even if aliased) 4054| | 4055| | #if DECTRACE 4056| | decDumpAr('A', lhs->lsu, D2U(lhs->digits)); 4057| | decDumpAr('B', rhs->lsu, D2U(rhs->digits)); 4058| | printf(" :h: %ld %ld\n", rhsshift, mult); 4059| | #endif 4060| | 4061| | // add [A+B*m] or subtract [A+B*(-m)] 4062| 0| res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits), ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 4063| 0| rhs->lsu, D2U(rhs->digits), ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 4064| 0| rhsshift, acc, mult) 4065| 0| *DECDPUN; // [units -> digits] ------------------ | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 4066| 0| if (res->digits<0) { // borrowed... ------------------ | Branch (4066:9): [True: 0, False: 0] ------------------ 4067| 0| res->digits=-res->digits; 4068| 0| res->bits^=DECNEG; // flip the sign ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 4069| 0| } 4070| | #if DECTRACE 4071| | decDumpAr('+', acc, D2U(res->digits)); 4072| | #endif 4073| | 4074| | // If a buffer was used the result must be copied back, possibly 4075| | // shortening. (If no buffer was used then the result must have 4076| | // fit, so can't need rounding and residue must be 0.) 4077| 0| residue=0; // clear accumulator 4078| 0| if (acc!=res->lsu) { ------------------ | Branch (4078:9): [True: 0, False: 0] ------------------ 4079| | #if DECSUBSET 4080| | if (set->extended) { // round from first significant digit 4081| | #endif 4082| | // remove leading zeros that were added due to rounding up to 4083| | // integral Units -- before the test for rounding. 4084| 0| if (res->digits>reqdigits) ------------------ | Branch (4084:13): [True: 0, False: 0] ------------------ 4085| 0| res->digits=decGetDigits(acc, D2U(res->digits)); ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 4086| 0| decSetCoeff(res, set, acc, res->digits, &residue, status); 4087| | #if DECSUBSET 4088| | } 4089| | else { // subset arithmetic rounds from original significant digit 4090| | // May have an underestimate. This only occurs when both 4091| | // numbers fit in DECDPUN digits and are padding with a 4092| | // negative multiple (-10, -100...) and the top digit(s) become 4093| | // 0. (This only matters when using X3.274 rules where the 4094| | // leading zero could be included in the rounding.) 4095| | if (res->digitsdigits))=0; // ensure leading 0 is there 4097| | res->digits=maxdigits; 4098| | } 4099| | else { 4100| | // remove leading zeros that added due to rounding up to 4101| | // integral Units (but only those in excess of the original 4102| | // maxdigits length, unless extended) before test for rounding. 4103| | if (res->digits>reqdigits) { 4104| | res->digits=decGetDigits(acc, D2U(res->digits)); 4105| | if (res->digitsdigits=maxdigits; 4106| | } 4107| | } 4108| | decSetCoeff(res, set, acc, res->digits, &residue, status); 4109| | // Now apply rounding if needed before removing leading zeros. 4110| | // This is safe because subnormals are not a possibility 4111| | if (residue!=0) { 4112| | decApplyRound(res, set, residue, status); 4113| | residue=0; // did what needed to be done 4114| | } 4115| | } // subset 4116| | #endif 4117| 0| } // used buffer 4118| | 4119| | // strip leading zeros [these were left on in case of subset subtract] 4120| 0| res->digits=decGetDigits(res->lsu, D2U(res->digits)); ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 4121| | 4122| | // apply checks and rounding 4123| 0| decFinish(res, set, &residue, status); ------------------ | | 267| 0|#define decFinish(a,b,c,d) decFinalize(a,b,c,d) ------------------ 4124| | 4125| | // "When the sum of two operands with opposite signs is exactly 4126| | // zero, the sign of that sum shall be '+' in all rounding modes 4127| | // except round toward -Infinity, in which mode that sign shall be 4128| | // '-'." [Subset zeros also never have '-', set by decFinish.] 4129| 0| if (ISZERO(res) && diffsign ------------------ | | 255| 0| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 0| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 0, False: 0] | | | | ------------------ | | | | 178| 0| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 0, False: 0] | | | | ------------------ | | | | 179| 0| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 0| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 0| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (4129:24): [True: 0, False: 0] ------------------ 4130| | #if DECSUBSET 4131| | && set->extended 4132| | #endif 4133| 0| && (*status&DEC_Inexact)==0) { ------------------ | | 133| 0| #define DEC_Inexact 0x00000020 ------------------ | Branch (4133:9): [True: 0, False: 0] ------------------ 4134| 0| if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; // sign - ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ | Branch (4134:11): [True: 0, False: 0] ------------------ 4135| 0| else res->bits&=~DECNEG; // sign + ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 4136| 0| } 4137| 0| } while(0); // end protected ------------------ | Branch (4137:13): [Folded, False: 0] ------------------ 4138| | 4139| 568k| if (allocacc!=NULL) free(allocacc); // drop any storage used ------------------ | Branch (4139:7): [True: 0, False: 568k] ------------------ 4140| | #if DECSUBSET 4141| | if (allocrhs!=NULL) free(allocrhs); // .. 4142| | if (alloclhs!=NULL) free(alloclhs); // .. 4143| | #endif 4144| 568k| return res; 4145| 568k| } // decAddOp decNumber.c:decUnitAddSub: 6339| 57.6k| Unit *c, Int m) { 6340| 57.6k| const Unit *alsu=a; // A lsu [need to remember it] 6341| 57.6k| Unit *clsu=c; // C ditto ------------------ | | 94| 57.6k| #define Unit decNumberUnit | | ------------------ | | | | 59| 57.6k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6342| 57.6k| Unit *minC; // low water mark for C ------------------ | | 94| 57.6k| #define Unit decNumberUnit | | ------------------ | | | | 59| 57.6k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6343| 57.6k| Unit *maxC; // high water mark for C ------------------ | | 94| 57.6k| #define Unit decNumberUnit | | ------------------ | | | | 59| 57.6k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6344| 57.6k| eInt carry=0; // carry integer (could be Long) ------------------ | | 203| 57.6k| #define eInt Int // extended integer | | ------------------ | | | | 92| 57.6k| #define Int int32_t | | ------------------ ------------------ 6345| 57.6k| Int add; // work ------------------ | | 92| 57.6k| #define Int int32_t ------------------ 6346| 57.6k| #if DECDPUN<=4 // myriadal, millenary, etc. 6347| 57.6k| Int est; // estimated quotient ------------------ | | 92| 57.6k| #define Int int32_t ------------------ 6348| 57.6k| #endif 6349| | 6350| | #if DECTRACE 6351| | if (alength<1 || blength<1) 6352| | printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m); 6353| | #endif 6354| | 6355| 57.6k| maxC=c+alength; // A is usually the longer 6356| 57.6k| minC=c+blength; // .. and B the shorter 6357| 57.6k| if (bshift!=0) { // B is shifted; low As copy across ------------------ | Branch (6357:7): [True: 31.4k, False: 26.2k] ------------------ 6358| 31.4k| minC+=bshift; 6359| | // if in place [common], skip copy unless there's a gap [rare] 6360| 31.4k| if (a==c && bshift<=alength) { ------------------ | Branch (6360:9): [True: 0, False: 31.4k] | Branch (6360:17): [True: 0, False: 0] ------------------ 6361| 0| c+=bshift; 6362| 0| a+=bshift; 6363| 0| } 6364| 10.5M| else for (; cmaxC) { // swap ------------------ | Branch (6369:7): [True: 1.88k, False: 55.7k] ------------------ 6370| 1.88k| Unit *hold=minC; ------------------ | | 94| 1.88k| #define Unit decNumberUnit | | ------------------ | | | | 59| 1.88k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6371| 1.88k| minC=maxC; 6372| 1.88k| maxC=hold; 6373| 1.88k| } 6374| | 6375| | // For speed, do the addition as two loops; the first where both A 6376| | // and B contribute, and the second (if necessary) where only one or 6377| | // other of the numbers contribute. 6378| | // Carry handling is the same (i.e., duplicated) in each case. 6379| 117k| for (; c=0) { 6392| | est=(((ueInt)carry>>11)*53687)>>18; 6393| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder 6394| | carry=est; // likely quotient [89%] 6395| | if (*c>11)*53687)>>18; 6403| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6404| | carry=est-(DECDPUNMAX+1); // correctly negative 6405| | if (*c=0) { ------------------ | Branch (6409:11): [True: 874, False: 12.3k] ------------------ 6410| 874| est=(((ueInt)carry>>3)*16777)>>21; 6411| 874| *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder ------------------ | | 209| 874| #define DECDPUNMAX 999 ------------------ 6412| 874| carry=est; // likely quotient [99%] 6413| 874| if (*c>3)*16777)>>21; 6421| 12.3k| *c=(Unit)(carry-est*(DECDPUNMAX+1)); ------------------ | | 209| 12.3k| #define DECDPUNMAX 999 ------------------ 6422| 12.3k| carry=est-(DECDPUNMAX+1); // correctly negative ------------------ | | 209| 12.3k| #define DECDPUNMAX 999 ------------------ 6423| 12.3k| if (*c=0) { 6429| | est=QUOT10(carry, DECDPUN); 6430| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder 6431| | carry=est; // quotient 6432| | continue; 6433| | } 6434| | // negative case 6435| | carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive 6436| | est=QUOT10(carry, DECDPUN); 6437| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6438| | carry=est-(DECDPUNMAX+1); // correctly negative 6439| | #else 6440| | // remainder operator is undefined if negative, so must test 6441| | if ((ueInt)carry<(DECDPUNMAX+1)*2) { // fastpath carry +1 6442| | *c=(Unit)(carry-(DECDPUNMAX+1)); // [helps additions] 6443| | carry=1; 6444| | continue; 6445| | } 6446| | if (carry>=0) { 6447| | *c=(Unit)(carry%(DECDPUNMAX+1)); 6448| | carry=carry/(DECDPUNMAX+1); 6449| | continue; 6450| | } 6451| | // negative case 6452| | carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive 6453| | *c=(Unit)(carry%(DECDPUNMAX+1)); 6454| | carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6455| | #endif 6456| 881| } // c 6457| | 6458| | // now may have one or other to complete 6459| | // [pretest to avoid loop setup/shutdown] 6460| 803k| if (cDECDPUNMAX 6477| | #if DECDPUN==4 // use divide-by-multiply 6478| | if (carry>=0) { 6479| | est=(((ueInt)carry>>11)*53687)>>18; 6480| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder 6481| | carry=est; // likely quotient [79.7%] 6482| | if (*c>11)*53687)>>18; 6490| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6491| | carry=est-(DECDPUNMAX+1); // correctly negative 6492| | if (*c=0) { ------------------ | Branch (6496:11): [True: 202k, False: 2.23k] ------------------ 6497| 202k| est=(((ueInt)carry>>3)*16777)>>21; 6498| 202k| *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder ------------------ | | 209| 202k| #define DECDPUNMAX 999 ------------------ 6499| 202k| carry=est; // likely quotient [99%] 6500| 202k| if (*c>3)*16777)>>21; 6508| 2.23k| *c=(Unit)(carry-est*(DECDPUNMAX+1)); ------------------ | | 209| 2.23k| #define DECDPUNMAX 999 ------------------ 6509| 2.23k| carry=est-(DECDPUNMAX+1); // correctly negative ------------------ | | 209| 2.23k| #define DECDPUNMAX 999 ------------------ 6510| 2.23k| if (*c=0) { 6515| | est=QUOT10(carry, DECDPUN); 6516| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder 6517| | carry=est; // quotient 6518| | continue; 6519| | } 6520| | // negative case 6521| | carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive 6522| | est=QUOT10(carry, DECDPUN); 6523| | *c=(Unit)(carry-est*(DECDPUNMAX+1)); 6524| | carry=est-(DECDPUNMAX+1); // correctly negative 6525| | #else 6526| | if ((ueInt)carry<(DECDPUNMAX+1)*2){ // fastpath carry 1 6527| | *c=(Unit)(carry-(DECDPUNMAX+1)); 6528| | carry=1; 6529| | continue; 6530| | } 6531| | // remainder operator is undefined if negative, so must test 6532| | if (carry>=0) { 6533| | *c=(Unit)(carry%(DECDPUNMAX+1)); 6534| | carry=carry/(DECDPUNMAX+1); 6535| | continue; 6536| | } 6537| | // negative case 6538| | carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive 6539| | *c=(Unit)(carry%(DECDPUNMAX+1)); 6540| | carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1); 6541| | #endif 6542| 293| } // c 6543| | 6544| | // OK, all A and B processed; might still have carry or borrow 6545| | // return number of Units in the result, negated if a borrow 6546| 57.6k| if (carry==0) return c-clsu; // no carry, so no more to do ------------------ | Branch (6546:7): [True: 48.8k, False: 8.87k] ------------------ 6547| 8.87k| if (carry>0) { // positive carry ------------------ | Branch (6547:7): [True: 0, False: 8.87k] ------------------ 6548| 0| *c=(Unit)carry; // place as new unit 6549| 0| c++; // .. 6550| 0| return c-clsu; 6551| 0| } 6552| | // -ve carry: it's a borrow; complement needed 6553| 8.87k| add=1; // temporary carry... 6554| 5.61M| for (c=clsu; c allocated acc buffer, iff allocated ------------------ | | 94| 1.71M| #define Unit decNumberUnit | | ------------------ | | | | 59| 1.71M| #define decNumberUnit uint16_t | | ------------------ ------------------ 6238| 1.71M| Int accunits, need; // units in use or needed for acc ------------------ | | 92| 1.71M| #define Int int32_t ------------------ 6239| 1.71M| const Unit *l, *r, *u; // work 6240| 1.71M| Int expunits, exprem, result; // .. ------------------ | | 92| 1.71M| #define Int int32_t ------------------ 6241| | 6242| 1.71M| if (exp==0) { // aligned; fastpath ------------------ | Branch (6242:7): [True: 1.53M, False: 177k] ------------------ 6243| 1.53M| if (alength>blength) return 1; ------------------ | Branch (6243:9): [True: 23.0k, False: 1.51M] ------------------ 6244| 1.51M| if (alength=a; l--, r--) { ------------------ | Branch (6248:11): [True: 1.23M, False: 766k] ------------------ 6249| 1.23M| if (*l>*r) return 1; ------------------ | Branch (6249:11): [True: 279k, False: 950k] ------------------ 6250| 950k| if (*l<*r) return -1; ------------------ | Branch (6250:11): [True: 44.0k, False: 906k] ------------------ 6251| 950k| } 6252| 766k| return 0; // all units match 6253| 1.08M| } // aligned 6254| | 6255| | // Unaligned. If one is >1 unit longer than the other, padded 6256| | // approximately, then can return easily 6257| 177k| if (alength>blength+(Int)D2U(exp)) return 1; ------------------ | | 264| 177k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 177k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 12.4k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 12.4k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 165k, False: 12.4k] | | ------------------ ------------------ | Branch (6257:7): [True: 35.3k, False: 142k] ------------------ 6258| 142k| if (alength+10 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 12.3k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 129k, False: 12.3k] | | ------------------ ------------------ | Branch (6258:7): [True: 89.3k, False: 52.9k] ------------------ 6259| | 6260| | // Need to do a real subtract. For this, a result buffer is needed 6261| | // even though only the sign is of interest. Its length needs 6262| | // to be the larger of alength and padded blength, +2 6263| 52.9k| need=blength+D2U(exp); // maximum real length of B ------------------ | | 264| 52.9k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 52.9k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 984| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 984| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 51.9k, False: 984] | | ------------------ ------------------ 6264| 52.9k| if (needsizeof(accbuff)) { ------------------ | Branch (6267:7): [True: 806, False: 52.1k] ------------------ 6268| 806| allocacc=(Unit *)malloc(need*sizeof(Unit)); 6269| 806| if (allocacc==NULL) return BADINT; // hopeless -- abandon ------------------ | | 194| 0|#define BADINT (Int)0x80000000 // most-negative Int; error indicator ------------------ | Branch (6269:9): [True: 0, False: 806] ------------------ 6270| 806| acc=allocacc; 6271| 806| } 6272| | // Calculate units and remainder from exponent. 6273| 52.9k| expunits=exp/DECDPUN; ------------------ | | 43| 52.9k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6274| 52.9k| exprem=exp%DECDPUN; ------------------ | | 43| 52.9k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6275| | // subtract [A+B*(-m)] 6276| 52.9k| accunits=decUnitAddSub(a, alength, b, blength, expunits, acc, 6277| 52.9k| -(Int)powers[exprem]); ------------------ | | 177| 52.9k|#define powers DECPOWERS // old internal name ------------------ 6278| | // [UnitAddSub result may have leading zeros, even on zero] 6279| 52.9k| if (accunits<0) result=-1; // negative result ------------------ | Branch (6279:7): [True: 8.87k, False: 44.0k] ------------------ 6280| 44.0k| else { // non-negative result 6281| | // check units of the result before freeing any storage 6282| 44.9k| for (u=acc; uround) { 7081| 0| case DEC_ROUND_05UP: { // round zero or five up (for reround) ------------------ | Branch (7081:5): [True: 0, False: 18.1k] ------------------ 7082| | // This is the same as DEC_ROUND_DOWN unless there is a 7083| | // positive residue and the lsd of dn is 0 or 5, in which case 7084| | // it is bumped; when residue is <0, the number is therefore 7085| | // bumped down unless the final digit was 1 or 6 (in which 7086| | // case it is bumped down and then up -- a no-op) 7087| 0| Int lsd5=*dn->lsu%5; // get lsd and quintate ------------------ | | 92| 0| #define Int int32_t ------------------ 7088| 0| if (residue<0 && lsd5!=1) bump=-1; ------------------ | Branch (7088:11): [True: 0, False: 0] | Branch (7088:24): [True: 0, False: 0] ------------------ 7089| 0| else if (residue>0 && lsd5==0) bump=1; ------------------ | Branch (7089:17): [True: 0, False: 0] | Branch (7089:30): [True: 0, False: 0] ------------------ 7090| | // [bump==1 could be applied directly; use common path for clarity] 7091| 0| break;} // r-05 7092| | 7093| 0| case DEC_ROUND_DOWN: { ------------------ | Branch (7093:5): [True: 0, False: 18.1k] ------------------ 7094| | // no change, except if negative residue 7095| 0| if (residue<0) bump=-1; ------------------ | Branch (7095:11): [True: 0, False: 0] ------------------ 7096| 0| break;} // r-d 7097| | 7098| 0| case DEC_ROUND_HALF_DOWN: { ------------------ | Branch (7098:5): [True: 0, False: 18.1k] ------------------ 7099| 0| if (residue>5) bump=1; ------------------ | Branch (7099:11): [True: 0, False: 0] ------------------ 7100| 0| break;} // r-h-d 7101| | 7102| 13.0k| case DEC_ROUND_HALF_EVEN: { ------------------ | Branch (7102:5): [True: 13.0k, False: 5.12k] ------------------ 7103| 13.0k| if (residue>5) bump=1; // >0.5 goes up ------------------ | Branch (7103:11): [True: 2.71k, False: 10.2k] ------------------ 7104| 10.2k| else if (residue==5) { // exactly 0.5000... ------------------ | Branch (7104:17): [True: 3.14k, False: 7.15k] ------------------ 7105| | // 0.5 goes up iff [new] lsd is odd 7106| 3.14k| if (*dn->lsu & 0x01) bump=1; ------------------ | Branch (7106:13): [True: 275, False: 2.86k] ------------------ 7107| 3.14k| } 7108| 13.0k| break;} // r-h-e 7109| | 7110| 5.12k| case DEC_ROUND_HALF_UP: { ------------------ | Branch (7110:5): [True: 5.12k, False: 13.0k] ------------------ 7111| 5.12k| if (residue>=5) bump=1; ------------------ | Branch (7111:11): [True: 3.29k, False: 1.82k] ------------------ 7112| 5.12k| break;} // r-h-u 7113| | 7114| 0| case DEC_ROUND_UP: { ------------------ | Branch (7114:5): [True: 0, False: 18.1k] ------------------ 7115| 0| if (residue>0) bump=1; ------------------ | Branch (7115:11): [True: 0, False: 0] ------------------ 7116| 0| break;} // r-u 7117| | 7118| 0| case DEC_ROUND_CEILING: { ------------------ | Branch (7118:5): [True: 0, False: 18.1k] ------------------ 7119| | // same as _UP for positive numbers, and as _DOWN for negatives 7120| | // [negative residue cannot occur on 0] 7121| 0| if (decNumberIsNegative(dn)) { ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 0, False: 0] | | ------------------ ------------------ 7122| 0| if (residue<0) bump=-1; ------------------ | Branch (7122:13): [True: 0, False: 0] ------------------ 7123| 0| } 7124| 0| else { 7125| 0| if (residue>0) bump=1; ------------------ | Branch (7125:13): [True: 0, False: 0] ------------------ 7126| 0| } 7127| 0| break;} // r-c 7128| | 7129| 0| case DEC_ROUND_FLOOR: { ------------------ | Branch (7129:5): [True: 0, False: 18.1k] ------------------ 7130| | // same as _UP for negative numbers, and as _DOWN for positive 7131| | // [negative residue cannot occur on 0] 7132| 0| if (!decNumberIsNegative(dn)) { ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ ------------------ | Branch (7132:11): [True: 0, False: 0] ------------------ 7133| 0| if (residue<0) bump=-1; ------------------ | Branch (7133:13): [True: 0, False: 0] ------------------ 7134| 0| } 7135| 0| else { 7136| 0| if (residue>0) bump=1; ------------------ | Branch (7136:13): [True: 0, False: 0] ------------------ 7137| 0| } 7138| 0| break;} // r-f 7139| | 7140| 0| default: { // e.g., DEC_ROUND_MAX ------------------ | Branch (7140:5): [True: 0, False: 18.1k] ------------------ 7141| 0| *status|=DEC_Invalid_context; ------------------ | | 134| 0| #define DEC_Invalid_context 0x00000040 ------------------ 7142| | #if DECTRACE || (DECCHECK && DECVERB) 7143| | printf("Unknown rounding mode: %d\n", set->round); 7144| | #endif 7145| 0| break;} 7146| 18.1k| } // switch 7147| | 7148| | // now bump the number, up or down, if need be 7149| 18.1k| if (bump==0) return; // no action required ------------------ | Branch (7149:7): [True: 11.8k, False: 6.28k] ------------------ 7150| | 7151| | // Simply use decUnitAddSub unless bumping up and the number is 7152| | // all nines. In this special case set to 100... explicitly 7153| | // and adjust the exponent by one (as otherwise could overflow 7154| | // the array) 7155| | // Similarly handle all-nines result if bumping down. 7156| 6.28k| if (bump>0) { ------------------ | Branch (7156:7): [True: 6.28k, False: 0] ------------------ 7157| 6.28k| Unit *up; // work ------------------ | | 94| 6.28k| #define Unit decNumberUnit | | ------------------ | | | | 59| 6.28k| #define decNumberUnit uint16_t | | ------------------ ------------------ 7158| 6.28k| uInt count=dn->digits; // digits to be checked ------------------ | | 93| 6.28k| #define uInt uint32_t ------------------ 7159| 471k| for (up=dn->lsu; ; up++) { 7160| 471k| if (count<=DECDPUN) { ------------------ | | 43| 471k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (7160:11): [True: 3.23k, False: 468k] ------------------ 7161| | // this is the last Unit (the msu) 7162| 3.23k| if (*up!=powers[count]-1) break; // not still 9s ------------------ | | 177| 3.23k|#define powers DECPOWERS // old internal name ------------------ | Branch (7162:13): [True: 1.70k, False: 1.53k] ------------------ 7163| | // here if it, too, is all nines 7164| 1.53k| *up=(Unit)powers[count-1]; // here 999 -> 100 etc. ------------------ | | 177| 1.53k|#define powers DECPOWERS // old internal name ------------------ 7165| 263k| for (up=up-1; up>=dn->lsu; up--) *up=0; // others all to 0 ------------------ | Branch (7165:23): [True: 261k, False: 1.53k] ------------------ 7166| 1.53k| dn->exponent++; // and bump exponent 7167| | // [which, very rarely, could cause Overflow...] 7168| 1.53k| if ((dn->exponent+dn->digits)>set->emax+1) { ------------------ | Branch (7168:13): [True: 442, False: 1.09k] ------------------ 7169| 442| decSetOverflow(dn, set, status); 7170| 442| } 7171| 1.53k| return; // done 7172| 3.23k| } 7173| | // a full unit to check, with more to come 7174| 468k| if (*up!=DECDPUNMAX) break; // not still 9s ------------------ | | 209| 468k| #define DECDPUNMAX 999 ------------------ | Branch (7174:11): [True: 3.05k, False: 465k] ------------------ 7175| 465k| count-=DECDPUN; ------------------ | | 43| 465k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 7176| 465k| } // up 7177| 6.28k| } // bump>0 7178| 0| else { // -1 7179| | // here checking for a pre-bump of 1000... (leading 1, all 7180| | // other digits zero) 7181| 0| Unit *up, *sup; // work ------------------ | | 94| 0| #define Unit decNumberUnit | | ------------------ | | | | 59| 0| #define decNumberUnit uint16_t | | ------------------ ------------------ 7182| 0| uInt count=dn->digits; // digits to be checked ------------------ | | 93| 0| #define uInt uint32_t ------------------ 7183| 0| for (up=dn->lsu; ; up++) { 7184| 0| if (count<=DECDPUN) { ------------------ | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (7184:11): [True: 0, False: 0] ------------------ 7185| | // this is the last Unit (the msu) 7186| 0| if (*up!=powers[count-1]) break; // not 100.. ------------------ | | 177| 0|#define powers DECPOWERS // old internal name ------------------ | Branch (7186:13): [True: 0, False: 0] ------------------ 7187| | // here if have the 1000... case 7188| 0| sup=up; // save msu pointer 7189| 0| *up=(Unit)powers[count]-1; // here 100 in msu -> 999 ------------------ | | 177| 0|#define powers DECPOWERS // old internal name ------------------ 7190| | // others all to all-nines, too 7191| 0| for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1; ------------------ | | 177| 0|#define powers DECPOWERS // old internal name ------------------ for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1; ------------------ | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (7191:23): [True: 0, False: 0] ------------------ 7192| 0| dn->exponent--; // and bump exponent 7193| | 7194| | // iff the number was at the subnormal boundary (exponent=etiny) 7195| | // then the exponent is now out of range, so it will in fact get 7196| | // clamped to etiny and the final 9 dropped. 7197| | // printf(">> emin=%d exp=%d sdig=%d\n", set->emin, 7198| | // dn->exponent, set->digits); 7199| 0| if (dn->exponent+1==set->emin-set->digits+1) { ------------------ | Branch (7199:13): [True: 0, False: 0] ------------------ 7200| 0| if (count==1 && dn->digits==1) *sup=0; // here 9 -> 0[.9] ------------------ | Branch (7200:15): [True: 0, False: 0] | Branch (7200:27): [True: 0, False: 0] ------------------ 7201| 0| else { 7202| 0| *sup=(Unit)powers[count-1]-1; // here 999.. in msu -> 99.. ------------------ | | 177| 0|#define powers DECPOWERS // old internal name ------------------ 7203| 0| dn->digits--; 7204| 0| } 7205| 0| dn->exponent++; 7206| 0| *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; ------------------ | | 143| 0| #define DEC_Underflow 0x00002000 ------------------ *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; ------------------ | | 142| 0| #define DEC_Subnormal 0x00001000 ------------------ *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; ------------------ | | 133| 0| #define DEC_Inexact 0x00000020 ------------------ *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; ------------------ | | 141| 0| #define DEC_Rounded 0x00000800 ------------------ 7207| 0| } 7208| 0| return; // done 7209| 0| } 7210| | 7211| | // a full unit to check, with more to come 7212| 0| if (*up!=0) break; // not still 0s ------------------ | Branch (7212:11): [True: 0, False: 0] ------------------ 7213| 0| count-=DECDPUN; ------------------ | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 7214| 0| } // up 7215| | 7216| 0| } // bump<0 7217| | 7218| | // Actual bump needed. Do it. 7219| 4.75k| decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump); ------------------ | | 264| 4.75k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 4.75k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 524| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 524| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 4.22k, False: 524] | | ------------------ ------------------ 7220| 4.75k| } // decApplyRound decNumber.c:decSetOverflow: 7348| 45.4k|static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) { 7349| 45.4k| Flag needmax=0; // result is maximum finite value ------------------ | | 87| 45.4k| #define Flag uint8_t ------------------ 7350| 45.4k| uByte sign=dn->bits&DECNEG; // clean and save sign bit ------------------ | | 89| 45.4k| #define uByte uint8_t ------------------ uByte sign=dn->bits&DECNEG; // clean and save sign bit ------------------ | | 31| 45.4k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 7351| | 7352| 45.4k| if (ISZERO(dn)) { // zero does not overflow magnitude ------------------ | | 255| 45.4k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 45.4k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 2.17k, False: 43.2k] | | | | ------------------ | | | | 178| 45.4k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 1.60k, False: 564] | | | | ------------------ | | | | 179| 45.4k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 1.60k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 1.60k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 1.60k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 1.60k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 1.60k, False: 0] | | | | ------------------ | | ------------------ ------------------ 7353| 1.60k| Int emax=set->emax; // limit value ------------------ | | 92| 1.60k| #define Int int32_t ------------------ 7354| 1.60k| if (set->clamp) emax-=set->digits-1; // lower if clamping ------------------ | Branch (7354:9): [True: 505, False: 1.10k] ------------------ 7355| 1.60k| if (dn->exponent>emax) { // clamp required ------------------ | Branch (7355:9): [True: 1.60k, False: 0] ------------------ 7356| 1.60k| dn->exponent=emax; 7357| 1.60k| *status|=DEC_Clamped; ------------------ | | 140| 1.60k| #define DEC_Clamped 0x00000400 ------------------ 7358| 1.60k| } 7359| 1.60k| return; 7360| 1.60k| } 7361| | 7362| 43.8k| decNumberZero(dn); 7363| 43.8k| switch (set->round) { 7364| 0| case DEC_ROUND_DOWN: { ------------------ | Branch (7364:5): [True: 0, False: 43.8k] ------------------ 7365| 0| needmax=1; // never Infinity 7366| 0| break;} // r-d 7367| 0| case DEC_ROUND_05UP: { ------------------ | Branch (7367:5): [True: 0, False: 43.8k] ------------------ 7368| 0| needmax=1; // never Infinity 7369| 0| break;} // r-05 7370| 0| case DEC_ROUND_CEILING: { ------------------ | Branch (7370:5): [True: 0, False: 43.8k] ------------------ 7371| 0| if (sign) needmax=1; // Infinity if non-negative ------------------ | Branch (7371:11): [True: 0, False: 0] ------------------ 7372| 0| break;} // r-c 7373| 0| case DEC_ROUND_FLOOR: { ------------------ | Branch (7373:5): [True: 0, False: 43.8k] ------------------ 7374| 0| if (!sign) needmax=1; // Infinity if negative ------------------ | Branch (7374:11): [True: 0, False: 0] ------------------ 7375| 0| break;} // r-f 7376| 43.8k| default: break; // Infinity in all other cases ------------------ | Branch (7376:5): [True: 43.8k, False: 0] ------------------ 7377| 43.8k| } 7378| 43.8k| if (needmax) { ------------------ | Branch (7378:7): [True: 0, False: 43.8k] ------------------ 7379| 0| decSetMaxValue(dn, set); 7380| 0| dn->bits=sign; // set sign 7381| 0| } 7382| 43.8k| else dn->bits=sign|DECINF; // Value is +/-Infinity ------------------ | | 32| 43.8k| #define DECINF 0x40 /* 1=Infinity */ ------------------ 7383| 43.8k| *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; ------------------ | | 139| 43.8k| #define DEC_Overflow 0x00000200 ------------------ *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; ------------------ | | 133| 43.8k| #define DEC_Inexact 0x00000020 ------------------ *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; ------------------ | | 141| 43.8k| #define DEC_Rounded 0x00000800 ------------------ 7384| 43.8k| } // decSetOverflow decNumber.c:decCompareOp: 6006| 1.79M| Flag op, uInt *status) { 6007| | #if DECSUBSET 6008| | decNumber *alloclhs=NULL; // non-NULL if rounded lhs allocated 6009| | decNumber *allocrhs=NULL; // .., rhs 6010| | #endif 6011| 1.79M| Int result=0; // default result value ------------------ | | 92| 1.79M| #define Int int32_t ------------------ 6012| 1.79M| uByte merged; // work ------------------ | | 89| 1.79M| #define uByte uint8_t ------------------ 6013| | 6014| | #if DECCHECK 6015| | if (decCheckOperands(res, lhs, rhs, set)) return res; 6016| | #endif 6017| | 6018| 1.79M| do { // protect allocated storage 6019| | #if DECSUBSET 6020| | if (!set->extended) { 6021| | // reduce operands and set lostDigits status, as needed 6022| | if (lhs->digits>set->digits) { 6023| | alloclhs=decRoundOperand(lhs, set, status); 6024| | if (alloclhs==NULL) {result=BADINT; break;} 6025| | lhs=alloclhs; 6026| | } 6027| | if (rhs->digits>set->digits) { 6028| | allocrhs=decRoundOperand(rhs, set, status); 6029| | if (allocrhs==NULL) {result=BADINT; break;} 6030| | rhs=allocrhs; 6031| | } 6032| | } 6033| | #endif 6034| | // [following code does not require input rounding] 6035| | 6036| | // If total ordering then handle differing signs 'up front' 6037| 1.79M| if (op==COMPTOTAL) { // total ordering ------------------ | | 187| 1.79M|#define COMPTOTAL 0x04 // .. ------------------ | Branch (6037:9): [True: 0, False: 1.79M] ------------------ 6038| 0| if (decNumberIsNegative(lhs) & !decNumberIsNegative(rhs)) { ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ ------------------ if (decNumberIsNegative(lhs) & !decNumberIsNegative(rhs)) { ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ ------------------ | Branch (6038:11): [True: 0, False: 0] ------------------ 6039| 0| result=-1; 6040| 0| break; 6041| 0| } 6042| 0| if (!decNumberIsNegative(lhs) & decNumberIsNegative(rhs)) { ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ ------------------ if (!decNumberIsNegative(lhs) & decNumberIsNegative(rhs)) { ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ ------------------ | Branch (6042:11): [True: 0, False: 0] ------------------ 6043| 0| result=+1; 6044| 0| break; 6045| 0| } 6046| 0| } 6047| | 6048| | // handle NaNs specially; let infinities drop through 6049| | // This assumes sNaN (even just one) leads to NaN. 6050| 1.79M| merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN); ------------------ | | 34| 1.79M| #define DECSNAN 0x10 /* 1=sNaN */ ------------------ merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN); ------------------ | | 33| 1.79M| #define DECNAN 0x20 /* 1=NaN */ ------------------ 6051| 1.79M| if (merged) { // a NaN bit set ------------------ | Branch (6051:9): [True: 0, False: 1.79M] ------------------ 6052| 0| if (op==COMPARE); // result will be NaN ------------------ | | 184| 0|#define COMPARE 0x01 // Compare operators ------------------ | Branch (6052:11): [True: 0, False: 0] ------------------ 6053| 0| else if (op==COMPSIG) // treat qNaN as sNaN ------------------ | | 189| 0|#define COMPSIG 0x06 // .. [signaling COMPARE] ------------------ | Branch (6053:17): [True: 0, False: 0] ------------------ 6054| 0| *status|=DEC_Invalid_operation | DEC_sNaN; ------------------ | | 135| 0| #define DEC_Invalid_operation 0x00000080 ------------------ *status|=DEC_Invalid_operation | DEC_sNaN; ------------------ | | 193| 0|#define DEC_sNaN 0x40000000 // local status: sNaN signal ------------------ 6055| 0| else if (op==COMPTOTAL) { // total ordering, always finite ------------------ | | 187| 0|#define COMPTOTAL 0x04 // .. ------------------ | Branch (6055:17): [True: 0, False: 0] ------------------ 6056| | // signs are known to be the same; compute the ordering here 6057| | // as if the signs are both positive, then invert for negatives 6058| 0| if (!decNumberIsNaN(lhs)) result=-1; ------------------ | | 172| 0| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ | Branch (6058:13): [True: 0, False: 0] ------------------ 6059| 0| else if (!decNumberIsNaN(rhs)) result=+1; ------------------ | | 172| 0| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ | Branch (6059:19): [True: 0, False: 0] ------------------ 6060| | // here if both NaNs 6061| 0| else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1; ------------------ | | 175| 0| #define decNumberIsSNaN(dn) (((dn)->bits&(DECSNAN))!=0) | | ------------------ | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (175:36): [True: 0, False: 0] | | ------------------ ------------------ else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1; ------------------ | | 174| 0| #define decNumberIsQNaN(dn) (((dn)->bits&(DECNAN))!=0) | | ------------------ | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | | Branch (174:36): [True: 0, False: 0] | | ------------------ ------------------ 6062| 0| else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1; ------------------ | | 174| 0| #define decNumberIsQNaN(dn) (((dn)->bits&(DECNAN))!=0) | | ------------------ | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | | Branch (174:36): [True: 0, False: 0] | | ------------------ ------------------ else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1; ------------------ | | 175| 0| #define decNumberIsSNaN(dn) (((dn)->bits&(DECSNAN))!=0) | | ------------------ | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (175:36): [True: 0, False: 0] | | ------------------ ------------------ 6063| 0| else { // both NaN or both sNaN 6064| | // now it just depends on the payload 6065| 0| result=decUnitCompare(lhs->lsu, D2U(lhs->digits), ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 6066| 0| rhs->lsu, D2U(rhs->digits), 0); ------------------ | | 264| 0| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 0| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 0, False: 0] | | ------------------ ------------------ 6067| | // [Error not possible, as these are 'aligned'] 6068| 0| } // both same NaNs 6069| 0| if (decNumberIsNegative(lhs)) result=-result; ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 0, False: 0] | | ------------------ ------------------ 6070| 0| break; 6071| 0| } // total order 6072| | 6073| 0| else if (merged & DECSNAN); // sNaN -> qNaN ------------------ | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ ------------------ | Branch (6073:17): [True: 0, False: 0] ------------------ 6074| 0| else { // here if MIN or MAX and one or two quiet NaNs 6075| | // min or max -- 754 rules ignore single NaN 6076| 0| if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) { ------------------ | | 172| 0| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) { ------------------ | | 172| 0| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ | Branch (6076:13): [True: 0, False: 0] | Branch (6076:37): [True: 0, False: 0] ------------------ 6077| | // just one NaN; force choice to be the non-NaN operand 6078| 0| op=COMPMAX; ------------------ | | 185| 0|#define COMPMAX 0x02 // .. ------------------ 6079| 0| if (lhs->bits & DECNAN) result=-1; // pick rhs ------------------ | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ ------------------ | Branch (6079:15): [True: 0, False: 0] ------------------ 6080| 0| else result=+1; // pick lhs 6081| 0| break; 6082| 0| } 6083| 0| } // max or min 6084| 0| op=COMPNAN; // use special path ------------------ | | 188| 0|#define COMPNAN 0x05 // .. [NaN processing] ------------------ 6085| 0| decNaNs(res, lhs, rhs, set, status); // propagate NaN 6086| 0| break; 6087| 0| } 6088| | // have numbers 6089| 1.79M| if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1); ------------------ | | 190| 3.58M|#define COMPMAXMAG 0x07 // .. ------------------ if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1); ------------------ | | 191| 1.79M|#define COMPMINMAG 0x08 // .. ------------------ | Branch (6089:9): [True: 0, False: 1.79M] | Branch (6089:27): [True: 0, False: 1.79M] ------------------ 6090| 1.79M| else result=decCompare(lhs, rhs, 0); // sign matters 6091| 1.79M| } while(0); // end protected ------------------ | Branch (6091:13): [Folded, False: 1.79M] ------------------ 6092| | 6093| 1.79M| if (result==BADINT) *status|=DEC_Insufficient_storage; // rare ------------------ | | 194| 1.79M|#define BADINT (Int)0x80000000 // most-negative Int; error indicator ------------------ if (result==BADINT) *status|=DEC_Insufficient_storage; // rare ------------------ | | 132| 0| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ ------------------ | Branch (6093:7): [True: 0, False: 1.79M] ------------------ 6094| 1.79M| else { 6095| 1.79M| if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { // returning signum ------------------ | | 184| 3.58M|#define COMPARE 0x01 // Compare operators ------------------ if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { // returning signum ------------------ | | 189| 1.79M|#define COMPSIG 0x06 // .. [signaling COMPARE] ------------------ if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { // returning signum ------------------ | | 187| 0|#define COMPTOTAL 0x04 // .. ------------------ | Branch (6095:9): [True: 1.79M, False: 0] | Branch (6095:24): [True: 0, False: 0] | Branch (6095:38): [True: 0, False: 0] ------------------ 6096| 1.79M| if (op==COMPTOTAL && result==0) { ------------------ | | 187| 3.58M|#define COMPTOTAL 0x04 // .. ------------------ | Branch (6096:11): [True: 0, False: 1.79M] | Branch (6096:28): [True: 0, False: 0] ------------------ 6097| | // operands are numerically equal or same NaN (and same sign, 6098| | // tested first); if identical, leave result 0 6099| 0| if (lhs->exponent!=rhs->exponent) { ------------------ | Branch (6099:13): [True: 0, False: 0] ------------------ 6100| 0| if (lhs->exponentexponent) result=-1; ------------------ | Branch (6100:15): [True: 0, False: 0] ------------------ 6101| 0| else result=+1; 6102| 0| if (decNumberIsNegative(lhs)) result=-result; ------------------ | | 173| 0| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 0, False: 0] | | ------------------ ------------------ 6103| 0| } // lexp!=rexp 6104| 0| } // total-order by exponent 6105| 1.79M| decNumberZero(res); // [always a valid result] 6106| 1.79M| if (result!=0) { // must be -1 or +1 ------------------ | Branch (6106:11): [True: 973k, False: 816k] ------------------ 6107| 973k| *res->lsu=1; 6108| 973k| if (result<0) res->bits=DECNEG; ------------------ | | 31| 611k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ | Branch (6108:13): [True: 611k, False: 362k] ------------------ 6109| 973k| } 6110| 1.79M| } 6111| 0| else if (op==COMPNAN); // special, drop through ------------------ | | 188| 0|#define COMPNAN 0x05 // .. [NaN processing] ------------------ | Branch (6111:15): [True: 0, False: 0] ------------------ 6112| 0| else { // MAX or MIN, non-NaN result 6113| 0| Int residue=0; // rounding accumulator ------------------ | | 92| 0| #define Int int32_t ------------------ 6114| | // choose the operand for the result 6115| 0| const decNumber *choice; 6116| 0| if (result==0) { // operands are numerically equal ------------------ | Branch (6116:11): [True: 0, False: 0] ------------------ 6117| | // choose according to sign then exponent (see 754) 6118| 0| uByte slhs=(lhs->bits & DECNEG); ------------------ | | 89| 0| #define uByte uint8_t ------------------ uByte slhs=(lhs->bits & DECNEG); ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 6119| 0| uByte srhs=(rhs->bits & DECNEG); ------------------ | | 89| 0| #define uByte uint8_t ------------------ uByte srhs=(rhs->bits & DECNEG); ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 6120| | #if DECSUBSET 6121| | if (!set->extended) { // subset: force left-hand 6122| | op=COMPMAX; 6123| | result=+1; 6124| | } 6125| | else 6126| | #endif 6127| 0| if (slhs!=srhs) { // signs differ ------------------ | Branch (6127:13): [True: 0, False: 0] ------------------ 6128| 0| if (slhs) result=-1; // rhs is max ------------------ | Branch (6128:15): [True: 0, False: 0] ------------------ 6129| 0| else result=+1; // lhs is max 6130| 0| } 6131| 0| else if (slhs && srhs) { // both negative ------------------ | Branch (6131:19): [True: 0, False: 0] | Branch (6131:27): [True: 0, False: 0] ------------------ 6132| 0| if (lhs->exponentexponent) result=+1; ------------------ | Branch (6132:15): [True: 0, False: 0] ------------------ 6133| 0| else result=-1; 6134| | // [if equal, use lhs, technically identical] 6135| 0| } 6136| 0| else { // both positive 6137| 0| if (lhs->exponent>rhs->exponent) result=+1; ------------------ | Branch (6137:15): [True: 0, False: 0] ------------------ 6138| 0| else result=-1; 6139| | // [ditto] 6140| 0| } 6141| 0| } // numerically equal 6142| | // here result will be non-0; reverse if looking for MIN 6143| 0| if (op==COMPMIN || op==COMPMINMAG) result=-result; ------------------ | | 186| 0|#define COMPMIN 0x03 // .. ------------------ if (op==COMPMIN || op==COMPMINMAG) result=-result; ------------------ | | 191| 0|#define COMPMINMAG 0x08 // .. ------------------ | Branch (6143:11): [True: 0, False: 0] | Branch (6143:26): [True: 0, False: 0] ------------------ 6144| 0| choice=(result>0 ? lhs : rhs); // choose ------------------ | Branch (6144:15): [True: 0, False: 0] ------------------ 6145| | // copy chosen to result, rounding if need be 6146| 0| decCopyFit(res, choice, set, &residue, status); 6147| 0| decFinish(res, set, &residue, status); ------------------ | | 267| 0|#define decFinish(a,b,c,d) decFinalize(a,b,c,d) ------------------ 6148| 0| } 6149| 1.79M| } 6150| | #if DECSUBSET 6151| | if (allocrhs!=NULL) free(allocrhs); // free any storage used 6152| | if (alloclhs!=NULL) free(alloclhs); // .. 6153| | #endif 6154| 1.79M| return res; 6155| 1.79M| } // decCompareOp decNumber.c:decCompare: 6170| 1.79M| Flag abs) { 6171| 1.79M| Int result; // result value ------------------ | | 92| 1.79M| #define Int int32_t ------------------ 6172| 1.79M| Int sigr; // rhs signum ------------------ | | 92| 1.79M| #define Int int32_t ------------------ 6173| 1.79M| Int compare; // work ------------------ | | 92| 1.79M| #define Int int32_t ------------------ 6174| | 6175| 1.79M| result=1; // assume signum(lhs) 6176| 1.79M| if (ISZERO(lhs)) result=0; ------------------ | | 255| 1.79M| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 1.79M| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 75.7k, False: 1.71M] | | | | ------------------ | | | | 178| 1.79M| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 61.9k, False: 13.7k] | | | | ------------------ | | | | 179| 1.79M| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 61.9k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 61.9k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 61.9k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 61.9k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 49.5k, False: 12.3k] | | | | ------------------ | | ------------------ ------------------ 6177| 1.79M| if (abs) { ------------------ | Branch (6177:7): [True: 444, False: 1.79M] ------------------ 6178| 444| if (ISZERO(rhs)) return result; // LHS wins or both 0 ------------------ | | 255| 444| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 444| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 0, False: 444] | | | | ------------------ | | | | 178| 444| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 0, False: 0] | | | | ------------------ | | | | 179| 444| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 0| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 0| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 6179| | // RHS is non-zero 6180| 444| if (result==0) return -1; // LHS is 0; RHS wins ------------------ | Branch (6180:9): [True: 56, False: 388] ------------------ 6181| | // [here, both non-zero, result=1] 6182| 444| } 6183| 1.79M| else { // signs matter 6184| 1.79M| if (result && decNumberIsNegative(lhs)) result=-1; ------------------ | | 173| 1.74M| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 1.74M| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 3.06k, False: 1.73M] | | ------------------ ------------------ | Branch (6184:9): [True: 1.74M, False: 49.4k] ------------------ 6185| 1.79M| sigr=1; // compute signum(rhs) 6186| 1.79M| if (ISZERO(rhs)) sigr=0; ------------------ | | 255| 1.79M| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 1.79M| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 77.0k, False: 1.71M] | | | | ------------------ | | | | 178| 1.79M| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 63.9k, False: 13.0k] | | | | ------------------ | | | | 179| 1.79M| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 63.9k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 63.9k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 63.9k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 63.9k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 53.9k, False: 10.0k] | | | | ------------------ | | ------------------ ------------------ 6187| 1.73M| else if (decNumberIsNegative(rhs)) sigr=-1; ------------------ | | 173| 1.73M| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 1.73M| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 2.92k, False: 1.73M] | | ------------------ ------------------ 6188| 1.79M| if (result > sigr) return +1; // L > R, return 1 ------------------ | Branch (6188:9): [True: 11.0k, False: 1.77M] ------------------ 6189| 1.77M| if (result < sigr) return -1; // L < R, return -1 ------------------ | Branch (6189:9): [True: 7.44k, False: 1.77M] ------------------ 6190| 1.77M| if (result==0) return 0; // both 0 ------------------ | Branch (6190:9): [True: 43.2k, False: 1.72M] ------------------ 6191| 1.77M| } 6192| | 6193| | // signums are the same; both are non-zero 6194| 1.72M| if ((lhs->bits | rhs->bits) & DECINF) { // one or more infinities ------------------ | | 32| 1.72M| #define DECINF 0x40 /* 1=Infinity */ ------------------ | Branch (6194:7): [True: 14.3k, False: 1.71M] ------------------ 6195| 14.3k| if (decNumberIsInfinite(rhs)) { ------------------ | | 171| 14.3k| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 14.3k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 9.92k, False: 4.43k] | | ------------------ ------------------ 6196| 9.92k| if (decNumberIsInfinite(lhs)) result=0;// both infinite ------------------ | | 171| 9.92k| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 9.92k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 7.69k, False: 2.23k] | | ------------------ ------------------ 6197| 2.23k| else result=-result; // only rhs infinite 6198| 9.92k| } 6199| 14.3k| return result; 6200| 14.3k| } 6201| | // must compare the coefficients, allowing for exponents 6202| 1.71M| if (lhs->exponent>rhs->exponent) { // LHS exponent larger ------------------ | Branch (6202:7): [True: 58.4k, False: 1.65M] ------------------ 6203| | // swap sides, and sign 6204| 58.4k| const decNumber *temp=lhs; 6205| 58.4k| lhs=rhs; 6206| 58.4k| rhs=temp; 6207| 58.4k| result=-result; 6208| 58.4k| } 6209| 1.71M| compare=decUnitCompare(lhs->lsu, D2U(lhs->digits), ------------------ | | 264| 1.71M| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.71M| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 2.28k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 2.28k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.71M, False: 2.28k] | | ------------------ ------------------ 6210| 1.71M| rhs->lsu, D2U(rhs->digits), ------------------ | | 264| 1.71M| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.71M| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 1.83k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 1.83k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.71M, False: 1.83k] | | ------------------ ------------------ 6211| 1.71M| rhs->exponent-lhs->exponent); 6212| 1.71M| if (compare!=BADINT) compare*=result; // comparison succeeded ------------------ | | 194| 1.71M|#define BADINT (Int)0x80000000 // most-negative Int; error indicator ------------------ | Branch (6212:7): [True: 1.71M, False: 0] ------------------ 6213| 1.71M| return compare; 6214| 1.72M| } // decCompare decNumber.c:decTrim: 6592| 137k| Flag noclamp, Int *dropped) { 6593| 137k| Int d, exp; // work ------------------ | | 92| 137k| #define Int int32_t ------------------ 6594| 137k| uInt cut; // .. ------------------ | | 93| 137k| #define uInt uint32_t ------------------ 6595| 137k| Unit *up; // -> current Unit ------------------ | | 94| 137k| #define Unit decNumberUnit | | ------------------ | | | | 59| 137k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6596| | 6597| | #if DECCHECK 6598| | if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 6599| | #endif 6600| | 6601| 137k| *dropped=0; // assume no zeros dropped 6602| 137k| if ((dn->bits & DECSPECIAL) // fast exit if special .. ------------------ | | 36| 137k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 32| 137k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 33| 137k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 34| 137k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ | Branch (6602:7): [True: 3.33k, False: 133k] ------------------ 6603| 133k| || (*dn->lsu & 0x01)) return dn; // .. or odd ------------------ | Branch (6603:8): [True: 65.8k, False: 67.9k] ------------------ 6604| 67.9k| if (ISZERO(dn)) { // .. or 0 ------------------ | | 255| 67.9k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 67.9k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 23.0k, False: 44.8k] | | | | ------------------ | | | | 178| 67.9k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 18.5k, False: 4.57k] | | | | ------------------ | | | | 179| 67.9k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 18.5k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 18.5k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 18.5k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 18.5k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 18.5k, False: 0] | | | | ------------------ | | ------------------ ------------------ 6605| 18.5k| dn->exponent=0; // (sign is preserved) 6606| 18.5k| return dn; 6607| 18.5k| } 6608| | 6609| | // have a finite number which is even 6610| 49.4k| exp=dn->exponent; 6611| 49.4k| cut=1; // digit (1-DECDPUN) in Unit 6612| 49.4k| up=dn->lsu; // -> current Unit 6613| 87.0k| for (d=0; ddigits-1; d++) { // [don't strip the final digit] ------------------ | Branch (6613:13): [True: 55.3k, False: 31.6k] ------------------ 6614| | // slice by powers 6615| 55.3k| #if DECDPUN<=4 6616| 55.3k| uInt quot=QUOT10(*up, cut); ------------------ | | 93| 55.3k| #define uInt uint32_t ------------------ uInt quot=QUOT10(*up, cut); ------------------ | | 210| 55.3k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6617| 55.3k| if ((*up-quot*powers[cut])!=0) break; // found non-0 digit ------------------ | | 177| 55.3k|#define powers DECPOWERS // old internal name ------------------ | Branch (6617:11): [True: 17.7k, False: 37.6k] ------------------ 6618| | #else 6619| | if (*up%powers[cut]!=0) break; // found non-0 digit 6620| | #endif 6621| | // have a trailing 0 6622| 37.6k| if (!all) { // trimming ------------------ | Branch (6622:9): [True: 0, False: 37.6k] ------------------ 6623| | // [if exp>0 then all trailing 0s are significant for trim] 6624| 0| if (exp<=0) { // if digit might be significant ------------------ | Branch (6624:11): [True: 0, False: 0] ------------------ 6625| 0| if (exp==0) break; // then quit ------------------ | Branch (6625:13): [True: 0, False: 0] ------------------ 6626| 0| exp++; // next digit might be significant 6627| 0| } 6628| 0| } 6629| 37.6k| cut++; // next power 6630| 37.6k| if (cut>DECDPUN) { // need new Unit ------------------ | | 43| 37.6k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6630:9): [True: 10.0k, False: 27.5k] ------------------ 6631| 10.0k| up++; 6632| 10.0k| cut=1; 6633| 10.0k| } 6634| 37.6k| } // d 6635| 49.4k| if (d==0) return dn; // none to drop ------------------ | Branch (6635:7): [True: 40.0k, False: 9.34k] ------------------ 6636| | 6637| | // may need to limit drop if clamping 6638| 9.34k| if (set->clamp && !noclamp) { ------------------ | Branch (6638:7): [True: 9.34k, False: 0] | Branch (6638:21): [True: 9.34k, False: 0] ------------------ 6639| 9.34k| Int maxd=set->emax-set->digits+1-dn->exponent; ------------------ | | 92| 9.34k| #define Int int32_t ------------------ 6640| 9.34k| if (maxd<=0) return dn; // nothing possible ------------------ | Branch (6640:9): [True: 1.25k, False: 8.09k] ------------------ 6641| 8.09k| if (d>maxd) d=maxd; ------------------ | Branch (6641:9): [True: 106, False: 7.99k] ------------------ 6642| 8.09k| } 6643| | 6644| | // effect the drop 6645| 8.09k| decShiftToLeast(dn->lsu, D2U(dn->digits), d); ------------------ | | 264| 8.09k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 8.09k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 8.09k, False: 0] | | ------------------ ------------------ 6646| 8.09k| dn->exponent+=d; // maintain numerical value 6647| 8.09k| dn->digits-=d; // new length 6648| 8.09k| *dropped=d; // report the count 6649| 8.09k| return dn; 6650| 9.34k| } // decTrim decNumber.c:decShiftToMost: 6685| 2.28k|static Int decShiftToMost(Unit *uar, Int digits, Int shift) { 6686| 2.28k| Unit *target, *source, *first; // work ------------------ | | 94| 2.28k| #define Unit decNumberUnit | | ------------------ | | | | 59| 2.28k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6687| 2.28k| Int cut; // odd 0's to add ------------------ | | 92| 2.28k| #define Int int32_t ------------------ 6688| 2.28k| uInt next; // work ------------------ | | 93| 2.28k| #define uInt uint32_t ------------------ 6689| | 6690| 2.28k| if (shift==0) return digits; // [fastpath] nothing to do ------------------ | Branch (6690:7): [True: 0, False: 2.28k] ------------------ 6691| 2.28k| if ((digits+shift)<=DECDPUN) { // [fastpath] single-unit case ------------------ | | 43| 2.28k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6691:7): [True: 457, False: 1.83k] ------------------ 6692| 457| *uar=(Unit)(*uar*powers[shift]); ------------------ | | 177| 457|#define powers DECPOWERS // old internal name ------------------ 6693| 457| return digits+shift; 6694| 457| } 6695| | 6696| 1.83k| next=0; // all paths 6697| 1.83k| source=uar+D2U(digits)-1; // where msu comes from ------------------ | | 264| 1.83k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.83k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 248| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 248| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.58k, False: 248] | | ------------------ ------------------ 6698| 1.83k| target=source+D2U(shift); // where upper part of first cut goes ------------------ | | 264| 1.83k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.83k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.83k, False: 0] | | ------------------ ------------------ 6699| 1.83k| cut=DECDPUN-MSUDIGITS(shift); // where to slice ------------------ | | 43| 1.83k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ cut=DECDPUN-MSUDIGITS(shift); // where to slice ------------------ | | 271| 1.83k| #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 264| 1.83k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 249| 1.83k| #define DECMAXD2U 49 | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | | Branch (264:21): [True: 1.83k, False: 0] | | | | ------------------ | | ------------------ | | #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 43| 1.83k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ ------------------ 6700| 1.83k| if (cut==0) { // unit-boundary case ------------------ | Branch (6700:7): [True: 427, False: 1.40k] ------------------ 6701| 1.49k| for (; source>=uar; source--, target--) *target=*source; ------------------ | Branch (6701:12): [True: 1.06k, False: 427] ------------------ 6702| 427| } 6703| 1.40k| else { 6704| 1.40k| first=uar+D2U(digits+shift)-1; // where msu of source will end up ------------------ | | 264| 1.40k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.40k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 250| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 250| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.15k, False: 250] | | ------------------ ------------------ 6705| 262k| for (; source>=uar; source--, target--) { ------------------ | Branch (6705:12): [True: 260k, False: 1.40k] ------------------ 6706| | // split the source Unit and accumulate remainder for next 6707| 260k| #if DECDPUN<=4 6708| 260k| uInt quot=QUOT10(*source, cut); ------------------ | | 93| 260k| #define uInt uint32_t ------------------ uInt quot=QUOT10(*source, cut); ------------------ | | 210| 260k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6709| 260k| uInt rem=*source-quot*powers[cut]; ------------------ | | 93| 260k| #define uInt uint32_t ------------------ uInt rem=*source-quot*powers[cut]; ------------------ | | 177| 260k|#define powers DECPOWERS // old internal name ------------------ 6710| 260k| next+=quot; 6711| | #else 6712| | uInt rem=*source%powers[cut]; 6713| | next+=*source/powers[cut]; 6714| | #endif 6715| 260k| if (target<=first) *target=(Unit)next; // write to target iff valid ------------------ | Branch (6715:11): [True: 259k, False: 1.20k] ------------------ 6716| 260k| next=rem*powers[DECDPUN-cut]; // save remainder for next Unit ------------------ | | 177| 260k|#define powers DECPOWERS // old internal name ------------------ next=rem*powers[DECDPUN-cut]; // save remainder for next Unit ------------------ | | 43| 260k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6717| 260k| } 6718| 1.40k| } // shift-move 6719| | 6720| | // propagate any partial unit to one below and clear the rest 6721| 6.09k| for (; target>=uar; target--) { ------------------ | Branch (6721:10): [True: 4.26k, False: 1.83k] ------------------ 6722| 4.26k| *target=(Unit)next; 6723| 4.26k| next=0; 6724| 4.26k| } 6725| 1.83k| return digits+shift; 6726| 2.28k| } // decShiftToMost decNumber.c:decShiftToLeast: 6741| 8.09k|static Int decShiftToLeast(Unit *uar, Int units, Int shift) { 6742| 8.09k| Unit *target, *up; // work ------------------ | | 94| 8.09k| #define Unit decNumberUnit | | ------------------ | | | | 59| 8.09k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6743| 8.09k| Int cut, count; // work ------------------ | | 92| 8.09k| #define Int int32_t ------------------ 6744| 8.09k| Int quot, rem; // for division ------------------ | | 92| 8.09k| #define Int int32_t ------------------ 6745| | 6746| 8.09k| if (shift==0) return units; // [fastpath] nothing to do ------------------ | Branch (6746:7): [True: 0, False: 8.09k] ------------------ 6747| 8.09k| if (shift==units*DECDPUN) { // [fastpath] little to do ------------------ | | 43| 8.09k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6747:7): [True: 0, False: 8.09k] ------------------ 6748| 0| *uar=0; // all digits cleared gives zero 6749| 0| return 1; // leaves just the one 6750| 0| } 6751| | 6752| 8.09k| target=uar; // both paths 6753| 8.09k| cut=MSUDIGITS(shift); ------------------ | | 271| 8.09k| #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 264| 8.09k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 249| 8.09k| #define DECMAXD2U 49 | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | | Branch (264:21): [True: 8.09k, False: 0] | | | | ------------------ | | ------------------ | | #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 43| 8.09k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ ------------------ 6754| 8.09k| if (cut==DECDPUN) { // unit-boundary case; easy ------------------ | | 43| 8.09k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6754:7): [True: 2.52k, False: 5.57k] ------------------ 6755| 2.52k| up=uar+D2U(shift); ------------------ | | 264| 2.52k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 2.52k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 2.52k, False: 0] | | ------------------ ------------------ 6756| 10.6k| for (; up0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 0| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 5.57k, False: 0] | | ------------------ ------------------ 6762| 5.57k| count=units*DECDPUN-shift; // the maximum new length ------------------ | | 43| 5.57k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6763| 5.57k| #if DECDPUN<=4 6764| 5.57k| quot=QUOT10(*up, cut); ------------------ | | 210| 5.57k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6765| | #else 6766| | quot=*up/powers[cut]; 6767| | #endif 6768| 16.6k| for (; ; target++) { 6769| 16.6k| *target=(Unit)quot; 6770| 16.6k| count-=(DECDPUN-cut); ------------------ | | 43| 16.6k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6771| 16.6k| if (count<=0) break; ------------------ | Branch (6771:9): [True: 5.57k, False: 11.0k] ------------------ 6772| 11.0k| up++; 6773| 11.0k| quot=*up; 6774| 11.0k| #if DECDPUN<=4 6775| 11.0k| quot=QUOT10(quot, cut); ------------------ | | 210| 11.0k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6776| 11.0k| rem=*up-quot*powers[cut]; ------------------ | | 177| 11.0k|#define powers DECPOWERS // old internal name ------------------ 6777| | #else 6778| | rem=quot%powers[cut]; 6779| | quot=quot/powers[cut]; 6780| | #endif 6781| 11.0k| *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 177| 11.0k|#define powers DECPOWERS // old internal name ------------------ *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 43| 11.0k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6782| 11.0k| count-=cut; 6783| 11.0k| if (count<=0) break; ------------------ | Branch (6783:9): [True: 0, False: 11.0k] ------------------ 6784| 11.0k| } 6785| 5.57k| return target-uar+1; 6786| 8.09k| } // decShiftToLeast decNumber.c:decCopyFit: 6844| 704k| decContext *set, Int *residue, uInt *status) { 6845| 704k| dest->bits=src->bits; 6846| 704k| dest->exponent=src->exponent; 6847| 704k| decSetCoeff(dest, set, src->lsu, src->digits, residue, status); 6848| 704k| } // decCopyFit decNumber.c:decSetCoeff: 6890| 713k| Int len, Int *residue, uInt *status) { 6891| 713k| Int discard; // number of digits to discard ------------------ | | 92| 713k| #define Int int32_t ------------------ 6892| 713k| uInt cut; // cut point in Unit ------------------ | | 93| 713k| #define uInt uint32_t ------------------ 6893| 713k| const Unit *up; // work 6894| 713k| Unit *target; // .. ------------------ | | 94| 713k| #define Unit decNumberUnit | | ------------------ | | | | 59| 713k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6895| 713k| Int count; // .. ------------------ | | 92| 713k| #define Int int32_t ------------------ 6896| 713k| #if DECDPUN<=4 6897| 713k| uInt temp; // .. ------------------ | | 93| 713k| #define uInt uint32_t ------------------ 6898| 713k| #endif 6899| | 6900| 713k| discard=len-set->digits; // digits to discard 6901| 713k| if (discard<=0) { // no digits are being discarded ------------------ | Branch (6901:7): [True: 693k, False: 20.2k] ------------------ 6902| 693k| if (dn->lsu!=lsu) { // copy needed ------------------ | Branch (6902:9): [True: 693k, False: 0] ------------------ 6903| | // copy the coefficient array to the result number; no shift needed 6904| 693k| count=len; // avoids D2U 6905| 693k| up=lsu; 6906| 3.57M| for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) ------------------ | | 43| 2.88M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6906:28): [True: 2.88M, False: 693k] ------------------ 6907| 2.88M| *target=*up; 6908| 693k| dn->digits=len; // set the new length 6909| 693k| } 6910| | // dn->exponent and residue are unchanged, record any inexactitude 6911| 693k| if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded); ------------------ | | 133| 0| #define DEC_Inexact 0x00000020 ------------------ if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded); ------------------ | | 141| 0| #define DEC_Rounded 0x00000800 ------------------ | Branch (6911:9): [True: 0, False: 693k] ------------------ 6912| 693k| return; 6913| 693k| } 6914| | 6915| | // some digits must be discarded ... 6916| 20.2k| dn->exponent+=discard; // maintain numerical value 6917| 20.2k| *status|=DEC_Rounded; // accumulate Rounded status ------------------ | | 141| 20.2k| #define DEC_Rounded 0x00000800 ------------------ 6918| 20.2k| if (*residue>1) *residue=1; // previous residue now to right, so reduce ------------------ | Branch (6918:7): [True: 1.07k, False: 19.2k] ------------------ 6919| | 6920| 20.2k| if (discard>len) { // everything, +1, is being discarded ------------------ | Branch (6920:7): [True: 3.64k, False: 16.6k] ------------------ 6921| | // guard digit is 0 6922| | // residue is all the number [NB could be all 0s] 6923| 3.64k| if (*residue<=0) { // not already positive ------------------ | Branch (6923:9): [True: 3.25k, False: 385] ------------------ 6924| 3.25k| count=len; // avoids D2U 6925| 5.50k| for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { // found non-0 ------------------ | | 43| 2.24k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6925:20): [True: 5.50k, False: 0] | Branch (6925:55): [True: 3.25k, False: 2.24k] ------------------ 6926| 3.25k| *residue=1; 6927| 3.25k| break; // no need to check any others 6928| 3.25k| } 6929| 3.25k| } 6930| 3.64k| if (*residue!=0) *status|=DEC_Inexact; // record inexactitude ------------------ | | 133| 3.64k| #define DEC_Inexact 0x00000020 ------------------ | Branch (6930:9): [True: 3.64k, False: 0] ------------------ 6931| 3.64k| *dn->lsu=0; // coefficient will now be 0 6932| 3.64k| dn->digits=1; // .. 6933| 3.64k| return; 6934| 3.64k| } // total discard 6935| | 6936| | // partial discard [most common case] 6937| | // here, at least the first (most significant) discarded digit exists 6938| | 6939| | // spin up the number, noting residue during the spin, until get to 6940| | // the Unit with the first discarded digit. When reach it, extract 6941| | // it and remember its position 6942| 16.6k| count=0; 6943| 2.27M| for (up=lsu;; up++) { 6944| 2.27M| count+=DECDPUN; ------------------ | | 43| 2.27M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6945| 2.27M| if (count>=discard) break; // full ones all checked ------------------ | Branch (6945:9): [True: 16.6k, False: 2.25M] ------------------ 6946| 2.25M| if (*up!=0) *residue=1; ------------------ | Branch (6946:9): [True: 21.3k, False: 2.23M] ------------------ 6947| 2.25M| } // up 6948| | 6949| | // here up -> Unit with first discarded digit 6950| 16.6k| cut=discard-(count-DECDPUN)-1; ------------------ | | 43| 16.6k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6951| 16.6k| if (cut==DECDPUN-1) { // unit-boundary case (fast) ------------------ | | 43| 16.6k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6951:7): [True: 4.07k, False: 12.5k] ------------------ 6952| 4.07k| Unit half=(Unit)powers[DECDPUN]>>1; ------------------ | | 94| 4.07k| #define Unit decNumberUnit | | ------------------ | | | | 59| 4.07k| #define decNumberUnit uint16_t | | ------------------ ------------------ Unit half=(Unit)powers[DECDPUN]>>1; ------------------ | | 177| 4.07k|#define powers DECPOWERS // old internal name ------------------ Unit half=(Unit)powers[DECDPUN]>>1; ------------------ | | 43| 4.07k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6953| | // set residue directly 6954| 4.07k| if (*up>=half) { ------------------ | Branch (6954:9): [True: 2.86k, False: 1.20k] ------------------ 6955| 2.86k| if (*up>half) *residue=7; ------------------ | Branch (6955:11): [True: 1.04k, False: 1.82k] ------------------ 6956| 1.82k| else *residue+=5; // add sticky bit 6957| 2.86k| } 6958| 1.20k| else { // digits<=0) { // special for Quantize/Subnormal :-( ------------------ | Branch (6961:9): [True: 339, False: 3.73k] ------------------ 6962| 339| *dn->lsu=0; // .. result is 0 6963| 339| dn->digits=1; // .. 6964| 339| } 6965| 3.73k| else { // shift to least 6966| 3.73k| count=set->digits; // now digits to end up with 6967| 3.73k| dn->digits=count; // set the new length 6968| 3.73k| up++; // move to next 6969| | // on unit boundary, so shift-down copy loop is simple 6970| 646k| for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) ------------------ | | 43| 642k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6970:28): [True: 642k, False: 3.73k] ------------------ 6971| 642k| *target=*up; 6972| 3.73k| } 6973| 4.07k| } // unit-boundary case 6974| | 6975| 12.5k| else { // discard digit is in low digit(s), and not top digit 6976| 12.5k| uInt discard1; // first discarded digit ------------------ | | 93| 12.5k| #define uInt uint32_t ------------------ 6977| 12.5k| uInt quot, rem; // for divisions ------------------ | | 93| 12.5k| #define uInt uint32_t ------------------ 6978| 12.5k| if (cut==0) quot=*up; // is at bottom of unit ------------------ | Branch (6978:9): [True: 6.94k, False: 5.62k] ------------------ 6979| 5.62k| else /* cut>0 */ { // it's not at bottom of unit 6980| 5.62k| #if DECDPUN<=4 6981| 5.62k| quot=QUOT10(*up, cut); ------------------ | | 210| 5.62k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6982| 5.62k| rem=*up-quot*powers[cut]; ------------------ | | 177| 5.62k|#define powers DECPOWERS // old internal name ------------------ 6983| | #else 6984| | rem=*up%powers[cut]; 6985| | quot=*up/powers[cut]; 6986| | #endif 6987| 5.62k| if (rem!=0) *residue=1; ------------------ | Branch (6987:11): [True: 4.87k, False: 744] ------------------ 6988| 5.62k| } 6989| | // discard digit is now at bottom of quot 6990| 12.5k| #if DECDPUN<=4 6991| 12.5k| temp=(quot*6554)>>16; // fast /10 6992| | // Vowels algorithm here not a win (9 instructions) 6993| 12.5k| discard1=quot-X10(temp); ------------------ | | 163| 12.5k| #define X10(i) (((i)<<1)+((i)<<3)) ------------------ 6994| 12.5k| quot=temp; 6995| | #else 6996| | discard1=quot%10; 6997| | quot=quot/10; 6998| | #endif 6999| | // here, discard1 is the guard digit, and residue is everything 7000| | // else [use mapping array to accumulate residue safely] 7001| 12.5k| *residue+=resmap[discard1]; 7002| 12.5k| cut++; // update cut 7003| | // here: up -> Unit of the array with bottom digit 7004| | // cut is the division point for each Unit 7005| | // quot holds the uncut high-order digits for the current unit 7006| 12.5k| if (set->digits<=0) { // special for Quantize/Subnormal :-( ------------------ | Branch (7006:9): [True: 981, False: 11.5k] ------------------ 7007| 981| *dn->lsu=0; // .. result is 0 7008| 981| dn->digits=1; // .. 7009| 981| } 7010| 11.5k| else { // shift to least needed 7011| 11.5k| count=set->digits; // now digits to end up with 7012| 11.5k| dn->digits=count; // set the new length 7013| | // shift-copy the coefficient array to the result number 7014| 1.12M| for (target=dn->lsu; ; target++) { 7015| 1.12M| *target=(Unit)quot; 7016| 1.12M| count-=(DECDPUN-cut); ------------------ | | 43| 1.12M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 7017| 1.12M| if (count<=0) break; ------------------ | Branch (7017:13): [True: 5.62k, False: 1.11M] ------------------ 7018| 1.11M| up++; 7019| 1.11M| quot=*up; 7020| 1.11M| #if DECDPUN<=4 7021| 1.11M| quot=QUOT10(quot, cut); ------------------ | | 210| 1.11M| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 7022| 1.11M| rem=*up-quot*powers[cut]; ------------------ | | 177| 1.11M|#define powers DECPOWERS // old internal name ------------------ 7023| | #else 7024| | rem=quot%powers[cut]; 7025| | quot=quot/powers[cut]; 7026| | #endif 7027| 1.11M| *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 177| 1.11M|#define powers DECPOWERS // old internal name ------------------ *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 43| 1.11M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 7028| 1.11M| count-=cut; 7029| 1.11M| if (count<=0) break; ------------------ | Branch (7029:13): [True: 5.96k, False: 1.11M] ------------------ 7030| 1.11M| } // shift-copy loop 7031| 11.5k| } // shift to least 7032| 12.5k| } // not unit boundary 7033| | 7034| 16.6k| if (*residue!=0) *status|=DEC_Inexact; // record inexactitude ------------------ | | 133| 15.5k| #define DEC_Inexact 0x00000020 ------------------ | Branch (7034:7): [True: 15.5k, False: 1.06k] ------------------ 7035| 16.6k| return; 7036| 20.2k| } // decSetCoeff decNumber.c:decFinalize: 7275| 756k| uInt *status) { 7276| 756k| Int shift; // shift needed if clamping ------------------ | | 92| 756k| #define Int int32_t ------------------ 7277| 756k| Int tinyexp=set->emin-dn->digits+1; // precalculate subnormal boundary ------------------ | | 92| 756k| #define Int int32_t ------------------ 7278| | 7279| | // Must be careful, here, when checking the exponent as the 7280| | // adjusted exponent could overflow 31 bits [because it may already 7281| | // be up to twice the expected]. 7282| | 7283| | // First test for subnormal. This must be done before any final 7284| | // round as the result could be rounded to Nmin or 0. 7285| 756k| if (dn->exponent<=tinyexp) { // prefilter ------------------ | Branch (7285:7): [True: 13.5k, False: 742k] ------------------ 7286| 13.5k| Int comp; ------------------ | | 92| 13.5k| #define Int int32_t ------------------ 7287| 13.5k| decNumber nmin; 7288| | // A very nasty case here is dn == Nmin and residue<0 7289| 13.5k| if (dn->exponentemin; 7298| 444| comp=decCompare(dn, &nmin, 1); // (signless compare) 7299| 444| if (comp==BADINT) { // oops ------------------ | | 194| 444|#define BADINT (Int)0x80000000 // most-negative Int; error indicator ------------------ | Branch (7299:9): [True: 0, False: 444] ------------------ 7300| 0| *status|=DEC_Insufficient_storage; // abandon... ------------------ | | 132| 0| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ ------------------ 7301| 0| return; 7302| 0| } 7303| 444| if (*residue<0 && comp==0) { // neg residue and dn==Nmin ------------------ | Branch (7303:9): [True: 0, False: 444] | Branch (7303:23): [True: 0, False: 0] ------------------ 7304| 0| decApplyRound(dn, set, *residue, status); // might force down 7305| 0| decSetSubnormal(dn, set, residue, status); 7306| 0| return; 7307| 0| } 7308| 444| } 7309| | 7310| | // now apply any pending round (this could raise overflow). 7311| 743k| if (*residue!=0) decApplyRound(dn, set, *residue, status); ------------------ | Branch (7311:7): [True: 9.86k, False: 733k] ------------------ 7312| | 7313| | // Check for overflow [redundant in the 'rare' case] or clamp 7314| 743k| if (dn->exponent<=set->emax-set->digits+1) return; // neither needed ------------------ | Branch (7314:7): [True: 696k, False: 47.1k] ------------------ 7315| | 7316| | 7317| | // here when might have an overflow or clamp to do 7318| 47.1k| if (dn->exponent>set->emax-dn->digits+1) { // too big ------------------ | Branch (7318:7): [True: 44.9k, False: 2.21k] ------------------ 7319| 44.9k| decSetOverflow(dn, set, status); 7320| 44.9k| return; 7321| 44.9k| } 7322| | // here when the result is normal but in clamp range 7323| 2.21k| if (!set->clamp) return; ------------------ | Branch (7323:7): [True: 702, False: 1.51k] ------------------ 7324| | 7325| | // here when need to apply the IEEE exponent clamp (fold-down) 7326| 1.51k| shift=dn->exponent-(set->emax-set->digits+1); 7327| | 7328| | // shift coefficient (if non-zero) 7329| 1.51k| if (!ISZERO(dn)) { ------------------ | | 255| 1.51k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 1.51k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 499, False: 1.01k] | | | | ------------------ | | | | 178| 1.51k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 266, False: 233] | | | | ------------------ | | | | 179| 1.51k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 266| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 266| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 266| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 266| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 266, False: 0] | | | | ------------------ | | ------------------ ------------------ 7330| 1.24k| dn->digits=decShiftToMost(dn->lsu, dn->digits, shift); 7331| 1.24k| } 7332| 1.51k| dn->exponent-=shift; // adjust the exponent to match 7333| 1.51k| *status|=DEC_Clamped; // and record the dirty deed ------------------ | | 140| 1.51k| #define DEC_Clamped 0x00000400 ------------------ 7334| 1.51k| return; 7335| 2.21k| } // decFinalize decNumber.c:decSetSubnormal: 7429| 13.0k| uInt *status) { 7430| 13.0k| decContext workset; // work 7431| 13.0k| Int etiny, adjust; // .. ------------------ | | 92| 13.0k| #define Int int32_t ------------------ 7432| | 7433| | #if DECSUBSET 7434| | // simple set to zero and 'hard underflow' for subset 7435| | if (!set->extended) { 7436| | decNumberZero(dn); 7437| | // always full overflow 7438| | *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded; 7439| | return; 7440| | } 7441| | #endif 7442| | 7443| | // Full arithmetic -- allow subnormals, rounded to minimum exponent 7444| | // (Etiny) if needed 7445| 13.0k| etiny=set->emin-(set->digits-1); // smallest allowed exponent 7446| | 7447| 13.0k| if ISZERO(dn) { // value is zero ------------------ | | 255| 13.0k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 13.0k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 3.68k, False: 9.41k] | | | | ------------------ | | | | 178| 13.0k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 1.95k, False: 1.72k] | | | | ------------------ | | | | 179| 13.0k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 1.95k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 1.95k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 1.95k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 1.95k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 1.95k, False: 0] | | | | ------------------ | | ------------------ ------------------ 7448| | // residue can never be non-zero here 7449| | #if DECCHECK 7450| | if (*residue!=0) { 7451| | printf("++ Subnormal 0 residue %ld\n", (LI)*residue); 7452| | *status|=DEC_Invalid_operation; 7453| | } 7454| | #endif 7455| 1.95k| if (dn->exponentexponent=etiny; 7457| 770| *status|=DEC_Clamped; ------------------ | | 140| 770| #define DEC_Clamped 0x00000400 ------------------ 7458| 770| } 7459| 1.95k| return; 7460| 1.95k| } 7461| | 7462| 11.1k| *status|=DEC_Subnormal; // have a non-zero subnormal ------------------ | | 142| 11.1k| #define DEC_Subnormal 0x00001000 ------------------ 7463| 11.1k| adjust=etiny-dn->exponent; // calculate digits to remove 7464| 11.1k| if (adjust<=0) { // not out of range; unrounded ------------------ | Branch (7464:7): [True: 2.51k, False: 8.62k] ------------------ 7465| | // residue can never be non-zero here, except in the Nmin-residue 7466| | // case (which is a subnormal result), so can take fast-path here 7467| | // it may already be inexact (from setting the coefficient) 7468| 2.51k| if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 133| 2.51k| #define DEC_Inexact 0x00000020 ------------------ if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 143| 0| #define DEC_Underflow 0x00002000 ------------------ | Branch (7468:9): [True: 0, False: 2.51k] ------------------ 7469| 2.51k| return; 7470| 2.51k| } 7471| | 7472| | // adjust>0, so need to rescale the result so exponent becomes Etiny 7473| | // [this code is similar to that in rescale] 7474| 8.62k| workset=*set; // clone rounding, etc. 7475| 8.62k| workset.digits=dn->digits-adjust; // set requested length 7476| 8.62k| workset.emin-=adjust; // and adjust emin to match 7477| | // [note that the latter can be <1, here, similar to Rescale case] 7478| 8.62k| decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status); 7479| 8.62k| decApplyRound(dn, &workset, *residue, status); 7480| | 7481| | // Use 754 default rule: Underflow is set iff Inexact 7482| | // [independent of whether trapped] 7483| 8.62k| if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 133| 8.62k| #define DEC_Inexact 0x00000020 ------------------ if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 143| 8.26k| #define DEC_Underflow 0x00002000 ------------------ | Branch (7483:7): [True: 8.26k, False: 358] ------------------ 7484| | 7485| | // if rounded up a 999s case, exponent will be off by one; adjust 7486| | // back if so [it will fit, because it was shortened earlier] 7487| 8.62k| if (dn->exponent>etiny) { ------------------ | Branch (7487:7): [True: 1.04k, False: 7.57k] ------------------ 7488| 1.04k| dn->digits=decShiftToMost(dn->lsu, dn->digits, 1); 7489| 1.04k| dn->exponent--; // (re)adjust the exponent. 7490| 1.04k| } 7491| | 7492| | // if rounded to zero, it is by definition clamped... 7493| 8.62k| if (ISZERO(dn)) *status|=DEC_Clamped; ------------------ | | 255| 8.62k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 8.62k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 5.56k, False: 3.05k] | | | | ------------------ | | | | 178| 8.62k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 4.12k, False: 1.43k] | | | | ------------------ | | | | 179| 8.62k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 4.12k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 4.12k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 4.12k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 4.12k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 4.12k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (ISZERO(dn)) *status|=DEC_Clamped; ------------------ | | 140| 4.12k| #define DEC_Clamped 0x00000400 ------------------ 7494| 8.62k| } // decSetSubnormal decNumber.c:decBiStr: 7667| 28.5k|static Flag decBiStr(const char *targ, const char *str1, const char *str2) { 7668| 37.3k| for (;;targ++, str1++, str2++) { 7669| 37.3k| if (*targ!=*str1 && *targ!=*str2) return 0; ------------------ | Branch (7669:9): [True: 28.3k, False: 8.99k] | Branch (7669:25): [True: 27.3k, False: 1.00k] ------------------ 7670| | // *targ has a match in one (or both, if terminator) 7671| 9.99k| if (*targ=='\0') break; ------------------ | Branch (7671:9): [True: 1.25k, False: 8.73k] ------------------ 7672| 9.99k| } // forever 7673| 1.25k| return 1; 7674| 28.5k| } // decBiStr decNumber.c:decStatus: 7741| 80.5k|static void decStatus(decNumber *dn, uInt status, decContext *set) { 7742| 80.5k| if (status & DEC_NaNs) { // error status -> NaN ------------------ | | 187| 80.5k| #define DEC_NaNs DEC_IEEE_754_Invalid_operation | | ------------------ | | | | 173| 80.5k| #define DEC_IEEE_754_Invalid_operation (DEC_Conversion_syntax | \ | | | | ------------------ | | | | | | 128| 80.5k| #define DEC_Conversion_syntax 0x00000001 | | | | ------------------ | | | | 174| 80.5k| DEC_Division_impossible | \ | | | | ------------------ | | | | | | 130| 80.5k| #define DEC_Division_impossible 0x00000004 | | | | ------------------ | | | | 175| 80.5k| DEC_Division_undefined | \ | | | | ------------------ | | | | | | 131| 80.5k| #define DEC_Division_undefined 0x00000008 | | | | ------------------ | | | | 176| 80.5k| DEC_Insufficient_storage | \ | | | | ------------------ | | | | | | 132| 80.5k| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ | | | | ------------------ | | | | 177| 80.5k| DEC_Invalid_context | \ | | | | ------------------ | | | | | | 134| 80.5k| #define DEC_Invalid_context 0x00000040 | | | | ------------------ | | | | 178| 80.5k| DEC_Invalid_operation) | | | | ------------------ | | | | | | 135| 80.5k| #define DEC_Invalid_operation 0x00000080 | | | | ------------------ | | ------------------ ------------------ | Branch (7742:7): [True: 11.7k, False: 68.7k] ------------------ 7743| | // if cause was an sNaN, clear and propagate [NaN is already set up] 7744| 11.7k| if (status & DEC_sNaN) status&=~DEC_sNaN; ------------------ | | 193| 11.7k|#define DEC_sNaN 0x40000000 // local status: sNaN signal ------------------ if (status & DEC_sNaN) status&=~DEC_sNaN; ------------------ | | 193| 0|#define DEC_sNaN 0x40000000 // local status: sNaN signal ------------------ | Branch (7744:9): [True: 0, False: 11.7k] ------------------ 7745| 11.7k| else { 7746| 11.7k| decNumberZero(dn); // other error: clean throughout 7747| 11.7k| dn->bits=DECNAN; // and make a quiet NaN ------------------ | | 33| 11.7k| #define DECNAN 0x20 /* 1=NaN */ ------------------ 7748| 11.7k| } 7749| 11.7k| } 7750| 80.5k| decContextSetStatus(set, status); // [may not return] 7751| 80.5k| return; 7752| 80.5k| } // decStatus ascii.c:init: 34| 1|{ 35| 1|#ifdef USE_CALLOUT 36| | 37| 1| int id; 38| 1| OnigEncoding enc; 39| 1| char* name; 40| 1| unsigned int args[4]; 41| 1| OnigValue opts[4]; 42| | 43| 1| enc = ONIG_ENCODING_ASCII; ------------------ | | 189| 1|#define ONIG_ENCODING_ASCII (&OnigEncodingASCII) ------------------ 44| | 45| 1| name = "FAIL"; BC0_P(name, fail); ------------------ | | 990| 1|#define BC0_P(name, func) do {\ | | 991| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 992| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 993| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 994| 1| ONIG_CALLOUT_IN_PROGRESS,\ | | 995| 1| onig_builtin_ ## func, 0, 0, 0, 0, 0);\ | | 996| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (996:7): [True: 0, False: 1] | | ------------------ | | 997| 1|} while(0) | | ------------------ | | | Branch (997:9): [Folded, False: 1] | | ------------------ ------------------ 46| 1| name = "MISMATCH"; BC0_P(name, mismatch); ------------------ | | 990| 1|#define BC0_P(name, func) do {\ | | 991| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 992| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 993| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 994| 1| ONIG_CALLOUT_IN_PROGRESS,\ | | 995| 1| onig_builtin_ ## func, 0, 0, 0, 0, 0);\ | | 996| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (996:7): [True: 0, False: 1] | | ------------------ | | 997| 1|} while(0) | | ------------------ | | | Branch (997:9): [Folded, False: 1] | | ------------------ ------------------ 47| 1|#ifdef USE_SKIP_SEARCH 48| 1| name = "SKIP"; BC0_P(name, skip); ------------------ | | 990| 1|#define BC0_P(name, func) do {\ | | 991| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 992| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 993| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 994| 1| ONIG_CALLOUT_IN_PROGRESS,\ | | 995| 1| onig_builtin_ ## func, 0, 0, 0, 0, 0);\ | | 996| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (996:7): [True: 0, False: 1] | | ------------------ | | 997| 1|} while(0) | | ------------------ | | | Branch (997:9): [Folded, False: 1] | | ------------------ ------------------ 49| 1|#endif 50| | 51| 1| name = "MAX"; 52| 1| args[0] = ONIG_TYPE_TAG | ONIG_TYPE_LONG; 53| 1| args[1] = ONIG_TYPE_CHAR; 54| 1| opts[0].c = 'X'; 55| 1| BC_B_O(name, max, 2, args, 1, opts); ------------------ | | 1044| 1|#define BC_B_O(name, func, nts, ts, nopts, opts) do {\ | | 1045| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 1046| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 1047| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 1048| 1| ONIG_CALLOUT_IN_BOTH,\ | | ------------------ | | | | 745| 1|#define ONIG_CALLOUT_IN_BOTH (ONIG_CALLOUT_IN_PROGRESS | ONIG_CALLOUT_IN_RETRACTION) | | ------------------ | | 1049| 1| onig_builtin_ ## func, 0, (nts), (ts), (nopts), (opts));\ | | 1050| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (1050:7): [True: 0, False: 1] | | ------------------ | | 1051| 1|} while(0) | | ------------------ | | | Branch (1051:9): [Folded, False: 1] | | ------------------ ------------------ 56| | 57| 1| name = "ERROR"; 58| 1| args[0] = ONIG_TYPE_LONG; opts[0].l = ONIG_ABORT; ------------------ | | 567| 1|#define ONIG_ABORT -3 ------------------ 59| 1| BC_P_O(name, error, 1, args, 1, opts); ------------------ | | 1026| 1|#define BC_P_O(name, func, nts, ts, nopts, opts) do {\ | | 1027| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 1028| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 1029| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 1030| 1| ONIG_CALLOUT_IN_PROGRESS,\ | | 1031| 1| onig_builtin_ ## func, 0, (nts), (ts), (nopts), (opts));\ | | 1032| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (1032:7): [True: 0, False: 1] | | ------------------ | | 1033| 1|} while(0) | | ------------------ | | | Branch (1033:9): [Folded, False: 1] | | ------------------ ------------------ 60| | 61| 1| name = "COUNT"; 62| 1| args[0] = ONIG_TYPE_CHAR; opts[0].c = '>'; 63| 1| BC_B_O(name, count, 1, args, 1, opts); ------------------ | | 1044| 1|#define BC_B_O(name, func, nts, ts, nopts, opts) do {\ | | 1045| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 1046| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 1047| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 1048| 1| ONIG_CALLOUT_IN_BOTH,\ | | ------------------ | | | | 745| 1|#define ONIG_CALLOUT_IN_BOTH (ONIG_CALLOUT_IN_PROGRESS | ONIG_CALLOUT_IN_RETRACTION) | | ------------------ | | 1049| 1| onig_builtin_ ## func, 0, (nts), (ts), (nopts), (opts));\ | | 1050| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (1050:7): [True: 0, False: 1] | | ------------------ | | 1051| 1|} while(0) | | ------------------ | | | Branch (1051:9): [Folded, False: 1] | | ------------------ ------------------ 64| | 65| 1| name = "TOTAL_COUNT"; 66| 1| args[0] = ONIG_TYPE_CHAR; opts[0].c = '>'; 67| 1| BC_B_O(name, total_count, 1, args, 1, opts); ------------------ | | 1044| 1|#define BC_B_O(name, func, nts, ts, nopts, opts) do {\ | | 1045| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 1046| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 1047| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 1048| 1| ONIG_CALLOUT_IN_BOTH,\ | | ------------------ | | | | 745| 1|#define ONIG_CALLOUT_IN_BOTH (ONIG_CALLOUT_IN_PROGRESS | ONIG_CALLOUT_IN_RETRACTION) | | ------------------ | | 1049| 1| onig_builtin_ ## func, 0, (nts), (ts), (nopts), (opts));\ | | 1050| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (1050:7): [True: 0, False: 1] | | ------------------ | | 1051| 1|} while(0) | | ------------------ | | | Branch (1051:9): [Folded, False: 1] | | ------------------ ------------------ 68| | 69| 1| name = "CMP"; 70| 1| args[0] = ONIG_TYPE_TAG | ONIG_TYPE_LONG; 71| 1| args[1] = ONIG_TYPE_STRING; 72| 1| args[2] = ONIG_TYPE_TAG | ONIG_TYPE_LONG; 73| 1| BC_P(name, cmp, 3, args); ------------------ | | 1017| 1|#define BC_P(name, func, na, ts) do {\ | | 1018| 1| int len = onigenc_str_bytelen_null(enc, (UChar* )name);\ | | 1019| 1| id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE,\ | | 1020| 1| (UChar* )(name), (UChar* )((name) + len),\ | | 1021| 1| ONIG_CALLOUT_IN_PROGRESS,\ | | 1022| 1| onig_builtin_ ## func, 0, (na), (ts), 0, 0); \ | | 1023| 1| if (id < 0) return id;\ | | ------------------ | | | Branch (1023:7): [True: 0, False: 1] | | ------------------ | | 1024| 1|} while(0) | | ------------------ | | | Branch (1024:9): [Folded, False: 1] | | ------------------ ------------------ 74| | 75| 1|#endif /* USE_CALLOUT */ 76| | 77| 1| return ONIG_NORMAL; ------------------ | | 563| 1|#define ONIG_NORMAL 0 ------------------ 78| 1|} onig_positive_int_multiply: 346| 56|{ 347| 56| if (x == 0 || y == 0) return 0; ------------------ | Branch (347:7): [True: 0, False: 56] | Branch (347:17): [True: 0, False: 56] ------------------ 348| | 349| 56| if (x < ONIG_INT_MAX / y) ------------------ | | 214| 56|#define ONIG_INT_MAX INT_MAX ------------------ | Branch (349:7): [True: 56, False: 0] ------------------ 350| 56| return x * y; 351| 0| else 352| 0| return -1; 353| 56|} onig_free_body: 7347| 46.9k|{ 7348| 46.9k| if (IS_NOT_NULL(reg)) { ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 46.9k, False: 0] | | ------------------ ------------------ 7349| 46.9k| ops_free(reg); 7350| 46.9k| if (IS_NOT_NULL(reg->string_pool)) { ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ 7351| 0| xfree(reg->string_pool); ------------------ | | 230| 0|#define xfree free ------------------ 7352| 0| reg->string_pool_end = reg->string_pool = 0; 7353| 0| } 7354| 46.9k| if (IS_NOT_NULL(reg->exact)) xfree(reg->exact); ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.0k, False: 2.89k] | | ------------------ ------------------ if (IS_NOT_NULL(reg->exact)) xfree(reg->exact); ------------------ | | 230| 44.0k|#define xfree free ------------------ 7355| 46.9k| if (IS_NOT_NULL(reg->repeat_range)) xfree(reg->repeat_range); ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ if (IS_NOT_NULL(reg->repeat_range)) xfree(reg->repeat_range); ------------------ | | 230| 0|#define xfree free ------------------ 7356| 46.9k| if (IS_NOT_NULL(reg->extp)) { ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ 7357| 0| free_regex_ext(reg->extp); 7358| 0| reg->extp = 0; 7359| 0| } 7360| | 7361| 46.9k| onig_names_free(reg); 7362| 46.9k| } 7363| 46.9k|} onig_free: 7367| 46.9k|{ 7368| 46.9k| if (IS_NOT_NULL(reg)) { ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 46.9k, False: 0] | | ------------------ ------------------ 7369| 46.9k| onig_free_body(reg); 7370| 46.9k| xfree(reg); ------------------ | | 230| 46.9k|#define xfree free ------------------ 7371| 46.9k| } 7372| 46.9k|} onig_compile: 7495| 46.9k|{ 7496| 46.9k| int r; 7497| 46.9k| Node* root; 7498| 46.9k| ParseEnv scan_env; 7499| 46.9k|#ifdef USE_CALL 7500| 46.9k| UnsetAddrList uslist = {0}; 7501| 46.9k|#endif 7502| | 7503| |#if defined(ONIG_DEBUG_PARSE) || defined(ONIG_DEBUG_MATCH) || \ 7504| | defined(ONIG_DEBUG_SEARCH) || defined(ONIG_DEBUG_COMPILE) 7505| | fprintf(DBGFP, "\nPATTERN: /"); 7506| | print_enc_string(DBGFP, reg->enc, pattern, pattern_end); 7507| | fprintf(DBGFP, "/\n"); 7508| | fprintf(DBGFP, "OPTIONS:"); 7509| | print_options(DBGFP, reg->options); 7510| | fprintf(DBGFP, "\n"); 7511| |#endif 7512| | 7513| 46.9k| if (reg->ops_alloc == 0) { ------------------ | Branch (7513:7): [True: 46.9k, False: 0] ------------------ 7514| 46.9k| r = ops_init(reg, OPS_INIT_SIZE); ------------------ | | 32| 46.9k|#define OPS_INIT_SIZE 8 ------------------ 7515| 46.9k| if (r != 0) { ------------------ | Branch (7515:9): [True: 0, False: 46.9k] ------------------ 7516| 0| if (IS_NOT_NULL(einfo)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7517| 0| einfo->enc = reg->enc; 7518| 0| einfo->par = (UChar* )NULL; 7519| 0| } 7520| 0| return r; 7521| 0| } 7522| 46.9k| } 7523| 0| else 7524| 0| reg->ops_used = 0; 7525| | 7526| 46.9k| r = parse_and_tune(reg, pattern, pattern_end, &scan_env, &root, einfo 7527| 46.9k|#ifdef USE_CALL 7528| 46.9k| , &uslist 7529| 46.9k|#endif 7530| 46.9k| ); 7531| 46.9k| if (r != 0) return r; ------------------ | Branch (7531:7): [True: 0, False: 46.9k] ------------------ 7532| | 7533| |#ifdef ONIG_DEBUG_PARSE 7534| | fprintf(DBGFP, "TREE (after tune)\n"); 7535| | print_tree(DBGFP, root); 7536| | fprintf(DBGFP, "\n"); 7537| |#endif 7538| | 7539| 46.9k| reg->capture_history = scan_env.cap_history; 7540| 46.9k| reg->push_mem_start = scan_env.backtrack_mem | scan_env.cap_history; 7541| | 7542| 46.9k|#ifdef USE_CALLOUT 7543| 46.9k| if (IS_NOT_NULL(reg->extp) && reg->extp->callout_num != 0) { ------------------ | | 202| 93.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ | Branch (7543:33): [True: 0, False: 0] ------------------ 7544| 0| reg->push_mem_end = reg->push_mem_start; 7545| 0| } 7546| 46.9k| else { 7547| 46.9k| if (MEM_STATUS_IS_ALL_ON(reg->push_mem_start)) ------------------ | | 369| 46.9k|#define MEM_STATUS_IS_ALL_ON(stats) (((stats) & 1) != 0) | | ------------------ | | | Branch (369:38): [True: 0, False: 46.9k] | | ------------------ ------------------ 7548| 0| reg->push_mem_end = scan_env.backrefed_mem | scan_env.cap_history; 7549| 46.9k| else 7550| 46.9k| reg->push_mem_end = reg->push_mem_start & 7551| 46.9k| (scan_env.backrefed_mem | scan_env.cap_history); 7552| 46.9k| } 7553| |#else 7554| | if (MEM_STATUS_IS_ALL_ON(reg->push_mem_start)) 7555| | reg->push_mem_end = scan_env.backrefed_mem | scan_env.cap_history; 7556| | else 7557| | reg->push_mem_end = reg->push_mem_start & 7558| | (scan_env.backrefed_mem | scan_env.cap_history); 7559| |#endif 7560| | 7561| 46.9k| clear_optimize_info(reg); 7562| 46.9k|#ifndef ONIG_DONT_OPTIMIZE 7563| 46.9k| r = set_optimize_info_from_tree(root, reg, &scan_env); 7564| 46.9k| if (r != 0) { ------------------ | Branch (7564:7): [True: 0, False: 46.9k] ------------------ 7565| 0|#ifdef USE_CALL 7566| 0| if (scan_env.num_call > 0) { ------------------ | Branch (7566:9): [True: 0, False: 0] ------------------ 7567| 0| unset_addr_list_end(&uslist); 7568| 0| } 7569| 0|#endif 7570| 0| goto err; 7571| 0| } 7572| 46.9k|#endif 7573| | 7574| 46.9k| if (IS_NOT_NULL(scan_env.mem_env_dynamic)) { ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ 7575| 0| xfree(scan_env.mem_env_dynamic); ------------------ | | 230| 0|#define xfree free ------------------ 7576| 0| scan_env.mem_env_dynamic = (MemEnv* )NULL; 7577| 0| } 7578| | 7579| 46.9k| r = compile_tree(root, reg, &scan_env); 7580| 46.9k| if (r == 0) { ------------------ | Branch (7580:7): [True: 46.9k, False: 0] ------------------ 7581| 46.9k| if (scan_env.keep_num > 0) { ------------------ | Branch (7581:9): [True: 0, False: 46.9k] ------------------ 7582| 0| r = add_op(reg, OP_UPDATE_VAR); 7583| 0| if (r != 0) goto err; ------------------ | Branch (7583:11): [True: 0, False: 0] ------------------ 7584| | 7585| 0| COP(reg)->update_var.type = UPDATE_VAR_KEEP_FROM_STACK_LAST; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 7586| 0| COP(reg)->update_var.id = 0; /* not used */ ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 7587| 0| COP(reg)->update_var.clear = FALSE; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->update_var.clear = FALSE; ------------------ | | 63| 0|#define FALSE 0 ------------------ 7588| 0| } 7589| | 7590| 46.9k| r = add_op(reg, OP_END); 7591| 46.9k| if (r != 0) goto err; ------------------ | Branch (7591:9): [True: 0, False: 46.9k] ------------------ 7592| | 7593| 46.9k|#ifdef USE_CALL 7594| 46.9k| if (scan_env.num_call > 0) { ------------------ | Branch (7594:9): [True: 0, False: 46.9k] ------------------ 7595| 0| r = fix_unset_addr_list(&uslist, reg); 7596| 0| unset_addr_list_end(&uslist); 7597| 0| if (r != 0) goto err; ------------------ | Branch (7597:11): [True: 0, False: 0] ------------------ 7598| 0| } 7599| 46.9k|#endif 7600| | 7601| 46.9k| r = ops_resize(reg, reg->ops_used); 7602| 46.9k| if (r != ONIG_NORMAL) goto err; ------------------ | | 563| 46.9k|#define ONIG_NORMAL 0 ------------------ | Branch (7602:9): [True: 0, False: 46.9k] ------------------ 7603| | 7604| 46.9k| set_addr_in_repeat_range(reg); 7605| | 7606| 46.9k| if ((reg->push_mem_end != 0) ------------------ | Branch (7606:9): [True: 0, False: 46.9k] ------------------ 7607| |#ifdef USE_REPEAT_AND_EMPTY_CHECK_LOCAL_VAR 7608| | || (reg->num_repeat != 0) 7609| | || (reg->num_empty_check != 0) 7610| |#endif 7611| 46.9k|#ifdef USE_CALLOUT 7612| 46.9k| || (IS_NOT_NULL(reg->extp) && reg->extp->callout_num != 0) ------------------ | | 202| 93.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ | Branch (7612:39): [True: 0, False: 0] ------------------ 7613| 46.9k|#endif 7614| 46.9k|#ifdef USE_CALL 7615| 46.9k| || scan_env.num_call > 0 ------------------ | Branch (7615:12): [True: 0, False: 46.9k] ------------------ 7616| 46.9k|#endif 7617| 46.9k| ) 7618| 0| reg->stack_pop_level = STACK_POP_LEVEL_ALL; 7619| 46.9k| else { 7620| 46.9k| if (reg->push_mem_start != 0) ------------------ | Branch (7620:11): [True: 104, False: 46.8k] ------------------ 7621| 104| reg->stack_pop_level = STACK_POP_LEVEL_MEM_START; 7622| 46.8k| else 7623| 46.8k| reg->stack_pop_level = STACK_POP_LEVEL_FREE; 7624| 46.9k| } 7625| | 7626| 46.9k| r = ops_make_string_pool(reg); 7627| 46.9k| if (r != 0) goto err; ------------------ | Branch (7627:9): [True: 0, False: 46.9k] ------------------ 7628| 46.9k| } 7629| 0|#ifdef USE_CALL 7630| 0| else if (scan_env.num_call > 0) { ------------------ | Branch (7630:12): [True: 0, False: 0] ------------------ 7631| 0| unset_addr_list_end(&uslist); 7632| 0| } 7633| 46.9k|#endif 7634| 46.9k| onig_node_free(root); 7635| | 7636| |#ifdef ONIG_DEBUG_COMPILE 7637| | onig_print_names(DBGFP, reg); 7638| | onig_print_compiled_byte_code_list(DBGFP, reg); 7639| |#endif 7640| | 7641| 46.9k|#ifdef USE_DIRECT_THREADED_CODE 7642| | /* opcode -> opaddr */ 7643| 46.9k| onig_init_for_match_at(reg); 7644| 46.9k|#endif 7645| | 7646| 46.9k| return r; 7647| | 7648| 0| err: 7649| 0| if (IS_NOT_NULL(scan_env.error)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7650| 0| if (IS_NOT_NULL(einfo)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7651| 0| einfo->par = scan_env.error; 7652| 0| einfo->par_end = scan_env.error_end; 7653| 0| } 7654| 0| } 7655| | 7656| 0| onig_node_free(root); 7657| 0| if (IS_NOT_NULL(scan_env.mem_env_dynamic)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7658| 0| xfree(scan_env.mem_env_dynamic); ------------------ | | 230| 0|#define xfree free ------------------ 7659| 0| return r; 7660| 46.9k|} onig_reg_init: 7668| 46.9k|{ 7669| 46.9k| int r; 7670| | 7671| 46.9k| xmemset(reg, 0, sizeof(*reg)); ------------------ | | 177| 46.9k|#define xmemset memset ------------------ 7672| | 7673| 46.9k| if (onig_inited == 0) { ------------------ | Branch (7673:7): [True: 1, False: 46.9k] ------------------ 7674| |#if 0 7675| | return ONIGERR_LIBRARY_IS_NOT_INITIALIZED; 7676| |#else 7677| 1| r = onig_initialize(&enc, 1); 7678| 1| if (r != 0) ------------------ | Branch (7678:9): [True: 0, False: 1] ------------------ 7679| 0| return ONIGERR_FAIL_TO_INITIALIZE; ------------------ | | 584| 0|#define ONIGERR_FAIL_TO_INITIALIZE -23 ------------------ 7680| | 7681| 1| onig_warning("You didn't call onig_initialize() explicitly"); 7682| 1|#endif 7683| 1| } 7684| | 7685| 46.9k| if (IS_NULL(reg)) ------------------ | | 201| 46.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 46.9k] | | ------------------ ------------------ 7686| 0| return ONIGERR_INVALID_ARGUMENT; ------------------ | | 586| 0|#define ONIGERR_INVALID_ARGUMENT -30 ------------------ 7687| | 7688| 46.9k| if (ONIGENC_IS_UNDEF(enc)) ------------------ | | 253| 46.9k|#define ONIGENC_IS_UNDEF(enc) ((enc) == ONIG_ENCODING_UNDEF) | | ------------------ | | | | 221| 46.9k|#define ONIG_ENCODING_UNDEF ((OnigEncoding )0) | | ------------------ | | | Branch (253:40): [True: 0, False: 46.9k] | | ------------------ ------------------ 7689| 0| return ONIGERR_DEFAULT_ENCODING_IS_NOT_SET; ------------------ | | 582| 0|#define ONIGERR_DEFAULT_ENCODING_IS_NOT_SET -21 ------------------ 7690| | 7691| 46.9k| if ((option & (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) ------------------ | | 384| 46.9k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | ------------------ | | | | 383| 46.9k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | ------------------ | | | | | | 382| 46.9k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | ------------------ | | | | | | | | 381| 46.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 380| 46.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 379| 46.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 378| 46.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 377| 46.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((option & (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) ------------------ | | 385| 46.9k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | ------------------ | | | | 384| 46.9k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | ------------------ | | | | | | 383| 46.9k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | ------------------ | | | | | | | | 382| 46.9k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | ------------------ | | | | | | | | | | 381| 46.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 380| 46.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 379| 46.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 378| 46.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 377| 46.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7691:7): [True: 0, False: 46.9k] ------------------ 7692| 46.9k| == (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) { ------------------ | | 384| 46.9k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | ------------------ | | | | 383| 46.9k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | ------------------ | | | | | | 382| 46.9k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | ------------------ | | | | | | | | 381| 46.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 380| 46.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 379| 46.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 378| 46.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 377| 46.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ == (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) { ------------------ | | 385| 46.9k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | ------------------ | | | | 384| 46.9k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | ------------------ | | | | | | 383| 46.9k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | ------------------ | | | | | | | | 382| 46.9k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | ------------------ | | | | | | | | | | 381| 46.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 380| 46.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 379| 46.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 378| 46.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 377| 46.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7693| 0| return ONIGERR_INVALID_COMBINATION_OF_OPTIONS; ------------------ | | 648| 0|#define ONIGERR_INVALID_COMBINATION_OF_OPTIONS -403 ------------------ 7694| 0| } 7695| | 7696| 46.9k| if ((option & ONIG_OPTION_NEGATE_SINGLELINE) != 0) { ------------------ | | 383| 46.9k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | ------------------ | | | | 382| 46.9k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 381| 46.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 380| 46.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 379| 46.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 378| 46.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 377| 46.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7696:7): [True: 0, False: 46.9k] ------------------ 7697| 0| option |= syntax->options; 7698| 0| option &= ~ONIG_OPTION_SINGLELINE; ------------------ | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | ------------------ | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7699| 0| } 7700| 46.9k| else 7701| 46.9k| option |= syntax->options; 7702| | 7703| 46.9k| if ((option & ONIG_OPTION_IGNORECASE_IS_ASCII) != 0) { ------------------ | | 392| 46.9k|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | ------------------ | | | | 390| 46.9k|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | ------------------ | | | | | | 389| 46.9k|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | ------------------ | | | | | | | | 388| 46.9k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 387| 46.9k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 385| 46.9k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 384| 46.9k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 383| 46.9k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 382| 46.9k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 381| 46.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 380| 46.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 379| 46.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 46.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 46.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7703:7): [True: 0, False: 46.9k] ------------------ 7704| 0| case_fold_flag &= ~(INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR | ------------------ | | 98| 0|#define INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR (1<<30) ------------------ 7705| 0| ONIGENC_CASE_FOLD_TURKISH_AZERI); ------------------ | | 97| 0|#define ONIGENC_CASE_FOLD_TURKISH_AZERI (1<<20) ------------------ 7706| 0| case_fold_flag |= ONIGENC_CASE_FOLD_ASCII_ONLY; ------------------ | | 94| 0|#define ONIGENC_CASE_FOLD_ASCII_ONLY (1) ------------------ 7707| 0| } 7708| | 7709| 46.9k| (reg)->enc = enc; 7710| 46.9k| (reg)->options = option; 7711| 46.9k| (reg)->syntax = syntax; 7712| 46.9k| (reg)->optimize = 0; 7713| 46.9k| (reg)->exact = (UChar* )NULL; 7714| 46.9k| (reg)->extp = (RegexExt* )NULL; 7715| 46.9k| (reg)->ops = (Operation* )NULL; 7716| 46.9k| (reg)->ops_curr = (Operation* )NULL; 7717| 46.9k| (reg)->ops_used = 0; 7718| 46.9k| (reg)->ops_alloc = 0; 7719| | (reg)->name_table = (void* )NULL; 7720| 46.9k| (reg)->case_fold_flag = case_fold_flag; 7721| 46.9k| return 0; 7722| 46.9k|} onig_new: 7743| 46.9k|{ 7744| 46.9k| int r; 7745| | 7746| 46.9k| *reg = (regex_t* )xmalloc(sizeof(regex_t)); ------------------ | | 227| 46.9k|#define xmalloc malloc ------------------ 7747| 46.9k| if (IS_NULL(*reg)) return ONIGERR_MEMORY; ------------------ | | 201| 46.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 46.9k] | | ------------------ ------------------ if (IS_NULL(*reg)) return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 7748| | 7749| 46.9k| r = onig_reg_init(*reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax); ------------------ | | 101| 46.9k|#define ONIGENC_CASE_FOLD_DEFAULT OnigDefaultCaseFoldFlag ------------------ 7750| 46.9k| if (r != 0) { ------------------ | Branch (7750:7): [True: 0, False: 46.9k] ------------------ 7751| 0| xfree(*reg); ------------------ | | 230| 0|#define xfree free ------------------ 7752| 0| *reg = NULL; 7753| 0| return r; 7754| 0| } 7755| | 7756| 46.9k| r = onig_compile(*reg, pattern, pattern_end, einfo); 7757| 46.9k| if (r != 0) { ------------------ | Branch (7757:7): [True: 0, False: 46.9k] ------------------ 7758| 0| onig_free(*reg); 7759| | *reg = NULL; 7760| 0| } 7761| 46.9k| return r; 7762| 46.9k|} onig_initialize: 7766| 1|{ 7767| 1| int i; 7768| 1| int r; 7769| | 7770| 1| if (onig_inited != 0) ------------------ | Branch (7770:7): [True: 0, False: 1] ------------------ 7771| 0| return 0; 7772| | 7773| 1| onigenc_init(); 7774| | 7775| 1| onig_inited = 1; 7776| | 7777| 2| for (i = 0; i < n; i++) { ------------------ | Branch (7777:15): [True: 1, False: 1] ------------------ 7778| 1| OnigEncoding enc = encodings[i]; 7779| 1| r = onig_initialize_encoding(enc); 7780| 1| if (r != 0) ------------------ | Branch (7780:9): [True: 0, False: 1] ------------------ 7781| 0| return r; 7782| 1| } 7783| | 7784| 1| return ONIG_NORMAL; ------------------ | | 563| 1|#define ONIG_NORMAL 0 ------------------ 7785| 1|} onig_is_code_in_cc_len: 7862| 49|{ 7863| 49| int found; 7864| 49| CClassNode* cc = (CClassNode* )cc_arg; 7865| | 7866| 49| if (elen > 1 || (code >= SINGLE_BYTE_SIZE)) { ------------------ | | 432| 49|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 49|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (7866:7): [True: 0, False: 49] | Branch (7866:19): [True: 0, False: 49] ------------------ 7867| 0| if (IS_NULL(cc->mbuf)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 7868| 0| found = 0; 7869| 0| } 7870| 0| else { 7871| 0| found = onig_is_in_code_range(cc->mbuf->p, code) != 0; 7872| 0| } 7873| 0| } 7874| 49| else { 7875| 49| found = BITSET_AT(cc->bs, code) != 0; ------------------ | | 450| 49|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 49|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 49|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ 7876| 49| } 7877| | 7878| 49| if (IS_NCCLASS_NOT(cc)) ------------------ | | 736| 49|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 49|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 49|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 0, False: 49] | | | | ------------------ | | ------------------ ------------------ 7879| 0| return !found; 7880| 49| else 7881| 49| return found; 7882| 49|} onig_is_code_in_cc: 7886| 49|{ 7887| 49| int len; 7888| | 7889| 49| if (ONIGENC_MBC_MINLEN(enc) > 1) { ------------------ | | 282| 49|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (7889:7): [True: 0, False: 49] ------------------ 7890| 0| len = 2; 7891| 0| } 7892| 49| else { 7893| 49| len = ONIGENC_CODE_TO_MBCLEN(enc, code); ------------------ | | 285| 49|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code) ------------------ 7894| 49| if (len < 0) return 0; ------------------ | Branch (7894:9): [True: 0, False: 49] ------------------ 7895| 49| } 7896| 49| return onig_is_code_in_cc_len(len, code, cc); 7897| 49|} regcomp.c:ops_free: 138| 46.9k|{ 139| 46.9k| int i; 140| | 141| 46.9k| if (IS_NULL(reg->ops)) return ; ------------------ | | 201| 46.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 46.9k] | | ------------------ ------------------ 142| | 143| 286k| for (i = 0; i < (int )reg->ops_used; i++) { ------------------ | Branch (143:15): [True: 239k, False: 46.9k] ------------------ 144| 239k| enum OpCode opcode; 145| 239k| Operation* op; 146| | 147| 239k| op = reg->ops + i; 148| | 149| 239k|#ifdef USE_DIRECT_THREADED_CODE 150| 239k| opcode = *(reg->ocs + i); 151| |#else 152| | opcode = op->opcode; 153| |#endif 154| | 155| 239k| switch (opcode) { 156| 0| case OP_STR_MBN: ------------------ | Branch (156:5): [True: 0, False: 239k] ------------------ 157| 0| if (! is_in_string_pool(reg, op->exact_len_n.s)) ------------------ | Branch (157:11): [True: 0, False: 0] ------------------ 158| 0| xfree(op->exact_len_n.s); ------------------ | | 230| 0|#define xfree free ------------------ 159| 0| break; 160| 0| case OP_STR_N: case OP_STR_MB2N: case OP_STR_MB3N: ------------------ | Branch (160:5): [True: 0, False: 239k] | Branch (160:20): [True: 0, False: 239k] | Branch (160:38): [True: 0, False: 239k] ------------------ 161| 0| if (! is_in_string_pool(reg, op->exact_n.s)) ------------------ | Branch (161:11): [True: 0, False: 0] ------------------ 162| 0| xfree(op->exact_n.s); ------------------ | | 230| 0|#define xfree free ------------------ 163| 0| break; 164| 89.7k| case OP_STR_1: case OP_STR_2: case OP_STR_3: case OP_STR_4: ------------------ | Branch (164:5): [True: 89.5k, False: 150k] | Branch (164:20): [True: 228, False: 239k] | Branch (164:35): [True: 19, False: 239k] | Branch (164:50): [True: 0, False: 239k] ------------------ 165| 89.7k| case OP_STR_5: case OP_STR_MB2N1: case OP_STR_MB2N2: ------------------ | Branch (165:5): [True: 0, False: 239k] | Branch (165:20): [True: 19, False: 239k] | Branch (165:39): [True: 0, False: 239k] ------------------ 166| 89.7k| case OP_STR_MB2N3: ------------------ | Branch (166:5): [True: 0, False: 239k] ------------------ 167| 89.7k| break; 168| | 169| 5.39k| case OP_CCLASS_NOT: case OP_CCLASS: ------------------ | Branch (169:5): [True: 106, False: 239k] | Branch (169:25): [True: 5.28k, False: 234k] ------------------ 170| 5.39k| xfree(op->cclass.bsp); ------------------ | | 230| 5.39k|#define xfree free ------------------ 171| 5.39k| break; 172| | 173| 0| case OP_CCLASS_MB_NOT: case OP_CCLASS_MB: ------------------ | Branch (173:5): [True: 0, False: 239k] | Branch (173:28): [True: 0, False: 239k] ------------------ 174| 0| xfree(op->cclass_mb.mb); ------------------ | | 230| 0|#define xfree free ------------------ 175| 0| break; 176| 0| case OP_CCLASS_MIX_NOT: case OP_CCLASS_MIX: ------------------ | Branch (176:5): [True: 0, False: 239k] | Branch (176:29): [True: 0, False: 239k] ------------------ 177| 0| xfree(op->cclass_mix.mb); ------------------ | | 230| 0|#define xfree free ------------------ 178| 0| xfree(op->cclass_mix.bsp); ------------------ | | 230| 0|#define xfree free ------------------ 179| 0| break; 180| | 181| 0| case OP_BACKREF1: case OP_BACKREF2: case OP_BACKREF_N: case OP_BACKREF_N_IC: ------------------ | Branch (181:5): [True: 0, False: 239k] | Branch (181:23): [True: 0, False: 239k] | Branch (181:41): [True: 0, False: 239k] | Branch (181:60): [True: 0, False: 239k] ------------------ 182| 0| break; 183| 0| case OP_BACKREF_MULTI: case OP_BACKREF_MULTI_IC: ------------------ | Branch (183:5): [True: 0, False: 239k] | Branch (183:33): [True: 0, False: 239k] ------------------ 184| 0| case OP_BACKREF_CHECK: ------------------ | Branch (184:5): [True: 0, False: 239k] ------------------ 185| 0|#ifdef USE_BACKREF_WITH_LEVEL 186| 0| case OP_BACKREF_WITH_LEVEL: ------------------ | Branch (186:5): [True: 0, False: 239k] ------------------ 187| 0| case OP_BACKREF_WITH_LEVEL_IC: ------------------ | Branch (187:5): [True: 0, False: 239k] ------------------ 188| 0| case OP_BACKREF_CHECK_WITH_LEVEL: ------------------ | Branch (188:5): [True: 0, False: 239k] ------------------ 189| 0|#endif 190| 0| if (op->backref_general.num != 1) ------------------ | Branch (190:11): [True: 0, False: 0] ------------------ 191| 0| xfree(op->backref_general.ns); ------------------ | | 230| 0|#define xfree free ------------------ 192| 0| break; 193| | 194| 144k| default: ------------------ | Branch (194:5): [True: 144k, False: 95.1k] ------------------ 195| 144k| break; 196| 239k| } 197| 239k| } 198| | 199| 46.9k| xfree(reg->ops); ------------------ | | 230| 46.9k|#define xfree free ------------------ 200| 46.9k|#ifdef USE_DIRECT_THREADED_CODE 201| 46.9k| xfree(reg->ocs); ------------------ | | 230| 46.9k|#define xfree free ------------------ 202| 46.9k| reg->ocs = 0; 203| 46.9k|#endif 204| | 205| 46.9k| reg->ops = 0; 206| 46.9k| reg->ops_curr = 0; 207| 46.9k| reg->ops_alloc = 0; 208| 46.9k| reg->ops_used = 0; 209| 46.9k|} regcomp.c:ops_init: 54| 46.9k|{ 55| 46.9k| Operation* p; 56| 46.9k| size_t size; 57| | 58| 46.9k| if (init_alloc_size <= 0) ------------------ | Branch (58:7): [True: 0, False: 46.9k] ------------------ 59| 0| return ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 60| | 61| 46.9k| size = sizeof(Operation) * init_alloc_size; 62| 46.9k| p = (Operation* )xrealloc(reg->ops, size); ------------------ | | 228| 46.9k|#define xrealloc realloc ------------------ 63| 46.9k| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 46.9k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 46.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 46.9k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 64| 46.9k| reg->ops = p; 65| 46.9k|#ifdef USE_DIRECT_THREADED_CODE 66| 46.9k| { 67| 46.9k| enum OpCode* cp; 68| 46.9k| size = sizeof(enum OpCode) * init_alloc_size; 69| 46.9k| cp = (enum OpCode* )xrealloc(reg->ocs, size); ------------------ | | 228| 46.9k|#define xrealloc realloc ------------------ 70| 46.9k| CHECK_NULL_RETURN_MEMERR(cp); ------------------ | | 204| 46.9k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 46.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 46.9k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 71| 46.9k| reg->ocs = cp; 72| 46.9k| } 73| 0|#endif 74| | 75| 0| reg->ops_curr = 0; /* !!! not yet done ops_new() */ 76| 46.9k| reg->ops_alloc = init_alloc_size; 77| 46.9k| reg->ops_used = 0; 78| | 79| 46.9k| return ONIG_NORMAL; ------------------ | | 563| 46.9k|#define ONIG_NORMAL 0 ------------------ 80| 46.9k|} regcomp.c:parse_and_tune: 7388| 46.9k|{ 7389| 46.9k| int r; 7390| 46.9k| Node* root; 7391| | 7392| 46.9k| root = NULL_NODE; ------------------ | | 266| 46.9k|#define NULL_NODE ((Node* )0) ------------------ 7393| 46.9k| if (IS_NOT_NULL(einfo)) { ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 46.9k, False: 0] | | ------------------ ------------------ 7394| 46.9k| einfo->enc = reg->enc; 7395| 46.9k| einfo->par = (UChar* )NULL; 7396| 46.9k| } 7397| | 7398| 46.9k| r = onig_parse_tree(&root, pattern, pattern_end, reg, scan_env); 7399| 46.9k| if (r != 0) goto err; ------------------ | Branch (7399:7): [True: 0, False: 46.9k] ------------------ 7400| | 7401| 46.9k|#ifdef USE_WHOLE_OPTIONS 7402| 46.9k| if ((scan_env->flags & PE_FLAG_HAS_WHOLE_OPTIONS) != 0) { ------------------ | | 458| 46.9k|#define PE_FLAG_HAS_WHOLE_OPTIONS (1<<1) ------------------ | Branch (7402:7): [True: 0, False: 46.9k] ------------------ 7403| 0| r = check_whole_options_position(root, scan_env); 7404| 0| if (r != 0) goto err; ------------------ | Branch (7404:9): [True: 0, False: 0] ------------------ 7405| 0| } 7406| 46.9k|#endif 7407| | 7408| 46.9k| r = reduce_string_list(root, reg->enc); 7409| 46.9k| if (r != 0) goto err; ------------------ | Branch (7409:7): [True: 0, False: 46.9k] ------------------ 7410| | 7411| | /* mixed use named group and no-named group */ 7412| 46.9k| if (scan_env->num_named > 0 && ------------------ | Branch (7412:7): [True: 503, False: 46.4k] ------------------ 7413| 503| IS_SYNTAX_BV(scan_env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) && ------------------ | | 407| 47.4k|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 503, False: 0] | | ------------------ ------------------ 7414| 503| ! OPTON_CAPTURE_GROUP(reg->options)) { ------------------ | | 415| 503|#define OPTON_CAPTURE_GROUP(option) ((option) & ONIG_OPTION_CAPTURE_GROUP) | | ------------------ | | | | 385| 503|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | ------------------ | | | | | | 384| 503|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 383| 503|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | ------------------ | | | | | | | | | | 382| 503|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 381| 503|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 380| 503|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 379| 503|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 378| 503|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 377| 503|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (7414:7): [True: 0, False: 503] ------------------ 7415| 0| if (scan_env->num_named != scan_env->num_mem) ------------------ | Branch (7415:9): [True: 0, False: 0] ------------------ 7416| 0| r = disable_noname_group_capture(&root, reg, scan_env); 7417| 0| else 7418| 0| r = numbered_ref_check(root); 7419| | 7420| 0| if (r != 0) goto err; ------------------ | Branch (7420:9): [True: 0, False: 0] ------------------ 7421| 0| } 7422| | 7423| 46.9k| r = check_backrefs(root, scan_env); 7424| 46.9k| if (r != 0) goto err; ------------------ | Branch (7424:7): [True: 0, False: 46.9k] ------------------ 7425| | 7426| 46.9k|#ifdef USE_CALL 7427| 46.9k| if (scan_env->num_call > 0) { ------------------ | Branch (7427:7): [True: 0, False: 46.9k] ------------------ 7428| 0| r = unset_addr_list_init(uslist, scan_env->num_call); 7429| 0| if (r != 0) goto err; ------------------ | Branch (7429:9): [True: 0, False: 0] ------------------ 7430| 0| scan_env->unset_addr_list = uslist; 7431| 0| r = tune_call(root, scan_env, 0); 7432| 0| if (r != 0) goto err_unset; ------------------ | Branch (7432:9): [True: 0, False: 0] ------------------ 7433| 0| r = tune_call2(root); 7434| 0| if (r != 0) goto err_unset; ------------------ | Branch (7434:9): [True: 0, False: 0] ------------------ 7435| 0| r = recursive_call_check_trav(root, scan_env, 0); 7436| 0| if (r < 0) goto err_unset; ------------------ | Branch (7436:9): [True: 0, False: 0] ------------------ 7437| 0| r = infinite_recursive_call_check_trav(root, scan_env); 7438| 0| if (r != 0) goto err_unset; ------------------ | Branch (7438:9): [True: 0, False: 0] ------------------ 7439| | 7440| 0| tune_called_state(root, 0); 7441| 0| } 7442| | 7443| 46.9k| reg->num_call = scan_env->num_call; 7444| 46.9k|#endif 7445| | 7446| |#ifdef ONIG_DEBUG_PARSE 7447| | fprintf(DBGFP, "MAX PARSE DEPTH: %d\n", scan_env->max_parse_depth); 7448| |#endif 7449| | 7450| 46.9k| r = tune_tree(root, reg, 0, scan_env); 7451| 46.9k| if (r != 0) { ------------------ | Branch (7451:7): [True: 0, False: 46.9k] ------------------ 7452| |#ifdef ONIG_DEBUG_PARSE 7453| | fprintf(DBGFP, "TREE (error in tune)\n"); 7454| | print_tree(DBGFP, root); 7455| | fprintf(DBGFP, "\n"); 7456| |#endif 7457| 0| goto err_unset; 7458| 0| } 7459| | 7460| 46.9k| if (scan_env->backref_num != 0) { ------------------ | Branch (7460:7): [True: 0, False: 46.9k] ------------------ 7461| 0| set_parent_node_trav(root, NULL_NODE); ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7462| 0| r = set_empty_repeat_node_trav(root, NULL_NODE, scan_env); ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7463| 0| if (r != 0) goto err_unset; ------------------ | Branch (7463:9): [True: 0, False: 0] ------------------ 7464| 0| set_empty_status_check_trav(root, scan_env); 7465| 0| } 7466| | 7467| 46.9k| *rroot = root; 7468| 46.9k| return r; 7469| | 7470| 0| err_unset: 7471| 0|#ifdef USE_CALL 7472| 0| if (scan_env->num_call > 0) { ------------------ | Branch (7472:7): [True: 0, False: 0] ------------------ 7473| 0| unset_addr_list_end(uslist); 7474| 0| } 7475| 0|#endif 7476| 0| err: 7477| 0| if (IS_NOT_NULL(scan_env->error)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7478| 0| if (IS_NOT_NULL(einfo)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7479| 0| einfo->par = scan_env->error; 7480| 0| einfo->par_end = scan_env->error_end; 7481| 0| } 7482| 0| } 7483| | 7484| 0| onig_node_free(root); 7485| 0| if (IS_NOT_NULL(scan_env->mem_env_dynamic)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7486| 0| xfree(scan_env->mem_env_dynamic); ------------------ | | 230| 0|#define xfree free ------------------ 7487| | 7488| 0| *rroot = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7489| 0| return r; 7490| 0|} regcomp.c:reduce_string_list: 4373| 141k|{ 4374| 141k| int r = 0; 4375| | 4376| 141k| switch (ND_TYPE(node)) { ------------------ | | 284| 141k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 4377| 44.0k| case ND_LIST: ------------------ | Branch (4377:3): [True: 44.0k, False: 97.4k] ------------------ 4378| 44.0k| { 4379| 44.0k| Node* prev; 4380| 44.0k| Node* curr; 4381| 44.0k| Node* prev_node; 4382| 44.0k| Node* next_node; 4383| | 4384| 44.0k| prev = NULL_NODE; ------------------ | | 266| 44.0k|#define NULL_NODE ((Node* )0) ------------------ 4385| 88.3k| do { 4386| 88.3k| next_node = ND_CDR(node); ------------------ | | 299| 88.3k|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 88.3k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 4387| 88.3k| curr = ND_CAR(node); ------------------ | | 298| 88.3k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 88.3k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 4388| 88.3k| if (ND_TYPE(curr) == ND_STRING) { ------------------ | | 284| 88.3k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (4388:13): [True: 40.9k, False: 47.3k] ------------------ 4389| 40.9k| if (IS_NULL(prev) ------------------ | | 201| 81.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 40.9k, False: 0] | | ------------------ ------------------ 4390| 0| || STR_(curr)->flag != STR_(prev)->flag ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ || STR_(curr)->flag != STR_(prev)->flag ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ | Branch (4390:18): [True: 0, False: 0] ------------------ 4391| 40.9k| || ND_STATUS(curr) != ND_STATUS(prev)) { ------------------ | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) ------------------ || ND_STATUS(curr) != ND_STATUS(prev)) { ------------------ | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) ------------------ | Branch (4391:18): [True: 0, False: 0] ------------------ 4392| 40.9k| prev = curr; 4393| 40.9k| prev_node = node; 4394| 40.9k| } 4395| 0| else { 4396| 0| r = node_str_node_cat(prev, curr); 4397| 0| if (r != 0) return r; ------------------ | Branch (4397:17): [True: 0, False: 0] ------------------ 4398| 0| remove_from_list(prev_node, node); 4399| 0| onig_node_free(node); 4400| 0| } 4401| 40.9k| } 4402| 47.3k| else { 4403| 47.3k| if (IS_NOT_NULL(prev)) { ------------------ | | 202| 47.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 40.7k, False: 6.62k] | | ------------------ ------------------ 4404| 40.7k|#ifdef USE_CHECK_VALIDITY_OF_STRING_IN_TREE 4405| 40.7k| StrNode* sn = STR_(prev); ------------------ | | 287| 40.7k|#define STR_(node) (&((node)->u.str)) ------------------ 4406| 40.7k| if (! ONIGENC_IS_VALID_MBC_STRING(enc, sn->s, sn->end)) ------------------ | | 271| 40.7k| (enc)->is_valid_mbc_string(s,end) ------------------ | Branch (4406:17): [True: 0, False: 40.7k] ------------------ 4407| 0| return ONIGERR_INVALID_WIDE_CHAR_VALUE; ------------------ | | 645| 0|#define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 ------------------ 4408| 40.7k|#endif 4409| 40.7k| prev = NULL_NODE; ------------------ | | 266| 40.7k|#define NULL_NODE ((Node* )0) ------------------ 4410| 40.7k| } 4411| 47.3k| r = reduce_string_list(curr, enc); 4412| 47.3k| if (r != 0) return r; ------------------ | Branch (4412:15): [True: 0, False: 47.3k] ------------------ 4413| 47.3k| prev_node = node; 4414| 47.3k| } 4415| | 4416| 88.3k| node = next_node; 4417| 88.3k| } while (r == 0 && IS_NOT_NULL(node)); ------------------ | | 202| 88.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.3k, False: 44.0k] | | ------------------ ------------------ | Branch (4417:16): [True: 88.3k, False: 0] ------------------ 4418| | 4419| 44.0k|#ifdef USE_CHECK_VALIDITY_OF_STRING_IN_TREE 4420| 44.0k| if (IS_NOT_NULL(prev)) { ------------------ | | 202| 44.0k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 213, False: 43.8k] | | ------------------ ------------------ 4421| 213| StrNode* sn = STR_(prev); ------------------ | | 287| 213|#define STR_(node) (&((node)->u.str)) ------------------ 4422| 213| if (! ONIGENC_IS_VALID_MBC_STRING(enc, sn->s, sn->end)) ------------------ | | 271| 213| (enc)->is_valid_mbc_string(s,end) ------------------ | Branch (4422:13): [True: 0, False: 213] ------------------ 4423| 0| return ONIGERR_INVALID_WIDE_CHAR_VALUE; ------------------ | | 645| 0|#define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 ------------------ 4424| 213| } 4425| 44.0k|#endif 4426| 44.0k| } 4427| 44.0k| break; 4428| | 4429| 44.0k| case ND_ALT: ------------------ | Branch (4429:3): [True: 0, False: 141k] ------------------ 4430| 0| do { 4431| 0| r = reduce_string_list(ND_CAR(node), enc); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 4432| 0| } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4432:14): [True: 0, False: 0] ------------------ 4433| 0| break; 4434| | 4435| 0|#ifdef USE_CHECK_VALIDITY_OF_STRING_IN_TREE 4436| 46.2k| case ND_STRING: ------------------ | Branch (4436:3): [True: 46.2k, False: 95.3k] ------------------ 4437| 46.2k| { 4438| 46.2k| StrNode* sn = STR_(node); ------------------ | | 287| 46.2k|#define STR_(node) (&((node)->u.str)) ------------------ 4439| 46.2k| if (! ONIGENC_IS_VALID_MBC_STRING(enc, sn->s, sn->end)) ------------------ | | 271| 46.2k| (enc)->is_valid_mbc_string(s,end) ------------------ | Branch (4439:11): [True: 0, False: 46.2k] ------------------ 4440| 0| return ONIGERR_INVALID_WIDE_CHAR_VALUE; ------------------ | | 645| 0|#define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 ------------------ 4441| 46.2k| } 4442| 46.2k| break; 4443| 46.2k|#endif 4444| | 4445| 46.2k| case ND_ANCHOR: ------------------ | Branch (4445:3): [True: 3.11k, False: 138k] ------------------ 4446| 3.11k| if (IS_NULL(ND_BODY(node))) ------------------ | | 201| 3.11k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 3.10k, False: 13] | | ------------------ ------------------ 4447| 3.10k| break; 4448| | /* fall */ 4449| 46.3k| case ND_QUANT: ------------------ | Branch (4449:3): [True: 46.3k, False: 95.1k] ------------------ 4450| 46.3k| r = reduce_string_list(ND_BODY(node), enc); ------------------ | | 394| 46.3k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 4451| 46.3k| break; 4452| | 4453| 801| case ND_BAG: ------------------ | Branch (4453:3): [True: 801, False: 140k] ------------------ 4454| 801| { 4455| 801| BagNode* en = BAG_(node); ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 4456| | 4457| 801| r = reduce_string_list(ND_BODY(node), enc); ------------------ | | 394| 801|#define ND_BODY(node) ((node)->u.base.body) ------------------ 4458| 801| if (r != 0) return r; ------------------ | Branch (4458:11): [True: 0, False: 801] ------------------ 4459| | 4460| 801| if (en->type == BAG_IF_ELSE) { ------------------ | Branch (4460:11): [True: 0, False: 801] ------------------ 4461| 0| if (IS_NOT_NULL(en->te.Then)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 4462| 0| r = reduce_string_list(en->te.Then, enc); 4463| 0| if (r != 0) return r; ------------------ | Branch (4463:15): [True: 0, False: 0] ------------------ 4464| 0| } 4465| 0| if (IS_NOT_NULL(en->te.Else)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 4466| 0| r = reduce_string_list(en->te.Else, enc); 4467| 0| if (r != 0) return r; ------------------ | Branch (4467:15): [True: 0, False: 0] ------------------ 4468| 0| } 4469| 0| } 4470| 801| } 4471| 801| break; 4472| | 4473| 953| default: ------------------ | Branch (4473:3): [True: 953, False: 140k] ------------------ 4474| 953| break; 4475| 141k| } 4476| | 4477| 141k| return r; 4478| 141k|} regcomp.c:check_backrefs: 3746| 182k|{ 3747| 182k| int r; 3748| | 3749| 182k| switch (ND_TYPE(node)) { ------------------ | | 284| 182k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 3750| 44.0k| case ND_LIST: ------------------ | Branch (3750:3): [True: 44.0k, False: 138k] ------------------ 3751| 44.0k| case ND_ALT: ------------------ | Branch (3751:3): [True: 0, False: 182k] ------------------ 3752| 88.3k| do { 3753| 88.3k| r = check_backrefs(ND_CAR(node), env); ------------------ | | 298| 88.3k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 88.3k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 3754| 88.3k| } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 88.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.3k, False: 44.0k] | | ------------------ ------------------ | Branch (3754:14): [True: 88.3k, False: 0] ------------------ 3755| 44.0k| break; 3756| | 3757| 3.11k| case ND_ANCHOR: ------------------ | Branch (3757:3): [True: 3.11k, False: 179k] ------------------ 3758| 3.11k| if (! ANCHOR_HAS_BODY(ANCHOR_(node))) { ------------------ | | 477| 3.11k|#define ANCHOR_HAS_BODY(a) ((a)->type < ANCR_BEGIN_BUF) | | ------------------ | | | | 461| 3.11k|#define ANCR_BEGIN_BUF (1<<4) | | ------------------ ------------------ | Branch (3758:9): [True: 3.10k, False: 13] ------------------ 3759| 3.10k| r = 0; 3760| 3.10k| break; 3761| 3.10k| } 3762| | /* fall */ 3763| 46.3k| case ND_QUANT: ------------------ | Branch (3763:3): [True: 46.3k, False: 136k] ------------------ 3764| 46.3k| r = check_backrefs(ND_BODY(node), env); ------------------ | | 394| 46.3k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3765| 46.3k| break; 3766| | 3767| 801| case ND_BAG: ------------------ | Branch (3767:3): [True: 801, False: 181k] ------------------ 3768| 801| r = check_backrefs(ND_BODY(node), env); ------------------ | | 394| 801|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3769| 801| { 3770| 801| BagNode* en = BAG_(node); ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 3771| | 3772| 801| if (en->type == BAG_IF_ELSE) { ------------------ | Branch (3772:11): [True: 0, False: 801] ------------------ 3773| 0| if (r != 0) return r; ------------------ | Branch (3773:13): [True: 0, False: 0] ------------------ 3774| 0| if (IS_NOT_NULL(en->te.Then)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3775| 0| r = check_backrefs(en->te.Then, env); 3776| 0| if (r != 0) return r; ------------------ | Branch (3776:15): [True: 0, False: 0] ------------------ 3777| 0| } 3778| 0| if (IS_NOT_NULL(en->te.Else)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3779| 0| r = check_backrefs(en->te.Else, env); 3780| 0| } 3781| 0| } 3782| 801| } 3783| 801| break; 3784| | 3785| 801| case ND_BACKREF: ------------------ | Branch (3785:3): [True: 0, False: 182k] ------------------ 3786| 0| { 3787| 0| int i; 3788| 0| BackRefNode* br = BACKREF_(node); ------------------ | | 290| 0|#define BACKREF_(node) (&((node)->u.backref)) ------------------ 3789| 0| int* backs = BACKREFS_P(br); ------------------ | | 322| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static) | | ------------------ | | | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (202:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3790| 0| MemEnv* mem_env = PARSEENV_MEMENV(env); ------------------ | | 402| 0| (IS_NOT_NULL((senv)->mem_env_dynamic) ? \ | | ------------------ | | | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (202:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 403| 0| (senv)->mem_env_dynamic : (senv)->mem_env_static) ------------------ 3791| | 3792| 0| for (i = 0; i < br->back_num; i++) { ------------------ | Branch (3792:19): [True: 0, False: 0] ------------------ 3793| 0| if (backs[i] > env->num_mem) ------------------ | Branch (3793:13): [True: 0, False: 0] ------------------ 3794| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 3795| | 3796| 0| ND_STATUS_ADD(mem_env[backs[i]].mem_node, BACKREF); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 341| 0|#define ND_ST_BACKREF (1<<16) | | ------------------ ------------------ 3797| 0| } 3798| 0| r = 0; 3799| 0| } 3800| 0| break; 3801| | 3802| 88.1k| default: ------------------ | Branch (3802:3): [True: 88.1k, False: 94.3k] ------------------ 3803| 88.1k| r = 0; 3804| 88.1k| break; 3805| 182k| } 3806| | 3807| 182k| return r; 3808| 182k|} regcomp.c:node_min_byte_len: 3606| 46.4k|{ 3607| 46.4k| OnigLen len; 3608| 46.4k| OnigLen tmin; 3609| | 3610| 46.4k| len = 0; 3611| 46.4k| switch (ND_TYPE(node)) { ------------------ | | 284| 46.4k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 3612| 0| case ND_BACKREF: ------------------ | Branch (3612:3): [True: 0, False: 46.4k] ------------------ 3613| 0| if (! ND_IS_CHECKER(node)) { ------------------ | | 376| 0|#define ND_IS_CHECKER(node) ((ND_STATUS(node) & ND_ST_CHECKER) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CHECKER(node) ((ND_STATUS(node) & ND_ST_CHECKER) != 0) | | ------------------ | | | | 342| 0|#define ND_ST_CHECKER (1<<17) | | ------------------ ------------------ | Branch (3613:9): [True: 0, False: 0] ------------------ 3614| 0| int i; 3615| 0| int* backs; 3616| 0| MemEnv* mem_env = PARSEENV_MEMENV(env); ------------------ | | 402| 0| (IS_NOT_NULL((senv)->mem_env_dynamic) ? \ | | ------------------ | | | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (202:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 403| 0| (senv)->mem_env_dynamic : (senv)->mem_env_static) ------------------ 3617| 0| BackRefNode* br = BACKREF_(node); ------------------ | | 290| 0|#define BACKREF_(node) (&((node)->u.backref)) ------------------ 3618| 0| if (ND_IS_RECURSION(node)) break; ------------------ | | 364| 0|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 0|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 0] | | ------------------ ------------------ 3619| | 3620| 0| backs = BACKREFS_P(br); ------------------ | | 322| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static) | | ------------------ | | | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (202:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3621| 0| len = node_min_byte_len(mem_env[backs[0]].mem_node, env); 3622| 0| for (i = 1; i < br->back_num; i++) { ------------------ | Branch (3622:19): [True: 0, False: 0] ------------------ 3623| 0| tmin = node_min_byte_len(mem_env[backs[i]].mem_node, env); 3624| 0| if (len > tmin) len = tmin; ------------------ | Branch (3624:13): [True: 0, False: 0] ------------------ 3625| 0| } 3626| 0| } 3627| 0| break; 3628| | 3629| 0|#ifdef USE_CALL 3630| 0| case ND_CALL: ------------------ | Branch (3630:3): [True: 0, False: 46.4k] ------------------ 3631| 0| { 3632| 0| Node* t = ND_BODY(node); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3633| 0| if (ND_IS_FIXED_MIN(t)) ------------------ | | 369| 0|#define ND_IS_FIXED_MIN(node) ((ND_STATUS(node) & ND_ST_FIXED_MIN) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_FIXED_MIN(node) ((ND_STATUS(node) & ND_ST_FIXED_MIN) != 0) | | ------------------ | | | | 325| 0|#define ND_ST_FIXED_MIN (1<<0) | | ------------------ | | | Branch (369:37): [True: 0, False: 0] | | ------------------ ------------------ 3634| 0| len = BAG_(t)->min_len; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 3635| 0| else 3636| 0| len = node_min_byte_len(t, env); 3637| 0| } 3638| 0| break; 3639| 0|#endif 3640| | 3641| 0| case ND_LIST: ------------------ | Branch (3641:3): [True: 0, False: 46.4k] ------------------ 3642| 0| do { 3643| 0| tmin = node_min_byte_len(ND_CAR(node), env); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 3644| 0| len = distance_add(len, tmin); 3645| 0| } while (IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3646| 0| break; 3647| | 3648| 0| case ND_ALT: ------------------ | Branch (3648:3): [True: 0, False: 46.4k] ------------------ 3649| 0| { 3650| 0| Node *x, *y; 3651| 0| y = node; 3652| 0| do { 3653| 0| x = ND_CAR(y); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 3654| 0| tmin = node_min_byte_len(x, env); 3655| 0| if (y == node) len = tmin; ------------------ | Branch (3655:13): [True: 0, False: 0] ------------------ 3656| 0| else if (len > tmin) len = tmin; ------------------ | Branch (3656:18): [True: 0, False: 0] ------------------ 3657| 0| } while (IS_NOT_NULL(y = ND_CDR(y))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3658| 0| } 3659| 0| break; 3660| | 3661| 45.8k| case ND_STRING: ------------------ | Branch (3661:3): [True: 45.8k, False: 618] ------------------ 3662| 45.8k| { 3663| 45.8k| StrNode* sn = STR_(node); ------------------ | | 287| 45.8k|#define STR_(node) (&((node)->u.str)) ------------------ 3664| 45.8k| len = (int )(sn->end - sn->s); 3665| 45.8k| } 3666| 45.8k| break; 3667| | 3668| 236| case ND_CTYPE: ------------------ | Branch (3668:3): [True: 236, False: 46.2k] ------------------ 3669| 514| case ND_CCLASS: ------------------ | Branch (3669:3): [True: 278, False: 46.2k] ------------------ 3670| 514| len = ONIGENC_MBC_MINLEN(env->enc); ------------------ | | 282| 514|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 3671| 514| break; 3672| | 3673| 0| case ND_QUANT: ------------------ | Branch (3673:3): [True: 0, False: 46.4k] ------------------ 3674| 0| { 3675| 0| QuantNode* qn = QUANT_(node); ------------------ | | 291| 0|#define QUANT_(node) (&((node)->u.quant)) ------------------ 3676| | 3677| 0| if (qn->lower > 0) { ------------------ | Branch (3677:11): [True: 0, False: 0] ------------------ 3678| 0| len = node_min_byte_len(ND_BODY(node), env); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3679| 0| len = distance_multiply(len, qn->lower); 3680| 0| } 3681| 0| } 3682| 0| break; 3683| | 3684| 104| case ND_BAG: ------------------ | Branch (3684:3): [True: 104, False: 46.3k] ------------------ 3685| 104| { 3686| 104| BagNode* en = BAG_(node); ------------------ | | 292| 104|#define BAG_(node) (&((node)->u.bag)) ------------------ 3687| 104| switch (en->type) { ------------------ | Branch (3687:15): [True: 104, False: 0] ------------------ 3688| 104| case BAG_MEMORY: ------------------ | Branch (3688:7): [True: 104, False: 0] ------------------ 3689| 104| if (ND_IS_FIXED_MIN(node)) ------------------ | | 369| 104|#define ND_IS_FIXED_MIN(node) ((ND_STATUS(node) & ND_ST_FIXED_MIN) != 0) | | ------------------ | | | | 356| 104|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_FIXED_MIN(node) ((ND_STATUS(node) & ND_ST_FIXED_MIN) != 0) | | ------------------ | | | | 325| 104|#define ND_ST_FIXED_MIN (1<<0) | | ------------------ | | | Branch (369:37): [True: 0, False: 104] | | ------------------ ------------------ 3690| 0| len = en->min_len; 3691| 104| else { 3692| 104| if (ND_IS_MARK1(node)) ------------------ | | 371| 104|#define ND_IS_MARK1(node) ((ND_STATUS(node) & ND_ST_MARK1) != 0) | | ------------------ | | | | 356| 104|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_MARK1(node) ((ND_STATUS(node) & ND_ST_MARK1) != 0) | | ------------------ | | | | 328| 104|#define ND_ST_MARK1 (1<<3) | | ------------------ | | | Branch (371:37): [True: 0, False: 104] | | ------------------ ------------------ 3693| 0| len = 0; /* recursive */ 3694| 104| else { 3695| 104| ND_STATUS_ADD(node, MARK1); ------------------ | | 357| 104|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 104|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 328| 104|#define ND_ST_MARK1 (1<<3) | | ------------------ ------------------ 3696| 104| len = node_min_byte_len(ND_BODY(node), env); ------------------ | | 394| 104|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3697| 104| ND_STATUS_REMOVE(node, MARK1); ------------------ | | 358| 104|#define ND_STATUS_REMOVE(node,f) (ND_STATUS(node) &= ~(ND_ST_ ## f)) | | ------------------ | | | | 356| 104|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_REMOVE(node,f) (ND_STATUS(node) &= ~(ND_ST_ ## f)) | | ------------------ | | | | 328| 104|#define ND_ST_MARK1 (1<<3) | | ------------------ ------------------ 3698| | 3699| 104| en->min_len = len; 3700| 104| ND_STATUS_ADD(node, FIXED_MIN); ------------------ | | 357| 104|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 104|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 325| 104|#define ND_ST_FIXED_MIN (1<<0) | | ------------------ ------------------ 3701| 104| } 3702| 104| } 3703| 104| break; 3704| | 3705| 0| case BAG_OPTION: ------------------ | Branch (3705:7): [True: 0, False: 104] ------------------ 3706| 0| case BAG_STOP_BACKTRACK: ------------------ | Branch (3706:7): [True: 0, False: 104] ------------------ 3707| 0| len = node_min_byte_len(ND_BODY(node), env); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3708| 0| break; 3709| 0| case BAG_IF_ELSE: ------------------ | Branch (3709:7): [True: 0, False: 104] ------------------ 3710| 0| { 3711| 0| OnigLen elen; 3712| | 3713| 0| len = node_min_byte_len(ND_BODY(node), env); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3714| 0| if (IS_NOT_NULL(en->te.Then)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3715| 0| len += node_min_byte_len(en->te.Then, env); 3716| 0| if (IS_NOT_NULL(en->te.Else)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3717| 0| elen = node_min_byte_len(en->te.Else, env); 3718| 0| else elen = 0; 3719| | 3720| 0| if (elen < len) len = elen; ------------------ | Branch (3720:15): [True: 0, False: 0] ------------------ 3721| 0| } 3722| 0| break; 3723| 104| } 3724| 104| } 3725| 104| break; 3726| | 3727| 104| case ND_GIMMICK: ------------------ | Branch (3727:3): [True: 0, False: 46.4k] ------------------ 3728| 0| { 3729| 0| GimmickNode* g = GIMMICK_(node); ------------------ | | 296| 0|#define GIMMICK_(node) (&((node)->u.gimmick)) ------------------ 3730| 0| if (g->type == GIMMICK_FAIL) { ------------------ | Branch (3730:11): [True: 0, False: 0] ------------------ 3731| 0| len = INFINITE_LEN; ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 3732| 0| break; 3733| 0| } 3734| 0| } 3735| | /* fall */ 3736| 0| case ND_ANCHOR: ------------------ | Branch (3736:3): [True: 0, False: 46.4k] ------------------ 3737| 0| default: ------------------ | Branch (3737:3): [True: 0, False: 46.4k] ------------------ 3738| 0| break; 3739| 46.4k| } 3740| | 3741| 46.4k| return len; 3742| 46.4k|} regcomp.c:distance_add: 446| 355k|{ 447| 355k| if (d1 == INFINITE_LEN || d2 == INFINITE_LEN) ------------------ | | 218| 355k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 711k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ if (d1 == INFINITE_LEN || d2 == INFINITE_LEN) ------------------ | | 218| 355k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 355k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (447:7): [True: 658, False: 355k] | Branch (447:29): [True: 87.7k, False: 267k] ------------------ 448| 88.4k| return INFINITE_LEN; ------------------ | | 218| 88.4k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 88.4k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 449| 267k| else { 450| 267k| if (d1 <= INFINITE_LEN - d2) return d1 + d2; ------------------ | | 218| 267k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 267k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (450:9): [True: 267k, False: 0] ------------------ 451| 0| else return INFINITE_LEN; ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 452| 267k| } 453| 355k|} regcomp.c:distance_multiply: 457| 46.4k|{ 458| 46.4k| if (m == 0) return 0; ------------------ | Branch (458:7): [True: 39.1k, False: 7.30k] ------------------ 459| | 460| 7.30k| if (d < INFINITE_LEN / m) ------------------ | | 218| 7.30k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 7.30k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (460:7): [True: 7.30k, False: 0] ------------------ 461| 7.30k| return d * m; 462| 0| else 463| 0| return INFINITE_LEN; ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 464| 7.30k|} regcomp.c:tune_tree: 5746| 182k|{ 5747| 182k| int r = 0; 5748| | 5749| 182k| switch (ND_TYPE(node)) { ------------------ | | 284| 182k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 5750| 44.0k| case ND_LIST: ------------------ | Branch (5750:3): [True: 44.0k, False: 138k] ------------------ 5751| 44.0k| { 5752| 44.0k| Node* prev = NULL_NODE; ------------------ | | 266| 44.0k|#define NULL_NODE ((Node* )0) ------------------ 5753| 88.3k| do { 5754| 88.3k| r = tune_tree(ND_CAR(node), reg, state, env); ------------------ | | 298| 88.3k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 88.3k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 5755| 88.3k| if (IS_NOT_NULL(prev) && r == 0) { ------------------ | | 202| 176k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.3k, False: 44.0k] | | ------------------ ------------------ | Branch (5755:34): [True: 44.3k, False: 0] ------------------ 5756| 44.3k| r = tune_next(prev, ND_CAR(node), reg); ------------------ | | 298| 44.3k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 44.3k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 5757| 44.3k| } 5758| 88.3k| prev = ND_CAR(node); ------------------ | | 298| 88.3k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 88.3k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 5759| 88.3k| } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 88.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.3k, False: 44.0k] | | ------------------ ------------------ | Branch (5759:16): [True: 88.3k, False: 0] ------------------ 5760| 44.0k| } 5761| 44.0k| break; 5762| | 5763| 0| case ND_ALT: ------------------ | Branch (5763:3): [True: 0, False: 182k] ------------------ 5764| 0| do { 5765| 0| r = tune_tree(ND_CAR(node), reg, (state | IN_ALT), env); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ r = tune_tree(ND_CAR(node), reg, (state | IN_ALT), env); ------------------ | | 4481| 0|#define IN_ALT (1<<0) ------------------ 5766| 0| } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5766:14): [True: 0, False: 0] ------------------ 5767| 0| break; 5768| | 5769| 87.1k| case ND_STRING: ------------------ | Branch (5769:3): [True: 87.1k, False: 95.3k] ------------------ 5770| 87.1k| if (ND_IS_REAL_IGNORECASE(node)) { ------------------ | | 35| 87.1k| (ND_IS_IGNORECASE(node) && !ND_STRING_IS_CRUDE(node)) | | ------------------ | | | | 384| 174k|#define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | | | ------------------ | | | | | | 356| 87.1k|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | | | ------------------ | | | | #define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | | | ------------------ | | | | | | 346| 87.1k|#define ND_ST_IGNORECASE (1<<21) | | | | ------------------ | | | | | Branch (384:37): [True: 2.35k, False: 84.8k] | | | | ------------------ | | ------------------ | | (ND_IS_IGNORECASE(node) && !ND_STRING_IS_CRUDE(node)) | | ------------------ | | | | 317| 2.35k| (((node)->u.str.flag & ND_STRING_CRUDE) != 0) | | | | ------------------ | | | | | | 309| 2.35k|#define ND_STRING_CRUDE (1<<0) | | | | ------------------ | | ------------------ | | | Branch (35:30): [True: 2.35k, False: 0] | | ------------------ ------------------ 5771| 2.35k| r = unravel_case_fold_string(node, reg, state); 5772| 2.35k| } 5773| 87.1k| break; 5774| | 5775| 0| case ND_BACKREF: ------------------ | Branch (5775:3): [True: 0, False: 182k] ------------------ 5776| 0| { 5777| 0| int i; 5778| 0| int* p; 5779| 0| BackRefNode* br = BACKREF_(node); ------------------ | | 290| 0|#define BACKREF_(node) (&((node)->u.backref)) ------------------ 5780| 0| p = BACKREFS_P(br); ------------------ | | 322| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static) | | ------------------ | | | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (202:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 5781| 0| for (i = 0; i < br->back_num; i++) { ------------------ | Branch (5781:19): [True: 0, False: 0] ------------------ 5782| 0| if (p[i] > env->num_mem) return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ | Branch (5782:13): [True: 0, False: 0] ------------------ 5783| 0| MEM_STATUS_ON(env->backrefed_mem, p[i]); ------------------ | | 371| 0|#define MEM_STATUS_ON(stats,n) do {\ | | 372| 0| if ((n) < (int )MEM_STATUS_BITS_NUM) {\ | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (372:7): [True: 0, False: 0] | | ------------------ | | 373| 0| if ((n) != 0)\ | | ------------------ | | | Branch (373:9): [True: 0, False: 0] | | ------------------ | | 374| 0| (stats) |= ((MemStatusType )1 << (n));\ | | 375| 0| }\ | | 376| 0| else\ | | 377| 0| (stats) |= 1;\ | | 378| 0|} while (0) | | ------------------ | | | Branch (378:10): [Folded, False: 0] | | ------------------ ------------------ 5784| |#if 0 5785| |#ifdef USE_BACKREF_WITH_LEVEL 5786| | if (ND_IS_NEST_LEVEL(node)) { 5787| | MEM_STATUS_ON(env->backtrack_mem, p[i]); 5788| | } 5789| |#endif 5790| |#else 5791| | /* More precisely, it should be checked whether alt/repeat exists before 5792| | the subject capture node, and then this backreference position 5793| | exists before (or in) the capture node. */ 5794| 0| MEM_STATUS_ON(env->backtrack_mem, p[i]); ------------------ | | 371| 0|#define MEM_STATUS_ON(stats,n) do {\ | | 372| 0| if ((n) < (int )MEM_STATUS_BITS_NUM) {\ | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (372:7): [True: 0, False: 0] | | ------------------ | | 373| 0| if ((n) != 0)\ | | ------------------ | | | Branch (373:9): [True: 0, False: 0] | | ------------------ | | 374| 0| (stats) |= ((MemStatusType )1 << (n));\ | | 375| 0| }\ | | 376| 0| else\ | | 377| 0| (stats) |= 1;\ | | 378| 0|} while (0) | | ------------------ | | | Branch (378:10): [Folded, False: 0] | | ------------------ ------------------ 5795| 0|#endif 5796| 0| } 5797| 0| } 5798| 0| break; 5799| | 5800| 801| case ND_BAG: ------------------ | Branch (5800:3): [True: 801, False: 181k] ------------------ 5801| 801| { 5802| 801| BagNode* en = BAG_(node); ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 5803| | 5804| 801| switch (en->type) { ------------------ | Branch (5804:15): [True: 801, False: 0] ------------------ 5805| 0| case BAG_OPTION: ------------------ | Branch (5805:7): [True: 0, False: 801] ------------------ 5806| 0| { 5807| 0| OnigOptionType options = reg->options; 5808| 0| reg->options = BAG_(node)->o.options; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 5809| 0| r = tune_tree(ND_BODY(node), reg, state, env); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 5810| 0| reg->options = options; 5811| 0| } 5812| 0| break; 5813| | 5814| 801| case BAG_MEMORY: ------------------ | Branch (5814:7): [True: 801, False: 0] ------------------ 5815| 801|#ifdef USE_CALL 5816| 801| state |= en->m.called_state; 5817| 801|#endif 5818| | 5819| 801| if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_MULTI_ENTRY)) != 0 ------------------ | | 4481| 801|#define IN_ALT (1<<0) ------------------ if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_MULTI_ENTRY)) != 0 ------------------ | | 4482| 801|#define IN_NOT (1<<1) ------------------ if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_MULTI_ENTRY)) != 0 ------------------ | | 4484| 801|#define IN_VAR_REPEAT (1<<3) ------------------ if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_MULTI_ENTRY)) != 0 ------------------ | | 4486| 801|#define IN_MULTI_ENTRY (1<<5) ------------------ | Branch (5819:13): [True: 104, False: 697] ------------------ 5820| 697| || ND_IS_RECURSION(node)) { ------------------ | | 364| 697|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 697|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 697|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 697] | | ------------------ ------------------ 5821| 104| MEM_STATUS_ON(env->backtrack_mem, en->m.regnum); ------------------ | | 371| 104|#define MEM_STATUS_ON(stats,n) do {\ | | 372| 104| if ((n) < (int )MEM_STATUS_BITS_NUM) {\ | | ------------------ | | | | 361| 104|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (372:7): [True: 104, False: 0] | | ------------------ | | 373| 104| if ((n) != 0)\ | | ------------------ | | | Branch (373:9): [True: 104, False: 0] | | ------------------ | | 374| 104| (stats) |= ((MemStatusType )1 << (n));\ | | 375| 104| }\ | | 376| 104| else\ | | 377| 104| (stats) |= 1;\ | | 378| 104|} while (0) | | ------------------ | | | Branch (378:10): [Folded, False: 104] | | ------------------ ------------------ 5822| 104| } 5823| 801| r = tune_tree(ND_BODY(node), reg, state, env); ------------------ | | 394| 801|#define ND_BODY(node) ((node)->u.base.body) ------------------ 5824| 801| break; 5825| | 5826| 0| case BAG_STOP_BACKTRACK: ------------------ | Branch (5826:7): [True: 0, False: 801] ------------------ 5827| 0| { 5828| 0| Node* target = ND_BODY(node); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 5829| 0| r = tune_tree(target, reg, state, env); 5830| 0| if (ND_TYPE(target) == ND_QUANT) { ------------------ | | 284| 0|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (5830:15): [True: 0, False: 0] ------------------ 5831| 0| QuantNode* tqn = QUANT_(target); ------------------ | | 291| 0|#define QUANT_(node) (&((node)->u.quant)) ------------------ 5832| 0| if (IS_INFINITE_REPEAT(tqn->upper) && tqn->lower <= 1 && ------------------ | | 428| 0|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 0|#define INFINITE_REPEAT -1 | | ------------------ | | | Branch (428:33): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5832:51): [True: 0, False: 0] ------------------ 5833| 0| tqn->greedy != 0) { /* (?>a*), a*+ etc... */ ------------------ | Branch (5833:17): [True: 0, False: 0] ------------------ 5834| 0| if (is_strict_real_node(ND_BODY(target))) ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ | Branch (5834:19): [True: 0, False: 0] ------------------ 5835| 0| ND_STATUS_ADD(node, STRICT_REAL_REPEAT); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 330| 0|#define ND_ST_STRICT_REAL_REPEAT (1<<5) | | ------------------ ------------------ 5836| 0| } 5837| 0| } 5838| 0| } 5839| 0| break; 5840| | 5841| 0| case BAG_IF_ELSE: ------------------ | Branch (5841:7): [True: 0, False: 801] ------------------ 5842| 0| r = tune_tree(ND_BODY(node), reg, (state | IN_ALT), env); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ r = tune_tree(ND_BODY(node), reg, (state | IN_ALT), env); ------------------ | | 4481| 0|#define IN_ALT (1<<0) ------------------ 5843| 0| if (r != 0) return r; ------------------ | Branch (5843:13): [True: 0, False: 0] ------------------ 5844| 0| if (IS_NOT_NULL(en->te.Then)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 5845| 0| r = tune_tree(en->te.Then, reg, (state | IN_ALT), env); ------------------ | | 4481| 0|#define IN_ALT (1<<0) ------------------ 5846| 0| if (r != 0) return r; ------------------ | Branch (5846:15): [True: 0, False: 0] ------------------ 5847| 0| } 5848| 0| if (IS_NOT_NULL(en->te.Else)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 5849| 0| r = tune_tree(en->te.Else, reg, (state | IN_ALT), env); ------------------ | | 4481| 0|#define IN_ALT (1<<0) ------------------ 5850| 0| break; 5851| 801| } 5852| 801| } 5853| 801| break; 5854| | 5855| 46.3k| case ND_QUANT: ------------------ | Branch (5855:3): [True: 46.3k, False: 136k] ------------------ 5856| 46.3k| if ((state & (IN_PREC_READ | IN_LOOK_BEHIND)) != 0) ------------------ | | 4487| 46.3k|#define IN_PREC_READ (1<<6) ------------------ if ((state & (IN_PREC_READ | IN_LOOK_BEHIND)) != 0) ------------------ | | 4488| 46.3k|#define IN_LOOK_BEHIND (1<<7) ------------------ | Branch (5856:9): [True: 0, False: 46.3k] ------------------ 5857| 0| ND_STATUS_ADD(node, INPEEK); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 352| 0|#define ND_ST_INPEEK (1<<27) | | ------------------ ------------------ 5858| | 5859| 46.3k| r = tune_quant(node, reg, state, env); 5860| 46.3k| break; 5861| | 5862| 3.11k| case ND_ANCHOR: ------------------ | Branch (5862:3): [True: 3.11k, False: 179k] ------------------ 5863| 3.11k| r = tune_anchor(node, reg, state, env); 5864| 3.11k| break; 5865| | 5866| 0|#ifdef USE_CALL 5867| 0| case ND_CALL: ------------------ | Branch (5867:3): [True: 0, False: 182k] ------------------ 5868| 0|#endif 5869| 562| case ND_CTYPE: ------------------ | Branch (5869:3): [True: 562, False: 181k] ------------------ 5870| 953| case ND_CCLASS: ------------------ | Branch (5870:3): [True: 391, False: 182k] ------------------ 5871| 953| case ND_GIMMICK: ------------------ | Branch (5871:3): [True: 0, False: 182k] ------------------ 5872| 953| default: ------------------ | Branch (5872:3): [True: 0, False: 182k] ------------------ 5873| 953| break; 5874| 182k| } 5875| | 5876| 182k| return r; 5877| 182k|} regcomp.c:tune_next: 4694| 44.3k|{ 4695| 44.3k| int called; 4696| 44.3k| NodeType type; 4697| | 4698| 44.3k| called = FALSE; ------------------ | | 63| 44.3k|#define FALSE 0 ------------------ 4699| | 4700| 44.4k| retry: 4701| 44.4k| type = ND_TYPE(node); ------------------ | | 284| 44.4k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 4702| 44.4k| if (type == ND_QUANT) { ------------------ | Branch (4702:7): [True: 336, False: 44.1k] ------------------ 4703| 336| QuantNode* qn = QUANT_(node); ------------------ | | 291| 336|#define QUANT_(node) (&((node)->u.quant)) ------------------ 4704| 336| if (qn->greedy && IS_INFINITE_REPEAT(qn->upper)) { ------------------ | | 428| 269|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 269|#define INFINITE_REPEAT -1 | | ------------------ | | | Branch (428:33): [True: 213, False: 56] | | ------------------ ------------------ | Branch (4704:9): [True: 269, False: 67] ------------------ 4705| 213|#ifdef USE_QUANT_PEEK_NEXT 4706| 213| if (called == FALSE) { ------------------ | | 63| 213|#define FALSE 0 ------------------ | Branch (4706:11): [True: 213, False: 0] ------------------ 4707| 213| Node* n = get_tree_head_literal(next_node, 1, reg); 4708| | /* '\0': for UTF-16BE etc... */ 4709| 213| if (IS_NOT_NULL(n) && STR_(n)->s[0] != '\0') { ------------------ | | 202| 426|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 139, False: 74] | | ------------------ ------------------ if (IS_NOT_NULL(n) && STR_(n)->s[0] != '\0') { ------------------ | | 287| 139|#define STR_(node) (&((node)->u.str)) ------------------ | Branch (4709:31): [True: 139, False: 0] ------------------ 4710| 139| qn->next_head_exact = n; 4711| 139| } 4712| 213| } 4713| 213|#endif 4714| | /* automatic posseivation a*b ==> (?>a*)b */ 4715| 213| if (qn->lower <= 1) { ------------------ | Branch (4715:11): [True: 213, False: 0] ------------------ 4716| 213| if (is_strict_real_node(ND_BODY(node))) { ------------------ | | 394| 213|#define ND_BODY(node) ((node)->u.base.body) ------------------ | Branch (4716:13): [True: 213, False: 0] ------------------ 4717| 213| Node *x, *y; 4718| 213| x = get_tree_head_literal(ND_BODY(node), 0, reg); ------------------ | | 394| 213|#define ND_BODY(node) ((node)->u.base.body) ------------------ 4719| 213| if (IS_NOT_NULL(x)) { ------------------ | | 202| 213|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 123, False: 90] | | ------------------ ------------------ 4720| 123| y = get_tree_head_literal(next_node, 0, reg); 4721| 123| if (IS_NOT_NULL(y) && is_exclusive(x, y, reg)) { ------------------ | | 202| 246|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 74, False: 49] | | ------------------ ------------------ | Branch (4721:35): [True: 74, False: 0] ------------------ 4722| 74| Node* en = onig_node_new_bag(BAG_STOP_BACKTRACK); 4723| 74| CHECK_NULL_RETURN_MEMERR(en); ------------------ | | 204| 74|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 74|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 74] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 4724| 74| ND_STATUS_ADD(en, STRICT_REAL_REPEAT); ------------------ | | 357| 74|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 74|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 330| 74|#define ND_ST_STRICT_REAL_REPEAT (1<<5) | | ------------------ ------------------ 4725| 74| node_swap(node, en); 4726| 74| ND_BODY(node) = en; ------------------ | | 394| 74|#define ND_BODY(node) ((node)->u.base.body) ------------------ 4727| 74| } 4728| 123| } 4729| 213| } 4730| 213| } 4731| 213| } 4732| 336| } 4733| 44.1k| else if (type == ND_BAG) { ------------------ | Branch (4733:12): [True: 194, False: 43.9k] ------------------ 4734| 194| BagNode* en = BAG_(node); ------------------ | | 292| 194|#define BAG_(node) (&((node)->u.bag)) ------------------ 4735| 194| if (en->type == BAG_MEMORY) { ------------------ | Branch (4735:9): [True: 194, False: 0] ------------------ 4736| 194| if (ND_IS_CALLED(node)) ------------------ | | 362| 194|#define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 356| 194|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 332| 194|#define ND_ST_CALLED (1<<7) | | ------------------ | | | Branch (362:37): [True: 0, False: 194] | | ------------------ ------------------ 4737| 0| called = TRUE; ------------------ | | 59| 0|#define TRUE 1 ------------------ 4738| 194| node = ND_BODY(node); ------------------ | | 394| 194|#define ND_BODY(node) ((node)->u.base.body) ------------------ 4739| 194| goto retry; 4740| 194| } 4741| 194| } 4742| 44.3k| return 0; 4743| 44.4k|} regcomp.c:get_tree_head_literal: 3238| 47.2k|{ 3239| 47.2k| Node* n = NULL_NODE; ------------------ | | 266| 47.2k|#define NULL_NODE ((Node* )0) ------------------ 3240| | 3241| 47.2k| switch (ND_TYPE(node)) { ------------------ | | 284| 47.2k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 3242| 0| case ND_BACKREF: ------------------ | Branch (3242:3): [True: 0, False: 47.2k] ------------------ 3243| 0| case ND_ALT: ------------------ | Branch (3243:3): [True: 0, False: 47.2k] ------------------ 3244| 0|#ifdef USE_CALL 3245| 0| case ND_CALL: ------------------ | Branch (3245:3): [True: 0, False: 47.2k] ------------------ 3246| 0|#endif 3247| 0| break; 3248| | 3249| 259| case ND_CTYPE: ------------------ | Branch (3249:3): [True: 259, False: 46.9k] ------------------ 3250| 259| if (CTYPE_(node)->ctype == CTYPE_ANYCHAR) ------------------ | | 289| 259|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ if (CTYPE_(node)->ctype == CTYPE_ANYCHAR) ------------------ | | 301| 259|#define CTYPE_ANYCHAR -1 ------------------ | Branch (3250:9): [True: 259, False: 0] ------------------ 3251| 259| break; 3252| | /* fall */ 3253| 2.69k| case ND_CCLASS: ------------------ | Branch (3253:3): [True: 2.69k, False: 44.5k] ------------------ 3254| 2.69k| if (exact == 0) { ------------------ | Branch (3254:9): [True: 148, False: 2.54k] ------------------ 3255| 148| n = node; 3256| 148| } 3257| 2.69k| break; 3258| | 3259| 56| case ND_LIST: ------------------ | Branch (3259:3): [True: 56, False: 47.1k] ------------------ 3260| 56| n = get_tree_head_literal(ND_CAR(node), exact, reg); ------------------ | | 298| 56|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 56|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 3261| 56| break; 3262| | 3263| 43.8k| case ND_STRING: ------------------ | Branch (3263:3): [True: 43.8k, False: 3.40k] ------------------ 3264| 43.8k| { 3265| 43.8k| StrNode* sn = STR_(node); ------------------ | | 287| 43.8k|#define STR_(node) (&((node)->u.str)) ------------------ 3266| | 3267| 43.8k| if (sn->end <= sn->s) ------------------ | Branch (3267:11): [True: 0, False: 43.8k] ------------------ 3268| 0| break; 3269| | 3270| 43.8k| if (exact == 0 || !ND_IS_REAL_IGNORECASE(node)) { ------------------ | | 35| 43.7k| (ND_IS_IGNORECASE(node) && !ND_STRING_IS_CRUDE(node)) | | ------------------ | | | | 384| 87.5k|#define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | | | ------------------ | | | | | | 356| 43.7k|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | | | ------------------ | | | | #define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | | | ------------------ | | | | | | 346| 43.7k|#define ND_ST_IGNORECASE (1<<21) | | | | ------------------ | | | | | Branch (384:37): [True: 0, False: 43.7k] | | | | ------------------ | | ------------------ | | (ND_IS_IGNORECASE(node) && !ND_STRING_IS_CRUDE(node)) | | ------------------ | | | | 317| 0| (((node)->u.str.flag & ND_STRING_CRUDE) != 0) | | | | ------------------ | | | | | | 309| 0|#define ND_STRING_CRUDE (1<<0) | | | | ------------------ | | ------------------ | | | Branch (35:30): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3270:11): [True: 49, False: 43.7k] ------------------ 3271| 43.8k| n = node; 3272| 43.8k| } 3273| 43.8k| } 3274| 0| break; 3275| | 3276| 148| case ND_QUANT: ------------------ | Branch (3276:3): [True: 148, False: 47.0k] ------------------ 3277| 148| { 3278| 148| QuantNode* qn = QUANT_(node); ------------------ | | 291| 148|#define QUANT_(node) (&((node)->u.quant)) ------------------ 3279| 148| if (qn->lower > 0) { ------------------ | Branch (3279:11): [True: 50, False: 98] ------------------ 3280| 50| if (IS_NOT_NULL(qn->head_exact)) ------------------ | | 202| 50|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 50] | | ------------------ ------------------ 3281| 0| n = qn->head_exact; 3282| 50| else 3283| 50| n = get_tree_head_literal(ND_BODY(node), exact, reg); ------------------ | | 394| 50|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3284| 50| } 3285| 148| } 3286| 148| break; 3287| | 3288| 252| case ND_BAG: ------------------ | Branch (3288:3): [True: 252, False: 46.9k] ------------------ 3289| 252| { 3290| 252| BagNode* en = BAG_(node); ------------------ | | 292| 252|#define BAG_(node) (&((node)->u.bag)) ------------------ 3291| 252| switch (en->type) { 3292| 0| case BAG_OPTION: ------------------ | Branch (3292:7): [True: 0, False: 252] ------------------ 3293| 252| case BAG_MEMORY: ------------------ | Branch (3293:7): [True: 252, False: 0] ------------------ 3294| 252| case BAG_STOP_BACKTRACK: ------------------ | Branch (3294:7): [True: 0, False: 252] ------------------ 3295| 252| n = get_tree_head_literal(ND_BODY(node), exact, reg); ------------------ | | 394| 252|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3296| 252| break; 3297| 0| default: ------------------ | Branch (3297:7): [True: 0, False: 252] ------------------ 3298| 0| break; 3299| 252| } 3300| 252| } 3301| 252| break; 3302| | 3303| 252| case ND_ANCHOR: ------------------ | Branch (3303:3): [True: 0, False: 47.2k] ------------------ 3304| 0| if (ANCHOR_(node)->type == ANCR_PREC_READ) ------------------ | | 293| 0|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ if (ANCHOR_(node)->type == ANCR_PREC_READ) ------------------ | | 456| 0|#define ANCR_PREC_READ (1<<0) ------------------ | Branch (3304:9): [True: 0, False: 0] ------------------ 3305| 0| n = get_tree_head_literal(ND_BODY(node), exact, reg); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 3306| 0| break; 3307| | 3308| 0| case ND_GIMMICK: ------------------ | Branch (3308:3): [True: 0, False: 47.2k] ------------------ 3309| 0| default: ------------------ | Branch (3309:3): [True: 0, False: 47.2k] ------------------ 3310| 0| break; 3311| 47.2k| } 3312| | 3313| 47.2k| return n; 3314| 47.2k|} regcomp.c:is_exclusive: 3044| 74|{ 3045| 74| int i, len; 3046| 74| OnigCodePoint code; 3047| 74| UChar *p; ------------------ | | 80| 74|#define UChar OnigUChar ------------------ 3048| 74| NodeType ytype; 3049| | 3050| 123| retry: 3051| 123| ytype = ND_TYPE(y); ------------------ | | 284| 123|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 3052| 123| switch (ND_TYPE(x)) { ------------------ | | 284| 123|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 3053| 0| case ND_CTYPE: ------------------ | Branch (3053:3): [True: 0, False: 123] ------------------ 3054| 0| { 3055| 0| if (CTYPE_(x)->ctype == CTYPE_ANYCHAR || ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ if (CTYPE_(x)->ctype == CTYPE_ANYCHAR || ------------------ | | 301| 0|#define CTYPE_ANYCHAR -1 ------------------ | Branch (3055:11): [True: 0, False: 0] ------------------ 3056| 0| CTYPE_(y)->ctype == CTYPE_ANYCHAR) ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ CTYPE_(y)->ctype == CTYPE_ANYCHAR) ------------------ | | 301| 0|#define CTYPE_ANYCHAR -1 ------------------ | Branch (3056:11): [True: 0, False: 0] ------------------ 3057| 0| break; 3058| | 3059| 0| switch (ytype) { 3060| 0| case ND_CTYPE: ------------------ | Branch (3060:7): [True: 0, False: 0] ------------------ 3061| 0| if (CTYPE_(y)->ctype == CTYPE_(x)->ctype && ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ if (CTYPE_(y)->ctype == CTYPE_(x)->ctype && ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (3061:13): [True: 0, False: 0] ------------------ 3062| 0| CTYPE_(y)->not != CTYPE_(x)->not && ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ CTYPE_(y)->not != CTYPE_(x)->not && ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (3062:13): [True: 0, False: 0] ------------------ 3063| 0| CTYPE_(y)->ascii_mode == CTYPE_(x)->ascii_mode) ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ CTYPE_(y)->ascii_mode == CTYPE_(x)->ascii_mode) ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (3063:13): [True: 0, False: 0] ------------------ 3064| 0| return 1; 3065| 0| else 3066| 0| return 0; 3067| 0| break; 3068| | 3069| 0| case ND_CCLASS: ------------------ | Branch (3069:7): [True: 0, False: 0] ------------------ 3070| 49| swap: 3071| 49| { 3072| 49| Node* tmp; 3073| 49| tmp = x; x = y; y = tmp; 3074| 49| goto retry; 3075| 0| } 3076| 0| break; 3077| | 3078| 0| case ND_STRING: ------------------ | Branch (3078:7): [True: 0, False: 0] ------------------ 3079| 0| goto swap; 3080| 0| break; 3081| | 3082| 0| default: ------------------ | Branch (3082:7): [True: 0, False: 0] ------------------ 3083| 0| break; 3084| 0| } 3085| 0| } 3086| 0| break; 3087| | 3088| 74| case ND_CCLASS: ------------------ | Branch (3088:3): [True: 74, False: 49] ------------------ 3089| 74| { 3090| 74| int range; 3091| 74| CClassNode* xc = CCLASS_(x); ------------------ | | 288| 74|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 3092| | 3093| 74| switch (ytype) { 3094| 0| case ND_CTYPE: ------------------ | Branch (3094:7): [True: 0, False: 74] ------------------ 3095| 0| switch (CTYPE_(y)->ctype) { ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 3096| 0| case CTYPE_ANYCHAR: ------------------ | | 301| 0|#define CTYPE_ANYCHAR -1 ------------------ | Branch (3096:9): [True: 0, False: 0] ------------------ 3097| 0| return 0; 3098| 0| break; 3099| | 3100| 0| case ONIGENC_CTYPE_WORD: ------------------ | Branch (3100:9): [True: 0, False: 0] ------------------ 3101| 0| if (CTYPE_(y)->not == 0) { ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (3101:15): [True: 0, False: 0] ------------------ 3102| 0| if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) { ------------------ | | 736| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (3102:38): [True: 0, False: 0] ------------------ 3103| 0| range = CTYPE_(y)->ascii_mode != 0 ? 128 : SINGLE_BYTE_SIZE; ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ range = CTYPE_(y)->ascii_mode != 0 ? 128 : SINGLE_BYTE_SIZE; ------------------ | | 432| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (3103:23): [True: 0, False: 0] ------------------ 3104| 0| for (i = 0; i < range; i++) { ------------------ | Branch (3104:27): [True: 0, False: 0] ------------------ 3105| 0| if (BITSET_AT(xc->bs, i)) { ------------------ | | 450| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 0|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 0|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ | | | Branch (450:36): [True: 0, False: 0] | | ------------------ ------------------ 3106| 0| if (ONIGENC_IS_CODE_WORD(reg->enc, i)) return 0; ------------------ | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | ------------------ | | | | | Branch (290:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3107| 0| } 3108| 0| } 3109| 0| return 1; 3110| 0| } 3111| 0| return 0; 3112| 0| } 3113| 0| else { 3114| 0| if (IS_NOT_NULL(xc->mbuf)) return 0; ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3115| 0| if (IS_NCCLASS_NOT(xc)) return 0; ------------------ | | 736| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3116| | 3117| 0| range = CTYPE_(y)->ascii_mode != 0 ? 128 : SINGLE_BYTE_SIZE; ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ range = CTYPE_(y)->ascii_mode != 0 ? 128 : SINGLE_BYTE_SIZE; ------------------ | | 432| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (3117:21): [True: 0, False: 0] ------------------ 3118| 0| for (i = 0; i < range; i++) { ------------------ | Branch (3118:25): [True: 0, False: 0] ------------------ 3119| 0| if (! ONIGENC_IS_CODE_WORD(reg->enc, i)) { ------------------ | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | ------------------ ------------------ | Branch (3119:19): [True: 0, False: 0] ------------------ 3120| 0| if (BITSET_AT(xc->bs, i)) ------------------ | | 450| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 0|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 0|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ | | | Branch (450:36): [True: 0, False: 0] | | ------------------ ------------------ 3121| 0| return 0; 3122| 0| } 3123| 0| } 3124| 0| for (i = range; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 432| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (3124:29): [True: 0, False: 0] ------------------ 3125| 0| if (BITSET_AT(xc->bs, i)) return 0; ------------------ | | 450| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 0|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 0|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ | | | Branch (450:36): [True: 0, False: 0] | | ------------------ ------------------ 3126| 0| } 3127| 0| return 1; 3128| 0| } 3129| 0| break; 3130| | 3131| 0| default: ------------------ | Branch (3131:9): [True: 0, False: 0] ------------------ 3132| 0| break; 3133| 0| } 3134| 0| break; 3135| | 3136| 25| case ND_CCLASS: ------------------ | Branch (3136:7): [True: 25, False: 49] ------------------ 3137| 25| { 3138| 25| int v; 3139| 25| CClassNode* yc = CCLASS_(y); ------------------ | | 288| 25|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 3140| | 3141| 6.42k| for (i = 0; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 432| 6.42k|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 6.42k|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (3141:23): [True: 6.40k, False: 25] ------------------ 3142| 6.40k| v = BITSET_AT(xc->bs, i); ------------------ | | 450| 6.40k|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 6.40k|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 6.40k|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ 3143| 6.40k| if ((v != 0 && !IS_NCCLASS_NOT(xc)) || (v == 0 && IS_NCCLASS_NOT(xc))) { ------------------ | | 736| 650|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 650|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 650|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ if ((v != 0 && !IS_NCCLASS_NOT(xc)) || (v == 0 && IS_NCCLASS_NOT(xc))) { ------------------ | | 736| 5.75k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 5.75k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 5.75k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 5.75k, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3143:18): [True: 650, False: 5.75k] | Branch (3143:28): [True: 0, False: 650] | Branch (3143:53): [True: 5.75k, False: 650] ------------------ 3144| 5.75k| v = BITSET_AT(yc->bs, i); ------------------ | | 450| 5.75k|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 5.75k|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 5.75k|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ 3145| 5.75k| if ((v != 0 && !IS_NCCLASS_NOT(yc)) || ------------------ | | 736| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (3145:20): [True: 0, False: 5.75k] | Branch (3145:30): [True: 0, False: 0] ------------------ 3146| 5.75k| (v == 0 && IS_NCCLASS_NOT(yc))) ------------------ | | 736| 5.75k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 5.75k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 5.75k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 0, False: 5.75k] | | | | ------------------ | | ------------------ ------------------ | Branch (3146:20): [True: 5.75k, False: 0] ------------------ 3147| 0| return 0; 3148| 5.75k| } 3149| 6.40k| } 3150| 25| if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) || ------------------ | | 201| 50|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 25, False: 0] | | ------------------ ------------------ if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) || ------------------ | | 736| 25|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 25|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 25|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (3150:37): [True: 0, False: 25] ------------------ 3151| 25| (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc))) ------------------ | | 201| 50|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 25, False: 0] | | ------------------ ------------------ (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc))) ------------------ | | 736| 25|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 25|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 25|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (3151:37): [True: 25, False: 0] ------------------ 3152| 25| return 1; 3153| 0| return 0; 3154| 25| } 3155| 0| break; 3156| | 3157| 49| case ND_STRING: ------------------ | Branch (3157:7): [True: 49, False: 25] ------------------ 3158| 49| goto swap; 3159| 0| break; 3160| | 3161| 0| default: ------------------ | Branch (3161:7): [True: 0, False: 74] ------------------ 3162| 0| break; 3163| 74| } 3164| 74| } 3165| 0| break; 3166| | 3167| 49| case ND_STRING: ------------------ | Branch (3167:3): [True: 49, False: 74] ------------------ 3168| 49| { 3169| 49| StrNode* xs = STR_(x); ------------------ | | 287| 49|#define STR_(node) (&((node)->u.str)) ------------------ 3170| | 3171| 49| if (ND_STRING_LEN(x) == 0) ------------------ | | 312| 49|#define ND_STRING_LEN(node) (int )((node)->u.str.end - (node)->u.str.s) ------------------ | Branch (3171:11): [True: 0, False: 49] ------------------ 3172| 0| break; 3173| | 3174| 49| switch (ytype) { 3175| 0| case ND_CTYPE: ------------------ | Branch (3175:7): [True: 0, False: 49] ------------------ 3176| 0| switch (CTYPE_(y)->ctype) { ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 3177| 0| case CTYPE_ANYCHAR: ------------------ | | 301| 0|#define CTYPE_ANYCHAR -1 ------------------ | Branch (3177:9): [True: 0, False: 0] ------------------ 3178| 0| break; 3179| | 3180| 0| case ONIGENC_CTYPE_WORD: ------------------ | Branch (3180:9): [True: 0, False: 0] ------------------ 3181| 0| if (CTYPE_(y)->ascii_mode == 0) { ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (3181:15): [True: 0, False: 0] ------------------ 3182| 0| if (ONIGENC_IS_MBC_WORD(reg->enc, xs->s, xs->end)) ------------------ | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3183| 0| return CTYPE_(y)->not; ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 3184| 0| else 3185| 0| return !(CTYPE_(y)->not); ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 3186| 0| } 3187| 0| else { 3188| 0| if (ONIGENC_IS_MBC_WORD_ASCII(reg->enc, xs->s, xs->end)) ------------------ | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (260:46): [True: 0, False: 0] | | ------------------ ------------------ 3189| 0| return CTYPE_(y)->not; ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 3190| 0| else 3191| 0| return !(CTYPE_(y)->not); ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 3192| 0| } 3193| 0| break; 3194| 0| default: ------------------ | Branch (3194:9): [True: 0, False: 0] ------------------ 3195| 0| break; 3196| 0| } 3197| 0| break; 3198| | 3199| 49| case ND_CCLASS: ------------------ | Branch (3199:7): [True: 49, False: 0] ------------------ 3200| 49| { 3201| 49| CClassNode* cc = CCLASS_(y); ------------------ | | 288| 49|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 3202| | 3203| 49| code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s, ------------------ | | 284| 49|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 3204| 49| xs->s + ONIGENC_MBC_MAXLEN(reg->enc)); 3205| 49| return onig_is_code_in_cc(reg->enc, code, cc) == 0; 3206| 0| } 3207| 0| break; 3208| | 3209| 0| case ND_STRING: ------------------ | Branch (3209:7): [True: 0, False: 49] ------------------ 3210| 0| { 3211| 0| UChar *q; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3212| 0| StrNode* ys = STR_(y); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 3213| | 3214| 0| len = ND_STRING_LEN(x); ------------------ | | 312| 0|#define ND_STRING_LEN(node) (int )((node)->u.str.end - (node)->u.str.s) ------------------ 3215| 0| if (len > ND_STRING_LEN(y)) len = ND_STRING_LEN(y); ------------------ | | 312| 0|#define ND_STRING_LEN(node) (int )((node)->u.str.end - (node)->u.str.s) ------------------ if (len > ND_STRING_LEN(y)) len = ND_STRING_LEN(y); ------------------ | | 312| 0|#define ND_STRING_LEN(node) (int )((node)->u.str.end - (node)->u.str.s) ------------------ | Branch (3215:15): [True: 0, False: 0] ------------------ 3216| | 3217| 0| for (i = 0, p = ys->s, q = xs->s; i < len; i++, p++, q++) { ------------------ | Branch (3217:45): [True: 0, False: 0] ------------------ 3218| 0| if (*p != *q) return 1; ------------------ | Branch (3218:17): [True: 0, False: 0] ------------------ 3219| 0| } 3220| 0| } 3221| 0| break; 3222| | 3223| 0| default: ------------------ | Branch (3223:7): [True: 0, False: 49] ------------------ 3224| 0| break; 3225| 49| } 3226| 49| } 3227| 0| break; 3228| | 3229| 0| default: ------------------ | Branch (3229:3): [True: 0, False: 123] ------------------ 3230| 0| break; 3231| 123| } 3232| | 3233| 0| return 0; 3234| 123|} regcomp.c:node_swap: 358| 2.43k|{ 359| 2.43k| Node c; 360| | 361| 2.43k| c = *a; *a = *b; *b = c; 362| | 363| 2.43k| if (ND_TYPE(a) == ND_STRING) { ------------------ | | 284| 2.43k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (363:7): [True: 0, False: 2.43k] ------------------ 364| 0| StrNode* sn = STR_(a); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 365| 0| if (sn->capacity == 0) { ------------------ | Branch (365:9): [True: 0, False: 0] ------------------ 366| 0| int len = (int )(sn->end - sn->s); 367| 0| sn->s = sn->buf; 368| 0| sn->end = sn->s + len; 369| 0| } 370| 0| } 371| | 372| 2.43k| if (ND_TYPE(b) == ND_STRING) { ------------------ | | 284| 2.43k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (372:7): [True: 2.35k, False: 74] ------------------ 373| 2.35k| StrNode* sn = STR_(b); ------------------ | | 287| 2.35k|#define STR_(node) (&((node)->u.str)) ------------------ 374| 2.35k| if (sn->capacity == 0) { ------------------ | Branch (374:9): [True: 2.35k, False: 0] ------------------ 375| 2.35k| int len = (int )(sn->end - sn->s); 376| 2.35k| sn->s = sn->buf; 377| 2.35k| sn->end = sn->s + len; 378| 2.35k| } 379| 2.35k| } 380| 2.43k|} regcomp.c:unravel_case_fold_string: 4964| 2.35k|{ 4965| 2.35k| int r, n, in_look_behind; 4966| 2.35k| OnigLen min_len, max_len, one_len; 4967| 2.35k| UChar *start, *end, *p, *q; ------------------ | | 80| 2.35k|#define UChar OnigUChar ------------------ 4968| 2.35k| StrNode* snode; 4969| 2.35k| Node *sn, *list; 4970| 2.35k| OnigEncoding enc; 4971| 2.35k| OnigCaseFoldCodeItem items[ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM]; 4972| | 4973| 2.35k| if (ND_STRING_IS_CASE_EXPANDED(node)) return 0; ------------------ | | 319| 2.35k| (((node)->u.str.flag & ND_STRING_CASE_EXPANDED) != 0) | | ------------------ | | | | 310| 2.35k|#define ND_STRING_CASE_EXPANDED (1<<1) | | ------------------ | | | Branch (319:3): [True: 0, False: 2.35k] | | ------------------ ------------------ 4974| | 4975| 2.35k| ND_STATUS_REMOVE(node, IGNORECASE); ------------------ | | 358| 2.35k|#define ND_STATUS_REMOVE(node,f) (ND_STATUS(node) &= ~(ND_ST_ ## f)) | | ------------------ | | | | 356| 2.35k|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_REMOVE(node,f) (ND_STATUS(node) &= ~(ND_ST_ ## f)) | | ------------------ | | | | 346| 2.35k|#define ND_ST_IGNORECASE (1<<21) | | ------------------ ------------------ 4976| 2.35k| snode = STR_(node); ------------------ | | 287| 2.35k|#define STR_(node) (&((node)->u.str)) ------------------ 4977| 2.35k| start = snode->s; 4978| 2.35k| end = snode->end; 4979| 2.35k| if (start >= end) return 0; ------------------ | Branch (4979:7): [True: 0, False: 2.35k] ------------------ 4980| | 4981| 2.35k| in_look_behind = (state & IN_LOOK_BEHIND) != 0; ------------------ | | 4488| 2.35k|#define IN_LOOK_BEHIND (1<<7) ------------------ 4982| 2.35k| enc = reg->enc; 4983| | 4984| 2.35k| list = sn = NULL_NODE; ------------------ | | 266| 2.35k|#define NULL_NODE ((Node* )0) ------------------ 4985| 2.35k| p = start; 4986| 5.16k| while (p < end) { ------------------ | Branch (4986:10): [True: 2.80k, False: 2.35k] ------------------ 4987| 2.80k| n = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, reg->case_fold_flag, p, end, ------------------ | | 275| 2.80k| (enc)->get_case_fold_codes_by_str(case_fold_flag,p,end,acs) ------------------ 4988| 2.80k| items); 4989| 2.80k| if (n < 0) { ------------------ | Branch (4989:9): [True: 0, False: 2.80k] ------------------ 4990| 0| r = n; 4991| 0| goto err; 4992| 0| } 4993| | 4994| 2.80k| one_len = (OnigLen )enclen(enc, p); ------------------ | | 83| 2.80k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 2.80k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 4995| 2.80k| if (n == 0) { ------------------ | Branch (4995:9): [True: 112, False: 2.69k] ------------------ 4996| 112| q = p + one_len; 4997| 112| if (q > end) q = end; ------------------ | Branch (4997:11): [True: 0, False: 112] ------------------ 4998| 112| r = unravel_cf_string_add(&list, &sn, p, q, 0 /* flag */); 4999| 112| if (r != 0) goto err; ------------------ | Branch (4999:11): [True: 0, False: 112] ------------------ 5000| 112| } 5001| 2.69k| else { 5002| 2.69k| if (in_look_behind != 0) { ------------------ | Branch (5002:11): [True: 0, False: 2.69k] ------------------ 5003| 0| q = p + one_len; 5004| 0| if (items[0].byte_len != one_len) { ------------------ | Branch (5004:13): [True: 0, False: 0] ------------------ 5005| 0| r = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, reg->case_fold_flag, p, q, ------------------ | | 275| 0| (enc)->get_case_fold_codes_by_str(case_fold_flag,p,end,acs) ------------------ 5006| 0| items); 5007| 0| if (r < 0) goto err; ------------------ | Branch (5007:15): [True: 0, False: 0] ------------------ 5008| 0| n = r; 5009| 0| } 5010| 0| r = unravel_cf_look_behind_add(&list, &sn, n, items, enc, p, one_len); 5011| 0| if (r != 0) goto err; ------------------ | Branch (5011:13): [True: 0, False: 0] ------------------ 5012| 0| } 5013| 2.69k| else { 5014| 2.69k| get_min_max_byte_len_case_fold_items(n, items, &min_len, &max_len); 5015| 2.69k| if (min_len != max_len) { ------------------ | Branch (5015:13): [True: 0, False: 2.69k] ------------------ 5016| 0| r = ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 5017| 0| goto err; 5018| 0| } 5019| | 5020| 2.69k| q = p + max_len; 5021| 2.69k| r = unravel_cf_string_alt_or_cc_add(&list, n, items, enc, 5022| 2.69k| reg->case_fold_flag, p, q); 5023| 2.69k| if (r != 0) goto err; ------------------ | Branch (5023:13): [True: 0, False: 2.69k] ------------------ 5024| 2.69k| sn = NULL_NODE; ------------------ | | 266| 2.69k|#define NULL_NODE ((Node* )0) ------------------ 5025| 2.69k| } 5026| 2.69k| } 5027| | 5028| 2.80k| p = q; 5029| 2.80k| } 5030| | 5031| 2.35k| if (IS_NOT_NULL(list)) { ------------------ | | 202| 2.35k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 2.35k, False: 0] | | ------------------ ------------------ 5032| 2.35k| if (node_list_len(list) == 1) { ------------------ | Branch (5032:9): [True: 2.18k, False: 169] ------------------ 5033| 2.18k| node_swap(node, ND_CAR(list)); ------------------ | | 298| 2.18k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 2.18k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 5034| 2.18k| } 5035| 169| else { 5036| 169| node_swap(node, list); 5037| 169| } 5038| 2.35k| onig_node_free(list); 5039| 2.35k| } 5040| 0| else { 5041| 0| node_swap(node, sn); 5042| 0| onig_node_free(sn); 5043| 0| } 5044| 2.35k| return 0; 5045| | 5046| 0| err: 5047| 0| if (IS_NOT_NULL(list)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 5048| 0| onig_node_free(list); 5049| 0| else if (IS_NOT_NULL(sn)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 5050| 0| onig_node_free(sn); 5051| | 5052| 0| return r; 5053| 2.35k|} regcomp.c:unravel_cf_string_add: 4834| 112|{ 4835| 112| int r; 4836| 112| Node *sn, *list; 4837| | 4838| 112| list = *rlist; 4839| 112| sn = *rsn; 4840| | 4841| 112| if (IS_NOT_NULL(sn) && STR_(sn)->flag == flag) { ------------------ | | 202| 224|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 112] | | ------------------ ------------------ if (IS_NOT_NULL(sn) && STR_(sn)->flag == flag) { ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ | Branch (4841:26): [True: 0, False: 0] ------------------ 4842| 0| r = onig_node_str_cat(sn, s, end); 4843| 0| } 4844| 112| else { 4845| 112| sn = onig_node_new_str(s, end); 4846| 112| CHECK_NULL_RETURN_MEMERR(sn); ------------------ | | 204| 112|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 112|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 112] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 4847| | 4848| 112| STR_(sn)->flag = flag; ------------------ | | 287| 112|#define STR_(node) (&((node)->u.str)) ------------------ 4849| 112| r = unravel_cf_node_add(&list, sn); 4850| 112| } 4851| | 4852| 112| if (r == 0) { ------------------ | Branch (4852:7): [True: 112, False: 0] ------------------ 4853| 112| *rlist = list; 4854| 112| *rsn = sn; 4855| 112| } 4856| 112| return r; 4857| 112|} regcomp.c:unravel_cf_node_add: 4814| 2.80k|{ 4815| 2.80k| Node *list; 4816| | 4817| 2.80k| list = *rlist; 4818| 2.80k| if (IS_NULL(list)) { ------------------ | | 201| 2.80k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 2.35k, False: 450] | | ------------------ ------------------ 4819| 2.35k| list = onig_node_new_list(add, NULL); 4820| 2.35k| CHECK_NULL_RETURN_MEMERR(list); ------------------ | | 204| 2.35k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 2.35k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 2.35k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 4821| 2.35k| *rlist = list; 4822| 2.35k| } 4823| 450| else { 4824| 450| Node* r = node_list_add(list, add); 4825| 450| CHECK_NULL_RETURN_MEMERR(r); ------------------ | | 204| 450|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 450|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 450] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 4826| 450| } 4827| | 4828| 2.80k| return 0; 4829| 2.80k|} regcomp.c:node_list_add: 398| 450|{ 399| 450| Node *n; 400| | 401| 450| n = onig_node_new_list(x, NULL); 402| 450| if (IS_NULL(n)) return NULL_NODE; ------------------ | | 201| 450|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 450] | | ------------------ ------------------ if (IS_NULL(n)) return NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 403| | 404| 450| if (IS_NOT_NULL(list)) { ------------------ | | 202| 450|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 450, False: 0] | | ------------------ ------------------ 405| 843| while (IS_NOT_NULL(ND_CDR(list))) ------------------ | | 202| 843|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 393, False: 450] | | ------------------ ------------------ 406| 393| list = ND_CDR(list); ------------------ | | 299| 393|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 393|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 407| | 408| 450| ND_CDR(list) = n; ------------------ | | 299| 450|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 450|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 409| 450| } 410| | 411| 450| return n; 412| 450|} regcomp.c:get_min_max_byte_len_case_fold_items: 4762| 2.69k|{ 4763| 2.69k| int i; 4764| 2.69k| OnigLen len, minlen, maxlen; 4765| | 4766| 2.69k| minlen = INFINITE_LEN; ------------------ | | 218| 2.69k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 2.69k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 4767| 2.69k| maxlen = 0; 4768| 5.39k| for (i = 0; i < n; i++) { ------------------ | Branch (4768:15): [True: 2.69k, False: 2.69k] ------------------ 4769| 2.69k| OnigCaseFoldCodeItem* item = items + i; 4770| | 4771| 2.69k| len = item->byte_len; 4772| 2.69k| if (len < minlen) minlen = len; ------------------ | Branch (4772:9): [True: 2.69k, False: 0] ------------------ 4773| 2.69k| if (len > maxlen) maxlen = len; ------------------ | Branch (4773:9): [True: 2.69k, False: 0] ------------------ 4774| 2.69k| } 4775| | 4776| 2.69k| *rmin = minlen; 4777| 2.69k| *rmax = maxlen; 4778| 2.69k| return 0; 4779| 2.69k|} regcomp.c:unravel_cf_string_alt_or_cc_add: 4863| 2.69k|{ 4864| 2.69k| int r, i; 4865| 2.69k| Node* node; 4866| | 4867| 2.69k| if (is_all_code_len_1_items(n, items)) { ------------------ | Branch (4867:7): [True: 2.69k, False: 0] ------------------ 4868| 2.69k| OnigCodePoint codes[14];/* least ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM + 1 */ 4869| | 4870| 2.69k| codes[0] = ONIGENC_MBC_TO_CODE(enc, s, end); ------------------ | | 284| 2.69k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 4871| 5.39k| for (i = 0; i < n; i++) { ------------------ | Branch (4871:17): [True: 2.69k, False: 2.69k] ------------------ 4872| 2.69k| OnigCaseFoldCodeItem* item = items + i; 4873| 2.69k| codes[i+1] = item->code[0]; 4874| 2.69k| } 4875| 2.69k| r = onig_new_cclass_with_code_list(&node, enc, n + 1, codes); 4876| 2.69k| if (r != 0) return r; ------------------ | Branch (4876:9): [True: 0, False: 2.69k] ------------------ 4877| 2.69k| } 4878| 0| else { 4879| 0| Node *snode, *alt, *curr; 4880| | 4881| 0| snode = onig_node_new_str(s, end); 4882| 0| CHECK_NULL_RETURN_MEMERR(snode); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 4883| 0| node = curr = onig_node_new_alt(snode, NULL_NODE); ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 4884| 0| if (IS_NULL(curr)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 4885| 0| onig_node_free(snode); 4886| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 4887| 0| } 4888| | 4889| 0| r = 0; 4890| 0| for (i = 0; i < n; i++) { ------------------ | Branch (4890:17): [True: 0, False: 0] ------------------ 4891| 0| OnigCaseFoldCodeItem* item = items + i; 4892| 0| r = make_code_list_to_string(&snode, enc, item->code_len, item->code); 4893| 0| if (r != 0) { ------------------ | Branch (4893:11): [True: 0, False: 0] ------------------ 4894| 0| onig_node_free(node); 4895| 0| return r; 4896| 0| } 4897| | 4898| 0| alt = onig_node_new_alt(snode, NULL_NODE); ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 4899| 0| if (IS_NULL(alt)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 4900| 0| onig_node_free(snode); 4901| 0| onig_node_free(node); 4902| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 4903| 0| } 4904| | 4905| 0| ND_CDR(curr) = alt; ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 4906| 0| curr = alt; 4907| 0| } 4908| 0| } 4909| | 4910| 2.69k| r = unravel_cf_node_add(rlist, node); 4911| 2.69k| if (r != 0) onig_node_free(node); ------------------ | Branch (4911:7): [True: 0, False: 2.69k] ------------------ 4912| 2.69k| return r; 4913| 2.69k|} regcomp.c:is_all_code_len_1_items: 4748| 2.69k|{ 4749| 2.69k| int i; 4750| | 4751| 5.39k| for (i = 0; i < n; i++) { ------------------ | Branch (4751:15): [True: 2.69k, False: 2.69k] ------------------ 4752| 2.69k| OnigCaseFoldCodeItem* item = items + i; 4753| 2.69k| if (item->code_len != 1) return 0; ------------------ | Branch (4753:9): [True: 0, False: 2.69k] ------------------ 4754| 2.69k| } 4755| | 4756| 2.69k| return 1; 4757| 2.69k|} regcomp.c:node_list_len: 384| 2.35k|{ 385| 2.35k| int len; 386| | 387| 2.35k| len = 1; 388| 2.80k| while (IS_NOT_NULL(ND_CDR(list))) { ------------------ | | 202| 2.80k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 450, False: 2.35k] | | ------------------ ------------------ 389| 450| list = ND_CDR(list); ------------------ | | 299| 450|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 450|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 390| 450| len++; 391| 450| } 392| | 393| 2.35k| return len; 394| 2.35k|} regcomp.c:is_strict_real_node: 938| 213|{ 939| 213| switch (ND_TYPE(node)) { ------------------ | | 284| 213|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 940| 0| case ND_STRING: ------------------ | Branch (940:3): [True: 0, False: 213] ------------------ 941| 0| { 942| 0| StrNode* sn = STR_(node); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 943| 0| return (sn->end != sn->s); 944| 0| } 945| 0| break; 946| | 947| 123| case ND_CCLASS: ------------------ | Branch (947:3): [True: 123, False: 90] ------------------ 948| 213| case ND_CTYPE: ------------------ | Branch (948:3): [True: 90, False: 123] ------------------ 949| 213| return 1; 950| 0| break; 951| | 952| 0| default: ------------------ | Branch (952:3): [True: 0, False: 213] ------------------ 953| 0| return 0; 954| 0| break; 955| 213| } 956| 213|} regcomp.c:tune_quant: 5669| 46.3k|{ 5670| 46.3k| int r; 5671| 46.3k| QuantNode* qn = QUANT_(node); ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 5672| 46.3k| Node* body = ND_BODY(node); ------------------ | | 394| 46.3k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 5673| | 5674| 46.3k| if ((state & IN_REAL_REPEAT) != 0) { ------------------ | | 4483| 46.3k|#define IN_REAL_REPEAT (1<<2) ------------------ | Branch (5674:7): [True: 0, False: 46.3k] ------------------ 5675| 0| ND_STATUS_ADD(node, IN_REAL_REPEAT); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 335| 0|#define ND_ST_IN_REAL_REPEAT (1<<10) /* STK_REPEAT is nested in stack. */ | | ------------------ ------------------ 5676| 0| } 5677| 46.3k| if ((state & IN_MULTI_ENTRY) != 0) { ------------------ | | 4486| 46.3k|#define IN_MULTI_ENTRY (1<<5) ------------------ | Branch (5677:7): [True: 0, False: 46.3k] ------------------ 5678| 0| ND_STATUS_ADD(node, IN_MULTI_ENTRY); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 337| 0|#define ND_ST_IN_MULTI_ENTRY (1<<12) | | ------------------ ------------------ 5679| 0| } 5680| | 5681| 46.3k| if (IS_INFINITE_REPEAT(qn->upper) || qn->upper >= 1) { ------------------ | | 428| 92.7k|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 46.3k|#define INFINITE_REPEAT -1 | | ------------------ | | | Branch (428:33): [True: 46.3k, False: 56] | | ------------------ ------------------ | Branch (5681:40): [True: 56, False: 0] ------------------ 5682| 46.3k| OnigLen d = node_min_byte_len(body, env); 5683| 46.3k| if (d == 0) { ------------------ | Branch (5683:9): [True: 0, False: 46.3k] ------------------ 5684| 0|#ifdef USE_RIGID_CHECK_CAPTURES_IN_EMPTY_REPEAT 5685| 0| qn->emptiness = quantifiers_memory_node_info(body); 5686| |#else 5687| | qn->emptiness = BODY_MAY_BE_EMPTY; 5688| |#endif 5689| 0| } 5690| 46.3k| } 5691| | 5692| 46.3k| if (IS_INFINITE_REPEAT(qn->upper) || qn->upper >= 2) ------------------ | | 428| 92.7k|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 46.3k|#define INFINITE_REPEAT -1 | | ------------------ | | | Branch (428:33): [True: 46.3k, False: 56] | | ------------------ ------------------ | Branch (5692:40): [True: 0, False: 56] ------------------ 5693| 46.3k| state |= IN_REAL_REPEAT; ------------------ | | 4483| 46.3k|#define IN_REAL_REPEAT (1<<2) ------------------ 5694| 46.3k| if (qn->lower != qn->upper) ------------------ | Branch (5694:7): [True: 46.3k, False: 0] ------------------ 5695| 46.3k| state |= IN_VAR_REPEAT; ------------------ | | 4484| 46.3k|#define IN_VAR_REPEAT (1<<3) ------------------ 5696| | 5697| 46.3k| r = tune_tree(body, reg, state, env); 5698| 46.3k| if (r != 0) return r; ------------------ | Branch (5698:7): [True: 0, False: 46.3k] ------------------ 5699| | 5700| | /* expand string */ 5701| 46.3k|#define EXPAND_STRING_MAX_LENGTH 100 5702| 46.3k| if (ND_TYPE(body) == ND_STRING) { ------------------ | | 284| 46.3k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (5702:7): [True: 43.5k, False: 2.80k] ------------------ 5703| 43.5k| if (!IS_INFINITE_REPEAT(qn->lower) && qn->lower == qn->upper && ------------------ | | 428| 87.1k|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 43.5k|#define INFINITE_REPEAT -1 | | ------------------ ------------------ | Branch (5703:9): [True: 43.5k, False: 0] | Branch (5703:43): [True: 0, False: 43.5k] ------------------ 5704| 0| qn->lower > 1 && qn->lower <= EXPAND_STRING_MAX_LENGTH) { ------------------ | | 5701| 0|#define EXPAND_STRING_MAX_LENGTH 100 ------------------ | Branch (5704:9): [True: 0, False: 0] | Branch (5704:26): [True: 0, False: 0] ------------------ 5705| 0| int len = ND_STRING_LEN(body); ------------------ | | 312| 0|#define ND_STRING_LEN(node) (int )((node)->u.str.end - (node)->u.str.s) ------------------ 5706| | 5707| 0| if (len * qn->lower <= EXPAND_STRING_MAX_LENGTH) { ------------------ | | 5701| 0|#define EXPAND_STRING_MAX_LENGTH 100 ------------------ | Branch (5707:11): [True: 0, False: 0] ------------------ 5708| 0| int i, n = qn->lower; 5709| 0| node_conv_to_str_node(node, body); 5710| 0| for (i = 0; i < n; i++) { ------------------ | Branch (5710:21): [True: 0, False: 0] ------------------ 5711| 0| r = node_str_node_cat(node, body); 5712| 0| if (r != 0) return r; ------------------ | Branch (5712:15): [True: 0, False: 0] ------------------ 5713| 0| } 5714| 0| onig_node_free(body); 5715| 0| return r; 5716| 0| } 5717| 0| } 5718| 43.5k| } 5719| | 5720| 46.3k| if (qn->greedy && (qn->emptiness == BODY_IS_NOT_EMPTY)) { ------------------ | Branch (5720:7): [True: 46.3k, False: 67] | Branch (5720:21): [True: 46.3k, False: 0] ------------------ 5721| 46.3k| if (ND_TYPE(body) == ND_QUANT) { ------------------ | | 284| 46.3k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (5721:9): [True: 0, False: 46.3k] ------------------ 5722| 0| QuantNode* tqn = QUANT_(body); ------------------ | | 291| 0|#define QUANT_(node) (&((node)->u.quant)) ------------------ 5723| 0| if (IS_NOT_NULL(tqn->head_exact)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 5724| 0| qn->head_exact = tqn->head_exact; 5725| 0| tqn->head_exact = NULL; 5726| 0| } 5727| 0| } 5728| 46.3k| else { 5729| 46.3k| qn->head_exact = get_tree_head_literal(ND_BODY(node), 1, reg); ------------------ | | 394| 46.3k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 5730| 46.3k| } 5731| 46.3k| } 5732| | 5733| 46.3k| return r; 5734| 46.3k|} regcomp.c:tune_anchor: 5638| 3.11k|{ 5639| 3.11k| int r; 5640| 3.11k| AnchorNode* an = ANCHOR_(node); ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 5641| | 5642| 3.11k| switch (an->type) { 5643| 13| case ANCR_PREC_READ: ------------------ | | 456| 13|#define ANCR_PREC_READ (1<<0) ------------------ | Branch (5643:3): [True: 13, False: 3.10k] ------------------ 5644| 13| r = tune_tree(ND_ANCHOR_BODY(an), reg, (state | IN_PREC_READ), env); ------------------ | | 398| 13|#define ND_ANCHOR_BODY(node) ((node)->body) ------------------ r = tune_tree(ND_ANCHOR_BODY(an), reg, (state | IN_PREC_READ), env); ------------------ | | 4487| 13|#define IN_PREC_READ (1<<6) ------------------ 5645| 13| break; 5646| 0| case ANCR_PREC_READ_NOT: ------------------ | | 457| 0|#define ANCR_PREC_READ_NOT (1<<1) ------------------ | Branch (5646:3): [True: 0, False: 3.11k] ------------------ 5647| 0| r = tune_tree(ND_ANCHOR_BODY(an), reg, (state | IN_PREC_READ | IN_NOT), ------------------ | | 398| 0|#define ND_ANCHOR_BODY(node) ((node)->body) ------------------ r = tune_tree(ND_ANCHOR_BODY(an), reg, (state | IN_PREC_READ | IN_NOT), ------------------ | | 4487| 0|#define IN_PREC_READ (1<<6) ------------------ r = tune_tree(ND_ANCHOR_BODY(an), reg, (state | IN_PREC_READ | IN_NOT), ------------------ | | 4482| 0|#define IN_NOT (1<<1) ------------------ 5648| 0| env); 5649| 0| break; 5650| | 5651| 0| case ANCR_LOOK_BEHIND: ------------------ | | 458| 0|#define ANCR_LOOK_BEHIND (1<<2) ------------------ | Branch (5651:3): [True: 0, False: 3.11k] ------------------ 5652| 0| case ANCR_LOOK_BEHIND_NOT: ------------------ | | 459| 0|#define ANCR_LOOK_BEHIND_NOT (1<<3) ------------------ | Branch (5652:3): [True: 0, False: 3.11k] ------------------ 5653| 0| r = tune_look_behind(node, reg, state, env); 5654| 0| break; 5655| | 5656| 3.10k| default: ------------------ | Branch (5656:3): [True: 3.10k, False: 13] ------------------ 5657| 3.10k| r = 0; 5658| 3.10k| break; 5659| 3.11k| } 5660| | 5661| 3.11k| return r; 5662| 3.11k|} regcomp.c:clear_optimize_info: 7068| 46.9k|{ 7069| 46.9k| reg->optimize = OPTIMIZE_NONE; 7070| 46.9k| reg->anchor = 0; 7071| 46.9k| reg->anc_dist_min = 0; 7072| 46.9k| reg->anc_dist_max = 0; 7073| 46.9k| reg->sub_anchor = 0; 7074| 46.9k| reg->exact_end = (UChar* )NULL; 7075| 46.9k| reg->map_offset = 0; 7076| 46.9k| reg->threshold_len = 0; 7077| 46.9k| if (IS_NOT_NULL(reg->exact)) { ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ 7078| 0| xfree(reg->exact); ------------------ | | 230| 0|#define xfree free ------------------ 7079| | reg->exact = (UChar* )NULL; 7080| 0| } 7081| 46.9k|} regcomp.c:set_optimize_info_from_tree: 7010| 46.9k|{ 7011| 46.9k| int r; 7012| 46.9k| OptNode opt; 7013| 46.9k| OptEnv env; 7014| | 7015| 46.9k| env.enc = reg->enc; 7016| 46.9k| env.case_fold_flag = reg->case_fold_flag; 7017| 46.9k| env.scan_env = scan_env; 7018| 46.9k| mml_clear(&env.mm); 7019| | 7020| 46.9k| r = optimize_nodes(node, &opt, &env); 7021| 46.9k| if (r != 0) return r; ------------------ | Branch (7021:7): [True: 0, False: 46.9k] ------------------ 7022| | 7023| 46.9k| reg->anchor = opt.anc.left & (ANCR_BEGIN_BUF | ------------------ | | 461| 46.9k|#define ANCR_BEGIN_BUF (1<<4) ------------------ 7024| 46.9k| ANCR_BEGIN_POSITION | ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML | ------------------ | | 463| 46.9k|#define ANCR_BEGIN_POSITION (1<<6) ------------------ ANCR_BEGIN_POSITION | ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML | ------------------ | | 471| 46.9k|#define ANCR_ANYCHAR_INF (1<<14) ------------------ ANCR_BEGIN_POSITION | ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML | ------------------ | | 472| 46.9k|#define ANCR_ANYCHAR_INF_ML (1<<15) ------------------ 7025| 46.9k| ANCR_LOOK_BEHIND); ------------------ | | 458| 46.9k|#define ANCR_LOOK_BEHIND (1<<2) ------------------ 7026| | 7027| 46.9k| if ((opt.anc.left & (ANCR_LOOK_BEHIND | ANCR_PREC_READ_NOT)) != 0) ------------------ | | 458| 46.9k|#define ANCR_LOOK_BEHIND (1<<2) ------------------ if ((opt.anc.left & (ANCR_LOOK_BEHIND | ANCR_PREC_READ_NOT)) != 0) ------------------ | | 457| 46.9k|#define ANCR_PREC_READ_NOT (1<<1) ------------------ | Branch (7027:7): [True: 0, False: 46.9k] ------------------ 7028| 0| reg->anchor &= ~ANCR_ANYCHAR_INF_ML; ------------------ | | 472| 0|#define ANCR_ANYCHAR_INF_ML (1<<15) ------------------ 7029| | 7030| 46.9k| reg->anchor |= opt.anc.right & (ANCR_END_BUF | ANCR_SEMI_END_BUF | ------------------ | | 464| 46.9k|#define ANCR_END_BUF (1<<7) ------------------ reg->anchor |= opt.anc.right & (ANCR_END_BUF | ANCR_SEMI_END_BUF | ------------------ | | 465| 46.9k|#define ANCR_SEMI_END_BUF (1<<8) ------------------ 7031| 46.9k| ANCR_PREC_READ_NOT); ------------------ | | 457| 46.9k|#define ANCR_PREC_READ_NOT (1<<1) ------------------ 7032| | 7033| 46.9k| if (reg->anchor & (ANCR_END_BUF | ANCR_SEMI_END_BUF)) { ------------------ | | 464| 46.9k|#define ANCR_END_BUF (1<<7) ------------------ if (reg->anchor & (ANCR_END_BUF | ANCR_SEMI_END_BUF)) { ------------------ | | 465| 46.9k|#define ANCR_SEMI_END_BUF (1<<8) ------------------ | Branch (7033:7): [True: 42, False: 46.9k] ------------------ 7034| 42| reg->anc_dist_min = opt.len.min; 7035| 42| reg->anc_dist_max = opt.len.max; 7036| 42| } 7037| | 7038| 46.9k| if (opt.sb.len > 0 || opt.sm.len > 0) { ------------------ | Branch (7038:7): [True: 267, False: 46.6k] | Branch (7038:25): [True: 43.8k, False: 2.84k] ------------------ 7039| 44.1k| select_opt_exact(reg->enc, &opt.sb, &opt.sm); 7040| 44.1k| if (opt.map.value > 0 && comp_opt_exact_or_map(&opt.sb, &opt.map) > 0) { ------------------ | Branch (7040:9): [True: 44.1k, False: 0] | Branch (7040:30): [True: 51, False: 44.0k] ------------------ 7041| 51| goto set_map; 7042| 51| } 7043| 44.0k| else { 7044| 44.0k| r = set_optimize_exact(reg, &opt.sb); 7045| 44.0k| set_sub_anchor(reg, &opt.sb.anc); 7046| 44.0k| } 7047| 44.1k| } 7048| 2.84k| else if (opt.map.value > 0) { ------------------ | Branch (7048:12): [True: 2.34k, False: 506] ------------------ 7049| 2.39k| set_map: 7050| 2.39k| set_optimize_map(reg, &opt.map); 7051| 2.39k| set_sub_anchor(reg, &opt.map.anc); 7052| 2.39k| } 7053| 506| else { 7054| 506| reg->sub_anchor |= opt.anc.left & ANCR_BEGIN_LINE; ------------------ | | 462| 506|#define ANCR_BEGIN_LINE (1<<5) ------------------ 7055| 506| if (opt.len.max == 0) ------------------ | Branch (7055:9): [True: 121, False: 385] ------------------ 7056| 121| reg->sub_anchor |= opt.anc.right & ANCR_END_LINE; ------------------ | | 466| 121|#define ANCR_END_LINE (1<<9) ------------------ 7057| 506| } 7058| | 7059| |#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH) 7060| | print_optimize_info(DBGFP, reg); 7061| |#endif 7062| 46.9k| return r; 7063| 46.9k|} regcomp.c:mml_clear: 605| 781k|{ 606| 781k| l->min = l->max = 0; 607| 781k|} regcomp.c:optimize_nodes: 6624| 183k|{ 6625| 183k| int i; 6626| 183k| int r; 6627| 183k| OptNode xo; 6628| 183k| OnigEncoding enc; 6629| | 6630| 183k| r = 0; 6631| 183k| enc = env->enc; 6632| 183k| clear_node_opt_info(opt); 6633| 183k| set_bound_node_opt_info(opt, &env->mm); 6634| | 6635| 183k| switch (ND_TYPE(node)) { ------------------ | | 284| 183k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 6636| 44.2k| case ND_LIST: ------------------ | Branch (6636:3): [True: 44.2k, False: 138k] ------------------ 6637| 44.2k| { 6638| 44.2k| OptEnv nenv; 6639| 44.2k| Node* nd = node; 6640| | 6641| 44.2k| copy_opt_env(&nenv, env); 6642| 88.9k| do { 6643| 88.9k| r = optimize_nodes(ND_CAR(nd), &xo, &nenv); ------------------ | | 298| 88.9k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 88.9k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 6644| 88.9k| if (r == 0) { ------------------ | Branch (6644:13): [True: 88.9k, False: 0] ------------------ 6645| 88.9k| mml_add(&nenv.mm, &xo.len); 6646| 88.9k| concat_left_node_opt_info(enc, opt, &xo); 6647| 88.9k| } 6648| 88.9k| } while (r == 0 && IS_NOT_NULL(nd = ND_CDR(nd))); ------------------ | | 202| 88.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.7k, False: 44.2k] | | ------------------ ------------------ | Branch (6648:16): [True: 88.9k, False: 0] ------------------ 6649| 44.2k| } 6650| 44.2k| break; 6651| | 6652| 0| case ND_ALT: ------------------ | Branch (6652:3): [True: 0, False: 183k] ------------------ 6653| 0| { 6654| 0| Node* nd = node; 6655| | 6656| 0| do { 6657| 0| r = optimize_nodes(ND_CAR(nd), &xo, env); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 6658| 0| if (r == 0) { ------------------ | Branch (6658:13): [True: 0, False: 0] ------------------ 6659| 0| if (nd == node) copy_node_opt_info(opt, &xo); ------------------ | Branch (6659:15): [True: 0, False: 0] ------------------ 6660| 0| else alt_merge_node_opt_info(opt, &xo, env); 6661| 0| } 6662| 0| } while ((r == 0) && IS_NOT_NULL(nd = ND_CDR(nd))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6662:16): [True: 0, False: 0] ------------------ 6663| 0| } 6664| 0| break; 6665| | 6666| 84.9k| case ND_STRING: ------------------ | Branch (6666:3): [True: 84.9k, False: 98.2k] ------------------ 6667| 84.9k| { 6668| 84.9k| StrNode* sn = STR_(node); ------------------ | | 287| 84.9k|#define STR_(node) (&((node)->u.str)) ------------------ 6669| 84.9k| int slen = (int )(sn->end - sn->s); 6670| | 6671| 84.9k| concat_opt_exact_str(&opt->sb, sn->s, sn->end, enc); 6672| 84.9k| if (slen > 0) { ------------------ | Branch (6672:11): [True: 84.8k, False: 75] ------------------ 6673| 84.8k| add_char_opt_map(&opt->map, *(sn->s), enc); 6674| 84.8k| } 6675| 84.9k| mml_set_min_max(&opt->len, slen, slen); 6676| 84.9k| } 6677| 84.9k| break; 6678| | 6679| 3.08k| case ND_CCLASS: ------------------ | Branch (6679:3): [True: 3.08k, False: 180k] ------------------ 6680| 3.08k| { 6681| 3.08k| int z; 6682| 3.08k| CClassNode* cc = CCLASS_(node); ------------------ | | 288| 3.08k|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 6683| | 6684| | /* no need to check ignore case. (set in tune_tree()) */ 6685| | 6686| 3.08k| if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) { ------------------ | | 202| 6.17k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 3.08k] | | ------------------ ------------------ if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) { ------------------ | | 736| 3.08k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 3.08k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 3.08k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 106, False: 2.98k] | | | | ------------------ | | ------------------ ------------------ 6687| 106| OnigLen min = ONIGENC_MBC_MINLEN(enc); ------------------ | | 282| 106|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 6688| 106| OnigLen max = ONIGENC_MBC_MAXLEN_DIST(enc); ------------------ | | 281| 106|#define ONIGENC_MBC_MAXLEN_DIST(enc) ONIGENC_MBC_MAXLEN(enc) | | ------------------ | | | | 280| 106|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ 6689| | 6690| 106| mml_set_min_max(&opt->len, min, max); 6691| 106| } 6692| 2.98k| else { 6693| 765k| for (i = 0; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 432| 765k|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 765k|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (6693:21): [True: 762k, False: 2.98k] ------------------ 6694| 762k| z = BITSET_AT(cc->bs, i); ------------------ | | 450| 762k|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 762k|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 762k|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ 6695| 762k| if ((z && ! IS_NCCLASS_NOT(cc)) || (! z && IS_NCCLASS_NOT(cc))) { ------------------ | | 736| 10.2k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 10.2k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 10.2k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ if ((z && ! IS_NCCLASS_NOT(cc)) || (! z && IS_NCCLASS_NOT(cc))) { ------------------ | | 736| 752k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 752k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 752k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 0, False: 752k] | | | | ------------------ | | ------------------ ------------------ | Branch (6695:16): [True: 10.2k, False: 752k] | Branch (6695:21): [True: 10.2k, False: 0] | Branch (6695:47): [True: 752k, False: 0] ------------------ 6696| 10.2k| add_char_opt_map(&opt->map, (UChar )i, enc); 6697| 10.2k| } 6698| 762k| } 6699| 2.98k| mml_set_min_max(&opt->len, 1, 1); 6700| 2.98k| } 6701| 3.08k| } 6702| 3.08k| break; 6703| | 6704| 562| case ND_CTYPE: ------------------ | Branch (6704:3): [True: 562, False: 182k] ------------------ 6705| 562| { 6706| 562| int min, max; 6707| 562| int range; 6708| | 6709| 562| max = ONIGENC_MBC_MAXLEN_DIST(enc); ------------------ | | 281| 562|#define ONIGENC_MBC_MAXLEN_DIST(enc) ONIGENC_MBC_MAXLEN(enc) | | ------------------ | | | | 280| 562|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ 6710| | 6711| 562| if (max == 1) { ------------------ | Branch (6711:11): [True: 0, False: 562] ------------------ 6712| 0| min = 1; 6713| | 6714| 0| switch (CTYPE_(node)->ctype) { ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (6714:17): [True: 0, False: 0] ------------------ 6715| 0| case CTYPE_ANYCHAR: ------------------ | | 301| 0|#define CTYPE_ANYCHAR -1 ------------------ | Branch (6715:9): [True: 0, False: 0] ------------------ 6716| 0| break; 6717| | 6718| 0| case ONIGENC_CTYPE_WORD: ------------------ | Branch (6718:9): [True: 0, False: 0] ------------------ 6719| 0| range = CTYPE_(node)->ascii_mode != 0 ? 128 : SINGLE_BYTE_SIZE; ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ range = CTYPE_(node)->ascii_mode != 0 ? 128 : SINGLE_BYTE_SIZE; ------------------ | | 432| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (6719:19): [True: 0, False: 0] ------------------ 6720| 0| if (CTYPE_(node)->not != 0) { ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (6720:15): [True: 0, False: 0] ------------------ 6721| 0| for (i = 0; i < range; i++) { ------------------ | Branch (6721:25): [True: 0, False: 0] ------------------ 6722| 0| if (! ONIGENC_IS_CODE_WORD(enc, i)) { ------------------ | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | ------------------ ------------------ | Branch (6722:19): [True: 0, False: 0] ------------------ 6723| 0| add_char_opt_map(&opt->map, (UChar )i, enc); 6724| 0| } 6725| 0| } 6726| 0| for (i = range; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 432| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (6726:29): [True: 0, False: 0] ------------------ 6727| 0| add_char_opt_map(&opt->map, (UChar )i, enc); 6728| 0| } 6729| 0| } 6730| 0| else { 6731| 0| for (i = 0; i < range; i++) { ------------------ | Branch (6731:25): [True: 0, False: 0] ------------------ 6732| 0| if (ONIGENC_IS_CODE_WORD(enc, i)) { ------------------ | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | ------------------ | | | | | Branch (290:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 6733| 0| add_char_opt_map(&opt->map, (UChar )i, enc); 6734| 0| } 6735| 0| } 6736| 0| } 6737| 0| break; 6738| 0| } 6739| 0| } 6740| 562| else { 6741| 562| min = ONIGENC_MBC_MINLEN(enc); ------------------ | | 282| 562|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 6742| 562| } 6743| 562| mml_set_min_max(&opt->len, min, max); 6744| 562| } 6745| 0| break; 6746| | 6747| 3.11k| case ND_ANCHOR: ------------------ | Branch (6747:3): [True: 3.11k, False: 180k] ------------------ 6748| 3.11k| switch (ANCHOR_(node)->type) { ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ | Branch (6748:13): [True: 3.11k, False: 0] ------------------ 6749| 3.06k| case ANCR_BEGIN_BUF: ------------------ | | 461| 3.06k|#define ANCR_BEGIN_BUF (1<<4) ------------------ | Branch (6749:5): [True: 3.06k, False: 55] ------------------ 6750| 3.06k| case ANCR_BEGIN_POSITION: ------------------ | | 463| 3.06k|#define ANCR_BEGIN_POSITION (1<<6) ------------------ | Branch (6750:5): [True: 0, False: 3.11k] ------------------ 6751| 3.06k| case ANCR_BEGIN_LINE: ------------------ | | 462| 3.06k|#define ANCR_BEGIN_LINE (1<<5) ------------------ | Branch (6751:5): [True: 0, False: 3.11k] ------------------ 6752| 3.06k| case ANCR_END_BUF: ------------------ | | 464| 3.06k|#define ANCR_END_BUF (1<<7) ------------------ | Branch (6752:5): [True: 0, False: 3.11k] ------------------ 6753| 3.10k| case ANCR_SEMI_END_BUF: ------------------ | | 465| 3.10k|#define ANCR_SEMI_END_BUF (1<<8) ------------------ | Branch (6753:5): [True: 42, False: 3.07k] ------------------ 6754| 3.10k| case ANCR_END_LINE: ------------------ | | 466| 3.10k|#define ANCR_END_LINE (1<<9) ------------------ | Branch (6754:5): [True: 0, False: 3.11k] ------------------ 6755| 3.10k| case ANCR_PREC_READ_NOT: ------------------ | | 457| 3.10k|#define ANCR_PREC_READ_NOT (1<<1) ------------------ | Branch (6755:5): [True: 0, False: 3.11k] ------------------ 6756| 3.10k| case ANCR_LOOK_BEHIND: ------------------ | | 458| 3.10k|#define ANCR_LOOK_BEHIND (1<<2) ------------------ | Branch (6756:5): [True: 0, False: 3.11k] ------------------ 6757| 3.10k| add_opt_anc_info(&opt->anc, ANCHOR_(node)->type); ------------------ | | 293| 3.10k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 6758| 3.10k| break; 6759| | 6760| 13| case ANCR_PREC_READ: ------------------ | | 456| 13|#define ANCR_PREC_READ (1<<0) ------------------ | Branch (6760:5): [True: 13, False: 3.10k] ------------------ 6761| 13| { 6762| 13| r = optimize_nodes(ND_BODY(node), &xo, env); ------------------ | | 394| 13|#define ND_BODY(node) ((node)->u.base.body) ------------------ 6763| 13| if (r == 0) { ------------------ | Branch (6763:13): [True: 13, False: 0] ------------------ 6764| 13| if (xo.sb.len > 0) ------------------ | Branch (6764:15): [True: 13, False: 0] ------------------ 6765| 13| copy_opt_exact(&opt->spr, &xo.sb); 6766| 0| else if (xo.sm.len > 0) ------------------ | Branch (6766:20): [True: 0, False: 0] ------------------ 6767| 0| copy_opt_exact(&opt->spr, &xo.sm); 6768| | 6769| 13| opt->spr.reach_end = 0; 6770| | 6771| 13| if (xo.map.value > 0) ------------------ | Branch (6771:15): [True: 13, False: 0] ------------------ 6772| 13| copy_opt_map(&opt->map, &xo.map); 6773| 13| } 6774| 13| } 6775| 13| break; 6776| | 6777| 0| case ANCR_LOOK_BEHIND_NOT: ------------------ | | 459| 0|#define ANCR_LOOK_BEHIND_NOT (1<<3) ------------------ | Branch (6777:5): [True: 0, False: 3.11k] ------------------ 6778| 0| break; 6779| 3.11k| } 6780| 3.11k| break; 6781| | 6782| 3.11k| case ND_BACKREF: ------------------ | Branch (6782:3): [True: 0, False: 183k] ------------------ 6783| 0| if (! ND_IS_CHECKER(node)) { ------------------ | | 376| 0|#define ND_IS_CHECKER(node) ((ND_STATUS(node) & ND_ST_CHECKER) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CHECKER(node) ((ND_STATUS(node) & ND_ST_CHECKER) != 0) | | ------------------ | | | | 342| 0|#define ND_ST_CHECKER (1<<17) | | ------------------ ------------------ | Branch (6783:9): [True: 0, False: 0] ------------------ 6784| 0| OnigLen min, max; 6785| | 6786| 0| min = node_min_byte_len(node, env->scan_env); 6787| 0| max = node_max_byte_len(node, env->scan_env); 6788| 0| mml_set_min_max(&opt->len, min, max); 6789| 0| } 6790| 0| break; 6791| | 6792| 0|#ifdef USE_CALL 6793| 0| case ND_CALL: ------------------ | Branch (6793:3): [True: 0, False: 183k] ------------------ 6794| 0| if (ND_IS_RECURSION(node)) ------------------ | | 364| 0|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 0|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 0] | | ------------------ ------------------ 6795| 0| mml_set_min_max(&opt->len, 0, INFINITE_LEN); ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 6796| 0| else { 6797| 0| r = optimize_nodes(ND_BODY(node), opt, env); ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 6798| 0| } 6799| 0| break; 6800| 0|#endif 6801| | 6802| 46.3k| case ND_QUANT: ------------------ | Branch (6802:3): [True: 46.3k, False: 136k] ------------------ 6803| 46.3k| { 6804| 46.3k| OnigLen min, max; 6805| 46.3k| QuantNode* qn = QUANT_(node); ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 6806| | 6807| | /* Issue #175 6808| | ex. /\g<1>{0}(?<=|())/ 6809| | 6810| | Empty and unused nodes in look-behind is removed in 6811| | tune_look_behind(). 6812| | Called group nodes are assigned to be not called if the caller side is 6813| | inside of zero-repetition. 6814| | As a result, the nodes are considered unused. 6815| | */ 6816| 46.3k| if (qn->upper == 0) { ------------------ | Branch (6816:11): [True: 0, False: 46.3k] ------------------ 6817| 0| mml_set_min_max(&opt->len, 0, 0); 6818| 0| break; 6819| 0| } 6820| | 6821| 46.3k| r = optimize_nodes(ND_BODY(node), &xo, env); ------------------ | | 394| 46.3k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 6822| 46.3k| if (r != 0) break; ------------------ | Branch (6822:11): [True: 0, False: 46.3k] ------------------ 6823| | 6824| 46.3k| if (qn->lower > 0) { ------------------ | Branch (6824:11): [True: 7.25k, False: 39.1k] ------------------ 6825| 7.25k| copy_node_opt_info(opt, &xo); 6826| 7.25k| if (xo.sb.len > 0) { ------------------ | Branch (6826:13): [True: 4.91k, False: 2.33k] ------------------ 6827| 4.91k| if (xo.sb.reach_end) { ------------------ | Branch (6827:15): [True: 4.91k, False: 0] ------------------ 6828| 4.91k| for (i = 2; i <= qn->lower && ! is_full_opt_exact(&opt->sb); i++) { ------------------ | Branch (6828:25): [True: 0, False: 4.91k] | Branch (6828:43): [True: 0, False: 0] ------------------ 6829| 0| int rc = concat_opt_exact(&opt->sb, &xo.sb, enc); 6830| 0| if (rc > 0) break; ------------------ | Branch (6830:19): [True: 0, False: 0] ------------------ 6831| 0| } 6832| 4.91k| if (i < qn->lower) opt->sb.reach_end = 0; ------------------ | Branch (6832:17): [True: 0, False: 4.91k] ------------------ 6833| 4.91k| } 6834| 4.91k| } 6835| | 6836| 7.25k| if (qn->lower != qn->upper) { ------------------ | Branch (6836:13): [True: 7.25k, False: 0] ------------------ 6837| 7.25k| opt->sb.reach_end = 0; 6838| 7.25k| opt->sm.reach_end = 0; 6839| 7.25k| } 6840| 7.25k| if (qn->lower > 1) ------------------ | Branch (6840:13): [True: 0, False: 7.25k] ------------------ 6841| 0| opt->sm.reach_end = 0; 6842| 7.25k| } 6843| | 6844| 46.3k| if (IS_INFINITE_REPEAT(qn->upper)) { ------------------ | | 428| 46.3k|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 46.3k|#define INFINITE_REPEAT -1 | | ------------------ | | | Branch (428:33): [True: 46.3k, False: 56] | | ------------------ ------------------ 6845| 46.3k| if (env->mm.max == 0 && ------------------ | Branch (6845:13): [True: 5.51k, False: 40.8k] ------------------ 6846| 5.51k| ND_IS_ANYCHAR(ND_BODY(node)) && qn->greedy != 0) { ------------------ | | 303| 51.8k| (ND_TYPE(node) == ND_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR) | | ------------------ | | | | 284| 5.51k|#define ND_TYPE(node) ((node)->u.base.node_type) | | ------------------ | | (ND_TYPE(node) == ND_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR) | | ------------------ | | | | 289| 236|#define CTYPE_(node) (&((node)->u.ctype)) | | ------------------ | | (ND_TYPE(node) == ND_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR) | | ------------------ | | | | 301| 236|#define CTYPE_ANYCHAR -1 | | ------------------ | | | Branch (303:4): [True: 236, False: 5.27k] | | | Branch (303:33): [True: 236, False: 0] | | ------------------ ------------------ | Branch (6846:45): [True: 169, False: 67] ------------------ 6847| 169| if (ND_IS_MULTILINE(ND_QUANT_BODY(qn))) ------------------ | | 385| 169|#define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 356| 169|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 347| 169|#define ND_ST_MULTILINE (1<<22) | | ------------------ | | | Branch (385:37): [True: 0, False: 169] | | ------------------ ------------------ 6848| 0| add_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF_ML); ------------------ | | 472| 0|#define ANCR_ANYCHAR_INF_ML (1<<15) ------------------ 6849| 169| else 6850| 169| add_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF); ------------------ | | 471| 169|#define ANCR_ANYCHAR_INF (1<<14) ------------------ 6851| 169| } 6852| | 6853| 46.3k| max = (xo.len.max > 0 ? INFINITE_LEN : 0); ------------------ | | 218| 46.3k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 46.3k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (6853:16): [True: 46.3k, False: 0] ------------------ 6854| 46.3k| } 6855| 56| else { 6856| 56| max = distance_multiply(xo.len.max, qn->upper); 6857| 56| } 6858| | 6859| 46.3k| min = distance_multiply(xo.len.min, qn->lower); 6860| 46.3k| mml_set_min_max(&opt->len, min, max); 6861| 46.3k| } 6862| 0| break; 6863| | 6864| 875| case ND_BAG: ------------------ | Branch (6864:3): [True: 875, False: 182k] ------------------ 6865| 875| { 6866| 875| BagNode* en = BAG_(node); ------------------ | | 292| 875|#define BAG_(node) (&((node)->u.bag)) ------------------ 6867| | 6868| 875| switch (en->type) { ------------------ | Branch (6868:15): [True: 875, False: 0] ------------------ 6869| 74| case BAG_STOP_BACKTRACK: ------------------ | Branch (6869:7): [True: 74, False: 801] ------------------ 6870| 74| case BAG_OPTION: ------------------ | Branch (6870:7): [True: 0, False: 875] ------------------ 6871| 74| r = optimize_nodes(ND_BODY(node), opt, env); ------------------ | | 394| 74|#define ND_BODY(node) ((node)->u.base.body) ------------------ 6872| 74| break; 6873| | 6874| 801| case BAG_MEMORY: ------------------ | Branch (6874:7): [True: 801, False: 74] ------------------ 6875| 801|#ifdef USE_CALL 6876| 801| en->opt_count++; 6877| 801| if (en->opt_count > MAX_ND_OPT_INFO_REF_COUNT) { ------------------ | | 6620| 801|#define MAX_ND_OPT_INFO_REF_COUNT 5 ------------------ | Branch (6877:13): [True: 0, False: 801] ------------------ 6878| 0| OnigLen min, max; 6879| | 6880| 0| min = 0; 6881| 0| max = INFINITE_LEN; ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 6882| 0| if (ND_IS_FIXED_MIN(node)) min = en->min_len; ------------------ | | 369| 0|#define ND_IS_FIXED_MIN(node) ((ND_STATUS(node) & ND_ST_FIXED_MIN) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_FIXED_MIN(node) ((ND_STATUS(node) & ND_ST_FIXED_MIN) != 0) | | ------------------ | | | | 325| 0|#define ND_ST_FIXED_MIN (1<<0) | | ------------------ | | | Branch (369:37): [True: 0, False: 0] | | ------------------ ------------------ 6883| 0| if (ND_IS_FIXED_MAX(node)) max = en->max_len; ------------------ | | 370| 0|#define ND_IS_FIXED_MAX(node) ((ND_STATUS(node) & ND_ST_FIXED_MAX) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_FIXED_MAX(node) ((ND_STATUS(node) & ND_ST_FIXED_MAX) != 0) | | ------------------ | | | | 326| 0|#define ND_ST_FIXED_MAX (1<<1) | | ------------------ | | | Branch (370:37): [True: 0, False: 0] | | ------------------ ------------------ 6884| 0| mml_set_min_max(&opt->len, min, max); 6885| 0| } 6886| 801| else 6887| 801|#endif 6888| 801| { 6889| 801| r = optimize_nodes(ND_BODY(node), opt, env); ------------------ | | 394| 801|#define ND_BODY(node) ((node)->u.base.body) ------------------ 6890| 801| if (is_set_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF_MASK)) { ------------------ | | 306| 801|#define ANCR_ANYCHAR_INF_MASK (ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML) | | ------------------ | | | | 471| 801|#define ANCR_ANYCHAR_INF (1<<14) | | ------------------ | | #define ANCR_ANYCHAR_INF_MASK (ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML) | | ------------------ | | | | 472| 801|#define ANCR_ANYCHAR_INF_ML (1<<15) | | ------------------ ------------------ | Branch (6890:17): [True: 79, False: 722] ------------------ 6891| 79| if (MEM_STATUS_AT0(env->scan_env->backrefed_mem, en->m.regnum)) ------------------ | | 367| 79| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 79|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 0, False: 79] | | | Branch (367:4): [True: 79, False: 0] | | | Branch (367:15): [True: 79, False: 0] | | ------------------ ------------------ 6892| 0| remove_opt_anc_info(&opt->anc, ANCR_ANYCHAR_INF_MASK); ------------------ | | 306| 0|#define ANCR_ANYCHAR_INF_MASK (ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML) | | ------------------ | | | | 471| 0|#define ANCR_ANYCHAR_INF (1<<14) | | ------------------ | | #define ANCR_ANYCHAR_INF_MASK (ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML) | | ------------------ | | | | 472| 0|#define ANCR_ANYCHAR_INF_ML (1<<15) | | ------------------ ------------------ 6893| 79| } 6894| 801| } 6895| 801| break; 6896| | 6897| 0| case BAG_IF_ELSE: ------------------ | Branch (6897:7): [True: 0, False: 875] ------------------ 6898| 0| { 6899| 0| OptEnv nenv; 6900| | 6901| 0| if (IS_NOT_NULL(en->te.Else)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 6902| 0| copy_opt_env(&nenv, env); 6903| 0| r = optimize_nodes(ND_BAG_BODY(en), &xo, &nenv); ------------------ | | 396| 0|#define ND_BAG_BODY(node) ((node)->body) ------------------ 6904| 0| if (r == 0) { ------------------ | Branch (6904:17): [True: 0, False: 0] ------------------ 6905| 0| mml_add(&nenv.mm, &xo.len); 6906| 0| concat_left_node_opt_info(enc, opt, &xo); 6907| 0| if (IS_NOT_NULL(en->te.Then)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 6908| 0| r = optimize_nodes(en->te.Then, &xo, &nenv); 6909| 0| if (r == 0) { ------------------ | Branch (6909:21): [True: 0, False: 0] ------------------ 6910| 0| concat_left_node_opt_info(enc, opt, &xo); 6911| 0| } 6912| 0| } 6913| | 6914| 0| r = optimize_nodes(en->te.Else, &xo, env); 6915| 0| if (r == 0) ------------------ | Branch (6915:21): [True: 0, False: 0] ------------------ 6916| 0| alt_merge_node_opt_info(opt, &xo, env); 6917| 0| } 6918| 0| } 6919| 0| } 6920| 0| break; 6921| 875| } 6922| 875| } 6923| 875| break; 6924| | 6925| 875| case ND_GIMMICK: ------------------ | Branch (6925:3): [True: 0, False: 183k] ------------------ 6926| 0| break; 6927| | 6928| 0| default: ------------------ | Branch (6928:3): [True: 0, False: 183k] ------------------ 6929| |#ifdef ONIG_DEBUG 6930| | fprintf(DBGFP, "optimize_nodes: undefined node type %d\n", ND_TYPE(node)); 6931| |#endif 6932| 0| r = ONIGERR_TYPE_BUG; ------------------ | | 571| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 6933| 0| break; 6934| 183k| } 6935| | 6936| 183k| return r; 6937| 183k|} regcomp.c:clear_node_opt_info: 6404| 183k|{ 6405| 183k| mml_clear(&opt->len); 6406| 183k| clear_opt_anc_info(&opt->anc); 6407| 183k| clear_opt_exact(&opt->sb); 6408| 183k| clear_opt_exact(&opt->sm); 6409| 183k| clear_opt_exact(&opt->spr); 6410| 183k| clear_opt_map(&opt->map); 6411| 183k|} regcomp.c:clear_opt_anc_info: 6075| 869k|{ 6076| 869k| a->left = 0; 6077| 869k| a->right = 0; 6078| 869k|} regcomp.c:clear_opt_exact: 6157| 551k|{ 6158| 551k| mml_clear(&e->mm); 6159| 551k| clear_opt_anc_info(&e->anc); 6160| 551k| e->reach_end = 0; 6161| 551k| e->len = 0; 6162| 551k| e->s[0] = '\0'; 6163| 551k|} regcomp.c:clear_opt_map: 6292| 183k|{ 6293| 183k| static const OptMap clean_info = { 6294| 183k| {0, 0}, {0, 0}, 0, 6295| 183k| { 6296| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6297| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6298| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6299| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6300| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6301| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6302| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6303| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6304| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6305| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6306| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6307| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6308| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6309| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6310| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6311| 183k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 6312| 183k| } 6313| 183k| }; 6314| | 6315| 183k| xmemcpy(map, &clean_info, sizeof(OptMap)); ------------------ | | 181| 183k|#define xmemcpy memcpy ------------------ 6316| 183k|} regcomp.c:set_bound_node_opt_info: 6396| 183k|{ 6397| 183k| mml_copy(&(opt->sb.mm), plen); 6398| 183k| mml_copy(&(opt->spr.mm), plen); 6399| 183k| mml_copy(&(opt->map.mm), plen); 6400| 183k|} regcomp.c:mml_copy: 611| 549k|{ 612| 549k| to->min = from->min; 613| 549k| to->max = from->max; 614| 549k|} regcomp.c:copy_opt_env: 6069| 44.2k|{ 6070| 44.2k| *to = *from; 6071| 44.2k|} regcomp.c:mml_add: 618| 177k|{ 619| 177k| to->min = distance_add(to->min, add->min); 620| 177k| to->max = distance_add(to->max, add->max); 621| 177k|} regcomp.c:concat_left_node_opt_info: 6421| 88.9k|{ 6422| 88.9k| int sb_reach, sm_reach; 6423| 88.9k| OptAnc tanc; 6424| | 6425| 88.9k| concat_opt_anc_info(&tanc, &to->anc, &add->anc, to->len.max, add->len.max); 6426| 88.9k| copy_opt_anc_info(&to->anc, &tanc); 6427| | 6428| 88.9k| if (add->sb.len > 0 && to->len.max == 0) { ------------------ | Branch (6428:7): [True: 45.8k, False: 43.0k] | Branch (6428:26): [True: 43.6k, False: 2.25k] ------------------ 6429| 43.6k| concat_opt_anc_info(&tanc, &to->anc, &add->sb.anc, to->len.max, add->len.max); 6430| 43.6k| copy_opt_anc_info(&add->sb.anc, &tanc); 6431| 43.6k| } 6432| | 6433| 88.9k| if (add->map.value > 0 && to->len.max == 0) { ------------------ | Branch (6433:7): [True: 46.7k, False: 42.2k] | Branch (6433:29): [True: 43.8k, False: 2.89k] ------------------ 6434| 43.8k| if (add->map.mm.max == 0) ------------------ | Branch (6434:9): [True: 43.7k, False: 112] ------------------ 6435| 43.7k| add->map.anc.left |= to->anc.left; 6436| 43.8k| } 6437| | 6438| 88.9k| sb_reach = to->sb.reach_end; 6439| 88.9k| sm_reach = to->sm.reach_end; 6440| | 6441| 88.9k| if (add->len.max != 0) ------------------ | Branch (6441:7): [True: 85.9k, False: 3.05k] ------------------ 6442| 85.9k| to->sb.reach_end = to->sm.reach_end = 0; 6443| | 6444| 88.9k| if (add->sb.len > 0) { ------------------ | Branch (6444:7): [True: 45.8k, False: 43.0k] ------------------ 6445| 45.8k| if (sb_reach) { ------------------ | Branch (6445:9): [True: 0, False: 45.8k] ------------------ 6446| 0| concat_opt_exact(&to->sb, &add->sb, enc); 6447| 0| clear_opt_exact(&add->sb); 6448| 0| } 6449| 45.8k| else if (sm_reach) { ------------------ | Branch (6449:14): [True: 1.99k, False: 43.8k] ------------------ 6450| 1.99k| concat_opt_exact(&to->sm, &add->sb, enc); 6451| 1.99k| clear_opt_exact(&add->sb); 6452| 1.99k| } 6453| 45.8k| } 6454| 88.9k| select_opt_exact(enc, &to->sm, &add->sb); 6455| 88.9k| select_opt_exact(enc, &to->sm, &add->sm); 6456| | 6457| 88.9k| if (to->spr.len > 0) { ------------------ | Branch (6457:7): [True: 0, False: 88.9k] ------------------ 6458| 0| if (add->len.max > 0) { ------------------ | Branch (6458:9): [True: 0, False: 0] ------------------ 6459| 0| if (to->spr.mm.max == 0) ------------------ | Branch (6459:11): [True: 0, False: 0] ------------------ 6460| 0| select_opt_exact(enc, &to->sb, &to->spr); 6461| 0| else 6462| 0| select_opt_exact(enc, &to->sm, &to->spr); 6463| 0| } 6464| 0| } 6465| 88.9k| else if (add->spr.len > 0) { ------------------ | Branch (6465:12): [True: 0, False: 88.9k] ------------------ 6466| 0| copy_opt_exact(&to->spr, &add->spr); 6467| 0| } 6468| | 6469| 88.9k| select_opt_map(&to->map, &add->map); 6470| 88.9k| mml_add(&to->len, &add->len); 6471| 88.9k|} regcomp.c:concat_opt_anc_info: 6089| 134k|{ 6090| 134k| clear_opt_anc_info(to); 6091| | 6092| 134k| to->left = left->left; 6093| 134k| if (left_len == 0) { ------------------ | Branch (6093:7): [True: 90.9k, False: 43.6k] ------------------ 6094| 90.9k| to->left |= right->left; 6095| 90.9k| } 6096| | 6097| 134k| to->right = right->right; 6098| 134k| if (right_len == 0) { ------------------ | Branch (6098:7): [True: 3.05k, False: 131k] ------------------ 6099| 3.05k| to->right |= left->right; 6100| 3.05k| } 6101| 131k| else { 6102| 131k| to->right |= (left->right & ANCR_PREC_READ_NOT); ------------------ | | 457| 131k|#define ANCR_PREC_READ_NOT (1<<1) ------------------ 6103| 131k| } 6104| 134k|} regcomp.c:copy_opt_anc_info: 6082| 134k|{ 6083| 134k| *to = *from; 6084| 134k|} regcomp.c:select_opt_map: 6335| 88.9k|{ 6336| 88.9k| static int z = 1<<15; /* 32768: something big value */ 6337| | 6338| 88.9k| int vn, va; 6339| | 6340| 88.9k| if (alt->value == 0) return ; ------------------ | Branch (6340:7): [True: 42.2k, False: 46.7k] ------------------ 6341| 46.7k| if (now->value == 0) { ------------------ | Branch (6341:7): [True: 44.1k, False: 2.59k] ------------------ 6342| 44.1k| copy_opt_map(now, alt); 6343| 44.1k| return ; 6344| 44.1k| } 6345| | 6346| 2.59k| vn = z / now->value; 6347| 2.59k| va = z / alt->value; 6348| 2.59k| if (comp_distance_value(&now->mm, &alt->mm, vn, va) > 0) ------------------ | Branch (6348:7): [True: 0, False: 2.59k] ------------------ 6349| 0| copy_opt_map(now, alt); 6350| 2.59k|} regcomp.c:comp_distance_value: 6052| 46.7k|{ 6053| 46.7k| if (v2 <= 0) return -1; ------------------ | Branch (6053:7): [True: 0, False: 46.7k] ------------------ 6054| 46.7k| if (v1 <= 0) return 1; ------------------ | Branch (6054:7): [True: 0, False: 46.7k] ------------------ 6055| | 6056| 46.7k| v1 *= distance_value(d1); 6057| 46.7k| v2 *= distance_value(d2); 6058| | 6059| 46.7k| if (v2 > v1) return 1; ------------------ | Branch (6059:7): [True: 51, False: 46.7k] ------------------ 6060| 46.7k| if (v2 < v1) return -1; ------------------ | Branch (6060:7): [True: 46.1k, False: 607] ------------------ 6061| | 6062| 607| if (d2->min < d1->min) return 1; ------------------ | Branch (6062:7): [True: 0, False: 607] ------------------ 6063| 607| if (d2->min > d1->min) return -1; ------------------ | Branch (6063:7): [True: 450, False: 157] ------------------ 6064| 157| return 0; 6065| 607|} regcomp.c:distance_value: 6023| 93.5k|{ 6024| | /* 1000 / (min-max-dist + 1) */ 6025| 93.5k| static const short int dist_vals[] = { 6026| 93.5k| 1000, 500, 333, 250, 200, 167, 143, 125, 111, 100, 6027| 93.5k| 91, 83, 77, 71, 67, 63, 59, 56, 53, 50, 6028| 93.5k| 48, 45, 43, 42, 40, 38, 37, 36, 34, 33, 6029| 93.5k| 32, 31, 30, 29, 29, 28, 27, 26, 26, 25, 6030| 93.5k| 24, 24, 23, 23, 22, 22, 21, 21, 20, 20, 6031| 93.5k| 20, 19, 19, 19, 18, 18, 18, 17, 17, 17, 6032| 93.5k| 16, 16, 16, 16, 15, 15, 15, 15, 14, 14, 6033| 93.5k| 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 6034| 93.5k| 12, 12, 12, 12, 12, 12, 11, 11, 11, 11, 6035| 93.5k| 11, 11, 11, 11, 11, 10, 10, 10, 10, 10 6036| 93.5k| }; 6037| | 6038| 93.5k| OnigLen d; 6039| | 6040| 93.5k| if (mm->max == INFINITE_LEN) return 0; ------------------ | | 218| 93.5k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 93.5k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (6040:7): [True: 461, False: 93.0k] ------------------ 6041| | 6042| 93.0k| d = mm->max - mm->min; 6043| 93.0k| if (d < (OnigLen )(sizeof(dist_vals)/sizeof(dist_vals[0]))) ------------------ | Branch (6043:7): [True: 93.0k, False: 0] ------------------ 6044| | /* return dist_vals[d] * 16 / (mm->min + 12); */ 6045| 93.0k| return (int )dist_vals[d]; 6046| 0| else 6047| 0| return 1; 6048| 93.0k|} regcomp.c:copy_node_opt_info: 6415| 7.25k|{ 6416| 7.25k| *to = *from; 6417| 7.25k|} regcomp.c:map_position_value: 5999| 95.1k|{ 6000| 95.1k| static const short int Vals[] = { 6001| 95.1k| 5, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 1, 1, 10, 1, 1, 6002| 95.1k| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6003| 95.1k| 12, 4, 7, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6004| 95.1k| 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 6005| 95.1k| 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6006| 95.1k| 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 5, 5, 5, 6007| 95.1k| 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6008| 95.1k| 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 1 6009| 95.1k| }; 6010| | 6011| 95.1k| if (i < (int )(sizeof(Vals)/sizeof(Vals[0]))) { ------------------ | Branch (6011:7): [True: 95.1k, False: 19] ------------------ 6012| 95.1k| if (i == 0 && ONIGENC_MBC_MINLEN(enc) > 1) ------------------ | | 282| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (6012:9): [True: 0, False: 95.1k] | Branch (6012:19): [True: 0, False: 0] ------------------ 6013| 0| return 20; 6014| 95.1k| else 6015| 95.1k| return (int )Vals[i]; 6016| 95.1k| } 6017| 19| else 6018| 19| return 4; /* Take it easy. */ 6019| 95.1k|} regcomp.c:concat_opt_exact_str: 6205| 84.9k|{ 6206| 84.9k| int i, j, len; 6207| 84.9k| UChar *p; ------------------ | | 80| 84.9k|#define UChar OnigUChar ------------------ 6208| | 6209| 170k| for (i = to->len, p = s; p < end && i < OPT_EXACT_MAXLEN; ) { ------------------ | | 5952| 85.1k|#define OPT_EXACT_MAXLEN 24 ------------------ | Branch (6209:28): [True: 85.1k, False: 84.9k] | Branch (6209:39): [True: 85.1k, False: 0] ------------------ 6210| 85.1k| len = enclen(enc, p); ------------------ | | 83| 85.1k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 85.1k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 6211| 85.1k| if (i + len > OPT_EXACT_MAXLEN) break; ------------------ | | 5952| 85.1k|#define OPT_EXACT_MAXLEN 24 ------------------ | Branch (6211:9): [True: 0, False: 85.1k] ------------------ 6212| 170k| for (j = 0; j < len && p < end; j++) { ------------------ | Branch (6212:17): [True: 85.1k, False: 85.1k] | Branch (6212:28): [True: 85.1k, False: 0] ------------------ 6213| | /* coverity[overrun-local] */ 6214| 85.1k| to->s[i++] = *p++; 6215| 85.1k| } 6216| 85.1k| } 6217| | 6218| 84.9k| to->len = i; 6219| | 6220| 84.9k| if (p >= end) ------------------ | Branch (6220:7): [True: 84.9k, False: 0] ------------------ 6221| 84.9k| to->reach_end = 1; 6222| 84.9k|} regcomp.c:add_char_opt_map: 6326| 95.0k|{ 6327| 95.0k| if (m->map[c] == 0) { ------------------ | Branch (6327:7): [True: 95.0k, False: 0] ------------------ 6328| 95.0k| m->map[c] = 1; 6329| 95.0k| m->value += map_position_value(enc, c); 6330| 95.0k| } 6331| 95.0k|} regcomp.c:mml_set_min_max: 598| 134k|{ 599| 134k| l->min = min; 600| 134k| l->max = max; 601| 134k|} regcomp.c:add_opt_anc_info: 6126| 3.27k|{ 6127| 3.27k| if (is_left(anc)) ------------------ | Branch (6127:7): [True: 3.23k, False: 42] ------------------ 6128| 3.23k| to->left |= anc; 6129| 42| else 6130| 42| to->right |= anc; 6131| 3.27k|} regcomp.c:is_left: 6108| 3.27k|{ 6109| 3.27k| if (a == ANCR_END_BUF || a == ANCR_SEMI_END_BUF || ------------------ | | 464| 6.54k|#define ANCR_END_BUF (1<<7) ------------------ if (a == ANCR_END_BUF || a == ANCR_SEMI_END_BUF || ------------------ | | 465| 6.54k|#define ANCR_SEMI_END_BUF (1<<8) ------------------ | Branch (6109:7): [True: 0, False: 3.27k] | Branch (6109:29): [True: 42, False: 3.23k] ------------------ 6110| 3.23k| a == ANCR_END_LINE || a == ANCR_PREC_READ || a == ANCR_PREC_READ_NOT) ------------------ | | 466| 6.50k|#define ANCR_END_LINE (1<<9) ------------------ a == ANCR_END_LINE || a == ANCR_PREC_READ || a == ANCR_PREC_READ_NOT) ------------------ | | 456| 6.50k|#define ANCR_PREC_READ (1<<0) ------------------ a == ANCR_END_LINE || a == ANCR_PREC_READ || a == ANCR_PREC_READ_NOT) ------------------ | | 457| 3.23k|#define ANCR_PREC_READ_NOT (1<<1) ------------------ | Branch (6110:7): [True: 0, False: 3.23k] | Branch (6110:29): [True: 0, False: 3.23k] | Branch (6110:52): [True: 0, False: 3.23k] ------------------ 6111| 42| return 0; 6112| | 6113| 3.23k| return 1; 6114| 3.27k|} regcomp.c:copy_opt_exact: 6167| 87.8k|{ 6168| 87.8k| *to = *from; 6169| 87.8k|} regcomp.c:copy_opt_map: 6320| 44.1k|{ 6321| 44.1k| *to = *from; 6322| 44.1k|} regcomp.c:concat_opt_exact: 6173| 1.99k|{ 6174| 1.99k| int i, j, len, r; 6175| 1.99k| UChar *p, *end; ------------------ | | 80| 1.99k|#define UChar OnigUChar ------------------ 6176| 1.99k| OptAnc tanc; 6177| | 6178| 1.99k| r = 0; 6179| 1.99k| p = add->s; 6180| 1.99k| end = p + add->len; 6181| 3.98k| for (i = to->len; p < end; ) { ------------------ | Branch (6181:21): [True: 1.99k, False: 1.99k] ------------------ 6182| 1.99k| len = enclen(enc, p); ------------------ | | 83| 1.99k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 1.99k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 6183| 1.99k| if (i + len > OPT_EXACT_MAXLEN) { ------------------ | | 5952| 1.99k|#define OPT_EXACT_MAXLEN 24 ------------------ | Branch (6183:9): [True: 0, False: 1.99k] ------------------ 6184| 0| r = 1; /* 1:full */ 6185| 0| break; 6186| 0| } 6187| 3.98k| for (j = 0; j < len && p < end; j++) { ------------------ | Branch (6187:17): [True: 1.99k, False: 1.99k] | Branch (6187:28): [True: 1.99k, False: 0] ------------------ 6188| | /* coverity[overrun-local] */ 6189| 1.99k| to->s[i++] = *p++; 6190| 1.99k| } 6191| 1.99k| } 6192| | 6193| 1.99k| to->len = i; 6194| 1.99k| to->reach_end = (p == end ? add->reach_end : 0); ------------------ | Branch (6194:20): [True: 1.99k, False: 0] ------------------ 6195| | 6196| 1.99k| concat_opt_anc_info(&tanc, &to->anc, &add->anc, 1, 1); 6197| 1.99k| if (! to->reach_end) tanc.right = 0; ------------------ | Branch (6197:7): [True: 1.99k, False: 0] ------------------ 6198| 1.99k| copy_opt_anc_info(&to->anc, &tanc); 6199| | 6200| 1.99k| return r; 6201| 1.99k|} regcomp.c:is_set_opt_anc_info: 6118| 801|{ 6119| 801| if ((to->left & anc) != 0) return 1; ------------------ | Branch (6119:7): [True: 79, False: 722] ------------------ 6120| | 6121| 722| return ((to->right & anc) != 0 ? 1 : 0); ------------------ | Branch (6121:11): [True: 0, False: 722] ------------------ 6122| 801|} regcomp.c:select_opt_exact: 6261| 222k|{ 6262| 222k| int vn, va; 6263| | 6264| 222k| vn = now->len; 6265| 222k| va = alt->len; 6266| | 6267| 222k| if (va == 0) { ------------------ | Branch (6267:7): [True: 134k, False: 87.8k] ------------------ 6268| 134k| return ; 6269| 134k| } 6270| 87.8k| else if (vn == 0) { ------------------ | Branch (6270:12): [True: 87.7k, False: 56] ------------------ 6271| 87.7k| copy_opt_exact(now, alt); 6272| 87.7k| return ; 6273| 87.7k| } 6274| 56| else if (vn <= 2 && va <= 2) { ------------------ | Branch (6274:12): [True: 56, False: 0] | Branch (6274:23): [True: 56, False: 0] ------------------ 6275| | /* ByteValTable[x] is big value --> low price */ 6276| 56| va = map_position_value(enc, now->s[0]); 6277| 56| vn = map_position_value(enc, alt->s[0]); 6278| | 6279| 56| if (now->len > 1) vn += 5; ------------------ | Branch (6279:9): [True: 0, False: 56] ------------------ 6280| 56| if (alt->len > 1) va += 5; ------------------ | Branch (6280:9): [True: 0, False: 56] ------------------ 6281| 56| } 6282| | 6283| 56| vn *= 2; 6284| 56| va *= 2; 6285| | 6286| 56| if (comp_distance_value(&now->mm, &alt->mm, vn, va) > 0) ------------------ | Branch (6286:7): [True: 0, False: 56] ------------------ 6287| 0| copy_opt_exact(now, alt); 6288| 56|} regcomp.c:comp_opt_exact_or_map: 6354| 44.1k|{ 6355| 44.1k|#define COMP_EM_BASE 20 6356| 44.1k| int ae, am; 6357| 44.1k| int case_value; 6358| | 6359| 44.1k| if (m->value <= 0) return -1; ------------------ | Branch (6359:7): [True: 0, False: 44.1k] ------------------ 6360| | 6361| 44.1k| case_value = 3; 6362| 44.1k| ae = COMP_EM_BASE * e->len * case_value; ------------------ | | 6355| 44.1k|#define COMP_EM_BASE 20 ------------------ 6363| 44.1k| am = COMP_EM_BASE * 5 * 2 / m->value; ------------------ | | 6355| 44.1k|#define COMP_EM_BASE 20 ------------------ 6364| 44.1k| return comp_distance_value(&e->mm, &m->mm, ae, am); 6365| 44.1k|} regcomp.c:set_optimize_exact: 6941| 44.0k|{ 6942| 44.0k| int r; 6943| 44.0k| int allow_reverse; 6944| | 6945| 44.0k| if (e->len == 0) return 0; ------------------ | Branch (6945:7): [True: 0, False: 44.0k] ------------------ 6946| | 6947| 44.0k| reg->exact = (UChar* )xmalloc(e->len); ------------------ | | 227| 44.0k|#define xmalloc malloc ------------------ 6948| 44.0k| CHECK_NULL_RETURN_MEMERR(reg->exact); ------------------ | | 204| 44.0k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 44.0k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 44.0k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6949| 44.0k| xmemcpy(reg->exact, e->s, e->len); ------------------ | | 181| 44.0k|#define xmemcpy memcpy ------------------ 6950| 44.0k| reg->exact_end = reg->exact + e->len; 6951| | 6952| 44.0k| allow_reverse = 6953| 44.0k| ONIGENC_IS_ALLOWED_REVERSE_MATCH(reg->enc, reg->exact, reg->exact_end); ------------------ | | 267| 44.0k| (enc)->is_allowed_reverse_match(s,end) ------------------ 6954| | 6955| 44.0k| if (e->len >= 2 || (e->len >= 1 && allow_reverse)) { ------------------ | Branch (6955:7): [True: 2.25k, False: 41.8k] | Branch (6955:23): [True: 41.8k, False: 0] | Branch (6955:38): [True: 41.8k, False: 0] ------------------ 6956| 44.0k| r = set_sunday_quick_search_or_bmh_skip_table(reg, 0, 6957| 44.0k| reg->exact, reg->exact_end, 6958| 44.0k| reg->map, &(reg->map_offset)); 6959| 44.0k| if (r != 0) return r; ------------------ | Branch (6959:9): [True: 0, False: 44.0k] ------------------ 6960| | 6961| 44.0k| reg->optimize = (allow_reverse != 0 ------------------ | Branch (6961:22): [True: 44.0k, False: 0] ------------------ 6962| 44.0k| ? OPTIMIZE_STR_FAST 6963| 44.0k| : OPTIMIZE_STR_FAST_STEP_FORWARD); 6964| 44.0k| } 6965| 0| else { 6966| 0| reg->optimize = OPTIMIZE_STR; 6967| 0| } 6968| | 6969| 44.0k| reg->dist_min = e->mm.min; 6970| 44.0k| reg->dist_max = e->mm.max; 6971| | 6972| 44.0k| if (reg->dist_min != INFINITE_LEN) { ------------------ | | 218| 44.0k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 44.0k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (6972:7): [True: 44.0k, False: 0] ------------------ 6973| 44.0k| int n = (int )(reg->exact_end - reg->exact); 6974| 44.0k| reg->threshold_len = reg->dist_min + n; 6975| 44.0k| } 6976| | 6977| 44.0k| return 0; 6978| 44.0k|} regcomp.c:set_sunday_quick_search_or_bmh_skip_table: 5884| 44.0k|{ 5885| 44.0k| int i, j, k, len, offset; 5886| 44.0k| int n, clen; 5887| 44.0k| UChar* p; ------------------ | | 80| 44.0k|#define UChar OnigUChar ------------------ 5888| 44.0k| OnigEncoding enc; 5889| 44.0k| OnigCaseFoldCodeItem items[ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM]; 5890| 44.0k| UChar buf[ONIGENC_MBC_CASE_FOLD_MAXLEN]; ------------------ | | 80| 44.0k|#define UChar OnigUChar ------------------ 5891| | 5892| 44.0k| enc = reg->enc; 5893| 44.0k| offset = ENC_GET_SKIP_OFFSET(enc); ------------------ | | 143| 44.0k| (((enc)->flag & ENC_FLAG_SKIP_OFFSET_MASK)>>2) | | ------------------ | | | | 134| 44.0k|#define ENC_FLAG_SKIP_OFFSET_MASK (7<<2) | | ------------------ ------------------ 5894| 44.0k| if (offset == ENC_SKIP_OFFSET_1_OR_0) { ------------------ | | 130| 44.0k|#define ENC_SKIP_OFFSET_1_OR_0 7 ------------------ | Branch (5894:7): [True: 44.0k, False: 0] ------------------ 5895| 44.0k| UChar* p = s; ------------------ | | 80| 44.0k|#define UChar OnigUChar ------------------ 5896| 46.3k| while (1) { ------------------ | Branch (5896:12): [True: 46.3k, Folded] ------------------ 5897| 46.3k| len = enclen(enc, p); ------------------ | | 83| 46.3k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 46.3k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5898| 46.3k| if (p + len >= end) { ------------------ | Branch (5898:11): [True: 44.0k, False: 2.25k] ------------------ 5899| 44.0k| if (len == 1) offset = 1; ------------------ | Branch (5899:13): [True: 44.0k, False: 19] ------------------ 5900| 19| else offset = 0; 5901| 44.0k| break; 5902| 44.0k| } 5903| 2.25k| p += len; 5904| 2.25k| } 5905| 44.0k| } 5906| | 5907| 44.0k| len = (int )(end - s); 5908| 44.0k| if (len + offset >= UCHAR_MAX) ------------------ | Branch (5908:7): [True: 0, False: 44.0k] ------------------ 5909| 0| return ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 5910| | 5911| 44.0k| *roffset = offset; 5912| | 5913| 11.3M| for (i = 0; i < CHAR_MAP_SIZE; i++) { ------------------ | | 217| 11.3M|#define CHAR_MAP_SIZE 256 ------------------ | Branch (5913:15): [True: 11.2M, False: 44.0k] ------------------ 5914| 11.2M| skip[i] = (UChar )(len + offset); 5915| 11.2M| } 5916| | 5917| 90.3k| for (p = s; p < end; ) { ------------------ | Branch (5917:15): [True: 46.3k, False: 44.0k] ------------------ 5918| 46.3k| int z; 5919| | 5920| 46.3k| clen = enclen(enc, p); ------------------ | | 83| 46.3k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 46.3k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5921| 46.3k| if (p + clen > end) clen = (int )(end - p); ------------------ | Branch (5921:9): [True: 0, False: 46.3k] ------------------ 5922| | 5923| 46.3k| len = (int )(end - p); 5924| 92.6k| for (j = 0; j < clen; j++) { ------------------ | Branch (5924:17): [True: 46.3k, False: 46.2k] ------------------ 5925| 46.3k| z = len - j + (offset - 1); 5926| 46.3k| if (z <= 0) break; ------------------ | Branch (5926:11): [True: 19, False: 46.3k] ------------------ 5927| 46.3k| skip[p[j]] = z; 5928| 46.3k| } 5929| | 5930| 46.3k| if (case_expand != 0) { ------------------ | Branch (5930:9): [True: 0, False: 46.3k] ------------------ 5931| 0| n = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, reg->case_fold_flag, ------------------ | | 275| 0| (enc)->get_case_fold_codes_by_str(case_fold_flag,p,end,acs) ------------------ 5932| 0| p, end, items); 5933| 0| for (k = 0; k < n; k++) { ------------------ | Branch (5933:19): [True: 0, False: 0] ------------------ 5934| 0| ONIGENC_CODE_TO_MBC(enc, items[k].code[0], buf); ------------------ | | 286| 0|#define ONIGENC_CODE_TO_MBC(enc,code,buf) (enc)->code_to_mbc(code,buf) ------------------ 5935| 0| for (j = 0; j < clen; j++) { ------------------ | Branch (5935:21): [True: 0, False: 0] ------------------ 5936| 0| z = len - j + (offset - 1); 5937| 0| if (z <= 0) break; ------------------ | Branch (5937:15): [True: 0, False: 0] ------------------ 5938| 0| if (skip[buf[j]] > z) ------------------ | Branch (5938:15): [True: 0, False: 0] ------------------ 5939| 0| skip[buf[j]] = z; 5940| 0| } 5941| 0| } 5942| 0| } 5943| | 5944| 46.3k| p += clen; 5945| 46.3k| } 5946| | 5947| 44.0k| return 0; 5948| 44.0k|} regcomp.c:set_sub_anchor: 6999| 46.4k|{ 7000| 46.4k| reg->sub_anchor |= anc->left & ANCR_BEGIN_LINE; ------------------ | | 462| 46.4k|#define ANCR_BEGIN_LINE (1<<5) ------------------ 7001| 46.4k| reg->sub_anchor |= anc->right & ANCR_END_LINE; ------------------ | | 466| 46.4k|#define ANCR_END_LINE (1<<9) ------------------ 7002| 46.4k|} regcomp.c:set_optimize_map: 6982| 2.39k|{ 6983| 2.39k| int i; 6984| | 6985| 614k| for (i = 0; i < CHAR_MAP_SIZE; i++) ------------------ | | 217| 614k|#define CHAR_MAP_SIZE 256 ------------------ | Branch (6985:15): [True: 612k, False: 2.39k] ------------------ 6986| 612k| reg->map[i] = m->map[i]; 6987| | 6988| 2.39k| reg->optimize = OPTIMIZE_MAP; 6989| 2.39k| reg->dist_min = m->mm.min; 6990| 2.39k| reg->dist_max = m->mm.max; 6991| | 6992| 2.39k| if (reg->dist_min != INFINITE_LEN) { ------------------ | | 218| 2.39k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 2.39k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (6992:7): [True: 2.39k, False: 0] ------------------ 6993| 2.39k| reg->threshold_len = reg->dist_min + ONIGENC_MBC_MINLEN(reg->enc); ------------------ | | 282| 2.39k|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 6994| 2.39k| } 6995| 2.39k|} regcomp.c:compile_tree: 2559| 190k|{ 2560| 190k| int n, len, pos, r = 0; 2561| | 2562| 190k| switch (ND_TYPE(node)) { ------------------ | | 284| 190k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 2563| 44.2k| case ND_LIST: ------------------ | Branch (2563:3): [True: 44.2k, False: 145k] ------------------ 2564| 88.9k| do { 2565| 88.9k| r = compile_tree(ND_CAR(node), reg, env); ------------------ | | 298| 88.9k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 88.9k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2566| 88.9k| } while (r == 0 && IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 88.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.7k, False: 44.2k] | | ------------------ ------------------ | Branch (2566:14): [True: 88.9k, False: 0] ------------------ 2567| 44.2k| break; 2568| | 2569| 0| case ND_ALT: ------------------ | Branch (2569:3): [True: 0, False: 190k] ------------------ 2570| 0| { 2571| 0| Node* x = node; 2572| 0| len = 0; 2573| 0| do { 2574| 0| len += compile_length_tree(ND_CAR(x), reg, env); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2575| 0| if (IS_NOT_NULL(ND_CDR(x))) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 2576| 0| len += OPSIZE_PUSH + OPSIZE_JUMP; ------------------ | | 648| 0|#define OPSIZE_PUSH 1 ------------------ len += OPSIZE_PUSH + OPSIZE_JUMP; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 2577| 0| } 2578| 0| } while (IS_NOT_NULL(x = ND_CDR(x))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 2579| 0| pos = COP_CURR_OFFSET(reg) + 1 + len; /* goal position */ ------------------ | | 948| 0|#define COP_CURR_OFFSET(reg) ((reg)->ops_used - 1) ------------------ 2580| | 2581| 0| do { 2582| 0| len = compile_length_tree(ND_CAR(node), reg, env); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2583| 0| if (IS_NOT_NULL(ND_CDR(node))) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 2584| 0| enum OpCode push = ND_IS_SUPER(node) ? OP_PUSH_SUPER : OP_PUSH; ------------------ | | 377| 0|#define ND_IS_SUPER(node) ((ND_STATUS(node) & ND_ST_SUPER) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_SUPER(node) ((ND_STATUS(node) & ND_ST_SUPER) != 0) | | ------------------ | | | | 344| 0|#define ND_ST_SUPER (1<<19) | | ------------------ | | | Branch (377:37): [True: 0, False: 0] | | ------------------ ------------------ 2585| 0| r = add_op(reg, push); 2586| 0| if (r != 0) break; ------------------ | Branch (2586:15): [True: 0, False: 0] ------------------ 2587| 0| COP(reg)->push.addr = SIZE_INC + len + OPSIZE_JUMP; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push.addr = SIZE_INC + len + OPSIZE_JUMP; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ COP(reg)->push.addr = SIZE_INC + len + OPSIZE_JUMP; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 2588| 0| } 2589| 0| r = compile_tree(ND_CAR(node), reg, env); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2590| 0| if (r != 0) break; ------------------ | Branch (2590:13): [True: 0, False: 0] ------------------ 2591| 0| if (IS_NOT_NULL(ND_CDR(node))) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 2592| 0| len = pos - (COP_CURR_OFFSET(reg) + 1); ------------------ | | 948| 0|#define COP_CURR_OFFSET(reg) ((reg)->ops_used - 1) ------------------ 2593| 0| r = add_op(reg, OP_JUMP); 2594| 0| if (r != 0) break; ------------------ | Branch (2594:15): [True: 0, False: 0] ------------------ 2595| 0| COP(reg)->jump.addr = len; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2596| 0| } 2597| 0| } while (IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 2598| 0| } 2599| 0| break; 2600| | 2601| 89.8k| case ND_STRING: ------------------ | Branch (2601:3): [True: 89.8k, False: 100k] ------------------ 2602| 89.8k| if (ND_STRING_IS_CRUDE(node)) ------------------ | | 317| 89.8k| (((node)->u.str.flag & ND_STRING_CRUDE) != 0) | | ------------------ | | | | 309| 89.8k|#define ND_STRING_CRUDE (1<<0) | | ------------------ | | | Branch (317:3): [True: 0, False: 89.8k] | | ------------------ ------------------ 2603| 0| r = compile_string_crude_node(STR_(node), reg); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 2604| 89.8k| else 2605| 89.8k| r = compile_string_node(node, reg); 2606| 89.8k| break; 2607| | 2608| 5.39k| case ND_CCLASS: ------------------ | Branch (2608:3): [True: 5.39k, False: 184k] ------------------ 2609| 5.39k| r = compile_cclass_node(CCLASS_(node), reg); ------------------ | | 288| 5.39k|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 2610| 5.39k| break; 2611| | 2612| 418| case ND_CTYPE: ------------------ | Branch (2612:3): [True: 418, False: 189k] ------------------ 2613| 418| { 2614| 418| int op; 2615| | 2616| 418| switch (CTYPE_(node)->ctype) { ------------------ | | 289| 418|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 2617| 418| case CTYPE_ANYCHAR: ------------------ | | 301| 418|#define CTYPE_ANYCHAR -1 ------------------ | Branch (2617:7): [True: 418, False: 0] ------------------ 2618| 418| r = add_op(reg, ND_IS_MULTILINE(node) ? OP_ANYCHAR_ML : OP_ANYCHAR); ------------------ | | 385| 418|#define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 356| 418|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 347| 418|#define ND_ST_MULTILINE (1<<22) | | ------------------ | | | Branch (385:37): [True: 0, False: 418] | | ------------------ ------------------ 2619| 418| break; 2620| | 2621| 0| case ONIGENC_CTYPE_WORD: ------------------ | Branch (2621:7): [True: 0, False: 418] ------------------ 2622| 0| if (CTYPE_(node)->ascii_mode == 0) { ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (2622:13): [True: 0, False: 0] ------------------ 2623| 0| op = CTYPE_(node)->not != 0 ? OP_NO_WORD : OP_WORD; ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (2623:16): [True: 0, False: 0] ------------------ 2624| 0| } 2625| 0| else { 2626| 0| op = CTYPE_(node)->not != 0 ? OP_NO_WORD_ASCII : OP_WORD_ASCII; ------------------ | | 289| 0|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ | Branch (2626:16): [True: 0, False: 0] ------------------ 2627| 0| } 2628| 0| r = add_op(reg, op); 2629| 0| break; 2630| | 2631| 0| default: ------------------ | Branch (2631:7): [True: 0, False: 418] ------------------ 2632| 0| return ONIGERR_TYPE_BUG; ------------------ | | 571| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 2633| 0| break; 2634| 418| } 2635| 418| } 2636| 418| break; 2637| | 2638| 418| case ND_BACKREF: ------------------ | Branch (2638:3): [True: 0, False: 190k] ------------------ 2639| 0| { 2640| 0| BackRefNode* br = BACKREF_(node); ------------------ | | 290| 0|#define BACKREF_(node) (&((node)->u.backref)) ------------------ 2641| | 2642| 0| if (ND_IS_CHECKER(node)) { ------------------ | | 376| 0|#define ND_IS_CHECKER(node) ((ND_STATUS(node) & ND_ST_CHECKER) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CHECKER(node) ((ND_STATUS(node) & ND_ST_CHECKER) != 0) | | ------------------ | | | | 342| 0|#define ND_ST_CHECKER (1<<17) | | ------------------ | | | Branch (376:37): [True: 0, False: 0] | | ------------------ ------------------ 2643| 0|#ifdef USE_BACKREF_WITH_LEVEL 2644| 0| if (ND_IS_NEST_LEVEL(node)) { ------------------ | | 373| 0|#define ND_IS_NEST_LEVEL(node) ((ND_STATUS(node) & ND_ST_NEST_LEVEL) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_NEST_LEVEL(node) ((ND_STATUS(node) & ND_ST_NEST_LEVEL) != 0) | | ------------------ | | | | 338| 0|#define ND_ST_NEST_LEVEL (1<<13) | | ------------------ | | | Branch (373:37): [True: 0, False: 0] | | ------------------ ------------------ 2645| 0| r = add_op(reg, OP_BACKREF_CHECK_WITH_LEVEL); 2646| 0| if (r != 0) return r; ------------------ | Branch (2646:15): [True: 0, False: 0] ------------------ 2647| 0| COP(reg)->backref_general.nest_level = br->nest_level; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2648| 0| } 2649| 0| else 2650| 0|#endif 2651| 0| { 2652| 0| r = add_op(reg, OP_BACKREF_CHECK); 2653| 0| if (r != 0) return r; ------------------ | Branch (2653:17): [True: 0, False: 0] ------------------ 2654| 0| } 2655| 0| goto add_bacref_mems; 2656| 0| } 2657| 0| else { 2658| 0|#ifdef USE_BACKREF_WITH_LEVEL 2659| 0| if (ND_IS_NEST_LEVEL(node)) { ------------------ | | 373| 0|#define ND_IS_NEST_LEVEL(node) ((ND_STATUS(node) & ND_ST_NEST_LEVEL) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_NEST_LEVEL(node) ((ND_STATUS(node) & ND_ST_NEST_LEVEL) != 0) | | ------------------ | | | | 338| 0|#define ND_ST_NEST_LEVEL (1<<13) | | ------------------ | | | Branch (373:37): [True: 0, False: 0] | | ------------------ ------------------ 2660| 0| if (ND_IS_IGNORECASE(node)) ------------------ | | 384| 0|#define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | ------------------ | | | | 346| 0|#define ND_ST_IGNORECASE (1<<21) | | ------------------ | | | Branch (384:37): [True: 0, False: 0] | | ------------------ ------------------ 2661| 0| r = add_op(reg, OP_BACKREF_WITH_LEVEL_IC); 2662| 0| else 2663| 0| r = add_op(reg, OP_BACKREF_WITH_LEVEL); 2664| | 2665| 0| if (r != 0) return r; ------------------ | Branch (2665:15): [True: 0, False: 0] ------------------ 2666| 0| COP(reg)->backref_general.nest_level = br->nest_level; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2667| 0| goto add_bacref_mems; 2668| 0| } 2669| 0| else 2670| 0|#endif 2671| 0| if (br->back_num == 1) { ------------------ | Branch (2671:13): [True: 0, False: 0] ------------------ 2672| 0| n = br->back_static[0]; 2673| 0| if (ND_IS_IGNORECASE(node)) { ------------------ | | 384| 0|#define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | ------------------ | | | | 346| 0|#define ND_ST_IGNORECASE (1<<21) | | ------------------ | | | Branch (384:37): [True: 0, False: 0] | | ------------------ ------------------ 2674| 0| r = add_op(reg, OP_BACKREF_N_IC); 2675| 0| if (r != 0) return r; ------------------ | Branch (2675:17): [True: 0, False: 0] ------------------ 2676| 0| COP(reg)->backref_n.n1 = n; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2677| 0| } 2678| 0| else { 2679| 0| switch (n) { 2680| 0| case 1: r = add_op(reg, OP_BACKREF1); break; ------------------ | Branch (2680:13): [True: 0, False: 0] ------------------ 2681| 0| case 2: r = add_op(reg, OP_BACKREF2); break; ------------------ | Branch (2681:13): [True: 0, False: 0] ------------------ 2682| 0| default: ------------------ | Branch (2682:13): [True: 0, False: 0] ------------------ 2683| 0| r = add_op(reg, OP_BACKREF_N); 2684| 0| if (r != 0) return r; ------------------ | Branch (2684:19): [True: 0, False: 0] ------------------ 2685| 0| COP(reg)->backref_n.n1 = n; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2686| 0| break; 2687| 0| } 2688| 0| } 2689| 0| } 2690| 0| else { 2691| 0| int num; 2692| 0| int* p; 2693| | 2694| 0| r = add_op(reg, ND_IS_IGNORECASE(node) ? ------------------ | | 384| 0|#define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_IGNORECASE(node) ((ND_STATUS(node) & ND_ST_IGNORECASE) != 0) | | ------------------ | | | | 346| 0|#define ND_ST_IGNORECASE (1<<21) | | ------------------ | | | Branch (384:37): [True: 0, False: 0] | | ------------------ ------------------ 2695| 0| OP_BACKREF_MULTI_IC : OP_BACKREF_MULTI); 2696| 0| if (r != 0) return r; ------------------ | Branch (2696:15): [True: 0, False: 0] ------------------ 2697| | 2698| 0| add_bacref_mems: 2699| 0| num = br->back_num; 2700| 0| COP(reg)->backref_general.num = num; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2701| 0| if (num == 1) { ------------------ | Branch (2701:15): [True: 0, False: 0] ------------------ 2702| 0| COP(reg)->backref_general.n1 = br->back_static[0]; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2703| 0| } 2704| 0| else { 2705| 0| int i, j; 2706| 0| MemNumType* ns; 2707| | 2708| 0| ns = xmalloc(sizeof(MemNumType) * num); ------------------ | | 227| 0|#define xmalloc malloc ------------------ 2709| 0| CHECK_NULL_RETURN_MEMERR(ns); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 2710| 0| COP(reg)->backref_general.ns = ns; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2711| 0| p = BACKREFS_P(br); ------------------ | | 322| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static) | | ------------------ | | | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (202:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2712| 0| for (i = num - 1, j = 0; i >= 0; i--, j++) { ------------------ | Branch (2712:38): [True: 0, False: 0] ------------------ 2713| 0| ns[j] = p[i]; 2714| 0| } 2715| 0| } 2716| 0| } 2717| 0| } 2718| 0| } 2719| 0| break; 2720| | 2721| 0|#ifdef USE_CALL 2722| 0| case ND_CALL: ------------------ | Branch (2722:3): [True: 0, False: 190k] ------------------ 2723| 0| r = compile_call(CALL_(node), reg, env); ------------------ | | 295| 0|#define CALL_(node) (&((node)->u.call)) ------------------ 2724| 0| break; 2725| 0|#endif 2726| | 2727| 46.3k| case ND_QUANT: ------------------ | Branch (2727:3): [True: 46.3k, False: 143k] ------------------ 2728| 46.3k| r = compile_quantifier_node(QUANT_(node), reg, env); ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2729| 46.3k| break; 2730| | 2731| 877| case ND_BAG: ------------------ | Branch (2731:3): [True: 877, False: 189k] ------------------ 2732| 877| r = compile_bag_node(BAG_(node), reg, env); ------------------ | | 292| 877|#define BAG_(node) (&((node)->u.bag)) ------------------ 2733| 877| break; 2734| | 2735| 3.11k| case ND_ANCHOR: ------------------ | Branch (2735:3): [True: 3.11k, False: 187k] ------------------ 2736| 3.11k| r = compile_anchor_node(ANCHOR_(node), reg, env); ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 2737| 3.11k| break; 2738| | 2739| 0| case ND_GIMMICK: ------------------ | Branch (2739:3): [True: 0, False: 190k] ------------------ 2740| 0| r = compile_gimmick_node(GIMMICK_(node), reg); ------------------ | | 296| 0|#define GIMMICK_(node) (&((node)->u.gimmick)) ------------------ 2741| 0| break; 2742| | 2743| 0| default: ------------------ | Branch (2743:3): [True: 0, False: 190k] ------------------ 2744| |#ifdef ONIG_DEBUG 2745| | fprintf(DBGFP, "compile_tree: undefined node type %d\n", ND_TYPE(node)); 2746| |#endif 2747| 0| break; 2748| 190k| } 2749| | 2750| 190k| return r; 2751| 190k|} regcomp.c:compile_length_tree: 2481| 46.6k|{ 2482| 46.6k| int len, r; 2483| | 2484| 46.6k| switch (ND_TYPE(node)) { ------------------ | | 284| 46.6k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 2485| 56| case ND_LIST: ------------------ | Branch (2485:3): [True: 56, False: 46.5k] ------------------ 2486| 56| len = 0; 2487| 168| do { 2488| 168| r = compile_length_tree(ND_CAR(node), reg, env); ------------------ | | 298| 168|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 168|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2489| 168| if (r < 0) return r; ------------------ | Branch (2489:11): [True: 0, False: 168] ------------------ 2490| 168| len += r; 2491| 168| } while (IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 168|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 112, False: 56] | | ------------------ ------------------ 2492| 56| r = len; 2493| 56| break; 2494| | 2495| 0| case ND_ALT: ------------------ | Branch (2495:3): [True: 0, False: 46.6k] ------------------ 2496| 0| { 2497| 0| int n; 2498| | 2499| 0| n = r = 0; 2500| 0| do { 2501| 0| r += compile_length_tree(ND_CAR(node), reg, env); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2502| 0| n++; 2503| 0| } while (IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 2504| 0| r += (OPSIZE_PUSH + OPSIZE_JUMP) * (n - 1); ------------------ | | 648| 0|#define OPSIZE_PUSH 1 ------------------ r += (OPSIZE_PUSH + OPSIZE_JUMP) * (n - 1); ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 2505| 0| } 2506| 0| break; 2507| | 2508| 43.6k| case ND_STRING: ------------------ | Branch (2508:3): [True: 43.6k, False: 3.02k] ------------------ 2509| 43.6k| if (ND_STRING_IS_CRUDE(node)) ------------------ | | 317| 43.6k| (((node)->u.str.flag & ND_STRING_CRUDE) != 0) | | ------------------ | | | | 309| 43.6k|#define ND_STRING_CRUDE (1<<0) | | ------------------ | | | Branch (317:3): [True: 0, False: 43.6k] | | ------------------ ------------------ 2510| 0| r = compile_length_string_crude_node(STR_(node), reg); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 2511| 43.6k| else 2512| 43.6k| r = compile_length_string_node(node, reg); 2513| 43.6k| break; 2514| | 2515| 2.63k| case ND_CCLASS: ------------------ | Branch (2515:3): [True: 2.63k, False: 44.0k] ------------------ 2516| 2.63k| r = compile_length_cclass_node(CCLASS_(node), reg); ------------------ | | 288| 2.63k|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 2517| 2.63k| break; 2518| | 2519| 236| case ND_CTYPE: ------------------ | Branch (2519:3): [True: 236, False: 46.4k] ------------------ 2520| 236| r = SIZE_OPCODE; ------------------ | | 623| 236|#define SIZE_OPCODE 1 ------------------ 2521| 236| break; 2522| | 2523| 0| case ND_BACKREF: ------------------ | Branch (2523:3): [True: 0, False: 46.6k] ------------------ 2524| 0| r = OPSIZE_BACKREF; ------------------ | | 660| 0|#define OPSIZE_BACKREF 1 ------------------ 2525| 0| break; 2526| | 2527| 0|#ifdef USE_CALL 2528| 0| case ND_CALL: ------------------ | Branch (2528:3): [True: 0, False: 46.6k] ------------------ 2529| 0| r = OPSIZE_CALL; ------------------ | | 671| 0|#define OPSIZE_CALL 1 ------------------ 2530| 0| break; 2531| 0|#endif 2532| | 2533| 0| case ND_QUANT: ------------------ | Branch (2533:3): [True: 0, False: 46.6k] ------------------ 2534| 0| r = compile_length_quantifier_node(QUANT_(node), reg, env); ------------------ | | 291| 0|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2535| 0| break; 2536| | 2537| 104| case ND_BAG: ------------------ | Branch (2537:3): [True: 104, False: 46.5k] ------------------ 2538| 104| r = compile_length_bag_node(BAG_(node), reg, env); ------------------ | | 292| 104|#define BAG_(node) (&((node)->u.bag)) ------------------ 2539| 104| break; 2540| | 2541| 0| case ND_ANCHOR: ------------------ | Branch (2541:3): [True: 0, False: 46.6k] ------------------ 2542| 0| r = compile_length_anchor_node(ANCHOR_(node), reg, env); ------------------ | | 293| 0|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 2543| 0| break; 2544| | 2545| 0| case ND_GIMMICK: ------------------ | Branch (2545:3): [True: 0, False: 46.6k] ------------------ 2546| 0| r = compile_length_gimmick_node(GIMMICK_(node), reg); ------------------ | | 296| 0|#define GIMMICK_(node) (&((node)->u.gimmick)) ------------------ 2547| 0| break; 2548| | 2549| 0| default: ------------------ | Branch (2549:3): [True: 0, False: 46.6k] ------------------ 2550| 0| return ONIGERR_TYPE_BUG; ------------------ | | 571| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 2551| 0| break; 2552| 46.6k| } 2553| | 2554| 46.6k| return r; 2555| 46.6k|} regcomp.c:add_compile_string_length: 1042| 43.6k|{ 1043| 43.6k| return 1; 1044| 43.6k|} regcomp.c:compile_length_string_node: 1086| 43.6k|{ 1087| 43.6k| int rlen, r, len, prev_len, slen; 1088| 43.6k| UChar *p, *prev; ------------------ | | 80| 43.6k|#define UChar OnigUChar ------------------ 1089| 43.6k| StrNode* sn; 1090| 43.6k| OnigEncoding enc = reg->enc; 1091| | 1092| 43.6k| sn = STR_(node); ------------------ | | 287| 43.6k|#define STR_(node) (&((node)->u.str)) ------------------ 1093| 43.6k| if (sn->end <= sn->s) ------------------ | Branch (1093:7): [True: 0, False: 43.6k] ------------------ 1094| 0| return 0; 1095| | 1096| 43.6k| p = prev = sn->s; 1097| 43.6k| prev_len = enclen(enc, p); ------------------ | | 83| 43.6k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 43.6k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 1098| 43.6k| p += prev_len; 1099| 43.6k| slen = 1; 1100| 43.6k| rlen = 0; 1101| | 1102| 43.6k| for (; p < sn->end; ) { ------------------ | Branch (1102:10): [True: 4, False: 43.6k] ------------------ 1103| 4| len = enclen(enc, p); ------------------ | | 83| 4|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 4|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 1104| 4| if (len == prev_len) { ------------------ | Branch (1104:9): [True: 4, False: 0] ------------------ 1105| 4| slen++; 1106| 4| } 1107| 0| else { 1108| 0| r = add_compile_string_length(prev, prev_len, slen, reg); 1109| 0| rlen += r; 1110| 0| prev = p; 1111| 0| slen = 1; 1112| 0| prev_len = len; 1113| 0| } 1114| 4| p += len; 1115| 4| } 1116| | 1117| 43.6k| r = add_compile_string_length(prev, prev_len, slen, reg); 1118| 43.6k| rlen += r; 1119| 43.6k| return rlen; 1120| 43.6k|} regcomp.c:compile_length_cclass_node: 1196| 2.63k|{ 1197| 2.63k| return 1; 1198| 2.63k|} regcomp.c:is_anychar_infinite_greedy: 1313| 46.3k|{ 1314| 46.3k| if (qn->greedy && IS_INFINITE_REPEAT(qn->upper) && ------------------ | | 428| 92.5k|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 46.2k|#define INFINITE_REPEAT -1 | | ------------------ | | | Branch (428:33): [True: 46.1k, False: 56] | | ------------------ ------------------ | Branch (1314:7): [True: 46.2k, False: 67] ------------------ 1315| 46.1k| ND_IS_ANYCHAR(ND_QUANT_BODY(qn))) ------------------ | | 303| 46.1k| (ND_TYPE(node) == ND_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR) | | ------------------ | | | | 284| 46.1k|#define ND_TYPE(node) ((node)->u.base.node_type) | | ------------------ | | (ND_TYPE(node) == ND_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR) | | ------------------ | | | | 289| 169|#define CTYPE_(node) (&((node)->u.ctype)) | | ------------------ | | (ND_TYPE(node) == ND_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR) | | ------------------ | | | | 301| 169|#define CTYPE_ANYCHAR -1 | | ------------------ | | | Branch (303:4): [True: 169, False: 46.0k] | | | Branch (303:33): [True: 169, False: 0] | | ------------------ ------------------ 1316| 169| return 1; 1317| 46.1k| else 1318| 46.1k| return 0; 1319| 46.3k|} regcomp.c:compile_length_bag_node: 1590| 104|{ 1591| 104| int len; 1592| 104| int tlen; 1593| | 1594| 104| if (node->type == BAG_OPTION) ------------------ | Branch (1594:7): [True: 0, False: 104] ------------------ 1595| 0| return compile_length_option_node(node, reg, env); 1596| | 1597| 104| if (ND_BAG_BODY(node)) { ------------------ | | 396| 104|#define ND_BAG_BODY(node) ((node)->body) | | ------------------ | | | Branch (396:33): [True: 104, False: 0] | | ------------------ ------------------ 1598| 104| tlen = compile_length_tree(ND_BAG_BODY(node), reg, env); ------------------ | | 396| 104|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1599| 104| if (tlen < 0) return tlen; ------------------ | Branch (1599:9): [True: 0, False: 104] ------------------ 1600| 104| } 1601| 0| else 1602| 0| tlen = 0; 1603| | 1604| 104| switch (node->type) { 1605| 104| case BAG_MEMORY: ------------------ | Branch (1605:3): [True: 104, False: 0] ------------------ 1606| 104|#ifdef USE_CALL 1607| | 1608| 104| if (node->m.regnum == 0 && ND_IS_CALLED(node)) { ------------------ | | 362| 0|#define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 332| 0|#define ND_ST_CALLED (1<<7) | | ------------------ | | | Branch (362:37): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1608:9): [True: 0, False: 104] ------------------ 1609| 0| len = tlen + OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN; ------------------ | | 671| 0|#define OPSIZE_CALL 1 ------------------ len = tlen + OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ len = tlen + OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN; ------------------ | | 672| 0|#define OPSIZE_RETURN 1 ------------------ 1610| 0| return len; 1611| 0| } 1612| | 1613| 104| if (ND_IS_CALLED(node)) { ------------------ | | 362| 104|#define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 356| 104|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 332| 104|#define ND_ST_CALLED (1<<7) | | ------------------ | | | Branch (362:37): [True: 0, False: 104] | | ------------------ ------------------ 1614| 0| len = OPSIZE_MEM_START_PUSH + tlen ------------------ | | 663| 0|#define OPSIZE_MEM_START_PUSH 1 ------------------ 1615| 0| + OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN; ------------------ | | 671| 0|#define OPSIZE_CALL 1 ------------------ + OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ + OPSIZE_CALL + OPSIZE_JUMP + OPSIZE_RETURN; ------------------ | | 672| 0|#define OPSIZE_RETURN 1 ------------------ 1616| 0| if (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum)) ------------------ | | 367| 0| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 0, False: 0] | | | Branch (367:4): [True: 0, False: 0] | | | Branch (367:15): [True: 0, False: 0] | | ------------------ ------------------ 1617| 0| len += (ND_IS_RECURSION(node) ------------------ | | 364| 0|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 0|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 0] | | ------------------ ------------------ 1618| 0| ? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_PUSH); ------------------ | | 665| 0|#define OPSIZE_MEM_END_PUSH_REC 1 ------------------ ? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_PUSH); ------------------ | | 664| 0|#define OPSIZE_MEM_END_PUSH 1 ------------------ 1619| 0| else 1620| 0| len += (ND_IS_RECURSION(node) ------------------ | | 364| 0|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 0|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 0] | | ------------------ ------------------ 1621| 0| ? OPSIZE_MEM_END_REC : OPSIZE_MEM_END); ------------------ | | 667| 0|#define OPSIZE_MEM_END_REC 1 ------------------ ? OPSIZE_MEM_END_REC : OPSIZE_MEM_END); ------------------ | | 666| 0|#define OPSIZE_MEM_END 1 ------------------ 1622| 0| } 1623| 104| else if (ND_IS_RECURSION(node)) { ------------------ | | 364| 104|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 104|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 104|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 104] | | ------------------ ------------------ 1624| 0| len = OPSIZE_MEM_START_PUSH; ------------------ | | 663| 0|#define OPSIZE_MEM_START_PUSH 1 ------------------ 1625| 0| len += tlen + (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum) ------------------ | | 367| 0| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 0, False: 0] | | | Branch (367:4): [True: 0, False: 0] | | | Branch (367:15): [True: 0, False: 0] | | ------------------ ------------------ 1626| 0| ? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_REC); ------------------ | | 665| 0|#define OPSIZE_MEM_END_PUSH_REC 1 ------------------ ? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_REC); ------------------ | | 667| 0|#define OPSIZE_MEM_END_REC 1 ------------------ 1627| 0| } 1628| 104| else 1629| 104|#endif 1630| 104| { 1631| 104| if (MEM_STATUS_AT0(reg->push_mem_start, node->m.regnum)) ------------------ | | 367| 104| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 104|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 104, False: 0] | | | Branch (367:4): [True: 104, False: 0] | | | Branch (367:15): [True: 104, False: 0] | | ------------------ ------------------ 1632| 104| len = OPSIZE_MEM_START_PUSH; ------------------ | | 663| 104|#define OPSIZE_MEM_START_PUSH 1 ------------------ 1633| 0| else 1634| 0| len = OPSIZE_MEM_START; ------------------ | | 662| 0|#define OPSIZE_MEM_START 1 ------------------ 1635| | 1636| 104| len += tlen + (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum) ------------------ | | 367| 104| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 104|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 0, False: 104] | | | Branch (367:4): [True: 104, False: 0] | | | Branch (367:15): [True: 104, False: 0] | | ------------------ ------------------ 1637| 104| ? OPSIZE_MEM_END_PUSH : OPSIZE_MEM_END); ------------------ | | 664| 0|#define OPSIZE_MEM_END_PUSH 1 ------------------ ? OPSIZE_MEM_END_PUSH : OPSIZE_MEM_END); ------------------ | | 666| 104|#define OPSIZE_MEM_END 1 ------------------ 1638| 104| } 1639| 104| break; 1640| | 1641| 0| case BAG_STOP_BACKTRACK: ------------------ | Branch (1641:3): [True: 0, False: 104] ------------------ 1642| 0| if (ND_IS_STRICT_REAL_REPEAT(node)) { ------------------ | | 381| 0| ((ND_STATUS(node) & ND_ST_STRICT_REAL_REPEAT) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | ((ND_STATUS(node) & ND_ST_STRICT_REAL_REPEAT) != 0) | | ------------------ | | | | 330| 0|#define ND_ST_STRICT_REAL_REPEAT (1<<5) | | ------------------ | | | Branch (381:5): [True: 0, False: 0] | | ------------------ ------------------ 1643| 0| int v; 1644| 0| QuantNode* qn; 1645| | 1646| 0| qn = QUANT_(ND_BAG_BODY(node)); ------------------ | | 291| 0|#define QUANT_(node) (&((node)->u.quant)) ------------------ 1647| 0| tlen = compile_length_tree(ND_QUANT_BODY(qn), reg, env); ------------------ | | 395| 0|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1648| 0| if (tlen < 0) return tlen; ------------------ | Branch (1648:11): [True: 0, False: 0] ------------------ 1649| | 1650| 0| v = onig_positive_int_multiply(qn->lower, tlen); 1651| 0| if (v < 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE; ------------------ | | 613| 0|#define ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE -201 ------------------ | Branch (1651:11): [True: 0, False: 0] ------------------ 1652| 0| len = v + OPSIZE_PUSH + tlen + OPSIZE_POP + OPSIZE_JUMP; ------------------ | | 648| 0|#define OPSIZE_PUSH 1 ------------------ len = v + OPSIZE_PUSH + tlen + OPSIZE_POP + OPSIZE_JUMP; ------------------ | | 650| 0|#define OPSIZE_POP 1 ------------------ len = v + OPSIZE_PUSH + tlen + OPSIZE_POP + OPSIZE_JUMP; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 1653| 0| } 1654| 0| else { 1655| 0| len = OPSIZE_MARK + tlen + OPSIZE_CUT_TO_MARK; ------------------ | | 677| 0|#define OPSIZE_MARK 1 ------------------ len = OPSIZE_MARK + tlen + OPSIZE_CUT_TO_MARK; ------------------ | | 676| 0|#define OPSIZE_CUT_TO_MARK 1 ------------------ 1656| 0| } 1657| 0| break; 1658| | 1659| 0| case BAG_IF_ELSE: ------------------ | Branch (1659:3): [True: 0, False: 104] ------------------ 1660| 0| { 1661| 0| Node* cond = ND_BAG_BODY(node); ------------------ | | 396| 0|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1662| 0| Node* Then = node->te.Then; 1663| 0| Node* Else = node->te.Else; 1664| | 1665| 0| len = compile_length_tree(cond, reg, env); 1666| 0| if (len < 0) return len; ------------------ | Branch (1666:11): [True: 0, False: 0] ------------------ 1667| 0| len += OPSIZE_PUSH + OPSIZE_MARK + OPSIZE_CUT_TO_MARK; ------------------ | | 648| 0|#define OPSIZE_PUSH 1 ------------------ len += OPSIZE_PUSH + OPSIZE_MARK + OPSIZE_CUT_TO_MARK; ------------------ | | 677| 0|#define OPSIZE_MARK 1 ------------------ len += OPSIZE_PUSH + OPSIZE_MARK + OPSIZE_CUT_TO_MARK; ------------------ | | 676| 0|#define OPSIZE_CUT_TO_MARK 1 ------------------ 1668| | 1669| 0| if (IS_NOT_NULL(Then)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1670| 0| tlen = compile_length_tree(Then, reg, env); 1671| 0| if (tlen < 0) return tlen; ------------------ | Branch (1671:13): [True: 0, False: 0] ------------------ 1672| 0| len += tlen; 1673| 0| } 1674| | 1675| 0| len += OPSIZE_JUMP + OPSIZE_CUT_TO_MARK; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ len += OPSIZE_JUMP + OPSIZE_CUT_TO_MARK; ------------------ | | 676| 0|#define OPSIZE_CUT_TO_MARK 1 ------------------ 1676| | 1677| 0| if (IS_NOT_NULL(Else)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1678| 0| tlen = compile_length_tree(Else, reg, env); 1679| 0| if (tlen < 0) return tlen; ------------------ | Branch (1679:13): [True: 0, False: 0] ------------------ 1680| 0| len += tlen; 1681| 0| } 1682| 0| } 1683| 0| break; 1684| | 1685| 0| case BAG_OPTION: ------------------ | Branch (1685:3): [True: 0, False: 104] ------------------ 1686| | /* never come here, but set for escape warning */ 1687| 0| len = 0; 1688| 0| break; 1689| | 1690| 0| default: ------------------ | Branch (1690:3): [True: 0, False: 104] ------------------ 1691| 0| return ONIGERR_TYPE_BUG; ------------------ | | 571| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 1692| 0| break; 1693| 104| } 1694| | 1695| 104| return len; 1696| 104|} regcomp.c:add_compile_string: 1048| 89.7k|{ 1049| 89.7k| int op; 1050| 89.7k| int r; 1051| 89.7k| int byte_len; 1052| 89.7k| UChar* p; ------------------ | | 80| 89.7k|#define UChar OnigUChar ------------------ 1053| 89.7k| UChar* end; ------------------ | | 80| 89.7k|#define UChar OnigUChar ------------------ 1054| | 1055| 89.7k| op = select_str_opcode(mb_len, str_len); 1056| 89.7k| r = add_op(reg, op); 1057| 89.7k| if (r != 0) return r; ------------------ | Branch (1057:7): [True: 0, False: 89.7k] ------------------ 1058| | 1059| 89.7k| byte_len = mb_len * str_len; 1060| 89.7k| end = s + byte_len; 1061| | 1062| 89.7k| if (op == OP_STR_MBN) { ------------------ | Branch (1062:7): [True: 0, False: 89.7k] ------------------ 1063| 0| p = onigenc_strdup(reg->enc, s, end); 1064| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1065| | 1066| 0| COP(reg)->exact_len_n.len = mb_len; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1067| 0| COP(reg)->exact_len_n.n = str_len; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1068| 0| COP(reg)->exact_len_n.s = p; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1069| 0| } 1070| 89.7k| else if (IS_NEED_STR_LEN_OP(op)) { ------------------ | | 895| 89.7k| ((op) == OP_STR_N || (op) == OP_STR_MB2N ||\ | | ------------------ | | | Branch (895:5): [True: 0, False: 89.7k] | | | Branch (895:28): [True: 0, False: 89.7k] | | ------------------ | | 896| 89.7k| (op) == OP_STR_MB3N || (op) == OP_STR_MBN) | | ------------------ | | | Branch (896:5): [True: 0, False: 89.7k] | | | Branch (896:28): [True: 0, False: 89.7k] | | ------------------ ------------------ 1071| 0| p = onigenc_strdup(reg->enc, s, end); 1072| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1073| 0| COP(reg)->exact_n.n = str_len; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1074| 0| COP(reg)->exact_n.s = p; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1075| 0| } 1076| 89.7k| else { 1077| 89.7k| xmemset(COP(reg)->exact.s, 0, sizeof(COP(reg)->exact.s)); ------------------ | | 177| 89.7k|#define xmemset memset ------------------ xmemset(COP(reg)->exact.s, 0, sizeof(COP(reg)->exact.s)); ------------------ | | 947| 89.7k|#define COP(reg) ((reg)->ops_curr) ------------------ xmemset(COP(reg)->exact.s, 0, sizeof(COP(reg)->exact.s)); ------------------ | | 947| 89.7k|#define COP(reg) ((reg)->ops_curr) ------------------ 1078| 89.7k| xmemcpy(COP(reg)->exact.s, s, (size_t )byte_len); ------------------ | | 181| 89.7k|#define xmemcpy memcpy ------------------ xmemcpy(COP(reg)->exact.s, s, (size_t )byte_len); ------------------ | | 947| 89.7k|#define COP(reg) ((reg)->ops_curr) ------------------ 1079| 89.7k| } 1080| | 1081| 89.7k| return 0; 1082| 89.7k|} regcomp.c:select_str_opcode: 900| 89.7k|{ 901| 89.7k| int op; 902| | 903| 89.7k| switch (mb_len) { 904| 89.7k| case 1: ------------------ | Branch (904:3): [True: 89.7k, False: 19] ------------------ 905| 89.7k| switch (str_len) { 906| 89.5k| case 1: op = OP_STR_1; break; ------------------ | Branch (906:5): [True: 89.5k, False: 247] ------------------ 907| 228| case 2: op = OP_STR_2; break; ------------------ | Branch (907:5): [True: 228, False: 89.5k] ------------------ 908| 19| case 3: op = OP_STR_3; break; ------------------ | Branch (908:5): [True: 19, False: 89.7k] ------------------ 909| 0| case 4: op = OP_STR_4; break; ------------------ | Branch (909:5): [True: 0, False: 89.7k] ------------------ 910| 0| case 5: op = OP_STR_5; break; ------------------ | Branch (910:5): [True: 0, False: 89.7k] ------------------ 911| 0| default: op = OP_STR_N; break; ------------------ | Branch (911:5): [True: 0, False: 89.7k] ------------------ 912| 89.7k| } 913| 89.7k| break; 914| | 915| 89.7k| case 2: ------------------ | Branch (915:3): [True: 19, False: 89.7k] ------------------ 916| 19| switch (str_len) { 917| 19| case 1: op = OP_STR_MB2N1; break; ------------------ | Branch (917:5): [True: 19, False: 0] ------------------ 918| 0| case 2: op = OP_STR_MB2N2; break; ------------------ | Branch (918:5): [True: 0, False: 19] ------------------ 919| 0| case 3: op = OP_STR_MB2N3; break; ------------------ | Branch (919:5): [True: 0, False: 19] ------------------ 920| 0| default: op = OP_STR_MB2N; break; ------------------ | Branch (920:5): [True: 0, False: 19] ------------------ 921| 19| } 922| 19| break; 923| | 924| 19| case 3: ------------------ | Branch (924:3): [True: 0, False: 89.7k] ------------------ 925| 0| op = OP_STR_MB3N; 926| 0| break; 927| | 928| 0| default: ------------------ | Branch (928:3): [True: 0, False: 89.7k] ------------------ 929| 0| op = OP_STR_MBN; 930| 0| break; 931| 89.7k| } 932| | 933| 89.7k| return op; 934| 89.7k|} regcomp.c:compile_string_node: 1134| 89.8k|{ 1135| 89.8k| int r, len, prev_len, slen; 1136| 89.8k| UChar *p, *prev, *end; ------------------ | | 80| 89.8k|#define UChar OnigUChar ------------------ 1137| 89.8k| StrNode* sn; 1138| 89.8k| OnigEncoding enc = reg->enc; 1139| | 1140| 89.8k| sn = STR_(node); ------------------ | | 287| 89.8k|#define STR_(node) (&((node)->u.str)) ------------------ 1141| 89.8k| if (sn->end <= sn->s) ------------------ | Branch (1141:7): [True: 75, False: 89.7k] ------------------ 1142| 75| return 0; 1143| | 1144| 89.7k| end = sn->end; 1145| | 1146| 89.7k| p = prev = sn->s; 1147| 89.7k| prev_len = enclen(enc, p); ------------------ | | 83| 89.7k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 89.7k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 1148| 89.7k| p += prev_len; 1149| 89.7k| slen = 1; 1150| | 1151| 90.0k| for (; p < end; ) { ------------------ | Branch (1151:10): [True: 266, False: 89.7k] ------------------ 1152| 266| len = enclen(enc, p); ------------------ | | 83| 266|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 266|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 1153| 266| if (len == prev_len) { ------------------ | Branch (1153:9): [True: 266, False: 0] ------------------ 1154| 266| slen++; 1155| 266| } 1156| 0| else { 1157| 0| r = add_compile_string(prev, prev_len, slen, reg); 1158| 0| if (r != 0) return r; ------------------ | Branch (1158:11): [True: 0, False: 0] ------------------ 1159| | 1160| 0| prev = p; 1161| 0| slen = 1; 1162| 0| prev_len = len; 1163| 0| } 1164| | 1165| 266| p += len; 1166| 266| } 1167| | 1168| 89.7k| return add_compile_string(prev, prev_len, slen, reg); 1169| 89.7k|} regcomp.c:compile_cclass_node: 1202| 5.39k|{ 1203| 5.39k| int r; 1204| | 1205| 5.39k| if (IS_NULL(cc->mbuf)) { ------------------ | | 201| 5.39k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 5.39k, False: 0] | | ------------------ ------------------ 1206| 5.39k| r = add_op(reg, IS_NCCLASS_NOT(cc) ? OP_CCLASS_NOT : OP_CCLASS); ------------------ | | 736| 5.39k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 5.39k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 5.39k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 106, False: 5.28k] | | | | ------------------ | | ------------------ ------------------ 1207| 5.39k| if (r != 0) return r; ------------------ | Branch (1207:9): [True: 0, False: 5.39k] ------------------ 1208| | 1209| 5.39k| COP(reg)->cclass.bsp = xmalloc(SIZE_BITSET); ------------------ | | 947| 5.39k|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->cclass.bsp = xmalloc(SIZE_BITSET); ------------------ | | 227| 5.39k|#define xmalloc malloc ------------------ COP(reg)->cclass.bsp = xmalloc(SIZE_BITSET); ------------------ | | 440| 5.39k|#define SIZE_BITSET sizeof(BitSet) ------------------ 1210| 5.39k| CHECK_NULL_RETURN_MEMERR(COP(reg)->cclass.bsp); ------------------ | | 204| 5.39k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 5.39k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 5.39k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1211| 5.39k| xmemcpy(COP(reg)->cclass.bsp, cc->bs, SIZE_BITSET); ------------------ | | 181| 5.39k|#define xmemcpy memcpy ------------------ xmemcpy(COP(reg)->cclass.bsp, cc->bs, SIZE_BITSET); ------------------ | | 947| 5.39k|#define COP(reg) ((reg)->ops_curr) ------------------ xmemcpy(COP(reg)->cclass.bsp, cc->bs, SIZE_BITSET); ------------------ | | 440| 5.39k|#define SIZE_BITSET sizeof(BitSet) ------------------ 1212| 5.39k| } 1213| 0| else { 1214| 0| void* p; 1215| | 1216| 0| if (ONIGENC_MBC_MINLEN(reg->enc) > 1 || bitset_is_empty(cc->bs)) { ------------------ | | 282| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (1216:9): [True: 0, False: 0] | Branch (1216:45): [True: 0, False: 0] ------------------ 1217| 0| r = add_op(reg, IS_NCCLASS_NOT(cc) ? OP_CCLASS_MB_NOT : OP_CCLASS_MB); ------------------ | | 736| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1218| 0| if (r != 0) return r; ------------------ | Branch (1218:11): [True: 0, False: 0] ------------------ 1219| | 1220| 0| p = set_multi_byte_cclass(cc->mbuf, reg); 1221| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1222| 0| COP(reg)->cclass_mb.mb = p; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1223| 0| } 1224| 0| else { 1225| 0| r = add_op(reg, IS_NCCLASS_NOT(cc) ? OP_CCLASS_MIX_NOT : OP_CCLASS_MIX); ------------------ | | 736| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1226| 0| if (r != 0) return r; ------------------ | Branch (1226:11): [True: 0, False: 0] ------------------ 1227| | 1228| 0| COP(reg)->cclass_mix.bsp = xmalloc(SIZE_BITSET); ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->cclass_mix.bsp = xmalloc(SIZE_BITSET); ------------------ | | 227| 0|#define xmalloc malloc ------------------ COP(reg)->cclass_mix.bsp = xmalloc(SIZE_BITSET); ------------------ | | 440| 0|#define SIZE_BITSET sizeof(BitSet) ------------------ 1229| 0| CHECK_NULL_RETURN_MEMERR(COP(reg)->cclass_mix.bsp); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1230| 0| xmemcpy(COP(reg)->cclass_mix.bsp, cc->bs, SIZE_BITSET); ------------------ | | 181| 0|#define xmemcpy memcpy ------------------ xmemcpy(COP(reg)->cclass_mix.bsp, cc->bs, SIZE_BITSET); ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ xmemcpy(COP(reg)->cclass_mix.bsp, cc->bs, SIZE_BITSET); ------------------ | | 440| 0|#define SIZE_BITSET sizeof(BitSet) ------------------ 1231| | 1232| 0| p = set_multi_byte_cclass(cc->mbuf, reg); 1233| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1234| 0| COP(reg)->cclass_mix.mb = p; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1235| 0| } 1236| 0| } 1237| | 1238| 5.39k| return 0; 1239| 5.39k|} regcomp.c:compile_quantifier_node: 1400| 46.3k|{ 1401| 46.3k| int i, r, mod_tlen; 1402| 46.3k| int infinite = IS_INFINITE_REPEAT(qn->upper); ------------------ | | 428| 46.3k|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 46.3k|#define INFINITE_REPEAT -1 | | ------------------ ------------------ 1403| 46.3k| enum BodyEmptyType emptiness = qn->emptiness; 1404| 46.3k| int tlen = compile_length_tree(ND_QUANT_BODY(qn), reg, env); ------------------ | | 395| 46.3k|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1405| | 1406| 46.3k| if (tlen < 0) return tlen; ------------------ | Branch (1406:7): [True: 0, False: 46.3k] ------------------ 1407| 46.3k| if (tlen == 0) return 0; ------------------ | Branch (1407:7): [True: 0, False: 46.3k] ------------------ 1408| | 1409| 46.3k| if (is_anychar_infinite_greedy(qn) && ------------------ | Branch (1409:7): [True: 169, False: 46.1k] ------------------ 1410| 169| (qn->lower <= 1 || ------------------ | Branch (1410:8): [True: 169, False: 0] ------------------ 1411| 0| len_multiply_cmp((OnigLen )tlen, qn->lower, ------------------ | Branch (1411:8): [True: 0, False: 0] ------------------ 1412| 169| QUANTIFIER_EXPAND_LIMIT_SIZE) <= 0)) { ------------------ | | 1321| 0|#define QUANTIFIER_EXPAND_LIMIT_SIZE 10 ------------------ 1413| 169| r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env); ------------------ | | 395| 169|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1414| 169| if (r != 0) return r; ------------------ | Branch (1414:9): [True: 0, False: 169] ------------------ 1415| 169| if (IS_NOT_NULL(qn->next_head_exact)) { ------------------ | | 202| 169|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 90, False: 79] | | ------------------ ------------------ 1416| 90| r = add_op(reg, ND_IS_MULTILINE(ND_QUANT_BODY(qn)) ? ------------------ | | 385| 90|#define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 356| 90|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 347| 90|#define ND_ST_MULTILINE (1<<22) | | ------------------ | | | Branch (385:37): [True: 0, False: 90] | | ------------------ ------------------ 1417| 90| OP_ANYCHAR_ML_STAR_PEEK_NEXT : OP_ANYCHAR_STAR_PEEK_NEXT); 1418| 90| if (r != 0) return r; ------------------ | Branch (1418:11): [True: 0, False: 90] ------------------ 1419| | 1420| 90| COP(reg)->anychar_star_peek_next.c = STR_(qn->next_head_exact)->s[0]; ------------------ | | 947| 90|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->anychar_star_peek_next.c = STR_(qn->next_head_exact)->s[0]; ------------------ | | 287| 90|#define STR_(node) (&((node)->u.str)) ------------------ 1421| 90| return 0; 1422| 90| } 1423| 79| else { 1424| 79| r = add_op(reg, ND_IS_MULTILINE(ND_QUANT_BODY(qn)) ? ------------------ | | 385| 79|#define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 356| 79|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_MULTILINE(node) ((ND_STATUS(node) & ND_ST_MULTILINE) != 0) | | ------------------ | | | | 347| 79|#define ND_ST_MULTILINE (1<<22) | | ------------------ | | | Branch (385:37): [True: 0, False: 79] | | ------------------ ------------------ 1425| 79| OP_ANYCHAR_ML_STAR : OP_ANYCHAR_STAR); 1426| 79| return r; 1427| 79| } 1428| 169| } 1429| | 1430| 46.1k| mod_tlen = tlen; 1431| 46.1k| if (emptiness != BODY_IS_NOT_EMPTY) ------------------ | Branch (1431:7): [True: 0, False: 46.1k] ------------------ 1432| 0| mod_tlen += OPSIZE_EMPTY_CHECK_START + OPSIZE_EMPTY_CHECK_END; ------------------ | | 668| 0|#define OPSIZE_EMPTY_CHECK_START 1 ------------------ mod_tlen += OPSIZE_EMPTY_CHECK_START + OPSIZE_EMPTY_CHECK_END; ------------------ | | 669| 0|#define OPSIZE_EMPTY_CHECK_END 1 ------------------ 1433| | 1434| 46.1k| if (infinite && ------------------ | Branch (1434:7): [True: 46.0k, False: 56] ------------------ 1435| 46.0k| (qn->lower <= 1 || ------------------ | Branch (1435:8): [True: 46.0k, False: 0] ------------------ 1436| 0| len_multiply_cmp((OnigLen )tlen, qn->lower, ------------------ | Branch (1436:8): [True: 0, False: 0] ------------------ 1437| 46.0k| QUANTIFIER_EXPAND_LIMIT_SIZE) <= 0)) { ------------------ | | 1321| 0|#define QUANTIFIER_EXPAND_LIMIT_SIZE 10 ------------------ 1438| 46.0k| int addr; 1439| | 1440| 46.0k| if (qn->lower == 1 && tlen > QUANTIFIER_EXPAND_LIMIT_SIZE) { ------------------ | | 1321| 7.20k|#define QUANTIFIER_EXPAND_LIMIT_SIZE 10 ------------------ | Branch (1440:9): [True: 7.20k, False: 38.8k] | Branch (1440:27): [True: 0, False: 7.20k] ------------------ 1441| 0| r = add_op(reg, OP_JUMP); 1442| 0| if (r != 0) return r; ------------------ | Branch (1442:11): [True: 0, False: 0] ------------------ 1443| 0| if (qn->greedy) { ------------------ | Branch (1443:11): [True: 0, False: 0] ------------------ 1444| 0|#ifdef USE_OP_PUSH_OR_JUMP_EXACT 1445| 0| if (IS_NOT_NULL(qn->head_exact)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1446| 0| COP(reg)->jump.addr = OPSIZE_PUSH_OR_JUMP_EXACT1 + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = OPSIZE_PUSH_OR_JUMP_EXACT1 + SIZE_INC; ------------------ | | 653| 0|#define OPSIZE_PUSH_OR_JUMP_EXACT1 1 ------------------ COP(reg)->jump.addr = OPSIZE_PUSH_OR_JUMP_EXACT1 + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1447| 0| else 1448| 0|#endif 1449| 0| if (IS_NOT_NULL(qn->next_head_exact)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1450| 0| COP(reg)->jump.addr = OPSIZE_PUSH_IF_PEEK_NEXT + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = OPSIZE_PUSH_IF_PEEK_NEXT + SIZE_INC; ------------------ | | 655| 0|#define OPSIZE_PUSH_IF_PEEK_NEXT 1 ------------------ COP(reg)->jump.addr = OPSIZE_PUSH_IF_PEEK_NEXT + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1451| 0| else 1452| 0| COP(reg)->jump.addr = OPSIZE_PUSH + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = OPSIZE_PUSH + SIZE_INC; ------------------ | | 648| 0|#define OPSIZE_PUSH 1 ------------------ COP(reg)->jump.addr = OPSIZE_PUSH + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1453| 0| } 1454| 0| else { 1455| 0| COP(reg)->jump.addr = OPSIZE_JUMP + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = OPSIZE_JUMP + SIZE_INC; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ COP(reg)->jump.addr = OPSIZE_JUMP + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1456| 0| } 1457| 0| } 1458| 46.0k| else { 1459| 46.0k| r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env); ------------------ | | 395| 46.0k|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1460| 46.0k| if (r != 0) return r; ------------------ | Branch (1460:11): [True: 0, False: 46.0k] ------------------ 1461| 46.0k| } 1462| | 1463| 46.0k| if (qn->greedy) { ------------------ | Branch (1463:9): [True: 46.0k, False: 67] ------------------ 1464| 46.0k|#ifdef USE_OP_PUSH_OR_JUMP_EXACT 1465| 46.0k| if (IS_NOT_NULL(qn->head_exact)) { ------------------ | | 202| 46.0k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 43.6k, False: 2.38k] | | ------------------ ------------------ 1466| 43.6k| r = add_op(reg, OP_PUSH_OR_JUMP_EXACT1); 1467| 43.6k| if (r != 0) return r; ------------------ | Branch (1467:13): [True: 0, False: 43.6k] ------------------ 1468| 43.6k| COP(reg)->push_or_jump_exact1.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 947| 43.6k|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push_or_jump_exact1.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 643| 43.6k|#define SIZE_INC 1 ------------------ COP(reg)->push_or_jump_exact1.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 647| 43.6k|#define OPSIZE_JUMP 1 ------------------ 1469| 43.6k| COP(reg)->push_or_jump_exact1.c = STR_(qn->head_exact)->s[0]; ------------------ | | 947| 43.6k|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push_or_jump_exact1.c = STR_(qn->head_exact)->s[0]; ------------------ | | 287| 43.6k|#define STR_(node) (&((node)->u.str)) ------------------ 1470| | 1471| 43.6k| r = compile_quant_body_with_empty_check(qn, reg, env); 1472| 43.6k| if (r != 0) return r; ------------------ | Branch (1472:13): [True: 0, False: 43.6k] ------------------ 1473| | 1474| 43.6k| addr = -(mod_tlen + (int )OPSIZE_PUSH_OR_JUMP_EXACT1); ------------------ | | 653| 43.6k|#define OPSIZE_PUSH_OR_JUMP_EXACT1 1 ------------------ 1475| 43.6k| } 1476| 2.38k| else 1477| 2.38k|#endif 1478| 2.38k| if (IS_NOT_NULL(qn->next_head_exact)) { ------------------ | | 202| 2.38k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 2.38k] | | ------------------ ------------------ 1479| 0| r = add_op(reg, OP_PUSH_IF_PEEK_NEXT); 1480| 0| if (r != 0) return r; ------------------ | Branch (1480:13): [True: 0, False: 0] ------------------ 1481| 0| COP(reg)->push_if_peek_next.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push_if_peek_next.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ COP(reg)->push_if_peek_next.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 1482| 0| COP(reg)->push_if_peek_next.c = STR_(qn->next_head_exact)->s[0]; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push_if_peek_next.c = STR_(qn->next_head_exact)->s[0]; ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 1483| | 1484| 0| r = compile_quant_body_with_empty_check(qn, reg, env); 1485| 0| if (r != 0) return r; ------------------ | Branch (1485:13): [True: 0, False: 0] ------------------ 1486| | 1487| 0| addr = -(mod_tlen + (int )OPSIZE_PUSH_IF_PEEK_NEXT); ------------------ | | 655| 0|#define OPSIZE_PUSH_IF_PEEK_NEXT 1 ------------------ 1488| 0| } 1489| 2.38k| else { 1490| 2.38k| r = add_op(reg, OP_PUSH); 1491| 2.38k| if (r != 0) return r; ------------------ | Branch (1491:13): [True: 0, False: 2.38k] ------------------ 1492| 2.38k| COP(reg)->push.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 947| 2.38k|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 643| 2.38k|#define SIZE_INC 1 ------------------ COP(reg)->push.addr = SIZE_INC + mod_tlen + OPSIZE_JUMP; ------------------ | | 647| 2.38k|#define OPSIZE_JUMP 1 ------------------ 1493| | 1494| 2.38k| r = compile_quant_body_with_empty_check(qn, reg, env); 1495| 2.38k| if (r != 0) return r; ------------------ | Branch (1495:13): [True: 0, False: 2.38k] ------------------ 1496| | 1497| 2.38k| addr = -(mod_tlen + (int )OPSIZE_PUSH); ------------------ | | 648| 2.38k|#define OPSIZE_PUSH 1 ------------------ 1498| 2.38k| } 1499| | 1500| 46.0k| r = add_op(reg, OP_JUMP); 1501| 46.0k| if (r != 0) return r; ------------------ | Branch (1501:11): [True: 0, False: 46.0k] ------------------ 1502| 46.0k| COP(reg)->jump.addr = addr; ------------------ | | 947| 46.0k|#define COP(reg) ((reg)->ops_curr) ------------------ 1503| 46.0k| } 1504| 67| else { 1505| 67| r = add_op(reg, OP_JUMP); 1506| 67| if (r != 0) return r; ------------------ | Branch (1506:11): [True: 0, False: 67] ------------------ 1507| 67| COP(reg)->jump.addr = mod_tlen + SIZE_INC; ------------------ | | 947| 67|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = mod_tlen + SIZE_INC; ------------------ | | 643| 67|#define SIZE_INC 1 ------------------ 1508| | 1509| 67| r = compile_quant_body_with_empty_check(qn, reg, env); 1510| 67| if (r != 0) return r; ------------------ | Branch (1510:11): [True: 0, False: 67] ------------------ 1511| | 1512| 67| r = add_op(reg, OP_PUSH); 1513| 67| if (r != 0) return r; ------------------ | Branch (1513:11): [True: 0, False: 67] ------------------ 1514| 67| COP(reg)->push.addr = -mod_tlen; ------------------ | | 947| 67|#define COP(reg) ((reg)->ops_curr) ------------------ 1515| 67| } 1516| 46.0k| } 1517| 56| else if (qn->upper == 0) { ------------------ | Branch (1517:12): [True: 0, False: 56] ------------------ 1518| 0| if (qn->include_referred != 0) { /* /(?..){0}/ */ ------------------ | Branch (1518:9): [True: 0, False: 0] ------------------ 1519| 0| r = add_op(reg, OP_JUMP); 1520| 0| if (r != 0) return r; ------------------ | Branch (1520:11): [True: 0, False: 0] ------------------ 1521| 0| COP(reg)->jump.addr = tlen + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = tlen + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1522| | 1523| 0| r = compile_tree(ND_QUANT_BODY(qn), reg, env); ------------------ | | 395| 0|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1524| 0| } 1525| 0| else { 1526| | /* Nothing output */ 1527| 0| r = 0; 1528| 0| } 1529| 0| } 1530| 56| else if (! infinite && qn->greedy && ------------------ | Branch (1530:12): [True: 56, False: 0] | Branch (1530:26): [True: 56, False: 0] ------------------ 1531| 56| (qn->upper == 1 || ------------------ | Branch (1531:13): [True: 56, False: 0] ------------------ 1532| 0| len_multiply_cmp((OnigLen )tlen + OPSIZE_PUSH, qn->upper, ------------------ | | 648| 0|#define OPSIZE_PUSH 1 ------------------ | Branch (1532:13): [True: 0, False: 0] ------------------ 1533| 56| QUANTIFIER_EXPAND_LIMIT_SIZE) <= 0)) { ------------------ | | 1321| 0|#define QUANTIFIER_EXPAND_LIMIT_SIZE 10 ------------------ 1534| 56| int n = qn->upper - qn->lower; 1535| | 1536| 56| r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env); ------------------ | | 395| 56|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1537| 56| if (r != 0) return r; ------------------ | Branch (1537:9): [True: 0, False: 56] ------------------ 1538| | 1539| 112| for (i = 0; i < n; i++) { ------------------ | Branch (1539:17): [True: 56, False: 56] ------------------ 1540| 56| int v = onig_positive_int_multiply(n - i, tlen + OPSIZE_PUSH); ------------------ | | 648| 56|#define OPSIZE_PUSH 1 ------------------ 1541| 56| if (v < 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE; ------------------ | | 613| 0|#define ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE -201 ------------------ | Branch (1541:11): [True: 0, False: 56] ------------------ 1542| | 1543| 56| r = add_op(reg, OP_PUSH); 1544| 56| if (r != 0) return r; ------------------ | Branch (1544:11): [True: 0, False: 56] ------------------ 1545| 56| COP(reg)->push.addr = v; ------------------ | | 947| 56|#define COP(reg) ((reg)->ops_curr) ------------------ 1546| | 1547| 56| r = compile_tree(ND_QUANT_BODY(qn), reg, env); ------------------ | | 395| 56|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1548| 56| if (r != 0) return r; ------------------ | Branch (1548:11): [True: 0, False: 56] ------------------ 1549| 56| } 1550| 56| } 1551| 0| else if (! qn->greedy && qn->upper == 1 && qn->lower == 0) { /* '??' */ ------------------ | Branch (1551:12): [True: 0, False: 0] | Branch (1551:28): [True: 0, False: 0] | Branch (1551:46): [True: 0, False: 0] ------------------ 1552| 0| r = add_op(reg, OP_PUSH); 1553| 0| if (r != 0) return r; ------------------ | Branch (1553:9): [True: 0, False: 0] ------------------ 1554| 0| COP(reg)->push.addr = SIZE_INC + OPSIZE_JUMP; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push.addr = SIZE_INC + OPSIZE_JUMP; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ COP(reg)->push.addr = SIZE_INC + OPSIZE_JUMP; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 1555| | 1556| 0| r = add_op(reg, OP_JUMP); 1557| 0| if (r != 0) return r; ------------------ | Branch (1557:9): [True: 0, False: 0] ------------------ 1558| 0| COP(reg)->jump.addr = tlen + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = tlen + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1559| | 1560| 0| r = compile_tree(ND_QUANT_BODY(qn), reg, env); ------------------ | | 395| 0|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1561| 0| } 1562| 0| else { 1563| 0| r = compile_range_repeat_node(qn, mod_tlen, emptiness, reg, env); 1564| 0| } 1565| 46.1k| return r; 1566| 46.1k|} regcomp.c:compile_tree_n_times: 1029| 46.3k|{ 1030| 46.3k| int i, r; 1031| | 1032| 53.6k| for (i = 0; i < n; i++) { ------------------ | Branch (1032:15): [True: 7.25k, False: 46.3k] ------------------ 1033| 7.25k| r = compile_tree(node, reg, env); 1034| 7.25k| if (r != 0) return r; ------------------ | Branch (1034:9): [True: 0, False: 7.25k] ------------------ 1035| 7.25k| } 1036| 46.3k| return 0; 1037| 46.3k|} regcomp.c:compile_quant_body_with_empty_check: 960| 46.0k|{ 961| 46.0k| int r; 962| 46.0k| int saved_num_empty_check; 963| 46.0k| int emptiness; 964| 46.0k| Node* body; 965| | 966| 46.0k| body = ND_BODY((Node* )qn); ------------------ | | 394| 46.0k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 967| 46.0k| emptiness = qn->emptiness; 968| 46.0k| saved_num_empty_check = reg->num_empty_check; 969| | 970| 46.0k| if (emptiness != BODY_IS_NOT_EMPTY) { ------------------ | Branch (970:7): [True: 0, False: 46.0k] ------------------ 971| 0| r = add_op(reg, OP_EMPTY_CHECK_START); 972| 0| if (r != 0) return r; ------------------ | Branch (972:9): [True: 0, False: 0] ------------------ 973| 0| COP(reg)->empty_check_start.mem = reg->num_empty_check; /* NULL CHECK ID */ ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 974| 0| reg->num_empty_check++; 975| 0| } 976| | 977| 46.0k| r = compile_tree(body, reg, env); 978| 46.0k| if (r != 0) return r; ------------------ | Branch (978:7): [True: 0, False: 46.0k] ------------------ 979| | 980| 46.0k| if (emptiness != BODY_IS_NOT_EMPTY) { ------------------ | Branch (980:7): [True: 0, False: 46.0k] ------------------ 981| 0| if (emptiness == BODY_MAY_BE_EMPTY) ------------------ | Branch (981:9): [True: 0, False: 0] ------------------ 982| 0| r = add_op(reg, OP_EMPTY_CHECK_END); 983| 0| else if (emptiness == BODY_MAY_BE_EMPTY_MEM) { ------------------ | Branch (983:14): [True: 0, False: 0] ------------------ 984| 0| if (ND_IS_EMPTY_STATUS_CHECK(qn) != 0 && qn->empty_status_mem != 0) { ------------------ | | 383| 0| ((ND_STATUS(node) & ND_ST_EMPTY_STATUS_CHECK) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | ((ND_STATUS(node) & ND_ST_EMPTY_STATUS_CHECK) != 0) | | ------------------ | | | | 345| 0|#define ND_ST_EMPTY_STATUS_CHECK (1<<20) | | ------------------ ------------------ | Branch (984:11): [True: 0, False: 0] | Branch (984:48): [True: 0, False: 0] ------------------ 985| 0| r = add_op(reg, OP_EMPTY_CHECK_END_MEMST); 986| 0| if (r != 0) return r; ------------------ | Branch (986:13): [True: 0, False: 0] ------------------ 987| 0| COP(reg)->empty_check_end.empty_status_mem = qn->empty_status_mem; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 988| 0| } 989| 0| else 990| 0| r = add_op(reg, OP_EMPTY_CHECK_END); 991| 0| } 992| 0|#ifdef USE_CALL 993| 0| else if (emptiness == BODY_MAY_BE_EMPTY_REC) { ------------------ | Branch (993:14): [True: 0, False: 0] ------------------ 994| 0| r = add_op(reg, OP_EMPTY_CHECK_END_MEMST_PUSH); 995| 0| if (r != 0) return r; ------------------ | Branch (995:11): [True: 0, False: 0] ------------------ 996| 0| COP(reg)->empty_check_end.empty_status_mem = qn->empty_status_mem; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 997| 0| } 998| 0|#endif 999| | 1000| 0| if (r != 0) return r; ------------------ | Branch (1000:9): [True: 0, False: 0] ------------------ 1001| 0| COP(reg)->empty_check_end.mem = saved_num_empty_check; /* NULL CHECK ID */ ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1002| 0| } 1003| 46.0k| return r; 1004| 46.0k|} regcomp.c:compile_bag_node: 1780| 877|{ 1781| 877| int r, len; 1782| | 1783| 877| switch (node->type) { 1784| 803| case BAG_MEMORY: ------------------ | Branch (1784:3): [True: 803, False: 74] ------------------ 1785| 803| r = compile_bag_memory_node(node, reg, env); 1786| 803| break; 1787| | 1788| 0| case BAG_OPTION: ------------------ | Branch (1788:3): [True: 0, False: 877] ------------------ 1789| 0| r = compile_option_node(node, reg, env); 1790| 0| break; 1791| | 1792| 74| case BAG_STOP_BACKTRACK: ------------------ | Branch (1792:3): [True: 74, False: 803] ------------------ 1793| 74| if (ND_IS_STRICT_REAL_REPEAT(node)) { ------------------ | | 381| 74| ((ND_STATUS(node) & ND_ST_STRICT_REAL_REPEAT) != 0) | | ------------------ | | | | 356| 74|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | ((ND_STATUS(node) & ND_ST_STRICT_REAL_REPEAT) != 0) | | ------------------ | | | | 330| 74|#define ND_ST_STRICT_REAL_REPEAT (1<<5) | | ------------------ | | | Branch (381:5): [True: 74, False: 0] | | ------------------ ------------------ 1794| 74| QuantNode* qn = QUANT_(ND_BAG_BODY(node)); ------------------ | | 291| 74|#define QUANT_(node) (&((node)->u.quant)) ------------------ 1795| 74| r = compile_tree_n_times(ND_QUANT_BODY(qn), qn->lower, reg, env); ------------------ | | 395| 74|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1796| 74| if (r != 0) return r; ------------------ | Branch (1796:11): [True: 0, False: 74] ------------------ 1797| | 1798| 74| len = compile_length_tree(ND_QUANT_BODY(qn), reg, env); ------------------ | | 395| 74|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1799| 74| if (len < 0) return len; ------------------ | Branch (1799:11): [True: 0, False: 74] ------------------ 1800| | 1801| 74| r = add_op(reg, OP_PUSH); 1802| 74| if (r != 0) return r; ------------------ | Branch (1802:11): [True: 0, False: 74] ------------------ 1803| 74| COP(reg)->push.addr = SIZE_INC + len + OPSIZE_POP + OPSIZE_JUMP; ------------------ | | 947| 74|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push.addr = SIZE_INC + len + OPSIZE_POP + OPSIZE_JUMP; ------------------ | | 643| 74|#define SIZE_INC 1 ------------------ COP(reg)->push.addr = SIZE_INC + len + OPSIZE_POP + OPSIZE_JUMP; ------------------ | | 650| 74|#define OPSIZE_POP 1 ------------------ COP(reg)->push.addr = SIZE_INC + len + OPSIZE_POP + OPSIZE_JUMP; ------------------ | | 647| 74|#define OPSIZE_JUMP 1 ------------------ 1804| | 1805| 74| r = compile_tree(ND_QUANT_BODY(qn), reg, env); ------------------ | | 395| 74|#define ND_QUANT_BODY(node) ((node)->body) ------------------ 1806| 74| if (r != 0) return r; ------------------ | Branch (1806:11): [True: 0, False: 74] ------------------ 1807| 74| r = add_op(reg, OP_POP); 1808| 74| if (r != 0) return r; ------------------ | Branch (1808:11): [True: 0, False: 74] ------------------ 1809| | 1810| 74| r = add_op(reg, OP_JUMP); 1811| 74| if (r != 0) return r; ------------------ | Branch (1811:11): [True: 0, False: 74] ------------------ 1812| 74| COP(reg)->jump.addr = -((int )OPSIZE_PUSH + len + (int )OPSIZE_POP); ------------------ | | 947| 74|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = -((int )OPSIZE_PUSH + len + (int )OPSIZE_POP); ------------------ | | 648| 74|#define OPSIZE_PUSH 1 ------------------ COP(reg)->jump.addr = -((int )OPSIZE_PUSH + len + (int )OPSIZE_POP); ------------------ | | 650| 74|#define OPSIZE_POP 1 ------------------ 1813| 74| } 1814| 0| else { 1815| 0| MemNumType mid; 1816| | 1817| 0| ID_ENTRY(env, mid); ------------------ | | 409| 0|#define ID_ENTRY(env, id) do {\ | | 410| 0| id = (env)->id_num++;\ | | 411| 0|} while(0) | | ------------------ | | | Branch (411:9): [Folded, False: 0] | | ------------------ ------------------ 1818| 0| r = add_op(reg, OP_MARK); 1819| 0| if (r != 0) return r; ------------------ | Branch (1819:11): [True: 0, False: 0] ------------------ 1820| 0| COP(reg)->mark.id = mid; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1821| 0| COP(reg)->mark.save_pos = 0; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1822| | 1823| 0| r = compile_tree(ND_BAG_BODY(node), reg, env); ------------------ | | 396| 0|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1824| 0| if (r != 0) return r; ------------------ | Branch (1824:11): [True: 0, False: 0] ------------------ 1825| 0| r = add_op(reg, OP_CUT_TO_MARK); 1826| 0| if (r != 0) return r; ------------------ | Branch (1826:11): [True: 0, False: 0] ------------------ 1827| 0| COP(reg)->cut_to_mark.id = mid; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1828| 0| COP(reg)->cut_to_mark.restore_pos = 0; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1829| 0| } 1830| 74| break; 1831| | 1832| 74| case BAG_IF_ELSE: ------------------ | Branch (1832:3): [True: 0, False: 877] ------------------ 1833| 0| { 1834| 0| int cond_len, then_len, else_len, jump_len; 1835| 0| MemNumType mid; 1836| 0| Node* cond = ND_BAG_BODY(node); ------------------ | | 396| 0|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1837| 0| Node* Then = node->te.Then; 1838| 0| Node* Else = node->te.Else; 1839| | 1840| 0| ID_ENTRY(env, mid); ------------------ | | 409| 0|#define ID_ENTRY(env, id) do {\ | | 410| 0| id = (env)->id_num++;\ | | 411| 0|} while(0) | | ------------------ | | | Branch (411:9): [Folded, False: 0] | | ------------------ ------------------ 1841| | 1842| 0| r = add_op(reg, OP_MARK); 1843| 0| if (r != 0) return r; ------------------ | Branch (1843:11): [True: 0, False: 0] ------------------ 1844| 0| COP(reg)->mark.id = mid; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1845| 0| COP(reg)->mark.save_pos = 0; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1846| | 1847| 0| cond_len = compile_length_tree(cond, reg, env); 1848| 0| if (cond_len < 0) return cond_len; ------------------ | Branch (1848:11): [True: 0, False: 0] ------------------ 1849| 0| if (IS_NOT_NULL(Then)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1850| 0| then_len = compile_length_tree(Then, reg, env); 1851| 0| if (then_len < 0) return then_len; ------------------ | Branch (1851:13): [True: 0, False: 0] ------------------ 1852| 0| } 1853| 0| else 1854| 0| then_len = 0; 1855| | 1856| 0| jump_len = cond_len + then_len + OPSIZE_CUT_TO_MARK + OPSIZE_JUMP; ------------------ | | 676| 0|#define OPSIZE_CUT_TO_MARK 1 ------------------ jump_len = cond_len + then_len + OPSIZE_CUT_TO_MARK + OPSIZE_JUMP; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 1857| | 1858| 0| r = add_op(reg, OP_PUSH); 1859| 0| if (r != 0) return r; ------------------ | Branch (1859:11): [True: 0, False: 0] ------------------ 1860| 0| COP(reg)->push.addr = SIZE_INC + jump_len; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push.addr = SIZE_INC + jump_len; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1861| | 1862| 0| r = compile_tree(cond, reg, env); 1863| 0| if (r != 0) return r; ------------------ | Branch (1863:11): [True: 0, False: 0] ------------------ 1864| 0| r = add_op(reg, OP_CUT_TO_MARK); 1865| 0| if (r != 0) return r; ------------------ | Branch (1865:11): [True: 0, False: 0] ------------------ 1866| 0| COP(reg)->cut_to_mark.id = mid; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1867| 0| COP(reg)->cut_to_mark.restore_pos = 0; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1868| | 1869| 0| if (IS_NOT_NULL(Then)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1870| 0| r = compile_tree(Then, reg, env); 1871| 0| if (r != 0) return r; ------------------ | Branch (1871:13): [True: 0, False: 0] ------------------ 1872| 0| } 1873| | 1874| 0| if (IS_NOT_NULL(Else)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1875| 0| else_len = compile_length_tree(Else, reg, env); 1876| 0| if (else_len < 0) return else_len; ------------------ | Branch (1876:13): [True: 0, False: 0] ------------------ 1877| 0| } 1878| 0| else 1879| 0| else_len = 0; 1880| | 1881| 0| r = add_op(reg, OP_JUMP); 1882| 0| if (r != 0) return r; ------------------ | Branch (1882:11): [True: 0, False: 0] ------------------ 1883| 0| COP(reg)->jump.addr = OPSIZE_CUT_TO_MARK + else_len + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = OPSIZE_CUT_TO_MARK + else_len + SIZE_INC; ------------------ | | 676| 0|#define OPSIZE_CUT_TO_MARK 1 ------------------ COP(reg)->jump.addr = OPSIZE_CUT_TO_MARK + else_len + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1884| | 1885| 0| r = add_op(reg, OP_CUT_TO_MARK); 1886| 0| if (r != 0) return r; ------------------ | Branch (1886:11): [True: 0, False: 0] ------------------ 1887| 0| COP(reg)->cut_to_mark.id = mid; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1888| 0| COP(reg)->cut_to_mark.restore_pos = 0; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1889| | 1890| 0| if (IS_NOT_NULL(Else)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1891| 0| r = compile_tree(Else, reg, env); 1892| 0| } 1893| 0| } 1894| 0| break; 1895| | 1896| 0| default: ------------------ | Branch (1896:3): [True: 0, False: 877] ------------------ 1897| 0| return ONIGERR_TYPE_BUG; ------------------ | | 571| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 1898| 0| break; 1899| 877| } 1900| | 1901| 877| return r; 1902| 877|} regcomp.c:compile_bag_memory_node: 1700| 803|{ 1701| 803| int r; 1702| | 1703| 803|#ifdef USE_CALL 1704| 803| if (ND_IS_CALLED(node)) { ------------------ | | 362| 803|#define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 356| 803|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 332| 803|#define ND_ST_CALLED (1<<7) | | ------------------ | | | Branch (362:37): [True: 0, False: 803] | | ------------------ ------------------ 1705| 0| int len; 1706| | 1707| 0| r = add_op(reg, OP_CALL); 1708| 0| if (r != 0) return r; ------------------ | Branch (1708:9): [True: 0, False: 0] ------------------ 1709| | 1710| 0| node->m.called_addr = COP_CURR_OFFSET(reg) + 1 + OPSIZE_JUMP; ------------------ | | 948| 0|#define COP_CURR_OFFSET(reg) ((reg)->ops_used - 1) ------------------ node->m.called_addr = COP_CURR_OFFSET(reg) + 1 + OPSIZE_JUMP; ------------------ | | 647| 0|#define OPSIZE_JUMP 1 ------------------ 1711| 0| ND_STATUS_ADD(node, FIXED_ADDR); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 333| 0|#define ND_ST_FIXED_ADDR (1<<8) | | ------------------ ------------------ 1712| 0| COP(reg)->call.addr = (int )node->m.called_addr; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 1713| | 1714| 0| if (node->m.regnum == 0) { ------------------ | Branch (1714:9): [True: 0, False: 0] ------------------ 1715| 0| len = compile_length_tree(ND_BAG_BODY(node), reg, env); ------------------ | | 396| 0|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1716| 0| len += OPSIZE_RETURN; ------------------ | | 672| 0|#define OPSIZE_RETURN 1 ------------------ 1717| | 1718| 0| r = add_op(reg, OP_JUMP); 1719| 0| if (r != 0) return r; ------------------ | Branch (1719:11): [True: 0, False: 0] ------------------ 1720| 0| COP(reg)->jump.addr = len + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = len + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1721| | 1722| 0| r = compile_tree(ND_BAG_BODY(node), reg, env); ------------------ | | 396| 0|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1723| 0| if (r != 0) return r; ------------------ | Branch (1723:11): [True: 0, False: 0] ------------------ 1724| | 1725| 0| r = add_op(reg, OP_RETURN); 1726| 0| return r; 1727| 0| } 1728| 0| else { 1729| 0| len = compile_length_tree(ND_BAG_BODY(node), reg, env); ------------------ | | 396| 0|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1730| 0| len += (OPSIZE_MEM_START_PUSH + OPSIZE_RETURN); ------------------ | | 663| 0|#define OPSIZE_MEM_START_PUSH 1 ------------------ len += (OPSIZE_MEM_START_PUSH + OPSIZE_RETURN); ------------------ | | 672| 0|#define OPSIZE_RETURN 1 ------------------ 1731| 0| if (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum)) ------------------ | | 367| 0| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 0, False: 0] | | | Branch (367:4): [True: 0, False: 0] | | | Branch (367:15): [True: 0, False: 0] | | ------------------ ------------------ 1732| 0| len += (ND_IS_RECURSION(node) ------------------ | | 364| 0|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 0|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 0] | | ------------------ ------------------ 1733| 0| ? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_PUSH); ------------------ | | 665| 0|#define OPSIZE_MEM_END_PUSH_REC 1 ------------------ ? OPSIZE_MEM_END_PUSH_REC : OPSIZE_MEM_END_PUSH); ------------------ | | 664| 0|#define OPSIZE_MEM_END_PUSH 1 ------------------ 1734| 0| else 1735| 0| len += (ND_IS_RECURSION(node) ? OPSIZE_MEM_END_REC : OPSIZE_MEM_END); ------------------ | | 364| 0|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 0|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 0] | | ------------------ ------------------ len += (ND_IS_RECURSION(node) ? OPSIZE_MEM_END_REC : OPSIZE_MEM_END); ------------------ | | 667| 0|#define OPSIZE_MEM_END_REC 1 ------------------ len += (ND_IS_RECURSION(node) ? OPSIZE_MEM_END_REC : OPSIZE_MEM_END); ------------------ | | 666| 0|#define OPSIZE_MEM_END 1 ------------------ 1736| | 1737| 0| r = add_op(reg, OP_JUMP); 1738| 0| if (r != 0) return r; ------------------ | Branch (1738:11): [True: 0, False: 0] ------------------ 1739| 0| COP(reg)->jump.addr = len + SIZE_INC; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->jump.addr = len + SIZE_INC; ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ 1740| 0| } 1741| 0| } 1742| 803|#endif 1743| | 1744| 803| if (MEM_STATUS_AT0(reg->push_mem_start, node->m.regnum)) ------------------ | | 367| 803| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 803|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 106, False: 697] | | | Branch (367:4): [True: 803, False: 0] | | | Branch (367:15): [True: 803, False: 0] | | ------------------ ------------------ 1745| 106| r = add_op(reg, OP_MEM_START_PUSH); 1746| 697| else 1747| 697| r = add_op(reg, OP_MEM_START); 1748| 803| if (r != 0) return r; ------------------ | Branch (1748:7): [True: 0, False: 803] ------------------ 1749| 803| COP(reg)->memory_start.num = node->m.regnum; ------------------ | | 947| 803|#define COP(reg) ((reg)->ops_curr) ------------------ 1750| | 1751| 803| r = compile_tree(ND_BAG_BODY(node), reg, env); ------------------ | | 396| 803|#define ND_BAG_BODY(node) ((node)->body) ------------------ 1752| 803| if (r != 0) return r; ------------------ | Branch (1752:7): [True: 0, False: 803] ------------------ 1753| | 1754| 803|#ifdef USE_CALL 1755| 803| if (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum)) ------------------ | | 367| 803| ((n) > 0 && (n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 803|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (367:3): [True: 0, False: 803] | | | Branch (367:4): [True: 803, False: 0] | | | Branch (367:15): [True: 803, False: 0] | | ------------------ ------------------ 1756| 0| r = add_op(reg, (ND_IS_RECURSION(node) ------------------ | | 364| 0|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 0|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 0] | | ------------------ ------------------ 1757| 0| ? OP_MEM_END_PUSH_REC : OP_MEM_END_PUSH)); 1758| 803| else 1759| 803| r = add_op(reg, (ND_IS_RECURSION(node) ? OP_MEM_END_REC : OP_MEM_END)); ------------------ | | 364| 803|#define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 356| 803|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_RECURSION(node) ((ND_STATUS(node) & ND_ST_RECURSION) != 0) | | ------------------ | | | | 331| 803|#define ND_ST_RECURSION (1<<6) | | ------------------ | | | Branch (364:37): [True: 0, False: 803] | | ------------------ ------------------ 1760| 803| if (r != 0) return r; ------------------ | Branch (1760:7): [True: 0, False: 803] ------------------ 1761| 803| COP(reg)->memory_end.num = node->m.regnum; ------------------ | | 947| 803|#define COP(reg) ((reg)->ops_curr) ------------------ 1762| | 1763| 803| if (ND_IS_CALLED(node)) { ------------------ | | 362| 803|#define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 356| 803|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_CALLED(node) ((ND_STATUS(node) & ND_ST_CALLED) != 0) | | ------------------ | | | | 332| 803|#define ND_ST_CALLED (1<<7) | | ------------------ | | | Branch (362:37): [True: 0, False: 803] | | ------------------ ------------------ 1764| 0| r = add_op(reg, OP_RETURN); 1765| 0| } 1766| |#else 1767| | if (MEM_STATUS_AT0(reg->push_mem_end, node->m.regnum)) 1768| | r = add_op(reg, OP_MEM_END_PUSH); 1769| | else 1770| | r = add_op(reg, OP_MEM_END); 1771| | if (r != 0) return r; 1772| | COP(reg)->memory_end.num = node->m.regnum; 1773| |#endif 1774| | 1775| 803| return r; 1776| 803|} regcomp.c:compile_anchor_node: 2261| 3.11k|{ 2262| 3.11k| int r, len; 2263| 3.11k| enum OpCode op; 2264| 3.11k| MemNumType mid; 2265| | 2266| 3.11k| switch (node->type) { 2267| 3.06k| case ANCR_BEGIN_BUF: r = add_op(reg, OP_BEGIN_BUF); break; ------------------ | | 461| 3.06k|#define ANCR_BEGIN_BUF (1<<4) ------------------ | Branch (2267:3): [True: 3.06k, False: 55] ------------------ 2268| 0| case ANCR_END_BUF: r = add_op(reg, OP_END_BUF); break; ------------------ | | 464| 0|#define ANCR_END_BUF (1<<7) ------------------ | Branch (2268:3): [True: 0, False: 3.11k] ------------------ 2269| 0| case ANCR_BEGIN_LINE: r = add_op(reg, OP_BEGIN_LINE); break; ------------------ | | 462| 0|#define ANCR_BEGIN_LINE (1<<5) ------------------ | Branch (2269:3): [True: 0, False: 3.11k] ------------------ 2270| 0| case ANCR_END_LINE: r = add_op(reg, OP_END_LINE); break; ------------------ | | 466| 0|#define ANCR_END_LINE (1<<9) ------------------ | Branch (2270:3): [True: 0, False: 3.11k] ------------------ 2271| 42| case ANCR_SEMI_END_BUF: r = add_op(reg, OP_SEMI_END_BUF); break; ------------------ | | 465| 42|#define ANCR_SEMI_END_BUF (1<<8) ------------------ | Branch (2271:3): [True: 42, False: 3.07k] ------------------ 2272| 0| case ANCR_BEGIN_POSITION: ------------------ | | 463| 0|#define ANCR_BEGIN_POSITION (1<<6) ------------------ | Branch (2272:3): [True: 0, False: 3.11k] ------------------ 2273| 0| r = add_op(reg, OP_CHECK_POSITION); 2274| 0| if (r != 0) return r; ------------------ | Branch (2274:9): [True: 0, False: 0] ------------------ 2275| 0| COP(reg)->check_position.type = CHECK_POSITION_SEARCH_START; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2276| 0| break; 2277| | 2278| 0| case ANCR_WORD_BOUNDARY: ------------------ | | 467| 0|#define ANCR_WORD_BOUNDARY (1<<10) ------------------ | Branch (2278:3): [True: 0, False: 3.11k] ------------------ 2279| 0| op = OP_WORD_BOUNDARY; 2280| 0| word: 2281| 0| r = add_op(reg, op); 2282| 0| if (r != 0) return r; ------------------ | Branch (2282:9): [True: 0, False: 0] ------------------ 2283| 0| COP(reg)->word_boundary.mode = (ModeType )node->ascii_mode; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2284| 0| break; 2285| | 2286| 0| case ANCR_NO_WORD_BOUNDARY: ------------------ | | 468| 0|#define ANCR_NO_WORD_BOUNDARY (1<<11) ------------------ | Branch (2286:3): [True: 0, False: 3.11k] ------------------ 2287| 0| op = OP_NO_WORD_BOUNDARY; goto word; 2288| 0| break; 2289| 0|#ifdef USE_WORD_BEGIN_END 2290| 0| case ANCR_WORD_BEGIN: ------------------ | | 469| 0|#define ANCR_WORD_BEGIN (1<<12) ------------------ | Branch (2290:3): [True: 0, False: 3.11k] ------------------ 2291| 0| op = OP_WORD_BEGIN; goto word; 2292| 0| break; 2293| 0| case ANCR_WORD_END: ------------------ | | 470| 0|#define ANCR_WORD_END (1<<13) ------------------ | Branch (2293:3): [True: 0, False: 3.11k] ------------------ 2294| 0| op = OP_WORD_END; goto word; 2295| 0| break; 2296| 0|#endif 2297| | 2298| 0| case ANCR_TEXT_SEGMENT_BOUNDARY: ------------------ | | 473| 0|#define ANCR_TEXT_SEGMENT_BOUNDARY (1<<16) ------------------ | Branch (2298:3): [True: 0, False: 3.11k] ------------------ 2299| 0| case ANCR_NO_TEXT_SEGMENT_BOUNDARY: ------------------ | | 474| 0|#define ANCR_NO_TEXT_SEGMENT_BOUNDARY (1<<17) ------------------ | Branch (2299:3): [True: 0, False: 3.11k] ------------------ 2300| 0| { 2301| 0| enum TextSegmentBoundaryType type; 2302| | 2303| 0| r = add_op(reg, OP_TEXT_SEGMENT_BOUNDARY); 2304| 0| if (r != 0) return r; ------------------ | Branch (2304:11): [True: 0, False: 0] ------------------ 2305| | 2306| 0| type = EXTENDED_GRAPHEME_CLUSTER_BOUNDARY; 2307| 0|#ifdef USE_UNICODE_WORD_BREAK 2308| 0| if (ND_IS_TEXT_SEGMENT_WORD(node)) ------------------ | | 386| 0|#define ND_IS_TEXT_SEGMENT_WORD(node) ((ND_STATUS(node) & ND_ST_TEXT_SEGMENT_WORD) != 0) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_IS_TEXT_SEGMENT_WORD(node) ((ND_STATUS(node) & ND_ST_TEXT_SEGMENT_WORD) != 0) | | ------------------ | | | | 348| 0|#define ND_ST_TEXT_SEGMENT_WORD (1<<23) | | ------------------ | | | Branch (386:40): [True: 0, False: 0] | | ------------------ ------------------ 2309| 0| type = WORD_BOUNDARY; 2310| 0|#endif 2311| | 2312| 0| COP(reg)->text_segment_boundary.type = type; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2313| 0| COP(reg)->text_segment_boundary.not = ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2314| 0| (node->type == ANCR_NO_TEXT_SEGMENT_BOUNDARY ? 1 : 0); ------------------ | | 474| 0|#define ANCR_NO_TEXT_SEGMENT_BOUNDARY (1<<17) ------------------ | Branch (2314:10): [True: 0, False: 0] ------------------ 2315| 0| } 2316| 0| break; 2317| | 2318| 13| case ANCR_PREC_READ: ------------------ | | 456| 13|#define ANCR_PREC_READ (1<<0) ------------------ | Branch (2318:3): [True: 13, False: 3.10k] ------------------ 2319| 13| { 2320| 13| ID_ENTRY(env, mid); ------------------ | | 409| 13|#define ID_ENTRY(env, id) do {\ | | 410| 13| id = (env)->id_num++;\ | | 411| 13|} while(0) | | ------------------ | | | Branch (411:9): [Folded, False: 13] | | ------------------ ------------------ 2321| 13| r = add_op(reg, OP_MARK); 2322| 13| if (r != 0) return r; ------------------ | Branch (2322:11): [True: 0, False: 13] ------------------ 2323| 13| COP(reg)->mark.id = mid; ------------------ | | 947| 13|#define COP(reg) ((reg)->ops_curr) ------------------ 2324| 13| COP(reg)->mark.save_pos = TRUE; ------------------ | | 947| 13|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->mark.save_pos = TRUE; ------------------ | | 59| 13|#define TRUE 1 ------------------ 2325| | 2326| 13| r = compile_tree(ND_ANCHOR_BODY(node), reg, env); ------------------ | | 398| 13|#define ND_ANCHOR_BODY(node) ((node)->body) ------------------ 2327| 13| if (r != 0) return r; ------------------ | Branch (2327:11): [True: 0, False: 13] ------------------ 2328| | 2329| 13| r = add_op(reg, OP_CUT_TO_MARK); 2330| 13| if (r != 0) return r; ------------------ | Branch (2330:11): [True: 0, False: 13] ------------------ 2331| 13| COP(reg)->cut_to_mark.id = mid; ------------------ | | 947| 13|#define COP(reg) ((reg)->ops_curr) ------------------ 2332| 13| COP(reg)->cut_to_mark.restore_pos = TRUE; ------------------ | | 947| 13|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->cut_to_mark.restore_pos = TRUE; ------------------ | | 59| 13|#define TRUE 1 ------------------ 2333| 13| } 2334| 0| break; 2335| | 2336| 0| case ANCR_PREC_READ_NOT: ------------------ | | 457| 0|#define ANCR_PREC_READ_NOT (1<<1) ------------------ | Branch (2336:3): [True: 0, False: 3.11k] ------------------ 2337| 0| { 2338| 0| len = compile_length_tree(ND_ANCHOR_BODY(node), reg, env); ------------------ | | 398| 0|#define ND_ANCHOR_BODY(node) ((node)->body) ------------------ 2339| 0| if (len < 0) return len; ------------------ | Branch (2339:11): [True: 0, False: 0] ------------------ 2340| | 2341| 0| ID_ENTRY(env, mid); ------------------ | | 409| 0|#define ID_ENTRY(env, id) do {\ | | 410| 0| id = (env)->id_num++;\ | | 411| 0|} while(0) | | ------------------ | | | Branch (411:9): [Folded, False: 0] | | ------------------ ------------------ 2342| 0| r = add_op(reg, OP_PUSH); 2343| 0| if (r != 0) return r; ------------------ | Branch (2343:11): [True: 0, False: 0] ------------------ 2344| 0| COP(reg)->push.addr = SIZE_INC + OPSIZE_MARK + len + ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->push.addr = SIZE_INC + OPSIZE_MARK + len + ------------------ | | 643| 0|#define SIZE_INC 1 ------------------ COP(reg)->push.addr = SIZE_INC + OPSIZE_MARK + len + ------------------ | | 677| 0|#define OPSIZE_MARK 1 ------------------ 2345| 0| OPSIZE_POP_TO_MARK + OPSIZE_POP + OPSIZE_FAIL; ------------------ | | 651| 0|#define OPSIZE_POP_TO_MARK 1 ------------------ OPSIZE_POP_TO_MARK + OPSIZE_POP + OPSIZE_FAIL; ------------------ | | 650| 0|#define OPSIZE_POP 1 ------------------ OPSIZE_POP_TO_MARK + OPSIZE_POP + OPSIZE_FAIL; ------------------ | | 661| 0|#define OPSIZE_FAIL 1 ------------------ 2346| | 2347| 0| r = add_op(reg, OP_MARK); 2348| 0| if (r != 0) return r; ------------------ | Branch (2348:11): [True: 0, False: 0] ------------------ 2349| 0| COP(reg)->mark.id = mid; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2350| 0| COP(reg)->mark.save_pos = FALSE; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ COP(reg)->mark.save_pos = FALSE; ------------------ | | 63| 0|#define FALSE 0 ------------------ 2351| | 2352| 0| r = compile_tree(ND_ANCHOR_BODY(node), reg, env); ------------------ | | 398| 0|#define ND_ANCHOR_BODY(node) ((node)->body) ------------------ 2353| 0| if (r != 0) return r; ------------------ | Branch (2353:11): [True: 0, False: 0] ------------------ 2354| | 2355| 0| r = add_op(reg, OP_POP_TO_MARK); 2356| 0| if (r != 0) return r; ------------------ | Branch (2356:11): [True: 0, False: 0] ------------------ 2357| 0| COP(reg)->pop_to_mark.id = mid; ------------------ | | 947| 0|#define COP(reg) ((reg)->ops_curr) ------------------ 2358| | 2359| 0| r = add_op(reg, OP_POP); 2360| 0| if (r != 0) return r; ------------------ | Branch (2360:11): [True: 0, False: 0] ------------------ 2361| 0| r = add_op(reg, OP_FAIL); 2362| 0| } 2363| 0| break; 2364| | 2365| 0| case ANCR_LOOK_BEHIND: ------------------ | | 458| 0|#define ANCR_LOOK_BEHIND (1<<2) ------------------ | Branch (2365:3): [True: 0, False: 3.11k] ------------------ 2366| 0| r = compile_anchor_look_behind_node(node, reg, env); 2367| 0| break; 2368| | 2369| 0| case ANCR_LOOK_BEHIND_NOT: ------------------ | | 459| 0|#define ANCR_LOOK_BEHIND_NOT (1<<3) ------------------ | Branch (2369:3): [True: 0, False: 3.11k] ------------------ 2370| 0| r = compile_anchor_look_behind_not_node(node, reg, env); 2371| 0| break; 2372| | 2373| 0| default: ------------------ | Branch (2373:3): [True: 0, False: 3.11k] ------------------ 2374| 0| return ONIGERR_TYPE_BUG; ------------------ | | 571| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 2375| 0| break; 2376| 3.11k| } 2377| | 2378| 3.11k| return r; 2379| 3.11k|} regcomp.c:add_op: 875| 239k|{ 876| 239k| int r; 877| | 878| 239k| r = ops_new(reg); 879| 239k| if (r != ONIG_NORMAL) return r; ------------------ | | 563| 239k|#define ONIG_NORMAL 0 ------------------ | Branch (879:7): [True: 0, False: 239k] ------------------ 880| | 881| 239k|#ifdef USE_DIRECT_THREADED_CODE 882| 239k| *(reg->ocs + (reg->ops_curr - reg->ops)) = opcode; 883| |#else 884| | reg->ops_curr->opcode = opcode; 885| |#endif 886| | 887| 239k| return 0; 888| 239k|} regcomp.c:ops_new: 117| 239k|{ 118| 239k| if (reg->ops_used >= reg->ops_alloc) { ------------------ | Branch (118:7): [True: 181, False: 239k] ------------------ 119| 181| int r = ops_resize(reg, reg->ops_alloc << 1); 120| 181| if (r != ONIG_NORMAL) return r; ------------------ | | 563| 181|#define ONIG_NORMAL 0 ------------------ | Branch (120:9): [True: 0, False: 181] ------------------ 121| 181| } 122| | 123| 239k| reg->ops_curr = reg->ops + reg->ops_used; 124| 239k| reg->ops_used++; 125| | 126| 239k| xmemset(reg->ops_curr, 0, sizeof(Operation)); ------------------ | | 177| 239k|#define xmemset memset ------------------ 127| 239k| return ONIG_NORMAL; ------------------ | | 563| 239k|#define ONIG_NORMAL 0 ------------------ 128| 239k|} regcomp.c:ops_resize: 84| 47.1k|{ 85| 47.1k|#ifdef USE_DIRECT_THREADED_CODE 86| 47.1k| enum OpCode* cp; 87| 47.1k|#endif 88| 47.1k| Operation* p; 89| 47.1k| size_t size; 90| | 91| 47.1k| if (n == reg->ops_alloc) return ONIG_NORMAL; ------------------ | | 563| 0|#define ONIG_NORMAL 0 ------------------ | Branch (91:7): [True: 0, False: 47.1k] ------------------ 92| 47.1k| if (n <= 0) return ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ | Branch (92:7): [True: 0, False: 47.1k] ------------------ 93| | 94| 47.1k| size = sizeof(Operation) * n; 95| 47.1k| p = (Operation* )xrealloc(reg->ops, size); ------------------ | | 228| 47.1k|#define xrealloc realloc ------------------ 96| 47.1k| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 47.1k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 47.1k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 47.1k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 97| 47.1k| reg->ops = p; 98| | 99| 47.1k|#ifdef USE_DIRECT_THREADED_CODE 100| 47.1k| size = sizeof(enum OpCode) * n; 101| 47.1k| cp = (enum OpCode* )xrealloc(reg->ocs, size); ------------------ | | 228| 47.1k|#define xrealloc realloc ------------------ 102| 47.1k| CHECK_NULL_RETURN_MEMERR(cp); ------------------ | | 204| 47.1k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 47.1k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 47.1k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 103| 47.1k| reg->ocs = cp; 104| 47.1k|#endif 105| | 106| 47.1k| reg->ops_alloc = n; 107| 47.1k| if (reg->ops_used == 0) ------------------ | Branch (107:7): [True: 0, False: 47.1k] ------------------ 108| 0| reg->ops_curr = 0; 109| 47.1k| else 110| 47.1k| reg->ops_curr = reg->ops + (reg->ops_used - 1); 111| | 112| 47.1k| return ONIG_NORMAL; ------------------ | | 563| 47.1k|#define ONIG_NORMAL 0 ------------------ 113| 47.1k|} regcomp.c:set_addr_in_repeat_range: 1243| 46.9k|{ 1244| 46.9k| int i; 1245| | 1246| 46.9k| for (i = 0; i < reg->num_repeat; i++) { ------------------ | Branch (1246:15): [True: 0, False: 46.9k] ------------------ 1247| 0| RepeatRange* p = reg->repeat_range + i; 1248| 0| int offset = p->u.offset; 1249| 0| p->u.pcode = reg->ops + offset; 1250| 0| } 1251| 46.9k|} regcomp.c:ops_make_string_pool: 253| 46.9k|{ 254| 46.9k| int i; 255| 46.9k| int len; 256| 46.9k| int size; 257| 46.9k| UChar* pool; ------------------ | | 80| 46.9k|#define UChar OnigUChar ------------------ 258| 46.9k| UChar* curr; ------------------ | | 80| 46.9k|#define UChar OnigUChar ------------------ 259| | 260| 46.9k| size = ops_calc_size_of_string_pool(reg); 261| 46.9k| if (size <= 0) { ------------------ | Branch (261:7): [True: 46.9k, False: 0] ------------------ 262| 46.9k| return 0; 263| 46.9k| } 264| | 265| 0| curr = pool = (UChar* )xmalloc((size_t )size); ------------------ | | 227| 0|#define xmalloc malloc ------------------ 266| 0| CHECK_NULL_RETURN_MEMERR(pool); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 267| | 268| 0| for (i = 0; i < (int )reg->ops_used; i++) { ------------------ | Branch (268:15): [True: 0, False: 0] ------------------ 269| 0| enum OpCode opcode; 270| 0| Operation* op; 271| | 272| 0| op = reg->ops + i; 273| 0|#ifdef USE_DIRECT_THREADED_CODE 274| 0| opcode = *(reg->ocs + i); 275| |#else 276| | opcode = op->opcode; 277| |#endif 278| | 279| 0| switch (opcode) { 280| 0| case OP_STR_MBN: ------------------ | Branch (280:5): [True: 0, False: 0] ------------------ 281| 0| len = op->exact_len_n.len * op->exact_len_n.n; 282| 0| xmemcpy(curr, op->exact_len_n.s, len); ------------------ | | 181| 0|#define xmemcpy memcpy ------------------ 283| 0| xfree(op->exact_len_n.s); ------------------ | | 230| 0|#define xfree free ------------------ 284| 0| op->exact_len_n.s = curr; 285| 0| curr += len; 286| 0| break; 287| 0| case OP_STR_N: ------------------ | Branch (287:5): [True: 0, False: 0] ------------------ 288| 0| len = op->exact_n.n; 289| 0| copy: 290| 0| xmemcpy(curr, op->exact_n.s, len); ------------------ | | 181| 0|#define xmemcpy memcpy ------------------ 291| 0| xfree(op->exact_n.s); ------------------ | | 230| 0|#define xfree free ------------------ 292| 0| op->exact_n.s = curr; 293| 0| curr += len; 294| 0| break; 295| 0| case OP_STR_MB2N: ------------------ | Branch (295:5): [True: 0, False: 0] ------------------ 296| 0| len = op->exact_n.n * 2; 297| 0| goto copy; 298| 0| break; 299| 0| case OP_STR_MB3N: ------------------ | Branch (299:5): [True: 0, False: 0] ------------------ 300| 0| len = op->exact_n.n * 3; 301| 0| goto copy; 302| 0| break; 303| | 304| 0| default: ------------------ | Branch (304:5): [True: 0, False: 0] ------------------ 305| 0| break; 306| 0| } 307| 0| } 308| | 309| 0| reg->string_pool = pool; 310| 0| reg->string_pool_end = pool + size; 311| 0| return 0; 312| 0|} regcomp.c:ops_calc_size_of_string_pool: 213| 46.9k|{ 214| 46.9k| int i; 215| 46.9k| int total; 216| | 217| 46.9k| if (IS_NULL(reg->ops)) return 0; ------------------ | | 201| 46.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 46.9k] | | ------------------ ------------------ 218| | 219| 46.9k| total = 0; 220| 286k| for (i = 0; i < (int )reg->ops_used; i++) { ------------------ | Branch (220:15): [True: 239k, False: 46.9k] ------------------ 221| 239k| enum OpCode opcode; 222| 239k| Operation* op; 223| | 224| 239k| op = reg->ops + i; 225| 239k|#ifdef USE_DIRECT_THREADED_CODE 226| 239k| opcode = *(reg->ocs + i); 227| |#else 228| | opcode = op->opcode; 229| |#endif 230| | 231| 239k| switch (opcode) { 232| 0| case OP_STR_MBN: ------------------ | Branch (232:5): [True: 0, False: 239k] ------------------ 233| 0| total += op->exact_len_n.len * op->exact_len_n.n; 234| 0| break; 235| 0| case OP_STR_N: ------------------ | Branch (235:5): [True: 0, False: 239k] ------------------ 236| 0| case OP_STR_MB2N: ------------------ | Branch (236:5): [True: 0, False: 239k] ------------------ 237| 0| total += op->exact_n.n * 2; 238| 0| break; 239| 0| case OP_STR_MB3N: ------------------ | Branch (239:5): [True: 0, False: 239k] ------------------ 240| 0| total += op->exact_n.n * 3; 241| 0| break; 242| | 243| 239k| default: ------------------ | Branch (243:5): [True: 239k, False: 0] ------------------ 244| 239k| break; 245| 239k| } 246| 239k| } 247| | 248| 46.9k| return total; 249| 46.9k|} onigenc_init: 87| 1|{ 88| 1| if (OnigEncInited != 0) return 0; ------------------ | Branch (88:7): [True: 0, False: 1] ------------------ 89| | 90| 1| OnigEncInited = 1; 91| 1| return 0; 92| 1|} onig_initialize_encoding: 111| 1|{ 112| 1| int r; 113| | 114| 1| if (enc != ONIG_ENCODING_ASCII && ------------------ | | 189| 2|#define ONIG_ENCODING_ASCII (&OnigEncodingASCII) ------------------ | Branch (114:7): [True: 1, False: 0] ------------------ 115| 1| ONIGENC_IS_ASCII_COMPATIBLE_ENCODING(enc)) { ------------------ | | 284| 1| (((enc)->flag & ENC_FLAG_ASCII_COMPATIBLE) != 0) | | ------------------ | | | | 132| 1|#define ENC_FLAG_ASCII_COMPATIBLE (1<<0) | | ------------------ | | | Branch (284:3): [True: 1, False: 0] | | ------------------ ------------------ 116| 1| OnigEncoding ascii = ONIG_ENCODING_ASCII; ------------------ | | 189| 1|#define ONIG_ENCODING_ASCII (&OnigEncodingASCII) ------------------ 117| 1| if (ascii->init != 0 && enc_is_inited(ascii) == 0) { ------------------ | Branch (117:9): [True: 1, False: 0] | Branch (117:29): [True: 1, False: 0] ------------------ 118| 1| r = ascii->init(); 119| 1| if (r != ONIG_NORMAL) return r; ------------------ | | 563| 1|#define ONIG_NORMAL 0 ------------------ | Branch (119:11): [True: 0, False: 1] ------------------ 120| 1| enc_inited_entry(ascii); 121| 1| } 122| 1| } 123| | 124| 1| if (enc->init != 0 && ------------------ | Branch (124:7): [True: 0, False: 1] ------------------ 125| 0| enc_is_inited(enc) == 0) { ------------------ | Branch (125:7): [True: 0, False: 0] ------------------ 126| 0| r = (enc->init)(); 127| 0| if (r == ONIG_NORMAL) ------------------ | | 563| 0|#define ONIG_NORMAL 0 ------------------ | Branch (127:9): [True: 0, False: 0] ------------------ 128| 0| enc_inited_entry(enc); 129| 0| return r; 130| 0| } 131| | 132| 1| return 0; 133| 1|} onigenc_strdup: 150| 673|{ 151| 673| int slen, term_len, i; 152| 673| UChar *r; ------------------ | | 80| 673|#define UChar OnigUChar ------------------ 153| | 154| 673| slen = (int )(end - s); 155| 673| term_len = ONIGENC_MBC_MINLEN(enc); ------------------ | | 282| 673|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 156| | 157| 673| r = (UChar* )xmalloc(slen + term_len); ------------------ | | 227| 673|#define xmalloc malloc ------------------ 158| 673| CHECK_NULL_RETURN(r); ------------------ | | 203| 673|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 673|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 673] | | | | ------------------ | | ------------------ ------------------ 159| 673| xmemcpy(r, s, slen); ------------------ | | 181| 673|#define xmemcpy memcpy ------------------ 160| | 161| 1.34k| for (i = 0; i < term_len; i++) ------------------ | Branch (161:15): [True: 673, False: 673] ------------------ 162| 673| r[slen + i] = (UChar )0; 163| | 164| 673| return r; 165| 673|} onigenc_get_right_adjust_char_head: 169| 2.14k|{ 170| 2.14k| UChar* p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s); ------------------ | | 80| 2.14k|#define UChar OnigUChar ------------------ UChar* p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s); ------------------ | | 269| 2.14k| (enc)->left_adjust_char_head(start, s) ------------------ 171| 2.14k| if (p < s) { ------------------ | Branch (171:7): [True: 1.13k, False: 1.01k] ------------------ 172| 1.13k| p += enclen(enc, p); ------------------ | | 83| 1.13k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 1.13k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 173| 1.13k| } 174| 2.14k| return p; 175| 2.14k|} onigenc_get_prev_char_head: 196| 40.8k|{ 197| 40.8k| if (s <= start) ------------------ | Branch (197:7): [True: 0, False: 40.8k] ------------------ 198| 0| return (UChar* )NULL; 199| | 200| 40.8k| return ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s - 1); ------------------ | | 269| 40.8k| (enc)->left_adjust_char_head(start, s) ------------------ 201| 40.8k|} onigenc_step_back: 205| 47|{ 206| 94| while (ONIG_IS_NOT_NULL(s) && n-- > 0) { ------------------ | | 75| 188|#define ONIG_IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (75:44): [True: 94, False: 0] | | ------------------ ------------------ | Branch (206:33): [True: 47, False: 47] ------------------ 207| 47| if (s <= start) ------------------ | Branch (207:9): [True: 0, False: 47] ------------------ 208| 0| return (UChar* )NULL; 209| | 210| 47| s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s - 1); ------------------ | | 269| 47| (enc)->left_adjust_char_head(start, s) ------------------ 211| 47| } 212| 47| return (UChar* )s; 213| 47|} onigenc_str_bytelen_null: 265| 8|{ 266| 8| const UChar* start = s; 267| 8| const UChar* p = s; 268| | 269| 51| while (1) { ------------------ | Branch (269:10): [True: 51, Folded] ------------------ 270| 51| if (*p == '\0') { ------------------ | Branch (270:9): [True: 8, False: 43] ------------------ 271| 8| const UChar* q; 272| 8| int len = ONIGENC_MBC_MINLEN(enc); ------------------ | | 282| 8|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 273| | 274| 8| if (len == 1) return (int )(p - start); ------------------ | Branch (274:11): [True: 8, False: 0] ------------------ 275| 0| q = p + 1; 276| 0| while (len > 1) { ------------------ | Branch (276:14): [True: 0, False: 0] ------------------ 277| 0| if (*q != '\0') break; ------------------ | Branch (277:13): [True: 0, False: 0] ------------------ 278| 0| q++; 279| 0| len--; 280| 0| } 281| 0| if (len == 1) return (int )(p - start); ------------------ | Branch (281:11): [True: 0, False: 0] ------------------ 282| 0| } 283| 43| p += ONIGENC_MBC_ENC_LEN(enc, p); ------------------ | | 279| 43|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) ------------------ 284| 43| } 285| 8|} onigenc_is_mbc_newline_0x0a: 702| 76.3M|{ 703| 76.3M| if (p < end) { ------------------ | Branch (703:7): [True: 76.3M, False: 0] ------------------ 704| 76.3M| if (*p == NEWLINE_CODE) return 1; ------------------ | | 81| 76.3M|#define NEWLINE_CODE 0x0a ------------------ | Branch (704:9): [True: 12.3k, False: 76.3M] ------------------ 705| 76.3M| } 706| 76.3M| return 0; 707| 76.3M|} onigenc_single_byte_mbc_enc_len: 722| 86|{ 723| 86| return 1; 724| 86|} onigenc_single_byte_mbc_to_code: 728| 43|{ 729| 43| return (OnigCodePoint )(*p); 730| 43|} onigenc_always_true_is_allowed_reverse_match: 755| 44.0k|{ 756| 44.0k| return TRUE; ------------------ | | 59| 44.0k|#define TRUE 1 ------------------ 757| 44.0k|} onig_codes_cmp: 971| 2.86k|{ 972| 2.86k| int i; 973| | 974| 5.55k| for (i = 0; i < n; i++) { ------------------ | Branch (974:15): [True: 2.86k, False: 2.69k] ------------------ 975| 2.86k| if (a[i] != b[i]) ------------------ | Branch (975:9): [True: 168, False: 2.69k] ------------------ 976| 168| return -1; 977| 2.86k| } 978| | 979| 2.69k| return 0; 980| 2.86k|} onig_codes_byte_at: 984| 20.7k|{ 985| 20.7k| int index; 986| 20.7k| int b; 987| 20.7k| OnigCodePoint code; 988| | 989| 20.7k| index = at / 3; 990| 20.7k| b = at % 3; 991| 20.7k| code = codes[index]; 992| | 993| 20.7k| return ((code >> ((2 - b) * 8)) & 0xff); 994| 20.7k|} regenc.c:enc_is_inited: 71| 1|{ 72| 1| int i; 73| | 74| 1| for (i = 0; i < InitedListNum; i++) { ------------------ | Branch (74:15): [True: 0, False: 1] ------------------ 75| 0| if (InitedList[i].enc == enc) { ------------------ | Branch (75:9): [True: 0, False: 0] ------------------ 76| 0| return InitedList[i].inited; 77| 0| } 78| 0| } 79| | 80| 1| return 0; 81| 1|} regenc.c:enc_inited_entry: 48| 1|{ 49| 1| int i; 50| | 51| 1| for (i = 0; i < InitedListNum; i++) { ------------------ | Branch (51:15): [True: 0, False: 1] ------------------ 52| 0| if (InitedList[i].enc == enc) { ------------------ | Branch (52:9): [True: 0, False: 0] ------------------ 53| 0| InitedList[i].inited = 1; 54| 0| return i; 55| 0| } 56| 0| } 57| | 58| 1| i = InitedListNum; 59| 1| if (i < INITED_LIST_SIZE - 1) { ------------------ | | 37| 1|#define INITED_LIST_SIZE 20 ------------------ | Branch (59:7): [True: 1, False: 0] ------------------ 60| 1| InitedList[i].enc = enc; 61| 1| InitedList[i].inited = 1; 62| 1| InitedListNum++; 63| 1| return i; 64| 1| } 65| | 66| 0| return -1; 67| 1|} onig_region_clear: 906| 140k|{ 907| 140k| int i; 908| | 909| 326k| for (i = 0; i < region->num_regs; i++) { ------------------ | Branch (909:15): [True: 186k, False: 140k] ------------------ 910| 186k| region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS; ------------------ | | 689| 186k|#define ONIG_REGION_NOTPOS -1 ------------------ 911| 186k| } 912| 140k|#ifdef USE_CAPTURE_HISTORY 913| 140k| history_root_free(region); 914| 140k|#endif 915| 140k|} onig_region_resize: 919| 140k|{ 920| 140k| region->num_regs = n; 921| | 922| 140k| if (n < ONIG_NREGION) ------------------ | | 362| 140k|#define ONIG_NREGION 10 ------------------ | Branch (922:7): [True: 140k, False: 0] ------------------ 923| 140k| n = ONIG_NREGION; ------------------ | | 362| 140k|#define ONIG_NREGION 10 ------------------ 924| | 925| 140k| if (region->allocated == 0) { ------------------ | Branch (925:7): [True: 93.7k, False: 46.2k] ------------------ 926| 93.7k| region->beg = (int* )xmalloc(n * sizeof(int)); ------------------ | | 227| 93.7k|#define xmalloc malloc ------------------ 927| 93.7k| region->end = (int* )xmalloc(n * sizeof(int)); ------------------ | | 227| 93.7k|#define xmalloc malloc ------------------ 928| | 929| 93.7k| if (region->beg == 0 || region->end == 0) ------------------ | Branch (929:9): [True: 0, False: 93.7k] | Branch (929:29): [True: 0, False: 93.7k] ------------------ 930| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 931| | 932| 93.7k| region->allocated = n; 933| 93.7k| } 934| 46.2k| else if (region->allocated < n) { ------------------ | Branch (934:12): [True: 0, False: 46.2k] ------------------ 935| 0| region->beg = (int* )xrealloc(region->beg, n * sizeof(int)); ------------------ | | 228| 0|#define xrealloc realloc ------------------ 936| 0| region->end = (int* )xrealloc(region->end, n * sizeof(int)); ------------------ | | 228| 0|#define xrealloc realloc ------------------ 937| | 938| 0| if (region->beg == 0 || region->end == 0) ------------------ | Branch (938:9): [True: 0, False: 0] | Branch (938:29): [True: 0, False: 0] ------------------ 939| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 940| | 941| 0| region->allocated = n; 942| 0| } 943| | 944| 140k| return 0; 945| 140k|} onig_region_init: 975| 46.9k|{ 976| 46.9k| region->num_regs = 0; 977| 46.9k| region->allocated = 0; 978| 46.9k| region->beg = (int* )0; 979| 46.9k| region->end = (int* )0; 980| 46.9k| region->history_root = (OnigCaptureTreeNode* )0; 981| 46.9k|} onig_region_new: 985| 46.9k|{ 986| 46.9k| OnigRegion* r; 987| | 988| 46.9k| r = (OnigRegion* )xmalloc(sizeof(OnigRegion)); ------------------ | | 227| 46.9k|#define xmalloc malloc ------------------ 989| 46.9k| CHECK_NULL_RETURN(r); ------------------ | | 203| 46.9k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 46.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 46.9k] | | | | ------------------ | | ------------------ ------------------ 990| 46.9k| onig_region_init(r); 991| 46.9k| return r; 992| 46.9k|} onig_region_free: 996| 98.2k|{ 997| 98.2k| if (r != 0) { ------------------ | Branch (997:7): [True: 98.2k, False: 0] ------------------ 998| 98.2k| if (r->allocated > 0) { ------------------ | Branch (998:9): [True: 93.7k, False: 4.46k] ------------------ 999| 93.7k| if (r->beg) xfree(r->beg); ------------------ | | 230| 93.7k|#define xfree free ------------------ | Branch (999:11): [True: 93.7k, False: 0] ------------------ 1000| 93.7k| if (r->end) xfree(r->end); ------------------ | | 230| 93.7k|#define xfree free ------------------ | Branch (1000:11): [True: 93.7k, False: 0] ------------------ 1001| 93.7k| r->allocated = 0; 1002| 93.7k| } 1003| 98.2k|#ifdef USE_CAPTURE_HISTORY 1004| 98.2k| history_root_free(r); 1005| 98.2k|#endif 1006| 98.2k| if (free_self) xfree(r); ------------------ | | 230| 46.9k|#define xfree free ------------------ | Branch (1006:9): [True: 46.9k, False: 51.2k] ------------------ 1007| 98.2k| } 1008| 98.2k|} onig_free_match_param_content: 1489| 140k|{ 1490| 140k|#ifdef USE_CALLOUT 1491| 140k| if (IS_NOT_NULL(p->callout_data)) { ------------------ | | 202| 140k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 140k] | | ------------------ ------------------ 1492| 0| xfree(p->callout_data); ------------------ | | 230| 0|#define xfree free ------------------ 1493| 0| p->callout_data = 0; 1494| 0| } 1495| 140k|#endif 1496| 140k|} onig_initialize_match_param: 1509| 140k|{ 1510| 140k| mp->match_stack_limit = MatchStackLimit; 1511| 140k|#ifdef USE_RETRY_LIMIT 1512| 140k| mp->retry_limit_in_match = RetryLimitInMatch; 1513| 140k| mp->retry_limit_in_search = RetryLimitInSearch; 1514| 140k|#endif 1515| | 1516| 140k| mp->callout_user_data = 0; 1517| | 1518| 140k|#ifdef USE_CALLOUT 1519| 140k| mp->progress_callout_of_contents = DefaultProgressCallout; 1520| 140k| mp->retraction_callout_of_contents = DefaultRetractionCallout; 1521| 140k| mp->match_at_call_counter = 0; 1522| 140k| mp->callout_data = 0; 1523| 140k| mp->callout_data_alloc_num = 0; 1524| 140k|#endif 1525| | 1526| 140k| return ONIG_NORMAL; ------------------ | | 563| 140k|#define ONIG_NORMAL 0 ------------------ 1527| 140k|} onig_search: 5443| 140k|{ 5444| 140k| int r; 5445| 140k| OnigMatchParam mp; 5446| 140k| const UChar* data_range; 5447| | 5448| 140k| onig_initialize_match_param(&mp); 5449| | 5450| | /* The following is an expanded code of onig_search_with_param() */ 5451| 140k| if (range > start) ------------------ | Branch (5451:7): [True: 124k, False: 15.7k] ------------------ 5452| 124k| data_range = range; 5453| 15.7k| else 5454| 15.7k| data_range = end; 5455| | 5456| 140k| r = search_in_range(reg, str, end, start, range, data_range, region, 5457| 140k| option, &mp); 5458| | 5459| 140k| onig_free_match_param_content(&mp); 5460| 140k| return r; 5461| | 5462| 140k|} onig_init_for_match_at: 6165| 46.9k|{ 6166| 46.9k| return match_at(reg, (const UChar* )NULL, (const UChar* )NULL, 6167| 46.9k| (const UChar* )NULL, (const UChar* )NULL, 6168| | (MatchArg* )NULL); 6169| 46.9k|} regexec.c:history_root_free: 801| 238k|{ 802| 238k| if (IS_NULL(r->history_root)) return ; ------------------ | | 201| 238k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 238k, False: 0] | | ------------------ ------------------ 803| | 804| 0| history_tree_free(r->history_root); 805| 0| r->history_root = (OnigCaptureTreeNode* )0; 806| 0|} regexec.c:adjust_match_param: 1533| 140k|{ 1534| 140k| RegexExt* ext = reg->extp; 1535| | 1536| 140k| mp->match_at_call_counter = 0; 1537| | 1538| 140k| if (IS_NULL(ext) || ext->callout_num == 0) return ONIG_NORMAL; ------------------ | | 201| 280k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 140k, False: 0] | | ------------------ ------------------ if (IS_NULL(ext) || ext->callout_num == 0) return ONIG_NORMAL; ------------------ | | 563| 140k|#define ONIG_NORMAL 0 ------------------ | Branch (1538:23): [True: 0, False: 0] ------------------ 1539| | 1540| 0| if (ext->callout_num > mp->callout_data_alloc_num) { ------------------ | Branch (1540:7): [True: 0, False: 0] ------------------ 1541| 0| CalloutData* d; 1542| 0| size_t n = ext->callout_num * sizeof(*d); 1543| 0| if (IS_NOT_NULL(mp->callout_data)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 1544| 0| d = (CalloutData* )xrealloc(mp->callout_data, n); ------------------ | | 228| 0|#define xrealloc realloc ------------------ 1545| 0| else 1546| 0| d = (CalloutData* )xmalloc(n); ------------------ | | 227| 0|#define xmalloc malloc ------------------ 1547| 0| CHECK_NULL_RETURN_MEMERR(d); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1548| | 1549| 0| mp->callout_data = d; 1550| 0| mp->callout_data_alloc_num = ext->callout_num; 1551| 0| } 1552| | 1553| 0| xmemset(mp->callout_data, 0, mp->callout_data_alloc_num * sizeof(CalloutData)); ------------------ | | 177| 0|#define xmemset memset ------------------ 1554| 0| return ONIG_NORMAL; ------------------ | | 563| 0|#define ONIG_NORMAL 0 ------------------ 1555| 0|} regexec.c:onig_region_resize_clear: 949| 140k|{ 950| 140k| int r; 951| | 952| 140k| r = onig_region_resize(region, n); 953| 140k| if (r != 0) return r; ------------------ | Branch (953:7): [True: 0, False: 140k] ------------------ 954| 140k| onig_region_clear(region); 955| 140k| return 0; 956| 140k|} regexec.c:match_at: 2865| 173k|{ 2866| | 2867| 173k|#if defined(USE_DIRECT_THREADED_CODE) 2868| 173k| static Operation FinishCode[] = { { .opaddr=&&L_FINISH } }; 2869| |#else 2870| | static Operation FinishCode[] = { { OP_FINISH } }; 2871| |#endif 2872| | 2873| 173k|#ifdef USE_THREADED_CODE 2874| 173k| static const void *opcode_to_label[] = { 2875| 173k| &&L_FINISH, 2876| 173k| &&L_END, 2877| 173k| &&L_STR_1, 2878| 173k| &&L_STR_2, 2879| 173k| &&L_STR_3, 2880| 173k| &&L_STR_4, 2881| 173k| &&L_STR_5, 2882| 173k| &&L_STR_N, 2883| 173k| &&L_STR_MB2N1, 2884| 173k| &&L_STR_MB2N2, 2885| 173k| &&L_STR_MB2N3, 2886| 173k| &&L_STR_MB2N, 2887| 173k| &&L_STR_MB3N, 2888| 173k| &&L_STR_MBN, 2889| 173k| &&L_CCLASS, 2890| 173k| &&L_CCLASS_MB, 2891| 173k| &&L_CCLASS_MIX, 2892| 173k| &&L_CCLASS_NOT, 2893| 173k| &&L_CCLASS_MB_NOT, 2894| 173k| &&L_CCLASS_MIX_NOT, 2895| 173k| &&L_ANYCHAR, 2896| 173k| &&L_ANYCHAR_ML, 2897| 173k| &&L_ANYCHAR_STAR, 2898| 173k| &&L_ANYCHAR_ML_STAR, 2899| 173k| &&L_ANYCHAR_STAR_PEEK_NEXT, 2900| 173k| &&L_ANYCHAR_ML_STAR_PEEK_NEXT, 2901| 173k| &&L_WORD, 2902| 173k| &&L_WORD_ASCII, 2903| 173k| &&L_NO_WORD, 2904| 173k| &&L_NO_WORD_ASCII, 2905| 173k| &&L_WORD_BOUNDARY, 2906| 173k| &&L_NO_WORD_BOUNDARY, 2907| 173k| &&L_WORD_BEGIN, 2908| 173k| &&L_WORD_END, 2909| 173k| &&L_TEXT_SEGMENT_BOUNDARY, 2910| 173k| &&L_BEGIN_BUF, 2911| 173k| &&L_END_BUF, 2912| 173k| &&L_BEGIN_LINE, 2913| 173k| &&L_END_LINE, 2914| 173k| &&L_SEMI_END_BUF, 2915| 173k| &&L_CHECK_POSITION, 2916| 173k| &&L_BACKREF1, 2917| 173k| &&L_BACKREF2, 2918| 173k| &&L_BACKREF_N, 2919| 173k| &&L_BACKREF_N_IC, 2920| 173k| &&L_BACKREF_MULTI, 2921| 173k| &&L_BACKREF_MULTI_IC, 2922| 173k|#ifdef USE_BACKREF_WITH_LEVEL 2923| 173k| &&L_BACKREF_WITH_LEVEL, 2924| 173k| &&L_BACKREF_WITH_LEVEL_IC, 2925| 173k|#endif 2926| 173k| &&L_BACKREF_CHECK, 2927| 173k|#ifdef USE_BACKREF_WITH_LEVEL 2928| 173k| &&L_BACKREF_CHECK_WITH_LEVEL, 2929| 173k|#endif 2930| 173k| &&L_MEM_START, 2931| 173k| &&L_MEM_START_PUSH, 2932| 173k| &&L_MEM_END_PUSH, 2933| 173k|#ifdef USE_CALL 2934| 173k| &&L_MEM_END_PUSH_REC, 2935| 173k|#endif 2936| 173k| &&L_MEM_END, 2937| 173k|#ifdef USE_CALL 2938| 173k| &&L_MEM_END_REC, 2939| 173k|#endif 2940| 173k| &&L_FAIL, 2941| 173k| &&L_JUMP, 2942| 173k| &&L_PUSH, 2943| 173k| &&L_PUSH_SUPER, 2944| 173k| &&L_POP, 2945| 173k| &&L_POP_TO_MARK, 2946| 173k|#ifdef USE_OP_PUSH_OR_JUMP_EXACT 2947| 173k| &&L_PUSH_OR_JUMP_EXACT1, 2948| 173k|#endif 2949| 173k| &&L_PUSH_IF_PEEK_NEXT, 2950| 173k| &&L_REPEAT, 2951| 173k| &&L_REPEAT_NG, 2952| 173k| &&L_REPEAT_INC, 2953| 173k| &&L_REPEAT_INC_NG, 2954| 173k| &&L_EMPTY_CHECK_START, 2955| 173k| &&L_EMPTY_CHECK_END, 2956| 173k| &&L_EMPTY_CHECK_END_MEMST, 2957| 173k|#ifdef USE_CALL 2958| 173k| &&L_EMPTY_CHECK_END_MEMST_PUSH, 2959| 173k|#endif 2960| 173k| &&L_MOVE, 2961| 173k| &&L_STEP_BACK_START, 2962| 173k| &&L_STEP_BACK_NEXT, 2963| 173k| &&L_CUT_TO_MARK, 2964| 173k| &&L_MARK, 2965| 173k| &&L_SAVE_VAL, 2966| 173k| &&L_UPDATE_VAR, 2967| 173k|#ifdef USE_CALL 2968| 173k| &&L_CALL, 2969| 173k| &&L_RETURN, 2970| 173k|#endif 2971| 173k|#ifdef USE_CALLOUT 2972| 173k| &&L_CALLOUT_CONTENTS, 2973| 173k| &&L_CALLOUT_NAME, 2974| 173k|#endif 2975| 173k| }; 2976| 173k|#endif 2977| | 2978| 173k| int i, n, num_mem, best_len, pop_level; 2979| 173k| LengthType tlen, tlen2; 2980| 173k| MemNumType mem; 2981| 173k| RelAddrType addr; 2982| 173k| UChar *s, *ps; ------------------ | | 80| 173k|#define UChar OnigUChar ------------------ 2983| 173k| UChar *right_range; ------------------ | | 80| 173k|#define UChar OnigUChar ------------------ 2984| 173k| int is_alloca; 2985| 173k| char *alloc_base; 2986| 173k| StackType *stk_base, *stk, *stk_end; 2987| 173k| StackType *stkp; /* used as any purpose. */ 2988| 173k| StkPtrType *mem_start_stk, *mem_end_stk; 2989| 173k| UChar* keep; ------------------ | | 80| 173k|#define UChar OnigUChar ------------------ 2990| 173k| OnigRegion* region; 2991| | 2992| |#ifdef USE_REPEAT_AND_EMPTY_CHECK_LOCAL_VAR 2993| | StackIndex *repeat_stk; 2994| | StackIndex *empty_check_stk; 2995| |#endif 2996| 173k|#ifdef USE_RETRY_LIMIT 2997| 173k| unsigned long retry_limit_in_match; 2998| 173k| unsigned long retry_in_match_counter; 2999| 173k|#endif 3000| 173k|#ifdef USE_CALLOUT 3001| 173k| int of; 3002| 173k|#endif 3003| |#ifdef ONIG_DEBUG_MATCH_COUNTER 3004| |#define MAX_SUBEXP_CALL_COUNTERS 9 3005| | unsigned long subexp_call_counters[MAX_SUBEXP_CALL_COUNTERS]; 3006| |#endif 3007| | 3008| 173k| OnigOptionType options; 3009| 173k| Operation* p = reg->ops; 3010| 173k| OnigEncoding encode = reg->enc; 3011| 173k| OnigCaseFoldType case_fold_flag = reg->case_fold_flag; 3012| | 3013| 173k|#ifdef USE_CALL 3014| 173k| unsigned long subexp_call_nest_counter = 0; 3015| 173k|#endif 3016| | 3017| |#ifdef ONIG_DEBUG_MATCH 3018| | static unsigned int counter = 1; 3019| |#endif 3020| | 3021| |#ifdef ONIG_DEBUG_MATCH_COUNTER 3022| | for (i = 0; i < MAX_SUBEXP_CALL_COUNTERS; i++) { 3023| | subexp_call_counters[i] = 0; 3024| | } 3025| |#endif 3026| | 3027| 173k|#ifdef USE_DIRECT_THREADED_CODE 3028| 173k| if (IS_NULL(msa)) { ------------------ | | 201| 173k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 46.9k, False: 126k] | | ------------------ ------------------ 3029| 286k| for (i = 0; i < reg->ops_used; i++) { ------------------ | Branch (3029:17): [True: 239k, False: 46.9k] ------------------ 3030| 239k| const void* addr; 3031| 239k| addr = opcode_to_label[reg->ocs[i]]; 3032| 239k| p->opaddr = addr; 3033| 239k| p++; 3034| 239k| } 3035| 46.9k| return ONIG_NORMAL; ------------------ | | 563| 46.9k|#define ONIG_NORMAL 0 ------------------ 3036| 46.9k| } 3037| 126k|#endif 3038| | 3039| 126k| options = msa->options; 3040| | 3041| 126k|#ifdef USE_CALLOUT 3042| 126k| msa->mp->match_at_call_counter++; 3043| 126k|#endif 3044| | 3045| 126k|#ifdef USE_RETRY_LIMIT 3046| 126k| retry_limit_in_match = msa->retry_limit_in_match; 3047| 126k| if (msa->retry_limit_in_search != 0) { ------------------ | Branch (3047:7): [True: 0, False: 126k] ------------------ 3048| 0| unsigned long rem = msa->retry_limit_in_search 3049| 0| - msa->retry_limit_in_search_counter; 3050| 0| if (rem < retry_limit_in_match || retry_limit_in_match == 0) ------------------ | Branch (3050:9): [True: 0, False: 0] | Branch (3050:39): [True: 0, False: 0] ------------------ 3051| 0| retry_limit_in_match = rem; 3052| 0| } 3053| 126k|#endif 3054| | 3055| 126k| pop_level = reg->stack_pop_level; 3056| 126k| num_mem = reg->num_mem; 3057| 126k| STACK_INIT(INIT_MATCH_STACK_SIZE); ------------------ | | 1329| 126k|#define STACK_INIT(stack_num) do {\ | | 1330| 126k| if (msa->stack_p) {\ | | ------------------ | | | Branch (1330:7): [True: 28.5k, False: 98.1k] | | ------------------ | | 1331| 28.5k| is_alloca = 0;\ | | 1332| 28.5k| alloc_base = msa->stack_p;\ | | 1333| 28.5k| stk_base = (StackType* )(alloc_base\ | | 1334| 28.5k| + (sizeof(StkPtrType) * msa->ptr_num));\ | | 1335| 28.5k| stk = stk_base;\ | | 1336| 28.5k| stk_end = stk_base + msa->stack_n;\ | | 1337| 28.5k| }\ | | 1338| 126k| else if (msa->ptr_num > ALLOCA_PTR_NUM_LIMIT) {\ | | ------------------ | | | | 1327| 98.1k|#define ALLOCA_PTR_NUM_LIMIT 50 | | ------------------ | | | Branch (1338:12): [True: 0, False: 98.1k] | | ------------------ | | 1339| 0| is_alloca = 0;\ | | 1340| 0| alloc_base = (char* )xmalloc(sizeof(StkPtrType) * msa->ptr_num\ | | ------------------ | | | | 227| 0|#define xmalloc malloc | | ------------------ | | 1341| 0| + sizeof(StackType) * (stack_num));\ | | 1342| 0| CHECK_NULL_RETURN_MEMERR(alloc_base);\ | | ------------------ | | | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | ------------------ | | | | | | | Branch (201:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 570| 0|#define ONIGERR_MEMORY -5 | | | | ------------------ | | ------------------ | | 1343| 0| stk_base = (StackType* )(alloc_base\ | | 1344| 0| + (sizeof(StkPtrType) * msa->ptr_num));\ | | 1345| 0| stk = stk_base;\ | | 1346| 0| stk_end = stk_base + (stack_num);\ | | 1347| 0| }\ | | 1348| 98.1k| else {\ | | 1349| 98.1k| is_alloca = 1;\ | | 1350| 98.1k| alloc_base = (char* )xalloca(sizeof(StkPtrType) * msa->ptr_num\ | | ------------------ | | | | 271| 98.1k|#define xalloca alloca | | ------------------ | | 1351| 98.1k| + sizeof(StackType) * (stack_num));\ | | 1352| 98.1k| CHECK_NULL_RETURN_MEMERR(alloc_base);\ | | ------------------ | | | | 204| 98.1k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 201| 98.1k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | ------------------ | | | | | | | Branch (201:39): [True: 0, False: 98.1k] | | | | | | ------------------ | | | | ------------------ | | | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 570| 0|#define ONIGERR_MEMORY -5 | | | | ------------------ | | ------------------ | | 1353| 98.1k| stk_base = (StackType* )(alloc_base\ | | 1354| 98.1k| + (sizeof(StkPtrType) * msa->ptr_num));\ | | 1355| 98.1k| stk = stk_base;\ | | 1356| 98.1k| stk_end = stk_base + (stack_num);\ | | 1357| 98.1k| }\ | | 1358| 126k|} while(0); | | ------------------ | | | Branch (1358:9): [Folded, False: 126k] | | ------------------ ------------------ 3058| 126k| UPDATE_FOR_STACK_REALLOC; ------------------ | | 1232| 126k|#define UPDATE_FOR_STACK_REALLOC do{\ | | 1233| 126k| mem_start_stk = (StkPtrType* )alloc_base;\ | | 1234| 126k| mem_end_stk = mem_start_stk + num_mem + 1;\ | | 1235| 126k|} while(0) | | ------------------ | | | Branch (1235:9): [Folded, False: 126k] | | ------------------ ------------------ 3059| 189k| for (i = 1; i <= num_mem; i++) { ------------------ | Branch (3059:15): [True: 63.1k, False: 126k] ------------------ 3060| 63.1k| mem_start_stk[i].i = mem_end_stk[i].i = INVALID_STACK_INDEX; ------------------ | | 1133| 63.1k|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ 3061| 63.1k| } 3062| | 3063| |#ifdef ONIG_DEBUG_MATCH 3064| | fprintf(DBGFP, "match_at: str: %p, end: %p, start: %p\n", str, end, sstart); 3065| | fprintf(DBGFP, "size: %d, start offset: %d\n", 3066| | (int )(end - str), (int )(sstart - str)); 3067| |#endif 3068| | 3069| 126k| best_len = ONIG_MISMATCH; ------------------ | | 565| 126k|#define ONIG_MISMATCH -1 ------------------ 3070| 126k| keep = s = (UChar* )sstart; 3071| 126k| STACK_PUSH_BOTTOM(STK_ALT, FinishCode); /* bottom stack */ ------------------ | | 1835| 126k|#define STACK_PUSH_BOTTOM(stack_type,pat) do {\ | | 1836| 126k| stk->type = (stack_type);\ | | 1837| 126k| stk->u.state.pcode = (pat);\ | | 1838| 126k| STACK_INC;\ | | ------------------ | | | | 2742| 126k|#define STACK_INC stk++ | | ------------------ | | 1839| 126k|} while (0) | | ------------------ | | | Branch (1839:10): [Folded, False: 126k] | | ------------------ ------------------ 3072| 126k| INIT_RIGHT_RANGE; ------------------ | | 2523| 126k|#define INIT_RIGHT_RANGE right_range = (UChar* )in_right_range ------------------ 3073| | 3074| 126k|#ifdef USE_RETRY_LIMIT 3075| 126k| retry_in_match_counter = 0; 3076| 126k|#endif 3077| | 3078| 126k| BYTECODE_INTERPRETER_START { ------------------ | | 2761| 126k|#define BYTECODE_INTERPRETER_START GOTO_OP; | | ------------------ | | | | 2768| 126k|#define GOTO_OP goto *(p->opaddr) | | ------------------ ------------------ 3079| 126k| CASE_OP(END) ------------------ | | 2763| 108k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3080| 108k| if (OPTON_MATCH_WHOLE_STRING(options)) { ------------------ | | 424| 108k|#define OPTON_MATCH_WHOLE_STRING(option) ((option) & ONIG_OPTION_MATCH_WHOLE_STRING) | | ------------------ | | | | 404| 108k|#define ONIG_OPTION_MATCH_WHOLE_STRING (ONIG_OPTION_CALLBACK_EACH_MATCH << 1) | | | | ------------------ | | | | | | 403| 108k|#define ONIG_OPTION_CALLBACK_EACH_MATCH (ONIG_OPTION_NOT_BEGIN_POSITION << 1) | | | | | | ------------------ | | | | | | | | 402| 108k|#define ONIG_OPTION_NOT_BEGIN_POSITION (ONIG_OPTION_NOT_END_STRING << 1) | | | | | | | | ------------------ | | | | | | | | | | 401| 108k|#define ONIG_OPTION_NOT_END_STRING (ONIG_OPTION_NOT_BEGIN_STRING << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 400| 108k|#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 398| 108k|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 397| 108k|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 396| 108k|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 395| 108k|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 394| 108k|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 393| 108k|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 392| 108k|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 390| 108k|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 389| 108k|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 388| 108k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 387| 108k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 108k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 108k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 108k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 108k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 108k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 108k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 108k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 108k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 108k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (424:43): [True: 0, False: 108k] | | ------------------ ------------------ 3081| 0| if (! ON_STR_END(s)) goto fail; ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) ------------------ | Branch (3081:13): [True: 0, False: 0] ------------------ 3082| 0| } 3083| | 3084| 108k| n = (int )(s - sstart); 3085| 108k| if (n == 0 && OPTON_FIND_NOT_EMPTY(options)) { ------------------ | | 410| 57.2k|#define OPTON_FIND_NOT_EMPTY(option) ((option) & ONIG_OPTION_FIND_NOT_EMPTY) | | ------------------ | | | | 382| 57.2k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 381| 57.2k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 380| 57.2k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 379| 57.2k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 378| 57.2k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 377| 57.2k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (410:38): [True: 10.7k, False: 46.5k] | | ------------------ ------------------ | Branch (3085:11): [True: 57.2k, False: 51.2k] ------------------ 3086| 10.7k| best_len = ONIG_MISMATCH; ------------------ | | 565| 10.7k|#define ONIG_MISMATCH -1 ------------------ 3087| 10.7k| goto fail; /* for retry */ 3088| 10.7k| } 3089| | 3090| 97.8k|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 3091| 97.8k| if (OPTON_FIND_LONGEST(options)) { ------------------ | | 409| 97.8k|#define OPTON_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 381| 97.8k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 380| 97.8k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 379| 97.8k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 378| 97.8k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 377| 97.8k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:38): [True: 0, False: 97.8k] | | ------------------ ------------------ 3092| 0| if (n > best_len) { ------------------ | Branch (3092:13): [True: 0, False: 0] ------------------ 3093| 0| if (n > msa->best_len) { ------------------ | Branch (3093:15): [True: 0, False: 0] ------------------ 3094| 0| best_len = n; 3095| 0| msa->best_len = n; 3096| 0| msa->best_s = (UChar* )sstart; 3097| 0| } 3098| 0| else { 3099| 0| if (s >= in_right_range && msa->best_s == sstart) { ------------------ | Branch (3099:17): [True: 0, False: 0] | Branch (3099:40): [True: 0, False: 0] ------------------ 3100| 0| goto op_end_out; 3101| 0| } 3102| 0| else { 3103| 0| goto fail; /* for retry */ 3104| 0| } 3105| 0| } 3106| 0| } 3107| 0| else { 3108| 0| goto fail; /* for retry */ 3109| 0| } 3110| 0| } 3111| 97.8k| else { 3112| 97.8k| best_len = n; 3113| 97.8k| } 3114| |#else 3115| | best_len = n; 3116| |#endif 3117| | 3118| | /* set region */ 3119| 97.8k| region = msa->region; 3120| 97.8k| if (region) { ------------------ | Branch (3120:11): [True: 97.8k, False: 0] ------------------ 3121| 97.8k| if (keep > s) keep = s; ------------------ | Branch (3121:13): [True: 0, False: 97.8k] ------------------ 3122| | 3123| |#ifdef USE_POSIX_API 3124| | if (OPTON_POSIX_REGION(options)) { 3125| | posix_regmatch_t* rmt = (posix_regmatch_t* )region; 3126| | 3127| | rmt[0].rm_so = (regoff_t )(keep - str); 3128| | rmt[0].rm_eo = (regoff_t )(s - str); 3129| | for (i = 1; i <= num_mem; i++) { 3130| | if (mem_end_stk[i].i != INVALID_STACK_INDEX) { 3131| | rmt[i].rm_so = (regoff_t )(STACK_MEM_START(reg, i) - str); 3132| | rmt[i].rm_eo = (regoff_t )(STACK_MEM_END(reg, i) - str); 3133| | } 3134| | else { 3135| | rmt[i].rm_so = rmt[i].rm_eo = ONIG_REGION_NOTPOS; 3136| | } 3137| | } 3138| | } 3139| | else { 3140| |#endif /* USE_POSIX_API */ 3141| 97.8k| region->beg[0] = (int )(keep - str); 3142| 97.8k| region->end[0] = (int )(s - str); 3143| 143k| for (i = 1; i <= num_mem; i++) { ------------------ | Branch (3143:23): [True: 45.4k, False: 97.8k] ------------------ 3144| 45.4k| if (mem_end_stk[i].i != INVALID_STACK_INDEX) { ------------------ | | 1133| 45.4k|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3144:17): [True: 44.9k, False: 481] ------------------ 3145| 44.9k| region->beg[i] = (int )(STACK_MEM_START(reg, i) - str); ------------------ | | 50| 44.9k| (MEM_STATUS_AT((reg)->push_mem_start, (idx)) != 0 ? \ | | ------------------ | | | | 365| 44.9k| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 44.9k|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 44.9k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (50:4): [True: 374, False: 44.5k] | | ------------------ | | 51| 44.9k| STACK_AT(mem_start_stk[idx].i)->u.mem.pstr : mem_start_stk[idx].s) | | ------------------ | | | | 1793| 374|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3146| 44.9k| region->end[i] = (int )(STACK_MEM_END(reg, i) - str); ------------------ | | 54| 44.9k| (MEM_STATUS_AT((reg)->push_mem_end, (idx)) != 0 ? \ | | ------------------ | | | | 365| 44.9k| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 44.9k|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 44.9k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (54:4): [True: 0, False: 44.9k] | | ------------------ | | 55| 44.9k| STACK_AT(mem_end_stk[idx].i)->u.mem.pstr : mem_end_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3147| 44.9k| } 3148| 481| else { 3149| 481| region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS; ------------------ | | 689| 481|#define ONIG_REGION_NOTPOS -1 ------------------ 3150| 481| } 3151| 45.4k| } 3152| | 3153| 97.8k|#ifdef USE_CAPTURE_HISTORY 3154| 97.8k| if (reg->capture_history != 0) { ------------------ | Branch (3154:15): [True: 0, False: 97.8k] ------------------ 3155| 0| OnigCaptureTreeNode* node; 3156| | 3157| 0| if (IS_NULL(region->history_root)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 3158| 0| region->history_root = node = history_node_new(); 3159| 0| CHECK_NULL_RETURN_MEMERR(node); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 3160| 0| } 3161| 0| else { 3162| 0| node = region->history_root; 3163| 0| history_tree_clear(node); 3164| 0| } 3165| | 3166| 0| node->group = 0; 3167| 0| node->beg = (int )(keep - str); 3168| 0| node->end = (int )(s - str); 3169| | 3170| 0| stkp = stk_base; 3171| 0| i = make_capture_history_tree(region->history_root, &stkp, 3172| 0| stk, (UChar* )str, reg); 3173| 0| if (i < 0) MATCH_AT_ERROR_RETURN(i); ------------------ | | 2844| 0|#define MATCH_AT_ERROR_RETURN(err_code) do {\ | | 2845| 0| best_len = err_code; goto match_at_end;\ | | 2846| 0|} while(0) | | ------------------ | | | Branch (2846:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (3173:17): [True: 0, False: 0] ------------------ 3174| 0| } 3175| 97.8k|#endif /* USE_CAPTURE_HISTORY */ 3176| |#ifdef USE_POSIX_API 3177| | } /* else OPTON_POSIX_REGION() */ 3178| |#endif 3179| 97.8k| } /* if (region) */ 3180| | 3181| 97.8k| if (OPTON_CALLBACK_EACH_MATCH(options) && ------------------ | | 408| 195k| ((option) & ONIG_OPTION_CALLBACK_EACH_MATCH) | | ------------------ | | | | 403| 97.8k|#define ONIG_OPTION_CALLBACK_EACH_MATCH (ONIG_OPTION_NOT_BEGIN_POSITION << 1) | | | | ------------------ | | | | | | 402| 97.8k|#define ONIG_OPTION_NOT_BEGIN_POSITION (ONIG_OPTION_NOT_END_STRING << 1) | | | | | | ------------------ | | | | | | | | 401| 97.8k|#define ONIG_OPTION_NOT_END_STRING (ONIG_OPTION_NOT_BEGIN_STRING << 1) | | | | | | | | ------------------ | | | | | | | | | | 400| 97.8k|#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 398| 97.8k|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 397| 97.8k|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 396| 97.8k|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 395| 97.8k|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 394| 97.8k|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 393| 97.8k|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 392| 97.8k|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 390| 97.8k|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 389| 97.8k|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 388| 97.8k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 387| 97.8k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 97.8k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 97.8k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 97.8k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 97.8k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 97.8k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 97.8k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 97.8k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 97.8k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 97.8k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (408:9): [True: 0, False: 97.8k] | | ------------------ ------------------ 3182| 0| IS_NOT_NULL(CallbackEachMatch)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 3183| 0| i = CallbackEachMatch(str, end, sstart, region, 3184| 0| msa->mp->callout_user_data); 3185| 0| if (i < 0) { ------------------ | Branch (3185:13): [True: 0, False: 0] ------------------ 3186| 0| SOP_OUT; 3187| 0| MATCH_AT_ERROR_RETURN(i); ------------------ | | 2844| 0|#define MATCH_AT_ERROR_RETURN(err_code) do {\ | | 2845| 0| best_len = err_code; goto match_at_end;\ | | 2846| 0|} while(0) | | ------------------ | | | Branch (2846:9): [Folded, False: 0] | | ------------------ ------------------ 3188| 0| } 3189| 0|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 3190| 0| if (! OPTON_FIND_LONGEST(options)) ------------------ | | 409| 0|#define OPTON_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (3190:13): [True: 0, False: 0] ------------------ 3191| 0|#endif 3192| 0| best_len = ONIG_MISMATCH; ------------------ | | 565| 0|#define ONIG_MISMATCH -1 ------------------ 3193| | 3194| 0| goto fail; 3195| 0| } 3196| | 3197| 97.8k|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 3198| 97.8k| if (OPTON_FIND_LONGEST(options)) goto fail; ------------------ | | 409| 97.8k|#define OPTON_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 381| 97.8k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 380| 97.8k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 379| 97.8k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 378| 97.8k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 377| 97.8k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:38): [True: 0, False: 97.8k] | | ------------------ ------------------ 3199| 97.8k|#endif 3200| | 3201| 97.8k| op_end_out: 3202| | /* default behavior: return first-matching result. */ 3203| 97.8k| SOP_OUT; 3204| 97.8k| goto match_at_end; 3205| | 3206| 68.9M| CASE_OP(STR_1) ------------------ | | 2763| 68.9M|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3207| 68.9M| DATA_ENSURE(1); ------------------ | | 2521| 68.9M|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 3.48k, False: 68.9M] | | ------------------ ------------------ 3208| 68.9M| ps = p->exact.s; 3209| 68.9M| if (*ps != *s) goto fail; ------------------ | Branch (3209:11): [True: 68.0M, False: 880k] ------------------ 3210| 880k| s++; 3211| 880k| INC_OP; ------------------ | | 2790| 880k|#define INC_OP p++ ------------------ 3212| 880k| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 880k|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 880k|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 880k|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 880k|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3213| | 3214| 880k| CASE_OP(STR_2) ------------------ | | 2763| 904|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3215| 904| DATA_ENSURE(2); ------------------ | | 2521| 904|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 904] | | ------------------ ------------------ 3216| 904| ps = p->exact.s; 3217| 904| if (*ps != *s) goto fail; ------------------ | Branch (3217:11): [True: 0, False: 904] ------------------ 3218| 904| ps++; s++; 3219| 904| if (*ps != *s) goto fail; ------------------ | Branch (3219:11): [True: 0, False: 904] ------------------ 3220| 904| s++; 3221| 904| INC_OP; ------------------ | | 2790| 904|#define INC_OP p++ ------------------ 3222| 904| JUMP_OUT; ------------------ | | 2792| 904|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 904|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 904|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3223| | 3224| 904| CASE_OP(STR_3) ------------------ | | 2763| 10|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3225| 10| DATA_ENSURE(3); ------------------ | | 2521| 10|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 10] | | ------------------ ------------------ 3226| 10| ps = p->exact.s; 3227| 10| if (*ps != *s) goto fail; ------------------ | Branch (3227:11): [True: 0, False: 10] ------------------ 3228| 10| ps++; s++; 3229| 10| if (*ps != *s) goto fail; ------------------ | Branch (3229:11): [True: 0, False: 10] ------------------ 3230| 10| ps++; s++; 3231| 10| if (*ps != *s) goto fail; ------------------ | Branch (3231:11): [True: 0, False: 10] ------------------ 3232| 10| s++; 3233| 10| INC_OP; ------------------ | | 2790| 10|#define INC_OP p++ ------------------ 3234| 10| JUMP_OUT; ------------------ | | 2792| 10|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 10|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 10|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3235| | 3236| 10| CASE_OP(STR_4) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3237| 0| DATA_ENSURE(4); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3238| 0| ps = p->exact.s; 3239| 0| if (*ps != *s) goto fail; ------------------ | Branch (3239:11): [True: 0, False: 0] ------------------ 3240| 0| ps++; s++; 3241| 0| if (*ps != *s) goto fail; ------------------ | Branch (3241:11): [True: 0, False: 0] ------------------ 3242| 0| ps++; s++; 3243| 0| if (*ps != *s) goto fail; ------------------ | Branch (3243:11): [True: 0, False: 0] ------------------ 3244| 0| ps++; s++; 3245| 0| if (*ps != *s) goto fail; ------------------ | Branch (3245:11): [True: 0, False: 0] ------------------ 3246| 0| s++; 3247| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3248| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3249| | 3250| 0| CASE_OP(STR_5) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3251| 0| DATA_ENSURE(5); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3252| 0| ps = p->exact.s; 3253| 0| if (*ps != *s) goto fail; ------------------ | Branch (3253:11): [True: 0, False: 0] ------------------ 3254| 0| ps++; s++; 3255| 0| if (*ps != *s) goto fail; ------------------ | Branch (3255:11): [True: 0, False: 0] ------------------ 3256| 0| ps++; s++; 3257| 0| if (*ps != *s) goto fail; ------------------ | Branch (3257:11): [True: 0, False: 0] ------------------ 3258| 0| ps++; s++; 3259| 0| if (*ps != *s) goto fail; ------------------ | Branch (3259:11): [True: 0, False: 0] ------------------ 3260| 0| ps++; s++; 3261| 0| if (*ps != *s) goto fail; ------------------ | Branch (3261:11): [True: 0, False: 0] ------------------ 3262| 0| s++; 3263| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3264| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3265| | 3266| 0| CASE_OP(STR_N) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3267| 0| tlen = p->exact_n.n; 3268| 0| DATA_ENSURE(tlen); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3269| 0| ps = p->exact_n.s; 3270| 0| while (tlen-- > 0) { ------------------ | Branch (3270:14): [True: 0, False: 0] ------------------ 3271| 0| if (*ps++ != *s++) goto fail; ------------------ | Branch (3271:13): [True: 0, False: 0] ------------------ 3272| 0| } 3273| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3274| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3275| | 3276| 17| CASE_OP(STR_MB2N1) ------------------ | | 2763| 17|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3277| 17| DATA_ENSURE(2); ------------------ | | 2521| 17|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 17] | | ------------------ ------------------ 3278| 17| ps = p->exact.s; 3279| 17| if (*ps != *s) goto fail; ------------------ | Branch (3279:11): [True: 0, False: 17] ------------------ 3280| 17| ps++; s++; 3281| 17| if (*ps != *s) goto fail; ------------------ | Branch (3281:11): [True: 0, False: 17] ------------------ 3282| 17| s++; 3283| 17| INC_OP; ------------------ | | 2790| 17|#define INC_OP p++ ------------------ 3284| 17| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 17|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 17|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 17|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 17|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3285| | 3286| 17| CASE_OP(STR_MB2N2) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3287| 0| DATA_ENSURE(4); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3288| 0| ps = p->exact.s; 3289| 0| if (*ps != *s) goto fail; ------------------ | Branch (3289:11): [True: 0, False: 0] ------------------ 3290| 0| ps++; s++; 3291| 0| if (*ps != *s) goto fail; ------------------ | Branch (3291:11): [True: 0, False: 0] ------------------ 3292| 0| ps++; s++; 3293| 0| if (*ps != *s) goto fail; ------------------ | Branch (3293:11): [True: 0, False: 0] ------------------ 3294| 0| ps++; s++; 3295| 0| if (*ps != *s) goto fail; ------------------ | Branch (3295:11): [True: 0, False: 0] ------------------ 3296| 0| s++; 3297| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3298| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3299| | 3300| 0| CASE_OP(STR_MB2N3) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3301| 0| DATA_ENSURE(6); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3302| 0| ps = p->exact.s; 3303| 0| if (*ps != *s) goto fail; ------------------ | Branch (3303:11): [True: 0, False: 0] ------------------ 3304| 0| ps++; s++; 3305| 0| if (*ps != *s) goto fail; ------------------ | Branch (3305:11): [True: 0, False: 0] ------------------ 3306| 0| ps++; s++; 3307| 0| if (*ps != *s) goto fail; ------------------ | Branch (3307:11): [True: 0, False: 0] ------------------ 3308| 0| ps++; s++; 3309| 0| if (*ps != *s) goto fail; ------------------ | Branch (3309:11): [True: 0, False: 0] ------------------ 3310| 0| ps++; s++; 3311| 0| if (*ps != *s) goto fail; ------------------ | Branch (3311:11): [True: 0, False: 0] ------------------ 3312| 0| ps++; s++; 3313| 0| if (*ps != *s) goto fail; ------------------ | Branch (3313:11): [True: 0, False: 0] ------------------ 3314| 0| ps++; s++; 3315| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3316| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3317| | 3318| 0| CASE_OP(STR_MB2N) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3319| 0| tlen = p->exact_n.n; 3320| 0| DATA_ENSURE(tlen * 2); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3321| 0| ps = p->exact_n.s; 3322| 0| while (tlen-- > 0) { ------------------ | Branch (3322:14): [True: 0, False: 0] ------------------ 3323| 0| if (*ps != *s) goto fail; ------------------ | Branch (3323:13): [True: 0, False: 0] ------------------ 3324| 0| ps++; s++; 3325| 0| if (*ps != *s) goto fail; ------------------ | Branch (3325:13): [True: 0, False: 0] ------------------ 3326| 0| ps++; s++; 3327| 0| } 3328| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3329| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3330| | 3331| 0| CASE_OP(STR_MB3N) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3332| 0| tlen = p->exact_n.n; 3333| 0| DATA_ENSURE(tlen * 3); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3334| 0| ps = p->exact_n.s; 3335| 0| while (tlen-- > 0) { ------------------ | Branch (3335:14): [True: 0, False: 0] ------------------ 3336| 0| if (*ps != *s) goto fail; ------------------ | Branch (3336:13): [True: 0, False: 0] ------------------ 3337| 0| ps++; s++; 3338| 0| if (*ps != *s) goto fail; ------------------ | Branch (3338:13): [True: 0, False: 0] ------------------ 3339| 0| ps++; s++; 3340| 0| if (*ps != *s) goto fail; ------------------ | Branch (3340:13): [True: 0, False: 0] ------------------ 3341| 0| ps++; s++; 3342| 0| } 3343| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3344| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3345| | 3346| 0| CASE_OP(STR_MBN) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3347| 0| tlen = p->exact_len_n.len; /* mb byte len */ 3348| 0| tlen2 = p->exact_len_n.n; /* number of chars */ 3349| 0| tlen2 *= tlen; 3350| 0| DATA_ENSURE(tlen2); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3351| 0| ps = p->exact_len_n.s; 3352| 0| while (tlen2-- > 0) { ------------------ | Branch (3352:14): [True: 0, False: 0] ------------------ 3353| 0| if (*ps != *s) goto fail; ------------------ | Branch (3353:13): [True: 0, False: 0] ------------------ 3354| 0| ps++; s++; 3355| 0| } 3356| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3357| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3358| | 3359| 2.32M| CASE_OP(CCLASS) ------------------ | | 2763| 2.32M|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3360| 2.32M| DATA_ENSURE(1); ------------------ | | 2521| 2.32M|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 495, False: 2.32M] | | ------------------ ------------------ 3361| 2.32M| if (BITSET_AT(p->cclass.bsp, *s) == 0) goto fail; ------------------ | | 450| 2.32M|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 2.32M|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 2.32M|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ | Branch (3361:11): [True: 5.43k, False: 2.31M] ------------------ 3362| 2.31M| if (ONIGENC_IS_MBC_HEAD(encode, s)) goto fail; ------------------ | | 255| 2.31M|#define ONIGENC_IS_MBC_HEAD(enc,p) (ONIGENC_MBC_ENC_LEN(enc,p) != 1) | | ------------------ | | | | 279| 2.31M|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | | Branch (255:40): [True: 0, False: 2.31M] | | ------------------ ------------------ 3363| 2.31M| s++; 3364| 2.31M| INC_OP; ------------------ | | 2790| 2.31M|#define INC_OP p++ ------------------ 3365| 2.31M| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 2.31M|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 2.31M|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 2.31M|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 2.31M|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3366| | 3367| 2.31M| CASE_OP(CCLASS_MB) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3368| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3369| 0| if (! ONIGENC_IS_MBC_HEAD(encode, s)) goto fail; ------------------ | | 255| 0|#define ONIGENC_IS_MBC_HEAD(enc,p) (ONIGENC_MBC_ENC_LEN(enc,p) != 1) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ | Branch (3369:11): [True: 0, False: 0] ------------------ 3370| | 3371| 0| cclass_mb: 3372| 0| { 3373| 0| OnigCodePoint code; 3374| 0| UChar *ss; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3375| 0| int mb_len; 3376| | 3377| 0| mb_len = enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3378| 0| DATA_ENSURE(mb_len); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3379| 0| ss = s; 3380| 0| s += mb_len; 3381| 0| code = ONIGENC_MBC_TO_CODE(encode, ss, s); ------------------ | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 3382| 0| if (! onig_is_in_code_range(p->cclass_mb.mb, code)) goto fail; ------------------ | Branch (3382:13): [True: 0, False: 0] ------------------ 3383| 0| } 3384| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3385| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3386| | 3387| 0| CASE_OP(CCLASS_MIX) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3388| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3389| 0| if (ONIGENC_IS_MBC_HEAD(encode, s)) { ------------------ | | 255| 0|#define ONIGENC_IS_MBC_HEAD(enc,p) (ONIGENC_MBC_ENC_LEN(enc,p) != 1) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | | Branch (255:40): [True: 0, False: 0] | | ------------------ ------------------ 3390| 0| goto cclass_mb; 3391| 0| } 3392| 0| else { 3393| 0| if (BITSET_AT(p->cclass_mix.bsp, *s) == 0) ------------------ | | 450| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 0|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 0|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ | Branch (3393:13): [True: 0, False: 0] ------------------ 3394| 0| goto fail; 3395| | 3396| 0| s++; 3397| 0| } 3398| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3399| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3400| | 3401| 1.88M| CASE_OP(CCLASS_NOT) ------------------ | | 2763| 1.88M|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3402| 1.88M| DATA_ENSURE(1); ------------------ | | 2521| 1.88M|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 126, False: 1.88M] | | ------------------ ------------------ 3403| 1.88M| if (BITSET_AT(p->cclass.bsp, *s) != 0) goto fail; ------------------ | | 450| 1.88M|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 1.88M|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 1.88M|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ | Branch (3403:11): [True: 2.84k, False: 1.88M] ------------------ 3404| 1.88M| s += enclen(encode, s); ------------------ | | 83| 1.88M|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 1.88M|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3405| 1.88M| INC_OP; ------------------ | | 2790| 1.88M|#define INC_OP p++ ------------------ 3406| 1.88M| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 1.88M|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 1.88M|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 1.88M|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 1.88M|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3407| | 3408| 1.88M| CASE_OP(CCLASS_MB_NOT) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3409| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3410| 0| if (! ONIGENC_IS_MBC_HEAD(encode, s)) { ------------------ | | 255| 0|#define ONIGENC_IS_MBC_HEAD(enc,p) (ONIGENC_MBC_ENC_LEN(enc,p) != 1) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ | Branch (3410:11): [True: 0, False: 0] ------------------ 3411| 0| s++; 3412| 0| goto cc_mb_not_success; 3413| 0| } 3414| | 3415| 0| cclass_mb_not: 3416| 0| { 3417| 0| OnigCodePoint code; 3418| 0| UChar *ss; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3419| 0| int mb_len = enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3420| | 3421| 0| if (! DATA_ENSURE_CHECK(mb_len)) { ------------------ | | 2520| 0|#define DATA_ENSURE_CHECK(n) ((n) <= right_range - s) ------------------ | Branch (3421:13): [True: 0, False: 0] ------------------ 3422| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3423| 0| s = (UChar* )end; 3424| 0| goto cc_mb_not_success; 3425| 0| } 3426| | 3427| 0| ss = s; 3428| 0| s += mb_len; 3429| 0| code = ONIGENC_MBC_TO_CODE(encode, ss, s); ------------------ | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 3430| 0| if (onig_is_in_code_range(p->cclass_mb.mb, code)) goto fail; ------------------ | Branch (3430:13): [True: 0, False: 0] ------------------ 3431| 0| } 3432| | 3433| 0| cc_mb_not_success: 3434| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3435| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3436| | 3437| 0| CASE_OP(CCLASS_MIX_NOT) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3438| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3439| 0| if (ONIGENC_IS_MBC_HEAD(encode, s)) { ------------------ | | 255| 0|#define ONIGENC_IS_MBC_HEAD(enc,p) (ONIGENC_MBC_ENC_LEN(enc,p) != 1) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | | Branch (255:40): [True: 0, False: 0] | | ------------------ ------------------ 3440| 0| goto cclass_mb_not; 3441| 0| } 3442| 0| else { 3443| 0| if (BITSET_AT(p->cclass_mix.bsp, *s) != 0) ------------------ | | 450| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 447| 0|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 448| 0|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ | Branch (3443:13): [True: 0, False: 0] ------------------ 3444| 0| goto fail; 3445| | 3446| 0| s++; 3447| 0| } 3448| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3449| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3450| | 3451| 68.0M| CASE_OP(ANYCHAR) ------------------ | | 2763| 68.0M|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3452| 68.0M| DATA_ENSURE(1); ------------------ | | 2521| 68.0M|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 3.25k, False: 68.0M] | | ------------------ ------------------ 3453| 68.0M| n = enclen(encode, s); ------------------ | | 83| 68.0M|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 68.0M|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3454| 68.0M| DATA_ENSURE(n); ------------------ | | 2521| 68.0M|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 68.0M] | | ------------------ ------------------ 3455| 68.0M| if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) goto fail; ------------------ | | 283| 68.0M|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) | | ------------------ | | | Branch (283:48): [True: 11.1k, False: 68.0M] | | ------------------ ------------------ 3456| 68.0M| s += n; 3457| 68.0M| INC_OP; ------------------ | | 2790| 68.0M|#define INC_OP p++ ------------------ 3458| 68.0M| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 68.0M|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 68.0M|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 68.0M|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 68.0M|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3459| | 3460| 68.0M| CASE_OP(ANYCHAR_ML) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3461| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3462| 0| n = enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3463| 0| DATA_ENSURE(n); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3464| 0| s += n; 3465| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3466| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3467| | 3468| 1.26k| CASE_OP(ANYCHAR_STAR) ------------------ | | 2763| 1.26k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3469| 1.26k| INC_OP; ------------------ | | 2790| 1.26k|#define INC_OP p++ ------------------ 3470| 3.23M| while (DATA_ENSURE_CHECK1) { ------------------ | | 2519| 3.23M|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 3.23M, False: 149] | | ------------------ ------------------ 3471| 3.23M| STACK_PUSH_ALT(p, s); ------------------ | | 1842| 3.23M|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 3.23M|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 3.23M| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 3.23M|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 3.23M| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 437, False: 3.23M] | | | | | | ------------------ | | | | | | 1787| 437| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 437| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 437] | | | | | | ------------------ | | | | | | 1789| 437| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 437|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 437| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 437| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 437|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 437] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 437| }\ | | | | | | 1791| 3.23M|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 3.23M] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 3.23M| stk->type = (stack_type);\ | | | | 1807| 3.23M| stk->u.state.pcode = (pat);\ | | | | 1808| 3.23M| stk->u.state.pstr = (s);\ | | | | 1809| 3.23M| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 3.23M|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 3.23M|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 3.23M] | | | | ------------------ | | ------------------ ------------------ 3472| 3.23M| n = enclen(encode, s); ------------------ | | 83| 3.23M|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 3.23M|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3473| 3.23M| DATA_ENSURE(n); ------------------ | | 2521| 3.23M|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 3.23M] | | ------------------ ------------------ 3474| 3.23M| if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) goto fail; ------------------ | | 283| 3.23M|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) | | ------------------ | | | Branch (283:48): [True: 1.11k, False: 3.23M] | | ------------------ ------------------ 3475| 3.23M| s += n; 3476| 3.23M| } 3477| 1.26k| JUMP_OUT; ------------------ | | 2792| 1.26k|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 1.26k|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 1.26k|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3478| | 3479| 149| CASE_OP(ANYCHAR_ML_STAR) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3480| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3481| 0| while (DATA_ENSURE_CHECK1) { ------------------ | | 2519| 0|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 0, False: 0] | | ------------------ ------------------ 3482| 0| STACK_PUSH_ALT(p, s); ------------------ | | 1842| 0|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3483| 0| n = enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3484| 0| if (n > 1) { ------------------ | Branch (3484:13): [True: 0, False: 0] ------------------ 3485| 0| DATA_ENSURE(n); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3486| 0| s += n; 3487| 0| } 3488| 0| else { 3489| 0| s++; 3490| 0| } 3491| 0| } 3492| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3493| | 3494| 80| CASE_OP(ANYCHAR_STAR_PEEK_NEXT) ------------------ | | 2763| 80|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3495| 80| { 3496| 80| UChar c; ------------------ | | 80| 80|#define UChar OnigUChar ------------------ 3497| | 3498| 80| c = p->anychar_star_peek_next.c; 3499| 80| INC_OP; ------------------ | | 2790| 80|#define INC_OP p++ ------------------ 3500| 5.03M| while (DATA_ENSURE_CHECK1) { ------------------ | | 2519| 5.03M|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 5.03M, False: 78] | | ------------------ ------------------ 3501| 5.03M| if (c == *s) { ------------------ | Branch (3501:15): [True: 3.17M, False: 1.85M] ------------------ 3502| 3.17M| STACK_PUSH_ALT(p, s); ------------------ | | 1842| 3.17M|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 3.17M|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 3.17M| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 3.17M|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 3.17M| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 66, False: 3.17M] | | | | | | ------------------ | | | | | | 1787| 66| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 66| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 66] | | | | | | ------------------ | | | | | | 1789| 66| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 66|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 66| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 66| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 66|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 66] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 66| }\ | | | | | | 1791| 3.17M|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 3.17M] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 3.17M| stk->type = (stack_type);\ | | | | 1807| 3.17M| stk->u.state.pcode = (pat);\ | | | | 1808| 3.17M| stk->u.state.pstr = (s);\ | | | | 1809| 3.17M| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 3.17M|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 3.17M|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 3.17M] | | | | ------------------ | | ------------------ ------------------ 3503| 3.17M| } 3504| 5.03M| n = enclen(encode, s); ------------------ | | 83| 5.03M|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 5.03M|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3505| 5.03M| DATA_ENSURE(n); ------------------ | | 2521| 5.03M|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 5.03M] | | ------------------ ------------------ 3506| 5.03M| if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) goto fail; ------------------ | | 283| 5.03M|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) | | ------------------ | | | Branch (283:48): [True: 2, False: 5.03M] | | ------------------ ------------------ 3507| 5.03M| s += n; 3508| 5.03M| } 3509| 80| } 3510| 80| JUMP_OUT; ------------------ | | 2792| 80|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 80|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 80|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3511| | 3512| 78| CASE_OP(ANYCHAR_ML_STAR_PEEK_NEXT) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3513| 0| { 3514| 0| UChar c; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3515| | 3516| 0| c = p->anychar_star_peek_next.c; 3517| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3518| 0| while (DATA_ENSURE_CHECK1) { ------------------ | | 2519| 0|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 0, False: 0] | | ------------------ ------------------ 3519| 0| if (c == *s) { ------------------ | Branch (3519:15): [True: 0, False: 0] ------------------ 3520| 0| STACK_PUSH_ALT(p, s); ------------------ | | 1842| 0|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3521| 0| } 3522| 0| n = enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3523| 0| if (n > 1) { ------------------ | Branch (3523:15): [True: 0, False: 0] ------------------ 3524| 0| DATA_ENSURE(n); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3525| 0| s += n; 3526| 0| } 3527| 0| else { 3528| 0| s++; 3529| 0| } 3530| 0| } 3531| 0| } 3532| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3533| | 3534| 0| CASE_OP(WORD) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3535| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3536| 0| if (! ONIGENC_IS_MBC_WORD(encode, s, end)) ------------------ | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | ------------------ | | ------------------ ------------------ | Branch (3536:11): [True: 0, False: 0] ------------------ 3537| 0| goto fail; 3538| | 3539| 0| s += enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3540| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3541| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3542| | 3543| 0| CASE_OP(WORD_ASCII) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3544| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3545| 0| if (! ONIGENC_IS_MBC_WORD_ASCII(encode, s, end)) ------------------ | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) ------------------ | Branch (3545:11): [True: 0, False: 0] ------------------ 3546| 0| goto fail; 3547| | 3548| 0| s += enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3549| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3550| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3551| | 3552| 0| CASE_OP(NO_WORD) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3553| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3554| 0| if (ONIGENC_IS_MBC_WORD(encode, s, end)) ------------------ | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3555| 0| goto fail; 3556| | 3557| 0| s += enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3558| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3559| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3560| | 3561| 0| CASE_OP(NO_WORD_ASCII) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3562| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3563| 0| if (ONIGENC_IS_MBC_WORD_ASCII(encode, s, end)) ------------------ | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (260:46): [True: 0, False: 0] | | ------------------ ------------------ 3564| 0| goto fail; 3565| | 3566| 0| s += enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 3567| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3568| 0| JUMP_OUT_WITH_SPREV_SET; ------------------ | | 2791| 0|#define JUMP_OUT_WITH_SPREV_SET SOP_OUT; NEXT_OP | | ------------------ | | | | 2765| 0|#define NEXT_OP JUMP_OP | | | | ------------------ | | | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | | | ------------------ | | | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3569| | 3570| 0| CASE_OP(WORD_BOUNDARY) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3571| 0| { 3572| 0| ModeType mode; 3573| | 3574| 0| mode = p->word_boundary.mode; 3575| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 2517| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (2517:32): [True: 0, False: 0] | | ------------------ ------------------ 3576| 0| DATA_ENSURE(1); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3577| 0| if (! IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3577:15): [True: 0, False: 0] ------------------ 3578| 0| goto fail; 3579| 0| } 3580| 0| else { 3581| 0| UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3582| 0| if (ON_STR_END(s)) { ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (2518:32): [True: 0, False: 0] | | ------------------ ------------------ 3583| 0| if (! IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3583:17): [True: 0, False: 0] ------------------ 3584| 0| goto fail; 3585| 0| } 3586| 0| else { 3587| 0| if (IS_MBC_WORD_ASCII_MODE(encode, s, end, mode) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3587:17): [True: 0, False: 0] ------------------ 3588| 0| == IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ 3589| 0| goto fail; 3590| 0| } 3591| 0| } 3592| 0| } 3593| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3594| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3595| | 3596| 0| CASE_OP(NO_WORD_BOUNDARY) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3597| 0| { 3598| 0| ModeType mode; 3599| | 3600| 0| mode = p->word_boundary.mode; 3601| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 2517| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (2517:32): [True: 0, False: 0] | | ------------------ ------------------ 3602| 0| if (DATA_ENSURE_CHECK1 && IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) ------------------ | | 2519| 0|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 0, False: 0] | | ------------------ ------------------ if (DATA_ENSURE_CHECK1 && IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:3): [True: 0, False: 0] | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ 3603| 0| goto fail; 3604| 0| } 3605| 0| else { 3606| 0| UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3607| 0| if (ON_STR_END(s)) { ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (2518:32): [True: 0, False: 0] | | ------------------ ------------------ 3608| 0| if (IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:3): [True: 0, False: 0] | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ 3609| 0| goto fail; 3610| 0| } 3611| 0| else { 3612| 0| if (IS_MBC_WORD_ASCII_MODE(encode, s, end, mode) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3612:17): [True: 0, False: 0] ------------------ 3613| 0| != IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ 3614| 0| goto fail; 3615| 0| } 3616| 0| } 3617| 0| } 3618| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3619| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3620| | 3621| 0|#ifdef USE_WORD_BEGIN_END 3622| 0| CASE_OP(WORD_BEGIN) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3623| 0| { 3624| 0| ModeType mode; 3625| | 3626| 0| mode = p->word_boundary.mode; 3627| 0| if (DATA_ENSURE_CHECK1 && IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) { ------------------ | | 2519| 0|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 0, False: 0] | | ------------------ ------------------ if (DATA_ENSURE_CHECK1 && IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) { ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:3): [True: 0, False: 0] | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ 3628| 0| UChar* sprev; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3629| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 2517| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (2517:32): [True: 0, False: 0] | | ------------------ ------------------ 3630| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3631| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3632| 0| } 3633| 0| sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); 3634| 0| if (! IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) { ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3634:15): [True: 0, False: 0] ------------------ 3635| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3636| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3637| 0| } 3638| 0| } 3639| 0| } 3640| 0| goto fail; 3641| | 3642| 0| CASE_OP(WORD_END) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3643| 0| { 3644| 0| ModeType mode; 3645| | 3646| 0| mode = p->word_boundary.mode; 3647| 0| if (! ON_STR_BEGIN(s)) { ------------------ | | 2517| 0|#define ON_STR_BEGIN(s) ((s) == str) ------------------ | Branch (3647:13): [True: 0, False: 0] ------------------ 3648| 0| UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3649| 0| if (IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) { ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:3): [True: 0, False: 0] | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ 3650| 0| if (ON_STR_END(s) || ! IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) { ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (2518:32): [True: 0, False: 0] | | ------------------ ------------------ if (ON_STR_END(s) || ! IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) { ------------------ | | 39| 0| ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 259| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | | | ------------------ | | | | | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | | | ------------------ | | | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end)) | | ------------------ | | | | 260| 0|#define ONIGENC_IS_MBC_WORD_ASCII(enc,s,end) onigenc_is_mbc_word_ascii(enc,s,end) | | ------------------ | | | Branch (39:4): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3650:34): [True: 0, False: 0] ------------------ 3651| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3652| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3653| 0| } 3654| 0| } 3655| 0| } 3656| 0| } 3657| 0| goto fail; 3658| 0|#endif 3659| | 3660| 0| CASE_OP(TEXT_SEGMENT_BOUNDARY) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3661| 0| { 3662| 0| int is_break; 3663| 0| UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3664| | 3665| 0| switch (p->text_segment_boundary.type) { 3666| 0| case EXTENDED_GRAPHEME_CLUSTER_BOUNDARY: ------------------ | Branch (3666:9): [True: 0, False: 0] ------------------ 3667| 0| is_break = onigenc_egcb_is_break_position(encode, s, sprev, str, end); 3668| 0| break; 3669| 0|#ifdef USE_UNICODE_WORD_BREAK 3670| 0| case WORD_BOUNDARY: ------------------ | Branch (3670:9): [True: 0, False: 0] ------------------ 3671| 0| is_break = onigenc_wb_is_break_position(encode, s, sprev, str, end); 3672| 0| break; 3673| 0|#endif 3674| 0| default: ------------------ | Branch (3674:9): [True: 0, False: 0] ------------------ 3675| 0| MATCH_AT_ERROR_RETURN(ONIGERR_UNDEFINED_BYTECODE); ------------------ | | 2844| 0|#define MATCH_AT_ERROR_RETURN(err_code) do {\ | | 2845| 0| best_len = err_code; goto match_at_end;\ | | 2846| 0|} while(0) | | ------------------ | | | Branch (2846:9): [Folded, False: 0] | | ------------------ ------------------ 3676| 0| break; 3677| 0| } 3678| | 3679| 0| if (p->text_segment_boundary.not != 0) ------------------ | Branch (3679:13): [True: 0, False: 0] ------------------ 3680| 0| is_break = ! is_break; 3681| | 3682| 0| if (is_break != 0) { ------------------ | Branch (3682:13): [True: 0, False: 0] ------------------ 3683| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3684| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3685| 0| } 3686| 0| else { 3687| 0| goto fail; 3688| 0| } 3689| 0| } 3690| | 3691| 632| CASE_OP(BEGIN_BUF) ------------------ | | 2763| 632|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3692| 632| if (! ON_STR_BEGIN(s)) goto fail; ------------------ | | 2517| 632|#define ON_STR_BEGIN(s) ((s) == str) ------------------ | Branch (3692:11): [True: 1, False: 631] ------------------ 3693| 631| if (OPTON_NOTBOL(options)) goto fail; ------------------ | | 416| 631|#define OPTON_NOTBOL(option) ((option) & ONIG_OPTION_NOTBOL) | | ------------------ | | | | 387| 631|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | ------------------ | | | | | | 385| 631|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 384| 631|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 383| 631|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 382| 631|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 381| 631|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 380| 631|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 379| 631|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 378| 631|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 377| 631|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (416:38): [True: 0, False: 631] | | ------------------ ------------------ 3694| 631| if (OPTON_NOT_BEGIN_STRING(options)) goto fail; ------------------ | | 421| 631|#define OPTON_NOT_BEGIN_STRING(option) ((option) & ONIG_OPTION_NOT_BEGIN_STRING) | | ------------------ | | | | 400| 631|#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1) | | | | ------------------ | | | | | | 398| 631|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | | | ------------------ | | | | | | | | 397| 631|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 396| 631|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 395| 631|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 394| 631|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 393| 631|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 392| 631|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 390| 631|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 389| 631|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 388| 631|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 387| 631|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 631|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 631|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 631|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 631|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 631|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 631|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 631|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 631|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 631|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (421:43): [True: 0, False: 631] | | ------------------ ------------------ 3695| | 3696| 631| INC_OP; ------------------ | | 2790| 631|#define INC_OP p++ ------------------ 3697| 631| JUMP_OUT; ------------------ | | 2792| 631|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 631|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 631|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3698| | 3699| 631| CASE_OP(END_BUF) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3700| 0| if (! ON_STR_END(s)) goto fail; ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) ------------------ | Branch (3700:11): [True: 0, False: 0] ------------------ 3701| 0| if (OPTON_NOTEOL(options)) goto fail; ------------------ | | 417| 0|#define OPTON_NOTEOL(option) ((option) & ONIG_OPTION_NOTEOL) | | ------------------ | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | ------------------ | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (417:38): [True: 0, False: 0] | | ------------------ ------------------ 3702| 0| if (OPTON_NOT_END_STRING(options)) goto fail; ------------------ | | 422| 0|#define OPTON_NOT_END_STRING(option) ((option) & ONIG_OPTION_NOT_END_STRING) | | ------------------ | | | | 401| 0|#define ONIG_OPTION_NOT_END_STRING (ONIG_OPTION_NOT_BEGIN_STRING << 1) | | | | ------------------ | | | | | | 400| 0|#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1) | | | | | | ------------------ | | | | | | | | 398| 0|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 396| 0|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (422:43): [True: 0, False: 0] | | ------------------ ------------------ 3703| | 3704| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3705| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3706| | 3707| 0| CASE_OP(BEGIN_LINE) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3708| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 2517| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (2517:32): [True: 0, False: 0] | | ------------------ ------------------ 3709| 0| if (OPTON_NOTBOL(options)) goto fail; ------------------ | | 416| 0|#define OPTON_NOTBOL(option) ((option) & ONIG_OPTION_NOTBOL) | | ------------------ | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | ------------------ | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (416:38): [True: 0, False: 0] | | ------------------ ------------------ 3710| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3711| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3712| 0| } 3713| 0| else if (! ON_STR_END(s)) { ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) ------------------ | Branch (3713:16): [True: 0, False: 0] ------------------ 3714| 0| UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3715| 0| if (ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) { ------------------ | | 283| 0|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) | | ------------------ | | | Branch (283:48): [True: 0, False: 0] | | ------------------ ------------------ 3716| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3717| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3718| 0| } 3719| 0| } 3720| 0| goto fail; 3721| | 3722| 0| CASE_OP(END_LINE) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3723| 0| if (ON_STR_END(s)) { ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (2518:32): [True: 0, False: 0] | | ------------------ ------------------ 3724| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 3725| | UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); 3726| | if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) { 3727| |#endif 3728| 0| if (OPTON_NOTEOL(options)) goto fail; ------------------ | | 417| 0|#define OPTON_NOTEOL(option) ((option) & ONIG_OPTION_NOTEOL) | | ------------------ | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | ------------------ | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (417:38): [True: 0, False: 0] | | ------------------ ------------------ 3729| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3730| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3731| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 3732| | } 3733| |#endif 3734| 0| } 3735| 0| else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) { ------------------ | | 283| 0|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) | | ------------------ | | | Branch (283:48): [True: 0, False: 0] | | ------------------ ------------------ 3736| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3737| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3738| 0| } 3739| |#ifdef USE_CRNL_AS_LINE_TERMINATOR 3740| | else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) { 3741| | INC_OP; 3742| | JUMP_OUT; 3743| | } 3744| |#endif 3745| 0| goto fail; 3746| | 3747| 48| CASE_OP(SEMI_END_BUF) ------------------ | | 2763| 48|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3748| 48| if (ON_STR_END(s)) { ------------------ | | 2518| 48|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (2518:32): [True: 42, False: 6] | | ------------------ ------------------ 3749| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 3750| | UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s); 3751| | if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) { 3752| |#endif 3753| 42| if (OPTON_NOTEOL(options)) goto fail; ------------------ | | 417| 42|#define OPTON_NOTEOL(option) ((option) & ONIG_OPTION_NOTEOL) | | ------------------ | | | | 388| 42|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | ------------------ | | | | | | 387| 42|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 385| 42|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 384| 42|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 383| 42|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 382| 42|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 381| 42|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 380| 42|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 379| 42|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 378| 42|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 377| 42|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (417:38): [True: 0, False: 42] | | ------------------ ------------------ 3754| 42| if (OPTON_NOT_END_STRING(options)) goto fail; ------------------ | | 422| 42|#define OPTON_NOT_END_STRING(option) ((option) & ONIG_OPTION_NOT_END_STRING) | | ------------------ | | | | 401| 42|#define ONIG_OPTION_NOT_END_STRING (ONIG_OPTION_NOT_BEGIN_STRING << 1) | | | | ------------------ | | | | | | 400| 42|#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1) | | | | | | ------------------ | | | | | | | | 398| 42|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | | | | | ------------------ | | | | | | | | | | 397| 42|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 396| 42|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 395| 42|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 394| 42|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 393| 42|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 392| 42|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 390| 42|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 389| 42|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 388| 42|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 387| 42|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 42|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 42|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 42|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 42|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 42|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 42|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 42|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 42|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 42|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (422:43): [True: 0, False: 42] | | ------------------ ------------------ 3755| 42| INC_OP; ------------------ | | 2790| 42|#define INC_OP p++ ------------------ 3756| 42| JUMP_OUT; ------------------ | | 2792| 42|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 42|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 42|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3757| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 3758| | } 3759| |#endif 3760| 42| } 3761| 6| else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end) && ------------------ | | 283| 12|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) | | ------------------ | | | Branch (283:48): [True: 6, False: 0] | | ------------------ ------------------ 3762| 6| ON_STR_END(s + enclen(encode, s))) { ------------------ | | 2518| 6|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (2518:32): [True: 6, False: 0] | | ------------------ ------------------ 3763| 6| if (OPTON_NOTEOL(options)) goto fail; ------------------ | | 417| 6|#define OPTON_NOTEOL(option) ((option) & ONIG_OPTION_NOTEOL) | | ------------------ | | | | 388| 6|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | ------------------ | | | | | | 387| 6|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 385| 6|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 384| 6|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 383| 6|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 382| 6|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 381| 6|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 380| 6|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 379| 6|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 378| 6|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 377| 6|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (417:38): [True: 0, False: 6] | | ------------------ ------------------ 3764| 6| if (OPTON_NOT_END_STRING(options)) goto fail; ------------------ | | 422| 6|#define OPTON_NOT_END_STRING(option) ((option) & ONIG_OPTION_NOT_END_STRING) | | ------------------ | | | | 401| 6|#define ONIG_OPTION_NOT_END_STRING (ONIG_OPTION_NOT_BEGIN_STRING << 1) | | | | ------------------ | | | | | | 400| 6|#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1) | | | | | | ------------------ | | | | | | | | 398| 6|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | | | | | ------------------ | | | | | | | | | | 397| 6|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 396| 6|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 395| 6|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 394| 6|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 393| 6|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 392| 6|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 390| 6|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 389| 6|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 388| 6|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 387| 6|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 6|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 6|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 6|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 6|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 6|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 6|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 6|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 6|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 6|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (422:43): [True: 0, False: 6] | | ------------------ ------------------ 3765| 6| INC_OP; ------------------ | | 2790| 6|#define INC_OP p++ ------------------ 3766| 6| JUMP_OUT; ------------------ | | 2792| 6|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 6|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 6|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3767| 6| } 3768| |#ifdef USE_CRNL_AS_LINE_TERMINATOR 3769| | else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) { 3770| | UChar* ss = s + enclen(encode, s); 3771| | ss += enclen(encode, ss); 3772| | if (ON_STR_END(ss)) { 3773| | if (OPTON_NOTEOL(options)) goto fail; 3774| | if (OPTON_NOT_END_STRING(options)) goto fail; 3775| | INC_OP; 3776| | JUMP_OUT; 3777| | } 3778| | } 3779| |#endif 3780| 48| goto fail; 3781| | 3782| 48| CASE_OP(CHECK_POSITION) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3783| 0| switch (p->check_position.type) { 3784| 0| case CHECK_POSITION_SEARCH_START: ------------------ | Branch (3784:7): [True: 0, False: 0] ------------------ 3785| 0| if (s != msa->start) goto fail; ------------------ | Branch (3785:13): [True: 0, False: 0] ------------------ 3786| 0| if (OPTON_NOT_BEGIN_POSITION(options)) goto fail; ------------------ | | 423| 0|#define OPTON_NOT_BEGIN_POSITION(option) ((option) & ONIG_OPTION_NOT_BEGIN_POSITION) | | ------------------ | | | | 402| 0|#define ONIG_OPTION_NOT_BEGIN_POSITION (ONIG_OPTION_NOT_END_STRING << 1) | | | | ------------------ | | | | | | 401| 0|#define ONIG_OPTION_NOT_END_STRING (ONIG_OPTION_NOT_BEGIN_STRING << 1) | | | | | | ------------------ | | | | | | | | 400| 0|#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1) | | | | | | | | ------------------ | | | | | | | | | | 398| 0|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 397| 0|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 396| 0|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (423:43): [True: 0, False: 0] | | ------------------ ------------------ 3787| 0| break; 3788| 0| case CHECK_POSITION_CURRENT_RIGHT_RANGE: ------------------ | Branch (3788:7): [True: 0, False: 0] ------------------ 3789| 0| if (s != right_range) goto fail; ------------------ | Branch (3789:13): [True: 0, False: 0] ------------------ 3790| 0| break; 3791| 0| default: ------------------ | Branch (3791:7): [True: 0, False: 0] ------------------ 3792| 0| break; 3793| 0| } 3794| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3795| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3796| | 3797| 702k| CASE_OP(MEM_START_PUSH) ------------------ | | 2763| 702k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3798| 702k| mem = p->memory_start.num; 3799| 702k| STACK_PUSH_MEM_START(mem, s); ------------------ | | 1866| 702k|#define STACK_PUSH_MEM_START(mnum, s) do {\ | | 1867| 702k| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 702k|#define STACK_ENSURE(n) do {\ | | | | 1786| 702k| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 332, False: 701k] | | | | ------------------ | | | | 1787| 332| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 332| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 332] | | | | ------------------ | | | | 1789| 332| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 332|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 332| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 332| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 332|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 332] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 332| }\ | | | | 1791| 702k|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 702k] | | | | ------------------ | | ------------------ | | 1868| 702k| stk->type = STK_MEM_START;\ | | ------------------ | | | | 1099| 702k|#define STK_MEM_START 0x0010 | | ------------------ | | 1869| 702k| stk->zid = (mnum);\ | | 1870| 702k| stk->u.mem.pstr = (s);\ | | 1871| 702k| stk->u.mem.prev_start = mem_start_stk[mnum];\ | | 1872| 702k| stk->u.mem.prev_end = mem_end_stk[mnum];\ | | 1873| 702k| mem_start_stk[mnum].i = GET_STACK_INDEX(stk);\ | | ------------------ | | | | 1794| 702k|#define GET_STACK_INDEX(stk) ((stk) - stk_base) | | ------------------ | | 1874| 702k| mem_end_stk[mnum].i = INVALID_STACK_INDEX;\ | | ------------------ | | | | 1133| 702k|#define INVALID_STACK_INDEX ((StackIndex )-1) | | ------------------ | | 1875| 702k| STACK_INC;\ | | ------------------ | | | | 2742| 702k|#define STACK_INC stk++ | | ------------------ | | 1876| 702k|} while(0) | | ------------------ | | | Branch (1876:9): [Folded, False: 702k] | | ------------------ ------------------ 3800| 702k| INC_OP; ------------------ | | 2790| 702k|#define INC_OP p++ ------------------ 3801| 702k| JUMP_OUT; ------------------ | | 2792| 702k|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 702k|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 702k|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3802| | 3803| 702k| CASE_OP(MEM_START) ------------------ | | 2763| 49.7k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3804| 49.7k| mem = p->memory_start.num; 3805| 49.7k| mem_start_stk[mem].s = s; 3806| 49.7k| INC_OP; ------------------ | | 2790| 49.7k|#define INC_OP p++ ------------------ 3807| 49.7k| JUMP_OUT; ------------------ | | 2792| 49.7k|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 49.7k|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 49.7k|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3808| | 3809| 49.7k| CASE_OP(MEM_END_PUSH) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3810| 0| mem = p->memory_end.num; 3811| 0| STACK_PUSH_MEM_END(mem, s); ------------------ | | 1878| 0|#define STACK_PUSH_MEM_END(mnum, s) do {\ | | 1879| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1880| 0| stk->type = STK_MEM_END;\ | | ------------------ | | | | 1100| 0|#define STK_MEM_END 0x8030 | | ------------------ | | 1881| 0| stk->zid = (mnum);\ | | 1882| 0| stk->u.mem.pstr = (s);\ | | 1883| 0| stk->u.mem.prev_start = mem_start_stk[mnum];\ | | 1884| 0| stk->u.mem.prev_end = mem_end_stk[mnum];\ | | 1885| 0| mem_end_stk[mnum].i = GET_STACK_INDEX(stk);\ | | ------------------ | | | | 1794| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) | | ------------------ | | 1886| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1887| 0|} while(0) | | ------------------ | | | Branch (1887:9): [Folded, False: 0] | | ------------------ ------------------ 3812| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3813| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3814| | 3815| 749k| CASE_OP(MEM_END) ------------------ | | 2763| 749k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3816| 749k| mem = p->memory_end.num; 3817| 749k| mem_end_stk[mem].s = s; 3818| 749k| INC_OP; ------------------ | | 2790| 749k|#define INC_OP p++ ------------------ 3819| 749k| JUMP_OUT; ------------------ | | 2792| 749k|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 749k|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 749k|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3820| | 3821| 749k|#ifdef USE_CALL 3822| 749k| CASE_OP(MEM_END_PUSH_REC) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3823| 0| { 3824| 0| StackIndex si; 3825| | 3826| 0| mem = p->memory_end.num; 3827| 0| STACK_GET_MEM_START(mem, stkp); /* should be before push mem-end. */ ------------------ | | 1896| 0|#define STACK_GET_MEM_START(mnum, k) do {\ | | 1897| 0| int level = 0;\ | | 1898| 0| k = stk;\ | | 1899| 0| while (k > stk_base) {\ | | ------------------ | | | Branch (1899:10): [True: 0, False: 0] | | ------------------ | | 1900| 0| k--;\ | | 1901| 0| if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \ | | ------------------ | | | | 1129| 0|#define STK_MASK_MEM_END_OR_MARK 0x8000 /* MEM_END or MEM_END_MARK */ | | ------------------ | | | Branch (1901:9): [True: 0, False: 0] | | ------------------ | | 1902| 0| && k->zid == (mnum)) {\ | | ------------------ | | | Branch (1902:10): [True: 0, False: 0] | | ------------------ | | 1903| 0| level++;\ | | 1904| 0| }\ | | 1905| 0| else if (k->type == STK_MEM_START && k->zid == (mnum)) {\ | | ------------------ | | | | 1099| 0|#define STK_MEM_START 0x0010 | | ------------------ | | | Branch (1905:14): [True: 0, False: 0] | | | Branch (1905:42): [True: 0, False: 0] | | ------------------ | | 1906| 0| if (level == 0) break;\ | | ------------------ | | | Branch (1906:11): [True: 0, False: 0] | | ------------------ | | 1907| 0| level--;\ | | 1908| 0| }\ | | 1909| 0| }\ | | 1910| 0|} while(0) | | ------------------ | | | Branch (1910:9): [Folded, False: 0] | | ------------------ ------------------ 3828| 0| si = GET_STACK_INDEX(stkp); ------------------ | | 1794| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 3829| 0| STACK_PUSH_MEM_END(mem, s); ------------------ | | 1878| 0|#define STACK_PUSH_MEM_END(mnum, s) do {\ | | 1879| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1880| 0| stk->type = STK_MEM_END;\ | | ------------------ | | | | 1100| 0|#define STK_MEM_END 0x8030 | | ------------------ | | 1881| 0| stk->zid = (mnum);\ | | 1882| 0| stk->u.mem.pstr = (s);\ | | 1883| 0| stk->u.mem.prev_start = mem_start_stk[mnum];\ | | 1884| 0| stk->u.mem.prev_end = mem_end_stk[mnum];\ | | 1885| 0| mem_end_stk[mnum].i = GET_STACK_INDEX(stk);\ | | ------------------ | | | | 1794| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) | | ------------------ | | 1886| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1887| 0|} while(0) | | ------------------ | | | Branch (1887:9): [Folded, False: 0] | | ------------------ ------------------ 3830| 0| mem_start_stk[mem].i = si; 3831| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3832| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3833| 0| } 3834| | 3835| 0| CASE_OP(MEM_END_REC) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3836| 0| mem = p->memory_end.num; 3837| 0| mem_end_stk[mem].s = s; 3838| 0| STACK_GET_MEM_START(mem, stkp); ------------------ | | 1896| 0|#define STACK_GET_MEM_START(mnum, k) do {\ | | 1897| 0| int level = 0;\ | | 1898| 0| k = stk;\ | | 1899| 0| while (k > stk_base) {\ | | ------------------ | | | Branch (1899:10): [True: 0, False: 0] | | ------------------ | | 1900| 0| k--;\ | | 1901| 0| if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \ | | ------------------ | | | | 1129| 0|#define STK_MASK_MEM_END_OR_MARK 0x8000 /* MEM_END or MEM_END_MARK */ | | ------------------ | | | Branch (1901:9): [True: 0, False: 0] | | ------------------ | | 1902| 0| && k->zid == (mnum)) {\ | | ------------------ | | | Branch (1902:10): [True: 0, False: 0] | | ------------------ | | 1903| 0| level++;\ | | 1904| 0| }\ | | 1905| 0| else if (k->type == STK_MEM_START && k->zid == (mnum)) {\ | | ------------------ | | | | 1099| 0|#define STK_MEM_START 0x0010 | | ------------------ | | | Branch (1905:14): [True: 0, False: 0] | | | Branch (1905:42): [True: 0, False: 0] | | ------------------ | | 1906| 0| if (level == 0) break;\ | | ------------------ | | | Branch (1906:11): [True: 0, False: 0] | | ------------------ | | 1907| 0| level--;\ | | 1908| 0| }\ | | 1909| 0| }\ | | 1910| 0|} while(0) | | ------------------ | | | Branch (1910:9): [Folded, False: 0] | | ------------------ ------------------ 3839| | 3840| 0| if (MEM_STATUS_AT(reg->push_mem_start, mem)) ------------------ | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (365:3): [True: 0, False: 0] | | | Branch (365:4): [True: 0, False: 0] | | ------------------ ------------------ 3841| 0| mem_start_stk[mem].i = GET_STACK_INDEX(stkp); ------------------ | | 1794| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 3842| 0| else 3843| 0| mem_start_stk[mem].s = stkp->u.mem.pstr; 3844| | 3845| 0| STACK_PUSH_MEM_END_MARK(mem); ------------------ | | 1889| 0|#define STACK_PUSH_MEM_END_MARK(mnum) do {\ | | 1890| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1891| 0| stk->type = STK_MEM_END_MARK;\ | | ------------------ | | | | 1118| 0|#define STK_MEM_END_MARK 0x8100 | | ------------------ | | 1892| 0| stk->zid = (mnum);\ | | 1893| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1894| 0|} while(0) | | ------------------ | | | Branch (1894:9): [Folded, False: 0] | | ------------------ ------------------ 3846| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3847| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3848| 0|#endif 3849| | 3850| 0| CASE_OP(BACKREF1) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3851| 0| mem = 1; 3852| 0| goto backref; 3853| | 3854| 0| CASE_OP(BACKREF2) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3855| 0| mem = 2; 3856| 0| goto backref; 3857| | 3858| 0| CASE_OP(BACKREF_N) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3859| 0| mem = p->backref_n.n1; 3860| 0| backref: 3861| 0| { 3862| 0| UChar *pstart, *pend; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3863| | 3864| 0| if (mem_end_stk[mem].i == INVALID_STACK_INDEX) goto fail; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3864:13): [True: 0, False: 0] ------------------ 3865| 0| if (mem_start_stk[mem].i == INVALID_STACK_INDEX) goto fail; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3865:13): [True: 0, False: 0] ------------------ 3866| | 3867| 0| pstart = STACK_MEM_START(reg, mem); ------------------ | | 50| 0| (MEM_STATUS_AT((reg)->push_mem_start, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (50:4): [True: 0, False: 0] | | ------------------ | | 51| 0| STACK_AT(mem_start_stk[idx].i)->u.mem.pstr : mem_start_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3868| 0| pend = STACK_MEM_END(reg, mem); ------------------ | | 54| 0| (MEM_STATUS_AT((reg)->push_mem_end, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (54:4): [True: 0, False: 0] | | ------------------ | | 55| 0| STACK_AT(mem_end_stk[idx].i)->u.mem.pstr : mem_end_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3869| 0| n = (int )(pend - pstart); 3870| 0| if (n != 0) { ------------------ | Branch (3870:13): [True: 0, False: 0] ------------------ 3871| 0| DATA_ENSURE(n); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3872| 0| STRING_CMP(s, pstart, n); ------------------ | | 2456| 0|#define STRING_CMP(s1,s2,len) do {\ | | 2457| 0| while (len-- > 0) {\ | | ------------------ | | | Branch (2457:10): [True: 0, False: 0] | | ------------------ | | 2458| 0| if (*s1++ != *s2++) goto fail;\ | | ------------------ | | | Branch (2458:9): [True: 0, False: 0] | | ------------------ | | 2459| 0| }\ | | 2460| 0|} while(0) | | ------------------ | | | Branch (2460:9): [Folded, False: 0] | | ------------------ ------------------ 3873| 0| } 3874| 0| } 3875| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3876| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3877| | 3878| 0| CASE_OP(BACKREF_N_IC) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3879| 0| mem = p->backref_n.n1; 3880| 0| { 3881| 0| UChar *pstart, *pend; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3882| | 3883| 0| if (mem_end_stk[mem].i == INVALID_STACK_INDEX) goto fail; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3883:13): [True: 0, False: 0] ------------------ 3884| 0| if (mem_start_stk[mem].i == INVALID_STACK_INDEX) goto fail; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3884:13): [True: 0, False: 0] ------------------ 3885| | 3886| 0| pstart = STACK_MEM_START(reg, mem); ------------------ | | 50| 0| (MEM_STATUS_AT((reg)->push_mem_start, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (50:4): [True: 0, False: 0] | | ------------------ | | 51| 0| STACK_AT(mem_start_stk[idx].i)->u.mem.pstr : mem_start_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3887| 0| pend = STACK_MEM_END(reg, mem); ------------------ | | 54| 0| (MEM_STATUS_AT((reg)->push_mem_end, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (54:4): [True: 0, False: 0] | | ------------------ | | 55| 0| STACK_AT(mem_end_stk[idx].i)->u.mem.pstr : mem_end_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3888| 0| n = (int )(pend - pstart); 3889| 0| if (n != 0) { ------------------ | Branch (3889:13): [True: 0, False: 0] ------------------ 3890| 0| DATA_ENSURE(n); ------------------ | | 2521| 0|#define DATA_ENSURE(n) if (right_range - s < (n)) goto fail | | ------------------ | | | Branch (2521:36): [True: 0, False: 0] | | ------------------ ------------------ 3891| 0| STRING_CMP_IC(case_fold_flag, pstart, &s, n); ------------------ | | 2462| 0|#define STRING_CMP_IC(case_fold_flag,s1,ps2,len) do {\ | | 2463| 0| if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len) == 0) \ | | ------------------ | | | Branch (2463:7): [True: 0, False: 0] | | ------------------ | | 2464| 0| goto fail; \ | | 2465| 0|} while(0) | | ------------------ | | | Branch (2465:9): [Folded, False: 0] | | ------------------ ------------------ 3892| 0| } 3893| 0| } 3894| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3895| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3896| | 3897| 0| CASE_OP(BACKREF_MULTI) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3898| 0| { 3899| 0| int is_fail; 3900| 0| UChar *pstart, *pend, *swork; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3901| | 3902| 0| tlen = p->backref_general.num; 3903| 0| for (i = 0; i < tlen; i++) { ------------------ | Branch (3903:21): [True: 0, False: 0] ------------------ 3904| 0| mem = tlen == 1 ? p->backref_general.n1 : p->backref_general.ns[i]; ------------------ | Branch (3904:17): [True: 0, False: 0] ------------------ 3905| | 3906| 0| if (mem_end_stk[mem].i == INVALID_STACK_INDEX) continue; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3906:15): [True: 0, False: 0] ------------------ 3907| 0| if (mem_start_stk[mem].i == INVALID_STACK_INDEX) continue; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3907:15): [True: 0, False: 0] ------------------ 3908| | 3909| 0| pstart = STACK_MEM_START(reg, mem); ------------------ | | 50| 0| (MEM_STATUS_AT((reg)->push_mem_start, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (50:4): [True: 0, False: 0] | | ------------------ | | 51| 0| STACK_AT(mem_start_stk[idx].i)->u.mem.pstr : mem_start_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3910| 0| pend = STACK_MEM_END(reg, mem); ------------------ | | 54| 0| (MEM_STATUS_AT((reg)->push_mem_end, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (54:4): [True: 0, False: 0] | | ------------------ | | 55| 0| STACK_AT(mem_end_stk[idx].i)->u.mem.pstr : mem_end_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3911| 0| n = (int )(pend - pstart); 3912| 0| if (n != 0) { ------------------ | Branch (3912:15): [True: 0, False: 0] ------------------ 3913| 0| if (! DATA_ENSURE_CHECK(n)) continue; ------------------ | | 2520| 0|#define DATA_ENSURE_CHECK(n) ((n) <= right_range - s) ------------------ | Branch (3913:17): [True: 0, False: 0] ------------------ 3914| 0| swork = s; 3915| 0| STRING_CMP_VALUE(swork, pstart, n, is_fail); ------------------ | | 2499| 0|#define STRING_CMP_VALUE(s1,s2,len,is_fail) do {\ | | 2500| 0| is_fail = 0;\ | | 2501| 0| while (len-- > 0) {\ | | ------------------ | | | Branch (2501:10): [True: 0, False: 0] | | ------------------ | | 2502| 0| if (*s1++ != *s2++) {\ | | ------------------ | | | Branch (2502:9): [True: 0, False: 0] | | ------------------ | | 2503| 0| is_fail = 1; break;\ | | 2504| 0| }\ | | 2505| 0| }\ | | 2506| 0|} while(0) | | ------------------ | | | Branch (2506:9): [Folded, False: 0] | | ------------------ ------------------ 3916| 0| if (is_fail) continue; ------------------ | Branch (3916:17): [True: 0, False: 0] ------------------ 3917| 0| s = swork; 3918| 0| } 3919| 0| break; /* success */ 3920| 0| } 3921| 0| if (i == tlen) goto fail; ------------------ | Branch (3921:13): [True: 0, False: 0] ------------------ 3922| 0| } 3923| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3924| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3925| | 3926| 0| CASE_OP(BACKREF_MULTI_IC) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3927| 0| { 3928| 0| int is_fail; 3929| 0| UChar *pstart, *pend, *swork; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3930| | 3931| 0| tlen = p->backref_general.num; 3932| 0| for (i = 0; i < tlen; i++) { ------------------ | Branch (3932:21): [True: 0, False: 0] ------------------ 3933| 0| mem = tlen == 1 ? p->backref_general.n1 : p->backref_general.ns[i]; ------------------ | Branch (3933:17): [True: 0, False: 0] ------------------ 3934| | 3935| 0| if (mem_end_stk[mem].i == INVALID_STACK_INDEX) continue; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3935:15): [True: 0, False: 0] ------------------ 3936| 0| if (mem_start_stk[mem].i == INVALID_STACK_INDEX) continue; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3936:15): [True: 0, False: 0] ------------------ 3937| | 3938| 0| pstart = STACK_MEM_START(reg, mem); ------------------ | | 50| 0| (MEM_STATUS_AT((reg)->push_mem_start, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (50:4): [True: 0, False: 0] | | ------------------ | | 51| 0| STACK_AT(mem_start_stk[idx].i)->u.mem.pstr : mem_start_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3939| 0| pend = STACK_MEM_END(reg, mem); ------------------ | | 54| 0| (MEM_STATUS_AT((reg)->push_mem_end, (idx)) != 0 ? \ | | ------------------ | | | | 365| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (365:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (54:4): [True: 0, False: 0] | | ------------------ | | 55| 0| STACK_AT(mem_end_stk[idx].i)->u.mem.pstr : mem_end_stk[idx].s) | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ ------------------ 3940| 0| n = (int )(pend - pstart); 3941| 0| if (n != 0) { ------------------ | Branch (3941:15): [True: 0, False: 0] ------------------ 3942| 0| if (! DATA_ENSURE_CHECK(n)) continue; ------------------ | | 2520| 0|#define DATA_ENSURE_CHECK(n) ((n) <= right_range - s) ------------------ | Branch (3942:17): [True: 0, False: 0] ------------------ 3943| 0| swork = s; 3944| 0| STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, is_fail); ------------------ | | 2508| 0|#define STRING_CMP_VALUE_IC(case_fold_flag,s1,ps2,len,is_fail) do {\ | | 2509| 0| if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len) == 0) \ | | ------------------ | | | Branch (2509:7): [True: 0, False: 0] | | ------------------ | | 2510| 0| is_fail = 1; \ | | 2511| 0| else \ | | 2512| 0| is_fail = 0; \ | | 2513| 0|} while(0) | | ------------------ | | | Branch (2513:9): [Folded, False: 0] | | ------------------ ------------------ 3945| 0| if (is_fail) continue; ------------------ | Branch (3945:17): [True: 0, False: 0] ------------------ 3946| 0| s = swork; 3947| 0| } 3948| 0| break; /* success */ 3949| 0| } 3950| 0| if (i == tlen) goto fail; ------------------ | Branch (3950:13): [True: 0, False: 0] ------------------ 3951| 0| } 3952| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3953| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3954| | 3955| 0|#ifdef USE_BACKREF_WITH_LEVEL 3956| 0| CASE_OP(BACKREF_WITH_LEVEL_IC) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3957| 0| n = 1; /* ignore case */ 3958| 0| goto backref_with_level; 3959| 0| CASE_OP(BACKREF_WITH_LEVEL) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3960| 0| { 3961| 0| int level; 3962| 0| MemNumType* mems; 3963| | 3964| 0| n = 0; 3965| 0| backref_with_level: 3966| 0| level = p->backref_general.nest_level; 3967| 0| tlen = p->backref_general.num; 3968| 0| mems = tlen == 1 ? &(p->backref_general.n1) : p->backref_general.ns; ------------------ | Branch (3968:16): [True: 0, False: 0] ------------------ 3969| | 3970| 0| if (! backref_match_at_nested_level(reg, stk, stk_base, n, ------------------ | Branch (3970:13): [True: 0, False: 0] ------------------ 3971| 0| case_fold_flag, level, (int )tlen, mems, &s, end)) { 3972| 0| goto fail; 3973| 0| } 3974| 0| } 3975| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3976| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3977| 0|#endif 3978| | 3979| 0| CASE_OP(BACKREF_CHECK) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3980| 0| { 3981| 0| MemNumType* mems; 3982| | 3983| 0| tlen = p->backref_general.num; 3984| 0| mems = tlen == 1 ? &(p->backref_general.n1) : p->backref_general.ns; ------------------ | Branch (3984:16): [True: 0, False: 0] ------------------ 3985| | 3986| 0| for (i = 0; i < tlen; i++) { ------------------ | Branch (3986:21): [True: 0, False: 0] ------------------ 3987| 0| mem = mems[i]; 3988| 0| if (mem_end_stk[mem].i == INVALID_STACK_INDEX) continue; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3988:15): [True: 0, False: 0] ------------------ 3989| 0| if (mem_start_stk[mem].i == INVALID_STACK_INDEX) continue; ------------------ | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) ------------------ | Branch (3989:15): [True: 0, False: 0] ------------------ 3990| 0| break; /* success */ 3991| 0| } 3992| 0| if (i == tlen) goto fail; ------------------ | Branch (3992:13): [True: 0, False: 0] ------------------ 3993| 0| } 3994| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 3995| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 3996| | 3997| 0|#ifdef USE_BACKREF_WITH_LEVEL 3998| 0| CASE_OP(BACKREF_CHECK_WITH_LEVEL) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 3999| 0| { 4000| 0| LengthType level; 4001| 0| MemNumType* mems; 4002| | 4003| 0| level = p->backref_general.nest_level; 4004| 0| tlen = p->backref_general.num; 4005| 0| mems = tlen == 1 ? &(p->backref_general.n1) : p->backref_general.ns; ------------------ | Branch (4005:16): [True: 0, False: 0] ------------------ 4006| | 4007| 0| if (backref_check_at_nested_level(reg, stk, stk_base, ------------------ | Branch (4007:13): [True: 0, False: 0] ------------------ 4008| 0| (int )level, (int )tlen, mems) == 0) 4009| 0| goto fail; 4010| 0| } 4011| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4012| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4013| 0|#endif 4014| | 4015| 0| CASE_OP(EMPTY_CHECK_START) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4016| 0| mem = p->empty_check_start.mem; /* mem: null check id */ 4017| 0| STACK_PUSH_EMPTY_CHECK_START(mem, s); ------------------ | | 1930| 0|#define STACK_PUSH_EMPTY_CHECK_START(cnum, s) do {\ | | 1931| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1932| 0| stk->type = STK_EMPTY_CHECK_START;\ | | ------------------ | | | | 1115| 0|#define STK_EMPTY_CHECK_START 0x3000 | | ------------------ | | 1933| 0| stk->zid = (cnum);\ | | 1934| 0| stk->u.empty_check.pstr = (s);\ | | 1935| 0| SAVE_EMPTY_CHECK_STK_VAR(cnum);\ | | 1936| 0| LOAD_TO_EMPTY_CHECK_STK_VAR(cnum);\ | | 1937| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1938| 0|} while(0) | | ------------------ | | | Branch (1938:9): [Folded, False: 0] | | ------------------ ------------------ 4018| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4019| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4020| | 4021| 0| CASE_OP(EMPTY_CHECK_END) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4022| 0| { 4023| 0| int is_empty; 4024| | 4025| 0| mem = p->empty_check_end.mem; /* mem: null check id */ 4026| 0| STACK_EMPTY_CHECK(is_empty, mem, s); ------------------ | | 2231| 0|#define STACK_EMPTY_CHECK(isnull, sid, s) do {\ | | 2232| 0| StackType* k;\ | | 2233| 0| GET_EMPTY_CHECK_START(sid, k);\ | | ------------------ | | | | 2226| 0|#define GET_EMPTY_CHECK_START(sid, k) EMPTY_CHECK_START_SEARCH(sid, k) | | | | ------------------ | | | | | | 2203| 0|#define EMPTY_CHECK_START_SEARCH(sid, k) do {\ | | | | | | 2204| 0| k = stk;\ | | | | | | 2205| 0| while (1) {\ | | | | | | ------------------ | | | | | | | Branch (2205:10): [True: 0, Folded] | | | | | | ------------------ | | | | | | 2206| 0| k--;\ | | | | | | 2207| 0| STACK_BASE_CHECK(k, "EMPTY_CHECK_START_SEARCH"); \ | | | | | | 2208| 0| if (k->type == STK_EMPTY_CHECK_START) {\ | | | | | | ------------------ | | | | | | | | 1115| 0|#define STK_EMPTY_CHECK_START 0x3000 | | | | | | ------------------ | | | | | | | Branch (2208:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2209| 0| if (k->zid == (sid)) break;\ | | | | | | ------------------ | | | | | | | Branch (2209:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2210| 0| }\ | | | | | | 2211| 0| }\ | | | | | | 2212| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (2212:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2234| 0| (isnull) = (k->u.empty_check.pstr == (s));\ | | 2235| 0|} while(0) | | ------------------ | | | Branch (2235:9): [Folded, False: 0] | | ------------------ ------------------ 4027| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4028| 0| if (is_empty) { ------------------ | Branch (4028:13): [True: 0, False: 0] ------------------ 4029| |#ifdef ONIG_DEBUG_MATCH 4030| | fprintf(DBGFP, "EMPTY_CHECK_END: skip id:%d, s:%p\n", (int )mem, s); 4031| |#endif 4032| 0| empty_check_found: 4033| | /* empty loop founded, skip next instruction */ 4034| |#if defined(ONIG_DEBUG) && !defined(USE_DIRECT_THREADED_CODE) 4035| | switch (p->opcode) { 4036| | case OP_JUMP: 4037| | case OP_PUSH: 4038| | case OP_REPEAT_INC: 4039| | case OP_REPEAT_INC_NG: 4040| | INC_OP; 4041| | break; 4042| | default: 4043| | MATCH_AT_ERROR_RETURN(ONIGERR_UNEXPECTED_BYTECODE); 4044| | break; 4045| | } 4046| |#else 4047| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4048| 0|#endif 4049| 0| } 4050| 0| } 4051| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4052| | 4053| 0|#ifdef USE_RIGID_CHECK_CAPTURES_IN_EMPTY_REPEAT 4054| 0| CASE_OP(EMPTY_CHECK_END_MEMST) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4055| 0| { 4056| 0| int is_empty; 4057| | 4058| 0| mem = p->empty_check_end.mem; /* mem: null check id */ 4059| 0| STACK_EMPTY_CHECK_MEM(is_empty, mem, p->empty_check_end.empty_status_mem, s, reg); ------------------ | | 2250| 0|#define STACK_EMPTY_CHECK_MEM(isnull, sid, empty_status_mem, s, reg) do {\ | | 2251| 0| StackType* klow;\ | | 2252| 0| GET_EMPTY_CHECK_START(sid, klow);\ | | ------------------ | | | | 2226| 0|#define GET_EMPTY_CHECK_START(sid, k) EMPTY_CHECK_START_SEARCH(sid, k) | | | | ------------------ | | | | | | 2203| 0|#define EMPTY_CHECK_START_SEARCH(sid, k) do {\ | | | | | | 2204| 0| k = stk;\ | | | | | | 2205| 0| while (1) {\ | | | | | | ------------------ | | | | | | | Branch (2205:10): [True: 0, Folded] | | | | | | ------------------ | | | | | | 2206| 0| k--;\ | | | | | | 2207| 0| STACK_BASE_CHECK(k, "EMPTY_CHECK_START_SEARCH"); \ | | | | | | 2208| 0| if (k->type == STK_EMPTY_CHECK_START) {\ | | | | | | ------------------ | | | | | | | | 1115| 0|#define STK_EMPTY_CHECK_START 0x3000 | | | | | | ------------------ | | | | | | | Branch (2208:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2209| 0| if (k->zid == (sid)) break;\ | | | | | | ------------------ | | | | | | | Branch (2209:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2210| 0| }\ | | | | | | 2211| 0| }\ | | | | | | 2212| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (2212:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2253| 0| if (klow->u.empty_check.pstr != (s)) {\ | | ------------------ | | | Branch (2253:7): [True: 0, False: 0] | | ------------------ | | 2254| 0| stack_empty_check_mem_not_empty:\ | | 2255| 0| (isnull) = 0;\ | | 2256| 0| }\ | | 2257| 0| else {\ | | 2258| 0| StackType *k, *kk;\ | | 2259| 0| MemStatusType ms = (empty_status_mem);\ | | 2260| 0| (isnull) = 1;\ | | 2261| 0| k = stk;\ | | 2262| 0| while (k > klow) {\ | | ------------------ | | | Branch (2262:12): [True: 0, False: 0] | | ------------------ | | 2263| 0| k--;\ | | 2264| 0| if (k->type == STK_MEM_END && MEM_STATUS_LIMIT_AT(ms, k->zid)) {\ | | ------------------ | | | | 1100| 0|#define STK_MEM_END 0x8030 | | ------------------ | | if (k->type == STK_MEM_END && MEM_STATUS_LIMIT_AT(ms, k->zid)) {\ | | ------------------ | | | | 386| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : 0) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (386:3): [True: 0, False: 0] | | | | | Branch (386:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (2264:11): [True: 0, False: 0] | | ------------------ | | 2265| 0| kk = klow;\ | | 2266| 0| while (kk < k) {\ | | ------------------ | | | Branch (2266:16): [True: 0, False: 0] | | ------------------ | | 2267| 0| if (kk->type == STK_MEM_START && kk->zid == k->zid) {\ | | ------------------ | | | | 1099| 0|#define STK_MEM_START 0x0010 | | ------------------ | | | Branch (2267:15): [True: 0, False: 0] | | | Branch (2267:44): [True: 0, False: 0] | | ------------------ | | 2268| 0| if (kk->u.mem.prev_end.i == INVALID_STACK_INDEX || \ | | ------------------ | | | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) | | ------------------ | | | Branch (2268:17): [True: 0, False: 0] | | ------------------ | | 2269| 0| ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | | Branch (2269:19): [True: 0, False: 0] | | | Branch (2269:82): [True: 0, False: 0] | | | Branch (2269:179): [True: 0, False: 0] | | | Branch (2269:243): [True: 0, False: 0] | | ------------------ | | 2270| 0| goto stack_empty_check_mem_not_empty;\ | | 2271| 0| }\ | | 2272| 0| else {\ | | 2273| 0| ms &= ~((MemStatusType )1 << k->zid);\ | | 2274| 0| break;\ | | 2275| 0| }\ | | 2276| 0| }\ | | 2277| 0| kk++;\ | | 2278| 0| }\ | | 2279| 0| if (ms == 0) break;\ | | ------------------ | | | Branch (2279:13): [True: 0, False: 0] | | ------------------ | | 2280| 0| }\ | | 2281| 0| }\ | | 2282| 0| }\ | | 2283| 0|} while(0) | | ------------------ | | | Branch (2283:9): [Folded, False: 0] | | ------------------ ------------------ 4060| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4061| 0| if (is_empty) { ------------------ | Branch (4061:13): [True: 0, False: 0] ------------------ 4062| |#ifdef ONIG_DEBUG_MATCH 4063| | fprintf(DBGFP, "EMPTY_CHECK_END_MEM: skip id:%d, s:%p\n", (int)mem, s); 4064| |#endif 4065| 0| if (is_empty == -1) goto fail; ------------------ | Branch (4065:15): [True: 0, False: 0] ------------------ 4066| 0| goto empty_check_found; 4067| 0| } 4068| 0| } 4069| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4070| 0|#endif 4071| | 4072| 0|#ifdef USE_CALL 4073| 0| CASE_OP(EMPTY_CHECK_END_MEMST_PUSH) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4074| 0| { 4075| 0| int is_empty; 4076| | 4077| 0| mem = p->empty_check_end.mem; /* mem: null check id */ 4078| 0|#ifdef USE_RIGID_CHECK_CAPTURES_IN_EMPTY_REPEAT 4079| 0| STACK_EMPTY_CHECK_MEM_REC(is_empty, mem, p->empty_check_end.empty_status_mem, s, reg); ------------------ | | 2285| 0|#define STACK_EMPTY_CHECK_MEM_REC(isnull,sid,empty_status_mem,s,reg) do {\ | | 2286| 0| int level = 0;\ | | 2287| 0| StackType* klow = stk;\ | | 2288| 0| while (1) {\ | | ------------------ | | | Branch (2288:10): [True: 0, Folded] | | ------------------ | | 2289| 0| klow--;\ | | 2290| 0| STACK_BASE_CHECK(klow, "STACK_EMPTY_CHECK_MEM_REC");\ | | 2291| 0| if (klow->type == STK_EMPTY_CHECK_START) {\ | | ------------------ | | | | 1115| 0|#define STK_EMPTY_CHECK_START 0x3000 | | ------------------ | | | Branch (2291:9): [True: 0, False: 0] | | ------------------ | | 2292| 0| if (klow->zid == (sid)) {\ | | ------------------ | | | Branch (2292:11): [True: 0, False: 0] | | ------------------ | | 2293| 0| if (level == 0) {\ | | ------------------ | | | Branch (2293:13): [True: 0, False: 0] | | ------------------ | | 2294| 0| if (klow->u.empty_check.pstr != (s)) {\ | | ------------------ | | | Branch (2294:15): [True: 0, False: 0] | | ------------------ | | 2295| 0| stack_empty_check_mem_rec_not_empty:\ | | 2296| 0| (isnull) = 0;\ | | 2297| 0| break;\ | | 2298| 0| }\ | | 2299| 0| else {\ | | 2300| 0| StackType *k, *kk;\ | | 2301| 0| MemStatusType ms;\ | | 2302| 0| (isnull) = 1;\ | | 2303| 0| if ((empty_status_mem) == 0) break;\ | | ------------------ | | | Branch (2303:17): [True: 0, False: 0] | | ------------------ | | 2304| 0| ms = (empty_status_mem);\ | | 2305| 0| k = stk;\ | | 2306| 0| while (k > klow) {\ | | ------------------ | | | Branch (2306:20): [True: 0, False: 0] | | ------------------ | | 2307| 0| k--;\ | | 2308| 0| if (k->type == STK_MEM_END) {\ | | ------------------ | | | | 1100| 0|#define STK_MEM_END 0x8030 | | ------------------ | | | Branch (2308:19): [True: 0, False: 0] | | ------------------ | | 2309| 0| if (level == 0 && MEM_STATUS_LIMIT_AT(ms, k->zid)) {\ | | ------------------ | | | | 386| 0| ((n) < (int )MEM_STATUS_BITS_NUM ? ((stats) & ((MemStatusType )1 << n)) : 0) | | | | ------------------ | | | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | | | ------------------ | | | | | Branch (386:3): [True: 0, False: 0] | | | | | Branch (386:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (2309:21): [True: 0, False: 0] | | ------------------ | | 2310| 0| kk = klow;\ | | 2311| 0| kk++;\ | | 2312| 0| while (kk < k) {\ | | ------------------ | | | Branch (2312:26): [True: 0, False: 0] | | ------------------ | | 2313| 0| if (kk->type == STK_MEM_START && kk->zid == k->zid) {\ | | ------------------ | | | | 1099| 0|#define STK_MEM_START 0x0010 | | ------------------ | | | Branch (2313:25): [True: 0, False: 0] | | | Branch (2313:54): [True: 0, False: 0] | | ------------------ | | 2314| 0| if (kk->u.mem.prev_end.i == INVALID_STACK_INDEX || \ | | ------------------ | | | | 1133| 0|#define INVALID_STACK_INDEX ((StackIndex )-1) | | ------------------ | | | Branch (2314:27): [True: 0, False: 0] | | ------------------ | | 2315| 0| ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | ((STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr) && (STACK_AT(k->u.mem.prev_start.i)->u.mem.pstr != k->u.mem.pstr || STACK_AT(kk->u.mem.prev_start.i)->u.mem.pstr != STACK_AT(kk->u.mem.prev_end.i)->u.mem.pstr))) {\ | | ------------------ | | | | 1793| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | | Branch (2315:29): [True: 0, False: 0] | | | Branch (2315:92): [True: 0, False: 0] | | | Branch (2315:189): [True: 0, False: 0] | | | Branch (2315:253): [True: 0, False: 0] | | ------------------ | | 2316| 0| goto stack_empty_check_mem_rec_not_empty;\ | | 2317| 0| }\ | | 2318| 0| else {\ | | 2319| 0| ms &= ~((MemStatusType )1 << k->zid);\ | | 2320| 0| break;\ | | 2321| 0| }\ | | 2322| 0| }\ | | 2323| 0| else if (kk->type == STK_EMPTY_CHECK_START) {\ | | ------------------ | | | | 1115| 0|#define STK_EMPTY_CHECK_START 0x3000 | | ------------------ | | | Branch (2323:30): [True: 0, False: 0] | | ------------------ | | 2324| 0| if (kk->zid == (sid)) level++;\ | | ------------------ | | | Branch (2324:27): [True: 0, False: 0] | | ------------------ | | 2325| 0| }\ | | 2326| 0| else if (kk->type == STK_EMPTY_CHECK_END) {\ | | ------------------ | | | | 1117| 0|#define STK_EMPTY_CHECK_END 0x5000 /* for recursive call */ | | ------------------ | | | Branch (2326:30): [True: 0, False: 0] | | ------------------ | | 2327| 0| if (kk->zid == (sid)) level--;\ | | ------------------ | | | Branch (2327:27): [True: 0, False: 0] | | ------------------ | | 2328| 0| }\ | | 2329| 0| kk++;\ | | 2330| 0| }\ | | 2331| 0| level = 0;\ | | 2332| 0| if (ms == 0) break;\ | | ------------------ | | | Branch (2332:23): [True: 0, False: 0] | | ------------------ | | 2333| 0| }\ | | 2334| 0| }\ | | 2335| 0| else if (k->type == STK_EMPTY_CHECK_START) {\ | | ------------------ | | | | 1115| 0|#define STK_EMPTY_CHECK_START 0x3000 | | ------------------ | | | Branch (2335:24): [True: 0, False: 0] | | ------------------ | | 2336| 0| if (k->zid == (sid)) level++;\ | | ------------------ | | | Branch (2336:21): [True: 0, False: 0] | | ------------------ | | 2337| 0| }\ | | 2338| 0| else if (k->type == STK_EMPTY_CHECK_END) {\ | | ------------------ | | | | 1117| 0|#define STK_EMPTY_CHECK_END 0x5000 /* for recursive call */ | | ------------------ | | | Branch (2338:24): [True: 0, False: 0] | | ------------------ | | 2339| 0| if (k->zid == (sid)) level--;\ | | ------------------ | | | Branch (2339:21): [True: 0, False: 0] | | ------------------ | | 2340| 0| }\ | | 2341| 0| }\ | | 2342| 0| break;\ | | 2343| 0| }\ | | 2344| 0| }\ | | 2345| 0| else {\ | | 2346| 0| level--;\ | | 2347| 0| }\ | | 2348| 0| }\ | | 2349| 0| }\ | | 2350| 0| else if (klow->type == STK_EMPTY_CHECK_END) {\ | | ------------------ | | | | 1117| 0|#define STK_EMPTY_CHECK_END 0x5000 /* for recursive call */ | | ------------------ | | | Branch (2350:14): [True: 0, False: 0] | | ------------------ | | 2351| 0| if (klow->zid == (sid)) level++;\ | | ------------------ | | | Branch (2351:11): [True: 0, False: 0] | | ------------------ | | 2352| 0| }\ | | 2353| 0| }\ | | 2354| 0|} while(0) | | ------------------ | | | Branch (2354:9): [Folded, False: 0] | | ------------------ ------------------ 4080| |#else 4081| | STACK_EMPTY_CHECK_REC(is_empty, mem, s); 4082| |#endif 4083| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4084| 0| if (is_empty) { ------------------ | Branch (4084:13): [True: 0, False: 0] ------------------ 4085| |#ifdef ONIG_DEBUG_MATCH 4086| | fprintf(DBGFP, "EMPTY_CHECK_END_MEM_PUSH: skip id:%d, s:%p\n", 4087| | (int )mem, s); 4088| |#endif 4089| 0| if (is_empty == -1) goto fail; ------------------ | Branch (4089:15): [True: 0, False: 0] ------------------ 4090| 0| goto empty_check_found; 4091| 0| } 4092| 0| else { 4093| 0| STACK_PUSH_EMPTY_CHECK_END(mem); ------------------ | | 1940| 0|#define STACK_PUSH_EMPTY_CHECK_END(cnum) do {\ | | 1941| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1942| 0| stk->type = STK_EMPTY_CHECK_END;\ | | ------------------ | | | | 1117| 0|#define STK_EMPTY_CHECK_END 0x5000 /* for recursive call */ | | ------------------ | | 1943| 0| stk->zid = (cnum);\ | | 1944| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1945| 0|} while(0) | | ------------------ | | | Branch (1945:9): [Folded, False: 0] | | ------------------ ------------------ 4094| 0| } 4095| 0| } 4096| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4097| 0|#endif 4098| | 4099| 5.05M| CASE_OP(JUMP) ------------------ | | 2763| 5.05M|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4100| 5.05M| addr = p->jump.addr; 4101| 5.05M| p += addr; 4102| 5.05M| CHECK_INTERRUPT_JUMP_OUT; ------------------ | | 2794| 5.05M|#define CHECK_INTERRUPT_JUMP_OUT SOP_OUT; CHECK_INTERRUPT_IN_MATCH; JUMP_OP | | ------------------ | | | | 2766| 5.05M|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 5.05M|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4103| | 4104| 72.2M| CASE_OP(PUSH) ------------------ | | 2763| 72.2M|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4105| 72.2M| addr = p->push.addr; 4106| 72.2M| STACK_PUSH_ALT(p + addr, s); ------------------ | | 1842| 72.2M|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 72.2M|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 72.2M| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 72.2M|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 72.2M| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 1.05k, False: 72.2M] | | | | | | ------------------ | | | | | | 1787| 1.05k| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 1.05k| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 1.05k] | | | | | | ------------------ | | | | | | 1789| 1.05k| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 1.05k|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 1.05k| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 1.05k| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 1.05k|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 1.05k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 1.05k| }\ | | | | | | 1791| 72.2M|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 72.2M] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 72.2M| stk->type = (stack_type);\ | | | | 1807| 72.2M| stk->u.state.pcode = (pat);\ | | | | 1808| 72.2M| stk->u.state.pstr = (s);\ | | | | 1809| 72.2M| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 72.2M|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 72.2M|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 72.2M] | | | | ------------------ | | ------------------ ------------------ 4107| 72.2M| INC_OP; ------------------ | | 2790| 72.2M|#define INC_OP p++ ------------------ 4108| 72.2M| JUMP_OUT; ------------------ | | 2792| 72.2M|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 72.2M|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 72.2M|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4109| | 4110| 72.2M| CASE_OP(PUSH_SUPER) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4111| 0| addr = p->push.addr; 4112| 0| STACK_PUSH_SUPER_ALT(p + addr, s); ------------------ | | 1843| 0|#define STACK_PUSH_SUPER_ALT(pat,s) STACK_PUSH(STK_SUPER_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4113| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4114| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4115| | 4116| 331k| CASE_OP(POP) ------------------ | | 2763| 331k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4117| 331k| STACK_POP_ONE; ------------------ | | 2074| 331k|#define STACK_POP_ONE do {\ | | 2075| 331k| stk--;\ | | 2076| 331k| STACK_BASE_CHECK(stk, "STACK_POP_ONE"); \ | | 2077| 331k|} while(0) | | ------------------ | | | Branch (2077:9): [Folded, False: 331k] | | ------------------ ------------------ 4118| 331k| INC_OP; ------------------ | | 2790| 331k|#define INC_OP p++ ------------------ 4119| 331k| JUMP_OUT; ------------------ | | 2792| 331k|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 331k|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 331k|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4120| | 4121| 331k| CASE_OP(POP_TO_MARK) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4122| 0| STACK_POP_TO_MARK(p->pop_to_mark.id); ------------------ | | 2133| 0|#define STACK_POP_TO_MARK(sid) do {\ | | 2134| 0| while (1) {\ | | ------------------ | | | Branch (2134:10): [True: 0, Folded] | | ------------------ | | 2135| 0| stk--;\ | | 2136| 0| STACK_BASE_CHECK(stk, "STACK_POP_TO_MARK");\ | | 2137| 0| if ((stk->type & STK_MASK_POP_HANDLED_TIL) != 0) {\ | | ------------------ | | | | 1127| 0|#define STK_MASK_POP_HANDLED_TIL (STK_MASK_POP_HANDLED | 0x0004) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | | Branch (2137:9): [True: 0, False: 0] | | ------------------ | | 2138| 0| if (stk->type == STK_MARK) {\ | | ------------------ | | | | 1122| 0|#define STK_MARK 0x0704 | | ------------------ | | | Branch (2138:11): [True: 0, False: 0] | | ------------------ | | 2139| 0| if (stk->zid == (sid)) break;\ | | ------------------ | | | Branch (2139:13): [True: 0, False: 0] | | ------------------ | | 2140| 0| }\ | | 2141| 0| else {\ | | 2142| 0| if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 1099| 0|#define STK_MEM_START 0x0010 | | ------------------ | | | Branch (2142:13): [True: 0, False: 0] | | ------------------ | | 2143| 0| mem_start_stk[stk->zid] = stk->u.mem.prev_start;\ | | 2144| 0| mem_end_stk[stk->zid] = stk->u.mem.prev_end;\ | | 2145| 0| }\ | | 2146| 0| else if (stk->type == STK_MEM_END) {\ | | ------------------ | | | | 1100| 0|#define STK_MEM_END 0x8030 | | ------------------ | | | Branch (2146:18): [True: 0, False: 0] | | ------------------ | | 2147| 0| mem_start_stk[stk->zid] = stk->u.mem.prev_start;\ | | 2148| 0| mem_end_stk[stk->zid] = stk->u.mem.prev_end;\ | | 2149| 0| }\ | | 2150| 0| POP_REPEAT_INC \ | | 2151| 0| POP_EMPTY_CHECK_START \ | | 2152| 0| POP_CALL \ | | ------------------ | | | | 1260| 0|#define POP_CALL else if (stk->type == STK_RETURN) {subexp_call_nest_counter++;} else if (stk->type == STK_CALL_FRAME) {subexp_call_nest_counter--;} | | | | ------------------ | | | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | #define POP_CALL else if (stk->type == STK_RETURN) {subexp_call_nest_counter++;} else if (stk->type == STK_CALL_FRAME) {subexp_call_nest_counter--;} | | | | ------------------ | | | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1260:28): [True: 0, False: 0] | | | | | Branch (1260:92): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2153| 0| /* Don't call callout here because negation of total success by (?!..) (?opaddr) | | | | ------------------ | | ------------------ ------------------ 4125| | 4126| 0| #ifdef USE_OP_PUSH_OR_JUMP_EXACT 4127| 889k| CASE_OP(PUSH_OR_JUMP_EXACT1) ------------------ | | 2763| 889k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4128| 889k| { 4129| 889k| UChar c; ------------------ | | 80| 889k|#define UChar OnigUChar ------------------ 4130| | 4131| 889k| addr = p->push_or_jump_exact1.addr; 4132| 889k| c = p->push_or_jump_exact1.c; 4133| 889k| if (DATA_ENSURE_CHECK1 && c == *s) { ------------------ | | 2519| 1.77M|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 886k, False: 2.42k] | | ------------------ ------------------ | Branch (4133:35): [True: 862k, False: 24.4k] ------------------ 4134| 862k| STACK_PUSH_ALT(p + addr, s); ------------------ | | 1842| 862k|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 862k|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 862k| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 862k|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 862k| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 708, False: 861k] | | | | | | ------------------ | | | | | | 1787| 708| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 708| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 708] | | | | | | ------------------ | | | | | | 1789| 708| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 708|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 708| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 708| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 708|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 708] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 708| }\ | | | | | | 1791| 862k|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 862k] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 862k| stk->type = (stack_type);\ | | | | 1807| 862k| stk->u.state.pcode = (pat);\ | | | | 1808| 862k| stk->u.state.pstr = (s);\ | | | | 1809| 862k| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 862k|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 862k|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 862k] | | | | ------------------ | | ------------------ ------------------ 4135| 862k| INC_OP; ------------------ | | 2790| 862k|#define INC_OP p++ ------------------ 4136| 862k| JUMP_OUT; ------------------ | | 2792| 862k|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 862k|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 862k|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4137| 862k| } 4138| 889k| } 4139| 889k| p += addr; 4140| 889k| JUMP_OUT; ------------------ | | 2792| 889k|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 889k|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 889k|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4141| 889k|#endif 4142| | 4143| 889k| CASE_OP(PUSH_IF_PEEK_NEXT) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4144| 0| { 4145| 0| UChar c; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 4146| | 4147| 0| addr = p->push_if_peek_next.addr; 4148| 0| c = p->push_if_peek_next.c; 4149| 0| if (DATA_ENSURE_CHECK1 && c == *s) { ------------------ | | 2519| 0|#define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (2519:32): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4149:35): [True: 0, False: 0] ------------------ 4150| 0| STACK_PUSH_ALT(p + addr, s); ------------------ | | 1842| 0|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4151| 0| } 4152| 0| } 4153| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4154| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4155| | 4156| 0| CASE_OP(REPEAT) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4157| 0| mem = p->repeat.id; /* mem: OP_REPEAT ID */ 4158| 0| addr = p->repeat.addr; 4159| | 4160| 0| STACK_PUSH_REPEAT_INC(mem, 0); ------------------ | | 1856| 0|#define STACK_PUSH_REPEAT_INC(sid, ct) do {\ | | 1857| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1858| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 1104| 0|#define STK_REPEAT_INC 0x0040 | | ------------------ | | 1859| 0| stk->zid = (sid);\ | | 1860| 0| stk->u.repeat_inc.count = (ct);\ | | 1861| 0| SAVE_REPEAT_STK_VAR(sid);\ | | 1862| 0| LOAD_TO_REPEAT_STK_VAR(sid);\ | | 1863| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1864| 0|} while(0) | | ------------------ | | | Branch (1864:9): [Folded, False: 0] | | ------------------ ------------------ 4161| 0| if (reg->repeat_range[mem].lower == 0) { ------------------ | Branch (4161:11): [True: 0, False: 0] ------------------ 4162| 0| STACK_PUSH_ALT(p + addr, s); ------------------ | | 1842| 0|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4163| 0| } 4164| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4165| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4166| | 4167| 0| CASE_OP(REPEAT_NG) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4168| 0| mem = p->repeat.id; /* mem: OP_REPEAT ID */ 4169| 0| addr = p->repeat.addr; 4170| | 4171| 0| STACK_PUSH_REPEAT_INC(mem, 0); ------------------ | | 1856| 0|#define STACK_PUSH_REPEAT_INC(sid, ct) do {\ | | 1857| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1858| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 1104| 0|#define STK_REPEAT_INC 0x0040 | | ------------------ | | 1859| 0| stk->zid = (sid);\ | | 1860| 0| stk->u.repeat_inc.count = (ct);\ | | 1861| 0| SAVE_REPEAT_STK_VAR(sid);\ | | 1862| 0| LOAD_TO_REPEAT_STK_VAR(sid);\ | | 1863| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1864| 0|} while(0) | | ------------------ | | | Branch (1864:9): [Folded, False: 0] | | ------------------ ------------------ 4172| 0| if (reg->repeat_range[mem].lower == 0) { ------------------ | Branch (4172:11): [True: 0, False: 0] ------------------ 4173| 0| STACK_PUSH_ALT(p + 1, s); ------------------ | | 1842| 0|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4174| 0| p += addr; 4175| 0| } 4176| 0| else 4177| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4178| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4179| | 4180| 0| CASE_OP(REPEAT_INC) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4181| 0| mem = p->repeat_inc.id; /* mem: OP_REPEAT ID */ 4182| 0| STACK_GET_REPEAT_COUNT(mem, n); ------------------ | | 2414| 0|#define STACK_GET_REPEAT_COUNT(sid, c) STACK_GET_REPEAT_COUNT_SEARCH(sid, c) | | ------------------ | | | | 2378| 0|#define STACK_GET_REPEAT_COUNT_SEARCH(sid, c) do {\ | | | | 2379| 0| StackType* k = stk;\ | | | | 2380| 0| while (1) {\ | | | | ------------------ | | | | | Branch (2380:10): [True: 0, Folded] | | | | ------------------ | | | | 2381| 0| (k)--;\ | | | | 2382| 0| STACK_BASE_CHECK(k, "STACK_GET_REPEAT_COUNT_SEARCH");\ | | | | 2383| 0| if ((k)->type == STK_REPEAT_INC) {\ | | | | ------------------ | | | | | | 1104| 0|#define STK_REPEAT_INC 0x0040 | | | | ------------------ | | | | | Branch (2383:9): [True: 0, False: 0] | | | | ------------------ | | | | 2384| 0| if ((k)->zid == (sid)) {\ | | | | ------------------ | | | | | Branch (2384:11): [True: 0, False: 0] | | | | ------------------ | | | | 2385| 0| (c) = (k)->u.repeat_inc.count;\ | | | | 2386| 0| break;\ | | | | 2387| 0| }\ | | | | 2388| 0| }\ | | | | 2389| 0| else if ((k)->type == STK_RETURN) {\ | | | | ------------------ | | | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (2389:14): [True: 0, False: 0] | | | | ------------------ | | | | 2390| 0| int level = -1;\ | | | | 2391| 0| while (1) {\ | | | | ------------------ | | | | | Branch (2391:14): [True: 0, Folded] | | | | ------------------ | | | | 2392| 0| (k)--;\ | | | | 2393| 0| if ((k)->type == STK_CALL_FRAME) {\ | | | | ------------------ | | | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (2393:13): [True: 0, False: 0] | | | | ------------------ | | | | 2394| 0| level++;\ | | | | 2395| 0| if (level == 0) break;\ | | | | ------------------ | | | | | Branch (2395:15): [True: 0, False: 0] | | | | ------------------ | | | | 2396| 0| }\ | | | | 2397| 0| else if ((k)->type == STK_RETURN) level--;\ | | | | ------------------ | | | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (2397:18): [True: 0, False: 0] | | | | ------------------ | | | | 2398| 0| }\ | | | | 2399| 0| }\ | | | | 2400| 0| }\ | | | | 2401| 0|} while(0) | | | | ------------------ | | | | | Branch (2401:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4183| 0| n++; 4184| 0| if (n >= reg->repeat_range[mem].upper) { ------------------ | Branch (4184:11): [True: 0, False: 0] ------------------ 4185| | /* end of repeat. Nothing to do. */ 4186| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4187| 0| } 4188| 0| else if (n >= reg->repeat_range[mem].lower) { ------------------ | Branch (4188:16): [True: 0, False: 0] ------------------ 4189| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4190| 0| STACK_PUSH_ALT(p, s); ------------------ | | 1842| 0|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4191| 0| p = reg->repeat_range[mem].u.pcode; 4192| 0| } 4193| 0| else { 4194| 0| p = reg->repeat_range[mem].u.pcode; 4195| 0| } 4196| 0| STACK_PUSH_REPEAT_INC(mem, n); ------------------ | | 1856| 0|#define STACK_PUSH_REPEAT_INC(sid, ct) do {\ | | 1857| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1858| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 1104| 0|#define STK_REPEAT_INC 0x0040 | | ------------------ | | 1859| 0| stk->zid = (sid);\ | | 1860| 0| stk->u.repeat_inc.count = (ct);\ | | 1861| 0| SAVE_REPEAT_STK_VAR(sid);\ | | 1862| 0| LOAD_TO_REPEAT_STK_VAR(sid);\ | | 1863| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1864| 0|} while(0) | | ------------------ | | | Branch (1864:9): [Folded, False: 0] | | ------------------ ------------------ 4197| 0| CHECK_INTERRUPT_JUMP_OUT; ------------------ | | 2794| 0|#define CHECK_INTERRUPT_JUMP_OUT SOP_OUT; CHECK_INTERRUPT_IN_MATCH; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4198| | 4199| 0| CASE_OP(REPEAT_INC_NG) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4200| 0| mem = p->repeat_inc.id; /* mem: OP_REPEAT ID */ 4201| 0| STACK_GET_REPEAT_COUNT(mem, n); ------------------ | | 2414| 0|#define STACK_GET_REPEAT_COUNT(sid, c) STACK_GET_REPEAT_COUNT_SEARCH(sid, c) | | ------------------ | | | | 2378| 0|#define STACK_GET_REPEAT_COUNT_SEARCH(sid, c) do {\ | | | | 2379| 0| StackType* k = stk;\ | | | | 2380| 0| while (1) {\ | | | | ------------------ | | | | | Branch (2380:10): [True: 0, Folded] | | | | ------------------ | | | | 2381| 0| (k)--;\ | | | | 2382| 0| STACK_BASE_CHECK(k, "STACK_GET_REPEAT_COUNT_SEARCH");\ | | | | 2383| 0| if ((k)->type == STK_REPEAT_INC) {\ | | | | ------------------ | | | | | | 1104| 0|#define STK_REPEAT_INC 0x0040 | | | | ------------------ | | | | | Branch (2383:9): [True: 0, False: 0] | | | | ------------------ | | | | 2384| 0| if ((k)->zid == (sid)) {\ | | | | ------------------ | | | | | Branch (2384:11): [True: 0, False: 0] | | | | ------------------ | | | | 2385| 0| (c) = (k)->u.repeat_inc.count;\ | | | | 2386| 0| break;\ | | | | 2387| 0| }\ | | | | 2388| 0| }\ | | | | 2389| 0| else if ((k)->type == STK_RETURN) {\ | | | | ------------------ | | | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (2389:14): [True: 0, False: 0] | | | | ------------------ | | | | 2390| 0| int level = -1;\ | | | | 2391| 0| while (1) {\ | | | | ------------------ | | | | | Branch (2391:14): [True: 0, Folded] | | | | ------------------ | | | | 2392| 0| (k)--;\ | | | | 2393| 0| if ((k)->type == STK_CALL_FRAME) {\ | | | | ------------------ | | | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (2393:13): [True: 0, False: 0] | | | | ------------------ | | | | 2394| 0| level++;\ | | | | 2395| 0| if (level == 0) break;\ | | | | ------------------ | | | | | Branch (2395:15): [True: 0, False: 0] | | | | ------------------ | | | | 2396| 0| }\ | | | | 2397| 0| else if ((k)->type == STK_RETURN) level--;\ | | | | ------------------ | | | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (2397:18): [True: 0, False: 0] | | | | ------------------ | | | | 2398| 0| }\ | | | | 2399| 0| }\ | | | | 2400| 0| }\ | | | | 2401| 0|} while(0) | | | | ------------------ | | | | | Branch (2401:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4202| 0| n++; 4203| 0| STACK_PUSH_REPEAT_INC(mem, n); ------------------ | | 1856| 0|#define STACK_PUSH_REPEAT_INC(sid, ct) do {\ | | 1857| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1858| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 1104| 0|#define STK_REPEAT_INC 0x0040 | | ------------------ | | 1859| 0| stk->zid = (sid);\ | | 1860| 0| stk->u.repeat_inc.count = (ct);\ | | 1861| 0| SAVE_REPEAT_STK_VAR(sid);\ | | 1862| 0| LOAD_TO_REPEAT_STK_VAR(sid);\ | | 1863| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1864| 0|} while(0) | | ------------------ | | | Branch (1864:9): [Folded, False: 0] | | ------------------ ------------------ 4204| 0| if (n == reg->repeat_range[mem].upper) { ------------------ | Branch (4204:11): [True: 0, False: 0] ------------------ 4205| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4206| 0| } 4207| 0| else { 4208| 0| if (n >= reg->repeat_range[mem].lower) { ------------------ | Branch (4208:13): [True: 0, False: 0] ------------------ 4209| 0| STACK_PUSH_ALT(reg->repeat_range[mem].u.pcode, s); ------------------ | | 1842| 0|#define STACK_PUSH_ALT(pat,s) STACK_PUSH(STK_ALT,pat,s) | | ------------------ | | | | 1804| 0|#define STACK_PUSH(stack_type,pat,s) do {\ | | | | 1805| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1806| 0| stk->type = (stack_type);\ | | | | 1807| 0| stk->u.state.pcode = (pat);\ | | | | 1808| 0| stk->u.state.pstr = (s);\ | | | | 1809| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1810| 0|} while(0) | | | | ------------------ | | | | | Branch (1810:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4210| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4211| 0| } 4212| 0| else { 4213| 0| p = reg->repeat_range[mem].u.pcode; 4214| 0| } 4215| 0| } 4216| 0| CHECK_INTERRUPT_JUMP_OUT; ------------------ | | 2794| 0|#define CHECK_INTERRUPT_JUMP_OUT SOP_OUT; CHECK_INTERRUPT_IN_MATCH; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4217| | 4218| 0|#ifdef USE_CALL 4219| 0| CASE_OP(CALL) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4220| 0| if (subexp_call_nest_counter == SubexpCallMaxNestLevel) ------------------ | Branch (4220:11): [True: 0, False: 0] ------------------ 4221| 0| goto fail; 4222| 0| subexp_call_nest_counter++; 4223| | 4224| 0| if (SubexpCallLimitInSearch != 0) { ------------------ | Branch (4224:11): [True: 0, False: 0] ------------------ 4225| 0| msa->subexp_call_in_search_counter++; 4226| |#ifdef ONIG_DEBUG_MATCH_COUNTER 4227| | if (p->call.called_mem < MAX_SUBEXP_CALL_COUNTERS) 4228| | subexp_call_counters[p->call.called_mem]++; 4229| | if (msa->subexp_call_in_search_counter % 1000 == 0) 4230| | MATCH_COUNTER_OUT("CALL"); 4231| |#endif 4232| 0| if (msa->subexp_call_in_search_counter > ------------------ | Branch (4232:13): [True: 0, False: 0] ------------------ 4233| 0| SubexpCallLimitInSearch) { 4234| 0| MATCH_AT_ERROR_RETURN(ONIGERR_SUBEXP_CALL_LIMIT_IN_SEARCH_OVER); ------------------ | | 2844| 0|#define MATCH_AT_ERROR_RETURN(err_code) do {\ | | 2845| 0| best_len = err_code; goto match_at_end;\ | | 2846| 0|} while(0) | | ------------------ | | | Branch (2846:9): [Folded, False: 0] | | ------------------ ------------------ 4235| 0| } 4236| 0| } 4237| | 4238| |#ifdef ONIG_DEBUG_CALL 4239| | fprintf(DBGFP, "CALL: id:%d, at:%ld, level:%lu\n", p->call.called_mem, s - str, subexp_call_nest_counter); 4240| |#endif 4241| 0| addr = p->call.addr; 4242| 0| INC_OP; STACK_PUSH_CALL_FRAME(p); ------------------ | | 2790| 0|#define INC_OP p++ ------------------ INC_OP; STACK_PUSH_CALL_FRAME(p); ------------------ | | 1947| 0|#define STACK_PUSH_CALL_FRAME(pat) do {\ | | 1948| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1949| 0| stk->type = STK_CALL_FRAME;\ | | ------------------ | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | 1950| 0| stk->u.call_frame.ret_addr = (pat);\ | | 1951| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1952| 0|} while(0) | | ------------------ | | | Branch (1952:9): [Folded, False: 0] | | ------------------ ------------------ 4243| 0| p = reg->ops + addr; 4244| | 4245| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4246| | 4247| 0| CASE_OP(RETURN) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4248| 0| STACK_RETURN(p); ------------------ | | 2418| 0|#define STACK_RETURN(addr) do {\ | | 2419| 0| int level = 0;\ | | 2420| 0| StackType* k = stk;\ | | 2421| 0| while (1) {\ | | ------------------ | | | Branch (2421:10): [True: 0, Folded] | | ------------------ | | 2422| 0| k--;\ | | 2423| 0| STACK_BASE_CHECK(k, "STACK_RETURN"); \ | | 2424| 0| if (k->type == STK_CALL_FRAME) {\ | | ------------------ | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | | Branch (2424:9): [True: 0, False: 0] | | ------------------ | | 2425| 0| if (level == 0) {\ | | ------------------ | | | Branch (2425:11): [True: 0, False: 0] | | ------------------ | | 2426| 0| (addr) = k->u.call_frame.ret_addr;\ | | 2427| 0| break;\ | | 2428| 0| }\ | | 2429| 0| else level--;\ | | 2430| 0| }\ | | 2431| 0| else if (k->type == STK_RETURN)\ | | ------------------ | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | | Branch (2431:14): [True: 0, False: 0] | | ------------------ | | 2432| 0| level++;\ | | 2433| 0| }\ | | 2434| 0|} while(0) | | ------------------ | | | Branch (2434:9): [Folded, False: 0] | | ------------------ ------------------ 4249| 0| STACK_PUSH_RETURN; ------------------ | | 1954| 0|#define STACK_PUSH_RETURN do {\ | | 1955| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1956| 0| stk->type = STK_RETURN;\ | | ------------------ | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | 1957| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1958| 0|} while(0) | | ------------------ | | | Branch (1958:9): [Folded, False: 0] | | ------------------ ------------------ 4250| 0| subexp_call_nest_counter--; 4251| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4252| 0|#endif 4253| | 4254| 0| CASE_OP(MOVE) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4255| 0| if (p->move.n < 0) { ------------------ | Branch (4255:11): [True: 0, False: 0] ------------------ 4256| 0| s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, -p->move.n); ------------------ | | 277| 0| onigenc_step_back((enc),(start),(s),(n)) ------------------ 4257| 0| if (IS_NULL(s)) goto fail; ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 4258| 0| } 4259| 0| else { 4260| 0| int len; 4261| | 4262| 0| for (tlen = p->move.n; tlen > 0; tlen--) { ------------------ | Branch (4262:32): [True: 0, False: 0] ------------------ 4263| 0| len = enclen(encode, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 4264| 0| s += len; 4265| 0| if (s > end) goto fail; ------------------ | Branch (4265:15): [True: 0, False: 0] ------------------ 4266| 0| if (s == end) { ------------------ | Branch (4266:15): [True: 0, False: 0] ------------------ 4267| 0| if (tlen != 1) goto fail; ------------------ | Branch (4267:17): [True: 0, False: 0] ------------------ 4268| 0| else break; 4269| 0| } 4270| 0| } 4271| 0| } 4272| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4273| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4274| | 4275| 0| CASE_OP(STEP_BACK_START) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4276| 0| tlen = p->step_back_start.initial; 4277| 0| if (tlen != 0) { ------------------ | Branch (4277:11): [True: 0, False: 0] ------------------ 4278| 0| s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen); ------------------ | | 277| 0| onigenc_step_back((enc),(start),(s),(n)) ------------------ 4279| 0| if (IS_NULL(s)) goto fail; ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 4280| 0| } 4281| 0| if (p->step_back_start.remaining != 0) { ------------------ | Branch (4281:11): [True: 0, False: 0] ------------------ 4282| 0| STACK_PUSH_ALT_WITH_ZID(p + 1, s, p->step_back_start.remaining); ------------------ | | 1844| 0|#define STACK_PUSH_ALT_WITH_ZID(pat,s,id) STACK_PUSH_WITH_ZID(STK_ALT,pat,s,id) | | ------------------ | | | | 1812| 0|#define STACK_PUSH_WITH_ZID(stack_type,pat,s,id) do {\ | | | | 1813| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1814| 0| stk->type = (stack_type);\ | | | | 1815| 0| stk->zid = (int )(id);\ | | | | 1816| 0| stk->u.state.pcode = (pat);\ | | | | 1817| 0| stk->u.state.pstr = (s);\ | | | | 1818| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1819| 0|} while(0) | | | | ------------------ | | | | | Branch (1819:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4283| 0| p += p->step_back_start.addr; 4284| 0| } 4285| 0| else 4286| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4287| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4288| | 4289| 0| CASE_OP(STEP_BACK_NEXT) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4290| 0| tlen = (LengthType )stk->zid; /* remaining count */ 4291| 0| if (tlen != INFINITE_LEN) tlen--; ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (4291:11): [True: 0, False: 0] ------------------ 4292| 0| s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, 1); ------------------ | | 277| 0| onigenc_step_back((enc),(start),(s),(n)) ------------------ 4293| 0| if (IS_NULL(s)) goto fail; ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 4294| 0| if (tlen != 0) { ------------------ | Branch (4294:11): [True: 0, False: 0] ------------------ 4295| 0| STACK_PUSH_ALT_WITH_ZID(p, s, (int )tlen); ------------------ | | 1844| 0|#define STACK_PUSH_ALT_WITH_ZID(pat,s,id) STACK_PUSH_WITH_ZID(STK_ALT,pat,s,id) | | ------------------ | | | | 1812| 0|#define STACK_PUSH_WITH_ZID(stack_type,pat,s,id) do {\ | | | | 1813| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (1786:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | | | 1788| 0| if (r != 0) return r;\ | | | | | | ------------------ | | | | | | | Branch (1788:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | | | ------------------ | | | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | | | 1235| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1790| 0| }\ | | | | | | 1791| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1791:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1814| 0| stk->type = (stack_type);\ | | | | 1815| 0| stk->zid = (int )(id);\ | | | | 1816| 0| stk->u.state.pcode = (pat);\ | | | | 1817| 0| stk->u.state.pstr = (s);\ | | | | 1818| 0| STACK_INC;\ | | | | ------------------ | | | | | | 2742| 0|#define STACK_INC stk++ | | | | ------------------ | | | | 1819| 0|} while(0) | | | | ------------------ | | | | | Branch (1819:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4296| 0| } 4297| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4298| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4299| | 4300| 339| CASE_OP(CUT_TO_MARK) ------------------ | | 2763| 339|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4301| 339| mem = p->cut_to_mark.id; /* mem: mark id */ 4302| 339| STACK_TO_VOID_TO_MARK(stkp, mem); ------------------ | | 2185| 339|#define STACK_TO_VOID_TO_MARK(k,sid) do {\ | | 2186| 339| k = stk;\ | | 2187| 339| while (1) {\ | | ------------------ | | | Branch (2187:10): [True: 339, Folded] | | ------------------ | | 2188| 339| k--;\ | | 2189| 339| STACK_BASE_CHECK(k, "STACK_TO_VOID_TO_MARK");\ | | 2190| 339| if (IS_TO_VOID_TARGET(k)) {\ | | ------------------ | | | | 1802| 339|#define IS_TO_VOID_TARGET(stk) (((stk)->type & STK_MASK_TO_VOID_TARGET) != 0) | | | | ------------------ | | | | | | 1128| 339|#define STK_MASK_TO_VOID_TARGET 0x100e | | | | ------------------ | | | | | Branch (1802:32): [True: 339, False: 0] | | | | ------------------ | | ------------------ | | 2191| 339| if (k->type == STK_MARK) {\ | | ------------------ | | | | 1122| 678|#define STK_MARK 0x0704 | | ------------------ | | | Branch (2191:11): [True: 339, False: 0] | | ------------------ | | 2192| 339| if (k->zid == (sid)) {\ | | ------------------ | | | Branch (2192:13): [True: 339, False: 0] | | ------------------ | | 2193| 339| k->type = STK_VOID;\ | | ------------------ | | | | 1111| 339|#define STK_VOID 0x0000 /* for fill a blank */ | | ------------------ | | 2194| 339| break;\ | | 2195| 339| } /* don't void different id mark */ \ | | 2196| 339| }\ | | 2197| 339| else\ | | 2198| 339| k->type = STK_VOID;\ | | ------------------ | | | | 1111| 339|#define STK_VOID 0x0000 /* for fill a blank */ | | ------------------ | | 2199| 339| }\ | | 2200| 339| }\ | | 2201| 339|} while(0) | | ------------------ | | | Branch (2201:9): [Folded, False: 339] | | ------------------ ------------------ 4303| 339| if (p->cut_to_mark.restore_pos != 0) { ------------------ | Branch (4303:11): [True: 339, False: 0] ------------------ 4304| 339| s = stkp->u.val.v; 4305| 339| } 4306| 339| INC_OP; ------------------ | | 2790| 339|#define INC_OP p++ ------------------ 4307| 339| JUMP_OUT; ------------------ | | 2792| 339|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 339|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 339|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4308| | 4309| 339| CASE_OP(MARK) ------------------ | | 2763| 339|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4310| 339| mem = p->mark.id; /* mem: mark id */ 4311| 339| if (p->mark.save_pos != 0) ------------------ | Branch (4311:11): [True: 339, False: 0] ------------------ 4312| 339| STACK_PUSH_MARK_WITH_POS(mem, s); ------------------ | | 1967| 339|#define STACK_PUSH_MARK_WITH_POS(sid, s) do {\ | | 1968| 339| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 339|#define STACK_ENSURE(n) do {\ | | | | 1786| 339| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 339] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 339|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 339] | | | | ------------------ | | ------------------ | | 1969| 339| stk->type = STK_MARK;\ | | ------------------ | | | | 1122| 339|#define STK_MARK 0x0704 | | ------------------ | | 1970| 339| stk->zid = (sid);\ | | 1971| 339| stk->u.val.v = (UChar* )(s);\ | | 1972| 339| STACK_INC;\ | | ------------------ | | | | 2742| 339|#define STACK_INC stk++ | | ------------------ | | 1973| 339|} while(0) | | ------------------ | | | Branch (1973:9): [Folded, False: 339] | | ------------------ ------------------ 4313| 0| else 4314| 0| STACK_PUSH_MARK(mem); ------------------ | | 1960| 0|#define STACK_PUSH_MARK(sid) do {\ | | 1961| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1962| 0| stk->type = STK_MARK;\ | | ------------------ | | | | 1122| 0|#define STK_MARK 0x0704 | | ------------------ | | 1963| 0| stk->zid = (sid);\ | | 1964| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1965| 0|} while(0) | | ------------------ | | | Branch (1965:9): [Folded, False: 0] | | ------------------ ------------------ 4315| | 4316| 339| INC_OP; ------------------ | | 2790| 339|#define INC_OP p++ ------------------ 4317| 339| JUMP_OUT; ------------------ | | 2792| 339|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 339|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 339|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4318| | 4319| 339| CASE_OP(SAVE_VAL) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4320| 0| { 4321| 0| SaveType type; 4322| | 4323| 0| type = p->save_val.type; 4324| 0| mem = p->save_val.id; /* mem: save id */ 4325| 0| switch ((enum SaveType )type) { ------------------ | Branch (4325:17): [True: 0, False: 0] ------------------ 4326| 0| case SAVE_KEEP: ------------------ | Branch (4326:9): [True: 0, False: 0] ------------------ 4327| 0| STACK_PUSH_SAVE_VAL(mem, type, s); ------------------ | | 1975| 0|#define STACK_PUSH_SAVE_VAL(sid, stype, sval) do {\ | | 1976| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1977| 0| stk->type = STK_SAVE_VAL;\ | | ------------------ | | | | 1121| 0|#define STK_SAVE_VAL 0x0600 | | ------------------ | | 1978| 0| stk->zid = (sid);\ | | 1979| 0| stk->u.val.type = (stype);\ | | 1980| 0| stk->u.val.v = (UChar* )(sval);\ | | 1981| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1982| 0|} while(0) | | ------------------ | | | Branch (1982:9): [Folded, False: 0] | | ------------------ ------------------ 4328| 0| break; 4329| | 4330| 0| case SAVE_S: ------------------ | Branch (4330:9): [True: 0, False: 0] ------------------ 4331| 0| STACK_PUSH_SAVE_VAL_WITH_SPREV(mem, type, s); ------------------ | | 1984| 0|#define STACK_PUSH_SAVE_VAL_WITH_SPREV(sid, stype, sval) do {\ | | 1985| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1986| 0| stk->type = STK_SAVE_VAL;\ | | ------------------ | | | | 1121| 0|#define STK_SAVE_VAL 0x0600 | | ------------------ | | 1987| 0| stk->zid = (sid);\ | | 1988| 0| stk->u.val.type = (stype);\ | | 1989| 0| stk->u.val.v = (UChar* )(sval);\ | | 1990| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1991| 0|} while(0) | | ------------------ | | | Branch (1991:9): [Folded, False: 0] | | ------------------ ------------------ 4332| 0| break; 4333| | 4334| 0| case SAVE_RIGHT_RANGE: ------------------ | Branch (4334:9): [True: 0, False: 0] ------------------ 4335| 0| STACK_PUSH_SAVE_VAL(mem, SAVE_RIGHT_RANGE, right_range); ------------------ | | 1975| 0|#define STACK_PUSH_SAVE_VAL(sid, stype, sval) do {\ | | 1976| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1977| 0| stk->type = STK_SAVE_VAL;\ | | ------------------ | | | | 1121| 0|#define STK_SAVE_VAL 0x0600 | | ------------------ | | 1978| 0| stk->zid = (sid);\ | | 1979| 0| stk->u.val.type = (stype);\ | | 1980| 0| stk->u.val.v = (UChar* )(sval);\ | | 1981| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 1982| 0|} while(0) | | ------------------ | | | Branch (1982:9): [Folded, False: 0] | | ------------------ ------------------ 4336| 0| break; 4337| 0| } 4338| 0| } 4339| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4340| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4341| | 4342| 0| CASE_OP(UPDATE_VAR) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4343| 0| { 4344| 0| UpdateVarType type; 4345| 0| enum SaveType save_type; 4346| | 4347| 0| type = p->update_var.type; 4348| | 4349| 0| switch ((enum UpdateVarType )type) { ------------------ | Branch (4349:17): [True: 0, False: 0] ------------------ 4350| 0| case UPDATE_VAR_KEEP_FROM_STACK_LAST: ------------------ | Branch (4350:9): [True: 0, False: 0] ------------------ 4351| 0| STACK_GET_SAVE_VAL_TYPE_LAST(SAVE_KEEP, keep); ------------------ | | 1993| 0|#define STACK_GET_SAVE_VAL_TYPE_LAST(stype, sval) do {\ | | 1994| 0| StackType *k = stk;\ | | 1995| 0| while (k > stk_base) {\ | | ------------------ | | | Branch (1995:10): [True: 0, False: 0] | | ------------------ | | 1996| 0| k--;\ | | 1997| 0| STACK_BASE_CHECK(k, "STACK_GET_SAVE_VAL_TYPE_LAST"); \ | | 1998| 0| if (k->type == STK_SAVE_VAL && k->u.val.type == (stype)) {\ | | ------------------ | | | | 1121| 0|#define STK_SAVE_VAL 0x0600 | | ------------------ | | | Branch (1998:9): [True: 0, False: 0] | | | Branch (1998:36): [True: 0, False: 0] | | ------------------ | | 1999| 0| (sval) = k->u.val.v;\ | | 2000| 0| break;\ | | 2001| 0| }\ | | 2002| 0| }\ | | 2003| 0|} while (0) | | ------------------ | | | Branch (2003:10): [Folded, False: 0] | | ------------------ ------------------ 4352| 0| break; 4353| 0| case UPDATE_VAR_S_FROM_STACK: ------------------ | Branch (4353:9): [True: 0, False: 0] ------------------ 4354| 0| mem = p->update_var.id; /* mem: save id */ 4355| 0| STACK_GET_SAVE_VAL_TYPE_LAST_ID_WITH_SPREV(SAVE_S, mem, s); ------------------ | | 2026| 0|#define STACK_GET_SAVE_VAL_TYPE_LAST_ID_WITH_SPREV(stype, sid, sval) do { \ | | 2027| 0| int level = 0;\ | | 2028| 0| StackType *k = stk;\ | | 2029| 0| while (k > stk_base) {\ | | ------------------ | | | Branch (2029:10): [True: 0, False: 0] | | ------------------ | | 2030| 0| k--;\ | | 2031| 0| STACK_BASE_CHECK(k, "STACK_GET_SAVE_VAL_TYPE_LAST_ID"); \ | | 2032| 0| if (k->type == STK_SAVE_VAL && k->u.val.type == (stype)\ | | ------------------ | | | | 1121| 0|#define STK_SAVE_VAL 0x0600 | | ------------------ | | | Branch (2032:9): [True: 0, False: 0] | | | Branch (2032:36): [True: 0, False: 0] | | ------------------ | | 2033| 0| && k->zid == (sid)) {\ | | ------------------ | | | Branch (2033:12): [True: 0, False: 0] | | ------------------ | | 2034| 0| if (level == 0) {\ | | ------------------ | | | Branch (2034:11): [True: 0, False: 0] | | ------------------ | | 2035| 0| (sval) = k->u.val.v;\ | | 2036| 0| break;\ | | 2037| 0| }\ | | 2038| 0| }\ | | 2039| 0| else if (k->type == STK_CALL_FRAME)\ | | ------------------ | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | | Branch (2039:14): [True: 0, False: 0] | | ------------------ | | 2040| 0| level--;\ | | 2041| 0| else if (k->type == STK_RETURN)\ | | ------------------ | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | | Branch (2041:14): [True: 0, False: 0] | | ------------------ | | 2042| 0| level++;\ | | 2043| 0| }\ | | 2044| 0|} while (0) | | ------------------ | | | Branch (2044:10): [Folded, False: 0] | | ------------------ ------------------ 4356| 0| break; 4357| 0| case UPDATE_VAR_RIGHT_RANGE_FROM_S_STACK: ------------------ | Branch (4357:9): [True: 0, False: 0] ------------------ 4358| 0| save_type = SAVE_S; 4359| 0| goto get_save_val_type_last_id; 4360| 0| break; 4361| 0| case UPDATE_VAR_RIGHT_RANGE_FROM_STACK: ------------------ | Branch (4361:9): [True: 0, False: 0] ------------------ 4362| 0| save_type = SAVE_RIGHT_RANGE; 4363| 0| get_save_val_type_last_id: 4364| 0| mem = p->update_var.id; /* mem: save id */ 4365| 0| STACK_GET_SAVE_VAL_TYPE_LAST_ID(save_type, mem, right_range, p->update_var.clear); ------------------ | | 2005| 0|#define STACK_GET_SAVE_VAL_TYPE_LAST_ID(stype, sid, sval, clear) do {\ | | 2006| 0| int level = 0;\ | | 2007| 0| StackType *k = stk;\ | | 2008| 0| while (k > stk_base) {\ | | ------------------ | | | Branch (2008:10): [True: 0, False: 0] | | ------------------ | | 2009| 0| k--;\ | | 2010| 0| STACK_BASE_CHECK(k, "STACK_GET_SAVE_VAL_TYPE_LAST_ID"); \ | | 2011| 0| if (k->type == STK_SAVE_VAL && k->u.val.type == (stype)\ | | ------------------ | | | | 1121| 0|#define STK_SAVE_VAL 0x0600 | | ------------------ | | | Branch (2011:9): [True: 0, False: 0] | | | Branch (2011:36): [True: 0, False: 0] | | ------------------ | | 2012| 0| && k->zid == (sid)) {\ | | ------------------ | | | Branch (2012:12): [True: 0, False: 0] | | ------------------ | | 2013| 0| if (level == 0) {\ | | ------------------ | | | Branch (2013:11): [True: 0, False: 0] | | ------------------ | | 2014| 0| (sval) = k->u.val.v;\ | | 2015| 0| if (clear != 0) k->type = STK_VOID;\ | | ------------------ | | | | 1111| 0|#define STK_VOID 0x0000 /* for fill a blank */ | | ------------------ | | | Branch (2015:13): [True: 0, False: 0] | | ------------------ | | 2016| 0| break;\ | | 2017| 0| }\ | | 2018| 0| }\ | | 2019| 0| else if (k->type == STK_CALL_FRAME)\ | | ------------------ | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | | Branch (2019:14): [True: 0, False: 0] | | ------------------ | | 2020| 0| level--;\ | | 2021| 0| else if (k->type == STK_RETURN)\ | | ------------------ | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | ------------------ | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | ------------------ | | ------------------ | | | Branch (2021:14): [True: 0, False: 0] | | ------------------ | | 2022| 0| level++;\ | | 2023| 0| }\ | | 2024| 0|} while (0) | | ------------------ | | | Branch (2024:10): [Folded, False: 0] | | ------------------ ------------------ 4366| 0| break; 4367| 0| case UPDATE_VAR_RIGHT_RANGE_TO_S: ------------------ | Branch (4367:9): [True: 0, False: 0] ------------------ 4368| 0| right_range = s; 4369| 0| break; 4370| 0| case UPDATE_VAR_RIGHT_RANGE_INIT: ------------------ | Branch (4370:9): [True: 0, False: 0] ------------------ 4371| 0| INIT_RIGHT_RANGE; ------------------ | | 2523| 0|#define INIT_RIGHT_RANGE right_range = (UChar* )in_right_range ------------------ 4372| 0| break; 4373| 0| } 4374| 0| } 4375| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4376| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4377| | 4378| 0|#ifdef USE_CALLOUT 4379| 0| CASE_OP(CALLOUT_CONTENTS) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4380| 0| of = ONIG_CALLOUT_OF_CONTENTS; 4381| 0| mem = p->callout_contents.num; 4382| 0| goto callout_common_entry; 4383| 0| BREAK_OUT; ------------------ | | 2793| 0|#define BREAK_OUT SOP_OUT; BREAK_OP ------------------ 4384| | 4385| 0| CASE_OP(CALLOUT_NAME) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4386| 0| { 4387| 0| int call_result; 4388| 0| int name_id; 4389| 0| int in; 4390| 0| CalloutListEntry* e; 4391| 0| OnigCalloutFunc func; 4392| 0| OnigCalloutArgs args; 4393| | 4394| 0| of = ONIG_CALLOUT_OF_NAME; 4395| 0| mem = p->callout_name.num; 4396| | 4397| 0| callout_common_entry: 4398| 0| e = onig_reg_callout_list_at(reg, mem); 4399| 0| in = e->in; 4400| 0| if (of == ONIG_CALLOUT_OF_NAME) { ------------------ | Branch (4400:13): [True: 0, False: 0] ------------------ 4401| 0| name_id = p->callout_name.id; 4402| 0| func = onig_get_callout_start_func(reg, mem); 4403| 0| } 4404| 0| else { 4405| 0| name_id = ONIG_NON_NAME_ID; ------------------ | | 760| 0|#define ONIG_NON_NAME_ID -1 ------------------ 4406| 0| func = msa->mp->progress_callout_of_contents; 4407| 0| } 4408| | 4409| 0| if (IS_NOT_NULL(func) && (in & ONIG_CALLOUT_IN_PROGRESS) != 0) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4409:34): [True: 0, False: 0] ------------------ 4410| 0| CALLOUT_BODY(func, ONIG_CALLOUT_IN_PROGRESS, name_id, ------------------ | | 1051| 0|#define CALLOUT_BODY(func, ain, aname_id, anum, user, args, result) do { \ | | 1052| 0| args.in = (ain);\ | | 1053| 0| args.name_id = (aname_id);\ | | 1054| 0| args.num = anum;\ | | 1055| 0| args.regex = reg;\ | | 1056| 0| args.string = str;\ | | 1057| 0| args.string_end = end;\ | | 1058| 0| args.start = sstart;\ | | 1059| 0| args.right_range = right_range;\ | | 1060| 0| args.current = s;\ | | 1061| 0| args.retry_in_match_counter = retry_in_match_counter;\ | | 1062| 0| args.msa = msa;\ | | 1063| 0| args.stk_base = stk_base;\ | | 1064| 0| args.stk = stk;\ | | 1065| 0| args.mem_start_stk = mem_start_stk;\ | | 1066| 0| args.mem_end_stk = mem_end_stk;\ | | 1067| 0| result = (func)(&args, user);\ | | 1068| 0|} while (0) | | ------------------ | | | Branch (1068:10): [Folded, False: 0] | | ------------------ ------------------ 4411| 0| (int )mem, msa->mp->callout_user_data, args, call_result); 4412| 0| switch (call_result) { 4413| 0| case ONIG_CALLOUT_FAIL: ------------------ | Branch (4413:11): [True: 0, False: 0] ------------------ 4414| 0| goto fail; 4415| 0| break; 4416| 0| case ONIG_CALLOUT_SUCCESS: ------------------ | Branch (4416:11): [True: 0, False: 0] ------------------ 4417| 0| goto retraction_callout2; 4418| 0| break; 4419| 0| default: /* error code */ ------------------ | Branch (4419:11): [True: 0, False: 0] ------------------ 4420| 0| if (call_result > 0) { ------------------ | Branch (4420:17): [True: 0, False: 0] ------------------ 4421| 0| call_result = ONIGERR_INVALID_ARGUMENT; ------------------ | | 586| 0|#define ONIGERR_INVALID_ARGUMENT -30 ------------------ 4422| 0| } 4423| 0| best_len = call_result; 4424| 0| goto match_at_end; 4425| 0| break; 4426| 0| } 4427| 0| } 4428| 0| else { 4429| 0| retraction_callout2: 4430| 0| if ((in & ONIG_CALLOUT_IN_RETRACTION) != 0) { ------------------ | Branch (4430:15): [True: 0, False: 0] ------------------ 4431| 0| if (of == ONIG_CALLOUT_OF_NAME) { ------------------ | Branch (4431:17): [True: 0, False: 0] ------------------ 4432| 0| if (IS_NOT_NULL(func)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 4433| 0| STACK_PUSH_CALLOUT_NAME(name_id, mem, func); ------------------ | | 2055| 0|#define STACK_PUSH_CALLOUT_NAME(aid, anum, func) do {\ | | 2056| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2057| 0| stk->type = STK_CALLOUT;\ | | ------------------ | | | | 1107| 0|#define STK_CALLOUT 0x0070 | | ------------------ | | 2058| 0| stk->zid = (aid);\ | | 2059| 0| stk->u.callout.num = (anum);\ | | 2060| 0| stk->u.callout.func = (func);\ | | 2061| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 2062| 0|} while(0) | | ------------------ | | | Branch (2062:9): [Folded, False: 0] | | ------------------ ------------------ 4434| 0| } 4435| 0| } 4436| 0| else { 4437| 0| func = msa->mp->retraction_callout_of_contents; 4438| 0| if (IS_NOT_NULL(func)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 4439| 0| STACK_PUSH_CALLOUT_CONTENTS(mem, func); ------------------ | | 2046| 0|#define STACK_PUSH_CALLOUT_CONTENTS(anum, func) do {\ | | 2047| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 1785| 0|#define STACK_ENSURE(n) do {\ | | | | 1786| 0| if ((int )(stk_end - stk) < (n)) {\ | | | | ------------------ | | | | | Branch (1786:9): [True: 0, False: 0] | | | | ------------------ | | | | 1787| 0| int r = stack_double(&is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\ | | | | 1788| 0| if (r != 0) return r;\ | | | | ------------------ | | | | | Branch (1788:9): [True: 0, False: 0] | | | | ------------------ | | | | 1789| 0| UPDATE_FOR_STACK_REALLOC;\ | | | | ------------------ | | | | | | 1232| 0|#define UPDATE_FOR_STACK_REALLOC do{\ | | | | | | 1233| 0| mem_start_stk = (StkPtrType* )alloc_base;\ | | | | | | 1234| 0| mem_end_stk = mem_start_stk + num_mem + 1;\ | | | | | | 1235| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1235:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 1790| 0| }\ | | | | 1791| 0|} while(0) | | | | ------------------ | | | | | Branch (1791:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2048| 0| stk->type = STK_CALLOUT;\ | | ------------------ | | | | 1107| 0|#define STK_CALLOUT 0x0070 | | ------------------ | | 2049| 0| stk->zid = ONIG_NON_NAME_ID;\ | | ------------------ | | | | 760| 0|#define ONIG_NON_NAME_ID -1 | | ------------------ | | 2050| 0| stk->u.callout.num = (anum);\ | | 2051| 0| stk->u.callout.func = (func);\ | | 2052| 0| STACK_INC;\ | | ------------------ | | | | 2742| 0|#define STACK_INC stk++ | | ------------------ | | 2053| 0|} while(0) | | ------------------ | | | Branch (2053:9): [Folded, False: 0] | | ------------------ ------------------ 4440| 0| } 4441| 0| } 4442| 0| } 4443| 0| } 4444| 0| } 4445| 0| INC_OP; ------------------ | | 2790| 0|#define INC_OP p++ ------------------ 4446| 0| JUMP_OUT; ------------------ | | 2792| 0|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 0|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 0|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4447| 0|#endif 4448| | 4449| 28.9k| CASE_OP(FINISH) ------------------ | | 2763| 28.9k|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4450| 28.9k|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 4451| 28.9k| if (OPTON_FIND_LONGEST(options)) { ------------------ | | 409| 28.9k|#define OPTON_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 381| 28.9k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 380| 28.9k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 379| 28.9k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 378| 28.9k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 377| 28.9k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:38): [True: 0, False: 28.9k] | | ------------------ ------------------ 4452| 0| best_len = ONIG_MISMATCH; ------------------ | | 565| 0|#define ONIG_MISMATCH -1 ------------------ 4453| 0| } 4454| 28.9k|#endif 4455| 28.9k| goto match_at_end; 4456| | 4457| |#ifdef ONIG_DEBUG_STATISTICS 4458| | fail: 4459| | SOP_OUT; 4460| | goto fail2; 4461| |#endif 4462| 0| CASE_OP(FAIL) ------------------ | | 2763| 0|#define CASE_OP(x) L_##x: SOP_IN(OP_##x); MATCH_DEBUG_OUT(0) ------------------ 4463| |#ifdef ONIG_DEBUG_STATISTICS 4464| | fail2: 4465| |#else 4466| 68.0M| fail: 4467| 68.0M|#endif 4468| 68.0M| STACK_POP; ------------------ | | 2089| 68.0M|#define STACK_POP do {\ | | 2090| 68.0M| switch (pop_level) {\ | | 2091| 68.0M| case STACK_POP_LEVEL_FREE:\ | | ------------------ | | | Branch (2091:3): [True: 68.0M, False: 12.0k] | | ------------------ | | 2092| 68.0M| while (1) {\ | | ------------------ | | | Branch (2092:12): [True: 68.0M, Folded] | | ------------------ | | 2093| 68.0M| stk--;\ | | 2094| 68.0M| STACK_BASE_CHECK(stk, "STACK_POP"); \ | | 2095| 68.0M| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 1125| 68.0M|#define STK_MASK_POP_USED STK_ALT_FLAG | | | | ------------------ | | | | | | 1091| 68.0M|#define STK_ALT_FLAG 0x0001 | | | | ------------------ | | ------------------ | | | Branch (2095:11): [True: 68.0M, False: 0] | | ------------------ | | 2096| 68.0M| }\ | | 2097| 68.0M| break;\ | | 2098| 12.0k| case STACK_POP_LEVEL_MEM_START:\ | | ------------------ | | | Branch (2098:3): [True: 12.0k, False: 68.0M] | | ------------------ | | 2099| 12.5k| while (1) {\ | | ------------------ | | | Branch (2099:12): [True: 12.5k, Folded] | | ------------------ | | 2100| 12.5k| stk--;\ | | 2101| 12.5k| STACK_BASE_CHECK(stk, "STACK_POP 2"); \ | | 2102| 12.5k| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 1125| 12.5k|#define STK_MASK_POP_USED STK_ALT_FLAG | | | | ------------------ | | | | | | 1091| 12.5k|#define STK_ALT_FLAG 0x0001 | | | | ------------------ | | ------------------ | | | Branch (2102:11): [True: 12.0k, False: 547] | | ------------------ | | 2103| 12.5k| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 1099| 547|#define STK_MEM_START 0x0010 | | ------------------ | | | Branch (2103:16): [True: 547, False: 0] | | ------------------ | | 2104| 547| mem_start_stk[stk->zid] = stk->u.mem.prev_start;\ | | 2105| 547| mem_end_stk[stk->zid] = stk->u.mem.prev_end;\ | | 2106| 547| }\ | | 2107| 12.5k| }\ | | 2108| 12.0k| break;\ | | 2109| 0| default:\ | | ------------------ | | | Branch (2109:3): [True: 0, False: 68.0M] | | ------------------ | | 2110| 0| while (1) {\ | | ------------------ | | | Branch (2110:12): [True: 0, Folded] | | ------------------ | | 2111| 0| stk--;\ | | 2112| 0| STACK_BASE_CHECK(stk, "STACK_POP 3"); \ | | 2113| 0| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 1125| 0|#define STK_MASK_POP_USED STK_ALT_FLAG | | | | ------------------ | | | | | | 1091| 0|#define STK_ALT_FLAG 0x0001 | | | | ------------------ | | ------------------ | | | Branch (2113:11): [True: 0, False: 0] | | ------------------ | | 2114| 0| else if ((stk->type & STK_MASK_POP_HANDLED) != 0) {\ | | ------------------ | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | ------------------ | | | Branch (2114:16): [True: 0, False: 0] | | ------------------ | | 2115| 0| if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 1099| 0|#define STK_MEM_START 0x0010 | | ------------------ | | | Branch (2115:13): [True: 0, False: 0] | | ------------------ | | 2116| 0| mem_start_stk[stk->zid] = stk->u.mem.prev_start;\ | | 2117| 0| mem_end_stk[stk->zid] = stk->u.mem.prev_end;\ | | 2118| 0| }\ | | 2119| 0| else if (stk->type == STK_MEM_END) {\ | | ------------------ | | | | 1100| 0|#define STK_MEM_END 0x8030 | | ------------------ | | | Branch (2119:18): [True: 0, False: 0] | | ------------------ | | 2120| 0| mem_start_stk[stk->zid] = stk->u.mem.prev_start;\ | | 2121| 0| mem_end_stk[stk->zid] = stk->u.mem.prev_end;\ | | 2122| 0| }\ | | 2123| 0| POP_REPEAT_INC \ | | 2124| 0| POP_EMPTY_CHECK_START \ | | 2125| 0| POP_CALL \ | | ------------------ | | | | 1260| 0|#define POP_CALL else if (stk->type == STK_RETURN) {subexp_call_nest_counter++;} else if (stk->type == STK_CALL_FRAME) {subexp_call_nest_counter--;} | | | | ------------------ | | | | | | 1120| 0|#define STK_RETURN (0x0500 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | #define POP_CALL else if (stk->type == STK_RETURN) {subexp_call_nest_counter++;} else if (stk->type == STK_CALL_FRAME) {subexp_call_nest_counter--;} | | | | ------------------ | | | | | | 1119| 0|#define STK_CALL_FRAME (0x0400 | STK_MASK_POP_HANDLED) | | | | | | ------------------ | | | | | | | | 1126| 0|#define STK_MASK_POP_HANDLED 0x0010 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1260:28): [True: 0, False: 0] | | | | | Branch (1260:92): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2126| 0| POP_CALLOUT_CASE\ | | ------------------ | | | | 2082| 0| else if (stk->type == STK_CALLOUT) {\ | | | | ------------------ | | | | | | 1107| 0|#define STK_CALLOUT 0x0070 | | | | ------------------ | | | | | Branch (2082:12): [True: 0, False: 0] | | | | ------------------ | | | | 2083| 0| RETRACTION_CALLOUT(stk->u.callout.func, stk->zid, stk->u.callout.num, msa->mp->callout_user_data);\ | | | | ------------------ | | | | | | 1070| 0|#define RETRACTION_CALLOUT(func, aname_id, anum, user) do {\ | | | | | | 1071| 0| int result;\ | | | | | | 1072| 0| OnigCalloutArgs args;\ | | | | | | 1073| 0| CALLOUT_BODY(func, ONIG_CALLOUT_IN_RETRACTION, aname_id, anum, user, args, result);\ | | | | | | ------------------ | | | | | | | | 1051| 0|#define CALLOUT_BODY(func, ain, aname_id, anum, user, args, result) do { \ | | | | | | | | 1052| 0| args.in = (ain);\ | | | | | | | | 1053| 0| args.name_id = (aname_id);\ | | | | | | | | 1054| 0| args.num = anum;\ | | | | | | | | 1055| 0| args.regex = reg;\ | | | | | | | | 1056| 0| args.string = str;\ | | | | | | | | 1057| 0| args.string_end = end;\ | | | | | | | | 1058| 0| args.start = sstart;\ | | | | | | | | 1059| 0| args.right_range = right_range;\ | | | | | | | | 1060| 0| args.current = s;\ | | | | | | | | 1061| 0| args.retry_in_match_counter = retry_in_match_counter;\ | | | | | | | | 1062| 0| args.msa = msa;\ | | | | | | | | 1063| 0| args.stk_base = stk_base;\ | | | | | | | | 1064| 0| args.stk = stk;\ | | | | | | | | 1065| 0| args.mem_start_stk = mem_start_stk;\ | | | | | | | | 1066| 0| args.mem_end_stk = mem_end_stk;\ | | | | | | | | 1067| 0| result = (func)(&args, user);\ | | | | | | | | 1068| 0|} while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (1068:10): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 1074| 0| switch (result) {\ | | | | | | 1075| 0| case ONIG_CALLOUT_FAIL:\ | | | | | | ------------------ | | | | | | | Branch (1075:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1076| 0| case ONIG_CALLOUT_SUCCESS:\ | | | | | | ------------------ | | | | | | | Branch (1076:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1077| 0| break;\ | | | | | | 1078| 0| default:\ | | | | | | ------------------ | | | | | | | Branch (1078:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1079| 0| if (result > 0) {\ | | | | | | ------------------ | | | | | | | Branch (1079:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1080| 0| result = ONIGERR_INVALID_ARGUMENT;\ | | | | | | ------------------ | | | | | | | | 586| 0|#define ONIGERR_INVALID_ARGUMENT -30 | | | | | | ------------------ | | | | | | 1081| 0| }\ | | | | | | 1082| 0| best_len = result;\ | | | | | | 1083| 0| goto match_at_end;\ | | | | | | 1084| 0| break;\ | | | | | | 1085| 0| }\ | | | | | | 1086| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (1086:9): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 2084| 0| } | | ------------------ | | 2127| 0| }\ | | 2128| 0| }\ | | 2129| 0| break;\ | | 2130| 68.0M| }\ | | 2131| 68.0M|} while(0) | | ------------------ | | | Branch (2131:9): [Folded, False: 68.0M] | | ------------------ ------------------ 4469| 68.0M| p = stk->u.state.pcode; 4470| 68.0M| s = stk->u.state.pstr; 4471| 68.0M| CHECK_RETRY_LIMIT_IN_MATCH; ------------------ | | 1395| 68.0M|#define CHECK_RETRY_LIMIT_IN_MATCH do {\ | | 1396| 68.0M| if (++retry_in_match_counter >= retry_limit_in_match && \ | | ------------------ | | | Branch (1396:7): [True: 0, False: 68.0M] | | ------------------ | | 1397| 68.0M| retry_limit_in_match != 0) {\ | | ------------------ | | | Branch (1397:7): [True: 0, False: 0] | | ------------------ | | 1398| 0| MATCH_AT_ERROR_RETURN((retry_in_match_counter >= msa->retry_limit_in_match && msa->retry_limit_in_match != 0) ? ONIGERR_RETRY_LIMIT_IN_MATCH_OVER : ONIGERR_RETRY_LIMIT_IN_SEARCH_OVER); \ | | ------------------ | | | | 2844| 0|#define MATCH_AT_ERROR_RETURN(err_code) do {\ | | | | 2845| 0| best_len = err_code; goto match_at_end;\ | | | | ------------------ | | | | | Branch (2845:14): [True: 0, False: 0] | | | | | Branch (2845:14): [True: 0, False: 0] | | | | ------------------ | | | | 2846| 0|} while(0) | | | | ------------------ | | | | | Branch (2846:9): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 1399| 0| }\ | | 1400| 68.0M|} while (0) | | ------------------ | | | Branch (1400:10): [Folded, False: 68.0M] | | ------------------ ------------------ 4472| 68.0M| JUMP_OUT; ------------------ | | 2792| 68.0M|#define JUMP_OUT SOP_OUT; JUMP_OP | | ------------------ | | | | 2766| 68.0M|#define JUMP_OP GOTO_OP | | | | ------------------ | | | | | | 2768| 68.0M|#define GOTO_OP goto *(p->opaddr) | | | | ------------------ | | ------------------ ------------------ 4473| | 4474| 68.0M| DEFAULT_OP 4475| 68.0M| MATCH_AT_ERROR_RETURN(ONIGERR_UNDEFINED_BYTECODE); ------------------ | | 2844| 68.0M|#define MATCH_AT_ERROR_RETURN(err_code) do {\ | | 2845| 68.0M| best_len = err_code; goto match_at_end;\ | | 2846| 68.0M|} while(0) | | ------------------ | | | Branch (2846:9): [Folded, False: 0] | | ------------------ ------------------ 4476| | 4477| 68.0M| } BYTECODE_INTERPRETER_END; 4478| | 4479| 126k| match_at_end: 4480| 126k| if (msa->retry_limit_in_search != 0) { ------------------ | Branch (4480:7): [True: 0, False: 126k] ------------------ 4481| |#ifdef ONIG_DEBUG 4482| | if (retry_in_match_counter > 4483| | ULONG_MAX - msa->retry_limit_in_search_counter) { 4484| | fprintf(DBGFP, "retry limit counter overflow: %8lu/%8lu\n", 4485| | retry_in_match_counter, msa->retry_limit_in_search_counter); 4486| | } 4487| |#endif 4488| 0| msa->retry_limit_in_search_counter += retry_in_match_counter; 4489| 0| } 4490| | 4491| |#ifdef ONIG_DEBUG_MATCH_COUNTER 4492| | MATCH_COUNTER_OUT("END"); 4493| |#endif 4494| | 4495| 126k| STACK_SAVE(msa, is_alloca, alloc_base); ------------------ | | 1361| 126k|#define STACK_SAVE(msa,is_alloca,alloc_base) do{\ | | 1362| 126k| (msa)->stack_n = (int )(stk_end - stk_base);\ | | 1363| 126k| if ((is_alloca) != 0) {\ | | ------------------ | | | Branch (1363:7): [True: 96.9k, False: 29.7k] | | ------------------ | | 1364| 96.9k| size_t size = sizeof(StkPtrType) * (msa)->ptr_num\ | | 1365| 96.9k| + sizeof(StackType) * (msa)->stack_n;\ | | 1366| 96.9k| (msa)->stack_p = xmalloc(size);\ | | ------------------ | | | | 227| 96.9k|#define xmalloc malloc | | ------------------ | | 1367| 96.9k| CHECK_NULL_RETURN_MEMERR((msa)->stack_p);\ | | ------------------ | | | | 204| 96.9k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 201| 96.9k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | ------------------ | | | | | | | Branch (201:39): [True: 0, False: 96.9k] | | | | | | ------------------ | | | | ------------------ | | | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 570| 0|#define ONIGERR_MEMORY -5 | | | | ------------------ | | ------------------ | | 1368| 96.9k| xmemcpy((msa)->stack_p, (alloc_base), size);\ | | ------------------ | | | | 181| 96.9k|#define xmemcpy memcpy | | ------------------ | | 1369| 96.9k| }\ | | 1370| 126k| else {\ | | 1371| 29.7k| (msa)->stack_p = (alloc_base);\ | | 1372| 126k| };\ | | 1373| 126k|} while(0) | | ------------------ | | | Branch (1373:9): [Folded, False: 126k] | | ------------------ ------------------ 4496| 126k| return best_len; 4497| 126k|} regexec.c:stack_double: 1732| 2.60k|{ 1733| 2.60k| unsigned int n; 1734| 2.60k| int used; 1735| 2.60k| size_t size; 1736| 2.60k| size_t new_size; 1737| 2.60k| char* alloc_base; 1738| 2.60k| char* new_alloc_base; 1739| 2.60k| StackType *stk_base, *stk_end, *stk; 1740| | 1741| 2.60k| alloc_base = *arg_alloc_base; 1742| 2.60k| stk_base = *arg_stk_base; 1743| 2.60k| stk_end = *arg_stk_end; 1744| 2.60k| stk = *arg_stk; 1745| | 1746| 2.60k| n = (unsigned int )(stk_end - stk_base); 1747| 2.60k| size = sizeof(StkPtrType) * msa->ptr_num + sizeof(StackType) * n; 1748| 2.60k| n *= 2; 1749| 2.60k| new_size = sizeof(StkPtrType) * msa->ptr_num + sizeof(StackType) * n; 1750| 2.60k| if (*is_alloca != 0) { ------------------ | Branch (1750:7): [True: 1.21k, False: 1.38k] ------------------ 1751| 1.21k| new_alloc_base = (char* )xmalloc(new_size); ------------------ | | 227| 1.21k|#define xmalloc malloc ------------------ 1752| 1.21k| if (IS_NULL(new_alloc_base)) { ------------------ | | 201| 1.21k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 1.21k] | | ------------------ ------------------ 1753| 0| STACK_SAVE(msa, *is_alloca, alloc_base); ------------------ | | 1361| 0|#define STACK_SAVE(msa,is_alloca,alloc_base) do{\ | | 1362| 0| (msa)->stack_n = (int )(stk_end - stk_base);\ | | 1363| 0| if ((is_alloca) != 0) {\ | | ------------------ | | | Branch (1363:7): [True: 0, False: 0] | | ------------------ | | 1364| 0| size_t size = sizeof(StkPtrType) * (msa)->ptr_num\ | | 1365| 0| + sizeof(StackType) * (msa)->stack_n;\ | | 1366| 0| (msa)->stack_p = xmalloc(size);\ | | ------------------ | | | | 227| 0|#define xmalloc malloc | | ------------------ | | 1367| 0| CHECK_NULL_RETURN_MEMERR((msa)->stack_p);\ | | ------------------ | | | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | ------------------ | | | | | | | Branch (201:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 570| 0|#define ONIGERR_MEMORY -5 | | | | ------------------ | | ------------------ | | 1368| 0| xmemcpy((msa)->stack_p, (alloc_base), size);\ | | ------------------ | | | | 181| 0|#define xmemcpy memcpy | | ------------------ | | 1369| 0| }\ | | 1370| 0| else {\ | | 1371| 0| (msa)->stack_p = (alloc_base);\ | | 1372| 0| };\ | | 1373| 0|} while(0) | | ------------------ | | | Branch (1373:9): [Folded, False: 0] | | ------------------ ------------------ 1754| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 1755| 0| } 1756| 1.21k| xmemcpy(new_alloc_base, alloc_base, size); ------------------ | | 181| 1.21k|#define xmemcpy memcpy ------------------ 1757| 1.21k| *is_alloca = 0; 1758| 1.21k| } 1759| 1.38k| else { 1760| 1.38k| if (msa->match_stack_limit != 0 && n > msa->match_stack_limit) { ------------------ | Branch (1760:9): [True: 0, False: 1.38k] | Branch (1760:40): [True: 0, False: 0] ------------------ 1761| 0| if ((unsigned int )(stk_end - stk_base) == msa->match_stack_limit) { ------------------ | Branch (1761:11): [True: 0, False: 0] ------------------ 1762| 0| STACK_SAVE(msa, *is_alloca, alloc_base); ------------------ | | 1361| 0|#define STACK_SAVE(msa,is_alloca,alloc_base) do{\ | | 1362| 0| (msa)->stack_n = (int )(stk_end - stk_base);\ | | 1363| 0| if ((is_alloca) != 0) {\ | | ------------------ | | | Branch (1363:7): [True: 0, False: 0] | | ------------------ | | 1364| 0| size_t size = sizeof(StkPtrType) * (msa)->ptr_num\ | | 1365| 0| + sizeof(StackType) * (msa)->stack_n;\ | | 1366| 0| (msa)->stack_p = xmalloc(size);\ | | ------------------ | | | | 227| 0|#define xmalloc malloc | | ------------------ | | 1367| 0| CHECK_NULL_RETURN_MEMERR((msa)->stack_p);\ | | ------------------ | | | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | ------------------ | | | | | | | Branch (201:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 570| 0|#define ONIGERR_MEMORY -5 | | | | ------------------ | | ------------------ | | 1368| 0| xmemcpy((msa)->stack_p, (alloc_base), size);\ | | ------------------ | | | | 181| 0|#define xmemcpy memcpy | | ------------------ | | 1369| 0| }\ | | 1370| 0| else {\ | | 1371| 0| (msa)->stack_p = (alloc_base);\ | | 1372| 0| };\ | | 1373| 0|} while(0) | | ------------------ | | | Branch (1373:9): [Folded, False: 0] | | ------------------ ------------------ 1763| 0| return ONIGERR_MATCH_STACK_LIMIT_OVER; ------------------ | | 576| 0|#define ONIGERR_MATCH_STACK_LIMIT_OVER -15 ------------------ 1764| 0| } 1765| 0| else 1766| 0| n = msa->match_stack_limit; 1767| 0| } 1768| 1.38k| new_alloc_base = (char* )xrealloc(alloc_base, new_size); ------------------ | | 228| 1.38k|#define xrealloc realloc ------------------ 1769| 1.38k| if (IS_NULL(new_alloc_base)) { ------------------ | | 201| 1.38k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 1.38k] | | ------------------ ------------------ 1770| 0| STACK_SAVE(msa, *is_alloca, alloc_base); ------------------ | | 1361| 0|#define STACK_SAVE(msa,is_alloca,alloc_base) do{\ | | 1362| 0| (msa)->stack_n = (int )(stk_end - stk_base);\ | | 1363| 0| if ((is_alloca) != 0) {\ | | ------------------ | | | Branch (1363:7): [True: 0, False: 0] | | ------------------ | | 1364| 0| size_t size = sizeof(StkPtrType) * (msa)->ptr_num\ | | 1365| 0| + sizeof(StackType) * (msa)->stack_n;\ | | 1366| 0| (msa)->stack_p = xmalloc(size);\ | | ------------------ | | | | 227| 0|#define xmalloc malloc | | ------------------ | | 1367| 0| CHECK_NULL_RETURN_MEMERR((msa)->stack_p);\ | | ------------------ | | | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | ------------------ | | | | | | | Branch (201:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | | | ------------------ | | | | | | 570| 0|#define ONIGERR_MEMORY -5 | | | | ------------------ | | ------------------ | | 1368| 0| xmemcpy((msa)->stack_p, (alloc_base), size);\ | | ------------------ | | | | 181| 0|#define xmemcpy memcpy | | ------------------ | | 1369| 0| }\ | | 1370| 0| else {\ | | 1371| 0| (msa)->stack_p = (alloc_base);\ | | 1372| 0| };\ | | 1373| 0|} while(0) | | ------------------ | | | Branch (1373:9): [Folded, False: 0] | | ------------------ ------------------ 1771| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 1772| 0| } 1773| 1.38k| } 1774| | 1775| 2.60k| alloc_base = new_alloc_base; 1776| 2.60k| used = (int )(stk - stk_base); 1777| 2.60k| *arg_alloc_base = alloc_base; 1778| 2.60k| *arg_stk_base = (StackType* )(alloc_base 1779| 2.60k| + (sizeof(StkPtrType) * msa->ptr_num)); 1780| 2.60k| *arg_stk = *arg_stk_base + used; 1781| 2.60k| *arg_stk_end = *arg_stk_base + n; 1782| 2.60k| return 0; 1783| 2.60k|} regexec.c:forward_search: 5222| 57.0k|{ 5223| 57.0k| UChar *p, *pprev = (UChar* )NULL; ------------------ | | 80| 57.0k|#define UChar OnigUChar ------------------ 5224| | 5225| |#ifdef ONIG_DEBUG_SEARCH 5226| | fprintf(DBGFP, "forward_search: str: %p, end: %p, start: %p, range: %p\n", 5227| | str, end, start, range); 5228| |#endif 5229| | 5230| 57.0k| p = start; 5231| 57.0k| if (reg->dist_min != 0) { ------------------ | Branch (5231:7): [True: 11.6k, False: 45.3k] ------------------ 5232| 11.6k| if (DIST_CAST(end - p) <= reg->dist_min) ------------------ | | 60| 11.6k|#define DIST_CAST(d) (d) ------------------ | Branch (5232:9): [True: 21, False: 11.6k] ------------------ 5233| 21| return 0; /* fail */ 5234| | 5235| 11.6k| if (ONIGENC_IS_SINGLEBYTE(reg->enc)) { ------------------ | | 254| 11.6k|#define ONIGENC_IS_SINGLEBYTE(enc) (ONIGENC_MBC_MAXLEN(enc) == 1) | | ------------------ | | | | 280| 11.6k|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ | | | Branch (254:40): [True: 0, False: 11.6k] | | ------------------ ------------------ 5236| 0| p += reg->dist_min; 5237| 0| } 5238| 11.6k| else { 5239| 11.6k| UChar *q = p + reg->dist_min; ------------------ | | 80| 11.6k|#define UChar OnigUChar ------------------ 5240| 26.1k| while (p < q) p += enclen(reg->enc, p); ------------------ | | 83| 14.4k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 14.4k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ | Branch (5240:14): [True: 14.4k, False: 11.6k] ------------------ 5241| 11.6k| } 5242| 11.6k| } 5243| | 5244| 57.0k| retry: 5245| 57.0k| switch (reg->optimize) { ------------------ | Branch (5245:11): [True: 57.0k, False: 0] ------------------ 5246| 0| case OPTIMIZE_STR: ------------------ | Branch (5246:3): [True: 0, False: 57.0k] ------------------ 5247| 0| p = slow_search(reg->enc, reg->exact, reg->exact_end, p, end, range); 5248| 0| break; 5249| | 5250| 42.5k| case OPTIMIZE_STR_FAST: ------------------ | Branch (5250:3): [True: 42.5k, False: 14.4k] ------------------ 5251| 42.5k| p = sunday_quick_search(reg, reg->exact, reg->exact_end, p, end, range); 5252| 42.5k| break; 5253| | 5254| 0| case OPTIMIZE_STR_FAST_STEP_FORWARD: ------------------ | Branch (5254:3): [True: 0, False: 57.0k] ------------------ 5255| 0| p = sunday_quick_search_step_forward(reg, reg->exact, reg->exact_end, 5256| 0| p, end, range); 5257| 0| break; 5258| | 5259| 14.4k| case OPTIMIZE_MAP: ------------------ | Branch (5259:3): [True: 14.4k, False: 42.5k] ------------------ 5260| 14.4k| p = map_search(reg->enc, reg->map, p, range); 5261| 14.4k| break; 5262| 57.0k| } 5263| | 5264| 57.0k| if (p && p < range) { ------------------ | Branch (5264:7): [True: 31.2k, False: 25.7k] | Branch (5264:12): [True: 30.9k, False: 348] ------------------ 5265| 30.9k| if (DIST_CAST(p - start) < reg->dist_min) { ------------------ | | 60| 30.9k|#define DIST_CAST(d) (d) ------------------ | Branch (5265:9): [True: 0, False: 30.9k] ------------------ 5266| 0| retry_gate: 5267| 0| pprev = p; 5268| 0| p += enclen(reg->enc, p); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5269| 0| goto retry; 5270| 0| } 5271| | 5272| 30.9k| if (reg->sub_anchor) { ------------------ | Branch (5272:9): [True: 0, False: 30.9k] ------------------ 5273| 0| UChar* prev; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 5274| | 5275| 0| switch (reg->sub_anchor) { ------------------ | Branch (5275:15): [True: 0, False: 0] ------------------ 5276| 0| case ANCR_BEGIN_LINE: ------------------ | | 462| 0|#define ANCR_BEGIN_LINE (1<<5) ------------------ | Branch (5276:7): [True: 0, False: 0] ------------------ 5277| 0| if (!ON_STR_BEGIN(p)) { ------------------ | | 2517| 0|#define ON_STR_BEGIN(s) ((s) == str) ------------------ | Branch (5277:13): [True: 0, False: 0] ------------------ 5278| 0| prev = onigenc_get_prev_char_head(reg->enc, (pprev ? pprev : str), p); ------------------ | Branch (5278:56): [True: 0, False: 0] ------------------ 5279| 0| if (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) ------------------ | | 283| 0|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) ------------------ | Branch (5279:15): [True: 0, False: 0] ------------------ 5280| 0| goto retry_gate; 5281| 0| } 5282| 0| break; 5283| | 5284| 0| case ANCR_END_LINE: ------------------ | | 466| 0|#define ANCR_END_LINE (1<<9) ------------------ | Branch (5284:7): [True: 0, False: 0] ------------------ 5285| 0| if (ON_STR_END(p)) { ------------------ | | 2518| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (2518:32): [True: 0, False: 0] | | ------------------ ------------------ 5286| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 5287| | prev = (UChar* )onigenc_get_prev_char_head(reg->enc, 5288| | (pprev ? pprev : str), p); 5289| | if (prev && ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) 5290| | goto retry_gate; 5291| |#endif 5292| 0| } 5293| 0| else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end) ------------------ | | 283| 0|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) ------------------ | Branch (5293:18): [True: 0, False: 0] ------------------ 5294| |#ifdef USE_CRNL_AS_LINE_TERMINATOR 5295| | && ! ONIGENC_IS_MBC_CRNL(reg->enc, p, end) 5296| |#endif 5297| 0| ) 5298| 0| goto retry_gate; 5299| | 5300| 0| break; 5301| 0| } 5302| 0| } 5303| | 5304| 30.9k| if (reg->dist_max == 0) { ------------------ | Branch (5304:9): [True: 18.2k, False: 12.6k] ------------------ 5305| 18.2k| *low = p; 5306| 18.2k| *high = p; 5307| 18.2k| } 5308| 12.6k| else { 5309| 12.6k| if (reg->dist_max != INFINITE_LEN) { ------------------ | | 218| 12.6k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 12.6k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (5309:11): [True: 11.5k, False: 1.09k] ------------------ 5310| 11.5k| if (DIST_CAST(p - str) < reg->dist_max) { ------------------ | | 60| 11.5k|#define DIST_CAST(d) (d) ------------------ | Branch (5310:13): [True: 94, False: 11.4k] ------------------ 5311| 94| *low = (UChar* )str; 5312| 94| } 5313| 11.4k| else { 5314| 11.4k| *low = p - reg->dist_max; 5315| 11.4k| if (*low > start) { ------------------ | Branch (5315:15): [True: 2.14k, False: 9.31k] ------------------ 5316| 2.14k| *low = onigenc_get_right_adjust_char_head(reg->enc, start, *low); 5317| 2.14k| } 5318| 11.4k| } 5319| 11.5k| } 5320| | /* no needs to adjust *high, *high is used as range check only */ 5321| 12.6k| if (DIST_CAST(p - str) < reg->dist_min) ------------------ | | 60| 12.6k|#define DIST_CAST(d) (d) ------------------ | Branch (5321:11): [True: 0, False: 12.6k] ------------------ 5322| 0| *high = (UChar* )str; 5323| 12.6k| else 5324| 12.6k| *high = p - reg->dist_min; 5325| 12.6k| } 5326| | 5327| |#ifdef ONIG_DEBUG_SEARCH 5328| | fprintf(DBGFP, 5329| | "forward_search success: low: %d, high: %d, dmin: %u, dmax: %u\n", 5330| | (int )(*low - str), (int )(*high - str), 5331| | reg->dist_min, reg->dist_max); 5332| |#endif 5333| 30.9k| return 1; /* success */ 5334| 30.9k| } 5335| | 5336| 26.0k| return 0; /* fail */ 5337| 57.0k|} regexec.c:sunday_quick_search: 5080| 42.5k|{ 5081| 42.5k| const UChar *s, *t, *p, *end; 5082| 42.5k| const UChar *tail; 5083| 42.5k| int map_offset; 5084| 42.5k| ptrdiff_t target_len; 5085| | 5086| 42.5k| map_offset = reg->map_offset; 5087| 42.5k| tail = target_end - 1; 5088| 42.5k| target_len = target_end - target; 5089| | 5090| 42.5k| if (target_len > text_end - text_range) { ------------------ | Branch (5090:7): [True: 40.5k, False: 1.99k] ------------------ 5091| 40.5k| end = text_end; 5092| 40.5k| if (target_len > text_end - text) ------------------ | Branch (5092:9): [True: 5, False: 40.5k] ------------------ 5093| 5| return (UChar* )NULL; 5094| 40.5k| } 5095| 1.99k| else { 5096| 1.99k| end = text_range + target_len; 5097| 1.99k| } 5098| | 5099| 42.5k| s = text + target_len - 1; 5100| | 5101| 42.5k|#ifdef USE_STRICT_POINTER_ADDRESS 5102| 42.5k| if (s < end) { ------------------ | Branch (5102:7): [True: 42.5k, False: 0] ------------------ 5103| 10.3M| while (TRUE) { ------------------ | | 59| 10.3M|#define TRUE 1 | | ------------------ | | | Branch (59:17): [True: 10.3M, Folded] | | ------------------ ------------------ 5104| 10.3M| p = s; 5105| 10.3M| t = tail; 5106| 10.3M| while (*p == *t) { ------------------ | Branch (5106:14): [True: 20.5k, False: 10.3M] ------------------ 5107| 20.5k| if (t == target) return (UChar* )p; ------------------ | Branch (5107:13): [True: 18.6k, False: 1.93k] ------------------ 5108| 1.93k| p--; t--; 5109| 1.93k| } 5110| 10.3M| if (text_end - s <= map_offset) break; ------------------ | Branch (5110:11): [True: 16.2k, False: 10.3M] ------------------ 5111| 10.3M| if (reg->map[*(s + map_offset)] >= end - s) break; ------------------ | Branch (5111:11): [True: 7.66k, False: 10.2M] ------------------ 5112| 10.2M| s += reg->map[*(s + map_offset)]; 5113| 10.2M| } 5114| 42.5k| } 5115| |#else 5116| | while (s < end) { 5117| | p = s; 5118| | t = tail; 5119| | while (*p == *t) { 5120| | if (t == target) return (UChar* )p; 5121| | p--; t--; 5122| | } 5123| | if (text_end - s <= map_offset) break; 5124| | s += reg->map[*(s + map_offset)]; 5125| | } 5126| |#endif 5127| | 5128| 23.9k| return (UChar* )NULL; 5129| 42.5k|} regexec.c:map_search: 5134| 14.4k|{ 5135| 14.4k| const UChar *s = text; 5136| | 5137| 11.6M| while (s < text_range) { ------------------ | Branch (5137:10): [True: 11.6M, False: 1.78k] ------------------ 5138| 11.6M| if (map[*s]) return (UChar* )s; ------------------ | Branch (5138:9): [True: 12.6k, False: 11.6M] ------------------ 5139| | 5140| 11.6M| s += enclen(enc, s); ------------------ | | 83| 11.6M|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 11.6M|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5141| 11.6M| } 5142| 1.78k| return (UChar* )NULL; 5143| 14.4k|} regexec.c:search_in_range: 5470| 140k|{ 5471| 140k| int r; 5472| 140k| int forward; 5473| 140k| UChar *s; ------------------ | | 80| 140k|#define UChar OnigUChar ------------------ 5474| 140k| MatchArg msa; 5475| 140k| const UChar *orig_start = start; 5476| | 5477| |#ifdef ONIG_DEBUG_SEARCH 5478| | fprintf(DBGFP, 5479| | "onig_search (entry point): str: %p, end: %d, start: %d, range: %d\n", 5480| | str, (int )(end - str), (int )(start - str), (int )(range - str)); 5481| |#endif 5482| | 5483| 140k| ADJUST_MATCH_PARAM(reg, mp); ------------------ | | 1558| 140k| r = adjust_match_param(reg, mp);\ | | 1559| 140k| if (r != ONIG_NORMAL) return r; | | ------------------ | | | | 563| 140k|#define ONIG_NORMAL 0 | | ------------------ | | | Branch (1559:7): [True: 0, False: 140k] | | ------------------ ------------------ 5484| | 5485| 140k|#ifndef USE_POSIX_API 5486| 140k| if (OPTON_POSIX_REGION(option)) { ------------------ | | 418| 140k|#define OPTON_POSIX_REGION(option) ((option) & ONIG_OPTION_POSIX_REGION) | | ------------------ | | | | 389| 140k|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | ------------------ | | | | | | 388| 140k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | ------------------ | | | | | | | | 387| 140k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 385| 140k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 384| 140k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 383| 140k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 382| 140k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 381| 140k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 380| 140k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 379| 140k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 378| 140k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 140k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (418:38): [True: 0, False: 140k] | | ------------------ ------------------ 5487| 0| r = ONIGERR_INVALID_ARGUMENT; ------------------ | | 586| 0|#define ONIGERR_INVALID_ARGUMENT -30 ------------------ 5488| 0| goto finish_no_msa; 5489| 0| } 5490| 140k|#endif 5491| | 5492| 140k| if (region ------------------ | Branch (5492:7): [True: 140k, False: 0] ------------------ 5493| |#ifdef USE_POSIX_API 5494| | && ! OPTON_POSIX_REGION(option) 5495| |#endif 5496| 140k| ) { 5497| 140k| r = onig_region_resize_clear(region, reg->num_mem + 1); 5498| 140k| if (r != 0) goto finish_no_msa; ------------------ | Branch (5498:9): [True: 0, False: 140k] ------------------ 5499| 140k| } 5500| | 5501| 140k| if (start > end || start < str) goto mismatch_no_msa; ------------------ | Branch (5501:7): [True: 0, False: 140k] | Branch (5501:22): [True: 0, False: 140k] ------------------ 5502| | 5503| 140k| if (OPTON_CHECK_VALIDITY_OF_STRING(option)) { ------------------ | | 419| 140k|#define OPTON_CHECK_VALIDITY_OF_STRING(option) ((option) & \ | | ------------------ | | | Branch (419:49): [True: 0, False: 140k] | | ------------------ | | 420| 140k| ONIG_OPTION_CHECK_VALIDITY_OF_STRING) | | ------------------ | | | | 390| 140k|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | ------------------ | | | | | | 389| 140k|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | ------------------ | | | | | | | | 388| 140k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 387| 140k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 385| 140k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 384| 140k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 383| 140k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 382| 140k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 381| 140k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 380| 140k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 379| 140k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 140k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 140k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5504| 0| if (! ONIGENC_IS_VALID_MBC_STRING(reg->enc, str, end)) { ------------------ | | 271| 0| (enc)->is_valid_mbc_string(s,end) ------------------ | Branch (5504:9): [True: 0, False: 0] ------------------ 5505| 0| r = ONIGERR_INVALID_WIDE_CHAR_VALUE; ------------------ | | 645| 0|#define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 ------------------ 5506| 0| goto finish_no_msa; 5507| 0| } 5508| 0| } 5509| | 5510| | 5511| 140k|#define MATCH_AND_RETURN_CHECK(upper_range) \ 5512| 140k| r = match_at(reg, str, end, (upper_range), s, &msa);\ 5513| 140k| if (r != ONIG_MISMATCH) {\ 5514| 140k| if (r >= 0) {\ 5515| 140k| goto match;\ 5516| 140k| }\ 5517| 140k| else goto finish; /* error */ \ 5518| 140k| } 5519| | 5520| 140k| forward = (range > start); 5521| | 5522| | /* anchor optimize: resume search range */ 5523| 140k| if (reg->anchor != 0 && str < end) { ------------------ | Branch (5523:7): [True: 4.49k, False: 135k] | Branch (5523:27): [True: 3.65k, False: 840] ------------------ 5524| 3.65k| UChar *min_semi_end, *max_semi_end; ------------------ | | 80| 3.65k|#define UChar OnigUChar ------------------ 5525| | 5526| 3.65k| if (reg->anchor & ANCR_BEGIN_POSITION) { ------------------ | | 463| 3.65k|#define ANCR_BEGIN_POSITION (1<<6) ------------------ | Branch (5526:9): [True: 0, False: 3.65k] ------------------ 5527| | /* search start-position only */ 5528| 0| begin_position: 5529| 0| if (range > start) ------------------ | Branch (5529:11): [True: 0, False: 0] ------------------ 5530| 0| range = start + 1; 5531| 0| else 5532| 0| range = start; 5533| 0| } 5534| 3.65k| else if (reg->anchor & ANCR_BEGIN_BUF) { ------------------ | | 461| 3.65k|#define ANCR_BEGIN_BUF (1<<4) ------------------ | Branch (5534:14): [True: 2.34k, False: 1.31k] ------------------ 5535| | /* search str-position only */ 5536| 2.34k| if (range > start) { ------------------ | Branch (5536:11): [True: 2.28k, False: 60] ------------------ 5537| 2.28k| if (start != str) goto mismatch_no_msa; ------------------ | Branch (5537:13): [True: 61, False: 2.22k] ------------------ 5538| 2.22k| range = str + 1; 5539| 2.22k| } 5540| 60| else { 5541| 60| if (range <= str) { ------------------ | Branch (5541:13): [True: 0, False: 60] ------------------ 5542| 0| start = str; 5543| 0| range = str; 5544| 0| } 5545| 60| else 5546| 60| goto mismatch_no_msa; 5547| 60| } 5548| 2.34k| } 5549| 1.31k| else if (reg->anchor & ANCR_END_BUF) { ------------------ | | 464| 1.31k|#define ANCR_END_BUF (1<<7) ------------------ | Branch (5549:14): [True: 0, False: 1.31k] ------------------ 5550| 0| min_semi_end = max_semi_end = (UChar* )end; 5551| | 5552| 40| end_buf: 5553| 40| if ((OnigLen )(max_semi_end - str) < reg->anc_dist_min) ------------------ | Branch (5553:11): [True: 0, False: 40] ------------------ 5554| 0| goto mismatch_no_msa; 5555| | 5556| 40| if (range > start) { ------------------ | Branch (5556:11): [True: 40, False: 0] ------------------ 5557| 40| if (reg->anc_dist_max != INFINITE_LEN && ------------------ | | 218| 40|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 80|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (5557:13): [True: 40, False: 0] ------------------ 5558| 40| DIST_CAST(min_semi_end - start) > reg->anc_dist_max) { ------------------ | | 60| 40|#define DIST_CAST(d) (d) ------------------ | Branch (5558:13): [True: 40, False: 0] ------------------ 5559| 40| start = min_semi_end - reg->anc_dist_max; 5560| 40| if (start < end) ------------------ | Branch (5560:15): [True: 5, False: 35] ------------------ 5561| 5| start = onigenc_get_right_adjust_char_head(reg->enc, str, start); 5562| 40| } 5563| 40| if (DIST_CAST(max_semi_end - (range - 1)) < reg->anc_dist_min) { ------------------ | | 60| 40|#define DIST_CAST(d) (d) ------------------ | Branch (5563:13): [True: 0, False: 40] ------------------ 5564| 0| if (DIST_CAST(max_semi_end - str + 1) < reg->anc_dist_min) ------------------ | | 60| 0|#define DIST_CAST(d) (d) ------------------ | Branch (5564:15): [True: 0, False: 0] ------------------ 5565| 0| goto mismatch_no_msa; 5566| 0| else 5567| 0| range = max_semi_end - reg->anc_dist_min + 1; 5568| 0| } 5569| | 5570| 40| if (start > range) goto mismatch_no_msa; ------------------ | Branch (5570:13): [True: 0, False: 40] ------------------ 5571| | /* If start == range, match with empty at end. 5572| | Backward search is used. */ 5573| 40| } 5574| 0| else { 5575| 0| if (reg->anc_dist_max != INFINITE_LEN && ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (5575:13): [True: 0, False: 0] ------------------ 5576| 0| DIST_CAST(min_semi_end - range) > reg->anc_dist_max) { ------------------ | | 60| 0|#define DIST_CAST(d) (d) ------------------ | Branch (5576:13): [True: 0, False: 0] ------------------ 5577| 0| range = min_semi_end - reg->anc_dist_max; 5578| 0| } 5579| 0| if (DIST_CAST(max_semi_end - start) < reg->anc_dist_min) { ------------------ | | 60| 0|#define DIST_CAST(d) (d) ------------------ | Branch (5579:13): [True: 0, False: 0] ------------------ 5580| 0| if (DIST_CAST(max_semi_end - str) < reg->anc_dist_min) ------------------ | | 60| 0|#define DIST_CAST(d) (d) ------------------ | Branch (5580:15): [True: 0, False: 0] ------------------ 5581| 0| goto mismatch_no_msa; 5582| 0| else { 5583| 0| start = max_semi_end - reg->anc_dist_min; 5584| 0| start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start); ------------------ | | 269| 0| (enc)->left_adjust_char_head(start, s) ------------------ 5585| 0| } 5586| 0| } 5587| 0| if (range > start) goto mismatch_no_msa; ------------------ | Branch (5587:13): [True: 0, False: 0] ------------------ 5588| 0| } 5589| 40| } 5590| 1.31k| else if (reg->anchor & ANCR_SEMI_END_BUF) { ------------------ | | 465| 1.31k|#define ANCR_SEMI_END_BUF (1<<8) ------------------ | Branch (5590:14): [True: 47, False: 1.26k] ------------------ 5591| 47| UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, 1); ------------------ | | 80| 47|#define UChar OnigUChar ------------------ UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, 1); ------------------ | | 277| 47| onigenc_step_back((enc),(start),(s),(n)) ------------------ 5592| | 5593| 47| max_semi_end = (UChar* )end; 5594| 47| if (ONIGENC_IS_MBC_NEWLINE(reg->enc, pre_end, end)) { ------------------ | | 283| 47|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) | | ------------------ | | | Branch (283:48): [True: 12, False: 35] | | ------------------ ------------------ 5595| 12| min_semi_end = pre_end; 5596| | 5597| |#ifdef USE_CRNL_AS_LINE_TERMINATOR 5598| | pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, 1); 5599| | if (IS_NOT_NULL(pre_end) && 5600| | ONIGENC_IS_MBC_CRNL(reg->enc, pre_end, end)) { 5601| | min_semi_end = pre_end; 5602| | } 5603| |#endif 5604| 12| if (min_semi_end > str && start <= min_semi_end) { ------------------ | Branch (5604:13): [True: 10, False: 2] | Branch (5604:35): [True: 5, False: 5] ------------------ 5605| 5| goto end_buf; 5606| 5| } 5607| 12| } 5608| 35| else { 5609| 35| min_semi_end = (UChar* )end; 5610| 35| goto end_buf; 5611| 35| } 5612| 47| } 5613| 1.26k| else if ((reg->anchor & ANCR_ANYCHAR_INF_ML) && range > start) { ------------------ | | 472| 1.26k|#define ANCR_ANYCHAR_INF_ML (1<<15) ------------------ | Branch (5613:14): [True: 0, False: 1.26k] | Branch (5613:53): [True: 0, False: 0] ------------------ 5614| 0| goto begin_position; 5615| 0| } 5616| 3.65k| } 5617| 136k| else if (str == end) { /* empty string */ ------------------ | Branch (5617:12): [True: 13.5k, False: 122k] ------------------ 5618| 13.5k| static const UChar* address_for_empty_string = (UChar* )""; 5619| | 5620| |#ifdef ONIG_DEBUG_SEARCH 5621| | fprintf(DBGFP, "onig_search: empty string.\n"); 5622| |#endif 5623| | 5624| 13.5k| if (reg->threshold_len == 0) { ------------------ | Branch (5624:9): [True: 11, False: 13.5k] ------------------ 5625| 11| start = end = str = address_for_empty_string; 5626| 11| s = (UChar* )start; 5627| | 5628| 11| MATCH_ARG_INIT(msa, reg, option, region, start, mp); ------------------ | | 1268| 11|#define MATCH_ARG_INIT(msa, reg, arg_option, arg_region, arg_start, mpv) do { \ | | 1269| 11| (msa).stack_p = (void* )0;\ | | 1270| 11| (msa).options = (arg_option)|(reg)->options;\ | | 1271| 11| (msa).region = (arg_region);\ | | 1272| 11| (msa).start = (arg_start);\ | | 1273| 11| (msa).match_stack_limit = (mpv)->match_stack_limit;\ | | 1274| 11| RETRY_IN_MATCH_ARG_INIT(msa,mpv)\ | | ------------------ | | | | 1249| 11| (msa).retry_limit_in_match = (mpv)->retry_limit_in_match;\ | | | | 1250| 11| (msa).retry_limit_in_search = (mpv)->retry_limit_in_search;\ | | | | 1251| 11| (msa).retry_limit_in_search_counter = 0; | | ------------------ | | 1275| 11| SUBEXP_CALL_IN_MATCH_ARG_INIT(msa,mpv)\ | | ------------------ | | | | 1258| 11| (msa).subexp_call_in_search_counter = 0; | | ------------------ | | 1276| 11| (msa).mp = mpv;\ | | 1277| 11| (msa).best_len = ONIG_MISMATCH;\ | | ------------------ | | | | 565| 11|#define ONIG_MISMATCH -1 | | ------------------ | | 1278| 11| (msa).ptr_num = PTR_NUM_SIZE(reg);\ | | ------------------ | | | | 1231| 11|#define PTR_NUM_SIZE(reg) (((reg)->num_mem + 1) * 2) | | ------------------ | | 1279| 11| (msa).skip_search = (UChar* )(arg_start);\ | | 1280| 11|} while(0) | | ------------------ | | | Branch (1280:9): [Folded, False: 11] | | ------------------ ------------------ 5629| 11| MATCH_AND_RETURN_CHECK(end); ------------------ | | 5512| 11| r = match_at(reg, str, end, (upper_range), s, &msa);\ | | 5513| 11| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 565| 11|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (5513:7): [True: 7, False: 4] | | ------------------ | | 5514| 7| if (r >= 0) {\ | | ------------------ | | | Branch (5514:9): [True: 7, False: 0] | | ------------------ | | 5515| 7| goto match;\ | | 5516| 7| }\ | | 5517| 7| else goto finish; /* error */ \ | | 5518| 7| } ------------------ 5630| 4| goto mismatch; 5631| 11| } 5632| 13.5k| goto mismatch_no_msa; 5633| 13.5k| } 5634| | 5635| |#ifdef ONIG_DEBUG_SEARCH 5636| | fprintf(DBGFP, "onig_search(apply anchor): end: %d, start: %d, range: %d\n", 5637| | (int )(end - str), (int )(start - str), (int )(range - str)); 5638| |#endif 5639| | 5640| 126k| MATCH_ARG_INIT(msa, reg, option, region, orig_start, mp); ------------------ | | 1268| 126k|#define MATCH_ARG_INIT(msa, reg, arg_option, arg_region, arg_start, mpv) do { \ | | 1269| 126k| (msa).stack_p = (void* )0;\ | | 1270| 126k| (msa).options = (arg_option)|(reg)->options;\ | | 1271| 126k| (msa).region = (arg_region);\ | | 1272| 126k| (msa).start = (arg_start);\ | | 1273| 126k| (msa).match_stack_limit = (mpv)->match_stack_limit;\ | | 1274| 126k| RETRY_IN_MATCH_ARG_INIT(msa,mpv)\ | | ------------------ | | | | 1249| 126k| (msa).retry_limit_in_match = (mpv)->retry_limit_in_match;\ | | | | 1250| 126k| (msa).retry_limit_in_search = (mpv)->retry_limit_in_search;\ | | | | 1251| 126k| (msa).retry_limit_in_search_counter = 0; | | ------------------ | | 1275| 126k| SUBEXP_CALL_IN_MATCH_ARG_INIT(msa,mpv)\ | | ------------------ | | | | 1258| 126k| (msa).subexp_call_in_search_counter = 0; | | ------------------ | | 1276| 126k| (msa).mp = mpv;\ | | 1277| 126k| (msa).best_len = ONIG_MISMATCH;\ | | ------------------ | | | | 565| 126k|#define ONIG_MISMATCH -1 | | ------------------ | | 1278| 126k| (msa).ptr_num = PTR_NUM_SIZE(reg);\ | | ------------------ | | | | 1231| 126k|#define PTR_NUM_SIZE(reg) (((reg)->num_mem + 1) * 2) | | ------------------ | | 1279| 126k| (msa).skip_search = (UChar* )(arg_start);\ | | 1280| 126k|} while(0) | | ------------------ | | | Branch (1280:9): [Folded, False: 126k] | | ------------------ ------------------ 5641| | 5642| 126k| s = (UChar* )start; 5643| 126k| if (forward != 0) { /* forward search */ ------------------ | Branch (5643:7): [True: 124k, False: 2.11k] ------------------ 5644| 124k| if (reg->optimize != OPTIMIZE_NONE) { ------------------ | Branch (5644:9): [True: 55.3k, False: 68.8k] ------------------ 5645| 55.3k| UChar *sch_range, *low, *high; ------------------ | | 80| 55.3k|#define UChar OnigUChar ------------------ 5646| | 5647| 55.3k| if (reg->dist_max != 0) { ------------------ | Branch (5647:11): [True: 11.8k, False: 43.5k] ------------------ 5648| 11.8k| if (reg->dist_max == INFINITE_LEN) ------------------ | | 218| 11.8k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 11.8k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (5648:13): [True: 1.12k, False: 10.7k] ------------------ 5649| 1.12k| sch_range = (UChar* )end; 5650| 10.7k| else { 5651| 10.7k| if (DIST_CAST(end - range) < reg->dist_max) ------------------ | | 60| 10.7k|#define DIST_CAST(d) (d) ------------------ | Branch (5651:15): [True: 10.7k, False: 0] ------------------ 5652| 10.7k| sch_range = (UChar* )end; 5653| 0| else { 5654| 0| sch_range = (UChar* )range + reg->dist_max; 5655| 0| } 5656| 10.7k| } 5657| 11.8k| } 5658| 43.5k| else 5659| 43.5k| sch_range = (UChar* )range; 5660| | 5661| 55.3k| if ((end - start) < reg->threshold_len) ------------------ | Branch (5661:11): [True: 456, False: 54.9k] ------------------ 5662| 456| goto mismatch; 5663| | 5664| 54.9k| if (reg->dist_max != INFINITE_LEN) { ------------------ | | 218| 54.9k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 54.9k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (5664:11): [True: 53.7k, False: 1.12k] ------------------ 5665| 55.9k| do { 5666| 55.9k| if (! forward_search(reg, str, end, s, sch_range, &low, &high)) ------------------ | Branch (5666:15): [True: 26.0k, False: 29.8k] ------------------ 5667| 26.0k| goto mismatch; 5668| 29.8k| if (s < low) { ------------------ | Branch (5668:15): [True: 14.5k, False: 15.3k] ------------------ 5669| 14.5k| s = low; 5670| 14.5k| } 5671| 33.5k| while (s <= high) { ------------------ | Branch (5671:18): [True: 31.4k, False: 2.14k] ------------------ 5672| 31.4k| MATCH_AND_RETURN_CHECK(data_range); ------------------ | | 5512| 31.4k| r = match_at(reg, str, end, (upper_range), s, &msa);\ | | 5513| 31.4k| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 565| 31.4k|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (5513:7): [True: 27.6k, False: 3.71k] | | ------------------ | | 5514| 27.6k| if (r >= 0) {\ | | ------------------ | | | Branch (5514:9): [True: 27.6k, False: 0] | | ------------------ | | 5515| 27.6k| goto match;\ | | 5516| 27.6k| }\ | | 5517| 27.6k| else goto finish; /* error */ \ | | 5518| 27.6k| } ------------------ 5673| 3.71k| s += enclen(reg->enc, s); ------------------ | | 83| 3.71k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 3.71k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5674| 3.71k|#ifdef USE_SKIP_SEARCH 5675| 3.71k| if (s < msa.skip_search) s = msa.skip_search; ------------------ | Branch (5675:17): [True: 0, False: 3.71k] ------------------ 5676| 3.71k|#endif 5677| 3.71k| } 5678| 29.8k| } while (s < range); ------------------ | Branch (5678:18): [True: 2.12k, False: 20] ------------------ 5679| 20| goto mismatch; 5680| 53.7k| } 5681| 1.12k| else { /* check only. */ 5682| 1.12k| if (! forward_search(reg, str, end, s, sch_range, &low, &high)) ------------------ | Branch (5682:13): [True: 29, False: 1.09k] ------------------ 5683| 29| goto mismatch; 5684| | 5685| 1.09k| if ((reg->anchor & ANCR_ANYCHAR_INF) != 0 && ------------------ | | 471| 1.09k|#define ANCR_ANYCHAR_INF (1<<14) ------------------ | Branch (5685:13): [True: 80, False: 1.01k] ------------------ 5686| 80| (reg->anchor & (ANCR_LOOK_BEHIND | ANCR_PREC_READ_NOT)) == 0) { ------------------ | | 458| 80|#define ANCR_LOOK_BEHIND (1<<2) ------------------ (reg->anchor & (ANCR_LOOK_BEHIND | ANCR_PREC_READ_NOT)) == 0) { ------------------ | | 457| 80|#define ANCR_PREC_READ_NOT (1<<1) ------------------ | Branch (5686:13): [True: 80, False: 0] ------------------ 5687| 82| while (s < range) { ------------------ | Branch (5687:18): [True: 80, False: 2] ------------------ 5688| 80| UChar* prev; ------------------ | | 80| 80|#define UChar OnigUChar ------------------ 5689| | 5690| 80| MATCH_AND_RETURN_CHECK(data_range); ------------------ | | 5512| 80| r = match_at(reg, str, end, (upper_range), s, &msa);\ | | 5513| 80| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 565| 80|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (5513:7): [True: 78, False: 2] | | ------------------ | | 5514| 78| if (r >= 0) {\ | | ------------------ | | | Branch (5514:9): [True: 78, False: 0] | | ------------------ | | 5515| 78| goto match;\ | | 5516| 78| }\ | | 5517| 78| else goto finish; /* error */ \ | | 5518| 78| } ------------------ 5691| 2| prev = s; 5692| 2| s += enclen(reg->enc, s); ------------------ | | 83| 2|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 2|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5693| | 5694| 2|#ifdef USE_SKIP_SEARCH 5695| 2| if (s < msa.skip_search) s = msa.skip_search; ------------------ | Branch (5695:17): [True: 0, False: 2] ------------------ 5696| 2| else { 5697| 2|#endif 5698| 2| while (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end) && ------------------ | | 283| 4|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end)) ------------------ | Branch (5698:22): [True: 1, False: 1] ------------------ 5699| 1| s < range) { ------------------ | Branch (5699:22): [True: 0, False: 1] ------------------ 5700| 0| prev = s; 5701| 0| s += enclen(reg->enc, s); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5702| 0| } 5703| 2|#ifdef USE_SKIP_SEARCH 5704| 2| } 5705| 2|#endif 5706| 2| } 5707| 2| goto mismatch; 5708| 80| } 5709| 1.09k| } 5710| 54.9k| } 5711| | 5712| 94.7k| while (1 == 1) { ------------------ | Branch (5712:12): [True: 94.7k, Folded] ------------------ 5713| 94.7k| MATCH_AND_RETURN_CHECK(data_range); ------------------ | | 5512| 94.7k| r = match_at(reg, str, end, (upper_range), s, &msa);\ | | 5513| 94.7k| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 565| 94.7k|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (5513:7): [True: 69.8k, False: 24.9k] | | ------------------ | | 5514| 69.8k| if (r >= 0) {\ | | ------------------ | | | Branch (5514:9): [True: 69.8k, False: 0] | | ------------------ | | 5515| 69.8k| goto match;\ | | 5516| 69.8k| }\ | | 5517| 69.8k| else goto finish; /* error */ \ | | 5518| 69.8k| } ------------------ 5714| 24.9k| if (s >= range) break; ------------------ | Branch (5714:11): [True: 41, False: 24.9k] ------------------ 5715| 24.9k| s += enclen(reg->enc, s); ------------------ | | 83| 24.9k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 24.9k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5716| | 5717| 24.9k|#ifdef USE_SKIP_SEARCH 5718| 24.9k| if (s < msa.skip_search) { ------------------ | Branch (5718:11): [True: 0, False: 24.9k] ------------------ 5719| 0| s = msa.skip_search; 5720| 0| if (s > range) break; ------------------ | Branch (5720:13): [True: 0, False: 0] ------------------ 5721| 0| } 5722| 24.9k|#endif 5723| 24.9k| } 5724| 69.8k| } 5725| 2.11k| else { /* backward search */ 5726| 2.11k| if (range < str) goto mismatch; ------------------ | Branch (5726:9): [True: 0, False: 2.11k] ------------------ 5727| | 5728| 2.11k| if (orig_start < end) ------------------ | Branch (5728:9): [True: 0, False: 2.11k] ------------------ 5729| 0| orig_start += enclen(reg->enc, orig_start); /* is upper range */ ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 5730| | 5731| 2.11k| if (reg->optimize != OPTIMIZE_NONE) { ------------------ | Branch (5731:9): [True: 1.67k, False: 436] ------------------ 5732| 1.67k| UChar *low, *high, *adjrange, *sch_start; ------------------ | | 80| 1.67k|#define UChar OnigUChar ------------------ 5733| 1.67k| const UChar *min_range; 5734| | 5735| 1.67k| if ((end - range) < reg->threshold_len) goto mismatch; ------------------ | Branch (5735:11): [True: 1.67k, False: 0] ------------------ 5736| | 5737| 0| if (range < end) ------------------ | Branch (5737:11): [True: 0, False: 0] ------------------ 5738| 0| adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range); ------------------ | | 269| 0| (enc)->left_adjust_char_head(start, s) ------------------ 5739| 0| else 5740| 0| adjrange = (UChar* )end; 5741| | 5742| 0| if (DIST_CAST(end - range) > reg->dist_min) ------------------ | | 60| 0|#define DIST_CAST(d) (d) ------------------ | Branch (5742:11): [True: 0, False: 0] ------------------ 5743| 0| min_range = range + reg->dist_min; 5744| 0| else 5745| 0| min_range = end; 5746| | 5747| 0| if (reg->dist_max != INFINITE_LEN) { ------------------ | | 218| 0|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 0|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ | Branch (5747:11): [True: 0, False: 0] ------------------ 5748| 0| do { 5749| 0| if (DIST_CAST(end - s) > reg->dist_max) ------------------ | | 60| 0|#define DIST_CAST(d) (d) ------------------ | Branch (5749:15): [True: 0, False: 0] ------------------ 5750| 0| sch_start = s + reg->dist_max; 5751| 0| else { 5752| 0| sch_start = onigenc_get_prev_char_head(reg->enc, str, end); 5753| 0| } 5754| | 5755| 0| if (backward_search(reg, str, end, sch_start, min_range, adjrange, ------------------ | Branch (5755:15): [True: 0, False: 0] ------------------ 5756| 0| &low, &high) <= 0) 5757| 0| goto mismatch; 5758| | 5759| 0| if (s > high) ------------------ | Branch (5759:15): [True: 0, False: 0] ------------------ 5760| 0| s = high; 5761| | 5762| 0| while (PTR_GE(s, low)) { ------------------ | | 208| 0|#define PTR_GE(p,q) ((p) != NULL && (p) >= (q)) | | ------------------ | | | Branch (208:24): [True: 0, False: 0] | | | Branch (208:39): [True: 0, False: 0] | | ------------------ ------------------ 5763| 0| MATCH_AND_RETURN_CHECK(orig_start); ------------------ | | 5512| 0| r = match_at(reg, str, end, (upper_range), s, &msa);\ | | 5513| 0| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 565| 0|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (5513:7): [True: 0, False: 0] | | ------------------ | | 5514| 0| if (r >= 0) {\ | | ------------------ | | | Branch (5514:9): [True: 0, False: 0] | | ------------------ | | 5515| 0| goto match;\ | | 5516| 0| }\ | | 5517| 0| else goto finish; /* error */ \ | | 5518| 0| } ------------------ 5764| 0| s = onigenc_get_prev_char_head(reg->enc, str, s); 5765| 0| } 5766| 0| } while (PTR_GE(s, range)); ------------------ | | 208| 0|#define PTR_GE(p,q) ((p) != NULL && (p) >= (q)) | | ------------------ | | | Branch (208:24): [True: 0, False: 0] | | | Branch (208:39): [True: 0, False: 0] | | ------------------ ------------------ 5767| 0| goto mismatch; 5768| 0| } 5769| 0| else { /* check only. */ 5770| 0| sch_start = onigenc_get_prev_char_head(reg->enc, str, end); 5771| | 5772| 0| if (backward_search(reg, str, end, sch_start, min_range, adjrange, ------------------ | Branch (5772:13): [True: 0, False: 0] ------------------ 5773| 0| &low, &high) <= 0) goto mismatch; 5774| 0| } 5775| 0| } 5776| | 5777| 436| do { 5778| 436| MATCH_AND_RETURN_CHECK(orig_start); ------------------ | | 5512| 436| r = match_at(reg, str, end, (upper_range), s, &msa);\ | | 5513| 436| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 565| 436|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (5513:7): [True: 204, False: 232] | | ------------------ | | 5514| 204| if (r >= 0) {\ | | ------------------ | | | Branch (5514:9): [True: 204, False: 0] | | ------------------ | | 5515| 204| goto match;\ | | 5516| 204| }\ | | 5517| 204| else goto finish; /* error */ \ | | 5518| 204| } ------------------ 5779| 232| s = onigenc_get_prev_char_head(reg->enc, str, s); 5780| 232| } while (PTR_GE(s, range)); ------------------ | | 208| 232|#define PTR_GE(p,q) ((p) != NULL && (p) >= (q)) | | ------------------ | | | Branch (208:24): [True: 232, False: 0] | | | Branch (208:39): [True: 0, False: 232] | | ------------------ ------------------ 5781| 436| } 5782| | 5783| 28.5k| mismatch: 5784| 28.5k|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 5785| 28.5k| if (OPTON_FIND_LONGEST(reg->options)) { ------------------ | | 409| 28.5k|#define OPTON_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 381| 28.5k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 380| 28.5k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 379| 28.5k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 378| 28.5k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 377| 28.5k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:38): [True: 0, False: 28.5k] | | ------------------ ------------------ 5786| 0| if (msa.best_len >= 0) { ------------------ | Branch (5786:9): [True: 0, False: 0] ------------------ 5787| 0| s = msa.best_s; 5788| 0| goto match; 5789| 0| } 5790| 0| } 5791| 28.5k|#endif 5792| 28.5k| r = ONIG_MISMATCH; ------------------ | | 565| 28.5k|#define ONIG_MISMATCH -1 ------------------ 5793| | 5794| 28.5k| finish: 5795| 28.5k| MATCH_ARG_FREE(msa); ------------------ | | 1324| 28.5k|#define MATCH_ARG_FREE(msa) if ((msa).stack_p) xfree((msa).stack_p) | | ------------------ | | | | 230| 341|#define xfree free | | ------------------ | | | Branch (1324:34): [True: 341, False: 28.1k] | | ------------------ ------------------ 5796| | 5797| | /* If result is mismatch and no FIND_NOT_EMPTY option, 5798| | then the region is not set in match_at(). */ 5799| 28.5k| if (OPTON_FIND_NOT_EMPTY(reg->options) && region ------------------ | | 410| 57.0k|#define OPTON_FIND_NOT_EMPTY(option) ((option) & ONIG_OPTION_FIND_NOT_EMPTY) | | ------------------ | | | | 382| 28.5k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 381| 28.5k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 380| 28.5k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 379| 28.5k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 378| 28.5k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 377| 28.5k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (410:38): [True: 46, False: 28.4k] | | ------------------ ------------------ | Branch (5799:45): [True: 46, False: 0] ------------------ 5800| |#ifdef USE_POSIX_API 5801| | && !OPTON_POSIX_REGION(option) 5802| |#endif 5803| 28.5k| ) { 5804| 46| onig_region_clear(region); 5805| 46| } 5806| | 5807| |#ifdef ONIG_DEBUG 5808| | if (r != ONIG_MISMATCH) 5809| | fprintf(DBGFP, "onig_search: error %d\n", r); 5810| |#endif 5811| 28.5k| return r; 5812| | 5813| 13.6k| mismatch_no_msa: 5814| 13.6k| r = ONIG_MISMATCH; ------------------ | | 565| 13.6k|#define ONIG_MISMATCH -1 ------------------ 5815| 13.6k| finish_no_msa: 5816| |#ifdef ONIG_DEBUG 5817| | if (r != ONIG_MISMATCH) 5818| | fprintf(DBGFP, "onig_search: error %d\n", r); 5819| |#endif 5820| 13.6k| return r; 5821| | 5822| 97.8k| match: 5823| 97.8k| MATCH_ARG_FREE(msa); ------------------ | | 1324| 97.8k|#define MATCH_ARG_FREE(msa) if ((msa).stack_p) xfree((msa).stack_p) | | ------------------ | | | | 230| 97.8k|#define xfree free | | ------------------ | | | Branch (1324:34): [True: 97.8k, False: 0] | | ------------------ ------------------ 5824| 97.8k| return (int )(s - str); 5825| 13.6k|} onig_warning: 275| 1|{ 276| 1| if (onig_warn == onig_null_warn) return ; ------------------ | Branch (276:7): [True: 1, False: 0] ------------------ 277| | 278| 0| (*onig_warn)(s); 279| 0|} onig_strcpy: 475| 128k|{ 476| 128k| int len = (int )(end - src); 477| 128k| if (len > 0) { ------------------ | Branch (477:7): [True: 128k, False: 0] ------------------ 478| 128k| xmemcpy(dest, src, len); ------------------ | | 181| 128k|#define xmemcpy memcpy ------------------ 479| 128k| dest[len] = (UChar )0; 480| 128k| } 481| 128k|} onig_st_init_strend_table_with_size: 590| 503|{ 591| 503| static struct st_hash_type hashType = { 592| 503| str_end_cmp, 593| 503| str_end_hash, 594| 503| }; 595| | 596| 503| return (hash_table_type )onig_st_init_table_with_size(&hashType, size); 597| 503|} onig_st_lookup_strend: 602| 162|{ 603| 162| st_str_end_key key; 604| | 605| 162| key.s = (UChar* )str_key; 606| 162| key.end = (UChar* )end_key; 607| | 608| 162| return onig_st_lookup(table, (st_data_t )(&key), value); 609| 162|} onig_st_insert_strend: 614| 665|{ 615| 665| st_str_end_key* key; 616| 665| int result; 617| | 618| 665| key = (st_str_end_key* )xmalloc(sizeof(st_str_end_key)); ------------------ | | 227| 665|#define xmalloc malloc ------------------ 619| 665| CHECK_NULL_RETURN_MEMERR(key); ------------------ | | 204| 665|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 665|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 665] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 620| | 621| 665| key->s = (UChar* )str_key; 622| 665| key->end = (UChar* )end_key; 623| 665| result = onig_st_insert(table, (st_data_t )key, value); 624| 665| if (result) { ------------------ | Branch (624:7): [True: 0, False: 665] ------------------ 625| 0| xfree(key); ------------------ | | 230| 0|#define xfree free ------------------ 626| 0| } 627| 665| return result; 628| 665|} onig_st_init_callout_name_table_with_size: 683| 1|{ 684| 1| static struct st_hash_type hashType = { 685| 1| callout_name_table_cmp, 686| 1| callout_name_table_hash, 687| 1| }; 688| | 689| 1| return (hash_table_type )onig_st_init_table_with_size(&hashType, size); 690| 1|} onig_st_lookup_callout_name_table: 699| 7|{ 700| 7| st_callout_name_key key; 701| | 702| 7| key.enc = enc; 703| 7| key.type = type; 704| 7| key.s = (UChar* )str_key; 705| 7| key.end = (UChar* )end_key; 706| | 707| 7| return onig_st_lookup(table, (st_data_t )(&key), value); 708| 7|} onig_names_free: 827| 46.9k|{ 828| 46.9k| int r; 829| 46.9k| NameTable* t; 830| | 831| 46.9k| r = names_clear(reg); 832| 46.9k| if (r != 0) return r; ------------------ | Branch (832:7): [True: 0, False: 46.9k] ------------------ 833| | 834| 46.9k| t = (NameTable* )reg->name_table; 835| 46.9k| if (IS_NOT_NULL(t)) onig_st_free_table(t); ------------------ | | 202| 46.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 503, False: 46.4k] | | ------------------ ------------------ 836| | reg->name_table = (void* )NULL; 837| 46.9k| return 0; 838| 46.9k|} onig_foreach_name: 885| 97.7k|{ 886| 97.7k| INamesArg narg; 887| 97.7k| NameTable* t = (NameTable* )reg->name_table; 888| | 889| 97.7k| narg.ret = 0; 890| 97.7k| if (IS_NOT_NULL(t)) { ------------------ | | 202| 97.7k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 33.6k, False: 64.1k] | | ------------------ ------------------ 891| 33.6k| narg.func = func; 892| 33.6k| narg.reg = reg; 893| 33.6k| narg.arg = arg; 894| 33.6k| narg.enc = reg->enc; /* should be pattern encoding. */ 895| 33.6k| onig_st_foreach(t, i_names, (HashDataType )&narg); 896| 33.6k| } 897| 97.7k| return narg.ret; 898| 97.7k|} onig_set_callout_of_name: 1664| 8|{ 1665| 8| int r; 1666| 8| int i; 1667| 8| int j; 1668| 8| int id; 1669| 8| int is_not_single; 1670| 8| CalloutNameEntry* e; 1671| 8| CalloutNameListEntry* fe; 1672| | 1673| 8| if (callout_type != ONIG_CALLOUT_TYPE_SINGLE) ------------------ | Branch (1673:7): [True: 0, False: 8] ------------------ 1674| 0| return ONIGERR_INVALID_ARGUMENT; ------------------ | | 586| 0|#define ONIGERR_INVALID_ARGUMENT -30 ------------------ 1675| | 1676| 8| if (arg_num < 0 || arg_num > ONIG_CALLOUT_MAX_ARGS_NUM) ------------------ | | 763| 8|#define ONIG_CALLOUT_MAX_ARGS_NUM 4 ------------------ | Branch (1676:7): [True: 0, False: 8] | Branch (1676:22): [True: 0, False: 8] ------------------ 1677| 0| return ONIGERR_INVALID_CALLOUT_ARG; ------------------ | | 643| 0|#define ONIGERR_INVALID_CALLOUT_ARG -232 ------------------ 1678| | 1679| 8| if (opt_arg_num < 0 || opt_arg_num > arg_num) ------------------ | Branch (1679:7): [True: 0, False: 8] | Branch (1679:26): [True: 0, False: 8] ------------------ 1680| 0| return ONIGERR_INVALID_CALLOUT_ARG; ------------------ | | 643| 0|#define ONIGERR_INVALID_CALLOUT_ARG -232 ------------------ 1681| | 1682| 8| if (start_func == 0 && end_func == 0) ------------------ | Branch (1682:7): [True: 0, False: 8] | Branch (1682:26): [True: 0, False: 0] ------------------ 1683| 0| return ONIGERR_INVALID_CALLOUT_ARG; ------------------ | | 643| 0|#define ONIGERR_INVALID_CALLOUT_ARG -232 ------------------ 1684| | 1685| 8| if ((in & ONIG_CALLOUT_IN_PROGRESS) == 0 && (in & ONIG_CALLOUT_IN_RETRACTION) == 0) ------------------ | Branch (1685:7): [True: 0, False: 8] | Branch (1685:47): [True: 0, False: 0] ------------------ 1686| 0| return ONIGERR_INVALID_CALLOUT_ARG; ------------------ | | 643| 0|#define ONIGERR_INVALID_CALLOUT_ARG -232 ------------------ 1687| | 1688| 16| for (i = 0; i < arg_num; i++) { ------------------ | Branch (1688:15): [True: 8, False: 8] ------------------ 1689| 8| unsigned int t = arg_types[i]; 1690| 8| if (t == ONIG_TYPE_VOID) ------------------ | Branch (1690:9): [True: 0, False: 8] ------------------ 1691| 0| return ONIGERR_INVALID_CALLOUT_ARG; ------------------ | | 643| 0|#define ONIGERR_INVALID_CALLOUT_ARG -232 ------------------ 1692| 8| else { 1693| 8| if (i >= arg_num - opt_arg_num) { ------------------ | Branch (1693:11): [True: 4, False: 4] ------------------ 1694| 4| if (t != ONIG_TYPE_LONG && t != ONIG_TYPE_CHAR && t != ONIG_TYPE_STRING && ------------------ | Branch (1694:13): [True: 3, False: 1] | Branch (1694:36): [True: 0, False: 3] | Branch (1694:59): [True: 0, False: 0] ------------------ 1695| 0| t != ONIG_TYPE_TAG) ------------------ | Branch (1695:13): [True: 0, False: 0] ------------------ 1696| 0| return ONIGERR_INVALID_CALLOUT_ARG; ------------------ | | 643| 0|#define ONIGERR_INVALID_CALLOUT_ARG -232 ------------------ 1697| 4| } 1698| 4| else { 1699| 4| if (t != ONIG_TYPE_LONG) { ------------------ | Branch (1699:13): [True: 4, False: 0] ------------------ 1700| 4| t = t & ~ONIG_TYPE_LONG; 1701| 4| if (t != ONIG_TYPE_CHAR && t != ONIG_TYPE_STRING && t != ONIG_TYPE_TAG) ------------------ | Branch (1701:15): [True: 4, False: 0] | Branch (1701:38): [True: 3, False: 1] | Branch (1701:63): [True: 0, False: 3] ------------------ 1702| 0| return ONIGERR_INVALID_CALLOUT_ARG; ------------------ | | 643| 0|#define ONIGERR_INVALID_CALLOUT_ARG -232 ------------------ 1703| 4| } 1704| 4| } 1705| 8| } 1706| 8| } 1707| | 1708| 8| if (! is_allowed_callout_name(enc, name, name_end)) { ------------------ | Branch (1708:7): [True: 0, False: 8] ------------------ 1709| 0| return ONIGERR_INVALID_CALLOUT_NAME; ------------------ | | 639| 0|#define ONIGERR_INVALID_CALLOUT_NAME -228 ------------------ 1710| 0| } 1711| | 1712| 8| is_not_single = (callout_type != ONIG_CALLOUT_TYPE_SINGLE); 1713| 8| id = callout_name_entry(&e, enc, is_not_single, name, name_end); 1714| 8| if (id < 0) return id; ------------------ | Branch (1714:7): [True: 0, False: 8] ------------------ 1715| | 1716| 8| r = ONIG_NORMAL; ------------------ | | 563| 8|#define ONIG_NORMAL 0 ------------------ 1717| 8| if (IS_NULL(GlobalCalloutNameList)) { ------------------ | | 201| 8|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 1, False: 7] | | ------------------ ------------------ 1718| 1| r = make_callout_func_list(&GlobalCalloutNameList, 10); 1719| 1| if (r != ONIG_NORMAL) return r; ------------------ | | 563| 1|#define ONIG_NORMAL 0 ------------------ | Branch (1719:9): [True: 0, False: 1] ------------------ 1720| 1| } 1721| | 1722| 17| while (id >= GlobalCalloutNameList->n) { ------------------ | Branch (1722:10): [True: 9, False: 8] ------------------ 1723| 9| int rid; 1724| 9| r = callout_func_list_add(GlobalCalloutNameList, &rid); 1725| 9| if (r != ONIG_NORMAL) return r; ------------------ | | 563| 9|#define ONIG_NORMAL 0 ------------------ | Branch (1725:9): [True: 0, False: 9] ------------------ 1726| 9| } 1727| | 1728| 8| fe = GlobalCalloutNameList->v + id; 1729| 8| fe->type = callout_type; 1730| 8| fe->in = in; 1731| 8| fe->start_func = start_func; 1732| 8| fe->end_func = end_func; 1733| 8| fe->arg_num = arg_num; 1734| 8| fe->opt_arg_num = opt_arg_num; 1735| 8| fe->name = e->name; 1736| | 1737| 16| for (i = 0; i < arg_num; i++) { ------------------ | Branch (1737:15): [True: 8, False: 8] ------------------ 1738| 8| fe->arg_types[i] = arg_types[i]; 1739| 8| } 1740| 12| for (i = arg_num - opt_arg_num, j = 0; i < arg_num; i++, j++) { ------------------ | Branch (1740:42): [True: 4, False: 8] ------------------ 1741| 4| if (IS_NULL(opt_defaults)) return ONIGERR_INVALID_ARGUMENT; ------------------ | | 201| 4|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 4] | | ------------------ ------------------ if (IS_NULL(opt_defaults)) return ONIGERR_INVALID_ARGUMENT; ------------------ | | 586| 0|#define ONIGERR_INVALID_ARGUMENT -30 ------------------ 1742| 4| if (fe->arg_types[i] == ONIG_TYPE_STRING) { ------------------ | Branch (1742:9): [True: 0, False: 4] ------------------ 1743| 0| OnigValue* val; 1744| 0| UChar* ds; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 1745| | 1746| 0| val = opt_defaults + j; 1747| 0| ds = onigenc_strdup(enc, val->s.start, val->s.end); 1748| 0| CHECK_NULL_RETURN_MEMERR(ds); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1749| | 1750| 0| fe->opt_defaults[i].s.start = ds; 1751| 0| fe->opt_defaults[i].s.end = ds + (val->s.end - val->s.start); 1752| 0| } 1753| 4| else { 1754| 4| fe->opt_defaults[i] = opt_defaults[j]; 1755| 4| } 1756| 4| } 1757| | 1758| 8| r = id; 1759| 8| return r; 1760| 8|} onig_node_free: 2259| 187k|{ 2260| 187k| if (IS_NULL(node)) return ; ------------------ | | 201| 187k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 187k] | | ------------------ ------------------ 2261| | 2262| |#ifdef DEBUG_ND_FREE 2263| | fprintf(stderr, "onig_node_free: %p\n", node); 2264| |#endif 2265| | 2266| 187k| node_free_body(node); 2267| 187k| xfree(node); ------------------ | | 230| 187k|#define xfree free ------------------ 2268| 187k|} onig_node_new_list: 2435| 2.80k|{ 2436| 2.80k| return node_new_list(left, right); 2437| 2.80k|} onig_node_new_bag: 2685| 74|{ 2686| 74| return node_new_bag(type); 2687| 74|} onig_node_str_cat: 3382| 128k|{ 3383| 128k| int addlen = (int )(end - s); 3384| | 3385| 128k| if (addlen > 0) { ------------------ | Branch (3385:7): [True: 128k, False: 75] ------------------ 3386| 128k| int len = (int )(STR_(node)->end - STR_(node)->s); ------------------ | | 287| 128k|#define STR_(node) (&((node)->u.str)) ------------------ int len = (int )(STR_(node)->end - STR_(node)->s); ------------------ | | 287| 128k|#define STR_(node) (&((node)->u.str)) ------------------ 3387| | 3388| 128k| if (STR_(node)->capacity > 0 || (len + addlen > ND_STRING_BUF_SIZE - 1)) { ------------------ | | 287| 128k|#define STR_(node) (&((node)->u.str)) ------------------ if (STR_(node)->capacity > 0 || (len + addlen > ND_STRING_BUF_SIZE - 1)) { ------------------ | | 35| 128k|#define ND_STRING_BUF_SIZE 24 /* sizeof(CClassNode) - sizeof(int)*4 */ ------------------ | Branch (3388:9): [True: 0, False: 128k] | Branch (3388:37): [True: 0, False: 128k] ------------------ 3389| 0| UChar* p; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 3390| 0| int capa = len + addlen + ND_STRING_MARGIN; ------------------ | | 34| 0|#define ND_STRING_MARGIN 16 ------------------ 3391| | 3392| 0| if (capa <= STR_(node)->capacity) { ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ | Branch (3392:11): [True: 0, False: 0] ------------------ 3393| 0| onig_strcpy(STR_(node)->s + len, s, end); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 3394| 0| } 3395| 0| else { 3396| 0| if (STR_(node)->s == STR_(node)->buf) ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ if (STR_(node)->s == STR_(node)->buf) ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ | Branch (3396:13): [True: 0, False: 0] ------------------ 3397| 0| p = strcat_capa_from_static(STR_(node)->s, STR_(node)->end, ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ p = strcat_capa_from_static(STR_(node)->s, STR_(node)->end, ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 3398| 0| s, end, capa); 3399| 0| else 3400| 0| p = strcat_capa(STR_(node)->s, STR_(node)->end, s, end, capa); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ p = strcat_capa(STR_(node)->s, STR_(node)->end, s, end, capa); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 3401| | 3402| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 3403| 0| STR_(node)->s = p; ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 3404| 0| STR_(node)->capacity = capa; ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 3405| 0| } 3406| 0| } 3407| 128k| else { 3408| 128k| onig_strcpy(STR_(node)->s + len, s, end); ------------------ | | 287| 128k|#define STR_(node) (&((node)->u.str)) ------------------ 3409| 128k| } 3410| 128k| STR_(node)->end = STR_(node)->s + len + addlen; ------------------ | | 287| 128k|#define STR_(node) (&((node)->u.str)) ------------------ STR_(node)->end = STR_(node)->s + len + addlen; ------------------ | | 287| 128k|#define STR_(node) (&((node)->u.str)) ------------------ 3411| 128k| } 3412| | 3413| 128k| return 0; 3414| 128k|} onig_node_new_str: 3521| 112|{ 3522| 112| return node_new_str(s, end); 3523| 112|} onig_new_cclass_with_code_list: 8674| 2.69k|{ 8675| 2.69k| int i; 8676| 2.69k| Node* node; 8677| 2.69k| CClassNode* cc; 8678| | 8679| 2.69k| *rnode = NULL_NODE; ------------------ | | 266| 2.69k|#define NULL_NODE ((Node* )0) ------------------ 8680| | 8681| 2.69k| node = node_new_cclass(); 8682| 2.69k| CHECK_NULL_RETURN_MEMERR(node); ------------------ | | 204| 2.69k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 2.69k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 2.69k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8683| | 8684| 2.69k| cc = CCLASS_(node); ------------------ | | 288| 2.69k|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 8685| | 8686| 8.08k| for (i = 0; i < n; i++) { ------------------ | Branch (8686:15): [True: 5.39k, False: 2.69k] ------------------ 8687| 5.39k| ADD_CODE_INTO_CC(cc, codes[i], enc); ------------------ | | 8662| 5.39k|#define ADD_CODE_INTO_CC(cc, code, enc) do {\ | | 8663| 5.39k| if (ONIGENC_MBC_MINLEN(enc) > 1 || ONIGENC_CODE_TO_MBCLEN(enc, code) != 1) {\ | | ------------------ | | | | 282| 5.39k|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) | | ------------------ | | if (ONIGENC_MBC_MINLEN(enc) > 1 || ONIGENC_CODE_TO_MBCLEN(enc, code) != 1) {\ | | ------------------ | | | | 285| 5.39k|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code) | | ------------------ | | | Branch (8663:7): [True: 0, False: 5.39k] | | | Branch (8663:38): [True: 0, False: 5.39k] | | ------------------ | | 8664| 0| add_code_range_to_buf(&((cc)->mbuf), code, code);\ | | 8665| 0| }\ | | 8666| 5.39k| else {\ | | 8667| 5.39k| BITSET_SET_BIT((cc)->bs, code);\ | | ------------------ | | | | 451| 5.39k|#define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | | | ------------------ | | | | | | 447| 5.39k|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | | | ------------------ | | | | #define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | | | ------------------ | | | | | | 448| 5.39k|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | | | ------------------ | | ------------------ | | 8668| 5.39k| }\ | | 8669| 5.39k|} while (0) | | ------------------ | | | Branch (8669:10): [Folded, False: 5.39k] | | ------------------ ------------------ 8688| 5.39k| } 8689| | 8690| 2.69k| *rnode = node; 8691| 2.69k| return 0; 8692| 2.69k|} onig_parse_tree: 9392| 46.9k|{ 9393| 46.9k| int r; 9394| 46.9k| UChar* p; ------------------ | | 80| 46.9k|#define UChar OnigUChar ------------------ 9395| 46.9k|#ifdef USE_CALLOUT 9396| 46.9k| RegexExt* ext; 9397| 46.9k|#endif 9398| | 9399| 46.9k| reg->string_pool = 0; 9400| 46.9k| reg->string_pool_end = 0; 9401| 46.9k| reg->num_mem = 0; 9402| 46.9k| reg->num_repeat = 0; 9403| 46.9k| reg->num_empty_check = 0; 9404| 46.9k| reg->repeat_range_alloc = 0; 9405| 46.9k| reg->repeat_range = (RepeatRange* )NULL; 9406| | 9407| 46.9k| names_clear(reg); 9408| | 9409| 46.9k| scan_env_clear(env); 9410| 46.9k| env->options = reg->options; 9411| 46.9k| env->case_fold_flag = reg->case_fold_flag; 9412| 46.9k| env->enc = reg->enc; 9413| 46.9k| env->syntax = reg->syntax; 9414| 46.9k| env->pattern = (UChar* )pattern; 9415| 46.9k| env->pattern_end = (UChar* )end; 9416| 46.9k| env->reg = reg; 9417| | 9418| 46.9k| *root = NULL; 9419| | 9420| 46.9k| if (! ONIGENC_IS_VALID_MBC_STRING(env->enc, pattern, end)) ------------------ | | 271| 46.9k| (enc)->is_valid_mbc_string(s,end) ------------------ | Branch (9420:7): [True: 0, False: 46.9k] ------------------ 9421| 0| return ONIGERR_INVALID_WIDE_CHAR_VALUE; ------------------ | | 645| 0|#define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 ------------------ 9422| | 9423| 46.9k| p = (UChar* )pattern; 9424| 46.9k| r = prs_regexp(root, &p, (UChar* )end, env); 9425| 46.9k| if (r != 0) return r; ------------------ | Branch (9425:7): [True: 0, False: 46.9k] ------------------ 9426| | 9427| 46.9k|#ifdef USE_CALL 9428| 46.9k| if ((env->flags & PE_FLAG_HAS_CALL_ZERO) != 0) { ------------------ | | 457| 46.9k|#define PE_FLAG_HAS_CALL_ZERO (1<<0) ------------------ | Branch (9428:7): [True: 0, False: 46.9k] ------------------ 9429| 0| Node* zero_node; 9430| 0| r = make_call_zero_body(*root, env, &zero_node); 9431| 0| if (r != 0) return r; ------------------ | Branch (9431:9): [True: 0, False: 0] ------------------ 9432| | 9433| 0| *root = zero_node; 9434| 0| } 9435| 46.9k|#endif 9436| | 9437| 46.9k| reg->num_mem = env->num_mem; 9438| | 9439| 46.9k|#ifdef USE_CALLOUT 9440| 46.9k| ext = reg->extp; 9441| 46.9k| if (IS_NOT_NULL(ext) && ext->callout_num > 0) { ------------------ | | 202| 93.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 46.9k] | | ------------------ ------------------ | Branch (9441:27): [True: 0, False: 0] ------------------ 9442| 0| r = setup_ext_callout_list_values(reg); 9443| 0| } 9444| 46.9k|#endif 9445| | 9446| 46.9k| return r; 9447| 46.9k|} regparse.c:str_end_hash: 575| 827|{ 576| 827| st_str_end_key* x = (st_str_end_key* )ax; 577| 827| UChar *p; ------------------ | | 80| 827|#define UChar OnigUChar ------------------ 578| 827| unsigned val = 0; 579| | 580| 827| p = x->s; 581| 1.94k| while (p < x->end) { ------------------ | Branch (581:10): [True: 1.11k, False: 827] ------------------ 582| 1.11k| val = val * 997 + (unsigned )*p++; 583| 1.11k| } 584| | 585| 827| return (int) (val + (val >> 5)); 586| 827|} regparse.c:callout_name_table_hash: 667| 15|{ 668| 15| st_callout_name_key* x = (st_callout_name_key* )ax; 669| 15| UChar *p; ------------------ | | 80| 15|#define UChar OnigUChar ------------------ 670| 15| unsigned int val = 0; 671| | 672| 15| p = x->s; 673| 97| while (p < x->end) { ------------------ | Branch (673:10): [True: 82, False: 15] ------------------ 674| 82| val = val * 997 + (unsigned int )*p++; 675| 82| } 676| | 677| | /* use intptr_t for escape warning in Windows */ 678| 15| return (int )(val + (val >> 5) + ((intptr_t )x->enc & 0xffff) + x->type); 679| 15|} regparse.c:names_clear: 816| 93.9k|{ 817| 93.9k| NameTable* t = (NameTable* )reg->name_table; 818| | 819| 93.9k| if (IS_NOT_NULL(t)) { ------------------ | | 202| 93.9k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 503, False: 93.4k] | | ------------------ ------------------ 820| 503| onig_st_foreach(t, i_free_name_entry, 0); 821| 503| } 822| 93.9k| return 0; 823| 93.9k|} regparse.c:i_free_name_entry: 801| 665|{ 802| 665| UChar* key; ------------------ | | 80| 665|#define UChar OnigUChar ------------------ 803| 665| NameEntry* e; 804| | 805| 665| key = (UChar* )akey; 806| 665| e = (NameEntry* )ae; 807| 665| xfree(e->name); ------------------ | | 230| 665|#define xfree free ------------------ 808| 665| if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs); ------------------ | | 202| 665|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 665] | | ------------------ ------------------ if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs); ------------------ | | 230| 0|#define xfree free ------------------ 809| 665| xfree(key); ------------------ | | 230| 665|#define xfree free ------------------ 810| 665| xfree(e); ------------------ | | 230| 665|#define xfree free ------------------ 811| 665| return ST_DELETE; 812| 665|} regparse.c:i_names: 863| 43.7k|{ 864| 43.7k| NameEntry* e; 865| 43.7k| INamesArg* arg; 866| | 867| 43.7k| e = (NameEntry* )ae; 868| 43.7k| arg = (INamesArg* )aarg; 869| | 870| 43.7k| int r = (*(arg->func))(e->name, 871| 43.7k| e->name + e->name_len, 872| 43.7k| e->back_num, 873| 43.7k| (e->back_num > 1 ? e->back_refs : &(e->back_ref1)), ------------------ | Branch (873:27): [True: 0, False: 43.7k] ------------------ 874| 43.7k| arg->reg, arg->arg); 875| 43.7k| if (r != 0) { ------------------ | Branch (875:7): [True: 0, False: 43.7k] ------------------ 876| 0| arg->ret = r; 877| 0| return ST_STOP; 878| 0| } 879| 43.7k| return ST_CONTINUE; 880| 43.7k|} regparse.c:name_find: 842| 665|{ 843| 665| NameEntry* e; 844| 665| NameTable* t = (NameTable* )reg->name_table; 845| | 846| 665| e = (NameEntry* )NULL; 847| 665| if (IS_NOT_NULL(t)) { ------------------ | | 202| 665|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 162, False: 503] | | ------------------ ------------------ 848| 162| onig_st_lookup_strend(t, name, name_end, (HashDataType* )((void* )(&e))); 849| 162| } 850| 665| return e; 851| 665|} regparse.c:is_allowed_callout_name: 1611| 8|{ 1612| 8| UChar* p; ------------------ | | 80| 8|#define UChar OnigUChar ------------------ 1613| 8| OnigCodePoint c; 1614| | 1615| 8| if (name >= name_end) return 0; ------------------ | Branch (1615:7): [True: 0, False: 8] ------------------ 1616| | 1617| 8| p = name; 1618| 51| while (p < name_end) { ------------------ | Branch (1618:10): [True: 43, False: 8] ------------------ 1619| 43| c = ONIGENC_MBC_TO_CODE(enc, p, name_end); ------------------ | | 284| 43|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 1620| 43| if (! IS_ALLOWED_CODE_IN_CALLOUT_NAME(c)) ------------------ | | 46| 43| ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_' /* || c == '!' */) | | ------------------ | | | Branch (46:5): [True: 43, False: 0] | | | Branch (46:17): [True: 42, False: 1] | | | Branch (46:31): [True: 0, False: 1] | | | Branch (46:43): [True: 0, False: 0] | | | Branch (46:57): [True: 1, False: 0] | | | Branch (46:69): [True: 0, False: 1] | | | Branch (46:82): [True: 1, False: 0] | | ------------------ ------------------ 1621| 0| return 0; 1622| | 1623| 43| if (p == name) { ------------------ | Branch (1623:9): [True: 8, False: 35] ------------------ 1624| 8| if (c >= '0' && c <= '9') return 0; ------------------ | Branch (1624:11): [True: 8, False: 0] | Branch (1624:23): [True: 0, False: 8] ------------------ 1625| 8| } 1626| | 1627| 43| p += ONIGENC_MBC_ENC_LEN(enc, p); ------------------ | | 279| 43|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) ------------------ 1628| 43| } 1629| | 1630| 8| return 1; 1631| 8|} regparse.c:callout_name_entry: 1528| 8|{ 1529| 8| int r; 1530| 8| CalloutNameEntry* e; 1531| 8| CalloutNameTable* t = GlobalCalloutNameTable; 1532| | 1533| 8| *rentry = 0; 1534| 8| if (name_end - name <= 0) ------------------ | Branch (1534:7): [True: 0, False: 8] ------------------ 1535| 0| return ONIGERR_INVALID_CALLOUT_NAME; ------------------ | | 639| 0|#define ONIGERR_INVALID_CALLOUT_NAME -228 ------------------ 1536| | 1537| 8| e = callout_name_find(enc, is_not_single, name, name_end); 1538| 8| if (IS_NULL(e)) { ------------------ | | 201| 8|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 8, False: 0] | | ------------------ ------------------ 1539| 8|#ifdef USE_ST_LIBRARY 1540| 8| if (IS_NULL(t)) { ------------------ | | 201| 8|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 1, False: 7] | | ------------------ ------------------ 1541| 1| t = onig_st_init_callout_name_table_with_size(INIT_NAMES_ALLOC_NUM); ------------------ | | 751| 1|#define INIT_NAMES_ALLOC_NUM 5 ------------------ 1542| 1| CHECK_NULL_RETURN_MEMERR(t); ------------------ | | 204| 1|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 1|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1543| 1| GlobalCalloutNameTable = t; 1544| 1| } 1545| 8| e = (CalloutNameEntry* )xmalloc(sizeof(CalloutNameEntry)); ------------------ | | 227| 8|#define xmalloc malloc ------------------ 1546| 8| CHECK_NULL_RETURN_MEMERR(e); ------------------ | | 204| 8|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 8|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 8] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1547| | 1548| 8| e->name = onigenc_strdup(enc, name, name_end); 1549| 8| if (IS_NULL(e->name)) { ------------------ | | 201| 8|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 8] | | ------------------ ------------------ 1550| 0| xfree(e); return ONIGERR_MEMORY; ------------------ | | 230| 0|#define xfree free ------------------ xfree(e); return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 1551| 0| } 1552| | 1553| 8| r = st_insert_callout_name_table(t, enc, is_not_single, 1554| 8| e->name, (e->name + (name_end - name)), 1555| 8| (HashDataType )e); 1556| 8| if (r < 0) return r; ------------------ | Branch (1556:9): [True: 0, False: 8] ------------------ 1557| | 1558| |#else 1559| | 1560| | int alloc; 1561| | 1562| | if (IS_NULL(t)) { 1563| | alloc = INIT_NAMES_ALLOC_NUM; 1564| | t = (CalloutNameTable* )xmalloc(sizeof(CalloutNameTable)); 1565| | CHECK_NULL_RETURN_MEMERR(t); 1566| | t->e = NULL; 1567| | t->alloc = 0; 1568| | t->num = 0; 1569| | 1570| | t->e = (CalloutNameEntry* )xmalloc(sizeof(CalloutNameEntry) * alloc); 1571| | if (IS_NULL(t->e)) { 1572| | xfree(t); 1573| | return ONIGERR_MEMORY; 1574| | } 1575| | t->alloc = alloc; 1576| | GlobalCalloutNameTable = t; 1577| | goto clear; 1578| | } 1579| | else if (t->num == t->alloc) { 1580| | int i; 1581| | 1582| | alloc = t->alloc * 2; 1583| | t->e = (CalloutNameEntry* )xrealloc(t->e, sizeof(CalloutNameEntry) * alloc); 1584| | CHECK_NULL_RETURN_MEMERR(t->e); 1585| | t->alloc = alloc; 1586| | 1587| | clear: 1588| | for (i = t->num; i < t->alloc; i++) { 1589| | t->e[i].name = NULL; 1590| | t->e[i].name_len = 0; 1591| | t->e[i].id = 0; 1592| | } 1593| | } 1594| | e = &(t->e[t->num]); 1595| | t->num++; 1596| | e->name = onigenc_strdup(enc, name, name_end); 1597| | if (IS_NULL(e->name)) return ONIGERR_MEMORY; 1598| |#endif 1599| | 1600| 8| CalloutNameIDCounter++; 1601| 8| e->id = CalloutNameIDCounter; 1602| 8| e->name_len = (int )(name_end - name); 1603| 8| } 1604| | 1605| 8| *rentry = e; 1606| 8| return e->id; 1607| 8|} regparse.c:callout_name_find: 1441| 8|{ 1442| 8| int r; 1443| 8| CalloutNameEntry* e; 1444| 8| CalloutNameTable* t = GlobalCalloutNameTable; 1445| | 1446| 8| e = (CalloutNameEntry* )NULL; 1447| 8| if (IS_NOT_NULL(t)) { ------------------ | | 202| 8|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 7, False: 1] | | ------------------ ------------------ 1448| 7| r = onig_st_lookup_callout_name_table(t, enc, is_not_single, name, name_end, 1449| 7| (HashDataType* )((void* )(&e))); 1450| 7| if (r == 0) { /* not found */ ------------------ | Branch (1450:9): [True: 7, False: 0] ------------------ 1451| 7| if (enc != ONIG_ENCODING_ASCII && ------------------ | | 189| 14|#define ONIG_ENCODING_ASCII (&OnigEncodingASCII) ------------------ | Branch (1451:11): [True: 0, False: 7] ------------------ 1452| 0| ONIGENC_IS_ASCII_COMPATIBLE_ENCODING(enc)) { ------------------ | | 284| 0| (((enc)->flag & ENC_FLAG_ASCII_COMPATIBLE) != 0) | | ------------------ | | | | 132| 0|#define ENC_FLAG_ASCII_COMPATIBLE (1<<0) | | ------------------ | | | Branch (284:3): [True: 0, False: 0] | | ------------------ ------------------ 1453| 0| enc = ONIG_ENCODING_ASCII; ------------------ | | 189| 0|#define ONIG_ENCODING_ASCII (&OnigEncodingASCII) ------------------ 1454| 0| onig_st_lookup_callout_name_table(t, enc, is_not_single, name, name_end, 1455| 0| (HashDataType* )((void* )(&e))); 1456| 0| } 1457| 7| } 1458| 7| } 1459| 8| return e; 1460| 8|} regparse.c:st_insert_callout_name_table: 715| 8|{ 716| 8| st_callout_name_key* key; 717| 8| int result; 718| | 719| 8| key = (st_callout_name_key* )xmalloc(sizeof(st_callout_name_key)); ------------------ | | 227| 8|#define xmalloc malloc ------------------ 720| 8| CHECK_NULL_RETURN_MEMERR(key); ------------------ | | 204| 8|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 8|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 8] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 721| | 722| | /* key->s: don't duplicate, because str_key is duped in callout_name_entry() */ 723| 8| key->enc = enc; 724| 8| key->type = type; 725| 8| key->s = str_key; 726| 8| key->end = end_key; 727| 8| result = onig_st_insert(table, (st_data_t )key, value); 728| 8| if (result) { ------------------ | Branch (728:7): [True: 0, False: 8] ------------------ 729| 0| xfree(key); ------------------ | | 230| 0|#define xfree free ------------------ 730| 0| } 731| 8| return result; 732| 8|} regparse.c:make_callout_func_list: 1309| 1|{ 1310| 1| CalloutNameListType* s; 1311| 1| CalloutNameListEntry* v; 1312| | 1313| 1| *rs = 0; 1314| | 1315| 1| s = xmalloc(sizeof(*s)); ------------------ | | 227| 1|#define xmalloc malloc ------------------ 1316| 1| if (IS_NULL(s)) return ONIGERR_MEMORY; ------------------ | | 201| 1|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 1] | | ------------------ ------------------ if (IS_NULL(s)) return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 1317| | 1318| 1| v = (CalloutNameListEntry* )xmalloc(sizeof(CalloutNameListEntry) * init_size); ------------------ | | 227| 1|#define xmalloc malloc ------------------ 1319| 1| if (IS_NULL(v)) { ------------------ | | 201| 1|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 1] | | ------------------ ------------------ 1320| 0| xfree(s); ------------------ | | 230| 0|#define xfree free ------------------ 1321| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 1322| 0| } 1323| | 1324| 1| s->n = 0; 1325| 1| s->alloc = init_size; 1326| 1| s->v = v; 1327| | 1328| 1| *rs = s; 1329| 1| return ONIG_NORMAL; ------------------ | | 563| 1|#define ONIG_NORMAL 0 ------------------ 1330| 1|} regparse.c:callout_func_list_add: 1356| 9|{ 1357| 9| if (s->n >= s->alloc) { ------------------ | Branch (1357:7): [True: 0, False: 9] ------------------ 1358| 0| int new_size = s->alloc * 2; 1359| 0| CalloutNameListEntry* nv = (CalloutNameListEntry* ) 1360| 0| xrealloc(s->v, sizeof(CalloutNameListEntry) * new_size); ------------------ | | 228| 0|#define xrealloc realloc ------------------ 1361| 0| if (IS_NULL(nv)) return ONIGERR_MEMORY; ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ if (IS_NULL(nv)) return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 1362| | 1363| 0| s->alloc = new_size; 1364| 0| s->v = nv; 1365| 0| } 1366| | 1367| 9| *rid = s->n; 1368| | 1369| 9| xmemset(&(s->v[s->n]), 0, sizeof(*(s->v))); ------------------ | | 177| 9|#define xmemset memset ------------------ 1370| 9| s->n++; 1371| 9| return ONIG_NORMAL; ------------------ | | 563| 9|#define ONIG_NORMAL 0 ------------------ 1372| 9|} regparse.c:node_free_body: 2188| 187k|{ 2189| 187k| if (IS_NULL(node)) return ; ------------------ | | 201| 187k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 187k] | | ------------------ ------------------ 2190| | 2191| 187k| switch (ND_TYPE(node)) { ------------------ | | 284| 187k|#define ND_TYPE(node) ((node)->u.base.node_type) | | ------------------ | | | Branch (284:35): [True: 187k, False: 0] | | ------------------ ------------------ 2192| 87.3k| case ND_STRING: ------------------ | Branch (2192:3): [True: 87.3k, False: 100k] ------------------ 2193| 87.3k| if (STR_(node)->capacity != 0 && ------------------ | | 287| 87.3k|#define STR_(node) (&((node)->u.str)) ------------------ | Branch (2193:9): [True: 0, False: 87.3k] ------------------ 2194| 0| IS_NOT_NULL(STR_(node)->s) && STR_(node)->s != STR_(node)->buf) { ------------------ | | 202| 87.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ IS_NOT_NULL(STR_(node)->s) && STR_(node)->s != STR_(node)->buf) { ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ IS_NOT_NULL(STR_(node)->s) && STR_(node)->s != STR_(node)->buf) { ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ | Branch (2194:39): [True: 0, False: 0] ------------------ 2195| 0| xfree(STR_(node)->s); ------------------ | | 230| 0|#define xfree free ------------------ xfree(STR_(node)->s); ------------------ | | 287| 0|#define STR_(node) (&((node)->u.str)) ------------------ 2196| 0| } 2197| 87.3k| break; 2198| | 2199| 46.4k| case ND_LIST: ------------------ | Branch (2199:3): [True: 46.4k, False: 141k] ------------------ 2200| 46.4k| case ND_ALT: ------------------ | Branch (2200:3): [True: 0, False: 187k] ------------------ 2201| 46.4k| onig_node_free(ND_CAR(node)); ------------------ | | 298| 46.4k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 46.4k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2202| 46.4k| node = ND_CDR(node); ------------------ | | 299| 46.4k|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 46.4k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2203| 91.1k| while (IS_NOT_NULL(node)) { ------------------ | | 202| 91.1k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 44.7k, False: 46.4k] | | ------------------ ------------------ 2204| 44.7k| Node* next = ND_CDR(node); ------------------ | | 299| 44.7k|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 44.7k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2205| 44.7k| onig_node_free(ND_CAR(node)); ------------------ | | 298| 44.7k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 44.7k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2206| 44.7k| xfree(node); ------------------ | | 230| 44.7k|#define xfree free ------------------ 2207| 44.7k| node = next; 2208| 44.7k| } 2209| 46.4k| break; 2210| | 2211| 3.08k| case ND_CCLASS: ------------------ | Branch (2211:3): [True: 3.08k, False: 184k] ------------------ 2212| 3.08k| { 2213| 3.08k| CClassNode* cc = CCLASS_(node); ------------------ | | 288| 3.08k|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 2214| | 2215| 3.08k| if (cc->mbuf) ------------------ | Branch (2215:11): [True: 0, False: 3.08k] ------------------ 2216| 0| bbuf_free(cc->mbuf); 2217| 3.08k| } 2218| 3.08k| break; 2219| | 2220| 0| case ND_BACKREF: ------------------ | Branch (2220:3): [True: 0, False: 187k] ------------------ 2221| 0| if (IS_NOT_NULL(BACKREF_(node)->back_dynamic)) ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 2222| 0| xfree(BACKREF_(node)->back_dynamic); ------------------ | | 230| 0|#define xfree free ------------------ xfree(BACKREF_(node)->back_dynamic); ------------------ | | 290| 0|#define BACKREF_(node) (&((node)->u.backref)) ------------------ 2223| 0| break; 2224| | 2225| 875| case ND_BAG: ------------------ | Branch (2225:3): [True: 875, False: 186k] ------------------ 2226| 875| if (ND_BODY(node)) ------------------ | | 394| 875|#define ND_BODY(node) ((node)->u.base.body) | | ------------------ | | | Branch (394:33): [True: 875, False: 0] | | ------------------ ------------------ 2227| 875| onig_node_free(ND_BODY(node)); ------------------ | | 394| 875|#define ND_BODY(node) ((node)->u.base.body) ------------------ 2228| | 2229| 875| { 2230| 875| BagNode* en = BAG_(node); ------------------ | | 292| 875|#define BAG_(node) (&((node)->u.bag)) ------------------ 2231| 875| if (en->type == BAG_IF_ELSE) { ------------------ | Branch (2231:11): [True: 0, False: 875] ------------------ 2232| 0| onig_node_free(en->te.Then); 2233| 0| onig_node_free(en->te.Else); 2234| 0| } 2235| 875| } 2236| 875| break; 2237| | 2238| 46.3k| case ND_QUANT: ------------------ | Branch (2238:3): [True: 46.3k, False: 141k] ------------------ 2239| 46.3k| if (ND_BODY(node)) ------------------ | | 394| 46.3k|#define ND_BODY(node) ((node)->u.base.body) | | ------------------ | | | Branch (394:33): [True: 46.3k, False: 0] | | ------------------ ------------------ 2240| 46.3k| onig_node_free(ND_BODY(node)); ------------------ | | 394| 46.3k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 2241| 46.3k| break; 2242| | 2243| 3.11k| case ND_ANCHOR: ------------------ | Branch (2243:3): [True: 3.11k, False: 184k] ------------------ 2244| 3.11k| if (ND_BODY(node)) ------------------ | | 394| 3.11k|#define ND_BODY(node) ((node)->u.base.body) | | ------------------ | | | Branch (394:33): [True: 13, False: 3.10k] | | ------------------ ------------------ 2245| 13| onig_node_free(ND_BODY(node)); ------------------ | | 394| 13|#define ND_BODY(node) ((node)->u.base.body) ------------------ 2246| 3.11k| if (IS_NOT_NULL(ANCHOR_(node)->lead_node)) ------------------ | | 202| 3.11k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 3.11k] | | ------------------ ------------------ 2247| 0| onig_node_free(ANCHOR_(node)->lead_node); ------------------ | | 293| 0|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 2248| 3.11k| break; 2249| | 2250| 562| case ND_CTYPE: ------------------ | Branch (2250:3): [True: 562, False: 187k] ------------------ 2251| 562| case ND_CALL: ------------------ | Branch (2251:3): [True: 0, False: 187k] ------------------ 2252| 562| case ND_GIMMICK: ------------------ | Branch (2252:3): [True: 0, False: 187k] ------------------ 2253| 562| break; 2254| 187k| } 2255| 187k|} regparse.c:node_new: 2280| 232k|{ 2281| 232k| Node* node; 2282| | 2283| 232k| node = (Node* )xmalloc(sizeof(Node)); ------------------ | | 227| 232k|#define xmalloc malloc ------------------ 2284| 232k| CHECK_NULL_RETURN(node); ------------------ | | 203| 232k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 232k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 232k] | | | | ------------------ | | ------------------ ------------------ 2285| 232k| xmemset(node, 0, sizeof(*node)); ------------------ | | 177| 232k|#define xmemset memset ------------------ 2286| | 2287| |#ifdef DEBUG_ND_FREE 2288| | fprintf(stderr, "node_new: %p\n", node); 2289| |#endif 2290| 232k| return node; 2291| 232k|} regparse.c:node_new_list: 2423| 91.1k|{ 2424| 91.1k| Node* node = node_new(); 2425| 91.1k| CHECK_NULL_RETURN(node); ------------------ | | 203| 91.1k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 91.1k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 91.1k] | | | | ------------------ | | ------------------ ------------------ 2426| | 2427| 91.1k| ND_SET_TYPE(node, ND_LIST); ------------------ | | 285| 91.1k|#define ND_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype) ------------------ 2428| 91.1k| ND_CAR(node) = left; ------------------ | | 298| 91.1k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 91.1k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2429| 91.1k| ND_CDR(node) = right; ------------------ | | 299| 91.1k|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 91.1k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 2430| 91.1k| return node; 2431| 91.1k|} regparse.c:node_new_bag: 2651| 875|{ 2652| 875| Node* node = node_new(); 2653| 875| CHECK_NULL_RETURN(node); ------------------ | | 203| 875|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 875|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 875] | | | | ------------------ | | ------------------ ------------------ 2654| | 2655| 875| ND_SET_TYPE(node, ND_BAG); ------------------ | | 285| 875|#define ND_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype) ------------------ 2656| 875| BAG_(node)->type = type; ------------------ | | 292| 875|#define BAG_(node) (&((node)->u.bag)) ------------------ 2657| | 2658| 875| switch (type) { ------------------ | Branch (2658:11): [True: 875, False: 0] ------------------ 2659| 801| case BAG_MEMORY: ------------------ | Branch (2659:3): [True: 801, False: 74] ------------------ 2660| 801| BAG_(node)->m.regnum = 0; ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 2661| 801| BAG_(node)->m.called_addr = -1; ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 2662| 801| BAG_(node)->m.entry_count = 1; ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 2663| 801| BAG_(node)->m.called_state = 0; ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 2664| 801| break; 2665| | 2666| 0| case BAG_OPTION: ------------------ | Branch (2666:3): [True: 0, False: 875] ------------------ 2667| 0| BAG_(node)->o.options = 0; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 2668| 0| break; 2669| | 2670| 74| case BAG_STOP_BACKTRACK: ------------------ | Branch (2670:3): [True: 74, False: 801] ------------------ 2671| 74| break; 2672| | 2673| 0| case BAG_IF_ELSE: ------------------ | Branch (2673:3): [True: 0, False: 875] ------------------ 2674| 0| BAG_(node)->te.Then = 0; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 2675| 0| BAG_(node)->te.Else = 0; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 2676| 0| break; 2677| 875| } 2678| | 2679| 875| BAG_(node)->opt_count = 0; ------------------ | | 292| 875|#define BAG_(node) (&((node)->u.bag)) ------------------ 2680| 875| return node; 2681| 875|} regparse.c:node_set_str: 3477| 87.3k|{ 3478| 87.3k| int r; 3479| | 3480| 87.3k| ND_SET_TYPE(node, ND_STRING); ------------------ | | 285| 87.3k|#define ND_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype) ------------------ 3481| 87.3k| STR_(node)->flag = 0; ------------------ | | 287| 87.3k|#define STR_(node) (&((node)->u.str)) ------------------ 3482| 87.3k| STR_(node)->s = STR_(node)->buf; ------------------ | | 287| 87.3k|#define STR_(node) (&((node)->u.str)) ------------------ STR_(node)->s = STR_(node)->buf; ------------------ | | 287| 87.3k|#define STR_(node) (&((node)->u.str)) ------------------ 3483| 87.3k| STR_(node)->end = STR_(node)->buf; ------------------ | | 287| 87.3k|#define STR_(node) (&((node)->u.str)) ------------------ STR_(node)->end = STR_(node)->buf; ------------------ | | 287| 87.3k|#define STR_(node) (&((node)->u.str)) ------------------ 3484| 87.3k| STR_(node)->capacity = 0; ------------------ | | 287| 87.3k|#define STR_(node) (&((node)->u.str)) ------------------ 3485| | 3486| 87.3k| r = onig_node_str_cat(node, s, end); 3487| 87.3k| return r; 3488| 87.3k|} regparse.c:node_new_str: 3492| 87.3k|{ 3493| 87.3k| int r; 3494| 87.3k| Node* node = node_new(); 3495| 87.3k| CHECK_NULL_RETURN(node); ------------------ | | 203| 87.3k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 87.3k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 87.3k] | | | | ------------------ | | ------------------ ------------------ 3496| | 3497| 87.3k| r = node_set_str(node, s, end); 3498| 87.3k| if (r != 0) { ------------------ | Branch (3498:7): [True: 0, False: 87.3k] ------------------ 3499| 0| onig_node_free(node); 3500| 0| return NULL; 3501| 0| } 3502| | 3503| 87.3k| return node; 3504| 87.3k|} regparse.c:node_new_cclass: 2364| 3.08k|{ 2365| 3.08k| Node* node = node_new(); 2366| 3.08k| CHECK_NULL_RETURN(node); ------------------ | | 203| 3.08k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 3.08k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 3.08k] | | | | ------------------ | | ------------------ ------------------ 2367| | 2368| 3.08k| ND_SET_TYPE(node, ND_CCLASS); ------------------ | | 285| 3.08k|#define ND_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype) ------------------ 2369| 3.08k| initialize_cclass(CCLASS_(node)); ------------------ | | 288| 3.08k|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 2370| 3.08k| return node; 2371| 3.08k|} regparse.c:initialize_cclass: 2356| 3.08k|{ 2357| 3.08k| BITSET_CLEAR(cc->bs); ------------------ | | 442| 3.08k|#define BITSET_CLEAR(bs) do {\ | | 443| 3.08k| int i;\ | | 444| 27.7k| for (i = 0; i < (int )BITSET_REAL_SIZE; i++) { (bs)[i] = 0; } \ | | ------------------ | | | | 434| 27.7k|#define BITSET_REAL_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 432| 27.7k|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 431| 27.7k|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | | | #define BITSET_REAL_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 433| 27.7k|#define BITS_IN_ROOM 32 /* 4 * BITS_PER_BYTE */ | | | | ------------------ | | ------------------ | | | Branch (444:15): [True: 24.6k, False: 3.08k] | | ------------------ | | 445| 3.08k|} while (0) | | ------------------ | | | Branch (445:10): [Folded, False: 3.08k] | | ------------------ ------------------ 2358| 3.08k| cc->flags = 0; 2359| | cc->mbuf = NULL; 2360| 3.08k|} regparse.c:scan_env_clear: 2107| 46.9k|{ 2108| 46.9k| MEM_STATUS_CLEAR(env->cap_history); ------------------ | | 362| 46.9k|#define MEM_STATUS_CLEAR(stats) (stats) = 0 ------------------ 2109| 46.9k| MEM_STATUS_CLEAR(env->backtrack_mem); ------------------ | | 362| 46.9k|#define MEM_STATUS_CLEAR(stats) (stats) = 0 ------------------ 2110| 46.9k| MEM_STATUS_CLEAR(env->backrefed_mem); ------------------ | | 362| 46.9k|#define MEM_STATUS_CLEAR(stats) (stats) = 0 ------------------ 2111| 46.9k| env->error = (UChar* )NULL; 2112| 46.9k| env->error_end = (UChar* )NULL; 2113| 46.9k| env->num_call = 0; 2114| | 2115| 46.9k|#ifdef USE_CALL 2116| 46.9k| env->unset_addr_list = NULL; 2117| 46.9k|#endif 2118| | 2119| 46.9k| env->num_mem = 0; 2120| 46.9k| env->num_named = 0; 2121| 46.9k| env->mem_alloc = 0; 2122| 46.9k| env->mem_env_dynamic = (MemEnv* )NULL; 2123| | 2124| 46.9k| xmemset(env->mem_env_static, 0, sizeof(env->mem_env_static)); ------------------ | | 177| 46.9k|#define xmemset memset ------------------ 2125| | 2126| 46.9k| env->parse_depth = 0; 2127| |#ifdef ONIG_DEBUG_PARSE 2128| | env->max_parse_depth = 0; 2129| |#endif 2130| 46.9k| env->backref_num = 0; 2131| 46.9k| env->keep_num = 0; 2132| 46.9k| env->id_num = 0; 2133| 46.9k| env->save_alloc_num = 0; 2134| 46.9k| env->saves = 0; 2135| 46.9k| env->flags = 0; 2136| 46.9k|} regparse.c:prs_regexp: 9354| 46.9k|{ 9355| 46.9k| int r; 9356| 46.9k| PToken tok; 9357| | 9358| 46.9k| ptoken_init(&tok); 9359| 46.9k| r = fetch_token(&tok, src, end, env); 9360| 46.9k| if (r < 0) return r; ------------------ | Branch (9360:7): [True: 0, False: 46.9k] ------------------ 9361| 46.9k| r = prs_alts(top, &tok, TK_EOT, src, end, env, FALSE); ------------------ | | 63| 46.9k|#define FALSE 0 ------------------ 9362| 46.9k| if (r < 0) return r; ------------------ | Branch (9362:7): [True: 0, False: 46.9k] ------------------ 9363| | 9364| 46.9k| return 0; 9365| 46.9k|} regparse.c:ptoken_init: 4617| 46.9k|{ 4618| 46.9k| tok->code_point_continue = 0; 4619| 46.9k|} regparse.c:fetch_token: 5554| 186k|{ 5555| 186k| int r; 5556| 186k| OnigCodePoint code; 5557| 186k| OnigCodePoint c; 5558| 186k| int mindigits, maxdigits; 5559| 186k| UChar* prev; ------------------ | | 80| 186k|#define UChar OnigUChar ------------------ 5560| 186k| int allow_num; 5561| 186k| OnigEncoding enc; 5562| 186k| OnigSyntaxType* syn; 5563| 186k| UChar* p; ------------------ | | 80| 186k|#define UChar OnigUChar ------------------ 5564| 186k| PFETCH_READY; ------------------ | | 486| 186k|#define PFETCH_READY UChar* pfetch_prev | | ------------------ | | | | 80| 186k|#define UChar OnigUChar | | ------------------ ------------------ 5565| | 5566| 186k| enc = env->enc; 5567| 186k| syn = env->syntax; 5568| 186k| p = *src; 5569| | 5570| 186k| if (tok->code_point_continue != 0) { ------------------ | Branch (5570:7): [True: 0, False: 186k] ------------------ 5571| 0| r = get_next_code_point(&p, end, tok->base_num, enc, FALSE, &code); ------------------ | | 63| 0|#define FALSE 0 ------------------ 5572| 0| if (r == 1) { ------------------ | Branch (5572:9): [True: 0, False: 0] ------------------ 5573| 0| tok->code_point_continue = 0; 5574| 0| } 5575| 0| else if (r == 0) { ------------------ | Branch (5575:14): [True: 0, False: 0] ------------------ 5576| 0| tok->type = TK_CODE_POINT; 5577| 0| tok->u.code = code; 5578| 0| goto out; 5579| 0| } 5580| 0| else 5581| 0| return r; /* error */ 5582| 0| } 5583| | 5584| 186k| start: 5585| 186k| if (PEND) { ------------------ | | 487| 186k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 46.9k, False: 139k] | | | Branch (487:23): [True: 139k, False: 46.9k] | | ------------------ ------------------ 5586| 46.9k| tok->type = TK_EOT; 5587| 46.9k| return tok->type; 5588| 46.9k| } 5589| | 5590| 139k| tok->type = TK_STRING; 5591| 139k| tok->base_num = 0; 5592| 139k| tok->backp = p; 5593| | 5594| 139k| PFETCH(c); ------------------ | | 494| 139k|#define PFETCH(c) do { \ | | 495| 139k| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 139k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 139k| pfetch_prev = p; \ | | 497| 139k| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 139k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 139k|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 139k] | | ------------------ ------------------ 5595| 139k| if (IS_MC_ESC_CODE(c, syn)) { ------------------ | | 695| 139k| ((code) == MC_ESC(syn) && \ | | ------------------ | | | | 687| 279k|#define MC_ESC(syn) (syn)->meta_char_table.esc | | ------------------ | | | Branch (695:4): [True: 0, False: 139k] | | ------------------ | | 696| 139k| !IS_SYNTAX_OP2((syn), ONIG_SYN_OP2_INEFFECTIVE_ESCAPE)) | | ------------------ | | | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (696:4): [True: 0, False: 0] | | ------------------ ------------------ 5596| 0| if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 592| 0|#define ONIGERR_END_PATTERN_AT_ESCAPE -104 ------------------ 5597| | 5598| 0| tok->backp = p; 5599| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 5600| | 5601| 0| tok->u.code = c; 5602| 0| tok->escaped = 1; 5603| 0| switch (c) { 5604| 0| case '*': ------------------ | Branch (5604:5): [True: 0, False: 0] ------------------ 5605| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5605:11): [True: 0, False: 0] ------------------ 5606| 0| tok->type = TK_REPEAT; 5607| 0| tok->u.repeat.lower = 0; 5608| 0| tok->u.repeat.upper = INFINITE_REPEAT; ------------------ | | 427| 0|#define INFINITE_REPEAT -1 ------------------ 5609| 0| goto greedy_check; 5610| 0| break; 5611| | 5612| 0| case '+': ------------------ | Branch (5612:5): [True: 0, False: 0] ------------------ 5613| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_PLUS_ONE_INF)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5613:11): [True: 0, False: 0] ------------------ 5614| 0| tok->type = TK_REPEAT; 5615| 0| tok->u.repeat.lower = 1; 5616| 0| tok->u.repeat.upper = INFINITE_REPEAT; ------------------ | | 427| 0|#define INFINITE_REPEAT -1 ------------------ 5617| 0| goto greedy_check; 5618| 0| break; 5619| | 5620| 0| case '?': ------------------ | Branch (5620:5): [True: 0, False: 0] ------------------ 5621| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_QMARK_ZERO_ONE)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5621:11): [True: 0, False: 0] ------------------ 5622| 0| tok->type = TK_REPEAT; 5623| 0| tok->u.repeat.lower = 0; 5624| 0| tok->u.repeat.upper = 1; 5625| 46.3k| greedy_check: 5626| 46.3k| tok->u.repeat.possessive = 0; 5627| 46.3k| greedy_check2: 5628| 46.3k| if (!PEND && PPEEK_IS('?') && ------------------ | | 487| 92.7k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 538, False: 45.8k] | | ------------------ ------------------ if (!PEND && PPEEK_IS('?') && ------------------ | | 509| 46.9k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 538|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 538|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 538, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 67, False: 471] | | ------------------ ------------------ | Branch (5628:11): [True: 538, False: 45.8k] ------------------ 5629| 67| IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_NON_GREEDY) && ------------------ | | 405| 46.4k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 67, False: 0] | | ------------------ ------------------ 5630| 67| tok->u.repeat.possessive == 0) { ------------------ | Branch (5630:11): [True: 67, False: 0] ------------------ 5631| 67| PFETCH(c); ------------------ | | 494| 67|#define PFETCH(c) do { \ | | 495| 67| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 67|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 67| pfetch_prev = p; \ | | 497| 67| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 67|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 67|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 67] | | ------------------ ------------------ 5632| 67| tok->u.repeat.greedy = 0; 5633| 67| tok->u.repeat.possessive = 0; 5634| 67| } 5635| 46.3k| else { 5636| 46.3k| possessive_check: 5637| 46.3k| tok->u.repeat.greedy = 1; 5638| 46.3k| if (!PEND && PPEEK_IS('+') && ------------------ | | 487| 92.6k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 471, False: 45.8k] | | ------------------ ------------------ if (!PEND && PPEEK_IS('+') && ------------------ | | 509| 46.7k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 471|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 471|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 471, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 471] | | ------------------ ------------------ | Branch (5638:13): [True: 471, False: 45.8k] ------------------ 5639| 0| ((IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT) && ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 5640| 0| tok->type != TK_INTERVAL) || ------------------ | Branch (5640:15): [True: 0, False: 0] ------------------ 5641| 0| (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL) && ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 5642| 0| tok->type == TK_INTERVAL)) && ------------------ | Branch (5642:15): [True: 0, False: 0] ------------------ 5643| 0| tok->u.repeat.possessive == 0) { ------------------ | Branch (5643:11): [True: 0, False: 0] ------------------ 5644| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 5645| 0| tok->u.repeat.possessive = 1; 5646| 0| } 5647| 46.3k| } 5648| 46.3k| break; 5649| | 5650| 46.3k| case '{': ------------------ | Branch (5650:5): [True: 0, False: 0] ------------------ 5651| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_BRACE_INTERVAL)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5651:11): [True: 0, False: 0] ------------------ 5652| 0| r = fetch_interval(&p, end, tok, env); 5653| 0| if (r < 0) return r; /* error */ ------------------ | Branch (5653:11): [True: 0, False: 0] ------------------ 5654| 0| if (r == 0) goto greedy_check2; ------------------ | Branch (5654:11): [True: 0, False: 0] ------------------ 5655| 0| else if (r == 2) { /* {n} */ ------------------ | Branch (5655:16): [True: 0, False: 0] ------------------ 5656| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 5657| 0| goto possessive_check; 5658| | 5659| 0| goto greedy_check2; 5660| 0| } 5661| | /* r == 1 : normal char */ 5662| 0| break; 5663| | 5664| 0| case '|': ------------------ | Branch (5664:5): [True: 0, False: 0] ------------------ 5665| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_VBAR_ALT)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5665:11): [True: 0, False: 0] ------------------ 5666| 0| tok->type = TK_ALT; 5667| 0| break; 5668| | 5669| 0| case '(': ------------------ | Branch (5669:5): [True: 0, False: 0] ------------------ 5670| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LPAREN_SUBEXP)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5670:11): [True: 0, False: 0] ------------------ 5671| 0| tok->type = TK_SUBEXP_OPEN; 5672| 0| break; 5673| | 5674| 0| case ')': ------------------ | Branch (5674:5): [True: 0, False: 0] ------------------ 5675| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LPAREN_SUBEXP)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5675:11): [True: 0, False: 0] ------------------ 5676| 0| tok->type = TK_SUBEXP_CLOSE; 5677| 0| break; 5678| | 5679| 0| case 'w': ------------------ | Branch (5679:5): [True: 0, False: 0] ------------------ 5680| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_W_WORD)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5680:11): [True: 0, False: 0] ------------------ 5681| 0| tok->type = TK_CHAR_TYPE; 5682| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; 5683| 0| tok->u.prop.not = 0; 5684| 0| break; 5685| | 5686| 0| case 'W': ------------------ | Branch (5686:5): [True: 0, False: 0] ------------------ 5687| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_W_WORD)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5687:11): [True: 0, False: 0] ------------------ 5688| 0| tok->type = TK_CHAR_TYPE; 5689| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; 5690| 0| tok->u.prop.not = 1; 5691| 0| break; 5692| | 5693| 0| case 'b': ------------------ | Branch (5693:5): [True: 0, False: 0] ------------------ 5694| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_B_WORD_BOUND)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5694:11): [True: 0, False: 0] ------------------ 5695| 0| tok->type = TK_ANCHOR; 5696| 0| tok->u.anchor = ANCR_WORD_BOUNDARY; ------------------ | | 467| 0|#define ANCR_WORD_BOUNDARY (1<<10) ------------------ 5697| 0| break; 5698| | 5699| 0| case 'B': ------------------ | Branch (5699:5): [True: 0, False: 0] ------------------ 5700| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_B_WORD_BOUND)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5700:11): [True: 0, False: 0] ------------------ 5701| 0| tok->type = TK_ANCHOR; 5702| 0| tok->u.anchor = ANCR_NO_WORD_BOUNDARY; ------------------ | | 468| 0|#define ANCR_NO_WORD_BOUNDARY (1<<11) ------------------ 5703| 0| break; 5704| | 5705| 0| case 'y': ------------------ | Branch (5705:5): [True: 0, False: 0] ------------------ 5706| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5706:11): [True: 0, False: 0] ------------------ 5707| 0| tok->type = TK_ANCHOR; 5708| 0| tok->u.anchor = ANCR_TEXT_SEGMENT_BOUNDARY; ------------------ | | 473| 0|#define ANCR_TEXT_SEGMENT_BOUNDARY (1<<16) ------------------ 5709| 0| break; 5710| | 5711| 0| case 'Y': ------------------ | Branch (5711:5): [True: 0, False: 0] ------------------ 5712| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5712:11): [True: 0, False: 0] ------------------ 5713| 0| tok->type = TK_ANCHOR; 5714| 0| tok->u.anchor = ANCR_NO_TEXT_SEGMENT_BOUNDARY; ------------------ | | 474| 0|#define ANCR_NO_TEXT_SEGMENT_BOUNDARY (1<<17) ------------------ 5715| 0| break; 5716| | 5717| 0|#ifdef USE_WORD_BEGIN_END 5718| 0| case '<': ------------------ | Branch (5718:5): [True: 0, False: 0] ------------------ 5719| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5719:11): [True: 0, False: 0] ------------------ 5720| 0| tok->type = TK_ANCHOR; 5721| 0| tok->u.anchor = ANCR_WORD_BEGIN; ------------------ | | 469| 0|#define ANCR_WORD_BEGIN (1<<12) ------------------ 5722| 0| break; 5723| | 5724| 0| case '>': ------------------ | Branch (5724:5): [True: 0, False: 0] ------------------ 5725| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5725:11): [True: 0, False: 0] ------------------ 5726| 0| tok->type = TK_ANCHOR; 5727| 0| tok->u.anchor = ANCR_WORD_END; ------------------ | | 470| 0|#define ANCR_WORD_END (1<<13) ------------------ 5728| 0| break; 5729| 0|#endif 5730| | 5731| 0| case 's': ------------------ | Branch (5731:5): [True: 0, False: 0] ------------------ 5732| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_S_WHITE_SPACE)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5732:11): [True: 0, False: 0] ------------------ 5733| 0| tok->type = TK_CHAR_TYPE; 5734| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; 5735| 0| tok->u.prop.not = 0; 5736| 0| break; 5737| | 5738| 0| case 'S': ------------------ | Branch (5738:5): [True: 0, False: 0] ------------------ 5739| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_S_WHITE_SPACE)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5739:11): [True: 0, False: 0] ------------------ 5740| 0| tok->type = TK_CHAR_TYPE; 5741| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; 5742| 0| tok->u.prop.not = 1; 5743| 0| break; 5744| | 5745| 0| case 'd': ------------------ | Branch (5745:5): [True: 0, False: 0] ------------------ 5746| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_D_DIGIT)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5746:11): [True: 0, False: 0] ------------------ 5747| 0| tok->type = TK_CHAR_TYPE; 5748| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; 5749| 0| tok->u.prop.not = 0; 5750| 0| break; 5751| | 5752| 0| case 'D': ------------------ | Branch (5752:5): [True: 0, False: 0] ------------------ 5753| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_D_DIGIT)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5753:11): [True: 0, False: 0] ------------------ 5754| 0| tok->type = TK_CHAR_TYPE; 5755| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; 5756| 0| tok->u.prop.not = 1; 5757| 0| break; 5758| | 5759| 0| case 'h': ------------------ | Branch (5759:5): [True: 0, False: 0] ------------------ 5760| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5760:11): [True: 0, False: 0] ------------------ 5761| 0| tok->type = TK_CHAR_TYPE; 5762| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; 5763| 0| tok->u.prop.not = 0; 5764| 0| break; 5765| | 5766| 0| case 'H': ------------------ | Branch (5766:5): [True: 0, False: 0] ------------------ 5767| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5767:11): [True: 0, False: 0] ------------------ 5768| 0| tok->type = TK_CHAR_TYPE; 5769| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; 5770| 0| tok->u.prop.not = 1; 5771| 0| break; 5772| | 5773| 0| case 'K': ------------------ | Branch (5773:5): [True: 0, False: 0] ------------------ 5774| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5774:11): [True: 0, False: 0] ------------------ 5775| 0| tok->type = TK_KEEP; 5776| 0| break; 5777| | 5778| 0| case 'R': ------------------ | Branch (5778:5): [True: 0, False: 0] ------------------ 5779| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_R_GENERAL_NEWLINE)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5779:11): [True: 0, False: 0] ------------------ 5780| 0| tok->type = TK_GENERAL_NEWLINE; 5781| 0| break; 5782| | 5783| 0| case 'N': ------------------ | Branch (5783:5): [True: 0, False: 0] ------------------ 5784| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_N_O_SUPER_DOT)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5784:11): [True: 0, False: 0] ------------------ 5785| 0| tok->type = TK_NO_NEWLINE; 5786| 0| break; 5787| | 5788| 0| case 'O': ------------------ | Branch (5788:5): [True: 0, False: 0] ------------------ 5789| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_N_O_SUPER_DOT)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5789:11): [True: 0, False: 0] ------------------ 5790| 0| tok->type = TK_TRUE_ANYCHAR; 5791| 0| break; 5792| | 5793| 0| case 'X': ------------------ | Branch (5793:5): [True: 0, False: 0] ------------------ 5794| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5794:11): [True: 0, False: 0] ------------------ 5795| 0| tok->type = TK_TEXT_SEGMENT; 5796| 0| break; 5797| | 5798| 0| case 'A': ------------------ | Branch (5798:5): [True: 0, False: 0] ------------------ 5799| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5799:11): [True: 0, False: 0] ------------------ 5800| 0| begin_buf: 5801| 0| tok->type = TK_ANCHOR; 5802| 0| tok->u.subtype = ANCR_BEGIN_BUF; ------------------ | | 461| 0|#define ANCR_BEGIN_BUF (1<<4) ------------------ 5803| 0| break; 5804| | 5805| 0| case 'Z': ------------------ | Branch (5805:5): [True: 0, False: 0] ------------------ 5806| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_PYTHON)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 5807| 0| goto end_buf; 5808| 0| } 5809| 0| else { 5810| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5810:13): [True: 0, False: 0] ------------------ 5811| 0| tok->type = TK_ANCHOR; 5812| 0| tok->u.subtype = ANCR_SEMI_END_BUF; ------------------ | | 465| 0|#define ANCR_SEMI_END_BUF (1<<8) ------------------ 5813| 0| } 5814| 0| break; 5815| | 5816| 0| case 'z': ------------------ | Branch (5816:5): [True: 0, False: 0] ------------------ 5817| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_PYTHON)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 5818| 0| return ONIGERR_UNDEFINED_OPERATOR; ------------------ | | 624| 0|#define ONIGERR_UNDEFINED_OPERATOR -213 ------------------ 5819| | 5820| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5820:11): [True: 0, False: 0] ------------------ 5821| 0| end_buf: 5822| 0| tok->type = TK_ANCHOR; 5823| 0| tok->u.subtype = ANCR_END_BUF; ------------------ | | 464| 0|#define ANCR_END_BUF (1<<7) ------------------ 5824| 0| break; 5825| | 5826| 0| case 'G': ------------------ | Branch (5826:5): [True: 0, False: 0] ------------------ 5827| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (5827:11): [True: 0, False: 0] ------------------ 5828| 0| tok->type = TK_ANCHOR; 5829| 0| tok->u.subtype = ANCR_BEGIN_POSITION; ------------------ | | 463| 0|#define ANCR_BEGIN_POSITION (1<<6) ------------------ 5830| 0| break; 5831| | 5832| 0| case '`': ------------------ | Branch (5832:5): [True: 0, False: 0] ------------------ 5833| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5833:11): [True: 0, False: 0] ------------------ 5834| 0| goto begin_buf; 5835| 0| break; 5836| | 5837| 0| case '\'': ------------------ | Branch (5837:5): [True: 0, False: 0] ------------------ 5838| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5838:11): [True: 0, False: 0] ------------------ 5839| 0| goto end_buf; 5840| 0| break; 5841| | 5842| 0| case 'o': ------------------ | Branch (5842:5): [True: 0, False: 0] ------------------ 5843| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5844| | 5845| 0| prev = p; 5846| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5847| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5848| 0| r = scan_octal_number(&p, end, 0, 11, enc, &code); 5849| 0| if (r < 0) return r; ------------------ | Branch (5849:13): [True: 0, False: 0] ------------------ 5850| 0| if (!PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5850:13): [True: 0, False: 0] ------------------ 5851| 0| if (IS_CODE_DIGIT_ASCII(enc, PPEEK)) ------------------ | | 397| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 257| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (257:43): [True: 0, False: 0] | | | | | Branch (257:45): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 315| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | | Branch (290:69): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5852| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 623| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 5853| 0| } 5854| | 5855| 0| tok->base_num = 8; 5856| 0| goto brace_code_point_entry; 5857| 0| } 5858| 0| break; 5859| | 5860| 0| case 'x': ------------------ | Branch (5860:5): [True: 0, False: 0] ------------------ 5861| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5862| | 5863| 0| prev = p; 5864| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5865| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5866| 0| r = scan_hexadecimal_number(&p, end, 0, 8, enc, &code); 5867| 0| if (r < 0) return r; ------------------ | Branch (5867:13): [True: 0, False: 0] ------------------ 5868| 0| if (!PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5868:13): [True: 0, False: 0] ------------------ 5869| 0| if (IS_CODE_XDIGIT_ASCII(enc, PPEEK)) ------------------ | | 399| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_XDIGIT(enc,code)) | | ------------------ | | | | 257| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (257:43): [True: 0, False: 0] | | | | | Branch (257:45): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_XDIGIT(enc,code)) | | ------------------ | | | | 317| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_XDIGIT) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | | Branch (290:69): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5870| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 623| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 5871| 0| } 5872| | 5873| 0| tok->base_num = 16; 5874| 0| brace_code_point_entry: 5875| 0| if ((p > prev + enclen(enc, prev))) { ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ | Branch (5875:13): [True: 0, False: 0] ------------------ 5876| 0| if (PEND) return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 644| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ 5877| 0| if (PPEEK_IS('}')) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ 5878| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5879| 0| } 5880| 0| else { 5881| 0| r = check_code_point_sequence(p, end, tok->base_num, enc); 5882| 0| if (r < 0) return r; ------------------ | Branch (5882:17): [True: 0, False: 0] ------------------ 5883| 0| if (r == 0) return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 644| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ | Branch (5883:17): [True: 0, False: 0] ------------------ 5884| 0| tok->code_point_continue = TRUE; ------------------ | | 59| 0|#define TRUE 1 ------------------ 5885| 0| } 5886| 0| tok->type = TK_CODE_POINT; 5887| 0| tok->u.code = code; 5888| 0| } 5889| 0| else { 5890| | /* can't read nothing or invalid format */ 5891| 0| p = prev; 5892| 0| } 5893| 0| } 5894| 0| else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5895| 0| r = scan_hexadecimal_number(&p, end, 0, 2, enc, &code); 5896| 0| if (r < 0) return r; ------------------ | Branch (5896:13): [True: 0, False: 0] ------------------ 5897| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (5897:13): [True: 0, False: 0] ------------------ 5898| 0| code = 0; /* but, it's not error */ 5899| 0| } 5900| 0| tok->type = TK_CRUDE_BYTE; 5901| 0| tok->base_num = 16; 5902| 0| tok->u.byte = (UChar )code; 5903| 0| } 5904| 0| break; 5905| | 5906| 0| case 'u': ------------------ | Branch (5906:5): [True: 0, False: 0] ------------------ 5907| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5908| 0| prev = p; 5909| 0| mindigits = maxdigits = 4; 5910| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 5911| 0| u_hex_digits: 5912| 0| r = scan_hexadecimal_number(&p, end, mindigits, maxdigits, enc, &code); 5913| 0| if (r < 0) return r; ------------------ | Branch (5913:13): [True: 0, False: 0] ------------------ 5914| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (5914:13): [True: 0, False: 0] ------------------ 5915| 0| code = 0; /* but, it's not error */ 5916| 0| } 5917| 0| tok->type = TK_CODE_POINT; 5918| 0| tok->base_num = 16; 5919| 0| tok->u.code = code; 5920| 0| } 5921| 0| break; 5922| | 5923| 0| case 'U': ------------------ | Branch (5923:5): [True: 0, False: 0] ------------------ 5924| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5925| 0| prev = p; 5926| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_PYTHON)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 5927| 0| mindigits = maxdigits = 8; 5928| 0| goto u_hex_digits; 5929| 0| } 5930| 0| break; 5931| | 5932| 0| case '1': case '2': case '3': case '4': ------------------ | Branch (5932:5): [True: 0, False: 0] | Branch (5932:15): [True: 0, False: 0] | Branch (5932:25): [True: 0, False: 0] | Branch (5932:35): [True: 0, False: 0] ------------------ 5933| 0| case '5': case '6': case '7': case '8': case '9': ------------------ | Branch (5933:5): [True: 0, False: 0] | Branch (5933:15): [True: 0, False: 0] | Branch (5933:25): [True: 0, False: 0] | Branch (5933:35): [True: 0, False: 0] | Branch (5933:45): [True: 0, False: 0] ------------------ 5934| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 5935| 0| prev = p; 5936| 0| r = scan_number(&p, end, enc); 5937| 0| if (r < 0 || r > ONIG_MAX_BACKREF_NUM) { ------------------ | | 364| 0|#define ONIG_MAX_BACKREF_NUM 1000 ------------------ | Branch (5937:11): [True: 0, False: 0] | Branch (5937:20): [True: 0, False: 0] ------------------ 5938| 0| goto skip_backref; 5939| 0| } 5940| | 5941| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_DECIMAL_BACKREF) && ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5942| 0| (r <= env->num_mem || r <= 9)) { /* This spec. from GNU regex */ ------------------ | Branch (5942:12): [True: 0, False: 0] | Branch (5942:33): [True: 0, False: 0] ------------------ 5943| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 5944| 0| if (r > env->num_mem || IS_NULL(PARSEENV_MEMENV(env)[r].mem_node)) ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | | Branch (201:49): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5944:15): [True: 0, False: 0] ------------------ 5945| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 5946| 0| } 5947| | 5948| 0| tok->type = TK_BACKREF; 5949| 0| tok->u.backref.num = 1; 5950| 0| tok->u.backref.ref1 = r; 5951| 0| tok->u.backref.by_name = 0; 5952| 0|#ifdef USE_BACKREF_WITH_LEVEL 5953| 0| tok->u.backref.exist_level = 0; 5954| 0| tok->u.backref.level = 0; 5955| 0|#endif 5956| 0| break; 5957| 0| } 5958| | 5959| 0| skip_backref: 5960| 0| if (c == '8' || c == '9') { ------------------ | Branch (5960:11): [True: 0, False: 0] | Branch (5960:23): [True: 0, False: 0] ------------------ 5961| | /* normal char */ 5962| 0| p = prev; PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5963| 0| break; 5964| 0| } 5965| | 5966| 0| p = prev; 5967| | /* fall through */ 5968| 0| case '0': ------------------ | Branch (5968:5): [True: 0, False: 0] ------------------ 5969| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5970| 0| prev = p; 5971| 0| r = scan_octal_number(&p, end, 0, (c == '0' ? 2:3), enc, &code); ------------------ | Branch (5971:44): [True: 0, False: 0] ------------------ 5972| 0| if (r < 0 || r >= 256) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 612| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (5972:13): [True: 0, False: 0] | Branch (5972:22): [True: 0, False: 0] ------------------ 5973| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (5973:13): [True: 0, False: 0] ------------------ 5974| 0| code = 0; /* but, it's not error */ 5975| 0| } 5976| 0| tok->type = TK_CRUDE_BYTE; 5977| 0| tok->base_num = 8; 5978| 0| tok->u.byte = (UChar )code; 5979| 0| } 5980| 0| else if (c != '0') { ------------------ | Branch (5980:16): [True: 0, False: 0] ------------------ 5981| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5982| 0| } 5983| 0| break; 5984| | 5985| 0| case 'k': ------------------ | Branch (5985:5): [True: 0, False: 0] ------------------ 5986| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF)) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5986:11): [True: 0, False: 0] ------------------ 5987| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 5988| 0| if (c == '<' || c == '\'') { ------------------ | Branch (5988:13): [True: 0, False: 0] | Branch (5988:25): [True: 0, False: 0] ------------------ 5989| 0| UChar* name_end; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 5990| 0| int* backs; 5991| 0| int back_num; 5992| 0| enum REF_NUM num_type; 5993| | 5994| 0| allow_num = 1; 5995| | 5996| 0| backref_start: 5997| 0| prev = p; 5998| | 5999| 0|#ifdef USE_BACKREF_WITH_LEVEL 6000| 0| name_end = NULL_UCHARP; /* no need. escape gcc warning. */ ------------------ | | 205| 0|#define NULL_UCHARP ((UChar* )0) ------------------ 6001| 0| r = fetch_name_with_level((OnigCodePoint )c, &p, end, &name_end, 6002| 0| env, &back_num, &tok->u.backref.level, &num_type); 6003| 0| if (r == 1) tok->u.backref.exist_level = 1; ------------------ | Branch (6003:15): [True: 0, False: 0] ------------------ 6004| 0| else tok->u.backref.exist_level = 0; 6005| |#else 6006| | r = fetch_name(c, &p, end, &name_end, env, &back_num, &num_type, TRUE); 6007| |#endif 6008| 0| if (r < 0) return r; ------------------ | Branch (6008:15): [True: 0, False: 0] ------------------ 6009| | 6010| 0| if (num_type != IS_NOT_NUM) { ------------------ | Branch (6010:15): [True: 0, False: 0] ------------------ 6011| 0| if (allow_num == 0) return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ | Branch (6011:17): [True: 0, False: 0] ------------------ 6012| | 6013| 0| if (num_type == IS_REL_NUM) { ------------------ | Branch (6013:17): [True: 0, False: 0] ------------------ 6014| 0| back_num = backref_rel_to_abs(back_num, env); 6015| 0| } 6016| 0| if (back_num <= 0) ------------------ | Branch (6016:17): [True: 0, False: 0] ------------------ 6017| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 6018| | 6019| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 6020| 0| if (back_num > env->num_mem || ------------------ | Branch (6020:19): [True: 0, False: 0] ------------------ 6021| 0| IS_NULL(PARSEENV_MEMENV(env)[back_num].mem_node)) ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | | Branch (201:49): [True: 0, False: 0] | | ------------------ ------------------ 6022| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 6023| 0| } 6024| 0| tok->type = TK_BACKREF; 6025| 0| tok->u.backref.by_name = 0; 6026| 0| tok->u.backref.num = 1; 6027| 0| tok->u.backref.ref1 = back_num; 6028| 0| } 6029| 0| else { 6030| 0| int num = name_to_group_numbers(env, prev, name_end, &backs); 6031| 0| if (num <= 0) { ------------------ | Branch (6031:17): [True: 0, False: 0] ------------------ 6032| 0| return ONIGERR_UNDEFINED_NAME_REFERENCE; ------------------ | | 628| 0|#define ONIGERR_UNDEFINED_NAME_REFERENCE -217 ------------------ 6033| 0| } 6034| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 6035| 0| int i; 6036| 0| for (i = 0; i < num; i++) { ------------------ | Branch (6036:27): [True: 0, False: 0] ------------------ 6037| 0| if (backs[i] > env->num_mem || ------------------ | Branch (6037:21): [True: 0, False: 0] ------------------ 6038| 0| IS_NULL(PARSEENV_MEMENV(env)[backs[i]].mem_node)) ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | | Branch (201:49): [True: 0, False: 0] | | ------------------ ------------------ 6039| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 6040| 0| } 6041| 0| } 6042| | 6043| 0| tok->type = TK_BACKREF; 6044| 0| tok->u.backref.by_name = 1; 6045| 0| if (num == 1) { ------------------ | Branch (6045:17): [True: 0, False: 0] ------------------ 6046| 0| tok->u.backref.num = 1; 6047| 0| tok->u.backref.ref1 = backs[0]; 6048| 0| } 6049| 0| else { 6050| 0| tok->u.backref.num = num; 6051| 0| tok->u.backref.refs = backs; 6052| 0| } 6053| 0| } 6054| 0| } 6055| 0| else 6056| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 6057| 0| } 6058| 0| break; 6059| | 6060| 0|#ifdef USE_CALL 6061| 0| case 'g': ------------------ | Branch (6061:5): [True: 0, False: 0] ------------------ 6062| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL)) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6062:11): [True: 0, False: 0] ------------------ 6063| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 6064| 0| if (c == '<' || c == '\'') { ------------------ | Branch (6064:13): [True: 0, False: 0] | Branch (6064:25): [True: 0, False: 0] ------------------ 6065| 0| int gnum; 6066| 0| UChar* name_end; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 6067| 0| enum REF_NUM num_type; 6068| | 6069| 0| allow_num = 1; 6070| | 6071| 0| call_start: 6072| 0| prev = p; 6073| 0| r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, 6074| 0| &gnum, &num_type, TRUE); ------------------ | | 59| 0|#define TRUE 1 ------------------ 6075| 0| if (r < 0) return r; ------------------ | Branch (6075:15): [True: 0, False: 0] ------------------ 6076| | 6077| 0| if (num_type != IS_NOT_NUM) { ------------------ | Branch (6077:15): [True: 0, False: 0] ------------------ 6078| 0| if (allow_num == 0) return ONIGERR_UNDEFINED_GROUP_REFERENCE; ------------------ | | 629| 0|#define ONIGERR_UNDEFINED_GROUP_REFERENCE -218 ------------------ | Branch (6078:17): [True: 0, False: 0] ------------------ 6079| | 6080| 0| if (num_type == IS_REL_NUM) { ------------------ | Branch (6080:17): [True: 0, False: 0] ------------------ 6081| 0| gnum = backref_rel_to_abs(gnum, env); 6082| 0| if (gnum < 0) { ------------------ | Branch (6082:19): [True: 0, False: 0] ------------------ 6083| 0| onig_scan_env_set_error_string(env, ONIGERR_UNDEFINED_NAME_REFERENCE, ------------------ | | 628| 0|#define ONIGERR_UNDEFINED_NAME_REFERENCE -217 ------------------ 6084| 0| prev, name_end); 6085| 0| return ONIGERR_UNDEFINED_GROUP_REFERENCE; ------------------ | | 629| 0|#define ONIGERR_UNDEFINED_GROUP_REFERENCE -218 ------------------ 6086| 0| } 6087| 0| } 6088| 0| tok->u.call.by_number = 1; 6089| 0| tok->u.call.gnum = gnum; 6090| 0| } 6091| 0| else { 6092| 0| tok->u.call.by_number = 0; 6093| 0| tok->u.call.gnum = 0; 6094| 0| } 6095| | 6096| 0| tok->type = TK_CALL; 6097| 0| tok->u.call.name = prev; 6098| 0| tok->u.call.name_end = name_end; 6099| 0| } 6100| 0| else 6101| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 6102| 0| } 6103| 0| break; 6104| 0|#endif 6105| | 6106| 0| case 'Q': ------------------ | Branch (6106:5): [True: 0, False: 0] ------------------ 6107| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 6108| 0| tok->type = TK_QUOTE_OPEN; 6109| 0| } 6110| 0| break; 6111| | 6112| 0| case 'p': ------------------ | Branch (6112:5): [True: 0, False: 0] ------------------ 6113| 0| case 'P': ------------------ | Branch (6113:5): [True: 0, False: 0] ------------------ 6114| 0| if (!PEND && PPEEK_IS('{') && ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && PPEEK_IS('{') && ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6114:11): [True: 0, False: 0] ------------------ 6115| 0| IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 6116| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 6117| 0| tok->type = TK_CHAR_PROPERTY; 6118| 0| tok->u.prop.not = c == 'P'; 6119| | 6120| 0| if (!PEND && ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6120:13): [True: 0, False: 0] ------------------ 6121| 0| IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 6122| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 6123| 0| if (c == '^') { ------------------ | Branch (6123:15): [True: 0, False: 0] ------------------ 6124| 0| tok->u.prop.not = tok->u.prop.not == 0; 6125| 0| } 6126| 0| else 6127| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 6128| 0| } 6129| 0| } 6130| 0| break; 6131| | 6132| 0| default: ------------------ | Branch (6132:5): [True: 0, False: 0] ------------------ 6133| 0| { 6134| 0| OnigCodePoint c2; 6135| | 6136| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 6137| 0| r = fetch_escaped_value(&p, end, env, &c2); 6138| 0| if (r < 0) return r; ------------------ | Branch (6138:13): [True: 0, False: 0] ------------------ 6139| 0| if (tok->u.code != c2) { ------------------ | Branch (6139:13): [True: 0, False: 0] ------------------ 6140| 0| tok->type = TK_CODE_POINT; 6141| 0| tok->u.code = c2; 6142| 0| } 6143| 0| else { /* string */ 6144| 0| p = tok->backp + enclen(enc, tok->backp); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 6145| 0| } 6146| 0| } 6147| 0| break; 6148| 0| } 6149| 0| } 6150| 139k| else { 6151| 139k| tok->u.code = c; 6152| 139k| tok->escaped = 0; 6153| | 6154| 139k|#ifdef USE_VARIABLE_META_CHARS 6155| 139k| if ((c != ONIG_INEFFECTIVE_META_CHAR) && ------------------ | | 557| 139k|#define ONIG_INEFFECTIVE_META_CHAR 0 ------------------ | Branch (6155:9): [True: 139k, False: 0] ------------------ 6156| 139k| IS_SYNTAX_OP(syn, ONIG_SYN_OP_VARIABLE_META_CHARACTERS)) { ------------------ | | 405| 139k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 139k] | | ------------------ ------------------ 6157| 0| if (c == MC_ANYCHAR(syn)) ------------------ | | 688| 0|#define MC_ANYCHAR(syn) (syn)->meta_char_table.anychar ------------------ | Branch (6157:11): [True: 0, False: 0] ------------------ 6158| 0| goto any_char; 6159| 0| else if (c == MC_ANYTIME(syn)) ------------------ | | 689| 0|#define MC_ANYTIME(syn) (syn)->meta_char_table.anytime ------------------ | Branch (6159:16): [True: 0, False: 0] ------------------ 6160| 0| goto any_time; 6161| 0| else if (c == MC_ZERO_OR_ONE_TIME(syn)) ------------------ | | 690| 0|#define MC_ZERO_OR_ONE_TIME(syn) (syn)->meta_char_table.zero_or_one_time ------------------ | Branch (6161:16): [True: 0, False: 0] ------------------ 6162| 0| goto zero_or_one_time; 6163| 0| else if (c == MC_ONE_OR_MORE_TIME(syn)) ------------------ | | 691| 0|#define MC_ONE_OR_MORE_TIME(syn) (syn)->meta_char_table.one_or_more_time ------------------ | Branch (6163:16): [True: 0, False: 0] ------------------ 6164| 0| goto one_or_more_time; 6165| 0| else if (c == MC_ANYCHAR_ANYTIME(syn)) { ------------------ | | 692| 0|#define MC_ANYCHAR_ANYTIME(syn) (syn)->meta_char_table.anychar_anytime ------------------ | Branch (6165:16): [True: 0, False: 0] ------------------ 6166| 0| tok->type = TK_ANYCHAR_ANYTIME; 6167| 0| goto out; 6168| 0| } 6169| 0| } 6170| 139k|#endif 6171| | 6172| 139k| switch (c) { 6173| 562| case '.': ------------------ | Branch (6173:5): [True: 562, False: 139k] ------------------ 6174| 562| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_DOT_ANYCHAR)) break; ------------------ | | 405| 562|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6174:11): [True: 0, False: 562] ------------------ 6175| 562|#ifdef USE_VARIABLE_META_CHARS 6176| 562| any_char: 6177| 562|#endif 6178| 562| tok->type = TK_ANYCHAR; 6179| 562| break; 6180| | 6181| 39.0k| case '*': ------------------ | Branch (6181:5): [True: 39.0k, False: 100k] ------------------ 6182| 39.0k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ASTERISK_ZERO_INF)) break; ------------------ | | 405| 39.0k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6182:11): [True: 0, False: 39.0k] ------------------ 6183| 39.0k|#ifdef USE_VARIABLE_META_CHARS 6184| 39.0k| any_time: 6185| 39.0k|#endif 6186| 39.0k| tok->type = TK_REPEAT; 6187| 39.0k| tok->u.repeat.lower = 0; 6188| 39.0k| tok->u.repeat.upper = INFINITE_REPEAT; ------------------ | | 427| 39.0k|#define INFINITE_REPEAT -1 ------------------ 6189| 39.0k| goto greedy_check; 6190| 0| break; 6191| | 6192| 7.25k| case '+': ------------------ | Branch (6192:5): [True: 7.25k, False: 132k] ------------------ 6193| 7.25k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_PLUS_ONE_INF)) break; ------------------ | | 405| 7.25k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6193:11): [True: 0, False: 7.25k] ------------------ 6194| 7.25k|#ifdef USE_VARIABLE_META_CHARS 6195| 7.25k| one_or_more_time: 6196| 7.25k|#endif 6197| 7.25k| tok->type = TK_REPEAT; 6198| 7.25k| tok->u.repeat.lower = 1; 6199| 7.25k| tok->u.repeat.upper = INFINITE_REPEAT; ------------------ | | 427| 7.25k|#define INFINITE_REPEAT -1 ------------------ 6200| 7.25k| goto greedy_check; 6201| 0| break; 6202| | 6203| 56| case '?': ------------------ | Branch (6203:5): [True: 56, False: 139k] ------------------ 6204| 56| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_ZERO_ONE)) break; ------------------ | | 405| 56|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6204:11): [True: 0, False: 56] ------------------ 6205| 56|#ifdef USE_VARIABLE_META_CHARS 6206| 56| zero_or_one_time: 6207| 56|#endif 6208| 56| tok->type = TK_REPEAT; 6209| 56| tok->u.repeat.lower = 0; 6210| 56| tok->u.repeat.upper = 1; 6211| 56| goto greedy_check; 6212| 0| break; 6213| | 6214| 0| case '{': ------------------ | Branch (6214:5): [True: 0, False: 139k] ------------------ 6215| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_BRACE_INTERVAL)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6215:11): [True: 0, False: 0] ------------------ 6216| 0| r = fetch_interval(&p, end, tok, env); 6217| 0| if (r < 0) return r; /* error */ ------------------ | Branch (6217:11): [True: 0, False: 0] ------------------ 6218| 0| if (r == 0) goto greedy_check2; ------------------ | Branch (6218:11): [True: 0, False: 0] ------------------ 6219| 0| else if (r == 2) { /* {n} */ ------------------ | Branch (6219:16): [True: 0, False: 0] ------------------ 6220| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 6221| 0| goto possessive_check; 6222| | 6223| 0| goto greedy_check2; 6224| 0| } 6225| | /* r == 1 : normal char */ 6226| 0| break; 6227| | 6228| 0| case '|': ------------------ | Branch (6228:5): [True: 0, False: 139k] ------------------ 6229| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_VBAR_ALT)) break; ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6229:11): [True: 0, False: 0] ------------------ 6230| 0| tok->type = TK_ALT; 6231| 0| break; 6232| | 6233| 814| case '(': ------------------ | Branch (6233:5): [True: 814, False: 139k] ------------------ 6234| 814| if (!PEND && PPEEK_IS('?') && ------------------ | | 487| 1.62k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 814, False: 0] | | ------------------ ------------------ if (!PEND && PPEEK_IS('?') && ------------------ | | 509| 1.62k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 814|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 814|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 814, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 678, False: 136] | | ------------------ ------------------ | Branch (6234:11): [True: 814, False: 0] ------------------ 6235| 678| IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) { ------------------ | | 406| 678|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 678, False: 0] | | ------------------ ------------------ 6236| 678| prev = p; 6237| 678| PINC; ------------------ | | 490| 678|#define PINC do { \ | | 491| 678| pfetch_prev = p; \ | | 492| 678| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 678|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 678|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 678] | | ------------------ ------------------ 6238| 678| if (! PEND) { ------------------ | | 487| 678|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 678, False: 0] | | ------------------ ------------------ | Branch (6238:13): [True: 678, False: 0] ------------------ 6239| 678| c = PPEEK; ------------------ | | 508| 678|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 284| 678|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 484| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (508:23): [True: 678, False: 0] | | ------------------ ------------------ 6240| 678| if (c == '#') { ------------------ | Branch (6240:15): [True: 0, False: 678] ------------------ 6241| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 6242| 0| while (1) { ------------------ | Branch (6242:20): [True: 0, Folded] ------------------ 6243| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 6244| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 6245| 0| if (c == MC_ESC(syn)) { ------------------ | | 687| 0|#define MC_ESC(syn) (syn)->meta_char_table.esc ------------------ | Branch (6245:19): [True: 0, False: 0] ------------------ 6246| 0| if (! PEND) PFETCH(c); ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (! PEND) PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ | Branch (6246:21): [True: 0, False: 0] ------------------ 6247| 0| } 6248| 0| else { 6249| 0| if (c == ')') break; ------------------ | Branch (6249:21): [True: 0, False: 0] ------------------ 6250| 0| } 6251| 0| } 6252| 0| goto start; 6253| 0| } 6254| 678| else if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_QMARK_PERL_SUBEXP_CALL)) { ------------------ | | 406| 678|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 678, False: 0] | | ------------------ ------------------ 6255| 678| int gnum; 6256| 678| UChar* name; ------------------ | | 80| 678|#define UChar OnigUChar ------------------ 6257| 678| UChar* name_end; ------------------ | | 80| 678|#define UChar OnigUChar ------------------ 6258| 678| enum REF_NUM num_type; 6259| | 6260| 678| switch (c) { 6261| 0| case '&': ------------------ | Branch (6261:13): [True: 0, False: 678] ------------------ 6262| 0| { 6263| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 6264| 0| name = p; 6265| 0| r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, 6266| 0| &gnum, &num_type, FALSE); ------------------ | | 63| 0|#define FALSE 0 ------------------ 6267| 0| if (r < 0) return r; ------------------ | Branch (6267:21): [True: 0, False: 0] ------------------ 6268| | 6269| 0| tok->type = TK_CALL; 6270| 0| tok->u.call.by_number = 0; 6271| 0| tok->u.call.gnum = 0; 6272| 0| tok->u.call.name = name; 6273| 0| tok->u.call.name_end = name_end; 6274| 0| } 6275| 0| break; 6276| | 6277| 0| case 'R': ------------------ | Branch (6277:13): [True: 0, False: 678] ------------------ 6278| 0| tok->type = TK_CALL; 6279| 0| tok->u.call.by_number = 1; 6280| 0| tok->u.call.gnum = 0; 6281| 0| tok->u.call.name = p; 6282| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 6283| 0| if (! PPEEK_IS(')')) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ if (! PPEEK_IS(')')) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ | Branch (6283:19): [True: 0, False: 0] ------------------ 6284| 0| tok->u.call.name_end = p; 6285| 0| break; 6286| | 6287| 0| case '-': ------------------ | Branch (6287:13): [True: 0, False: 678] ------------------ 6288| 0| case '+': ------------------ | Branch (6288:13): [True: 0, False: 678] ------------------ 6289| 0| if (! PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6289:19): [True: 0, False: 0] ------------------ 6290| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 6291| 0| if (! PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6291:21): [True: 0, False: 0] ------------------ 6292| 0| c = PPEEK; ------------------ | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 484| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (508:23): [True: 0, False: 0] | | ------------------ ------------------ 6293| 0| if (ONIGENC_IS_CODE_DIGIT(enc, c)) { ------------------ | | 315| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | ------------------ | | | | | Branch (290:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 6294| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 6295| 0| goto lparen_qmark_num; 6296| 0| } 6297| 0| } 6298| 0| } 6299| 0| p = prev; 6300| 0| goto lparen_qmark_end2; 6301| 0| break; 6302| | 6303| 678| default: ------------------ | Branch (6303:13): [True: 678, False: 0] ------------------ 6304| 678| if (! ONIGENC_IS_CODE_DIGIT(enc, c)) goto lparen_qmark_end; ------------------ | | 315| 678| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 290| 678|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | ------------------ ------------------ | Branch (6304:19): [True: 678, False: 0] ------------------ 6305| | 6306| 0| lparen_qmark_num: 6307| 0| { 6308| 0| name = p; 6309| 0| r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, 6310| 0| &gnum, &num_type, TRUE); ------------------ | | 59| 0|#define TRUE 1 ------------------ 6311| 0| if (r < 0) return r; ------------------ | Branch (6311:21): [True: 0, False: 0] ------------------ 6312| | 6313| 0| if (num_type == IS_NOT_NUM) { ------------------ | Branch (6313:21): [True: 0, False: 0] ------------------ 6314| 0| return ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 6315| 0| } 6316| 0| else { 6317| 0| if (num_type == IS_REL_NUM) { ------------------ | Branch (6317:23): [True: 0, False: 0] ------------------ 6318| 0| gnum = backref_rel_to_abs(gnum, env); 6319| 0| if (gnum < 0) { ------------------ | Branch (6319:25): [True: 0, False: 0] ------------------ 6320| 0| onig_scan_env_set_error_string(env, 6321| 0| ONIGERR_UNDEFINED_NAME_REFERENCE, name, name_end); ------------------ | | 628| 0|#define ONIGERR_UNDEFINED_NAME_REFERENCE -217 ------------------ 6322| 0| return ONIGERR_UNDEFINED_GROUP_REFERENCE; ------------------ | | 629| 0|#define ONIGERR_UNDEFINED_GROUP_REFERENCE -218 ------------------ 6323| 0| } 6324| 0| } 6325| 0| tok->u.call.by_number = 1; 6326| 0| tok->u.call.gnum = gnum; 6327| 0| } 6328| | 6329| 0| tok->type = TK_CALL; 6330| 0| tok->u.call.name = name; 6331| 0| tok->u.call.name_end = name_end; 6332| 0| } 6333| 0| break; 6334| 678| } 6335| 0| break; 6336| 678| } 6337| 0| else if (c == 'P' && ------------------ | Branch (6337:20): [True: 0, False: 0] ------------------ 6338| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_CAPITAL_P_NAME)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 6339| 0| PINC; /* skip 'P' */ ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 6340| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 6341| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 6342| 0| allow_num = 0; 6343| 0| if (c == '=') { ------------------ | Branch (6343:17): [True: 0, False: 0] ------------------ 6344| 0| c = '('; 6345| 0| goto backref_start; 6346| 0| } 6347| 0| else if (c == '>') { ------------------ | Branch (6347:22): [True: 0, False: 0] ------------------ 6348| 0|#ifdef USE_CALL 6349| 0| c = '('; 6350| 0| goto call_start; 6351| |#else 6352| | return ONIGERR_UNDEFINED_OPERATOR; 6353| |#endif 6354| 0| } 6355| 0| else { 6356| 0| p = prev; 6357| 0| goto lparen_qmark_end2; 6358| 0| } 6359| 0| } 6360| 678| } 6361| 678| lparen_qmark_end: 6362| 678| PUNFETCH; ------------------ | | 488| 678|#define PUNFETCH p = pfetch_prev ------------------ 6363| 678| } 6364| | 6365| 814| lparen_qmark_end2: 6366| 814| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LPAREN_SUBEXP)) break; ------------------ | | 405| 814|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6366:11): [True: 0, False: 814] ------------------ 6367| 814| tok->type = TK_SUBEXP_OPEN; 6368| 814| break; 6369| | 6370| 814| case ')': ------------------ | Branch (6370:5): [True: 814, False: 139k] ------------------ 6371| 814| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LPAREN_SUBEXP)) break; ------------------ | | 405| 814|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6371:11): [True: 0, False: 814] ------------------ 6372| 814| tok->type = TK_SUBEXP_CLOSE; 6373| 814| break; 6374| | 6375| 3.06k| case '^': ------------------ | Branch (6375:5): [True: 3.06k, False: 136k] ------------------ 6376| 3.06k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break; ------------------ | | 405| 3.06k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6376:11): [True: 0, False: 3.06k] ------------------ 6377| 3.06k| if (IS_SYNTAX_BV(syn, ONIG_SYN_BRE_ANCHOR_AT_EDGE_OF_SUBEXP)) { ------------------ | | 407| 3.06k|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 3.06k] | | ------------------ ------------------ 6378| 0| if (! is_head_of_bre_subexp(PPREV, end, enc, env)) break; ------------------ | | 489| 0|#define PPREV pfetch_prev ------------------ | Branch (6378:13): [True: 0, False: 0] ------------------ 6379| 0| } 6380| 3.06k| tok->type = TK_ANCHOR; 6381| 3.06k| tok->u.subtype = (OPTON_SINGLELINE(env->options) ------------------ | | 50| 3.06k|#define OPTON_SINGLELINE(option) ((option) & ONIG_OPTION_SINGLELINE) | | ------------------ | | | | 380| 3.06k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | ------------------ | | | | | | 379| 3.06k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | ------------------ | | | | | | | | 378| 3.06k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | ------------------ | | | | | | | | | | 377| 3.06k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (50:38): [True: 3.06k, False: 0] | | ------------------ ------------------ 6382| 3.06k| ? ANCR_BEGIN_BUF : ANCR_BEGIN_LINE); ------------------ | | 461| 3.06k|#define ANCR_BEGIN_BUF (1<<4) ------------------ ? ANCR_BEGIN_BUF : ANCR_BEGIN_LINE); ------------------ | | 462| 0|#define ANCR_BEGIN_LINE (1<<5) ------------------ 6383| 3.06k| break; 6384| | 6385| 42| case '$': ------------------ | Branch (6385:5): [True: 42, False: 139k] ------------------ 6386| 42| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break; ------------------ | | 405| 42|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6386:11): [True: 0, False: 42] ------------------ 6387| 42| if (IS_SYNTAX_BV(syn, ONIG_SYN_BRE_ANCHOR_AT_EDGE_OF_SUBEXP)) { ------------------ | | 407| 42|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 42] | | ------------------ ------------------ 6388| 0| if (! is_end_of_bre_subexp(p, end, enc, env)) break; ------------------ | Branch (6388:13): [True: 0, False: 0] ------------------ 6389| 0| } 6390| 42| tok->type = TK_ANCHOR; 6391| 42| tok->u.subtype = (OPTON_SINGLELINE(env->options) ------------------ | | 50| 42|#define OPTON_SINGLELINE(option) ((option) & ONIG_OPTION_SINGLELINE) | | ------------------ | | | | 380| 42|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | ------------------ | | | | | | 379| 42|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | ------------------ | | | | | | | | 378| 42|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | ------------------ | | | | | | | | | | 377| 42|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (50:38): [True: 42, False: 0] | | ------------------ ------------------ 6392| 42| ? ANCR_SEMI_END_BUF : ANCR_END_LINE); ------------------ | | 465| 42|#define ANCR_SEMI_END_BUF (1<<8) ------------------ ? ANCR_SEMI_END_BUF : ANCR_END_LINE); ------------------ | | 466| 0|#define ANCR_END_LINE (1<<9) ------------------ 6393| 42| break; 6394| | 6395| 391| case '[': ------------------ | Branch (6395:5): [True: 391, False: 139k] ------------------ 6396| 391| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_BRACKET_CC)) break; ------------------ | | 405| 391|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (6396:11): [True: 0, False: 391] ------------------ 6397| 391| tok->type = TK_OPEN_CC; 6398| 391| break; 6399| | 6400| 0| case ']': ------------------ | Branch (6400:5): [True: 0, False: 139k] ------------------ 6401| 0| if (*src > env->pattern) /* /].../ is allowed. */ ------------------ | Branch (6401:11): [True: 0, False: 0] ------------------ 6402| 0| CLOSE_BRACKET_WITHOUT_ESC_WARN(env, (UChar* )"]"); 6403| 0| break; 6404| | 6405| 1| case '#': ------------------ | Branch (6405:5): [True: 1, False: 139k] ------------------ 6406| 1| if (OPTON_EXTEND(env->options)) { ------------------ | | 53| 1|#define OPTON_EXTEND(option) ((option) & ONIG_OPTION_EXTEND) | | ------------------ | | | | 378| 1|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | ------------------ | | | | | | 377| 1|#define ONIG_OPTION_IGNORECASE 1U | | | | ------------------ | | ------------------ | | | Branch (53:38): [True: 1, False: 0] | | ------------------ ------------------ 6407| 20| while (!PEND) { ------------------ | | 487| 20|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 19, False: 1] | | ------------------ ------------------ | Branch (6407:16): [True: 19, False: 1] ------------------ 6408| 19| PFETCH(c); ------------------ | | 494| 19|#define PFETCH(c) do { \ | | 495| 19| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 19|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 19| pfetch_prev = p; \ | | 497| 19| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 19|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 19|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 19] | | ------------------ ------------------ 6409| 19| if (ONIGENC_IS_CODE_NEWLINE(enc, c)) ------------------ | | 293| 19| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_NEWLINE) | | ------------------ | | | | 290| 19|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | ------------------ | | | | | Branch (290:48): [True: 0, False: 19] | | | | ------------------ | | ------------------ ------------------ 6410| 0| break; 6411| 19| } 6412| 1| goto start; 6413| 0| break; 6414| 1| } 6415| 0| break; 6416| | 6417| 41.0k| case ' ': case '\t': case '\n': case '\r': case '\f': ------------------ | Branch (6417:5): [True: 41.0k, False: 98.8k] | Branch (6417:15): [True: 0, False: 139k] | Branch (6417:26): [True: 0, False: 139k] | Branch (6417:37): [True: 0, False: 139k] | Branch (6417:48): [True: 0, False: 139k] ------------------ 6418| 41.0k| if (OPTON_EXTEND(env->options)) ------------------ | | 53| 41.0k|#define OPTON_EXTEND(option) ((option) & ONIG_OPTION_EXTEND) | | ------------------ | | | | 378| 41.0k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | ------------------ | | | | | | 377| 41.0k|#define ONIG_OPTION_IGNORECASE 1U | | | | ------------------ | | ------------------ | | | Branch (53:38): [True: 3, False: 41.0k] | | ------------------ ------------------ 6419| 3| goto start; 6420| 41.0k| break; 6421| | 6422| 46.7k| default: ------------------ | Branch (6422:5): [True: 46.7k, False: 93.1k] ------------------ 6423| | /* string */ 6424| 46.7k| break; 6425| 139k| } 6426| 139k| } 6427| | 6428| 139k| out: 6429| 139k| *src = p; 6430| 139k| return tok->type; 6431| 139k|} regparse.c:get_name_end_code_point: 4819| 665|{ 4820| 665| switch (start) { 4821| 665| case '<': return (OnigCodePoint )'>'; break; ------------------ | Branch (4821:3): [True: 665, False: 0] ------------------ 4822| 0| case '\'': return (OnigCodePoint )'\''; break; ------------------ | Branch (4822:3): [True: 0, False: 665] ------------------ 4823| 0| case '(': return (OnigCodePoint )')'; break; ------------------ | Branch (4823:3): [True: 0, False: 665] ------------------ 4824| 0| default: ------------------ | Branch (4824:3): [True: 0, False: 665] ------------------ 4825| 0| break; 4826| 665| } 4827| | 4828| 0| return (OnigCodePoint )0; 4829| 665|} regparse.c:fetch_name: 4986| 665|{ 4987| 665| int r, sign; 4988| 665| int digit_count; 4989| 665| OnigCodePoint end_code; 4990| 665| OnigCodePoint c = 0; 4991| 665| OnigEncoding enc = env->enc; 4992| 665| UChar *name_end; ------------------ | | 80| 665|#define UChar OnigUChar ------------------ 4993| 665| UChar *pnum_head; ------------------ | | 80| 665|#define UChar OnigUChar ------------------ 4994| 665| UChar *p = *src; ------------------ | | 80| 665|#define UChar OnigUChar ------------------ 4995| | 4996| 665| *rback_num = 0; 4997| | 4998| 665| end_code = get_name_end_code_point(start_code); 4999| | 5000| 665| digit_count = 0; 5001| 665| name_end = end; 5002| 665| pnum_head = *src; 5003| 665| r = 0; 5004| 665| *num_type = IS_NOT_NUM; 5005| 665| sign = 1; 5006| 665| if (PEND) { ------------------ | | 487| 665|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 665] | | | Branch (487:23): [True: 665, False: 0] | | ------------------ ------------------ 5007| 0| return ONIGERR_EMPTY_GROUP_NAME; ------------------ | | 625| 0|#define ONIGERR_EMPTY_GROUP_NAME -214 ------------------ 5008| 0| } 5009| 665| else { 5010| 665| PFETCH_S(c); ------------------ | | 503| 665|#define PFETCH_S(c) do { \ | | 504| 665| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 665|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 505| 665| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 665|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 506| 665|} while (0) | | ------------------ | | | Branch (506:10): [Folded, False: 665] | | ------------------ ------------------ 5011| 665| if (c == end_code) ------------------ | Branch (5011:9): [True: 0, False: 665] ------------------ 5012| 0| return ONIGERR_EMPTY_GROUP_NAME; ------------------ | | 625| 0|#define ONIGERR_EMPTY_GROUP_NAME -214 ------------------ 5013| | 5014| 665| if (IS_CODE_DIGIT_ASCII(enc, c)) { ------------------ | | 397| 665| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 257| 1.33k|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (257:43): [True: 665, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 315| 665| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | | | ------------------ | | | | | | 290| 665|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 665] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5015| 0| if (is_ref == TRUE) ------------------ | | 59| 0|#define TRUE 1 ------------------ | Branch (5015:11): [True: 0, False: 0] ------------------ 5016| 0| *num_type = IS_ABS_NUM; 5017| 0| else { 5018| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 5019| 0| } 5020| 0| digit_count++; 5021| 0| } 5022| 665| else if (c == '-') { ------------------ | Branch (5022:14): [True: 0, False: 665] ------------------ 5023| 0| if (is_ref == TRUE) { ------------------ | | 59| 0|#define TRUE 1 ------------------ | Branch (5023:11): [True: 0, False: 0] ------------------ 5024| 0| *num_type = IS_REL_NUM; 5025| 0| sign = -1; 5026| 0| pnum_head = p; 5027| 0| } 5028| 0| else { 5029| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 5030| 0| } 5031| 0| } 5032| 665| else if (c == '+') { ------------------ | Branch (5032:14): [True: 0, False: 665] ------------------ 5033| 0| if (is_ref == TRUE) { ------------------ | | 59| 0|#define TRUE 1 ------------------ | Branch (5033:11): [True: 0, False: 0] ------------------ 5034| 0| *num_type = IS_REL_NUM; 5035| 0| sign = 1; 5036| 0| pnum_head = p; 5037| 0| } 5038| 0| else { 5039| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 5040| 0| } 5041| 0| } 5042| 665| else if (!ONIGENC_IS_CODE_WORD(enc, c)) { ------------------ | | 319| 665| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 290| 665|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | ------------------ ------------------ | Branch (5042:14): [True: 0, False: 665] ------------------ 5043| 0| r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME; ------------------ | | 627| 0|#define ONIGERR_INVALID_CHAR_IN_GROUP_NAME -216 ------------------ 5044| 0| } 5045| 665| } 5046| | 5047| 665| if (r == 0) { ------------------ | Branch (5047:7): [True: 665, False: 0] ------------------ 5048| 954| while (!PEND) { ------------------ | | 487| 954|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 954, False: 0] | | ------------------ ------------------ | Branch (5048:12): [True: 954, False: 0] ------------------ 5049| 954| name_end = p; 5050| 954| PFETCH_S(c); ------------------ | | 503| 954|#define PFETCH_S(c) do { \ | | 504| 954| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 954|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 505| 954| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 954|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 506| 954|} while (0) | | ------------------ | | | Branch (506:10): [Folded, False: 954] | | ------------------ ------------------ 5051| 954| if (c == end_code || c == ')') { ------------------ | Branch (5051:11): [True: 665, False: 289] | Branch (5051:28): [True: 0, False: 289] ------------------ 5052| 665| if (*num_type != IS_NOT_NUM && digit_count == 0) ------------------ | Branch (5052:13): [True: 0, False: 665] | Branch (5052:40): [True: 0, False: 0] ------------------ 5053| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 5054| 665| break; 5055| 665| } 5056| | 5057| 289| if (*num_type != IS_NOT_NUM) { ------------------ | Branch (5057:11): [True: 0, False: 289] ------------------ 5058| 0| if (IS_CODE_DIGIT_ASCII(enc, c)) { ------------------ | | 397| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 257| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (257:43): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 315| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5059| 0| digit_count++; 5060| 0| } 5061| 0| else { 5062| 0| if (!ONIGENC_IS_CODE_WORD(enc, c)) ------------------ | | 319| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | ------------------ ------------------ | Branch (5062:15): [True: 0, False: 0] ------------------ 5063| 0| r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME; ------------------ | | 627| 0|#define ONIGERR_INVALID_CHAR_IN_GROUP_NAME -216 ------------------ 5064| 0| else 5065| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 5066| | 5067| 0| *num_type = IS_NOT_NUM; 5068| 0| } 5069| 0| } 5070| 289| else { 5071| 289| if (!ONIGENC_IS_CODE_WORD(enc, c)) { ------------------ | | 319| 289| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 290| 289|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | ------------------ ------------------ | Branch (5071:13): [True: 0, False: 289] ------------------ 5072| 0| r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME; ------------------ | | 627| 0|#define ONIGERR_INVALID_CHAR_IN_GROUP_NAME -216 ------------------ 5073| 0| } 5074| 289| } 5075| 289| } 5076| | 5077| 665| if (c != end_code) { ------------------ | Branch (5077:9): [True: 0, False: 665] ------------------ 5078| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 5079| 0| goto err; 5080| 0| } 5081| | 5082| 665| if (*num_type != IS_NOT_NUM) { ------------------ | Branch (5082:9): [True: 0, False: 665] ------------------ 5083| 0| *rback_num = scan_number(&pnum_head, name_end, enc); 5084| 0| if (*rback_num < 0) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 612| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (5084:11): [True: 0, False: 0] ------------------ 5085| 0| else if (*rback_num == 0) { ------------------ | Branch (5085:16): [True: 0, False: 0] ------------------ 5086| 0| if (*num_type == IS_REL_NUM) { ------------------ | Branch (5086:13): [True: 0, False: 0] ------------------ 5087| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 626| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 5088| 0| goto err; 5089| 0| } 5090| 0| } 5091| | 5092| 0| *rback_num *= sign; 5093| 0| } 5094| | 5095| 665| *rname_end = name_end; 5096| 665| *src = p; 5097| 665| return 0; 5098| 665| } 5099| 0| else { 5100| 0| while (!PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5100:12): [True: 0, False: 0] ------------------ 5101| 0| name_end = p; 5102| 0| PFETCH_S(c); ------------------ | | 503| 0|#define PFETCH_S(c) do { \ | | 504| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 505| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 506| 0|} while (0) | | ------------------ | | | Branch (506:10): [Folded, False: 0] | | ------------------ ------------------ 5103| 0| if (c == end_code || c == ')') ------------------ | Branch (5103:11): [True: 0, False: 0] | Branch (5103:28): [True: 0, False: 0] ------------------ 5104| 0| break; 5105| 0| } 5106| 0| if (PEND) ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5107| 0| name_end = end; 5108| | 5109| 0| err: 5110| 0| onig_scan_env_set_error_string(env, r, *src, name_end); 5111| 0| return r; 5112| 0| } 5113| 665|} regparse.c:prs_alts: 9290| 47.7k|{ 9291| 47.7k| int r; 9292| 47.7k| Node *node, **headp; 9293| 47.7k| OnigOptionType save_options; 9294| | 9295| 47.7k| *top = NULL; 9296| 47.7k| INC_PARSE_DEPTH(env->parse_depth); ------------------ | | 320| 47.7k|#define INC_PARSE_DEPTH(d) do {\ | | 321| 47.7k| (d)++;\ | | 322| 47.7k| if ((d) > ParseDepthLimit) \ | | ------------------ | | | Branch (322:7): [True: 0, False: 47.7k] | | ------------------ | | 323| 47.7k| return ONIGERR_PARSE_DEPTH_LIMIT_OVER;\ | | ------------------ | | | | 577| 0|#define ONIGERR_PARSE_DEPTH_LIMIT_OVER -16 | | ------------------ | | 324| 47.7k|} while (0) | | ------------------ | | | Branch (324:10): [Folded, False: 47.7k] | | ------------------ ------------------ 9297| 47.7k| save_options = env->options; 9298| | 9299| 47.7k| r = prs_branch(&node, tok, term, src, end, env, group_head); 9300| 47.7k| if (r < 0) { ------------------ | Branch (9300:7): [True: 0, False: 47.7k] ------------------ 9301| 0| onig_node_free(node); 9302| 0| return r; 9303| 0| } 9304| | 9305| 47.7k| if (r == term) { ------------------ | Branch (9305:7): [True: 47.7k, False: 0] ------------------ 9306| 47.7k| *top = node; 9307| 47.7k| } 9308| 0| else if (r == TK_ALT) { ------------------ | Branch (9308:12): [True: 0, False: 0] ------------------ 9309| 0| *top = onig_node_new_alt(node, NULL); 9310| 0| if (IS_NULL(*top)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 9311| 0| onig_node_free(node); 9312| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 9313| 0| } 9314| | 9315| 0| headp = &(ND_CDR(*top)); ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9316| 0| while (r == TK_ALT) { ------------------ | Branch (9316:12): [True: 0, False: 0] ------------------ 9317| 0| r = fetch_token(tok, src, end, env); 9318| 0| if (r < 0) return r; ------------------ | Branch (9318:11): [True: 0, False: 0] ------------------ 9319| 0| r = prs_branch(&node, tok, term, src, end, env, FALSE); ------------------ | | 63| 0|#define FALSE 0 ------------------ 9320| 0| if (r < 0) { ------------------ | Branch (9320:11): [True: 0, False: 0] ------------------ 9321| 0| onig_node_free(node); 9322| 0| return r; 9323| 0| } 9324| 0| *headp = onig_node_new_alt(node, NULL); 9325| 0| if (IS_NULL(*headp)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 9326| 0| onig_node_free(node); 9327| 0| onig_node_free(*top); 9328| 0| *top = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 9329| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 9330| 0| } 9331| | 9332| 0| headp = &(ND_CDR(*headp)); ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9333| 0| } 9334| | 9335| 0| if (tok->type != (enum TokenSyms )term) ------------------ | Branch (9335:9): [True: 0, False: 0] ------------------ 9336| 0| goto err; 9337| 0| } 9338| 0| else { 9339| 0| onig_node_free(node); 9340| 0| err: 9341| 0| if (term == TK_SUBEXP_CLOSE) ------------------ | Branch (9341:9): [True: 0, False: 0] ------------------ 9342| 0| return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS; ------------------ | | 604| 0|#define ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS -117 ------------------ 9343| 0| else 9344| 0| return ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 9345| 0| } 9346| | 9347| 47.7k| env->options = save_options; 9348| 47.7k| DEC_PARSE_DEPTH(env->parse_depth); ------------------ | | 327| 47.7k|#define DEC_PARSE_DEPTH(d) (d)-- ------------------ 9349| 47.7k| return r; 9350| 47.7k|} regparse.c:prs_branch: 9237| 47.7k|{ 9238| 47.7k| int r; 9239| 47.7k| Node *node, **headp; 9240| | 9241| 47.7k| *top = NULL; 9242| 47.7k| INC_PARSE_DEPTH(env->parse_depth); ------------------ | | 320| 47.7k|#define INC_PARSE_DEPTH(d) do {\ | | 321| 47.7k| (d)++;\ | | 322| 47.7k| if ((d) > ParseDepthLimit) \ | | ------------------ | | | Branch (322:7): [True: 0, False: 47.7k] | | ------------------ | | 323| 47.7k| return ONIGERR_PARSE_DEPTH_LIMIT_OVER;\ | | ------------------ | | | | 577| 0|#define ONIGERR_PARSE_DEPTH_LIMIT_OVER -16 | | ------------------ | | 324| 47.7k|} while (0) | | ------------------ | | | Branch (324:10): [Folded, False: 47.7k] | | ------------------ ------------------ 9243| | 9244| 47.7k| r = prs_exp(&node, tok, term, src, end, env, group_head); 9245| 47.7k| if (r < 0) { ------------------ | Branch (9245:7): [True: 0, False: 47.7k] ------------------ 9246| 0| onig_node_free(node); 9247| 0| return r; 9248| 0| } 9249| | 9250| 47.7k| if (r == TK_EOT || r == term || r == TK_ALT) { ------------------ | Branch (9250:7): [True: 43.5k, False: 4.22k] | Branch (9250:22): [True: 814, False: 3.40k] | Branch (9250:35): [True: 0, False: 3.40k] ------------------ 9251| 44.3k| *top = node; 9252| 44.3k| } 9253| 3.40k| else { 9254| 3.40k| *top = node_new_list(node, NULL); 9255| 3.40k| if (IS_NULL(*top)) { ------------------ | | 201| 3.40k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 3.40k] | | ------------------ ------------------ 9256| 0| mem_err: 9257| 0| onig_node_free(node); 9258| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 9259| 0| } 9260| | 9261| 3.40k| headp = &(ND_CDR(*top)); ------------------ | | 299| 3.40k|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 3.40k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9262| 7.05k| while (r != TK_EOT && r != term && r != TK_ALT) { ------------------ | Branch (9262:12): [True: 3.64k, False: 3.40k] | Branch (9262:27): [True: 3.64k, False: 0] | Branch (9262:40): [True: 3.64k, False: 0] ------------------ 9263| 3.64k| r = prs_exp(&node, tok, term, src, end, env, FALSE); ------------------ | | 63| 3.64k|#define FALSE 0 ------------------ 9264| 3.64k| if (r < 0) { ------------------ | Branch (9264:11): [True: 0, False: 3.64k] ------------------ 9265| 0| onig_node_free(node); 9266| 0| return r; 9267| 0| } 9268| | 9269| 3.64k| if (ND_TYPE(node) == ND_LIST) { ------------------ | | 284| 3.64k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (9269:11): [True: 0, False: 3.64k] ------------------ 9270| 0| *headp = node; 9271| 0| while (IS_NOT_NULL(ND_CDR(node))) node = ND_CDR(node); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ while (IS_NOT_NULL(ND_CDR(node))) node = ND_CDR(node); ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9272| 0| headp = &(ND_CDR(node)); ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9273| 0| } 9274| 3.64k| else { 9275| 3.64k| *headp = node_new_list(node, NULL); 9276| 3.64k| if (IS_NULL(*headp)) goto mem_err; ------------------ | | 201| 3.64k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 3.64k] | | ------------------ ------------------ 9277| 3.64k| headp = &(ND_CDR(*headp)); ------------------ | | 299| 3.64k|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 3.64k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9278| 3.64k| } 9279| 3.64k| } 9280| 3.40k| } 9281| | 9282| 47.7k| DEC_PARSE_DEPTH(env->parse_depth); ------------------ | | 327| 47.7k|#define DEC_PARSE_DEPTH(d) (d)-- ------------------ 9283| 47.7k| return r; 9284| 47.7k|} regparse.c:prs_exp: 8816| 51.4k|{ 8817| 51.4k| int r, len, group; 8818| 51.4k| Node* qn; 8819| 51.4k| Node** tp; 8820| 51.4k| unsigned int parse_depth; 8821| | 8822| 51.4k| retry: 8823| 51.4k| group = 0; 8824| 51.4k| *np = NULL; 8825| 51.4k| if (tok->type == (enum TokenSyms )term) ------------------ | Branch (8825:7): [True: 75, False: 51.3k] ------------------ 8826| 75| goto end_of_token; 8827| | 8828| 51.3k| parse_depth = env->parse_depth; 8829| | 8830| 51.3k| switch (tok->type) { 8831| 0| case TK_ALT: ------------------ | Branch (8831:3): [True: 0, False: 51.3k] ------------------ 8832| 0| case TK_EOT: ------------------ | Branch (8832:3): [True: 0, False: 51.3k] ------------------ 8833| 75| end_of_token: 8834| 75| *np = node_new_empty(); 8835| 75| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 75|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 75|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 75] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8836| 75| return tok->type; 8837| 0| break; 8838| | 8839| 814| case TK_SUBEXP_OPEN: ------------------ | Branch (8839:3): [True: 814, False: 50.5k] ------------------ 8840| 814| r = prs_bag(np, tok, TK_SUBEXP_CLOSE, src, end, env); 8841| 814| if (r < 0) return r; ------------------ | Branch (8841:9): [True: 0, False: 814] ------------------ 8842| 814| if (r == 1) { /* group */ ------------------ | Branch (8842:9): [True: 0, False: 814] ------------------ 8843| 0| if (group_head == 0) ------------------ | Branch (8843:11): [True: 0, False: 0] ------------------ 8844| 0| group = 1; 8845| 0| else { 8846| 0| Node* target = *np; 8847| 0| *np = node_new_group(target); 8848| 0| if (IS_NULL(*np)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 8849| 0| onig_node_free(target); 8850| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 8851| 0| } 8852| 0| group = 2; 8853| 0| } 8854| 0| } 8855| 814| else if (r == 2) { /* option only */ ------------------ | Branch (8855:14): [True: 0, False: 814] ------------------ 8856| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ISOLATED_OPTION_CONTINUE_BRANCH)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 8857| 0| env->options = BAG_(*np)->o.options; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 8858| 0| r = fetch_token(tok, src, end, env); 8859| 0| if (r < 0) return r; ------------------ | Branch (8859:13): [True: 0, False: 0] ------------------ 8860| 0| onig_node_free(*np); 8861| 0| goto retry; 8862| 0| } 8863| 0| else { 8864| 0| Node* target; 8865| 0| OnigOptionType prev = env->options; 8866| | 8867| 0| env->options = BAG_(*np)->o.options; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 8868| 0| r = fetch_token(tok, src, end, env); 8869| 0| if (r < 0) return r; ------------------ | Branch (8869:13): [True: 0, False: 0] ------------------ 8870| 0| r = prs_alts(&target, tok, term, src, end, env, FALSE); ------------------ | | 63| 0|#define FALSE 0 ------------------ 8871| 0| env->options = prev; 8872| 0| if (r < 0) { ------------------ | Branch (8872:13): [True: 0, False: 0] ------------------ 8873| 0| onig_node_free(target); 8874| 0| return r; 8875| 0| } 8876| 0| ND_BODY(*np) = target; ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 8877| 0| } 8878| 0| return tok->type; 8879| 0| } 8880| 814| break; 8881| | 8882| 814| case TK_SUBEXP_CLOSE: ------------------ | Branch (8882:3): [True: 0, False: 51.3k] ------------------ 8883| 0| if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (8883:9): [True: 0, False: 0] ------------------ 8884| 0| return ONIGERR_UNMATCHED_CLOSE_PARENTHESIS; ------------------ | | 603| 0|#define ONIGERR_UNMATCHED_CLOSE_PARENTHESIS -116 ------------------ 8885| | 8886| 0| if (tok->escaped) goto tk_crude_byte; ------------------ | Branch (8886:9): [True: 0, False: 0] ------------------ 8887| 0| else goto tk_byte; 8888| 0| break; 8889| | 8890| 46.4k| case TK_STRING: ------------------ | Branch (8890:3): [True: 46.4k, False: 4.87k] ------------------ 8891| 46.4k| tk_byte: 8892| 46.4k| { 8893| 46.4k| *np = node_new_str_with_options(tok->backp, *src, env->options); 8894| 46.4k| tk_byte2: 8895| 46.4k| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 46.4k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 46.4k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 46.4k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8896| | 8897| 87.8k| while (1) { ------------------ | Branch (8897:14): [True: 87.8k, Folded] ------------------ 8898| 87.8k| r = fetch_token(tok, src, end, env); 8899| 87.8k| if (r < 0) return r; ------------------ | Branch (8899:13): [True: 0, False: 87.8k] ------------------ 8900| 87.8k| if (r != TK_STRING) break; ------------------ | Branch (8900:13): [True: 46.4k, False: 41.3k] ------------------ 8901| | 8902| 41.3k| r = onig_node_str_cat(*np, tok->backp, *src); 8903| 41.3k| if (r < 0) return r; ------------------ | Branch (8903:13): [True: 0, False: 41.3k] ------------------ 8904| 41.3k| } 8905| | 8906| 46.4k| string_end: 8907| 46.4k| tp = np; 8908| 46.4k| goto repeat; 8909| 46.4k| } 8910| 0| break; 8911| | 8912| 0| case TK_CRUDE_BYTE: ------------------ | Branch (8912:3): [True: 0, False: 51.3k] ------------------ 8913| 0| tk_crude_byte: 8914| 0| { 8915| 0| *np = node_new_str_crude_char(tok->u.byte, env->options); 8916| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8917| 0| len = 1; 8918| 0| while (1) { ------------------ | Branch (8918:14): [True: 0, Folded] ------------------ 8919| 0| if (len >= ONIGENC_MBC_MINLEN(env->enc)) { ------------------ | | 282| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (8919:13): [True: 0, False: 0] ------------------ 8920| 0| if (len == enclen(env->enc, STR_(*np)->s)) { ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ | Branch (8920:15): [True: 0, False: 0] ------------------ 8921| 0| r = fetch_token(tok, src, end, env); 8922| 0| goto tk_crude_byte_end; 8923| 0| } 8924| 0| } 8925| | 8926| 0| r = fetch_token(tok, src, end, env); 8927| 0| if (r < 0) return r; ------------------ | Branch (8927:13): [True: 0, False: 0] ------------------ 8928| 0| if (r != TK_CRUDE_BYTE) ------------------ | Branch (8928:13): [True: 0, False: 0] ------------------ 8929| 0| return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING; ------------------ | | 618| 0|#define ONIGERR_TOO_SHORT_MULTI_BYTE_STRING -206 ------------------ 8930| | 8931| 0| r = node_str_cat_char(*np, tok->u.byte); 8932| 0| if (r < 0) return r; ------------------ | Branch (8932:13): [True: 0, False: 0] ------------------ 8933| | 8934| 0| len++; 8935| 0| } 8936| | 8937| 0| tk_crude_byte_end: 8938| 0| if (! ONIGENC_IS_VALID_MBC_STRING(env->enc, STR_(*np)->s, STR_(*np)->end)) ------------------ | | 271| 0| (enc)->is_valid_mbc_string(s,end) ------------------ | Branch (8938:11): [True: 0, False: 0] ------------------ 8939| 0| return ONIGERR_INVALID_WIDE_CHAR_VALUE; ------------------ | | 645| 0|#define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 ------------------ 8940| | 8941| 0| ND_STRING_CLEAR_CRUDE(*np); ------------------ | | 314| 0|#define ND_STRING_CLEAR_CRUDE(node) (node)->u.str.flag &= ~ND_STRING_CRUDE | | ------------------ | | | | 309| 0|#define ND_STRING_CRUDE (1<<0) | | ------------------ ------------------ 8942| 0| goto string_end; 8943| 0| } 8944| 0| break; 8945| | 8946| 0| case TK_CODE_POINT: ------------------ | Branch (8946:3): [True: 0, False: 51.3k] ------------------ 8947| 0| { 8948| 0| UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN]; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 8949| 0| len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.code); ------------------ | | 285| 0|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code) ------------------ 8950| 0| if (len < 0) return len; ------------------ | Branch (8950:11): [True: 0, False: 0] ------------------ 8951| 0| len = ONIGENC_CODE_TO_MBC(env->enc, tok->u.code, buf); ------------------ | | 286| 0|#define ONIGENC_CODE_TO_MBC(enc,code,buf) (enc)->code_to_mbc(code,buf) ------------------ 8952| |#ifdef NUMBERED_CHAR_IS_NOT_CASE_AMBIG 8953| | *np = node_new_str_crude(buf, buf + len, env->options); 8954| |#else 8955| 0| *np = node_new_str_with_options(buf, buf + len, env->options); 8956| 0|#endif 8957| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8958| 0| } 8959| 0| break; 8960| | 8961| 0| case TK_QUOTE_OPEN: ------------------ | Branch (8961:3): [True: 0, False: 51.3k] ------------------ 8962| 0| { 8963| 0| OnigCodePoint end_op[2]; 8964| 0| UChar *qstart, *qend, *nextp; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 8965| | 8966| 0| end_op[0] = (OnigCodePoint )MC_ESC(env->syntax); ------------------ | | 687| 0|#define MC_ESC(syn) (syn)->meta_char_table.esc ------------------ 8967| 0| end_op[1] = (OnigCodePoint )'E'; 8968| 0| qstart = *src; 8969| 0| qend = find_str_position(end_op, 2, qstart, end, &nextp, env->enc); 8970| 0| if (IS_NULL(qend)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 8971| 0| nextp = qend = end; 8972| 0| } 8973| 0| *np = node_new_str_with_options(qstart, qend, env->options); 8974| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8975| 0| *src = nextp; 8976| 0| } 8977| 0| break; 8978| | 8979| 0| case TK_CHAR_TYPE: ------------------ | Branch (8979:3): [True: 0, False: 51.3k] ------------------ 8980| 0| { 8981| 0| switch (tok->u.prop.ctype) { 8982| 0| case ONIGENC_CTYPE_WORD: ------------------ | Branch (8982:7): [True: 0, False: 0] ------------------ 8983| 0| *np = node_new_ctype(tok->u.prop.ctype, tok->u.prop.not, env->options); 8984| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8985| 0| break; 8986| | 8987| 0| case ONIGENC_CTYPE_SPACE: ------------------ | Branch (8987:7): [True: 0, False: 0] ------------------ 8988| 0| case ONIGENC_CTYPE_DIGIT: ------------------ | Branch (8988:7): [True: 0, False: 0] ------------------ 8989| 0| case ONIGENC_CTYPE_XDIGIT: ------------------ | Branch (8989:7): [True: 0, False: 0] ------------------ 8990| 0| { 8991| 0| CClassNode* cc; 8992| | 8993| 0| *np = node_new_cclass(); 8994| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8995| 0| cc = CCLASS_(*np); ------------------ | | 288| 0|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 8996| 0| r = add_ctype_to_cc(cc, tok->u.prop.ctype, FALSE, env); ------------------ | | 63| 0|#define FALSE 0 ------------------ 8997| 0| if (r != 0) { ------------------ | Branch (8997:15): [True: 0, False: 0] ------------------ 8998| 0| onig_node_free(*np); 8999| 0| *np = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 9000| 0| return r; 9001| 0| } 9002| 0| if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc); ------------------ | | 734| 0|#define NCCLASS_SET_NOT(nd) NCCLASS_FLAG_SET(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 726| 0|#define NCCLASS_FLAG_SET(cc,flag) (NCCLASS_FLAGS(cc) |= (flag)) | | | | ------------------ | | | | | | 725| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (9002:15): [True: 0, False: 0] ------------------ 9003| 0| } 9004| 0| break; 9005| | 9006| 0| default: ------------------ | Branch (9006:7): [True: 0, False: 0] ------------------ 9007| 0| return ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 9008| 0| break; 9009| 0| } 9010| 0| } 9011| 0| break; 9012| | 9013| 0| case TK_CHAR_PROPERTY: ------------------ | Branch (9013:3): [True: 0, False: 51.3k] ------------------ 9014| 0| r = prs_char_property(np, tok, src, end, env); 9015| 0| if (r != 0) return r; ------------------ | Branch (9015:9): [True: 0, False: 0] ------------------ 9016| 0| break; 9017| | 9018| 391| case TK_OPEN_CC: ------------------ | Branch (9018:3): [True: 391, False: 50.9k] ------------------ 9019| 391| { 9020| 391| CClassNode* cc; 9021| | 9022| 391| r = prs_cc(np, tok, src, end, env); 9023| 391| if (r != 0) return r; ------------------ | Branch (9023:11): [True: 0, False: 391] ------------------ 9024| | 9025| 391| cc = CCLASS_(*np); ------------------ | | 288| 391|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 9026| 391| if (OPTON_IGNORECASE(env->options)) { ------------------ | | 52| 391|#define OPTON_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 377| 391|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ | | | Branch (52:38): [True: 0, False: 391] | | ------------------ ------------------ 9027| 0| IApplyCaseFoldArg iarg; 9028| | 9029| 0| iarg.env = env; 9030| 0| iarg.cc = cc; 9031| 0| iarg.alt_root = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 9032| 0| iarg.ptail = &(iarg.alt_root); 9033| | 9034| 0| r = ONIGENC_APPLY_ALL_CASE_FOLD(env->enc, env->reg->case_fold_flag, ------------------ | | 273| 0| (enc)->apply_all_case_fold(case_fold_flag,f,arg) ------------------ 9035| 0| i_apply_case_fold, &iarg); 9036| 0| if (r != 0) { ------------------ | Branch (9036:13): [True: 0, False: 0] ------------------ 9037| 0| onig_node_free(iarg.alt_root); 9038| 0| return r; 9039| 0| } 9040| 0| if (IS_NOT_NULL(iarg.alt_root)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 9041| 0| Node* work = onig_node_new_alt(*np, iarg.alt_root); 9042| 0| if (IS_NULL(work)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 9043| 0| onig_node_free(iarg.alt_root); 9044| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 9045| 0| } 9046| 0| *np = work; 9047| 0| } 9048| 0| } 9049| 391| } 9050| 391| break; 9051| | 9052| 562| case TK_ANYCHAR: ------------------ | Branch (9052:3): [True: 562, False: 50.7k] ------------------ 9053| 562| *np = node_new_anychar(env->options); 9054| 562| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 562|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 562|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 562] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9055| 562| break; 9056| | 9057| 562| case TK_ANYCHAR_ANYTIME: ------------------ | Branch (9057:3): [True: 0, False: 51.3k] ------------------ 9058| 0| *np = node_new_anychar(env->options); 9059| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9060| 0| qn = node_new_quantifier(0, INFINITE_REPEAT, FALSE); ------------------ | | 427| 0|#define INFINITE_REPEAT -1 ------------------ qn = node_new_quantifier(0, INFINITE_REPEAT, FALSE); ------------------ | | 63| 0|#define FALSE 0 ------------------ 9061| 0| CHECK_NULL_RETURN_MEMERR(qn); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9062| 0| ND_BODY(qn) = *np; ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 9063| 0| *np = qn; 9064| 0| break; 9065| | 9066| 0| case TK_BACKREF: ------------------ | Branch (9066:3): [True: 0, False: 51.3k] ------------------ 9067| 0| len = tok->u.backref.num; 9068| 0| *np = node_new_backref(len, 9069| 0| (len > 1 ? tok->u.backref.refs : &(tok->u.backref.ref1)), ------------------ | Branch (9069:20): [True: 0, False: 0] ------------------ 9070| 0| tok->u.backref.by_name, 9071| 0|#ifdef USE_BACKREF_WITH_LEVEL 9072| 0| tok->u.backref.exist_level, 9073| 0| tok->u.backref.level, 9074| 0|#endif 9075| 0| env); 9076| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9077| 0| break; 9078| | 9079| 0|#ifdef USE_CALL 9080| 0| case TK_CALL: ------------------ | Branch (9080:3): [True: 0, False: 51.3k] ------------------ 9081| 0| { 9082| 0| int gnum = tok->u.call.gnum; 9083| | 9084| 0| *np = node_new_call(tok->u.call.name, tok->u.call.name_end, 9085| 0| gnum, tok->u.call.by_number); 9086| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9087| 0| env->num_call++; 9088| 0| if (tok->u.call.by_number != 0 && gnum == 0) { ------------------ | Branch (9088:11): [True: 0, False: 0] | Branch (9088:41): [True: 0, False: 0] ------------------ 9089| 0| env->flags |= PE_FLAG_HAS_CALL_ZERO; ------------------ | | 457| 0|#define PE_FLAG_HAS_CALL_ZERO (1<<0) ------------------ 9090| 0| } 9091| 0| } 9092| 0| break; 9093| 0|#endif 9094| | 9095| 3.10k| case TK_ANCHOR: ------------------ | Branch (9095:3): [True: 3.10k, False: 48.2k] ------------------ 9096| 3.10k| *np = node_new_anchor_with_options(tok->u.anchor, env->options); 9097| 3.10k| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 3.10k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 3.10k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 3.10k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9098| 3.10k| break; 9099| | 9100| 3.10k| case TK_REPEAT: ------------------ | Branch (9100:3): [True: 0, False: 51.3k] ------------------ 9101| 0| case TK_INTERVAL: ------------------ | Branch (9101:3): [True: 0, False: 51.3k] ------------------ 9102| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 9103| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 9104| 0| return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED; ------------------ | | 600| 0|#define ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED -113 ------------------ 9105| 0| else { 9106| 0| *np = node_new_empty(); 9107| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9108| 0| } 9109| 0| } 9110| 0| else { 9111| 0| if (tok->type == TK_INTERVAL && ------------------ | Branch (9111:11): [True: 0, False: 0] ------------------ 9112| 0| IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_BRACE_INTERVAL)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 9113| 0| *np = node_new_str_with_options(tok->backp, *src, env->options); 9114| 0| node_str_remove_char(*np, (UChar )'\\'); 9115| 0| goto tk_byte2; 9116| 0| } 9117| 0| else { 9118| 0| goto tk_byte; 9119| 0| } 9120| 0| } 9121| 0| break; 9122| | 9123| 0| case TK_KEEP: ------------------ | Branch (9123:3): [True: 0, False: 51.3k] ------------------ 9124| 0| r = node_new_keep(np, env); 9125| 0| if (r < 0) return r; ------------------ | Branch (9125:9): [True: 0, False: 0] ------------------ 9126| 0| break; 9127| | 9128| 0| case TK_GENERAL_NEWLINE: ------------------ | Branch (9128:3): [True: 0, False: 51.3k] ------------------ 9129| 0| r = node_new_general_newline(np, env); 9130| 0| if (r < 0) return r; ------------------ | Branch (9130:9): [True: 0, False: 0] ------------------ 9131| 0| break; 9132| | 9133| 0| case TK_NO_NEWLINE: ------------------ | Branch (9133:3): [True: 0, False: 51.3k] ------------------ 9134| 0| r = node_new_no_newline(np, env); 9135| 0| if (r < 0) return r; ------------------ | Branch (9135:9): [True: 0, False: 0] ------------------ 9136| 0| break; 9137| | 9138| 0| case TK_TRUE_ANYCHAR: ------------------ | Branch (9138:3): [True: 0, False: 51.3k] ------------------ 9139| 0| r = node_new_true_anychar(np); 9140| 0| if (r < 0) return r; ------------------ | Branch (9140:9): [True: 0, False: 0] ------------------ 9141| 0| break; 9142| | 9143| 0| case TK_TEXT_SEGMENT: ------------------ | Branch (9143:3): [True: 0, False: 51.3k] ------------------ 9144| 0| r = make_text_segment(np, env); 9145| 0| if (r < 0) return r; ------------------ | Branch (9145:9): [True: 0, False: 0] ------------------ 9146| 0| break; 9147| | 9148| 0| default: ------------------ | Branch (9148:3): [True: 0, False: 51.3k] ------------------ 9149| 0| return ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 9150| 0| break; 9151| 51.3k| } 9152| | 9153| 4.87k| { 9154| 4.87k| tp = np; 9155| | 9156| 51.2k| re_entry: 9157| 51.2k| r = fetch_token(tok, src, end, env); 9158| 51.2k| if (r < 0) return r; ------------------ | Branch (9158:9): [True: 0, False: 51.2k] ------------------ 9159| | 9160| 97.7k| repeat: 9161| 97.7k| if (r == TK_REPEAT || r == TK_INTERVAL) { ------------------ | Branch (9161:9): [True: 46.3k, False: 51.3k] | Branch (9161:27): [True: 0, False: 51.3k] ------------------ 9162| 46.3k| Node* target; 9163| | 9164| 46.3k| if (is_invalid_quantifier_target(*tp)) { ------------------ | Branch (9164:11): [True: 0, False: 46.3k] ------------------ 9165| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 9166| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 9167| 0| return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID; ------------------ | | 601| 0|#define ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID -114 ------------------ 9168| 0| } 9169| | 9170| 0| return r; 9171| 0| } 9172| | 9173| 46.3k| INC_PARSE_DEPTH(parse_depth); ------------------ | | 320| 46.3k|#define INC_PARSE_DEPTH(d) do {\ | | 321| 46.3k| (d)++;\ | | 322| 46.3k| if ((d) > ParseDepthLimit) \ | | ------------------ | | | Branch (322:7): [True: 0, False: 46.3k] | | ------------------ | | 323| 46.3k| return ONIGERR_PARSE_DEPTH_LIMIT_OVER;\ | | ------------------ | | | | 577| 0|#define ONIGERR_PARSE_DEPTH_LIMIT_OVER -16 | | ------------------ | | 324| 46.3k|} while (0) | | ------------------ | | | Branch (324:10): [Folded, False: 46.3k] | | ------------------ ------------------ 9174| | 9175| 46.3k| qn = node_new_quantifier(tok->u.repeat.lower, tok->u.repeat.upper, 9176| 46.3k| r == TK_INTERVAL); 9177| 46.3k| CHECK_NULL_RETURN_MEMERR(qn); ------------------ | | 204| 46.3k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 46.3k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 46.3k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 9178| 46.3k| QUANT_(qn)->greedy = tok->u.repeat.greedy; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 9179| 46.3k| if (group == 2) { ------------------ | Branch (9179:11): [True: 0, False: 46.3k] ------------------ 9180| 0| target = node_drop_group(*tp); 9181| 0| *tp = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 9182| 0| } 9183| 46.3k| else { 9184| 46.3k| target = *tp; 9185| 46.3k| } 9186| 46.3k| r = assign_quantifier_body(qn, target, group, env); 9187| 46.3k| if (r < 0) { ------------------ | Branch (9187:11): [True: 0, False: 46.3k] ------------------ 9188| 0| onig_node_free(qn); 9189| 0| *tp = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 9190| 0| return r; 9191| 0| } 9192| | 9193| 46.3k| if (tok->u.repeat.possessive != 0) { ------------------ | Branch (9193:11): [True: 0, False: 46.3k] ------------------ 9194| 0| Node* en; 9195| 0| en = node_new_bag(BAG_STOP_BACKTRACK); 9196| 0| if (IS_NULL(en)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 9197| 0| onig_node_free(qn); 9198| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 9199| 0| } 9200| 0| ND_BODY(en) = qn; ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 9201| 0| qn = en; 9202| 0| } 9203| | 9204| 46.3k| if (r == 0) { ------------------ | Branch (9204:11): [True: 5.72k, False: 40.6k] ------------------ 9205| 5.72k| *tp = qn; 9206| 5.72k| } 9207| 40.6k| else if (r == 1) { /* x{1,1} ==> x */ ------------------ | Branch (9207:16): [True: 0, False: 40.6k] ------------------ 9208| 0| onig_node_free(qn); 9209| 0| *tp = target; 9210| 0| } 9211| 40.6k| else if (r == 2) { /* split case: /abc+/ */ ------------------ | Branch (9211:16): [True: 40.6k, False: 0] ------------------ 9212| 40.6k| Node *tmp; 9213| | 9214| 40.6k| *tp = node_new_list(*tp, NULL); 9215| 40.6k| if (IS_NULL(*tp)) { ------------------ | | 201| 40.6k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 40.6k] | | ------------------ ------------------ 9216| 0| onig_node_free(qn); 9217| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 9218| 0| } 9219| 40.6k| tmp = ND_CDR(*tp) = node_new_list(qn, NULL); ------------------ | | 299| 40.6k|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 40.6k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9220| 40.6k| if (IS_NULL(tmp)) { ------------------ | | 201| 40.6k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 40.6k] | | ------------------ ------------------ 9221| 0| onig_node_free(qn); 9222| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 9223| 0| } 9224| 40.6k| tp = &(ND_CAR(tmp)); ------------------ | | 298| 40.6k|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 40.6k|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 9225| 40.6k| } 9226| 46.3k| group = 0; 9227| 46.3k| goto re_entry; 9228| 46.3k| } 9229| 97.7k| } 9230| | 9231| 51.3k| return r; 9232| 97.7k|} regparse.c:node_new_empty: 3549| 75|{ 3550| 75| return node_new_str(NULL, NULL); 3551| 75|} regparse.c:prs_bag: 7847| 814|{ 7848| 814| int r, num; 7849| 814| Node *target; 7850| 814| OnigOptionType option; 7851| 814| OnigCodePoint c; 7852| 814| int list_capture; 7853| 814| OnigEncoding enc; 7854| 814| UChar* p; ------------------ | | 80| 814|#define UChar OnigUChar ------------------ 7855| 814| PFETCH_READY; ------------------ | | 486| 814|#define PFETCH_READY UChar* pfetch_prev | | ------------------ | | | | 80| 814|#define UChar OnigUChar | | ------------------ ------------------ 7856| | 7857| 814| p = *src; 7858| 814| enc = env->enc; 7859| 814| *np = NULL; 7860| 814| if (PEND) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS; ------------------ | | 487| 814|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 814] | | | Branch (487:23): [True: 814, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS; ------------------ | | 604| 0|#define ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS -117 ------------------ 7861| | 7862| 814| option = env->options; 7863| 814| c = PPEEK; ------------------ | | 508| 814|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 284| 814|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 484| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (508:23): [True: 814, False: 0] | | ------------------ ------------------ 7864| 814| if (c == '?' && IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) { ------------------ | | 406| 678|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 678, False: 0] | | ------------------ ------------------ | Branch (7864:7): [True: 678, False: 136] ------------------ 7865| 678| PINC; ------------------ | | 490| 678|#define PINC do { \ | | 491| 678| pfetch_prev = p; \ | | 492| 678| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 678|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 678|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 678] | | ------------------ ------------------ 7866| 678| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 678|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 678] | | | Branch (487:23): [True: 678, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 7867| | 7868| 678| PFETCH(c); ------------------ | | 494| 678|#define PFETCH(c) do { \ | | 495| 678| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 678|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 678| pfetch_prev = p; \ | | 497| 678| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 678|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 678|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 678] | | ------------------ ------------------ 7869| 678| switch (c) { 7870| 0| case ':': /* (?:...) grouping only */ ------------------ | Branch (7870:5): [True: 0, False: 678] ------------------ 7871| 0| group: 7872| 0| r = fetch_token(tok, &p, end, env); 7873| 0| if (r < 0) return r; ------------------ | Branch (7873:11): [True: 0, False: 0] ------------------ 7874| 0| r = prs_alts(np, tok, term, &p, end, env, FALSE); ------------------ | | 63| 0|#define FALSE 0 ------------------ 7875| 0| if (r < 0) return r; ------------------ | Branch (7875:11): [True: 0, False: 0] ------------------ 7876| 0| *src = p; 7877| 0| return 1; /* group */ 7878| 0| break; 7879| | 7880| 13| case '=': ------------------ | Branch (7880:5): [True: 13, False: 665] ------------------ 7881| 13| *np = node_new_anchor(ANCR_PREC_READ); ------------------ | | 456| 13|#define ANCR_PREC_READ (1<<0) ------------------ 7882| 13| break; 7883| 0| case '!': /* preceding read */ ------------------ | Branch (7883:5): [True: 0, False: 678] ------------------ 7884| 0| *np = node_new_anchor(ANCR_PREC_READ_NOT); ------------------ | | 457| 0|#define ANCR_PREC_READ_NOT (1<<1) ------------------ 7885| 0| break; 7886| 0| case '>': /* (?>...) stop backtrack */ ------------------ | Branch (7886:5): [True: 0, False: 678] ------------------ 7887| 0| *np = node_new_bag(BAG_STOP_BACKTRACK); 7888| 0| break; 7889| | 7890| 0| case '\'': ------------------ | Branch (7890:5): [True: 0, False: 678] ------------------ 7891| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 7892| 0| goto named_group1; 7893| 0| } 7894| 0| else 7895| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 7896| 0| break; 7897| | 7898| 665| case '<': /* look behind (?<=...), (?mbc_to_code((p),(end)) | | ------------------ | | 496| 665| pfetch_prev = p; \ | | 497| 665| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 665|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 665|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 665] | | ------------------ ------------------ 7901| 665| if (c == '=') ------------------ | Branch (7901:11): [True: 0, False: 665] ------------------ 7902| 0| *np = node_new_anchor(ANCR_LOOK_BEHIND); ------------------ | | 458| 0|#define ANCR_LOOK_BEHIND (1<<2) ------------------ 7903| 665| else if (c == '!') ------------------ | Branch (7903:16): [True: 0, False: 665] ------------------ 7904| 0| *np = node_new_anchor(ANCR_LOOK_BEHIND_NOT); ------------------ | | 459| 0|#define ANCR_LOOK_BEHIND_NOT (1<<3) ------------------ 7905| 665| else { 7906| 665| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) { ------------------ | | 406| 665|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 665, False: 0] | | ------------------ ------------------ 7907| 665| UChar *name; ------------------ | | 80| 665|#define UChar OnigUChar ------------------ 7908| 665| UChar *name_end; ------------------ | | 80| 665|#define UChar OnigUChar ------------------ 7909| 665| enum REF_NUM num_type; 7910| | 7911| 665| PUNFETCH; ------------------ | | 488| 665|#define PUNFETCH p = pfetch_prev ------------------ 7912| 665| c = '<'; 7913| | 7914| 665| named_group1: 7915| 665| list_capture = 0; 7916| | 7917| 665|#ifdef USE_CAPTURE_HISTORY 7918| 665| named_group2: 7919| 665|#endif 7920| 665| name = p; 7921| 665| r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &num, 7922| 665| &num_type, FALSE); ------------------ | | 63| 665|#define FALSE 0 ------------------ 7923| 665| if (r < 0) return r; ------------------ | Branch (7923:15): [True: 0, False: 665] ------------------ 7924| | 7925| 665| num = scan_env_add_mem_entry(env); 7926| 665| if (num < 0) return num; ------------------ | Branch (7926:15): [True: 0, False: 665] ------------------ 7927| 665| if (list_capture != 0 && num >= (int )MEM_STATUS_BITS_NUM) ------------------ | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) ------------------ | Branch (7927:15): [True: 0, False: 665] | Branch (7927:36): [True: 0, False: 0] ------------------ 7928| 0| return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY; ------------------ | | 633| 0|#define ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY -222 ------------------ 7929| | 7930| 665| r = name_add(env->reg, name, name_end, num, env); 7931| 665| if (r != 0) return r; ------------------ | Branch (7931:15): [True: 0, False: 665] ------------------ 7932| 665| *np = node_new_memory(1); 7933| 665| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 665|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 665|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 665] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 7934| 665| BAG_(*np)->m.regnum = num; ------------------ | | 292| 665|#define BAG_(node) (&((node)->u.bag)) ------------------ 7935| 665| if (list_capture != 0) ------------------ | Branch (7935:15): [True: 0, False: 665] ------------------ 7936| 0| MEM_STATUS_ON_SIMPLE(env->cap_history, num); ------------------ | | 380| 0|#define MEM_STATUS_ON_SIMPLE(stats,n) do {\ | | 381| 0| if ((n) < (int )MEM_STATUS_BITS_NUM)\ | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (381:9): [True: 0, False: 0] | | ------------------ | | 382| 0| (stats) |= ((MemStatusType )1 << (n));\ | | 383| 0|} while (0) | | ------------------ | | | Branch (383:10): [Folded, False: 0] | | ------------------ ------------------ 7937| 665| env->num_named++; 7938| 665| } 7939| 0| else { 7940| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 7941| 0| } 7942| 665| } 7943| 665| break; 7944| | 7945| 665| case '~': ------------------ | Branch (7945:5): [True: 0, False: 678] ------------------ 7946| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_TILDE_ABSENT_GROUP)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 7947| 0| Node* absent; 7948| 0| Node* expr; 7949| 0| int head_bar; 7950| 0| int is_range_cutter; 7951| | 7952| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 7953| | 7954| 0| if (PPEEK_IS('|')) { /* (?~|generator|absent) */ ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ 7955| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 7956| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 7957| | 7958| 0| head_bar = 1; 7959| 0| if (PPEEK_IS(')')) { /* (?~|) : range clear */ ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ 7960| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 7961| 0| r = make_range_clear(np, env); 7962| 0| if (r != 0) return r; ------------------ | Branch (7962:17): [True: 0, False: 0] ------------------ 7963| 0| env->flags |= PE_FLAG_HAS_ABSENT_STOPPER; ------------------ | | 459| 0|#define PE_FLAG_HAS_ABSENT_STOPPER (1<<2) ------------------ 7964| 0| goto end; 7965| 0| } 7966| 0| } 7967| 0| else 7968| 0| head_bar = 0; 7969| | 7970| 0| r = fetch_token(tok, &p, end, env); 7971| 0| if (r < 0) return r; ------------------ | Branch (7971:13): [True: 0, False: 0] ------------------ 7972| 0| r = prs_alts(&absent, tok, term, &p, end, env, TRUE); ------------------ | | 59| 0|#define TRUE 1 ------------------ 7973| 0| if (r < 0) { ------------------ | Branch (7973:13): [True: 0, False: 0] ------------------ 7974| 0| onig_node_free(absent); 7975| 0| return r; 7976| 0| } 7977| | 7978| 0| expr = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7979| 0| is_range_cutter = 0; 7980| 0| if (head_bar != 0) { ------------------ | Branch (7980:13): [True: 0, False: 0] ------------------ 7981| 0| Node* top = absent; 7982| 0| if (ND_TYPE(top) != ND_ALT || IS_NULL(ND_CDR(top))) { ------------------ | | 284| 0|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ if (ND_TYPE(top) != ND_ALT || IS_NULL(ND_CDR(top))) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (7982:15): [True: 0, False: 0] ------------------ 7983| 0| expr = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7984| 0| is_range_cutter = 1; 7985| 0| env->flags |= PE_FLAG_HAS_ABSENT_STOPPER; ------------------ | | 459| 0|#define PE_FLAG_HAS_ABSENT_STOPPER (1<<2) ------------------ 7986| 0| } 7987| 0| else { 7988| 0| absent = ND_CAR(top); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 7989| 0| expr = ND_CDR(top); ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 7990| 0| ND_CAR(top) = NULL_NODE; ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ ND_CAR(top) = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7991| 0| ND_CDR(top) = NULL_NODE; ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ ND_CDR(top) = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7992| 0| onig_node_free(top); 7993| 0| if (IS_NULL(ND_CDR(expr))) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 7994| 0| top = expr; 7995| 0| expr = ND_CAR(top); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 7996| 0| ND_CAR(top) = NULL_NODE; ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ ND_CAR(top) = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 7997| 0| onig_node_free(top); 7998| 0| } 7999| 0| } 8000| 0| } 8001| | 8002| 0| r = make_absent_tree(np, absent, expr, is_range_cutter, env); 8003| 0| if (r != 0) { ------------------ | Branch (8003:13): [True: 0, False: 0] ------------------ 8004| 0| return r; 8005| 0| } 8006| 0| goto end; 8007| 0| } 8008| 0| else { 8009| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8010| 0| } 8011| 0| break; 8012| | 8013| 0|#ifdef USE_CALLOUT 8014| 0| case '{': ------------------ | Branch (8014:5): [True: 0, False: 678] ------------------ 8015| 0| if (! IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_BRACE_CALLOUT_CONTENTS)) ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (8015:11): [True: 0, False: 0] ------------------ 8016| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8017| | 8018| 0| r = prs_callout_of_contents(np, ')', &p, end, env); 8019| 0| if (r != 0) return r; ------------------ | Branch (8019:11): [True: 0, False: 0] ------------------ 8020| | 8021| 0| goto end; 8022| 0| break; 8023| 0|#endif 8024| | 8025| 0| case '(': ------------------ | Branch (8025:5): [True: 0, False: 678] ------------------ 8026| | /* (?()...) */ 8027| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LPAREN_IF_ELSE)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8028| 0| UChar *prev; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 8029| 0| Node* condition; 8030| 0| int condition_is_checker; 8031| | 8032| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8033| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8034| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8035| | 8036| 0| if (IS_CODE_DIGIT_ASCII(enc, c) ------------------ | | 397| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 257| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (257:43): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 315| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8037| 0| || c == '-' || c == '+' || c == '<' || c == '\'') { ------------------ | Branch (8037:16): [True: 0, False: 0] | Branch (8037:28): [True: 0, False: 0] | Branch (8037:40): [True: 0, False: 0] | Branch (8037:52): [True: 0, False: 0] ------------------ 8038| 0|#ifdef USE_BACKREF_WITH_LEVEL 8039| 0| int exist_level; 8040| 0| int level; 8041| 0|#endif 8042| 0| UChar* name_end; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 8043| 0| int back_num; 8044| 0| enum REF_NUM num_type; 8045| 0| int is_enclosed; 8046| | 8047| 0| is_enclosed = (c == '<' || c == '\'') ? 1 : 0; ------------------ | Branch (8047:26): [True: 0, False: 0] | Branch (8047:38): [True: 0, False: 0] ------------------ 8048| 0| if (! is_enclosed) ------------------ | Branch (8048:15): [True: 0, False: 0] ------------------ 8049| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 8050| 0| prev = p; 8051| 0|#ifdef USE_BACKREF_WITH_LEVEL 8052| 0| exist_level = 0; 8053| 0| name_end = NULL_UCHARP; /* no need. escape gcc warning. */ ------------------ | | 205| 0|#define NULL_UCHARP ((UChar* )0) ------------------ 8054| 0| r = fetch_name_with_level( 8055| 0| (OnigCodePoint )(is_enclosed != 0 ? c : '('), ------------------ | Branch (8055:38): [True: 0, False: 0] ------------------ 8056| 0| &p, end, &name_end, 8057| 0| env, &back_num, &level, &num_type); 8058| 0| if (r == 1) exist_level = 1; ------------------ | Branch (8058:15): [True: 0, False: 0] ------------------ 8059| |#else 8060| | r = fetch_name((OnigCodePoint )(is_enclosed != 0 ? c : '('), 8061| | &p, end, &name_end, env, &back_num, &num_type, TRUE); 8062| |#endif 8063| 0| if (r < 0) { ------------------ | Branch (8063:15): [True: 0, False: 0] ------------------ 8064| 0| if (is_enclosed == 0) { ------------------ | Branch (8064:17): [True: 0, False: 0] ------------------ 8065| 0| goto any_condition; 8066| 0| } 8067| 0| else 8068| 0| return r; 8069| 0| } 8070| | 8071| 0| condition_is_checker = 1; 8072| 0| if (num_type != IS_NOT_NUM) { ------------------ | Branch (8072:15): [True: 0, False: 0] ------------------ 8073| 0| if (num_type == IS_REL_NUM) { ------------------ | Branch (8073:17): [True: 0, False: 0] ------------------ 8074| 0| back_num = backref_rel_to_abs(back_num, env); 8075| 0| } 8076| 0| if (back_num <= 0) ------------------ | Branch (8076:17): [True: 0, False: 0] ------------------ 8077| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 8078| | 8079| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_STRICT_CHECK_BACKREF)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 8080| 0| if (back_num > env->num_mem || ------------------ | Branch (8080:19): [True: 0, False: 0] ------------------ 8081| 0| IS_NULL(PARSEENV_MEMENV(env)[back_num].mem_node)) ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | | Branch (201:49): [True: 0, False: 0] | | ------------------ ------------------ 8082| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 8083| 0| } 8084| | 8085| 0| condition = node_new_backref_checker(1, &back_num, FALSE, ------------------ | | 63| 0|#define FALSE 0 ------------------ 8086| 0|#ifdef USE_BACKREF_WITH_LEVEL 8087| 0| exist_level, level, 8088| 0|#endif 8089| 0| env); 8090| 0| } 8091| 0| else { 8092| 0| int num; 8093| 0| int* backs; 8094| | 8095| 0| num = name_to_group_numbers(env, prev, name_end, &backs); 8096| 0| if (num <= 0) { ------------------ | Branch (8096:17): [True: 0, False: 0] ------------------ 8097| 0| return ONIGERR_UNDEFINED_NAME_REFERENCE; ------------------ | | 628| 0|#define ONIGERR_UNDEFINED_NAME_REFERENCE -217 ------------------ 8098| 0| } 8099| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_STRICT_CHECK_BACKREF)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 8100| 0| int i; 8101| 0| for (i = 0; i < num; i++) { ------------------ | Branch (8101:27): [True: 0, False: 0] ------------------ 8102| 0| if (backs[i] > env->num_mem || ------------------ | Branch (8102:21): [True: 0, False: 0] ------------------ 8103| 0| IS_NULL(PARSEENV_MEMENV(env)[backs[i]].mem_node)) ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | | Branch (201:49): [True: 0, False: 0] | | ------------------ ------------------ 8104| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 620| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 8105| 0| } 8106| 0| } 8107| | 8108| 0| condition = node_new_backref_checker(num, backs, TRUE, ------------------ | | 59| 0|#define TRUE 1 ------------------ 8109| 0|#ifdef USE_BACKREF_WITH_LEVEL 8110| 0| exist_level, level, 8111| 0|#endif 8112| 0| env); 8113| 0| } 8114| | 8115| 0| if (is_enclosed != 0) { ------------------ | Branch (8115:15): [True: 0, False: 0] ------------------ 8116| 0| if (PEND) goto err_if_else; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 8117| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8118| 0| if (c != ')') goto err_if_else; ------------------ | Branch (8118:17): [True: 0, False: 0] ------------------ 8119| 0| } 8120| 0| } 8121| 0|#ifdef USE_CALLOUT 8122| 0| else if (c == '?') { ------------------ | Branch (8122:18): [True: 0, False: 0] ------------------ 8123| 0| if (IS_SYNTAX_OP2(env->syntax, ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8124| 0| ONIG_SYN_OP2_QMARK_BRACE_CALLOUT_CONTENTS)) { 8125| 0| if (! PEND && PPEEK_IS('{')) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (! PEND && PPEEK_IS('{')) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ | Branch (8125:17): [True: 0, False: 0] ------------------ 8126| | /* condition part is callouts of contents: (?(?{...})THEN|ELSE) */ 8127| 0| condition_is_checker = 0; 8128| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8129| 0| r = prs_callout_of_contents(&condition, ')', &p, end, env); 8130| 0| if (r != 0) return r; ------------------ | Branch (8130:19): [True: 0, False: 0] ------------------ 8131| 0| goto end_condition; 8132| 0| } 8133| 0| } 8134| 0| goto any_condition; 8135| 0| } 8136| 0| else if (c == '*' && ------------------ | Branch (8136:18): [True: 0, False: 0] ------------------ 8137| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ASTERISK_CALLOUT_NAME)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8138| 0| condition_is_checker = 0; 8139| 0| r = prs_callout_of_name(&condition, ')', &p, end, env); 8140| 0| if (r != 0) return r; ------------------ | Branch (8140:15): [True: 0, False: 0] ------------------ 8141| 0| goto end_condition; 8142| 0| } 8143| 0|#endif 8144| 0| else { 8145| 0| any_condition: 8146| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 8147| 0| condition_is_checker = 0; 8148| 0| r = fetch_token(tok, &p, end, env); 8149| 0| if (r < 0) return r; ------------------ | Branch (8149:15): [True: 0, False: 0] ------------------ 8150| 0| r = prs_alts(&condition, tok, term, &p, end, env, FALSE); ------------------ | | 63| 0|#define FALSE 0 ------------------ 8151| 0| if (r < 0) { ------------------ | Branch (8151:15): [True: 0, False: 0] ------------------ 8152| 0| onig_node_free(condition); 8153| 0| return r; 8154| 0| } 8155| 0| } 8156| | 8157| 0|#ifdef USE_CALLOUT 8158| 0| end_condition: 8159| 0|#endif 8160| 0| CHECK_NULL_RETURN_MEMERR(condition); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8161| | 8162| 0| if (PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 8163| 0| err_if_else: 8164| 0| onig_node_free(condition); 8165| 0| return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8166| 0| } 8167| | 8168| 0| if (PPEEK_IS(')')) { /* case: empty body: make backref checker */ ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ 8169| 0| if (condition_is_checker == 0) { ------------------ | Branch (8169:15): [True: 0, False: 0] ------------------ 8170| 0| onig_node_free(condition); 8171| 0| return ONIGERR_INVALID_IF_ELSE_SYNTAX; ------------------ | | 635| 0|#define ONIGERR_INVALID_IF_ELSE_SYNTAX -224 ------------------ 8172| 0| } 8173| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8174| 0| *np = condition; 8175| 0| } 8176| 0| else { /* if-else */ 8177| 0| int then_is_empty; 8178| 0| Node *Then, *Else; 8179| | 8180| 0| Then = 0; 8181| 0| if (PPEEK_IS('|')) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ 8182| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8183| 0| then_is_empty = 1; 8184| 0| } 8185| 0| else 8186| 0| then_is_empty = 0; 8187| | 8188| 0| r = fetch_token(tok, &p, end, env); 8189| 0| if (r < 0) { ------------------ | Branch (8189:15): [True: 0, False: 0] ------------------ 8190| 0| onig_node_free(condition); 8191| 0| return r; 8192| 0| } 8193| 0| r = prs_alts(&target, tok, term, &p, end, env, TRUE); ------------------ | | 59| 0|#define TRUE 1 ------------------ 8194| 0| if (r < 0) { ------------------ | Branch (8194:15): [True: 0, False: 0] ------------------ 8195| 0| onig_node_free(condition); 8196| 0| onig_node_free(target); 8197| 0| return r; 8198| 0| } 8199| | 8200| 0| if (then_is_empty != 0) { ------------------ | Branch (8200:15): [True: 0, False: 0] ------------------ 8201| 0| Else = target; 8202| 0| } 8203| 0| else { 8204| 0| if (ND_TYPE(target) == ND_ALT) { ------------------ | | 284| 0|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (8204:17): [True: 0, False: 0] ------------------ 8205| 0| Then = ND_CAR(target); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 8206| 0| if (ND_CDR(ND_CDR(target)) == NULL_NODE) { ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ if (ND_CDR(ND_CDR(target)) == NULL_NODE) { ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ | Branch (8206:19): [True: 0, False: 0] ------------------ 8207| 0| Else = ND_CAR(ND_CDR(target)); ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 8208| 0| cons_node_free_alone(ND_CDR(target)); ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 8209| 0| } 8210| 0| else { 8211| 0| Else = ND_CDR(target); ------------------ | | 299| 0|#define ND_CDR(node) (CONS_(node)->cdr) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ 8212| 0| } 8213| 0| cons_node_free_alone(target); 8214| 0| } 8215| 0| else { 8216| 0| Then = target; 8217| 0| Else = 0; 8218| 0| } 8219| 0| } 8220| | 8221| 0| *np = node_new_bag_if_else(condition, Then, Else); 8222| 0| if (IS_NULL(*np)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 8223| 0| onig_node_free(condition); 8224| 0| onig_node_free(Then); 8225| 0| onig_node_free(Else); 8226| 0| return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 8227| 0| } 8228| 0| } 8229| 0| goto end; 8230| 0| } 8231| 0| else { 8232| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8233| 0| } 8234| 0| break; 8235| | 8236| 0|#ifdef USE_CAPTURE_HISTORY 8237| 0| case '@': ------------------ | Branch (8237:5): [True: 0, False: 678] ------------------ 8238| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8239| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8240| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8241| 0| if (c == '<' || c == '\'') { ------------------ | Branch (8241:15): [True: 0, False: 0] | Branch (8241:27): [True: 0, False: 0] ------------------ 8242| 0| list_capture = 1; 8243| 0| goto named_group2; /* (?@...) */ 8244| 0| } 8245| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 8246| 0| } 8247| | 8248| 0| *np = node_new_memory(0); 8249| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8250| 0| num = scan_env_add_mem_entry(env); 8251| 0| if (num < 0) { ------------------ | Branch (8251:13): [True: 0, False: 0] ------------------ 8252| 0| return num; 8253| 0| } 8254| 0| else if (num >= (int )MEM_STATUS_BITS_NUM) { ------------------ | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) ------------------ | Branch (8254:18): [True: 0, False: 0] ------------------ 8255| 0| return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY; ------------------ | | 633| 0|#define ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY -222 ------------------ 8256| 0| } 8257| 0| BAG_(*np)->m.regnum = num; ------------------ | | 292| 0|#define BAG_(node) (&((node)->u.bag)) ------------------ 8258| 0| MEM_STATUS_ON_SIMPLE(env->cap_history, num); ------------------ | | 380| 0|#define MEM_STATUS_ON_SIMPLE(stats,n) do {\ | | 381| 0| if ((n) < (int )MEM_STATUS_BITS_NUM)\ | | ------------------ | | | | 361| 0|#define MEM_STATUS_BITS_NUM (sizeof(MemStatusType) * 8) | | ------------------ | | | Branch (381:9): [True: 0, False: 0] | | ------------------ | | 382| 0| (stats) |= ((MemStatusType )1 << (n));\ | | 383| 0|} while (0) | | ------------------ | | | Branch (383:10): [Folded, False: 0] | | ------------------ ------------------ 8259| 0| } 8260| 0| else { 8261| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8262| 0| } 8263| 0| break; 8264| 0|#endif 8265| | 8266| 0|#ifdef USE_WHOLE_OPTIONS 8267| 0| case 'C': ------------------ | Branch (8267:5): [True: 0, False: 678] ------------------ 8268| 0| case 'I': ------------------ | Branch (8268:5): [True: 0, False: 678] ------------------ 8269| 0| case 'L': ------------------ | Branch (8269:5): [True: 0, False: 678] ------------------ 8270| 0| if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_WHOLE_OPTIONS)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (8270:11): [True: 0, False: 0] ------------------ 8271| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8272| | 8273| 0| goto options_start; 8274| 0| break; 8275| 0|#endif 8276| | 8277| 0| case 'P': ------------------ | Branch (8277:5): [True: 0, False: 678] ------------------ 8278| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_CAPITAL_P_NAME)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8279| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8280| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8281| 0| if (c == '<') goto named_group1; ------------------ | Branch (8281:13): [True: 0, False: 0] ------------------ 8282| | 8283| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8284| 0| } 8285| | /* else fall */ 8286| 0| case 'W': case 'D': case 'S': ------------------ | Branch (8286:5): [True: 0, False: 678] | Branch (8286:15): [True: 0, False: 678] | Branch (8286:25): [True: 0, False: 678] ------------------ 8287| 0| case 'y': ------------------ | Branch (8287:5): [True: 0, False: 678] ------------------ 8288| 0| if (! IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_ONIGURUMA)) ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (8288:11): [True: 0, False: 0] ------------------ 8289| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8290| | /* else fall */ 8291| | 8292| |#ifdef USE_POSIXLINE_OPTION 8293| | case 'p': 8294| |#endif 8295| 0| case 'a': ------------------ | Branch (8295:5): [True: 0, False: 678] ------------------ 8296| 0| case '-': case 'i': case 'm': case 's': case 'x': ------------------ | Branch (8296:5): [True: 0, False: 678] | Branch (8296:15): [True: 0, False: 678] | Branch (8296:25): [True: 0, False: 678] | Branch (8296:35): [True: 0, False: 678] | Branch (8296:45): [True: 0, False: 678] ------------------ 8297| 0|#ifdef USE_WHOLE_OPTIONS 8298| 0| options_start: 8299| 0|#endif 8300| 0| { 8301| 0| int neg; 8302| 0|#ifdef USE_WHOLE_OPTIONS 8303| 0| int whole_options; 8304| 0| whole_options = FALSE; ------------------ | | 63| 0|#define FALSE 0 ------------------ 8305| 0|#endif 8306| 0| neg = FALSE; ------------------ | | 63| 0|#define FALSE 0 ------------------ 8307| 0| while (1) { ------------------ | Branch (8307:16): [True: 0, Folded] ------------------ 8308| 0| switch (c) { 8309| 0| case ':': ------------------ | Branch (8309:11): [True: 0, False: 0] ------------------ 8310| 0| case ')': ------------------ | Branch (8310:11): [True: 0, False: 0] ------------------ 8311| 0| break; 8312| | 8313| 0| case '-': neg = TRUE; break; ------------------ | | 59| 0|#define TRUE 1 ------------------ | Branch (8313:11): [True: 0, False: 0] ------------------ 8314| 0| case 'x': OPTION_NEGATE(option, ONIG_OPTION_EXTEND, neg); break; ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ | Branch (8314:11): [True: 0, False: 0] ------------------ 8315| 0| case 'i': OPTION_NEGATE(option, ONIG_OPTION_IGNORECASE, neg); break; ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ | Branch (8315:11): [True: 0, False: 0] ------------------ 8316| 0| case 's': ------------------ | Branch (8316:11): [True: 0, False: 0] ------------------ 8317| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8318| 0| OPTION_NEGATE(option, ONIG_OPTION_MULTILINE, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8319| 0| } 8320| 0| else 8321| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8322| 0| break; 8323| | 8324| 0| case 'm': ------------------ | Branch (8324:11): [True: 0, False: 0] ------------------ 8325| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8326| 0| OPTION_NEGATE(option, ONIG_OPTION_SINGLELINE, (neg == FALSE ? TRUE : FALSE)); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | | Branch (391:41): [True: 0, False: 0] | | ------------------ ------------------ 8327| 0| } 8328| 0| else if (IS_SYNTAX_OP2(env->syntax, ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8329| 0| ONIG_SYN_OP2_OPTION_ONIGURUMA|ONIG_SYN_OP2_OPTION_RUBY)) { 8330| 0| OPTION_NEGATE(option, ONIG_OPTION_MULTILINE, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8331| 0| } 8332| 0| else 8333| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8334| 0| break; 8335| |#ifdef USE_POSIXLINE_OPTION 8336| | case 'p': 8337| | OPTION_NEGATE(option, ONIG_OPTION_MULTILINE|ONIG_OPTION_SINGLELINE, neg); 8338| | break; 8339| |#endif 8340| 0| case 'W': ------------------ | Branch (8340:11): [True: 0, False: 0] ------------------ 8341| 0| if (! IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_ONIGURUMA)) ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (8341:17): [True: 0, False: 0] ------------------ 8342| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8343| 0| OPTION_NEGATE(option, ONIG_OPTION_WORD_IS_ASCII, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8344| 0| break; 8345| 0| case 'D': ------------------ | Branch (8345:11): [True: 0, False: 0] ------------------ 8346| 0| if (! IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_ONIGURUMA)) ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (8346:17): [True: 0, False: 0] ------------------ 8347| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8348| 0| OPTION_NEGATE(option, ONIG_OPTION_DIGIT_IS_ASCII, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8349| 0| break; 8350| 0| case 'S': ------------------ | Branch (8350:11): [True: 0, False: 0] ------------------ 8351| 0| if (! IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_ONIGURUMA)) ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (8351:17): [True: 0, False: 0] ------------------ 8352| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8353| 0| OPTION_NEGATE(option, ONIG_OPTION_SPACE_IS_ASCII, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8354| 0| break; 8355| 0| case 'P': ------------------ | Branch (8355:11): [True: 0, False: 0] ------------------ 8356| 0| if (! IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_ONIGURUMA)) ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (8356:17): [True: 0, False: 0] ------------------ 8357| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8358| 0| OPTION_NEGATE(option, ONIG_OPTION_POSIX_IS_ASCII, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8359| 0| break; 8360| | 8361| 0| case 'y': /* y{g}, y{w} */ ------------------ | Branch (8361:11): [True: 0, False: 0] ------------------ 8362| 0| { 8363| 0| if (! IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_ONIGURUMA)) ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (8363:19): [True: 0, False: 0] ------------------ 8364| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8365| | 8366| 0| if (neg == TRUE) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 59| 0|#define TRUE 1 ------------------ if (neg == TRUE) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ | Branch (8366:19): [True: 0, False: 0] ------------------ 8367| | 8368| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8369| 0| if (! PPEEK_IS('{')) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ if (! PPEEK_IS('{')) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ | Branch (8369:19): [True: 0, False: 0] ------------------ 8370| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8371| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8372| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8373| 0| switch (c) { 8374| 0| case 'g': ------------------ | Branch (8374:15): [True: 0, False: 0] ------------------ 8375| 0| if (! ONIGENC_IS_UNICODE_ENCODING(enc)) ------------------ | | 281| 0| (((enc)->flag & ENC_FLAG_UNICODE) != 0) | | ------------------ | | | | 133| 0|#define ENC_FLAG_UNICODE (1<<1) | | ------------------ ------------------ | Branch (8375:21): [True: 0, False: 0] ------------------ 8376| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8377| | 8378| 0| OPTION_NEGATE(option, ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER, FALSE); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [Folded, False: 0] | | ------------------ ------------------ 8379| 0| OPTION_NEGATE(option, ONIG_OPTION_TEXT_SEGMENT_WORD, TRUE); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, Folded] | | ------------------ ------------------ 8380| 0| break; 8381| 0|#ifdef USE_UNICODE_WORD_BREAK 8382| 0| case 'w': ------------------ | Branch (8382:15): [True: 0, False: 0] ------------------ 8383| 0| if (! ONIGENC_IS_UNICODE_ENCODING(enc)) ------------------ | | 281| 0| (((enc)->flag & ENC_FLAG_UNICODE) != 0) | | ------------------ | | | | 133| 0|#define ENC_FLAG_UNICODE (1<<1) | | ------------------ ------------------ | Branch (8383:21): [True: 0, False: 0] ------------------ 8384| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8385| | 8386| 0| OPTION_NEGATE(option, ONIG_OPTION_TEXT_SEGMENT_WORD, FALSE); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [Folded, False: 0] | | ------------------ ------------------ 8387| 0| OPTION_NEGATE(option, ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER, TRUE); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, Folded] | | ------------------ ------------------ 8388| 0| break; 8389| 0|#endif 8390| 0| default: ------------------ | Branch (8390:15): [True: 0, False: 0] ------------------ 8391| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8392| 0| break; 8393| 0| } 8394| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8395| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8396| 0| if (c != '}') ------------------ | Branch (8396:19): [True: 0, False: 0] ------------------ 8397| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8398| 0| } /* case 'y' */ 8399| 0| break; 8400| | 8401| 0| case 'a': ------------------ | Branch (8401:11): [True: 0, False: 0] ------------------ 8402| 0| if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_PYTHON)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (8402:17): [True: 0, False: 0] ------------------ 8403| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8404| | 8405| 0| OPTION_NEGATE(option, ONIG_OPTION_POSIX_IS_ASCII, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8406| 0| break; 8407| | 8408| 0|#ifdef USE_WHOLE_OPTIONS 8409| 0| case 'C': ------------------ | Branch (8409:11): [True: 0, False: 0] ------------------ 8410| 0| if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_WHOLE_OPTIONS)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (8410:17): [True: 0, False: 0] ------------------ 8411| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8412| | 8413| 0| if (neg == TRUE) return ONIGERR_INVALID_GROUP_OPTION; ------------------ | | 59| 0|#define TRUE 1 ------------------ if (neg == TRUE) return ONIGERR_INVALID_GROUP_OPTION; ------------------ | | 607| 0|#define ONIGERR_INVALID_GROUP_OPTION -120 ------------------ | Branch (8413:17): [True: 0, False: 0] ------------------ 8414| 0| OPTION_NEGATE(option, ONIG_OPTION_DONT_CAPTURE_GROUP, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8415| 0| whole_options = TRUE; ------------------ | | 59| 0|#define TRUE 1 ------------------ 8416| 0| break; 8417| | 8418| 0| case 'I': ------------------ | Branch (8418:11): [True: 0, False: 0] ------------------ 8419| 0| if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_WHOLE_OPTIONS)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (8419:17): [True: 0, False: 0] ------------------ 8420| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8421| | 8422| 0| if (neg == TRUE) return ONIGERR_INVALID_GROUP_OPTION; ------------------ | | 59| 0|#define TRUE 1 ------------------ if (neg == TRUE) return ONIGERR_INVALID_GROUP_OPTION; ------------------ | | 607| 0|#define ONIGERR_INVALID_GROUP_OPTION -120 ------------------ | Branch (8422:17): [True: 0, False: 0] ------------------ 8423| 0| OPTION_NEGATE(option, ONIG_OPTION_IGNORECASE_IS_ASCII, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8424| 0| whole_options = TRUE; ------------------ | | 59| 0|#define TRUE 1 ------------------ 8425| 0| break; 8426| | 8427| 0| case 'L': ------------------ | Branch (8427:11): [True: 0, False: 0] ------------------ 8428| 0| if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_WHOLE_OPTIONS)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (8428:17): [True: 0, False: 0] ------------------ 8429| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8430| | 8431| 0| if (neg == TRUE) return ONIGERR_INVALID_GROUP_OPTION; ------------------ | | 59| 0|#define TRUE 1 ------------------ if (neg == TRUE) return ONIGERR_INVALID_GROUP_OPTION; ------------------ | | 607| 0|#define ONIGERR_INVALID_GROUP_OPTION -120 ------------------ | Branch (8431:17): [True: 0, False: 0] ------------------ 8432| 0| OPTION_NEGATE(option, ONIG_OPTION_FIND_LONGEST, neg); ------------------ | | 391| 0|#define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (391:40): [True: 0, False: 0] | | ------------------ ------------------ 8433| 0| whole_options = TRUE; ------------------ | | 59| 0|#define TRUE 1 ------------------ 8434| 0| break; 8435| 0|#endif 8436| | 8437| 0| default: ------------------ | Branch (8437:11): [True: 0, False: 0] ------------------ 8438| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8439| 0| } 8440| | 8441| 0| if (c == ')') { ------------------ | Branch (8441:15): [True: 0, False: 0] ------------------ 8442| 0| *np = node_new_option(option); 8443| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8444| | 8445| 0|#ifdef USE_WHOLE_OPTIONS 8446| 0| if (whole_options == TRUE) { ------------------ | | 59| 0|#define TRUE 1 ------------------ | Branch (8446:17): [True: 0, False: 0] ------------------ 8447| 0| r = set_whole_options(option, env); 8448| 0| if (r != 0) return r; ------------------ | Branch (8448:19): [True: 0, False: 0] ------------------ 8449| 0| ND_STATUS_ADD(*np, WHOLE_OPTIONS); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 353| 0|#define ND_ST_WHOLE_OPTIONS (1<<28) | | ------------------ ------------------ 8450| 0| } 8451| 0|#endif 8452| 0| *src = p; 8453| 0| return 2; /* option only */ 8454| 0| } 8455| 0| else if (c == ':') { ------------------ | Branch (8455:20): [True: 0, False: 0] ------------------ 8456| 0| OnigOptionType prev = env->options; 8457| | 8458| 0| env->options = option; 8459| 0|#ifdef USE_WHOLE_OPTIONS 8460| 0| if (whole_options == TRUE) { ------------------ | | 59| 0|#define TRUE 1 ------------------ | Branch (8460:17): [True: 0, False: 0] ------------------ 8461| 0| r = set_whole_options(option, env); 8462| 0| if (r != 0) return r; ------------------ | Branch (8462:19): [True: 0, False: 0] ------------------ 8463| 0| } 8464| 0|#endif 8465| 0| r = fetch_token(tok, &p, end, env); 8466| 0| if (r < 0) return r; ------------------ | Branch (8466:17): [True: 0, False: 0] ------------------ 8467| 0| r = prs_alts(&target, tok, term, &p, end, env, FALSE); ------------------ | | 63| 0|#define FALSE 0 ------------------ 8468| 0| env->options = prev; 8469| 0| if (r < 0) { ------------------ | Branch (8469:17): [True: 0, False: 0] ------------------ 8470| 0| onig_node_free(target); 8471| 0| return r; 8472| 0| } 8473| | 8474| 0| *np = node_new_option(option); 8475| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8476| 0| ND_BODY(*np) = target; ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 8477| 0| ND_STATUS_ADD(*np, WHOLE_OPTIONS); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 353| 0|#define ND_ST_WHOLE_OPTIONS (1<<28) | | ------------------ ------------------ 8478| | 8479| 0| *src = p; 8480| 0| return 0; 8481| 0| } 8482| | 8483| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 605| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 8484| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 8485| 0| } /* while (1) */ 8486| 0| } 8487| 0| break; 8488| | 8489| 0| default: ------------------ | Branch (8489:5): [True: 0, False: 678] ------------------ 8490| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 606| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 8491| 678| } 8492| 678| } 8493| 136|#ifdef USE_CALLOUT 8494| 136| else if (c == '*' && ------------------ | Branch (8494:12): [True: 0, False: 136] ------------------ 8495| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ASTERISK_CALLOUT_NAME)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 8496| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 8497| 0| r = prs_callout_of_name(np, ')', &p, end, env); 8498| 0| if (r != 0) return r; ------------------ | Branch (8498:9): [True: 0, False: 0] ------------------ 8499| | 8500| 0| goto end; 8501| 0| } 8502| 136|#endif 8503| 136| else { 8504| 136| if (OPTON_DONT_CAPTURE_GROUP(env->options)) ------------------ | | 413| 136|#define OPTON_DONT_CAPTURE_GROUP(option) ((option) & \ | | ------------------ | | | Branch (413:42): [True: 0, False: 136] | | ------------------ | | 414| 136| ONIG_OPTION_DONT_CAPTURE_GROUP) | | ------------------ | | | | 384| 136|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | ------------------ | | | | | | 383| 136|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | ------------------ | | | | | | | | 382| 136|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | ------------------ | | | | | | | | | | 381| 136|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 380| 136|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 379| 136|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 378| 136|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 377| 136|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8505| 0| goto group; 8506| | 8507| 136| *np = node_new_memory(0); 8508| 136| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 136|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 136|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 136] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8509| 136| num = scan_env_add_mem_entry(env); 8510| 136| if (num < 0) return num; ------------------ | Branch (8510:9): [True: 0, False: 136] ------------------ 8511| 136| BAG_(*np)->m.regnum = num; ------------------ | | 292| 136|#define BAG_(node) (&((node)->u.bag)) ------------------ 8512| 136| } 8513| | 8514| 814| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 204| 814|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 814|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 814] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 8515| 814| r = fetch_token(tok, &p, end, env); 8516| 814| if (r < 0) return r; ------------------ | Branch (8516:7): [True: 0, False: 814] ------------------ 8517| 814| r = prs_alts(&target, tok, term, &p, end, env, FALSE); ------------------ | | 63| 814|#define FALSE 0 ------------------ 8518| 814| if (r < 0) { ------------------ | Branch (8518:7): [True: 0, False: 814] ------------------ 8519| 0| onig_node_free(target); 8520| 0| return r; 8521| 0| } 8522| | 8523| 814| ND_BODY(*np) = target; ------------------ | | 394| 814|#define ND_BODY(node) ((node)->u.base.body) ------------------ 8524| | 8525| 814| if (ND_TYPE(*np) == ND_BAG) { ------------------ | | 284| 814|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ | Branch (8525:7): [True: 801, False: 13] ------------------ 8526| 801| if (BAG_(*np)->type == BAG_MEMORY) { ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ | Branch (8526:9): [True: 801, False: 0] ------------------ 8527| | /* Don't move this to previous of prs_alts() */ 8528| 801| r = scan_env_set_mem_node(env, BAG_(*np)->m.regnum, *np); ------------------ | | 292| 801|#define BAG_(node) (&((node)->u.bag)) ------------------ 8529| 801| if (r != 0) return r; ------------------ | Branch (8529:11): [True: 0, False: 801] ------------------ 8530| 801| } 8531| 801| } 8532| | 8533| 814| end: 8534| 814| *src = p; 8535| 814| return 0; 8536| 814|} regparse.c:node_new_anchor: 2499| 3.11k|{ 2500| 3.11k| Node* node; 2501| | 2502| 3.11k| node = node_new(); 2503| 3.11k| CHECK_NULL_RETURN(node); ------------------ | | 203| 3.11k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 3.11k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 3.11k] | | | | ------------------ | | ------------------ ------------------ 2504| | 2505| 3.11k| ND_SET_TYPE(node, ND_ANCHOR); ------------------ | | 285| 3.11k|#define ND_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype) ------------------ 2506| 3.11k| ANCHOR_(node)->type = type; ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 2507| 3.11k| ANCHOR_(node)->char_min_len = 0; ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 2508| 3.11k| ANCHOR_(node)->char_max_len = INFINITE_LEN; ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ ANCHOR_(node)->char_max_len = INFINITE_LEN; ------------------ | | 218| 3.11k|#define INFINITE_LEN ONIG_INFINITE_DISTANCE | | ------------------ | | | | 88| 3.11k|#define ONIG_INFINITE_DISTANCE ~((OnigLen )0) | | ------------------ ------------------ 2509| 3.11k| ANCHOR_(node)->ascii_mode = 0; ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 2510| 3.11k| ANCHOR_(node)->lead_node = NULL_NODE; ------------------ | | 293| 3.11k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ ANCHOR_(node)->lead_node = NULL_NODE; ------------------ | | 266| 3.11k|#define NULL_NODE ((Node* )0) ------------------ 2511| 3.11k| return node; 2512| 3.11k|} regparse.c:scan_env_add_mem_entry: 2140| 801|{ 2141| 801| int i, need, alloc; 2142| 801| MemEnv* p; 2143| | 2144| 801| need = env->num_mem + 1; 2145| 801| if (need > MaxCaptureNum && MaxCaptureNum != 0) ------------------ | Branch (2145:7): [True: 0, False: 801] | Branch (2145:31): [True: 0, False: 0] ------------------ 2146| 0| return ONIGERR_TOO_MANY_CAPTURES; ------------------ | | 622| 0|#define ONIGERR_TOO_MANY_CAPTURES -210 ------------------ 2147| | 2148| 801| if (need >= PARSEENV_MEMENV_SIZE) { ------------------ | | 400| 801|#define PARSEENV_MEMENV_SIZE 8 ------------------ | Branch (2148:7): [True: 0, False: 801] ------------------ 2149| 0| if (env->mem_alloc <= need) { ------------------ | Branch (2149:9): [True: 0, False: 0] ------------------ 2150| 0| if (IS_NULL(env->mem_env_dynamic)) { ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 2151| 0| alloc = INIT_PARSEENV_MEMENV_ALLOC_SIZE; ------------------ | | 2103| 0|#define INIT_PARSEENV_MEMENV_ALLOC_SIZE 16 ------------------ 2152| 0| p = (MemEnv* )xmalloc(sizeof(MemEnv) * alloc); ------------------ | | 227| 0|#define xmalloc malloc ------------------ 2153| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 2154| 0| xmemcpy(p, env->mem_env_static, sizeof(env->mem_env_static)); ------------------ | | 181| 0|#define xmemcpy memcpy ------------------ 2155| 0| } 2156| 0| else { 2157| 0| alloc = env->mem_alloc * 2; 2158| 0| p = (MemEnv* )xrealloc(env->mem_env_dynamic, sizeof(MemEnv) * alloc); ------------------ | | 228| 0|#define xrealloc realloc ------------------ 2159| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 2160| 0| } 2161| | 2162| 0| for (i = env->num_mem + 1; i < alloc; i++) { ------------------ | Branch (2162:34): [True: 0, False: 0] ------------------ 2163| 0| p[i].mem_node = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 2164| 0| p[i].empty_repeat_node = NULL_NODE; ------------------ | | 266| 0|#define NULL_NODE ((Node* )0) ------------------ 2165| 0| } 2166| | 2167| 0| env->mem_env_dynamic = p; 2168| 0| env->mem_alloc = alloc; 2169| 0| } 2170| 0| } 2171| | 2172| 801| env->num_mem++; 2173| 801| return env->num_mem; 2174| 801|} regparse.c:name_add: 1085| 665|{ 1086| 665| int r; 1087| 665| int alloc; 1088| 665| NameEntry* e; 1089| 665| NameTable* t = (NameTable* )reg->name_table; 1090| | 1091| 665| if (name_end - name <= 0) ------------------ | Branch (1091:7): [True: 0, False: 665] ------------------ 1092| 0| return ONIGERR_EMPTY_GROUP_NAME; ------------------ | | 625| 0|#define ONIGERR_EMPTY_GROUP_NAME -214 ------------------ 1093| | 1094| 665| e = name_find(reg, name, name_end); 1095| 665| if (IS_NULL(e)) { ------------------ | | 201| 665|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 665, False: 0] | | ------------------ ------------------ 1096| 665|#ifdef USE_ST_LIBRARY 1097| 665| if (IS_NULL(t)) { ------------------ | | 201| 665|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 503, False: 162] | | ------------------ ------------------ 1098| 503| t = onig_st_init_strend_table_with_size(INIT_NAMES_ALLOC_NUM); ------------------ | | 751| 503|#define INIT_NAMES_ALLOC_NUM 5 ------------------ 1099| 503| CHECK_NULL_RETURN_MEMERR(t); ------------------ | | 204| 503|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 503|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 503] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1100| 503| reg->name_table = (void* )t; 1101| 503| } 1102| 665| e = (NameEntry* )xmalloc(sizeof(NameEntry)); ------------------ | | 227| 665|#define xmalloc malloc ------------------ 1103| 665| CHECK_NULL_RETURN_MEMERR(e); ------------------ | | 204| 665|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 665|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 665] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1104| | 1105| 665| e->name = onigenc_strdup(reg->enc, name, name_end); 1106| 665| if (IS_NULL(e->name)) { ------------------ | | 201| 665|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 665] | | ------------------ ------------------ 1107| 0| xfree(e); return ONIGERR_MEMORY; ------------------ | | 230| 0|#define xfree free ------------------ xfree(e); return ONIGERR_MEMORY; ------------------ | | 570| 0|#define ONIGERR_MEMORY -5 ------------------ 1108| 0| } 1109| 665| r = onig_st_insert_strend(t, e->name, (e->name + (name_end - name)), 1110| 665| (HashDataType )e); 1111| 665| if (r < 0) return r; ------------------ | Branch (1111:9): [True: 0, False: 665] ------------------ 1112| | 1113| 665| e->name_len = (int )(name_end - name); 1114| 665| e->back_num = 0; 1115| 665| e->back_alloc = 0; 1116| 665| e->back_refs = (int* )NULL; 1117| | 1118| |#else 1119| | 1120| | if (IS_NULL(t)) { 1121| | alloc = INIT_NAMES_ALLOC_NUM; 1122| | t = (NameTable* )xmalloc(sizeof(NameTable)); 1123| | CHECK_NULL_RETURN_MEMERR(t); 1124| | t->e = NULL; 1125| | t->alloc = 0; 1126| | t->num = 0; 1127| | 1128| | t->e = (NameEntry* )xmalloc(sizeof(NameEntry) * alloc); 1129| | if (IS_NULL(t->e)) { 1130| | xfree(t); 1131| | return ONIGERR_MEMORY; 1132| | } 1133| | t->alloc = alloc; 1134| | reg->name_table = t; 1135| | goto clear; 1136| | } 1137| | else if (t->num == t->alloc) { 1138| | int i; 1139| | 1140| | alloc = t->alloc * 2; 1141| | t->e = (NameEntry* )xrealloc(t->e, sizeof(NameEntry) * alloc); 1142| | CHECK_NULL_RETURN_MEMERR(t->e); 1143| | t->alloc = alloc; 1144| | 1145| | clear: 1146| | for (i = t->num; i < t->alloc; i++) { 1147| | t->e[i].name = NULL; 1148| | t->e[i].name_len = 0; 1149| | t->e[i].back_num = 0; 1150| | t->e[i].back_alloc = 0; 1151| | t->e[i].back_refs = (int* )NULL; 1152| | } 1153| | } 1154| | e = &(t->e[t->num]); 1155| | t->num++; 1156| | e->name = onigenc_strdup(reg->enc, name, name_end); 1157| | if (IS_NULL(e->name)) return ONIGERR_MEMORY; 1158| | e->name_len = name_end - name; 1159| |#endif 1160| 665| } 1161| | 1162| 665| if (e->back_num >= 1 && ------------------ | Branch (1162:7): [True: 0, False: 665] ------------------ 1163| 0| ! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (1163:7): [True: 0, False: 0] ------------------ 1164| 0| onig_scan_env_set_error_string(env, ONIGERR_MULTIPLEX_DEFINED_NAME, ------------------ | | 630| 0|#define ONIGERR_MULTIPLEX_DEFINED_NAME -219 ------------------ 1165| 0| name, name_end); 1166| 0| return ONIGERR_MULTIPLEX_DEFINED_NAME; ------------------ | | 630| 0|#define ONIGERR_MULTIPLEX_DEFINED_NAME -219 ------------------ 1167| 0| } 1168| | 1169| 665| e->back_num++; 1170| 665| if (e->back_num == 1) { ------------------ | Branch (1170:7): [True: 665, False: 0] ------------------ 1171| 665| e->back_ref1 = backref; 1172| 665| } 1173| 0| else { 1174| 0| if (e->back_num == 2) { ------------------ | Branch (1174:9): [True: 0, False: 0] ------------------ 1175| 0| alloc = INIT_NAME_BACKREFS_ALLOC_NUM; ------------------ | | 738| 0|#define INIT_NAME_BACKREFS_ALLOC_NUM 8 ------------------ 1176| 0| e->back_refs = (int* )xmalloc(sizeof(int) * alloc); ------------------ | | 227| 0|#define xmalloc malloc ------------------ 1177| 0| CHECK_NULL_RETURN_MEMERR(e->back_refs); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1178| 0| e->back_alloc = alloc; 1179| 0| e->back_refs[0] = e->back_ref1; 1180| 0| e->back_refs[1] = backref; 1181| 0| } 1182| 0| else { 1183| 0| if (e->back_num > e->back_alloc) { ------------------ | Branch (1183:11): [True: 0, False: 0] ------------------ 1184| 0| alloc = e->back_alloc * 2; 1185| 0| e->back_refs = (int* )xrealloc(e->back_refs, sizeof(int) * alloc); ------------------ | | 228| 0|#define xrealloc realloc ------------------ 1186| 0| CHECK_NULL_RETURN_MEMERR(e->back_refs); ------------------ | | 204| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1187| 0| e->back_alloc = alloc; 1188| 0| } 1189| 0| e->back_refs[e->back_num - 1] = backref; 1190| 0| } 1191| 0| } 1192| | 1193| 665| return 0; 1194| 665|} regparse.c:node_new_memory: 2704| 801|{ 2705| 801| Node* node = node_new_bag(BAG_MEMORY); 2706| 801| CHECK_NULL_RETURN(node); ------------------ | | 203| 801|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 801|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 801] | | | | ------------------ | | ------------------ ------------------ 2707| 801| if (is_named != 0) ------------------ | Branch (2707:7): [True: 665, False: 136] ------------------ 2708| 665| ND_STATUS_ADD(node, NAMED_GROUP); ------------------ | | 357| 665|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 665|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 334| 665|#define ND_ST_NAMED_GROUP (1<<9) | | ------------------ ------------------ 2709| | 2710| 801| return node; 2711| 801|} regparse.c:scan_env_set_mem_node: 2178| 801|{ 2179| 801| if (env->num_mem >= num) ------------------ | Branch (2179:7): [True: 801, False: 0] ------------------ 2180| 801| PARSEENV_MEMENV(env)[num].mem_node = node; ------------------ | | 402| 801| (IS_NOT_NULL((senv)->mem_env_dynamic) ? \ | | ------------------ | | | | 202| 801|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (202:39): [True: 0, False: 801] | | | | ------------------ | | ------------------ | | 403| 801| (senv)->mem_env_dynamic : (senv)->mem_env_static) ------------------ 2181| 0| else 2182| 0| return ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 2183| 801| return 0; 2184| 801|} regparse.c:node_new_str_with_options: 3528| 46.4k|{ 3529| 46.4k| Node* node; 3530| 46.4k| node = node_new_str(s, end); 3531| | 3532| 46.4k| if (OPTON_IGNORECASE(options)) ------------------ | | 52| 46.4k|#define OPTON_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 377| 46.4k|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ | | | Branch (52:38): [True: 2.35k, False: 44.1k] | | ------------------ ------------------ 3533| 2.35k| ND_STATUS_ADD(node, IGNORECASE); ------------------ | | 357| 2.35k|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 2.35k|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 346| 2.35k|#define ND_ST_IGNORECASE (1<<21) | | ------------------ ------------------ 3534| | 3535| 46.4k| return node; 3536| 46.4k|} regparse.c:node_new_ctype: 2375| 562|{ 2376| 562| Node* node = node_new(); 2377| 562| CHECK_NULL_RETURN(node); ------------------ | | 203| 562|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 562|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 562] | | | | ------------------ | | ------------------ ------------------ 2378| | 2379| 562| ND_SET_TYPE(node, ND_CTYPE); ------------------ | | 285| 562|#define ND_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype) ------------------ 2380| 562| CTYPE_(node)->ctype = type; ------------------ | | 289| 562|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 2381| 562| CTYPE_(node)->not = not; ------------------ | | 289| 562|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ 2382| 562| CTYPE_(node)->ascii_mode = OPTON_IS_ASCII_MODE_CTYPE(type, options); ------------------ | | 289| 562|#define CTYPE_(node) (&((node)->u.ctype)) ------------------ CTYPE_(node)->ascii_mode = OPTON_IS_ASCII_MODE_CTYPE(type, options); ------------------ | | 64| 562| ((ctype) >= 0 && \ | | ------------------ | | | Branch (64:4): [True: 0, False: 562] | | ------------------ | | 65| 562| (((ctype) < ONIGENC_CTYPE_ASCII && OPTON_POSIX_ASCII(options)) ||\ | | ------------------ | | | | 60| 0|#define OPTON_POSIX_ASCII(option) ((option) & ONIG_OPTION_POSIX_IS_ASCII) | | | | ------------------ | | | | | | 396| 0|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (60:38): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (65:5): [True: 0, False: 0] | | ------------------ | | 66| 0| ((ctype) == ONIGENC_CTYPE_WORD && OPTON_WORD_ASCII(options)) ||\ | | ------------------ | | | | 55| 0| ((option) & (ONIG_OPTION_WORD_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | | | ------------------ | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | ------------------ | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | ((option) & (ONIG_OPTION_WORD_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | | | ------------------ | | | | | | 396| 0|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (66:5): [True: 0, False: 0] | | ------------------ | | 67| 0| ((ctype) == ONIGENC_CTYPE_DIGIT && OPTON_DIGIT_ASCII(options)) ||\ | | ------------------ | | | | 57| 0| ((option) & (ONIG_OPTION_DIGIT_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | | | ------------------ | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | ------------------ | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | ((option) & (ONIG_OPTION_DIGIT_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | | | ------------------ | | | | | | 396| 0|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (57:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (67:5): [True: 0, False: 0] | | ------------------ | | 68| 0| ((ctype) == ONIGENC_CTYPE_SPACE && OPTON_SPACE_ASCII(options)))) | | ------------------ | | | | 59| 0| ((option) & (ONIG_OPTION_SPACE_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | | | ------------------ | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | ((option) & (ONIG_OPTION_SPACE_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | | | ------------------ | | | | | | 396| 0|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (59:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (68:5): [True: 0, False: 0] | | ------------------ ------------------ 2383| 562| return node; 2384| 562|} regparse.c:prs_cc: 6933| 391|{ 6934| 391| int r, neg, len, fetched, and_start; 6935| 391| OnigCodePoint in_code, curr_code; 6936| 391| UChar *p; ------------------ | | 80| 391|#define UChar OnigUChar ------------------ 6937| 391| Node* node; 6938| 391| CClassNode *cc, *prev_cc; 6939| 391| CClassNode work_cc; 6940| 391| int curr_raw, in_raw; 6941| 391| CSTATE state; 6942| 391| CVAL in_type; 6943| 391| CVAL curr_type; 6944| | 6945| 391| *np = NULL_NODE; ------------------ | | 266| 391|#define NULL_NODE ((Node* )0) ------------------ 6946| 391| INC_PARSE_DEPTH(env->parse_depth); ------------------ | | 320| 391|#define INC_PARSE_DEPTH(d) do {\ | | 321| 391| (d)++;\ | | 322| 391| if ((d) > ParseDepthLimit) \ | | ------------------ | | | Branch (322:7): [True: 0, False: 391] | | ------------------ | | 323| 391| return ONIGERR_PARSE_DEPTH_LIMIT_OVER;\ | | ------------------ | | | | 577| 0|#define ONIGERR_PARSE_DEPTH_LIMIT_OVER -16 | | ------------------ | | 324| 391|} while (0) | | ------------------ | | | Branch (324:10): [Folded, False: 391] | | ------------------ ------------------ 6947| | 6948| 391| state = CS_START; 6949| 391| prev_cc = (CClassNode* )NULL; 6950| 391| r = fetch_token_cc(tok, src, end, env, state); 6951| 391| if (r == TK_CHAR && tok->u.code == (OnigCodePoint )'^' && tok->escaped == 0) { ------------------ | Branch (6951:7): [True: 391, False: 0] | Branch (6951:23): [True: 106, False: 285] | Branch (6951:61): [True: 106, False: 0] ------------------ 6952| 106| neg = 1; 6953| 106| r = fetch_token_cc(tok, src, end, env, state); 6954| 106| } 6955| 285| else { 6956| 285| neg = 0; 6957| 285| } 6958| | 6959| 391| if (r < 0) return r; ------------------ | Branch (6959:7): [True: 0, False: 391] ------------------ 6960| 391| if (r == TK_CC_CLOSE) { ------------------ | Branch (6960:7): [True: 0, False: 391] ------------------ 6961| 0| if (! code_exist_check((OnigCodePoint )']', ------------------ | Branch (6961:9): [True: 0, False: 0] ------------------ 6962| 0| *src, env->pattern_end, 1, env)) 6963| 0| return ONIGERR_EMPTY_CHAR_CLASS; ------------------ | | 590| 0|#define ONIGERR_EMPTY_CHAR_CLASS -102 ------------------ 6964| | 6965| 0| CC_ESC_WARN(env, (UChar* )"]"); 6966| 0| r = tok->type = TK_CHAR; /* allow []...] */ 6967| 0| } 6968| | 6969| 391| *np = node = node_new_cclass(); 6970| 391| CHECK_NULL_RETURN_MEMERR(node); ------------------ | | 204| 391|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 201| 391|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 391] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 570| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6971| 391| cc = CCLASS_(node); ------------------ | | 288| 391|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 6972| | 6973| 391| and_start = 0; 6974| 391| curr_type = CV_UNDEF; 6975| | 6976| 391| p = *src; 6977| 1.50k| while (r != TK_CC_CLOSE) { ------------------ | Branch (6977:10): [True: 1.10k, False: 391] ------------------ 6978| 1.10k| fetched = 0; 6979| 1.10k| switch (r) { 6980| 750| case TK_CHAR: ------------------ | Branch (6980:5): [True: 750, False: 359] ------------------ 6981| 750| any_char_in: 6982| 750| len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.code); ------------------ | | 285| 750|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code) ------------------ 6983| 750| if (len < 0) { ------------------ | Branch (6983:11): [True: 0, False: 750] ------------------ 6984| 0| r = len; 6985| 0| goto err; 6986| 0| } 6987| 750| in_type = (len == 1) ? CV_SB : CV_MB; ------------------ | Branch (6987:17): [True: 750, False: 0] ------------------ 6988| 750| in_code = tok->u.code; 6989| 750| in_raw = 0; 6990| 750| goto val_entry2; 6991| 0| break; 6992| | 6993| 0| case TK_CRUDE_BYTE: ------------------ | Branch (6993:5): [True: 0, False: 1.10k] ------------------ 6994| | /* tok->base_num != 0 : octal or hexadec. */ 6995| 0| if (! ONIGENC_IS_SINGLEBYTE(env->enc) && tok->base_num != 0) { ------------------ | | 254| 0|#define ONIGENC_IS_SINGLEBYTE(enc) (ONIGENC_MBC_MAXLEN(enc) == 1) | | ------------------ | | | | 280| 0|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ | Branch (6995:11): [True: 0, False: 0] | Branch (6995:48): [True: 0, False: 0] ------------------ 6996| 0| int i, j; 6997| 0| UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN]; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 6998| 0| UChar* bufe = buf + ONIGENC_CODE_TO_MBC_MAXLEN; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ UChar* bufe = buf + ONIGENC_CODE_TO_MBC_MAXLEN; ------------------ | | 225| 0|#define ONIGENC_CODE_TO_MBC_MAXLEN 7 ------------------ 6999| 0| UChar* psave = p; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 7000| 0| int base_num = tok->base_num; 7001| | 7002| 0| buf[0] = tok->u.byte; 7003| 0| for (i = 1; i < ONIGENC_MBC_MAXLEN(env->enc); i++) { ------------------ | | 280| 0|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) ------------------ | Branch (7003:21): [True: 0, False: 0] ------------------ 7004| 0| r = fetch_token_cc(tok, &p, end, env, CS_COMPLETE); 7005| 0| if (r < 0) goto err; ------------------ | Branch (7005:15): [True: 0, False: 0] ------------------ 7006| 0| if (r != TK_CRUDE_BYTE || tok->base_num != base_num) { ------------------ | Branch (7006:15): [True: 0, False: 0] | Branch (7006:37): [True: 0, False: 0] ------------------ 7007| 0| fetched = 1; 7008| 0| break; 7009| 0| } 7010| 0| buf[i] = tok->u.byte; 7011| 0| } 7012| | 7013| 0| if (i < ONIGENC_MBC_MINLEN(env->enc)) { ------------------ | | 282| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (7013:13): [True: 0, False: 0] ------------------ 7014| 0| r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING; ------------------ | | 618| 0|#define ONIGERR_TOO_SHORT_MULTI_BYTE_STRING -206 ------------------ 7015| 0| goto err; 7016| 0| } 7017| | 7018| | /* clear buf tail */ 7019| 0| for (j = i; j < ONIGENC_CODE_TO_MBC_MAXLEN; j++) buf[j] = '\0'; ------------------ | | 225| 0|#define ONIGENC_CODE_TO_MBC_MAXLEN 7 ------------------ | Branch (7019:21): [True: 0, False: 0] ------------------ 7020| | 7021| 0| len = enclen(env->enc, buf); ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 7022| 0| if (i < len) { ------------------ | Branch (7022:13): [True: 0, False: 0] ------------------ 7023| 0| r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING; ------------------ | | 618| 0|#define ONIGERR_TOO_SHORT_MULTI_BYTE_STRING -206 ------------------ 7024| 0| goto err; 7025| 0| } 7026| 0| else if (i > len) { /* fetch back */ ------------------ | Branch (7026:18): [True: 0, False: 0] ------------------ 7027| 0| p = psave; 7028| 0| for (i = 1; i < len; i++) { ------------------ | Branch (7028:23): [True: 0, False: 0] ------------------ 7029| 0| r = fetch_token_cc(tok, &p, end, env, CS_COMPLETE); 7030| 0| if (r < 0) goto err; ------------------ | Branch (7030:17): [True: 0, False: 0] ------------------ 7031| 0| } 7032| 0| fetched = 0; 7033| 0| } 7034| | 7035| 0| if (i == 1) { ------------------ | Branch (7035:13): [True: 0, False: 0] ------------------ 7036| 0| in_code = (OnigCodePoint )buf[0]; 7037| 0| goto crude_single; 7038| 0| } 7039| 0| else { 7040| 0| if (! ONIGENC_IS_VALID_MBC_STRING(env->enc, buf, buf + len)) { ------------------ | | 271| 0| (enc)->is_valid_mbc_string(s,end) ------------------ | Branch (7040:15): [True: 0, False: 0] ------------------ 7041| 0| r = ONIGERR_INVALID_WIDE_CHAR_VALUE; ------------------ | | 645| 0|#define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 ------------------ 7042| 0| goto err; 7043| 0| } 7044| | 7045| 0| in_code = ONIGENC_MBC_TO_CODE(env->enc, buf, bufe); ------------------ | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 7046| 0| in_type = CV_MB; 7047| 0| } 7048| 0| } 7049| 0| else { 7050| 0| in_code = (OnigCodePoint )tok->u.byte; 7051| 0| crude_single: 7052| 0| in_type = CV_SB; 7053| 0| } 7054| 0| in_raw = 1; 7055| 0| goto val_entry2; 7056| 0| break; 7057| | 7058| 0| case TK_CODE_POINT: ------------------ | Branch (7058:5): [True: 0, False: 1.10k] ------------------ 7059| 0| in_code = tok->u.code; 7060| 0| in_raw = 1; 7061| 0| val_entry: 7062| 0| len = ONIGENC_CODE_TO_MBCLEN(env->enc, in_code); ------------------ | | 285| 0|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code) ------------------ 7063| 0| if (len < 0) { ------------------ | Branch (7063:11): [True: 0, False: 0] ------------------ 7064| 0| if (state != CS_RANGE || ------------------ | Branch (7064:13): [True: 0, False: 0] ------------------ 7065| 0| ! IS_SYNTAX_BV(env->syntax, ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (7065:13): [True: 0, False: 0] ------------------ 7066| 0| ONIG_SYN_ALLOW_INVALID_CODE_END_OF_RANGE_IN_CC) || 7067| 0| in_code < 0x100 || ONIGENC_MBC_MAXLEN(env->enc) == 1) { ------------------ | | 280| 0|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) ------------------ | Branch (7067:13): [True: 0, False: 0] | Branch (7067:32): [True: 0, False: 0] ------------------ 7068| 0| r = len; 7069| 0| goto err; 7070| 0| } 7071| 0| } 7072| 0| in_type = (len == 1 ? CV_SB : CV_MB); ------------------ | Branch (7072:18): [True: 0, False: 0] ------------------ 7073| 750| val_entry2: 7074| 750| r = cc_char_next(cc, &curr_code, in_code, &curr_raw, in_raw, in_type, 7075| 750| &curr_type, &state, env); 7076| 750| if (r != 0) goto err; ------------------ | Branch (7076:11): [True: 0, False: 750] ------------------ 7077| 750| break; 7078| | 7079| 750| case TK_CC_POSIX_BRACKET_OPEN: ------------------ | Branch (7079:5): [True: 0, False: 1.10k] ------------------ 7080| 0| r = prs_posix_bracket(cc, &p, end, env); 7081| 0| if (r < 0) goto err; ------------------ | Branch (7081:11): [True: 0, False: 0] ------------------ 7082| 0| if (r == 1) { /* is not POSIX bracket */ ------------------ | Branch (7082:11): [True: 0, False: 0] ------------------ 7083| 0| CC_ESC_WARN(env, (UChar* )"["); 7084| 0| p = tok->backp; 7085| 0| in_code = tok->u.code; 7086| 0| in_raw = 0; 7087| 0| goto val_entry; 7088| 0| } 7089| 0| goto next_cprop; 7090| 0| break; 7091| | 7092| 0| case TK_CHAR_TYPE: ------------------ | Branch (7092:5): [True: 0, False: 1.10k] ------------------ 7093| 0| r = add_ctype_to_cc(cc, tok->u.prop.ctype, tok->u.prop.not, env); 7094| 0| if (r != 0) goto err; ------------------ | Branch (7094:11): [True: 0, False: 0] ------------------ 7095| | 7096| 0| next_cprop: 7097| 0| r = cc_cprop_next(cc, &curr_code, &curr_type, &state, env); 7098| 0| if (r != 0) goto err; ------------------ | Branch (7098:11): [True: 0, False: 0] ------------------ 7099| 0| break; 7100| | 7101| 0| case TK_CHAR_PROPERTY: ------------------ | Branch (7101:5): [True: 0, False: 1.10k] ------------------ 7102| 0| { 7103| 0| int ctype = fetch_char_property_to_ctype(&p, end, env); 7104| 0| if (ctype < 0) { ------------------ | Branch (7104:13): [True: 0, False: 0] ------------------ 7105| 0| r = ctype; 7106| 0| goto err; 7107| 0| } 7108| 0| r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, env); 7109| 0| if (r != 0) goto err; ------------------ | Branch (7109:13): [True: 0, False: 0] ------------------ 7110| 0| goto next_cprop; 7111| 0| } 7112| 0| break; 7113| | 7114| 359| case TK_CC_RANGE: ------------------ | Branch (7114:5): [True: 359, False: 750] ------------------ 7115| 359| if (state == CS_VALUE) { ------------------ | Branch (7115:11): [True: 359, False: 0] ------------------ 7116| 359| r = fetch_token_cc(tok, &p, end, env, CS_RANGE); 7117| 359| if (r < 0) goto err; ------------------ | Branch (7117:13): [True: 0, False: 359] ------------------ 7118| | 7119| 359| fetched = 1; 7120| 359| if (r == TK_CC_CLOSE) { /* allow [x-] */ ------------------ | Branch (7120:13): [True: 0, False: 359] ------------------ 7121| 0| range_end_val: 7122| 0| in_code = (OnigCodePoint )'-'; 7123| 0| in_raw = 0; 7124| 0| goto val_entry; 7125| 0| } 7126| 359| else if (r == TK_CC_AND) { ------------------ | Branch (7126:18): [True: 0, False: 359] ------------------ 7127| 0| range_end_val_with_warning: 7128| 0| CC_ESC_WARN(env, (UChar* )"-"); 7129| 0| goto range_end_val; 7130| 0| } 7131| | 7132| 359| if (curr_type == CV_CPROP) { ------------------ | Branch (7132:13): [True: 0, False: 359] ------------------ 7133| 0| if (IS_SYNTAX_BV(env->syntax, ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 7134| 0| ONIG_SYN_ALLOW_CHAR_TYPE_FOLLOWED_BY_MINUS_IN_CC)) { 7135| 0| goto range_end_val_with_warning; 7136| 0| } 7137| 0| r = ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS; ------------------ | | 599| 0|#define ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS -112 ------------------ 7138| 0| goto err; 7139| 0| } 7140| | 7141| 359| state = CS_RANGE; 7142| 359| } 7143| 0| else if (state == CS_START) { ------------------ | Branch (7143:16): [True: 0, False: 0] ------------------ 7144| | /* [-xa] is allowed */ 7145| 0| in_code = tok->u.code; 7146| 0| in_raw = 0; 7147| | 7148| 0| r = fetch_token_cc(tok, &p, end, env, CS_VALUE); 7149| 0| if (r < 0) goto err; ------------------ | Branch (7149:13): [True: 0, False: 0] ------------------ 7150| | 7151| 0| fetched = 1; 7152| | /* [--x] or [a&&-x] is warned. */ 7153| 0| if (r == TK_CC_RANGE || and_start != 0) ------------------ | Branch (7153:13): [True: 0, False: 0] | Branch (7153:33): [True: 0, False: 0] ------------------ 7154| 0| CC_ESC_WARN(env, (UChar* )"-"); 7155| | 7156| 0| goto val_entry; 7157| 0| } 7158| 0| else if (state == CS_RANGE) { ------------------ | Branch (7158:16): [True: 0, False: 0] ------------------ 7159| 0| CC_ESC_WARN(env, (UChar* )"-"); 7160| 0| goto any_char_in; /* [!--] is allowed */ 7161| 0| } 7162| 0| else { /* CS_COMPLETE */ 7163| 0| r = fetch_token_cc(tok, &p, end, env, CS_VALUE); 7164| 0| if (r < 0) goto err; ------------------ | Branch (7164:13): [True: 0, False: 0] ------------------ 7165| | 7166| 0| fetched = 1; 7167| 0| if (r == TK_CC_CLOSE) { ------------------ | Branch (7167:13): [True: 0, False: 0] ------------------ 7168| 0| goto range_end_val; /* allow [a-b-] */ 7169| 0| } 7170| 0| else if (r == TK_CC_AND) { ------------------ | Branch (7170:18): [True: 0, False: 0] ------------------ 7171| 0| goto range_end_val_with_warning; 7172| 0| } 7173| | 7174| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 7175| | /* [0-9-a] is allowed as [0-9\-a] */ 7176| 0| goto range_end_val_with_warning; 7177| 0| } 7178| 0| r = ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS; ------------------ | | 599| 0|#define ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS -112 ------------------ 7179| 0| goto err; 7180| 0| } 7181| 359| break; 7182| | 7183| 359| case TK_CC_OPEN_CC: /* [ */ ------------------ | Branch (7183:5): [True: 0, False: 1.10k] ------------------ 7184| 0| { 7185| 0| Node *anode; 7186| 0| CClassNode* acc; 7187| | 7188| 0| if (state == CS_VALUE) { ------------------ | Branch (7188:13): [True: 0, False: 0] ------------------ 7189| 0| r = cc_char_next(cc, &curr_code, 0, &curr_raw, 0, curr_type, &curr_type, 7190| 0| &state, env); 7191| 0| if (r != 0) goto err; ------------------ | Branch (7191:15): [True: 0, False: 0] ------------------ 7192| 0| } 7193| 0| state = CS_COMPLETE; 7194| | 7195| 0| r = prs_cc(&anode, tok, &p, end, env); 7196| 0| if (r != 0) { ------------------ | Branch (7196:13): [True: 0, False: 0] ------------------ 7197| 0| onig_node_free(anode); 7198| 0| goto cc_open_err; 7199| 0| } 7200| 0| acc = CCLASS_(anode); ------------------ | | 288| 0|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ 7201| 0| r = or_cclass(cc, acc, env->enc); 7202| 0| onig_node_free(anode); 7203| | 7204| 0| cc_open_err: 7205| 0| if (r != 0) goto err; ------------------ | Branch (7205:13): [True: 0, False: 0] ------------------ 7206| 0| } 7207| 0| break; 7208| | 7209| 0| case TK_CC_AND: /* && */ ------------------ | Branch (7209:5): [True: 0, False: 1.10k] ------------------ 7210| 0| { 7211| 0| if (state == CS_VALUE) { ------------------ | Branch (7211:13): [True: 0, False: 0] ------------------ 7212| 0| r = cc_char_next(cc, &curr_code, 0, &curr_raw, 0, curr_type, &curr_type, 7213| 0| &state, env); 7214| 0| if (r != 0) goto err; ------------------ | Branch (7214:15): [True: 0, False: 0] ------------------ 7215| 0| } 7216| | /* initialize local variables */ 7217| 0| and_start = 1; 7218| 0| state = CS_START; 7219| | 7220| 0| if (IS_NOT_NULL(prev_cc)) { ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 7221| 0| r = and_cclass(prev_cc, cc, env->enc); 7222| 0| if (r != 0) goto err; ------------------ | Branch (7222:15): [True: 0, False: 0] ------------------ 7223| 0| bbuf_free(cc->mbuf); 7224| 0| } 7225| 0| else { 7226| 0| prev_cc = cc; 7227| 0| cc = &work_cc; 7228| 0| } 7229| 0| initialize_cclass(cc); 7230| 0| } 7231| 0| break; 7232| | 7233| 0| case TK_EOT: ------------------ | Branch (7233:5): [True: 0, False: 1.10k] ------------------ 7234| 0| r = ONIGERR_PREMATURE_END_OF_CHAR_CLASS; ------------------ | | 591| 0|#define ONIGERR_PREMATURE_END_OF_CHAR_CLASS -103 ------------------ 7235| 0| goto err; 7236| 0| break; 7237| 0| default: ------------------ | Branch (7237:5): [True: 0, False: 1.10k] ------------------ 7238| 0| r = ONIGERR_PARSER_BUG; ------------------ | | 572| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 7239| 0| goto err; 7240| 0| break; 7241| 1.10k| } 7242| | 7243| 1.10k| if (fetched) ------------------ | Branch (7243:9): [True: 359, False: 750] ------------------ 7244| 359| r = tok->type; 7245| 750| else { 7246| 750| r = fetch_token_cc(tok, &p, end, env, state); 7247| 750| if (r < 0) goto err; ------------------ | Branch (7247:11): [True: 0, False: 750] ------------------ 7248| 750| } 7249| 1.10k| } 7250| | 7251| 391| if (state == CS_VALUE) { ------------------ | Branch (7251:7): [True: 32, False: 359] ------------------ 7252| 32| r = cc_char_next(cc, &curr_code, 0, &curr_raw, 0, curr_type, &curr_type, 7253| 32| &state, env); 7254| 32| if (r != 0) goto err; ------------------ | Branch (7254:9): [True: 0, False: 32] ------------------ 7255| 32| } 7256| | 7257| 391| if (IS_NOT_NULL(prev_cc)) { ------------------ | | 202| 391|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 391] | | ------------------ ------------------ 7258| 0| r = and_cclass(prev_cc, cc, env->enc); 7259| 0| if (r != 0) goto err; ------------------ | Branch (7259:9): [True: 0, False: 0] ------------------ 7260| 0| bbuf_free(cc->mbuf); 7261| 0| cc = prev_cc; 7262| 0| } 7263| | 7264| 391| if (neg != 0) ------------------ | Branch (7264:7): [True: 106, False: 285] ------------------ 7265| 391| NCCLASS_SET_NOT(cc); ------------------ | | 734| 106|#define NCCLASS_SET_NOT(nd) NCCLASS_FLAG_SET(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 726| 106|#define NCCLASS_FLAG_SET(cc,flag) (NCCLASS_FLAGS(cc) |= (flag)) | | | | ------------------ | | | | | | 725| 106|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ 7266| 285| else 7267| 391| NCCLASS_CLEAR_NOT(cc); ------------------ | | 735| 285|#define NCCLASS_CLEAR_NOT(nd) NCCLASS_FLAG_CLEAR(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 727| 285|#define NCCLASS_FLAG_CLEAR(cc,flag) (NCCLASS_FLAGS(cc) &= ~(flag)) | | | | ------------------ | | | | | | 725| 285|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ 7268| 391| if (IS_NCCLASS_NOT(cc) && ------------------ | | 736| 391|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 728| 782|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 725| 391|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (728:37): [True: 106, False: 285] | | | | ------------------ | | ------------------ ------------------ 7269| 106| IS_SYNTAX_BV(env->syntax, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC)) { ------------------ | | 407| 106|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 106] | | ------------------ ------------------ 7270| 0| int is_empty = (IS_NULL(cc->mbuf) ? 1 : 0); ------------------ | | 201| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (201:39): [True: 0, False: 0] | | ------------------ ------------------ 7271| 0| if (is_empty != 0) ------------------ | Branch (7271:9): [True: 0, False: 0] ------------------ 7272| 0| BITSET_IS_EMPTY(cc->bs, is_empty); ------------------ | | 407| 0|#define BITSET_IS_EMPTY(bs,empty) do {\ | | 408| 0| int i;\ | | 409| 0| empty = 1;\ | | 410| 0| for (i = 0; i < (int )BITSET_REAL_SIZE; i++) {\ | | ------------------ | | | | 434| 0|#define BITSET_REAL_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 432| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 431| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | | | #define BITSET_REAL_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 433| 0|#define BITS_IN_ROOM 32 /* 4 * BITS_PER_BYTE */ | | | | ------------------ | | ------------------ | | | Branch (410:15): [True: 0, False: 0] | | ------------------ | | 411| 0| if ((bs)[i] != 0) {\ | | ------------------ | | | Branch (411:9): [True: 0, False: 0] | | ------------------ | | 412| 0| empty = 0; break;\ | | 413| 0| }\ | | 414| 0| }\ | | 415| 0|} while (0) | | ------------------ | | | Branch (415:10): [Folded, False: 0] | | ------------------ ------------------ 7273| | 7274| 0| if (is_empty == 0) { ------------------ | Branch (7274:9): [True: 0, False: 0] ------------------ 7275| 0| if (ONIGENC_IS_CODE_NEWLINE(env->enc, NEWLINE_CODE)) { ------------------ | | 293| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_NEWLINE) | | ------------------ | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | ------------------ | | | | | Branch (290:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 7276| 0| if (ONIGENC_CODE_TO_MBCLEN(env->enc, NEWLINE_CODE) == 1) ------------------ | | 285| 0|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code) ------------------ | Branch (7276:13): [True: 0, False: 0] ------------------ 7277| 0| BITSET_SET_BIT(cc->bs, NEWLINE_CODE); ------------------ | | 451| 0|#define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 447| 0|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 448| 0|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ 7278| 0| else 7279| 0| add_code_range(&(cc->mbuf), env, NEWLINE_CODE, NEWLINE_CODE); ------------------ | | 81| 0|#define NEWLINE_CODE 0x0a ------------------ add_code_range(&(cc->mbuf), env, NEWLINE_CODE, NEWLINE_CODE); ------------------ | | 81| 0|#define NEWLINE_CODE 0x0a ------------------ 7280| 0| } 7281| 0| } 7282| 0| } 7283| 391| *src = p; 7284| 391| DEC_PARSE_DEPTH(env->parse_depth); ------------------ | | 327| 391|#define DEC_PARSE_DEPTH(d) (d)-- ------------------ 7285| 391| return 0; 7286| | 7287| 0| err: 7288| 0| if (cc != CCLASS_(*np)) ------------------ | | 288| 0|#define CCLASS_(node) (&((node)->u.cclass)) ------------------ | Branch (7288:7): [True: 0, False: 0] ------------------ 7289| 0| bbuf_free(cc->mbuf); 7290| 0| return r; 7291| 391|} regparse.c:fetch_token_cc: 5269| 1.60k|{ 5270| 1.60k| int r; 5271| 1.60k| OnigCodePoint code; 5272| 1.60k| OnigCodePoint c, c2; 5273| 1.60k| int mindigits, maxdigits; 5274| 1.60k| OnigSyntaxType* syn; 5275| 1.60k| OnigEncoding enc; 5276| 1.60k| UChar* prev; ------------------ | | 80| 1.60k|#define UChar OnigUChar ------------------ 5277| 1.60k| UChar* p; ------------------ | | 80| 1.60k|#define UChar OnigUChar ------------------ 5278| 1.60k| PFETCH_READY; ------------------ | | 486| 1.60k|#define PFETCH_READY UChar* pfetch_prev | | ------------------ | | | | 80| 1.60k|#define UChar OnigUChar | | ------------------ ------------------ 5279| | 5280| 1.60k| p = *src; 5281| 1.60k| enc = env->enc; 5282| 1.60k| syn = env->syntax; 5283| 1.60k| if (tok->code_point_continue != 0) { ------------------ | Branch (5283:7): [True: 0, False: 1.60k] ------------------ 5284| 0| r = get_next_code_point(&p, end, tok->base_num, enc, TRUE, &code); ------------------ | | 59| 0|#define TRUE 1 ------------------ 5285| 0| if (r == 1) { ------------------ | Branch (5285:9): [True: 0, False: 0] ------------------ 5286| 0| tok->code_point_continue = 0; 5287| 0| } 5288| 0| else if (r == 2) { ------------------ | Branch (5288:14): [True: 0, False: 0] ------------------ 5289| 0| tok->type = TK_CC_RANGE; 5290| 0| goto end; 5291| 0| } 5292| 0| else if (r == 0) { ------------------ | Branch (5292:14): [True: 0, False: 0] ------------------ 5293| 0| tok->type = TK_CODE_POINT; 5294| 0| tok->u.code = code; 5295| 0| goto end; 5296| 0| } 5297| 0| else 5298| 0| return r; /* error */ 5299| 0| } 5300| | 5301| 1.60k| if (PEND) { ------------------ | | 487| 1.60k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 1.60k] | | | Branch (487:23): [True: 1.60k, False: 0] | | ------------------ ------------------ 5302| 0| tok->type = TK_EOT; 5303| 0| return tok->type; 5304| 0| } 5305| | 5306| 1.60k| PFETCH(c); ------------------ | | 494| 1.60k|#define PFETCH(c) do { \ | | 495| 1.60k| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 1.60k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 1.60k| pfetch_prev = p; \ | | 497| 1.60k| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 1.60k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 1.60k|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 1.60k] | | ------------------ ------------------ 5307| 1.60k| tok->type = TK_CHAR; 5308| 1.60k| tok->base_num = 0; 5309| 1.60k| tok->u.code = c; 5310| 1.60k| tok->escaped = 0; 5311| | 5312| 1.60k| if (c == ']') { ------------------ | Branch (5312:7): [True: 391, False: 1.21k] ------------------ 5313| 391| tok->type = TK_CC_CLOSE; 5314| 391| } 5315| 1.21k| else if (c == '-') { ------------------ | Branch (5315:12): [True: 359, False: 856] ------------------ 5316| 359| tok->type = TK_CC_RANGE; 5317| 359| } 5318| 856| else if (c == MC_ESC(syn)) { ------------------ | | 687| 856|#define MC_ESC(syn) (syn)->meta_char_table.esc ------------------ | Branch (5318:12): [True: 0, False: 856] ------------------ 5319| 0| if (! IS_SYNTAX_BV(syn, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (5319:9): [True: 0, False: 0] ------------------ 5320| 0| goto end; 5321| | 5322| 0| if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 592| 0|#define ONIGERR_END_PATTERN_AT_ESCAPE -104 ------------------ 5323| | 5324| 0| PFETCH(c); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 5325| 0| tok->escaped = 1; 5326| 0| tok->u.code = c; 5327| 0| switch (c) { 5328| 0| case 'w': ------------------ | Branch (5328:5): [True: 0, False: 0] ------------------ 5329| 0| tok->type = TK_CHAR_TYPE; 5330| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; 5331| 0| tok->u.prop.not = 0; 5332| 0| break; 5333| 0| case 'W': ------------------ | Branch (5333:5): [True: 0, False: 0] ------------------ 5334| 0| tok->type = TK_CHAR_TYPE; 5335| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; 5336| 0| tok->u.prop.not = 1; 5337| 0| break; 5338| 0| case 'd': ------------------ | Branch (5338:5): [True: 0, False: 0] ------------------ 5339| 0| tok->type = TK_CHAR_TYPE; 5340| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; 5341| 0| tok->u.prop.not = 0; 5342| 0| break; 5343| 0| case 'D': ------------------ | Branch (5343:5): [True: 0, False: 0] ------------------ 5344| 0| tok->type = TK_CHAR_TYPE; 5345| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; 5346| 0| tok->u.prop.not = 1; 5347| 0| break; 5348| 0| case 's': ------------------ | Branch (5348:5): [True: 0, False: 0] ------------------ 5349| 0| tok->type = TK_CHAR_TYPE; 5350| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; 5351| 0| tok->u.prop.not = 0; 5352| 0| break; 5353| 0| case 'S': ------------------ | Branch (5353:5): [True: 0, False: 0] ------------------ 5354| 0| tok->type = TK_CHAR_TYPE; 5355| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; 5356| 0| tok->u.prop.not = 1; 5357| 0| break; 5358| 0| case 'h': ------------------ | Branch (5358:5): [True: 0, False: 0] ------------------ 5359| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5359:11): [True: 0, False: 0] ------------------ 5360| 0| tok->type = TK_CHAR_TYPE; 5361| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; 5362| 0| tok->u.prop.not = 0; 5363| 0| break; 5364| 0| case 'H': ------------------ | Branch (5364:5): [True: 0, False: 0] ------------------ 5365| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (5365:11): [True: 0, False: 0] ------------------ 5366| 0| tok->type = TK_CHAR_TYPE; 5367| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; 5368| 0| tok->u.prop.not = 1; 5369| 0| break; 5370| | 5371| 0| case 'p': ------------------ | Branch (5371:5): [True: 0, False: 0] ------------------ 5372| 0| case 'P': ------------------ | Branch (5372:5): [True: 0, False: 0] ------------------ 5373| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5374| | 5375| 0| c2 = PPEEK; ------------------ | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 484| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (508:23): [True: 0, False: 0] | | ------------------ ------------------ 5376| 0| if (c2 == '{' && ------------------ | Branch (5376:11): [True: 0, False: 0] ------------------ 5377| 0| IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 5378| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5379| 0| tok->type = TK_CHAR_PROPERTY; 5380| 0| tok->u.prop.not = c == 'P'; 5381| | 5382| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5382:13): [True: 0, False: 0] ------------------ 5383| 0| PFETCH(c2); ------------------ | | 494| 0|#define PFETCH(c) do { \ | | 495| 0| c = ONIGENC_MBC_TO_CODE(enc, p, end); \ | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | 496| 0| pfetch_prev = p; \ | | 497| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 498| 0|} while (0) | | ------------------ | | | Branch (498:10): [Folded, False: 0] | | ------------------ ------------------ 5384| 0| if (c2 == '^') { ------------------ | Branch (5384:15): [True: 0, False: 0] ------------------ 5385| 0| tok->u.prop.not = tok->u.prop.not == 0; 5386| 0| } 5387| 0| else 5388| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 5389| 0| } 5390| 0| } 5391| 0| break; 5392| | 5393| 0| case 'o': ------------------ | Branch (5393:5): [True: 0, False: 0] ------------------ 5394| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5395| | 5396| 0| prev = p; 5397| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5398| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5399| 0| r = scan_octal_number(&p, end, 0, 11, enc, &code); 5400| 0| if (r < 0) return r; ------------------ | Branch (5400:13): [True: 0, False: 0] ------------------ 5401| 0| if (!PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5401:13): [True: 0, False: 0] ------------------ 5402| 0| c2 = PPEEK; ------------------ | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 484| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (508:23): [True: 0, False: 0] | | ------------------ ------------------ 5403| 0| if (IS_CODE_DIGIT_ASCII(enc, c2)) ------------------ | | 397| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 257| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (257:43): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_DIGIT(enc,code)) | | ------------------ | | | | 315| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5404| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 623| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 5405| 0| } 5406| | 5407| 0| tok->base_num = 8; 5408| 0| goto brace_code_point_entry; 5409| 0| } 5410| 0| break; 5411| | 5412| 0| case 'x': ------------------ | Branch (5412:5): [True: 0, False: 0] ------------------ 5413| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5414| | 5415| 0| prev = p; 5416| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5417| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5418| 0| r = scan_hexadecimal_number(&p, end, 0, 8, enc, &code); 5419| 0| if (r < 0) return r; ------------------ | Branch (5419:13): [True: 0, False: 0] ------------------ 5420| 0| if (!PEND) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5420:13): [True: 0, False: 0] ------------------ 5421| 0| c2 = PPEEK; ------------------ | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 484| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (508:23): [True: 0, False: 0] | | ------------------ ------------------ 5422| 0| if (IS_CODE_XDIGIT_ASCII(enc, c2)) ------------------ | | 399| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_XDIGIT(enc,code)) | | ------------------ | | | | 257| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (257:43): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_XDIGIT(enc,code)) | | ------------------ | | | | 317| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_XDIGIT) | | | | ------------------ | | | | | | 290| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype) | | | | | | ------------------ | | | | | | | Branch (290:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5423| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 623| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 5424| 0| } 5425| | 5426| 0| tok->base_num = 16; 5427| 0| brace_code_point_entry: 5428| 0| if ((p > prev + enclen(enc, prev))) { ------------------ | | 83| 0|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ | Branch (5428:13): [True: 0, False: 0] ------------------ 5429| 0| if (PEND) return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 644| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ 5430| 0| if (PPEEK_IS('}')) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (509:22): [True: 0, False: 0] | | ------------------ ------------------ 5431| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5432| 0| } 5433| 0| else { 5434| 0| int curr_state; 5435| | 5436| 0| curr_state = (state == CS_RANGE) ? CPS_EMPTY : CPS_START; ------------------ | Branch (5436:26): [True: 0, False: 0] ------------------ 5437| 0| r = check_code_point_sequence_cc(p, end, tok->base_num, enc, 5438| 0| curr_state); 5439| 0| if (r < 0) return r; ------------------ | Branch (5439:17): [True: 0, False: 0] ------------------ 5440| 0| if (r == 0) return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 644| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ | Branch (5440:17): [True: 0, False: 0] ------------------ 5441| 0| tok->code_point_continue = TRUE; ------------------ | | 59| 0|#define TRUE 1 ------------------ 5442| 0| } 5443| 0| tok->type = TK_CODE_POINT; 5444| 0| tok->u.code = code; 5445| 0| } 5446| 0| else { 5447| | /* can't read nothing or invalid format */ 5448| 0| p = prev; 5449| 0| } 5450| 0| } 5451| 0| else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5452| 0| r = scan_hexadecimal_number(&p, end, 0, 2, enc, &code); 5453| 0| if (r < 0) return r; ------------------ | Branch (5453:13): [True: 0, False: 0] ------------------ 5454| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (5454:13): [True: 0, False: 0] ------------------ 5455| 0| code = 0; /* but, it's not error */ 5456| 0| } 5457| 0| tok->type = TK_CRUDE_BYTE; 5458| 0| tok->base_num = 16; 5459| 0| tok->u.byte = (UChar )code; 5460| 0| } 5461| 0| break; 5462| | 5463| 0| case 'u': ------------------ | Branch (5463:5): [True: 0, False: 0] ------------------ 5464| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5465| 0| prev = p; 5466| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 5467| 0| mindigits = maxdigits = 4; 5468| 0| u_hex_digits: 5469| 0| r = scan_hexadecimal_number(&p, end, mindigits, maxdigits, enc, &code); 5470| 0| if (r < 0) return r; ------------------ | Branch (5470:13): [True: 0, False: 0] ------------------ 5471| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (5471:13): [True: 0, False: 0] ------------------ 5472| 0| code = 0; /* but, it's not error */ 5473| 0| } 5474| 0| tok->type = TK_CODE_POINT; 5475| 0| tok->base_num = 16; 5476| 0| tok->u.code = code; 5477| 0| } 5478| 0| break; 5479| | 5480| 0| case 'U': ------------------ | Branch (5480:5): [True: 0, False: 0] ------------------ 5481| 0| if (PEND) break; ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:22): [True: 0, False: 0] | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ 5482| 0| prev = p; 5483| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_PYTHON)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 5484| 0| mindigits = maxdigits = 8; 5485| 0| goto u_hex_digits; 5486| 0| } 5487| 0| break; 5488| | 5489| 0| case '0': ------------------ | Branch (5489:5): [True: 0, False: 0] ------------------ 5490| 0| case '1': case '2': case '3': case '4': case '5': case '6': case '7': ------------------ | Branch (5490:5): [True: 0, False: 0] | Branch (5490:15): [True: 0, False: 0] | Branch (5490:25): [True: 0, False: 0] | Branch (5490:35): [True: 0, False: 0] | Branch (5490:45): [True: 0, False: 0] | Branch (5490:55): [True: 0, False: 0] | Branch (5490:65): [True: 0, False: 0] ------------------ 5491| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 5492| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 5493| 0| prev = p; 5494| 0| r = scan_octal_number(&p, end, 0, 3, enc, &code); 5495| 0| if (r < 0) return r; ------------------ | Branch (5495:13): [True: 0, False: 0] ------------------ 5496| 0| if (code >= 256) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 612| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (5496:13): [True: 0, False: 0] ------------------ 5497| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (5497:13): [True: 0, False: 0] ------------------ 5498| 0| code = 0; /* but, it's not error */ 5499| 0| } 5500| 0| tok->type = TK_CRUDE_BYTE; 5501| 0| tok->base_num = 8; 5502| 0| tok->u.byte = (UChar )code; 5503| 0| } 5504| 0| break; 5505| | 5506| 0| default: ------------------ | Branch (5506:5): [True: 0, False: 0] ------------------ 5507| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 5508| 0| r = fetch_escaped_value(&p, end, env, &c2); 5509| 0| if (r < 0) return r; ------------------ | Branch (5509:11): [True: 0, False: 0] ------------------ 5510| 0| if (tok->u.code != c2) { ------------------ | Branch (5510:11): [True: 0, False: 0] ------------------ 5511| 0| tok->u.code = c2; 5512| 0| tok->type = TK_CODE_POINT; 5513| 0| } 5514| 0| break; 5515| 0| } 5516| 0| } 5517| 856| else if (c == '[') { ------------------ | Branch (5517:12): [True: 0, False: 856] ------------------ 5518| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_POSIX_BRACKET) && (PPEEK_IS(':'))) { ------------------ | | 405| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_POSIX_BRACKET) && (PPEEK_IS(':'))) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (5518:57): [True: 0, False: 0] ------------------ 5519| 0| tok->backp = p; /* point at '[' is read */ 5520| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5521| 0| if (is_posix_bracket_start(p, end, enc)) { ------------------ | Branch (5521:11): [True: 0, False: 0] ------------------ 5522| 0| tok->type = TK_CC_POSIX_BRACKET_OPEN; 5523| 0| } 5524| 0| else { 5525| 0| PUNFETCH; ------------------ | | 488| 0|#define PUNFETCH p = pfetch_prev ------------------ 5526| 0| goto cc_in_cc; 5527| 0| } 5528| 0| } 5529| 0| else { 5530| 0| cc_in_cc: 5531| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP)) { ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 5532| 0| tok->type = TK_CC_OPEN_CC; 5533| 0| } 5534| 0| else { 5535| 0| CC_ESC_WARN(env, (UChar* )"["); 5536| 0| } 5537| 0| } 5538| 0| } 5539| 856| else if (c == '&') { ------------------ | Branch (5539:12): [True: 0, False: 856] ------------------ 5540| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP) && ------------------ | | 406| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 5541| 0| !PEND && (PPEEK_IS('&'))) { ------------------ | | 487| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (487:23): [True: 0, False: 0] | | ------------------ ------------------ !PEND && (PPEEK_IS('&'))) { ------------------ | | 509| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 508| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 284| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 484| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (508:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (5541:9): [True: 0, False: 0] | Branch (5541:18): [True: 0, False: 0] ------------------ 5542| 0| PINC; ------------------ | | 490| 0|#define PINC do { \ | | 491| 0| pfetch_prev = p; \ | | 492| 0| p += ONIGENC_MBC_ENC_LEN(enc, p); \ | | ------------------ | | | | 279| 0|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ | | 493| 0|} while (0) | | ------------------ | | | Branch (493:10): [Folded, False: 0] | | ------------------ ------------------ 5543| 0| tok->type = TK_CC_AND; 5544| 0| } 5545| 0| } 5546| | 5547| 1.60k| end: 5548| 1.60k| *src = p; 5549| 1.60k| return tok->type; 5550| 1.60k|} regparse.c:cc_char_next: 6842| 782|{ 6843| 782| int r; 6844| | 6845| 782| switch (*state) { 6846| 32| case CS_VALUE: ------------------ | Branch (6846:3): [True: 32, False: 750] ------------------ 6847| 32| if (*type == CV_SB) { ------------------ | Branch (6847:9): [True: 32, False: 0] ------------------ 6848| 32| if (*from > 0xff) ------------------ | Branch (6848:11): [True: 0, False: 32] ------------------ 6849| 0| return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 644| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ 6850| | 6851| 32| BITSET_SET_BIT(cc->bs, (int )(*from)); ------------------ | | 451| 32|#define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 447| 32|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 448| 32|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ 6852| 32| } 6853| 0| else if (*type == CV_MB) { ------------------ | Branch (6853:14): [True: 0, False: 0] ------------------ 6854| 0| r = add_code_range(&(cc->mbuf), env, *from, *from); 6855| 0| if (r < 0) return r; ------------------ | Branch (6855:11): [True: 0, False: 0] ------------------ 6856| 0| } 6857| 32| break; 6858| | 6859| 359| case CS_RANGE: ------------------ | Branch (6859:3): [True: 359, False: 423] ------------------ 6860| 359| if (intype == *type) { ------------------ | Branch (6860:9): [True: 359, False: 0] ------------------ 6861| 359| if (intype == CV_SB) { ------------------ | Branch (6861:11): [True: 359, False: 0] ------------------ 6862| 359| if (*from > 0xff || to > 0xff) ------------------ | Branch (6862:13): [True: 0, False: 359] | Branch (6862:29): [True: 0, False: 359] ------------------ 6863| 0| return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 644| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ 6864| | 6865| 359| if (*from > to) { ------------------ | Branch (6865:13): [True: 0, False: 359] ------------------ 6866| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 6867| 0| goto ccs_range_end; 6868| 0| else 6869| 0| return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS; ------------------ | | 615| 0|#define ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS -203 ------------------ 6870| 0| } 6871| 359| bitset_set_range(cc->bs, (int )*from, (int )to); 6872| 359| } 6873| 0| else { 6874| 0| r = add_code_range(&(cc->mbuf), env, *from, to); 6875| 0| if (r < 0) return r; ------------------ | Branch (6875:13): [True: 0, False: 0] ------------------ 6876| 0| } 6877| 359| } 6878| 0| else { 6879| 0| if (*from > to) { ------------------ | Branch (6879:11): [True: 0, False: 0] ------------------ 6880| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC)) ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 6881| 0| goto ccs_range_end; 6882| 0| else 6883| 0| return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS; ------------------ | | 615| 0|#define ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS -203 ------------------ 6884| 0| } 6885| 0| bitset_set_range(cc->bs, (int )*from, (int )(to < 0xff ? to : 0xff)); ------------------ | Branch (6885:52): [True: 0, False: 0] ------------------ 6886| 0| r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*from, to); 6887| 0| if (r < 0) return r; ------------------ | Branch (6887:11): [True: 0, False: 0] ------------------ 6888| 0| } 6889| 359| ccs_range_end: 6890| 359| *state = CS_COMPLETE; 6891| 359| break; 6892| | 6893| 0| case CS_COMPLETE: ------------------ | Branch (6893:3): [True: 0, False: 782] ------------------ 6894| 391| case CS_START: ------------------ | Branch (6894:3): [True: 391, False: 391] ------------------ 6895| 391| *state = CS_VALUE; 6896| 391| break; 6897| | 6898| 0| default: ------------------ | Branch (6898:3): [True: 0, False: 782] ------------------ 6899| 0| break; 6900| 782| } 6901| | 6902| 782| *from_raw = to_raw; 6903| 782| *from = to; 6904| 782| *type = intype; 6905| 782| return 0; 6906| 782|} regparse.c:bitset_set_range: 419| 359|{ 420| 359| int i; 421| 7.10k| for (i = from; i <= to && i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 432| 6.74k|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 431| 6.74k|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (421:18): [True: 6.74k, False: 359] | Branch (421:29): [True: 6.74k, False: 0] ------------------ 422| 6.74k| BITSET_SET_BIT(bs, i); ------------------ | | 451| 6.74k|#define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 447| 6.74k|#define BS_ROOM(bs,pos) (bs)[(unsigned int )(pos) >> 5] | | ------------------ | | #define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 448| 6.74k|#define BS_BIT(pos) (1u << ((unsigned int )(pos) & 0x1f)) | | ------------------ ------------------ 423| 6.74k| } 424| 359|} regparse.c:node_new_anychar: 2388| 562|{ 2389| 562| Node* node; 2390| | 2391| 562| node = node_new_ctype(CTYPE_ANYCHAR, FALSE, options); ------------------ | | 301| 562|#define CTYPE_ANYCHAR -1 ------------------ node = node_new_ctype(CTYPE_ANYCHAR, FALSE, options); ------------------ | | 63| 562|#define FALSE 0 ------------------ 2392| 562| CHECK_NULL_RETURN(node); ------------------ | | 203| 562|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 562|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 562] | | | | ------------------ | | ------------------ ------------------ 2393| | 2394| 562| if (OPTON_MULTILINE(options)) ------------------ | | 51| 562|#define OPTON_MULTILINE(option) ((option) & ONIG_OPTION_MULTILINE) | | ------------------ | | | | 379| 562|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 378| 562|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 377| 562|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (51:38): [True: 0, False: 562] | | ------------------ ------------------ 2395| 0| ND_STATUS_ADD(node, MULTILINE); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 347| 0|#define ND_ST_MULTILINE (1<<22) | | ------------------ ------------------ 2396| 562| return node; 2397| 562|} regparse.c:node_new_quantifier: 2630| 46.3k|{ 2631| 46.3k| Node* node = node_new(); 2632| 46.3k| CHECK_NULL_RETURN(node); ------------------ | | 203| 46.3k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 46.3k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 46.3k] | | | | ------------------ | | ------------------ ------------------ 2633| | 2634| 46.3k| ND_SET_TYPE(node, ND_QUANT); ------------------ | | 285| 46.3k|#define ND_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype) ------------------ 2635| 46.3k| QUANT_(node)->lower = lower; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2636| 46.3k| QUANT_(node)->upper = upper; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2637| 46.3k| QUANT_(node)->greedy = 1; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2638| 46.3k| QUANT_(node)->emptiness = BODY_IS_NOT_EMPTY; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2639| 46.3k| QUANT_(node)->head_exact = NULL_NODE; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ QUANT_(node)->head_exact = NULL_NODE; ------------------ | | 266| 46.3k|#define NULL_NODE ((Node* )0) ------------------ 2640| 46.3k| QUANT_(node)->next_head_exact = NULL_NODE; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ QUANT_(node)->next_head_exact = NULL_NODE; ------------------ | | 266| 46.3k|#define NULL_NODE ((Node* )0) ------------------ 2641| 46.3k| QUANT_(node)->include_referred = 0; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2642| 46.3k| QUANT_(node)->empty_status_mem = 0; ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 2643| 46.3k| if (by_number != 0) ------------------ | Branch (2643:7): [True: 0, False: 46.3k] ------------------ 2644| 0| ND_STATUS_ADD(node, BY_NUMBER); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 339| 0|#define ND_ST_BY_NUMBER (1<<14) /* {n,m} */ | | ------------------ ------------------ 2645| | 2646| 46.3k| return node; 2647| 46.3k|} regparse.c:node_new_anchor_with_options: 2516| 3.10k|{ 2517| 3.10k| int ascii_mode; 2518| 3.10k| Node* node; 2519| | 2520| 3.10k| node = node_new_anchor(type); 2521| 3.10k| CHECK_NULL_RETURN(node); ------------------ | | 203| 3.10k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 3.10k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 3.10k] | | | | ------------------ | | ------------------ ------------------ 2522| | 2523| 3.10k| ascii_mode = OPTON_WORD_ASCII(options) && IS_WORD_ANCHOR_TYPE(type) ? 1 : 0; ------------------ | | 55| 6.20k| ((option) & (ONIG_OPTION_WORD_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | ------------------ | | | | 393| 3.10k|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | ------------------ | | | | | | 392| 3.10k|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | ------------------ | | | | | | | | 390| 3.10k|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | ------------------ | | | | | | | | | | 389| 3.10k|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 388| 3.10k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 387| 3.10k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 385| 3.10k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 384| 3.10k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 383| 3.10k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 382| 3.10k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 381| 3.10k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 3.10k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 3.10k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 3.10k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 3.10k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ((option) & (ONIG_OPTION_WORD_IS_ASCII | ONIG_OPTION_POSIX_IS_ASCII)) | | ------------------ | | | | 396| 3.10k|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | ------------------ | | | | | | 395| 3.10k|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 394| 3.10k|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 393| 3.10k|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 392| 3.10k|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 390| 3.10k|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 389| 3.10k|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 388| 3.10k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 387| 3.10k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 385| 3.10k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 384| 3.10k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 3.10k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 3.10k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 3.10k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 3.10k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 3.10k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 3.10k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 3.10k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (55:3): [True: 0, False: 3.10k] | | ------------------ ------------------ ascii_mode = OPTON_WORD_ASCII(options) && IS_WORD_ANCHOR_TYPE(type) ? 1 : 0; ------------------ | | 480| 0| ((type) == ANCR_WORD_BOUNDARY || (type) == ANCR_NO_WORD_BOUNDARY || \ | | ------------------ | | | | 467| 0|#define ANCR_WORD_BOUNDARY (1<<10) | | ------------------ | | ((type) == ANCR_WORD_BOUNDARY || (type) == ANCR_NO_WORD_BOUNDARY || \ | | ------------------ | | | | 468| 0|#define ANCR_NO_WORD_BOUNDARY (1<<11) | | ------------------ | | | Branch (480:4): [True: 0, False: 0] | | | Branch (480:36): [True: 0, False: 0] | | ------------------ | | 481| 0| (type) == ANCR_WORD_BEGIN || (type) == ANCR_WORD_END) | | ------------------ | | | | 469| 0|#define ANCR_WORD_BEGIN (1<<12) | | ------------------ | | (type) == ANCR_WORD_BEGIN || (type) == ANCR_WORD_END) | | ------------------ | | | | 470| 0|#define ANCR_WORD_END (1<<13) | | ------------------ | | | Branch (481:4): [True: 0, False: 0] | | | Branch (481:33): [True: 0, False: 0] | | ------------------ ------------------ 2524| 3.10k| ANCHOR_(node)->ascii_mode = ascii_mode; ------------------ | | 293| 3.10k|#define ANCHOR_(node) (&((node)->u.anchor)) ------------------ 2525| | 2526| 3.10k| if (type == ANCR_TEXT_SEGMENT_BOUNDARY || ------------------ | | 473| 6.20k|#define ANCR_TEXT_SEGMENT_BOUNDARY (1<<16) ------------------ | Branch (2526:7): [True: 0, False: 3.10k] ------------------ 2527| 3.10k| type == ANCR_NO_TEXT_SEGMENT_BOUNDARY) { ------------------ | | 474| 3.10k|#define ANCR_NO_TEXT_SEGMENT_BOUNDARY (1<<17) ------------------ | Branch (2527:7): [True: 0, False: 3.10k] ------------------ 2528| 0| if (OPTON_TEXT_SEGMENT_WORD(options)) ------------------ | | 61| 0|#define OPTON_TEXT_SEGMENT_WORD(option) ((option) & ONIG_OPTION_TEXT_SEGMENT_WORD) | | ------------------ | | | | 398| 0|#define ONIG_OPTION_TEXT_SEGMENT_WORD (ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER << 1) | | | | ------------------ | | | | | | 397| 0|#define ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER (ONIG_OPTION_POSIX_IS_ASCII << 1) | | | | | | ------------------ | | | | | | | | 396| 0|#define ONIG_OPTION_POSIX_IS_ASCII (ONIG_OPTION_SPACE_IS_ASCII << 1) | | | | | | | | ------------------ | | | | | | | | | | 395| 0|#define ONIG_OPTION_SPACE_IS_ASCII (ONIG_OPTION_DIGIT_IS_ASCII << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 394| 0|#define ONIG_OPTION_DIGIT_IS_ASCII (ONIG_OPTION_WORD_IS_ASCII << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 393| 0|#define ONIG_OPTION_WORD_IS_ASCII (ONIG_OPTION_IGNORECASE_IS_ASCII << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 392| 0|#define ONIG_OPTION_IGNORECASE_IS_ASCII (ONIG_OPTION_CHECK_VALIDITY_OF_STRING << 3) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 390| 0|#define ONIG_OPTION_CHECK_VALIDITY_OF_STRING (ONIG_OPTION_POSIX_REGION << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 389| 0|#define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 388| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 387| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 385| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 384| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 383| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 382| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 381| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 380| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 379| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 378| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 377| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (61:42): [True: 0, False: 0] | | ------------------ ------------------ 2529| 0| ND_STATUS_ADD(node, TEXT_SEGMENT_WORD); ------------------ | | 357| 0|#define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 356| 0|#define ND_STATUS(node) (((Node* )node)->u.base.status) | | ------------------ | | #define ND_STATUS_ADD(node,f) (ND_STATUS(node) |= (ND_ST_ ## f)) | | ------------------ | | | | 348| 0|#define ND_ST_TEXT_SEGMENT_WORD (1<<23) | | ------------------ ------------------ 2530| 0| } 2531| | 2532| 3.10k| return node; 2533| 3.10k|} regparse.c:is_invalid_quantifier_target: 4346| 46.3k|{ 4347| 46.3k| switch (ND_TYPE(node)) { ------------------ | | 284| 46.3k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 4348| 0| case ND_ANCHOR: ------------------ | Branch (4348:3): [True: 0, False: 46.3k] ------------------ 4349| 0| case ND_GIMMICK: ------------------ | Branch (4349:3): [True: 0, False: 46.3k] ------------------ 4350| 0| return 1; 4351| 0| break; 4352| | 4353| 104| case ND_BAG: ------------------ | Branch (4353:3): [True: 104, False: 46.2k] ------------------ 4354| | /* allow enclosed elements */ 4355| | /* return is_invalid_quantifier_target(ND_BODY(node)); */ 4356| 104| break; 4357| | 4358| 0| case ND_LIST: ------------------ | Branch (4358:3): [True: 0, False: 46.3k] ------------------ 4359| 0| do { 4360| 0| if (! is_invalid_quantifier_target(ND_CAR(node))) return 0; ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ | Branch (4360:11): [True: 0, False: 0] ------------------ 4361| 0| } while (IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 4362| 0| return 0; 4363| 0| break; 4364| | 4365| 0| case ND_ALT: ------------------ | Branch (4365:3): [True: 0, False: 46.3k] ------------------ 4366| 0| do { 4367| 0| if (is_invalid_quantifier_target(ND_CAR(node))) return 1; ------------------ | | 298| 0|#define ND_CAR(node) (CONS_(node)->car) | | ------------------ | | | | 294| 0|#define CONS_(node) (&((node)->u.cons)) | | ------------------ ------------------ | Branch (4367:11): [True: 0, False: 0] ------------------ 4368| 0| } while (IS_NOT_NULL(node = ND_CDR(node))); ------------------ | | 202| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 0, False: 0] | | ------------------ ------------------ 4369| 0| break; 4370| | 4371| 46.2k| default: ------------------ | Branch (4371:3): [True: 46.2k, False: 104] ------------------ 4372| 46.2k| break; 4373| 46.3k| } 4374| 46.3k| return 0; 4375| 46.3k|} regparse.c:assign_quantifier_body: 8548| 46.3k|{ 8549| 46.3k| QuantNode* qn; 8550| | 8551| 46.3k| qn = QUANT_(qnode); ------------------ | | 291| 46.3k|#define QUANT_(node) (&((node)->u.quant)) ------------------ 8552| 46.3k| if (qn->lower == 1 && qn->upper == 1) ------------------ | Branch (8552:7): [True: 7.25k, False: 39.1k] | Branch (8552:25): [True: 0, False: 7.25k] ------------------ 8553| 0| return 1; 8554| | 8555| 46.3k| switch (ND_TYPE(target)) { ------------------ | | 284| 46.3k|#define ND_TYPE(node) ((node)->u.base.node_type) ------------------ 8556| 45.7k| case ND_STRING: ------------------ | Branch (8556:3): [True: 45.7k, False: 618] ------------------ 8557| 45.7k| if (group == 0) { ------------------ | Branch (8557:9): [True: 45.7k, False: 0] ------------------ 8558| 45.7k| if (str_node_can_be_split(target, env->enc)) { ------------------ | Branch (8558:11): [True: 40.6k, False: 5.10k] ------------------ 8559| 40.6k| Node* n = str_node_split_last_char(target, env->enc); 8560| 40.6k| if (IS_NOT_NULL(n)) { ------------------ | | 202| 40.6k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (202:39): [True: 40.6k, False: 0] | | ------------------ ------------------ 8561| 40.6k| ND_BODY(qnode) = n; ------------------ | | 394| 40.6k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 8562| 40.6k| return 2; 8563| 40.6k| } 8564| 40.6k| } 8565| 45.7k| } 8566| 5.10k| break; 8567| | 8568| 5.10k| case ND_QUANT: ------------------ | Branch (8568:3): [True: 0, False: 46.3k] ------------------ 8569| 0| { /* check redundant double repeat. */ 8570| | /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */ 8571| 0| QuantNode* qnt = QUANT_(target); ------------------ | | 291| 0|#define QUANT_(node) (&((node)->u.quant)) ------------------ 8572| 0| int nestq_num = quantifier_type_num(qn); 8573| 0| int targetq_num = quantifier_type_num(qnt); 8574| | 8575| 0|#ifdef USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR 8576| 0| if (targetq_num >= 0 && nestq_num >= 0 && ------------------ | Branch (8576:11): [True: 0, False: 0] | Branch (8576:31): [True: 0, False: 0] ------------------ 8577| 0| IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT)) { ------------------ | | 407| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (407:35): [True: 0, False: 0] | | ------------------ ------------------ 8578| 0| UChar buf[WARN_BUFSIZE]; ------------------ | | 80| 0|#define UChar OnigUChar ------------------ 8579| | 8580| 0| switch(ReduceTypeTable[targetq_num][nestq_num]) { 8581| 0| case RQ_ASIS: ------------------ | Branch (8581:9): [True: 0, False: 0] ------------------ 8582| 0| break; 8583| | 8584| 0| case RQ_DEL: ------------------ | Branch (8584:9): [True: 0, False: 0] ------------------ 8585| 0| if (onig_verb_warn != onig_null_warn) { ------------------ | Branch (8585:15): [True: 0, False: 0] ------------------ 8586| 0| onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc, ------------------ | | 41| 0|#define WARN_BUFSIZE 256 ------------------ 8587| 0| env->pattern, env->pattern_end, 8588| 0| "redundant nested repeat operator"); 8589| 0| (*onig_verb_warn)((char* )buf); 8590| 0| } 8591| 0| goto warn_exit; 8592| 0| break; 8593| | 8594| 0| default: ------------------ | Branch (8594:9): [True: 0, False: 0] ------------------ 8595| 0| if (onig_verb_warn != onig_null_warn) { ------------------ | Branch (8595:15): [True: 0, False: 0] ------------------ 8596| 0| onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc, ------------------ | | 41| 0|#define WARN_BUFSIZE 256 ------------------ 8597| 0| env->pattern, env->pattern_end, 8598| 0| "nested repeat operator %s and %s was replaced with '%s'", 8599| 0| PopularQStr[targetq_num], PopularQStr[nestq_num], 8600| 0| ReduceQStr[ReduceTypeTable[targetq_num][nestq_num]]); 8601| 0| (*onig_verb_warn)((char* )buf); 8602| 0| } 8603| 0| goto warn_exit; 8604| 0| break; 8605| 0| } 8606| 0| } 8607| | 8608| 0| warn_exit: 8609| 0|#endif 8610| 0| if (targetq_num >= 0 && nestq_num < 0) { ------------------ | Branch (8610:11): [True: 0, False: 0] | Branch (8610:31): [True: 0, False: 0] ------------------ 8611| 0| if (targetq_num == 1 || targetq_num == 2) { /* * or + */ ------------------ | Branch (8611:13): [True: 0, False: 0] | Branch (8611:33): [True: 0, False: 0] ------------------ 8612| | /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */ 8613| 0| if (! IS_INFINITE_REPEAT(qn->upper) && qn->upper > 1 && qn->greedy) { ------------------ | | 428| 0|#define IS_INFINITE_REPEAT(n) ((n) == INFINITE_REPEAT) | | ------------------ | | | | 427| 0|#define INFINITE_REPEAT -1 | | ------------------ ------------------ | Branch (8613:15): [True: 0, False: 0] | Branch (8613:50): [True: 0, False: 0] | Branch (8613:67): [True: 0, False: 0] ------------------ 8614| 0| qn->upper = (qn->lower == 0 ? 1 : qn->lower); ------------------ | Branch (8614:26): [True: 0, False: 0] ------------------ 8615| 0| } 8616| 0| } 8617| 0| } 8618| 0| else { 8619| 0| int r; 8620| | 8621| 0| ND_BODY(qnode) = target; ------------------ | | 394| 0|#define ND_BODY(node) ((node)->u.base.body) ------------------ 8622| 0| r = onig_reduce_nested_quantifier(qnode); 8623| 0| return r; 8624| 0| } 8625| 0| } 8626| 0| break; 8627| | 8628| 618| default: ------------------ | Branch (8628:3): [True: 618, False: 45.7k] ------------------ 8629| 618| break; 8630| 46.3k| } 8631| | 8632| 5.72k| ND_BODY(qnode) = target; ------------------ | | 394| 5.72k|#define ND_BODY(node) ((node)->u.base.body) ------------------ 8633| 5.72k| return 0; 8634| 46.3k|} regparse.c:str_node_can_be_split: 3597| 45.7k|{ 3598| 45.7k| StrNode* sn = STR_(node); ------------------ | | 287| 45.7k|#define STR_(node) (&((node)->u.str)) ------------------ 3599| 45.7k| if (sn->end > sn->s) { ------------------ | Branch (3599:7): [True: 45.7k, False: 0] ------------------ 3600| 45.7k| return ((enclen(enc, sn->s) < sn->end - sn->s) ? 1 : 0); ------------------ | | 83| 45.7k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 45.7k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ | Branch (3600:13): [True: 40.6k, False: 5.10k] ------------------ 3601| 45.7k| } 3602| 0| return 0; 3603| 45.7k|} regparse.c:str_node_split_last_char: 3573| 40.6k|{ 3574| 40.6k| const UChar *p; 3575| 40.6k| Node* rn; 3576| 40.6k| StrNode* sn; 3577| | 3578| 40.6k| sn = STR_(node); ------------------ | | 287| 40.6k|#define STR_(node) (&((node)->u.str)) ------------------ 3579| 40.6k| rn = NULL_NODE; ------------------ | | 266| 40.6k|#define NULL_NODE ((Node* )0) ------------------ 3580| 40.6k| if (sn->end > sn->s) { ------------------ | Branch (3580:7): [True: 40.6k, False: 0] ------------------ 3581| 40.6k| p = onigenc_get_prev_char_head(enc, sn->s, sn->end); 3582| 40.6k| if (p && p > sn->s) { /* can be split. */ ------------------ | Branch (3582:9): [True: 40.6k, False: 0] | Branch (3582:14): [True: 40.6k, False: 0] ------------------ 3583| 40.6k| rn = node_new_str(p, sn->end); 3584| 40.6k| CHECK_NULL_RETURN(rn); ------------------ | | 203| 40.6k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 201| 40.6k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 40.6k] | | | | ------------------ | | ------------------ ------------------ 3585| | 3586| 40.6k| sn->end = (UChar* )p; 3587| 40.6k| STR_(rn)->flag = sn->flag; ------------------ | | 287| 40.6k|#define STR_(node) (&((node)->u.str)) ------------------ 3588| 40.6k| ND_STATUS(rn) = ND_STATUS(node); ------------------ | | 356| 40.6k|#define ND_STATUS(node) (((Node* )node)->u.base.status) ------------------ ND_STATUS(rn) = ND_STATUS(node); ------------------ | | 356| 40.6k|#define ND_STATUS(node) (((Node* )node)->u.base.status) ------------------ 3589| 40.6k| } 3590| 40.6k| } 3591| | 3592| 40.6k| return rn; 3593| 40.6k|} onig_st_init_table_with_size: 139| 504|{ 140| 504| st_table *tbl; 141| | 142| |#ifdef HASH_LOG 143| | if (init_st == 0) { 144| | init_st = 1; 145| | atexit(stat_col); 146| | } 147| |#endif 148| | 149| 504| size = new_size(size); /* round up to prime number */ 150| 504| if (size <= 0) return 0; ------------------ | Branch (150:7): [True: 0, False: 504] ------------------ 151| | 152| 504| tbl = alloc(st_table); ------------------ | | 51| 504|#define alloc(type) (type*)xmalloc((unsigned)sizeof(type)) | | ------------------ | | | | 227| 504|#define xmalloc malloc | | ------------------ ------------------ 153| 504| if (tbl == 0) return 0; ------------------ | Branch (153:7): [True: 0, False: 504] ------------------ 154| | 155| 504| tbl->type = type; 156| 504| tbl->num_entries = 0; 157| 504| tbl->num_bins = size; 158| 504| tbl->bins = (st_table_entry **)Calloc(size, sizeof(st_table_entry*)); ------------------ | | 52| 504|#define Calloc(n,s) (char*)xcalloc((n),(s)) | | ------------------ | | | | 229| 504|#define xcalloc calloc | | ------------------ ------------------ 159| 504| if (tbl->bins == 0) { ------------------ | Branch (159:7): [True: 0, False: 504] ------------------ 160| 0| free(tbl); 161| 0| return 0; 162| 0| } 163| | 164| 504| return tbl; 165| 504|} onig_st_free_table: 199| 503|{ 200| 503| register st_table_entry *ptr, *next; 201| 503| int i; 202| | 203| 6.03k| for(i = 0; i < table->num_bins; i++) { ------------------ | Branch (203:14): [True: 5.53k, False: 503] ------------------ 204| 5.53k| ptr = table->bins[i]; 205| 5.53k| while (ptr != 0) { ------------------ | Branch (205:12): [True: 0, False: 5.53k] ------------------ 206| 0| next = ptr->next; 207| 0| free(ptr); 208| 0| ptr = next; 209| 0| } 210| 5.53k| } 211| 503| free(table->bins); 212| 503| free(table); 213| 503|} onig_st_lookup: 238| 169|{ 239| 169| unsigned int hash_val, bin_pos; 240| 169| register st_table_entry *ptr; 241| | 242| 169| hash_val = do_hash(key, table); ------------------ | | 56| 169|#define do_hash(key,table) (unsigned int)(*(table)->type->hash)((key)) ------------------ 243| 169| FIND_ENTRY(table, ptr, hash_val, bin_pos); ------------------ | | 224| 169|#define FIND_ENTRY(table, ptr, hash_val, bin_pos) do {\ | | 225| 169| bin_pos = hash_val%(table)->num_bins;\ | | 226| 169| ptr = (table)->bins[bin_pos];\ | | 227| 169| if (PTR_NOT_EQUAL(table, ptr, hash_val, key)) {\ | | ------------------ | | | | 215| 169|#define PTR_NOT_EQUAL(table, ptr, hash_val, key) \ | | | | 216| 169|((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (key), (ptr)->key))) | | | | ------------------ | | | | | | 54| 0|#define EQUAL(table,x,y) ((x)==(y) || (*table->type->compare)((x),(y)) == 0) | | | | | | ------------------ | | | | | | | Branch (54:27): [True: 0, False: 0] | | | | | | | Branch (54:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (216:2): [True: 1, False: 168] | | | | | Branch (216:17): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 228| 1| COLLISION;\ | | 229| 1| while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\ | | ------------------ | | | | 215| 1|#define PTR_NOT_EQUAL(table, ptr, hash_val, key) \ | | | | 216| 1|((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (key), (ptr)->key))) | | | | ------------------ | | | | | | 54| 0|#define EQUAL(table,x,y) ((x)==(y) || (*table->type->compare)((x),(y)) == 0) | | | | | | ------------------ | | | | | | | Branch (54:27): [True: 0, False: 0] | | | | | | | Branch (54:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (216:2): [True: 0, False: 1] | | | | | Branch (216:17): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 230| 0| ptr = ptr->next;\ | | 231| 0| }\ | | 232| 1| ptr = ptr->next;\ | | 233| 1| }\ | | 234| 169|} while (0) | | ------------------ | | | Branch (234:10): [Folded, False: 169] | | ------------------ ------------------ 244| | 245| 169| if (ptr == 0) { ------------------ | Branch (245:7): [True: 169, False: 0] ------------------ 246| 169| return 0; 247| 169| } 248| 0| else { 249| 0| if (value != 0) *value = ptr->record; ------------------ | Branch (249:9): [True: 0, False: 0] ------------------ 250| 0| return 1; 251| 0| } 252| 169|} onig_st_insert: 273| 673|{ 274| 673| unsigned int hash_val, bin_pos; 275| 673| register st_table_entry *ptr; 276| | 277| 673| hash_val = do_hash(key, table); ------------------ | | 56| 673|#define do_hash(key,table) (unsigned int)(*(table)->type->hash)((key)) ------------------ 278| 673| FIND_ENTRY(table, ptr, hash_val, bin_pos); ------------------ | | 224| 673|#define FIND_ENTRY(table, ptr, hash_val, bin_pos) do {\ | | 225| 673| bin_pos = hash_val%(table)->num_bins;\ | | 226| 673| ptr = (table)->bins[bin_pos];\ | | 227| 673| if (PTR_NOT_EQUAL(table, ptr, hash_val, key)) {\ | | ------------------ | | | | 215| 673|#define PTR_NOT_EQUAL(table, ptr, hash_val, key) \ | | | | 216| 673|((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (key), (ptr)->key))) | | | | ------------------ | | | | | | 54| 0|#define EQUAL(table,x,y) ((x)==(y) || (*table->type->compare)((x),(y)) == 0) | | | | | | ------------------ | | | | | | | Branch (54:27): [True: 0, False: 0] | | | | | | | Branch (54:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (216:2): [True: 1, False: 672] | | | | | Branch (216:17): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 228| 1| COLLISION;\ | | 229| 1| while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\ | | ------------------ | | | | 215| 1|#define PTR_NOT_EQUAL(table, ptr, hash_val, key) \ | | | | 216| 1|((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (key), (ptr)->key))) | | | | ------------------ | | | | | | 54| 0|#define EQUAL(table,x,y) ((x)==(y) || (*table->type->compare)((x),(y)) == 0) | | | | | | ------------------ | | | | | | | Branch (54:27): [True: 0, False: 0] | | | | | | | Branch (54:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (216:2): [True: 0, False: 1] | | | | | Branch (216:17): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 230| 0| ptr = ptr->next;\ | | 231| 0| }\ | | 232| 1| ptr = ptr->next;\ | | 233| 1| }\ | | 234| 673|} while (0) | | ------------------ | | | Branch (234:10): [Folded, False: 673] | | ------------------ ------------------ 279| | 280| 673| if (ptr == 0) { ------------------ | Branch (280:7): [True: 673, False: 0] ------------------ 281| 673| ADD_DIRECT(table, key, value, hash_val, bin_pos, ONIGERR_MEMORY); ------------------ | | 254| 673|#define ADD_DIRECT(table, key, value, hash_val, bin_pos, ret) \ | | 255| 673|do {\ | | 256| 673| st_table_entry *entry;\ | | 257| 673| if (table->num_entries/(table->num_bins) > ST_DEFAULT_MAX_DENSITY) {\ | | ------------------ | | | | 22| 1.34k|#define ST_DEFAULT_MAX_DENSITY 5 | | ------------------ | | | Branch (257:7): [True: 0, False: 673] | | ------------------ | | 258| 0| rehash(table);\ | | 259| 0| bin_pos = hash_val % table->num_bins;\ | | 260| 0| }\ | | 261| 673| entry = alloc(st_table_entry);\ | | ------------------ | | | | 51| 673|#define alloc(type) (type*)xmalloc((unsigned)sizeof(type)) | | | | ------------------ | | | | | | 227| 673|#define xmalloc malloc | | | | ------------------ | | ------------------ | | 262| 673| if (IS_NULL(entry)) return ret;\ | | ------------------ | | | | 201| 673|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (201:39): [True: 0, False: 673] | | | | ------------------ | | ------------------ | | 263| 673| entry->hash = hash_val;\ | | 264| 673| entry->key = key;\ | | 265| 673| entry->record = value;\ | | 266| 673| entry->next = table->bins[bin_pos];\ | | 267| 673| table->bins[bin_pos] = entry;\ | | 268| 673| table->num_entries++;\ | | 269| 673|} while (0) | | ------------------ | | | Branch (269:10): [Folded, False: 673] | | ------------------ ------------------ 282| 673| return 0; 283| 673| } 284| 0| else { 285| 0| ptr->record = value; 286| 0| return 1; 287| 0| } 288| 673|} onig_st_foreach: 460| 34.1k|{ 461| 34.1k| st_table_entry *ptr, *last, *tmp; 462| 34.1k| enum st_retval retval; 463| 34.1k| int i; 464| | 465| 409k| for(i = 0; i < table->num_bins; i++) { ------------------ | Branch (465:14): [True: 375k, False: 34.1k] ------------------ 466| 375k| last = 0; 467| 419k| for(ptr = table->bins[i]; ptr != 0;) { ------------------ | Branch (467:31): [True: 44.4k, False: 375k] ------------------ 468| 44.4k| retval = (*func)(ptr->key, ptr->record, arg); 469| 44.4k| switch (retval) { ------------------ | Branch (469:14): [True: 44.4k, False: 0] ------------------ 470| 0| case ST_CHECK: /* check if hash is modified during iteration */ ------------------ | Branch (470:6): [True: 0, False: 44.4k] ------------------ 471| 0| tmp = 0; 472| 0| if (i < table->num_bins) { ------------------ | Branch (472:13): [True: 0, False: 0] ------------------ 473| 0| for (tmp = table->bins[i]; tmp; tmp=tmp->next) { ------------------ | Branch (473:38): [True: 0, False: 0] ------------------ 474| 0| if (tmp == ptr) break; ------------------ | Branch (474:17): [True: 0, False: 0] ------------------ 475| 0| } 476| 0| } 477| 0| if (!tmp) { ------------------ | Branch (477:13): [True: 0, False: 0] ------------------ 478| | /* call func with error notice */ 479| 0| return 1; 480| 0| } 481| | /* fall through */ 482| 43.7k| case ST_CONTINUE: ------------------ | Branch (482:6): [True: 43.7k, False: 665] ------------------ 483| 43.7k| last = ptr; 484| 43.7k| ptr = ptr->next; 485| 43.7k| break; 486| 0| case ST_STOP: ------------------ | Branch (486:6): [True: 0, False: 44.4k] ------------------ 487| 0| return 0; 488| 665| case ST_DELETE: ------------------ | Branch (488:6): [True: 665, False: 43.7k] ------------------ 489| 665| tmp = ptr; 490| 665| if (last == 0) { ------------------ | Branch (490:13): [True: 665, False: 0] ------------------ 491| 665| table->bins[i] = ptr->next; 492| 665| } 493| 0| else { 494| 0| last->next = ptr->next; 495| 0| } 496| 665| ptr = ptr->next; 497| 665| free(tmp); 498| 665| table->num_entries--; 499| 44.4k| } 500| 44.4k| } 501| 375k| } 502| 34.1k| return 0; 503| 34.1k|} st.c:new_size: 101| 504|{ 102| 504| int i; 103| | 104| |#if 0 105| | for (i=3; i<31; i++) { 106| | if ((1< size) return 1< size) return primes[i]; ------------------ | Branch (115:11): [True: 504, False: 0] ------------------ 116| 504| } 117| | /* Ran out of polynomials */ 118| 0| return -1; /* should raise exception */ 119| 504|#endif 120| 504|} onigenc_unicode_get_case_fold_codes_by_str: 292| 2.80k|{ 293| 2.80k| int n, m, i, j, k, len, lens[3]; 294| 2.80k| int index; 295| 2.80k| int fn, ncs[3]; 296| 2.80k| OnigCodePoint cs[3][4]; 297| 2.80k| OnigCodePoint code, codes[3], orig_codes[3]; 298| 2.80k| const struct ByUnfoldKey* buk1; 299| | 300| 2.80k| n = 0; 301| | 302| 2.80k| code = ONIGENC_MBC_TO_CODE(enc, p, end); ------------------ | | 284| 2.80k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 303| 2.80k| if (CASE_FOLD_IS_ASCII_ONLY(flag)) { ------------------ | | 146| 2.80k| (((flag) & ONIGENC_CASE_FOLD_ASCII_ONLY) != 0) | | ------------------ | | | | 94| 2.80k|#define ONIGENC_CASE_FOLD_ASCII_ONLY (1) | | ------------------ | | | Branch (146:3): [True: 0, False: 2.80k] | | ------------------ ------------------ 304| 0| if (! ONIGENC_IS_ASCII_CODE(code)) return n; ------------------ | | 269| 0|#define ONIGENC_IS_ASCII_CODE(code) ((code) < 0x80) ------------------ | Branch (304:9): [True: 0, False: 0] ------------------ 305| 0| } 306| 2.80k| len = enclen(enc, p); ------------------ | | 83| 2.80k|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 2.80k|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 307| | 308| |#ifdef USE_UNICODE_CASE_FOLD_TURKISH_AZERI 309| | if ((flag & ONIGENC_CASE_FOLD_TURKISH_AZERI) != 0) { 310| | if (code == 0x0049) { 311| | items[0].byte_len = len; 312| | items[0].code_len = 1; 313| | items[0].code[0] = 0x0131; 314| | return 1; 315| | } 316| | else if (code == 0x0130) { 317| | items[0].byte_len = len; 318| | items[0].code_len = 1; 319| | items[0].code[0] = 0x0069; 320| | return 1; 321| | } 322| | else if (code == 0x0131) { 323| | items[0].byte_len = len; 324| | items[0].code_len = 1; 325| | items[0].code[0] = 0x0049; 326| | return 1; 327| | } 328| | else if (code == 0x0069) { 329| | items[0].byte_len = len; 330| | items[0].code_len = 1; 331| | items[0].code[0] = 0x0130; 332| | return 1; 333| | } 334| | } 335| |#endif 336| | 337| 2.80k| orig_codes[0] = code; 338| 2.80k| lens[0] = len; 339| 2.80k| p += len; 340| | 341| 2.80k| buk1 = onigenc_unicode_unfold_key(orig_codes[0]); 342| 2.80k| if (buk1 != 0 && buk1->fold_len == 1) { ------------------ | Branch (342:7): [True: 0, False: 2.80k] | Branch (342:20): [True: 0, False: 0] ------------------ 343| 0| codes[0] = *FOLDS1_FOLD(buk1->index); ------------------ | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) ------------------ 344| 0| } 345| 2.80k| else 346| 2.80k| codes[0] = orig_codes[0]; 347| | 348| 2.80k| if ((flag & INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR) == 0) ------------------ | | 98| 2.80k|#define INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR (1<<30) ------------------ | Branch (348:7): [True: 0, False: 2.80k] ------------------ 349| 0| goto fold1; 350| | 351| 2.80k| if (p < end) { ------------------ | Branch (351:7): [True: 450, False: 2.35k] ------------------ 352| 450| const struct ByUnfoldKey* buk; 353| | 354| 450| code = ONIGENC_MBC_TO_CODE(enc, p, end); ------------------ | | 284| 450|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 355| 450| orig_codes[1] = code; 356| 450| len = enclen(enc, p); ------------------ | | 83| 450|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 450|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 357| 450| lens[1] = lens[0] + len; 358| 450| buk = onigenc_unicode_unfold_key(orig_codes[1]); 359| 450| if (buk != 0 && buk->fold_len == 1) { ------------------ | Branch (359:9): [True: 0, False: 450] | Branch (359:21): [True: 0, False: 0] ------------------ 360| 0| codes[1] = *FOLDS1_FOLD(buk->index); ------------------ | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) ------------------ 361| 0| } 362| 450| else 363| 450| codes[1] = orig_codes[1]; 364| | 365| 450| p += len; 366| 450| if (p < end) { ------------------ | Branch (366:9): [True: 281, False: 169] ------------------ 367| 281| code = ONIGENC_MBC_TO_CODE(enc, p, end); ------------------ | | 284| 281|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end)) ------------------ 368| 281| orig_codes[2] = code; 369| 281| len = enclen(enc, p); ------------------ | | 83| 281|#define enclen(enc,p) ONIGENC_MBC_ENC_LEN(enc,p) | | ------------------ | | | | 279| 281|#define ONIGENC_MBC_ENC_LEN(enc,p) (enc)->mbc_enc_len(p) | | ------------------ ------------------ 370| 281| lens[2] = lens[1] + len; 371| 281| buk = onigenc_unicode_unfold_key(orig_codes[2]); 372| 281| if (buk != 0 && buk->fold_len == 1) { ------------------ | Branch (372:11): [True: 0, False: 281] | Branch (372:23): [True: 0, False: 0] ------------------ 373| 0| codes[2] = *FOLDS1_FOLD(buk->index); ------------------ | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) ------------------ 374| 0| } 375| 281| else 376| 281| codes[2] = orig_codes[2]; 377| | 378| 281| index = onigenc_unicode_fold3_key(codes); 379| 281| if (index >= 0) { ------------------ | Branch (379:11): [True: 0, False: 281] ------------------ 380| 0| m = FOLDS3_UNFOLDS_NUM(index); ------------------ | | 208| 0|#define FOLDS3_UNFOLDS_NUM(i) (OnigUnicodeFolds3[(i)+3]) ------------------ 381| 0| for (i = 0; i < m; i++) { ------------------ | Branch (381:21): [True: 0, False: 0] ------------------ 382| 0| items[n].byte_len = lens[2]; 383| 0| items[n].code_len = 1; 384| 0| items[n].code[0] = FOLDS3_UNFOLDS(index)[i]; ------------------ | | 211| 0|#define FOLDS3_UNFOLDS(i) (FOLDS3_FOLD(i) + 4) | | ------------------ | | | | 205| 0|#define FOLDS3_FOLD(i) (OnigUnicodeFolds3 + (i)) | | ------------------ ------------------ 385| 0| n++; 386| 0| } 387| | 388| 0| for (fn = 0; fn < 3; fn++) { ------------------ | Branch (388:22): [True: 0, False: 0] ------------------ 389| 0| int sindex; 390| 0| cs[fn][0] = FOLDS3_FOLD(index)[fn]; ------------------ | | 205| 0|#define FOLDS3_FOLD(i) (OnigUnicodeFolds3 + (i)) ------------------ 391| 0| ncs[fn] = 1; 392| 0| sindex = onigenc_unicode_fold1_key(&cs[fn][0]); 393| 0| if (sindex >= 0) { ------------------ | Branch (393:15): [True: 0, False: 0] ------------------ 394| 0| int m = FOLDS1_UNFOLDS_NUM(sindex); ------------------ | | 206| 0|#define FOLDS1_UNFOLDS_NUM(i) (OnigUnicodeFolds1[(i)+1]) ------------------ 395| 0| for (i = 0; i < m; i++) { ------------------ | Branch (395:25): [True: 0, False: 0] ------------------ 396| 0| cs[fn][i+1] = FOLDS1_UNFOLDS(sindex)[i]; ------------------ | | 209| 0|#define FOLDS1_UNFOLDS(i) (FOLDS1_FOLD(i) + 2) | | ------------------ | | | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) | | ------------------ ------------------ 397| 0| } 398| 0| ncs[fn] += m; 399| 0| } 400| 0| } 401| | 402| 0| for (i = 0; i < ncs[0]; i++) { ------------------ | Branch (402:21): [True: 0, False: 0] ------------------ 403| 0| for (j = 0; j < ncs[1]; j++) { ------------------ | Branch (403:23): [True: 0, False: 0] ------------------ 404| 0| for (k = 0; k < ncs[2]; k++) { ------------------ | Branch (404:25): [True: 0, False: 0] ------------------ 405| 0| if (cs[0][i] == orig_codes[0] && cs[1][j] == orig_codes[1] && ------------------ | Branch (405:19): [True: 0, False: 0] | Branch (405:48): [True: 0, False: 0] ------------------ 406| 0| cs[2][k] == orig_codes[2]) ------------------ | Branch (406:19): [True: 0, False: 0] ------------------ 407| 0| continue; 408| | 409| 0| items[n].byte_len = lens[2]; 410| 0| items[n].code_len = 3; 411| 0| items[n].code[0] = cs[0][i]; 412| 0| items[n].code[1] = cs[1][j]; 413| 0| items[n].code[2] = cs[2][k]; 414| 0| n++; 415| 0| } 416| 0| } 417| 0| } 418| | 419| 0| return n; 420| 0| } 421| 281| } 422| | 423| 450| index = onigenc_unicode_fold2_key(codes); 424| 450| if (index >= 0) { ------------------ | Branch (424:9): [True: 0, False: 450] ------------------ 425| 0| m = FOLDS2_UNFOLDS_NUM(index); ------------------ | | 207| 0|#define FOLDS2_UNFOLDS_NUM(i) (OnigUnicodeFolds2[(i)+2]) ------------------ 426| 0| for (i = 0; i < m; i++) { ------------------ | Branch (426:19): [True: 0, False: 0] ------------------ 427| 0| items[n].byte_len = lens[1]; 428| 0| items[n].code_len = 1; 429| 0| items[n].code[0] = FOLDS2_UNFOLDS(index)[i]; ------------------ | | 210| 0|#define FOLDS2_UNFOLDS(i) (FOLDS2_FOLD(i) + 3) | | ------------------ | | | | 204| 0|#define FOLDS2_FOLD(i) (OnigUnicodeFolds2 + (i)) | | ------------------ ------------------ 430| 0| n++; 431| 0| } 432| | 433| 0| for (fn = 0; fn < 2; fn++) { ------------------ | Branch (433:20): [True: 0, False: 0] ------------------ 434| 0| int sindex; 435| 0| cs[fn][0] = FOLDS2_FOLD(index)[fn]; ------------------ | | 204| 0|#define FOLDS2_FOLD(i) (OnigUnicodeFolds2 + (i)) ------------------ 436| 0| ncs[fn] = 1; 437| 0| sindex = onigenc_unicode_fold1_key(&cs[fn][0]); 438| 0| if (sindex >= 0) { ------------------ | Branch (438:13): [True: 0, False: 0] ------------------ 439| 0| int m = FOLDS1_UNFOLDS_NUM(sindex); ------------------ | | 206| 0|#define FOLDS1_UNFOLDS_NUM(i) (OnigUnicodeFolds1[(i)+1]) ------------------ 440| 0| for (i = 0; i < m; i++) { ------------------ | Branch (440:23): [True: 0, False: 0] ------------------ 441| 0| cs[fn][i+1] = FOLDS1_UNFOLDS(sindex)[i]; ------------------ | | 209| 0|#define FOLDS1_UNFOLDS(i) (FOLDS1_FOLD(i) + 2) | | ------------------ | | | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) | | ------------------ ------------------ 442| 0| } 443| 0| ncs[fn] += m; 444| 0| } 445| 0| } 446| | 447| 0| for (i = 0; i < ncs[0]; i++) { ------------------ | Branch (447:19): [True: 0, False: 0] ------------------ 448| 0| for (j = 0; j < ncs[1]; j++) { ------------------ | Branch (448:21): [True: 0, False: 0] ------------------ 449| 0| if (cs[0][i] == orig_codes[0] && cs[1][j] == orig_codes[1]) ------------------ | Branch (449:15): [True: 0, False: 0] | Branch (449:44): [True: 0, False: 0] ------------------ 450| 0| continue; 451| 0| items[n].byte_len = lens[1]; 452| 0| items[n].code_len = 2; 453| 0| items[n].code[0] = cs[0][i]; 454| 0| items[n].code[1] = cs[1][j]; 455| 0| n++; 456| 0| } 457| 0| } 458| | 459| 0| return n; 460| 0| } 461| 450| } 462| | 463| 2.80k| fold1: 464| 2.80k| if (buk1 != 0) { ------------------ | Branch (464:7): [True: 0, False: 2.80k] ------------------ 465| 0| if (buk1->fold_len == 1) { ------------------ | Branch (465:9): [True: 0, False: 0] ------------------ 466| 0| int un; 467| | 468| 0| if (CASE_FOLD_IS_NOT_ASCII_ONLY(flag) || ------------------ | | 148| 0| (((flag) & ONIGENC_CASE_FOLD_ASCII_ONLY) == 0) | | ------------------ | | | | 94| 0|#define ONIGENC_CASE_FOLD_ASCII_ONLY (1) | | ------------------ | | | Branch (148:3): [True: 0, False: 0] | | ------------------ ------------------ 469| 0| ONIGENC_IS_ASCII_CODE(*FOLDS1_FOLD(buk1->index))) { ------------------ | | 269| 0|#define ONIGENC_IS_ASCII_CODE(code) ((code) < 0x80) | | ------------------ | | | Branch (269:38): [True: 0, False: 0] | | ------------------ ------------------ 470| 0| items[0].byte_len = lens[0]; 471| 0| items[0].code_len = 1; 472| 0| items[0].code[0] = *FOLDS1_FOLD(buk1->index); ------------------ | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) ------------------ 473| 0| n++; 474| 0| } 475| | 476| 0| un = FOLDS1_UNFOLDS_NUM(buk1->index); ------------------ | | 206| 0|#define FOLDS1_UNFOLDS_NUM(i) (OnigUnicodeFolds1[(i)+1]) ------------------ 477| 0| for (i = 0; i < un; i++) { ------------------ | Branch (477:19): [True: 0, False: 0] ------------------ 478| 0| OnigCodePoint unfold = FOLDS1_UNFOLDS(buk1->index)[i]; ------------------ | | 209| 0|#define FOLDS1_UNFOLDS(i) (FOLDS1_FOLD(i) + 2) | | ------------------ | | | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) | | ------------------ ------------------ 479| 0| if (unfold != orig_codes[0]) { ------------------ | Branch (479:13): [True: 0, False: 0] ------------------ 480| 0| if (CASE_FOLD_IS_NOT_ASCII_ONLY(flag) || ------------------ | | 148| 0| (((flag) & ONIGENC_CASE_FOLD_ASCII_ONLY) == 0) | | ------------------ | | | | 94| 0|#define ONIGENC_CASE_FOLD_ASCII_ONLY (1) | | ------------------ | | | Branch (148:3): [True: 0, False: 0] | | ------------------ ------------------ 481| 0| ONIGENC_IS_ASCII_CODE(unfold)) { ------------------ | | 269| 0|#define ONIGENC_IS_ASCII_CODE(code) ((code) < 0x80) | | ------------------ | | | Branch (269:38): [True: 0, False: 0] | | ------------------ ------------------ 482| 0| items[n].byte_len = lens[0]; 483| 0| items[n].code_len = 1; 484| 0| items[n].code[0] = unfold; 485| 0| n++; 486| 0| } 487| 0| } 488| 0| } 489| 0| } 490| 0| else if ((flag & INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR) != 0) { ------------------ | | 98| 0|#define INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR (1<<30) ------------------ | Branch (490:14): [True: 0, False: 0] ------------------ 491| 0| if (buk1->fold_len == 2) { ------------------ | Branch (491:11): [True: 0, False: 0] ------------------ 492| 0| m = FOLDS2_UNFOLDS_NUM(buk1->index); ------------------ | | 207| 0|#define FOLDS2_UNFOLDS_NUM(i) (OnigUnicodeFolds2[(i)+2]) ------------------ 493| 0| for (i = 0; i < m; i++) { ------------------ | Branch (493:21): [True: 0, False: 0] ------------------ 494| 0| OnigCodePoint unfold = FOLDS2_UNFOLDS(buk1->index)[i]; ------------------ | | 210| 0|#define FOLDS2_UNFOLDS(i) (FOLDS2_FOLD(i) + 3) | | ------------------ | | | | 204| 0|#define FOLDS2_FOLD(i) (OnigUnicodeFolds2 + (i)) | | ------------------ ------------------ 495| 0| if (unfold == orig_codes[0]) continue; ------------------ | Branch (495:15): [True: 0, False: 0] ------------------ 496| | 497| 0| items[n].byte_len = lens[0]; 498| 0| items[n].code_len = 1; 499| 0| items[n].code[0] = unfold; 500| 0| n++; 501| 0| } 502| | 503| 0| for (fn = 0; fn < 2; fn++) { ------------------ | Branch (503:22): [True: 0, False: 0] ------------------ 504| 0| int index; 505| 0| cs[fn][0] = FOLDS2_FOLD(buk1->index)[fn]; ------------------ | | 204| 0|#define FOLDS2_FOLD(i) (OnigUnicodeFolds2 + (i)) ------------------ 506| 0| ncs[fn] = 1; 507| 0| index = onigenc_unicode_fold1_key(&cs[fn][0]); 508| 0| if (index >= 0) { ------------------ | Branch (508:15): [True: 0, False: 0] ------------------ 509| 0| int m = FOLDS1_UNFOLDS_NUM(index); ------------------ | | 206| 0|#define FOLDS1_UNFOLDS_NUM(i) (OnigUnicodeFolds1[(i)+1]) ------------------ 510| 0| for (i = 0; i < m; i++) { ------------------ | Branch (510:25): [True: 0, False: 0] ------------------ 511| 0| cs[fn][i+1] = FOLDS1_UNFOLDS(index)[i]; ------------------ | | 209| 0|#define FOLDS1_UNFOLDS(i) (FOLDS1_FOLD(i) + 2) | | ------------------ | | | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) | | ------------------ ------------------ 512| 0| } 513| 0| ncs[fn] += m; 514| 0| } 515| 0| } 516| | 517| 0| for (i = 0; i < ncs[0]; i++) { ------------------ | Branch (517:21): [True: 0, False: 0] ------------------ 518| 0| for (j = 0; j < ncs[1]; j++) { ------------------ | Branch (518:23): [True: 0, False: 0] ------------------ 519| 0| items[n].byte_len = lens[0]; 520| 0| items[n].code_len = 2; 521| 0| items[n].code[0] = cs[0][i]; 522| 0| items[n].code[1] = cs[1][j]; 523| 0| n++; 524| 0| } 525| 0| } 526| 0| } 527| 0| else { /* fold_len == 3 */ 528| 0| m = FOLDS3_UNFOLDS_NUM(buk1->index); ------------------ | | 208| 0|#define FOLDS3_UNFOLDS_NUM(i) (OnigUnicodeFolds3[(i)+3]) ------------------ 529| 0| for (i = 0; i < m; i++) { ------------------ | Branch (529:21): [True: 0, False: 0] ------------------ 530| 0| OnigCodePoint unfold = FOLDS3_UNFOLDS(buk1->index)[i]; ------------------ | | 211| 0|#define FOLDS3_UNFOLDS(i) (FOLDS3_FOLD(i) + 4) | | ------------------ | | | | 205| 0|#define FOLDS3_FOLD(i) (OnigUnicodeFolds3 + (i)) | | ------------------ ------------------ 531| 0| if (unfold == orig_codes[0]) continue; ------------------ | Branch (531:15): [True: 0, False: 0] ------------------ 532| | 533| 0| items[n].byte_len = lens[0]; 534| 0| items[n].code_len = 1; 535| 0| items[n].code[0] = unfold; 536| 0| n++; 537| 0| } 538| | 539| 0| for (fn = 0; fn < 3; fn++) { ------------------ | Branch (539:22): [True: 0, False: 0] ------------------ 540| 0| int index; 541| 0| cs[fn][0] = FOLDS3_FOLD(buk1->index)[fn]; ------------------ | | 205| 0|#define FOLDS3_FOLD(i) (OnigUnicodeFolds3 + (i)) ------------------ 542| 0| ncs[fn] = 1; 543| 0| index = onigenc_unicode_fold1_key(&cs[fn][0]); 544| 0| if (index >= 0) { ------------------ | Branch (544:15): [True: 0, False: 0] ------------------ 545| 0| int m = FOLDS1_UNFOLDS_NUM(index); ------------------ | | 206| 0|#define FOLDS1_UNFOLDS_NUM(i) (OnigUnicodeFolds1[(i)+1]) ------------------ 546| 0| for (i = 0; i < m; i++) { ------------------ | Branch (546:25): [True: 0, False: 0] ------------------ 547| 0| cs[fn][i+1] = FOLDS1_UNFOLDS(index)[i]; ------------------ | | 209| 0|#define FOLDS1_UNFOLDS(i) (FOLDS1_FOLD(i) + 2) | | ------------------ | | | | 203| 0|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) | | ------------------ ------------------ 548| 0| } 549| 0| ncs[fn] += m; 550| 0| } 551| 0| } 552| | 553| 0| for (i = 0; i < ncs[0]; i++) { ------------------ | Branch (553:21): [True: 0, False: 0] ------------------ 554| 0| for (j = 0; j < ncs[1]; j++) { ------------------ | Branch (554:23): [True: 0, False: 0] ------------------ 555| 0| for (k = 0; k < ncs[2]; k++) { ------------------ | Branch (555:25): [True: 0, False: 0] ------------------ 556| 0| items[n].byte_len = lens[0]; 557| 0| items[n].code_len = 3; 558| 0| items[n].code[0] = cs[0][i]; 559| 0| items[n].code[1] = cs[1][j]; 560| 0| items[n].code[2] = cs[2][k]; 561| 0| n++; 562| 0| } 563| 0| } 564| 0| } 565| 0| } 566| 0| } 567| 0| } 568| 2.80k| else { 569| 2.80k| int index = onigenc_unicode_fold1_key(orig_codes); 570| 2.80k| if (index >= 0) { ------------------ | Branch (570:9): [True: 2.69k, False: 112] ------------------ 571| 2.69k| int m = FOLDS1_UNFOLDS_NUM(index); ------------------ | | 206| 2.69k|#define FOLDS1_UNFOLDS_NUM(i) (OnigUnicodeFolds1[(i)+1]) ------------------ 572| 5.39k| for (i = 0; i < m; i++) { ------------------ | Branch (572:19): [True: 2.69k, False: 2.69k] ------------------ 573| 2.69k| code = FOLDS1_UNFOLDS(index)[i]; ------------------ | | 209| 2.69k|#define FOLDS1_UNFOLDS(i) (FOLDS1_FOLD(i) + 2) | | ------------------ | | | | 203| 2.69k|#define FOLDS1_FOLD(i) (OnigUnicodeFolds1 + (i)) | | ------------------ ------------------ 574| 2.69k| if (CASE_FOLD_IS_NOT_ASCII_ONLY(flag)||ONIGENC_IS_ASCII_CODE(code)) { ------------------ | | 148| 5.39k| (((flag) & ONIGENC_CASE_FOLD_ASCII_ONLY) == 0) | | ------------------ | | | | 94| 2.69k|#define ONIGENC_CASE_FOLD_ASCII_ONLY (1) | | ------------------ | | | Branch (148:3): [True: 2.69k, False: 0] | | ------------------ ------------------ if (CASE_FOLD_IS_NOT_ASCII_ONLY(flag)||ONIGENC_IS_ASCII_CODE(code)) { ------------------ | | 269| 0|#define ONIGENC_IS_ASCII_CODE(code) ((code) < 0x80) | | ------------------ | | | Branch (269:38): [True: 0, False: 0] | | ------------------ ------------------ 575| 2.69k| items[n].byte_len = lens[0]; 576| 2.69k| items[n].code_len = 1; 577| 2.69k| items[n].code[0] = code; 578| 2.69k| n++; 579| 2.69k| } 580| 2.69k| } 581| 2.69k| } 582| 2.80k| } 583| | 584| 2.80k| return n; 585| 2.80k|} onigenc_unicode_is_code_ctype: 1143| 2.31k|{ 1144| 2.31k| if ( 1145| 2.31k|#ifdef USE_UNICODE_PROPERTIES 1146| 2.31k| ctype <= ONIGENC_MAX_STD_CTYPE && ------------------ | | 248| 4.63k|#define ONIGENC_MAX_STD_CTYPE ONIGENC_CTYPE_ASCII ------------------ | Branch (1146:7): [True: 2.31k, False: 0] ------------------ 1147| 2.31k|#endif 1148| 2.31k| code < 256) { ------------------ | Branch (1148:7): [True: 2.31k, False: 0] ------------------ 1149| 2.31k| return ONIGENC_IS_UNICODE_ISO_8859_1_CTYPE(code, ctype); ------------------ | | 38| 2.31k| ((EncUNICODE_ISO_8859_1_CtypeTable[code] & CTYPE_TO_BIT(ctype)) != 0) | | ------------------ | | | | 102| 2.31k|#define CTYPE_TO_BIT(ctype) (1<<(ctype)) | | ------------------ ------------------ 1150| 2.31k| } 1151| | 1152| 0| if (ctype >= CODE_RANGES_NUM) { ------------------ | |33043| 0|#define CODE_RANGES_NUM 629 ------------------ | Branch (1152:7): [True: 0, False: 0] ------------------ 1153| 0| int index = ctype - CODE_RANGES_NUM; ------------------ | |33043| 0|#define CODE_RANGES_NUM 629 ------------------ 1154| 0| if (index < UserDefinedPropertyNum) ------------------ | Branch (1154:9): [True: 0, False: 0] ------------------ 1155| 0| return onig_is_in_code_range((UChar* )UserDefinedPropertyRanges[index].ranges, code); 1156| 0| else 1157| 0| return ONIGERR_TYPE_BUG; ------------------ | | 571| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 1158| 0| } 1159| | 1160| 0| return onig_is_in_code_range((UChar* )CodeRanges[ctype], code); 1161| 0|} onigenc_unicode_fold1_key: 90| 2.80k|{ 91| 2.80k| static const short int wordlist[] = 92| 2.80k| { 93| 2.80k| -1, -1, -1, -1, 94| | 95| 2.80k| 1915, 96| | 97| 2.80k| 1876, 98| | 99| 2.80k| 210, 100| | 101| 2.80k| 171, 102| | 103| 2.80k| 3453, 104| | 105| 2.80k| 1936, 106| | 107| 2.80k| 3558, 108| | 109| 2.80k| 231, 110| | 111| 2.80k| 993, 112| | 113| 2.80k| 1321, 114| | 115| 2.80k| 1282, 116| | 117| 2.80k| 3153, 118| | 119| 2.80k| 2669, 120| | 121| 2.80k| 3714, 122| | 123| 2.80k| 1342, 124| | 125| 2.80k| 544, 126| | 127| 2.80k| 505, 128| | 129| 2.80k| 2105, 130| | 131| 2.80k| 1141, 132| | 133| 2.80k| 390, 134| | 135| 2.80k| 562, 136| | 137| 2.80k| 3693, 138| | 139| 2.80k| 2804, 140| | 141| 2.80k| 3309, 142| | 143| 2.80k| 3711, 144| | 145| 2.80k| 2036, 146| | 147| 2.80k| 1069, 148| | 149| 2.80k| 324, 150| | 151| 2.80k| 2249, 152| | 153| 2.80k| 27, 154| | 155| 2.80k| 1612, 156| | 157| 2.80k| 3249, 158| | 159| 2.80k| 1618, 160| | 161| 2.80k| 3732, 162| | 163| 2.80k| 1384, 164| | 165| 2.80k| 159, 166| | 167| 2.80k| 2252, 168| | 169| 2.80k| 1047, 170| | 171| 2.80k| 3405, 172| | 173| 2.80k| 402, 174| | 175| 2.80k| 664, 176| | 177| 2.80k| 2723, 178| | 179| 2.80k| 3096, 180| | 181| 2.80k| 1615, 182| | 183| 2.80k| 3750, 184| | 185| 2.80k| 2027, 186| | 187| 2.80k| 1060, 188| | 189| 2.80k| 315, 190| | 191| 2.80k| 4131, 192| | 193| 2.80k| 12, 194| | 195| 2.80k| 2732, 196| | 197| 2.80k| 3240, 198| | 199| 2.80k| 1636, 200| | 201| 2.80k| 2270, 202| | 203| 2.80k| 1366, 204| | 205| 2.80k| 3681, 206| | 207| 2.80k| 2099, 208| | 209| 2.80k| 1120, 210| | 211| 2.80k| 372, 212| | 213| 2.80k| 2306, 214| | 215| 2.80k| 649, 216| | 217| 2.80k| 2783, 218| | 219| 2.80k| 3087, 220| | 221| 2.80k| 1654, 222| | 223| 2.80k| 2432, 224| | 225| 2.80k| 2020, 226| | 227| 2.80k| 1053, 228| | 229| 2.80k| 309, 230| | 231| 2.80k| 4113, 232| | 233| 2.80k| 0, 234| | 235| 2.80k| 2729, 236| | 237| 2.80k| 3234, 238| | 239| 2.80k| 2381, 240| | 241| 2.80k| 3132, 242| | 243| 2.80k| 1354, 244| | 245| 2.80k| 3591, 246| | 247| 2.80k| 2195, 248| | 249| 2.80k| 1231, 250| | 251| 2.80k| 459, 252| | 253| 2.80k| 3288, 254| | 255| 2.80k| 640, 256| | 257| 2.80k| 2894, 258| | 259| 2.80k| 3081, 260| | 261| 2.80k| 1465, 262| | 263| 2.80k| 3597, 264| | 265| 2.80k| 2198, 266| | 267| 2.80k| 1234, 268| | 269| 2.80k| 462, 270| | 271| 2.80k| 4101, 272| | 273| 2.80k| 80, 274| | 275| 2.80k| 2897, 276| | 277| 2.80k| 1888, 278| | 279| 2.80k| 2369, 280| | 281| 2.80k| 183, 282| | 283| 2.80k| 3456, 284| | 285| 2.80k| 2993, 286| | 287| 2.80k| 2915, 288| | 289| 2.80k| 1696, 290| | 291| 2.80k| 3660, 292| | 293| 2.80k| 1894, 294| | 295| 2.80k| 1294, 296| | 297| 2.80k| 189, 298| | 299| 2.80k| 1795, 300| | 301| 2.80k| 144, 302| | 303| 2.80k| 2918, 304| | 305| 2.80k| 3366, 306| | 307| 2.80k| 517, 308| | 309| 2.80k| 3546, 310| | 311| 2.80k| 1300, 312| | 313| 2.80k| 980, 314| | 315| 2.80k| 273, 316| | 317| 2.80k| 1801, 318| | 319| 2.80k| 2447, 320| | 321| 2.80k| 2657, 322| | 323| 2.80k| 523, 324| | 325| 2.80k| 3609, 326| | 327| 2.80k| 2204, 328| | 329| 2.80k| 1240, 330| | 331| 2.80k| 468, 332| | 333| 2.80k| 2984, 334| | 335| 2.80k| 92, 336| | 337| 2.80k| 2960, 338| | 339| 2.80k| 2996, 340| | 341| 2.80k| 3603, 342| | 343| 2.80k| 2201, 344| | 345| 2.80k| 1237, 346| | 347| 2.80k| 465, 348| | 349| 2.80k| 3672, 350| | 351| 2.80k| 86, 352| | 353| 2.80k| 2900, 354| | 355| 2.80k| 3588, 356| | 357| 2.80k| 1924, 358| | 359| 2.80k| 153, 360| | 361| 2.80k| 219, 362| | 363| 2.80k| 165, 364| | 365| 2.80k| 3585, 366| | 367| 2.80k| 2192, 368| | 369| 2.80k| 1228, 370| | 371| 2.80k| 456, 372| | 373| 2.80k| 3393, 374| | 375| 2.80k| 1330, 376| | 377| 2.80k| 2891, 378| | 379| 2.80k| 1813, 380| | 381| 2.80k| 2450, 382| | 383| 2.80k| 1906, 384| | 385| 2.80k| 2978, 386| | 387| 2.80k| 201, 388| | 389| 2.80k| 2090, 390| | 391| 2.80k| 1111, 392| | 393| 2.80k| 2954, 394| | 395| 2.80k| 1807, 396| | 397| 2.80k| 2246, 398| | 399| 2.80k| 2774, 400| | 401| 2.80k| 1312, 402| | 403| 2.80k| 3579, 404| | 405| 2.80k| 2189, 406| | 407| 2.80k| 1225, 408| | 409| 2.80k| 1792, 410| | 411| 2.80k| 2291, 412| | 413| 2.80k| 535, 414| | 415| 2.80k| 2888, 416| | 417| 2.80k| 3363, 418| | 419| 2.80k| 1789, 420| | 421| 2.80k| 1684, 422| | 423| 2.80k| 3123, 424| | 425| 2.80k| 3876, 426| | 427| 2.80k| 3573, 428| | 429| 2.80k| 2186, 430| | 431| 2.80k| 1222, 432| | 433| 2.80k| 2948, 434| | 435| 2.80k| 2942, 436| | 437| 2.80k| 2285, 438| | 439| 2.80k| 2885, 440| | 441| 2.80k| 3360, 442| | 443| 2.80k| 3882, 444| | 445| 2.80k| 1513, 446| | 447| 2.80k| 2045, 448| | 449| 2.80k| 1078, 450| | 451| 2.80k| 333, 452| | 453| 2.80k| 2936, 454| | 455| 2.80k| 46, 456| | 457| 2.80k| 1783, 458| | 459| 2.80k| 1459, 460| 2.80k| -1, 461| | 462| 2.80k| 1519, 463| | 464| 2.80k| 1402, 465| | 466| 2.80k| 2939, 467| | 468| 2.80k| 3621, 469| | 470| 2.80k| 2210, 471| | 472| 2.80k| 1246, 473| | 474| 2.80k| 474, 475| | 476| 2.80k| 673, 477| | 478| 2.80k| 105, 479| | 480| 2.80k| 1777, 481| | 482| 2.80k| 2951, 483| | 484| 2.80k| 798, 485| | 486| 2.80k| 2183, 487| | 488| 2.80k| 1219, 489| | 490| 2.80k| 1582, 491| | 492| 2.80k| 4149, 493| | 494| 2.80k| 863, 495| | 496| 2.80k| 2882, 497| | 498| 2.80k| 3357, 499| | 500| 2.80k| 2393, 501| | 502| 2.80k| 366, 503| | 504| 2.80k| 3894, 505| | 506| 2.80k| 1135, 507| | 508| 2.80k| 2552, 509| | 510| 2.80k| 3279, 511| | 512| 2.80k| 866, 513| | 514| 2.80k| 2798, 515| | 516| 2.80k| 3303, 517| | 518| 2.80k| 3702, 519| | 520| 2.80k| 3888, 521| | 522| 2.80k| 1825, 523| | 524| 2.80k| 1531, 525| | 526| 2.80k| 2558, 527| | 528| 2.80k| 709, 529| | 530| 2.80k| 4095, 531| | 532| 2.80k| 2912, 533| | 534| 2.80k| 3873, 535| 2.80k| -1, 536| | 537| 2.80k| 1771, 538| | 539| 2.80k| 1525, 540| | 541| 2.80k| 2288, 542| | 543| 2.80k| 3870, 544| | 545| 2.80k| 3011, 546| | 547| 2.80k| 1594, 548| | 549| 2.80k| 369, 550| | 551| 2.80k| 1600, 552| | 553| 2.80k| 1510, 554| | 555| 2.80k| 3615, 556| | 557| 2.80k| 2207, 558| | 559| 2.80k| 1243, 560| | 561| 2.80k| 471, 562| | 563| 2.80k| 1507, 564| | 565| 2.80k| 99, 566| | 567| 2.80k| 2174, 568| | 569| 2.80k| 1210, 570| | 571| 2.80k| 2975, 572| | 573| 2.80k| 872, 574| | 575| 2.80k| 712, 576| | 577| 2.80k| 2873, 578| | 579| 2.80k| 3354, 580| | 581| 2.80k| 3864, 582| 2.80k| -1, 583| | 584| 2.80k| 3996, 585| | 586| 2.80k| 2570, 587| | 588| 2.80k| 869, 589| | 590| 2.80k| 3939, 591| | 592| 2.80k| 1912, 593| | 594| 2.80k| 3564, 595| | 596| 2.80k| 207, 597| | 598| 2.80k| 999, 599| | 600| 2.80k| 1501, 601| | 602| 2.80k| 2564, 603| | 604| 2.80k| 3858, 605| | 606| 2.80k| 2675, 607| | 608| 2.80k| 1819, 609| | 610| 2.80k| 1318, 611| | 612| 2.80k| 860, 613| | 614| 2.80k| 784, 615| | 616| 2.80k| 2549, 617| | 618| 2.80k| 1753, 619| | 620| 2.80k| 2441, 621| | 622| 2.80k| 541, 623| | 624| 2.80k| 1495, 625| | 626| 2.80k| 2546, 627| 2.80k| -1, 628| | 629| 2.80k| 3651, 630| | 631| 2.80k| 2225, 632| | 633| 2.80k| 1261, 634| | 635| 2.80k| 486, 636| | 637| 2.80k| 4092, 638| | 639| 2.80k| 135, 640| | 641| 2.80k| 2909, 642| | 643| 2.80k| 1132, 644| | 645| 2.80k| 3906, 646| | 647| 2.80k| 4089, 648| | 649| 2.80k| 857, 650| | 651| 2.80k| 2795, 652| | 653| 2.80k| 3300, 654| | 655| 2.80k| 3696, 656| | 657| 2.80k| 3411, 658| | 659| 2.80k| 3612, 660| | 661| 2.80k| 3852, 662| | 663| 2.80k| 2540, 664| | 665| 2.80k| 1543, 666| | 667| 2.80k| 4215, 668| | 669| 2.80k| 96, 670| | 671| 2.80k| 715, 672| | 673| 2.80k| 854, 674| | 675| 2.80k| 3008, 676| | 677| 2.80k| 1660, 678| | 679| 2.80k| 378, 680| | 681| 2.80k| 1489, 682| | 683| 2.80k| 1855, 684| | 685| 2.80k| 4083, 686| | 687| 2.80k| 2534, 688| | 689| 2.80k| 3687, 690| | 691| 2.80k| 721, 692| | 693| 2.80k| 2024, 694| | 695| 2.80k| 1056, 696| | 697| 2.80k| 312, 698| 2.80k| -1, 699| | 700| 2.80k| 6, 701| | 702| 2.80k| 703, 703| | 704| 2.80k| 3237, 705| | 706| 2.80k| 2078, 707| | 708| 2.80k| 4077, 709| | 710| 2.80k| 1360, 711| | 712| 2.80k| 1816, 713| | 714| 2.80k| 878, 715| | 716| 2.80k| 2762, 717| | 718| 2.80k| 3276, 719| | 720| 2.80k| 4206, 721| | 722| 2.80k| 643, 723| | 724| 2.80k| 384, 725| | 726| 2.80k| 3084, 727| | 728| 2.80k| 2582, 729| | 730| 2.80k| 851, 731| | 732| 2.80k| 3900, 733| | 734| 2.80k| 3699, 735| | 736| 2.80k| 694, 737| | 738| 2.80k| 4107, 739| | 740| 2.80k| 3111, 741| | 742| 2.80k| 3834, 743| | 744| 2.80k| 2528, 745| | 746| 2.80k| 2375, 747| | 748| 2.80k| 363, 749| | 750| 2.80k| 718, 751| | 752| 2.80k| 1537, 753| | 754| 2.80k| 3639, 755| | 756| 2.80k| 2219, 757| | 758| 2.80k| 1255, 759| | 760| 2.80k| 483, 761| | 762| 2.80k| 1471, 763| | 764| 2.80k| 123, 765| | 766| 2.80k| 4071, 767| | 768| 2.80k| 2048, 769| | 770| 2.80k| 1081, 771| | 772| 2.80k| 336, 773| | 774| 2.80k| 697, 775| | 776| 2.80k| 52, 777| | 778| 2.80k| 2747, 779| | 780| 2.80k| 2987, 781| 2.80k| -1, -1, 782| | 783| 2.80k| 1408, 784| | 785| 2.80k| 3633, 786| | 787| 2.80k| 2216, 788| | 789| 2.80k| 1252, 790| | 791| 2.80k| 480, 792| | 793| 2.80k| 3648, 794| | 795| 2.80k| 117, 796| 2.80k| -1, 797| | 798| 2.80k| 875, 799| | 800| 2.80k| 3002, 801| | 802| 2.80k| 132, 803| | 804| 2.80k| 1843, 805| | 806| 2.80k| 2117, 807| | 808| 2.80k| 1153, 809| | 810| 2.80k| 4155, 811| | 812| 2.80k| 2576, 813| 2.80k| -1, 814| | 815| 2.80k| 2816, 816| | 817| 2.80k| 2399, 818| | 819| 2.80k| 3735, 820| | 821| 2.80k| 2510, 822| | 823| 2.80k| 1573, 824| | 825| 2.80k| 3627, 826| | 827| 2.80k| 2213, 828| | 829| 2.80k| 1249, 830| | 831| 2.80k| 477, 832| | 833| 2.80k| 3897, 834| | 835| 2.80k| 111, 836| | 837| 2.80k| 1837, 838| | 839| 2.80k| 2300, 840| | 841| 2.80k| 4218, 842| | 843| 2.80k| 4053, 844| | 845| 2.80k| 1852, 846| | 847| 2.80k| 2033, 848| | 849| 2.80k| 1066, 850| | 851| 2.80k| 321, 852| | 853| 2.80k| 1534, 854| | 855| 2.80k| 4296, 856| | 857| 2.80k| 1639, 858| | 859| 2.80k| 3246, 860| | 861| 2.80k| 348, 862| | 863| 2.80k| 3720, 864| | 865| 2.80k| 1378, 866| | 867| 2.80k| 754, 868| | 869| 2.80k| 3261, 870| 2.80k| -1, 871| | 872| 2.80k| 893, 873| | 874| 2.80k| 1435, 875| | 876| 2.80k| 658, 877| | 878| 2.80k| 1831, 879| | 880| 2.80k| 3093, 881| 2.80k| -1, 882| | 883| 2.80k| 3780, 884| | 885| 2.80k| 2030, 886| | 887| 2.80k| 1063, 888| | 889| 2.80k| 318, 890| | 891| 2.80k| 4125, 892| | 893| 2.80k| 18, 894| | 895| 2.80k| 3654, 896| | 897| 2.80k| 3243, 898| | 899| 2.80k| 1624, 900| | 901| 2.80k| 4182, 902| | 903| 2.80k| 1372, 904| | 905| 2.80k| 138, 906| | 907| 2.80k| 3945, 908| | 909| 2.80k| 2426, 910| | 911| 2.80k| 2063, 912| | 913| 2.80k| 1096, 914| | 915| 2.80k| 2573, 916| | 917| 2.80k| 3705, 918| | 919| 2.80k| 3090, 920| | 921| 2.80k| 1690, 922| 2.80k| -1, -1, 923| | 924| 2.80k| 3924, 925| | 926| 2.80k| 1438, 927| | 928| 2.80k| 4119, 929| | 930| 2.80k| 1999, 931| | 932| 2.80k| 1014, 933| | 934| 2.80k| 288, 935| | 936| 2.80k| 2387, 937| | 938| 2.80k| 682, 939| | 940| 2.80k| 2690, 941| | 942| 2.80k| 3213, 943| | 944| 2.80k| 1561, 945| | 946| 2.80k| 1858, 947| 2.80k| -1, 948| | 949| 2.80k| 2504, 950| | 951| 2.80k| 1606, 952| | 953| 2.80k| 4185, 954| | 955| 2.80k| 2459, 956| | 957| 2.80k| 3918, 958| | 959| 2.80k| 616, 960| | 961| 2.80k| 2429, 962| | 963| 2.80k| 3060, 964| | 965| 2.80k| 3933, 966| 2.80k| -1, 967| | 968| 2.80k| 3020, 969| | 970| 2.80k| 2051, 971| | 972| 2.80k| 1084, 973| | 974| 2.80k| 339, 975| | 976| 2.80k| 1555, 977| | 978| 2.80k| 59, 979| 2.80k| -1, 980| | 981| 2.80k| 2357, 982| | 983| 2.80k| 1570, 984| | 985| 2.80k| 3468, 986| | 987| 2.80k| 1414, 988| | 989| 2.80k| 3426, 990| | 991| 2.80k| 887, 992| | 993| 2.80k| 2282, 994| | 995| 2.80k| 3972, 996| | 997| 2.80k| 3912, 998| | 999| 2.80k| 679, 1000| | 1001| 2.80k| 3462, 1002| | 1003| 2.80k| 724, 1004| 2.80k| -1, -1, 1005| | 1006| 2.80k| 2005, 1007| | 1008| 2.80k| 1026, 1009| | 1010| 2.80k| 294, 1011| | 1012| 2.80k| 4161, 1013| | 1014| 2.80k| 1549, 1015| | 1016| 2.80k| 2702, 1017| | 1018| 2.80k| 3219, 1019| | 1020| 2.80k| 2405, 1021| | 1022| 2.80k| 884, 1023| | 1024| 2.80k| 345, 1025| 2.80k| -1, 1026| | 1027| 2.80k| 74, 1028| | 1029| 2.80k| 890, 1030| | 1031| 2.80k| 3258, 1032| | 1033| 2.80k| 637, 1034| | 1035| 2.80k| 625, 1036| | 1037| 2.80k| 1429, 1038| | 1039| 2.80k| 3066, 1040| | 1041| 2.80k| 1996, 1042| | 1043| 2.80k| 1008, 1044| | 1045| 2.80k| 285, 1046| | 1047| 2.80k| 3975, 1048| | 1049| 2.80k| 4098, 1050| | 1051| 2.80k| 2684, 1052| | 1053| 2.80k| 3210, 1054| 2.80k| -1, 1055| | 1056| 2.80k| 2366, 1057| | 1058| 2.80k| 2363, 1059| 2.80k| -1, 1060| | 1061| 2.80k| 881, 1062| | 1063| 2.80k| 4176, 1064| | 1065| 2.80k| 3438, 1066| 2.80k| -1, 1067| | 1068| 2.80k| 610, 1069| | 1070| 2.80k| 2420, 1071| | 1072| 2.80k| 3057, 1073| | 1074| 2.80k| 3567, 1075| | 1076| 2.80k| 1993, 1077| | 1078| 2.80k| 1002, 1079| | 1080| 2.80k| 282, 1081| | 1082| 2.80k| 1576, 1083| | 1084| 2.80k| 2168, 1085| | 1086| 2.80k| 2678, 1087| | 1088| 2.80k| 3207, 1089| | 1090| 2.80k| 733, 1091| | 1092| 2.80k| 2354, 1093| | 1094| 2.80k| 2867, 1095| | 1096| 2.80k| 3351, 1097| | 1098| 2.80k| 2453, 1099| | 1100| 2.80k| 3420, 1101| 2.80k| -1, 1102| | 1103| 2.80k| 791, 1104| | 1105| 2.80k| 604, 1106| | 1107| 2.80k| 3951, 1108| | 1109| 2.80k| 3054, 1110| | 1111| 2.80k| 3561, 1112| | 1113| 2.80k| 1990, 1114| | 1115| 2.80k| 996, 1116| | 1117| 2.80k| 279, 1118| 2.80k| -1, 1119| | 1120| 2.80k| 2972, 1121| | 1122| 2.80k| 2672, 1123| | 1124| 2.80k| 3204, 1125| | 1126| 2.80k| 3555, 1127| | 1128| 2.80k| 1987, 1129| | 1130| 2.80k| 990, 1131| | 1132| 2.80k| 276, 1133| | 1134| 2.80k| 1741, 1135| | 1136| 2.80k| 3414, 1137| | 1138| 2.80k| 2666, 1139| | 1140| 2.80k| 3201, 1141| | 1142| 2.80k| 601, 1143| | 1144| 2.80k| 736, 1145| | 1146| 2.80k| 3051, 1147| 2.80k| -1, 1148| | 1149| 2.80k| 1864, 1150| | 1151| 2.80k| 3531, 1152| | 1153| 2.80k| 1975, 1154| | 1155| 2.80k| 965, 1156| | 1157| 2.80k| 598, 1158| | 1159| 2.80k| 3966, 1160| | 1161| 2.80k| 3047, 1162| | 1163| 2.80k| 2642, 1164| | 1165| 2.80k| 3189, 1166| | 1167| 2.80k| 3525, 1168| | 1169| 2.80k| 1972, 1170| | 1171| 2.80k| 956, 1172| | 1173| 2.80k| 3408, 1174| | 1175| 2.80k| 3666, 1176| 2.80k| -1, 1177| | 1178| 2.80k| 2636, 1179| | 1180| 2.80k| 3186, 1181| | 1182| 2.80k| 1873, 1183| | 1184| 2.80k| 147, 1185| | 1186| 2.80k| 3035, 1187| | 1188| 2.80k| 3402, 1189| | 1190| 2.80k| 2180, 1191| | 1192| 2.80k| 1216, 1193| | 1194| 2.80k| 3663, 1195| | 1196| 2.80k| 2231, 1197| | 1198| 2.80k| 1267, 1199| | 1200| 2.80k| 2879, 1201| | 1202| 2.80k| 3032, 1203| 2.80k| -1, 1204| | 1205| 2.80k| 2345, 1206| | 1207| 2.80k| 2054, 1208| | 1209| 2.80k| 1087, 1210| | 1211| 2.80k| 342, 1212| | 1213| 2.80k| 3378, 1214| | 1215| 2.80k| 65, 1216| | 1217| 2.80k| 2177, 1218| | 1219| 2.80k| 1213, 1220| | 1221| 2.80k| 2339, 1222| | 1223| 2.80k| 2276, 1224| | 1225| 2.80k| 1420, 1226| | 1227| 2.80k| 2876, 1228| | 1229| 2.80k| 3372, 1230| | 1231| 2.80k| 3483, 1232| | 1233| 2.80k| 1951, 1234| | 1235| 2.80k| 912, 1236| | 1237| 2.80k| 243, 1238| | 1239| 2.80k| 3450, 1240| | 1241| 2.80k| 1765, 1242| | 1243| 2.80k| 2594, 1244| | 1245| 2.80k| 3165, 1246| | 1247| 2.80k| 2042, 1248| | 1249| 2.80k| 1075, 1250| | 1251| 2.80k| 330, 1252| | 1253| 2.80k| 4167, 1254| | 1255| 2.80k| 40, 1256| | 1257| 2.80k| 3822, 1258| | 1259| 2.80k| 3255, 1260| | 1261| 2.80k| 2411, 1262| | 1263| 2.80k| 577, 1264| | 1265| 2.80k| 1396, 1266| | 1267| 2.80k| 2465, 1268| | 1269| 2.80k| 1759, 1270| | 1271| 2.80k| 2138, 1272| | 1273| 2.80k| 1174, 1274| | 1275| 2.80k| 411, 1276| | 1277| 2.80k| 670, 1278| | 1279| 2.80k| 37, 1280| | 1281| 2.80k| 2837, 1282| | 1283| 2.80k| 3327, 1284| | 1285| 2.80k| 3774, 1286| | 1287| 2.80k| 2321, 1288| | 1289| 2.80k| 1393, 1290| | 1291| 2.80k| 2072, 1292| | 1293| 2.80k| 4143, 1294| | 1295| 2.80k| 357, 1296| | 1297| 2.80k| 2057, 1298| | 1299| 2.80k| 1090, 1300| | 1301| 2.80k| 2756, 1302| | 1303| 2.80k| 3270, 1304| | 1305| 2.80k| 71, 1306| | 1307| 2.80k| 1453, 1308| | 1309| 2.80k| 1456, 1310| | 1311| 2.80k| 2060, 1312| | 1313| 2.80k| 1093, 1314| | 1315| 2.80k| 1426, 1316| | 1317| 2.80k| 4140, 1318| | 1319| 2.80k| 688, 1320| | 1321| 2.80k| 691, 1322| | 1323| 2.80k| 1681, 1324| | 1325| 2.80k| 3105, 1326| | 1327| 2.80k| 845, 1328| | 1329| 2.80k| 1432, 1330| | 1331| 2.80k| 4200, 1332| 2.80k| -1, -1, 1333| | 1334| 2.80k| 2039, 1335| | 1336| 2.80k| 1072, 1337| | 1338| 2.80k| 327, 1339| | 1340| 2.80k| 4173, 1341| | 1342| 2.80k| 34, 1343| 2.80k| -1, 1344| | 1345| 2.80k| 3252, 1346| | 1347| 2.80k| 2417, 1348| | 1349| 2.80k| 3957, 1350| | 1351| 2.80k| 1390, 1352| | 1353| 2.80k| 4179, 1354| | 1355| 2.80k| 2966, 1356| | 1357| 2.80k| 2492, 1358| | 1359| 2.80k| 4041, 1360| | 1361| 2.80k| 2423, 1362| | 1363| 2.80k| 3846, 1364| | 1365| 2.80k| 2990, 1366| | 1367| 2.80k| 3099, 1368| | 1369| 2.80k| 1588, 1370| 2.80k| -1, 1371| | 1372| 2.80k| 3537, 1373| | 1374| 2.80k| 1978, 1375| | 1376| 2.80k| 971, 1377| | 1378| 2.80k| 4137, 1379| 2.80k| -1, 1380| | 1381| 2.80k| 1483, 1382| | 1383| 2.80k| 2648, 1384| | 1385| 2.80k| 3192, 1386| | 1387| 2.80k| 1585, 1388| | 1389| 2.80k| 3840, 1390| | 1391| 2.80k| 2008, 1392| | 1393| 2.80k| 1032, 1394| | 1395| 2.80k| 297, 1396| 2.80k| -1, -1, 1397| | 1398| 2.80k| 2708, 1399| | 1400| 2.80k| 3222, 1401| 2.80k| -1, 1402| | 1403| 2.80k| 3038, 1404| | 1405| 2.80k| 1477, 1406| | 1407| 2.80k| 2495, 1408| | 1409| 2.80k| 396, 1410| 2.80k| -1, 1411| | 1412| 2.80k| 896, 1413| 2.80k| -1, 1414| | 1415| 2.80k| 628, 1416| | 1417| 2.80k| 3726, 1418| | 1419| 2.80k| 3069, 1420| | 1421| 2.80k| 2351, 1422| | 1423| 2.80k| 3990, 1424| | 1425| 2.80k| 3993, 1426| | 1427| 2.80k| 1198, 1428| | 1429| 2.80k| 3384, 1430| | 1431| 2.80k| 3963, 1432| 2.80k| -1, 1433| | 1434| 2.80k| 2264, 1435| | 1436| 2.80k| 3348, 1437| | 1438| 2.80k| 2522, 1439| | 1440| 2.80k| 9, 1441| | 1442| 2.80k| 727, 1443| | 1444| 2.80k| 3969, 1445| | 1446| 2.80k| 3444, 1447| | 1448| 2.80k| 2258, 1449| | 1450| 2.80k| 1363, 1451| | 1452| 2.80k| 3528, 1453| | 1454| 2.80k| 1630, 1455| | 1456| 2.80k| 960, 1457| | 1458| 2.80k| 264, 1459| | 1460| 2.80k| 4065, 1461| | 1462| 2.80k| 646, 1463| | 1464| 2.80k| 2639, 1465| | 1466| 2.80k| 2516, 1467| | 1468| 2.80k| 2471, 1469| | 1470| 2.80k| 2002, 1471| | 1472| 2.80k| 1020, 1473| | 1474| 2.80k| 291, 1475| | 1476| 2.80k| 1732, 1477| | 1478| 2.80k| 4110, 1479| | 1480| 2.80k| 2696, 1481| | 1482| 2.80k| 3216, 1483| | 1484| 2.80k| 589, 1485| | 1486| 2.80k| 2378, 1487| | 1488| 2.80k| 4059, 1489| 2.80k| -1, -1, -1, -1, 1490| | 1491| 2.80k| 3549, 1492| | 1493| 2.80k| 1984, 1494| | 1495| 2.80k| 983, 1496| | 1497| 2.80k| 3063, 1498| | 1499| 2.80k| 779, 1500| | 1501| 2.80k| 2342, 1502| | 1503| 2.80k| 2660, 1504| | 1505| 2.80k| 3198, 1506| | 1507| 2.80k| 3516, 1508| | 1509| 2.80k| 3375, 1510| | 1511| 2.80k| 946, 1512| | 1513| 2.80k| 258, 1514| | 1515| 2.80k| 2486, 1516| | 1517| 2.80k| 2360, 1518| | 1519| 2.80k| 2627, 1520| | 1521| 2.80k| 4230, 1522| | 1523| 2.80k| 595, 1524| | 1525| 2.80k| 3432, 1526| | 1527| 2.80k| 3044, 1528| | 1529| 2.80k| 3543, 1530| | 1531| 2.80k| 1981, 1532| | 1533| 2.80k| 977, 1534| 2.80k| -1, 1535| | 1536| 2.80k| 4224, 1537| | 1538| 2.80k| 730, 1539| | 1540| 2.80k| 2654, 1541| | 1542| 2.80k| 3195, 1543| | 1544| 2.80k| 3495, 1545| | 1546| 2.80k| 1957, 1547| | 1548| 2.80k| 925, 1549| | 1550| 2.80k| 249, 1551| 2.80k| -1, 1552| | 1553| 2.80k| 3396, 1554| | 1555| 2.80k| 2606, 1556| | 1557| 2.80k| 3171, 1558| | 1559| 2.80k| 592, 1560| | 1561| 2.80k| 2930, 1562| | 1563| 2.80k| 3041, 1564| | 1565| 2.80k| 3489, 1566| | 1567| 2.80k| 1954, 1568| | 1569| 2.80k| 919, 1570| | 1571| 2.80k| 246, 1572| 2.80k| -1, 1573| | 1574| 2.80k| 2924, 1575| | 1576| 2.80k| 2600, 1577| | 1578| 2.80k| 3168, 1579| | 1580| 2.80k| 3465, 1581| | 1582| 2.80k| 1942, 1583| | 1584| 2.80k| 1933, 1585| | 1586| 2.80k| 237, 1587| | 1588| 2.80k| 228, 1589| | 1590| 2.80k| 3390, 1591| | 1592| 2.80k| 3813, 1593| | 1594| 2.80k| 3159, 1595| | 1596| 2.80k| 3150, 1597| | 1598| 2.80k| 2333, 1599| | 1600| 2.80k| 1348, 1601| | 1602| 2.80k| 1339, 1603| | 1604| 2.80k| 1930, 1605| | 1606| 2.80k| 1927, 1607| | 1608| 2.80k| 225, 1609| | 1610| 2.80k| 222, 1611| | 1612| 2.80k| 568, 1613| | 1614| 2.80k| 559, 1615| | 1616| 2.80k| 3147, 1617| | 1618| 2.80k| 3144, 1619| | 1620| 2.80k| 2327, 1621| | 1622| 2.80k| 1336, 1623| | 1624| 2.80k| 1333, 1625| | 1626| 2.80k| 3582, 1627| 2.80k| -1, 1628| | 1629| 2.80k| 3594, 1630| | 1631| 2.80k| 453, 1632| | 1633| 2.80k| 556, 1634| | 1635| 2.80k| 553, 1636| | 1637| 2.80k| 2309, 1638| | 1639| 2.80k| 77, 1640| | 1641| 2.80k| 3657, 1642| | 1643| 2.80k| 2228, 1644| | 1645| 2.80k| 1264, 1646| | 1647| 2.80k| 490, 1648| 2.80k| -1, 1649| | 1650| 2.80k| 141, 1651| 2.80k| -1, -1, 1652| | 1653| 2.80k| 2303, 1654| | 1655| 2.80k| 2297, 1656| | 1657| 2.80k| 836, 1658| | 1659| 2.80k| 3645, 1660| | 1661| 2.80k| 2222, 1662| | 1663| 2.80k| 1258, 1664| | 1665| 2.80k| 3576, 1666| | 1667| 2.80k| 3570, 1668| | 1669| 2.80k| 129, 1670| | 1671| 2.80k| 450, 1672| | 1673| 2.80k| 447, 1674| | 1675| 2.80k| 1786, 1676| | 1677| 2.80k| 435, 1678| | 1679| 2.80k| 1798, 1680| | 1681| 2.80k| 2444, 1682| | 1683| 2.80k| 3477, 1684| | 1685| 2.80k| 1948, 1686| | 1687| 2.80k| 905, 1688| | 1689| 2.80k| 4293, 1690| | 1691| 2.80k| 1861, 1692| | 1693| 2.80k| 4032, 1694| | 1695| 2.80k| 2588, 1696| | 1697| 2.80k| 2162, 1698| | 1699| 2.80k| 2153, 1700| | 1701| 2.80k| 424, 1702| | 1703| 2.80k| 2477, 1704| | 1705| 2.80k| 4287, 1706| | 1707| 2.80k| 2861, 1708| | 1709| 2.80k| 2852, 1710| | 1711| 2.80k| 3342, 1712| | 1713| 2.80k| 1849, 1714| | 1715| 2.80k| 574, 1716| 2.80k| -1, 1717| | 1718| 2.80k| 1780, 1719| | 1720| 2.80k| 1774, 1721| | 1722| 2.80k| 2150, 1723| | 1724| 2.80k| 1750, 1725| | 1726| 2.80k| 2438, 1727| | 1728| 2.80k| 1041, 1729| 2.80k| -1, 1730| | 1731| 2.80k| 2849, 1732| | 1733| 2.80k| 3339, 1734| | 1735| 2.80k| 2717, 1736| | 1737| 2.80k| 2315, 1738| 2.80k| -1, 1739| | 1740| 2.80k| 2147, 1741| | 1742| 2.80k| 1183, 1743| | 1744| 2.80k| 417, 1745| | 1746| 2.80k| 1729, 1747| | 1748| 2.80k| 1711, 1749| | 1750| 2.80k| 2846, 1751| | 1752| 2.80k| 3336, 1753| | 1754| 2.80k| 634, 1755| 2.80k| -1, -1, 1756| | 1757| 2.80k| 2126, 1758| | 1759| 2.80k| 1162, 1760| | 1761| 2.80k| 3029, 1762| | 1763| 2.80k| 3026, 1764| | 1765| 2.80k| 4245, 1766| | 1767| 2.80k| 2825, 1768| | 1769| 2.80k| 1705, 1770| | 1771| 2.80k| 3753, 1772| | 1773| 2.80k| 4212, 1774| 2.80k| -1, -1, -1, -1, 1775| | 1776| 2.80k| 3023, 1777| | 1778| 2.80k| 3017, 1779| | 1780| 2.80k| 2483, 1781| | 1782| 2.80k| 1699, 1783| 2.80k| -1, -1, 1784| | 1785| 2.80k| 3867, 1786| 2.80k| -1, 1787| | 1788| 2.80k| 3879, 1789| | 1790| 2.80k| 2489, 1791| | 1792| 2.80k| 2120, 1793| | 1794| 2.80k| 1156, 1795| | 1796| 2.80k| 399, 1797| | 1798| 2.80k| 1657, 1799| | 1800| 2.80k| 2435, 1801| | 1802| 2.80k| 2819, 1803| | 1804| 2.80k| 1504, 1805| | 1806| 2.80k| 3741, 1807| | 1808| 2.80k| 1516, 1809| 2.80k| -1, -1, 1810| | 1811| 2.80k| 2144, 1812| | 1813| 2.80k| 1180, 1814| | 1815| 2.80k| 414, 1816| | 1817| 2.80k| 1579, 1818| | 1819| 2.80k| 3930, 1820| | 1821| 2.80k| 2843, 1822| | 1823| 2.80k| 3333, 1824| | 1825| 2.80k| 3861, 1826| | 1827| 2.80k| 3855, 1828| 2.80k| -1, 1829| | 1830| 2.80k| 3831, 1831| | 1832| 2.80k| 2087, 1833| | 1834| 2.80k| 1108, 1835| 2.80k| -1, 1836| | 1837| 2.80k| 1567, 1838| | 1839| 2.80k| 1645, 1840| | 1841| 2.80k| 2771, 1842| | 1843| 2.80k| 1498, 1844| | 1845| 2.80k| 1492, 1846| 2.80k| -1, 1847| | 1848| 2.80k| 1468, 1849| 2.80k| -1, 1850| | 1851| 2.80k| 3810, 1852| | 1853| 2.80k| 3792, 1854| | 1855| 2.80k| 2066, 1856| | 1857| 2.80k| 1099, 1858| | 1859| 2.80k| 1693, 1860| | 1861| 2.80k| 2543, 1862| | 1863| 2.80k| 3120, 1864| | 1865| 2.80k| 2555, 1866| | 1867| 2.80k| 3264, 1868| 2.80k| -1, -1, 1869| | 1870| 2.80k| 1444, 1871| 2.80k| -1, 1872| | 1873| 2.80k| 3786, 1874| | 1875| 2.80k| 2141, 1876| | 1877| 2.80k| 1177, 1878| | 1879| 2.80k| 4086, 1880| | 1881| 2.80k| 2135, 1882| | 1883| 2.80k| 1171, 1884| | 1885| 2.80k| 2840, 1886| | 1887| 2.80k| 3330, 1888| | 1889| 2.80k| 3777, 1890| | 1891| 2.80k| 2834, 1892| | 1893| 2.80k| 3324, 1894| | 1895| 2.80k| 3768, 1896| | 1897| 2.80k| 4191, 1898| 2.80k| -1, 1899| | 1900| 2.80k| 2537, 1901| | 1902| 2.80k| 2531, 1903| 2.80k| -1, 1904| | 1905| 2.80k| 2507, 1906| | 1907| 2.80k| 3522, 1908| 2.80k| -1, 1909| | 1910| 2.80k| 953, 1911| | 1912| 2.80k| 261, 1913| | 1914| 2.80k| 832, 1915| | 1916| 2.80k| 812, 1917| | 1918| 2.80k| 2633, 1919| | 1920| 2.80k| 4080, 1921| | 1922| 2.80k| 4074, 1923| | 1924| 2.80k| 1687, 1925| | 1926| 2.80k| 4050, 1927| 2.80k| -1, 1928| | 1929| 2.80k| 1675, 1930| | 1931| 2.80k| 2132, 1932| | 1933| 2.80k| 1168, 1934| 2.80k| -1, 1935| | 1936| 2.80k| 586, 1937| | 1938| 2.80k| 808, 1939| | 1940| 2.80k| 2831, 1941| | 1942| 2.80k| 3321, 1943| | 1944| 2.80k| 3762, 1945| | 1946| 2.80k| 1870, 1947| | 1948| 2.80k| 4029, 1949| | 1950| 2.80k| 4011, 1951| | 1952| 2.80k| 2108, 1953| | 1954| 2.80k| 1144, 1955| | 1956| 2.80k| 393, 1957| | 1958| 2.80k| 801, 1959| | 1960| 2.80k| 2336, 1961| | 1962| 2.80k| 2807, 1963| | 1964| 2.80k| 3312, 1965| | 1966| 2.80k| 3717, 1967| 2.80k| -1, -1, 1968| | 1969| 2.80k| 4290, 1970| | 1971| 2.80k| 4005, 1972| 2.80k| -1, 1973| | 1974| 2.80k| 751, 1975| 2.80k| -1, 1976| | 1977| 2.80k| 1669, 1978| | 1979| 2.80k| 2102, 1980| | 1981| 2.80k| 1138, 1982| | 1983| 2.80k| 387, 1984| 2.80k| -1, 1985| | 1986| 2.80k| 3981, 1987| | 1988| 2.80k| 2801, 1989| | 1990| 2.80k| 3306, 1991| | 1992| 2.80k| 3708, 1993| | 1994| 2.80k| 31, 1995| | 1996| 2.80k| 2744, 1997| | 1998| 2.80k| 1621, 1999| | 2000| 2.80k| 49, 2001| | 2002| 2.80k| 2075, 2003| | 2004| 2.80k| 1387, 2005| | 2006| 2.80k| 360, 2007| 2.80k| -1, 2008| | 2009| 2.80k| 1405, 2010| | 2011| 2.80k| 2759, 2012| | 2013| 2.80k| 3273, 2014| | 2015| 2.80k| 667, 2016| | 2017| 2.80k| 742, 2018| | 2019| 2.80k| 1462, 2020| | 2021| 2.80k| 676, 2022| | 2023| 2.80k| 62, 2024| | 2025| 2.80k| 2750, 2026| | 2027| 2.80k| 4278, 2028| | 2029| 2.80k| 1609, 2030| | 2031| 2.80k| 4134, 2032| | 2033| 2.80k| 1417, 2034| | 2035| 2.80k| 3108, 2036| | 2037| 2.80k| 4152, 2038| | 2039| 2.80k| 795, 2040| | 2041| 2.80k| 2069, 2042| | 2043| 2.80k| 1102, 2044| | 2045| 2.80k| 2396, 2046| | 2047| 2.80k| 3618, 2048| 2.80k| -1, 2049| | 2050| 2.80k| 2753, 2051| | 2052| 2.80k| 3267, 2053| 2.80k| -1, 2054| | 2055| 2.80k| 102, 2056| | 2057| 2.80k| 1450, 2058| | 2059| 2.80k| 4164, 2060| 2.80k| -1, 2061| | 2062| 2.80k| 4257, 2063| | 2064| 2.80k| 444, 2065| | 2066| 2.80k| 2408, 2067| 2.80k| -1, -1, 2068| | 2069| 2.80k| 3102, 2070| 2.80k| -1, 2071| | 2072| 2.80k| 2011, 2073| | 2074| 2.80k| 1038, 2075| | 2076| 2.80k| 300, 2077| | 2078| 2.80k| 3636, 2079| | 2080| 2.80k| 4251, 2081| | 2082| 2.80k| 2714, 2083| | 2084| 2.80k| 3225, 2085| | 2086| 2.80k| 441, 2087| | 2088| 2.80k| 120, 2089| | 2090| 2.80k| 2906, 2091| 2.80k| -1, 2092| | 2093| 2.80k| 1822, 2094| | 2095| 2.80k| 4227, 2096| | 2097| 2.80k| 4209, 2098| 2.80k| -1, 2099| | 2100| 2.80k| 631, 2101| | 2102| 2.80k| 788, 2103| | 2104| 2.80k| 3072, 2105| | 2106| 2.80k| 1768, 2107| | 2108| 2.80k| 771, 2109| | 2110| 2.80k| 3519, 2111| | 2112| 2.80k| 1969, 2113| | 2114| 2.80k| 950, 2115| | 2116| 2.80k| 4203, 2117| | 2118| 2.80k| 4197, 2119| | 2120| 2.80k| 438, 2121| | 2122| 2.80k| 2630, 2123| | 2124| 2.80k| 3183, 2125| 2.80k| -1, 2126| | 2127| 2.80k| 3942, 2128| | 2129| 2.80k| 1840, 2130| | 2131| 2.80k| 1762, 2132| | 2133| 2.80k| 3471, 2134| | 2135| 2.80k| 1945, 2136| | 2137| 2.80k| 3999, 2138| | 2139| 2.80k| 240, 2140| | 2141| 2.80k| 583, 2142| | 2143| 2.80k| 3459, 2144| | 2145| 2.80k| 1939, 2146| | 2147| 2.80k| 3162, 2148| | 2149| 2.80k| 234, 2150| | 2151| 2.80k| 3954, 2152| | 2153| 2.80k| 1351, 2154| 2.80k| -1, 2155| | 2156| 2.80k| 3156, 2157| | 2158| 2.80k| 3630, 2159| | 2160| 2.80k| 764, 2161| | 2162| 2.80k| 1345, 2163| | 2164| 2.80k| 571, 2165| | 2166| 2.80k| 1756, 2167| | 2168| 2.80k| 114, 2169| | 2170| 2.80k| 2903, 2171| 2.80k| -1, 2172| | 2173| 2.80k| 565, 2174| | 2175| 2.80k| 3987, 2176| | 2177| 2.80k| 3675, 2178| | 2179| 2.80k| 2237, 2180| | 2181| 2.80k| 1273, 2182| | 2183| 2.80k| 496, 2184| | 2185| 2.80k| 3369, 2186| | 2187| 2.80k| 156, 2188| 2.80k| -1, 2189| | 2190| 2.80k| 3669, 2191| | 2192| 2.80k| 2234, 2193| | 2194| 2.80k| 1270, 2195| | 2196| 2.80k| 493, 2197| | 2198| 2.80k| 4239, 2199| | 2200| 2.80k| 150, 2201| | 2202| 2.80k| 3606, 2203| 2.80k| -1, 2204| | 2205| 2.80k| 3600, 2206| | 2207| 2.80k| 1189, 2208| | 2209| 2.80k| 1834, 2210| | 2211| 2.80k| 89, 2212| | 2213| 2.80k| 3903, 2214| | 2215| 2.80k| 83, 2216| | 2217| 2.80k| 1204, 2218| | 2219| 2.80k| 432, 2220| 2.80k| -1, -1, -1, 2221| | 2222| 2.80k| 3849, 2223| | 2224| 2.80k| 2171, 2225| | 2226| 2.80k| 1207, 2227| | 2228| 2.80k| 1540, 2229| | 2230| 2.80k| 1201, 2231| | 2232| 2.80k| 428, 2233| | 2234| 2.80k| 2870, 2235| | 2236| 2.80k| 1192, 2237| | 2238| 2.80k| 420, 2239| 2.80k| -1, 2240| | 2241| 2.80k| 1486, 2242| 2.80k| -1, 2243| | 2244| 2.80k| 3921, 2245| | 2246| 2.80k| 3843, 2247| | 2248| 2.80k| 1810, 2249| | 2250| 2.80k| 1714, 2251| | 2252| 2.80k| 1804, 2253| | 2254| 2.80k| 1035, 2255| | 2256| 2.80k| 3771, 2257| | 2258| 2.80k| 1195, 2259| | 2260| 2.80k| 1744, 2261| | 2262| 2.80k| 2711, 2263| | 2264| 2.80k| 1558, 2265| | 2266| 2.80k| 1480, 2267| | 2268| 2.80k| 3345, 2269| 2.80k| -1, 2270| | 2271| 2.80k| 1029, 2272| | 2273| 2.80k| 1747, 2274| 2.80k| -1, 2275| | 2276| 2.80k| 1738, 2277| | 2278| 2.80k| 2705, 2279| | 2280| 2.80k| 3837, 2281| | 2282| 2.80k| 1720, 2283| | 2284| 2.80k| 2165, 2285| | 2286| 2.80k| 2159, 2287| | 2288| 2.80k| 2579, 2289| 2.80k| -1, 2290| | 2291| 2.80k| 1678, 2292| | 2293| 2.80k| 2864, 2294| | 2295| 2.80k| 2858, 2296| | 2297| 2.80k| 1186, 2298| | 2299| 2.80k| 1474, 2300| | 2301| 2.80k| 2525, 2302| | 2303| 2.80k| 2156, 2304| | 2305| 2.80k| 1726, 2306| | 2307| 2.80k| 2129, 2308| | 2309| 2.80k| 1165, 2310| | 2311| 2.80k| 3447, 2312| | 2313| 2.80k| 2855, 2314| 2.80k| -1, 2315| | 2316| 2.80k| 2828, 2317| | 2318| 2.80k| 1867, 2319| | 2320| 2.80k| 3756, 2321| | 2322| 2.80k| 4068, 2323| | 2324| 2.80k| 3915, 2325| | 2326| 2.80k| 2519, 2327| | 2328| 2.80k| 3441, 2329| | 2330| 2.80k| 68, 2331| | 2332| 2.80k| 408, 2333| | 2334| 2.80k| 1735, 2335| | 2336| 2.80k| 1723, 2337| | 2338| 2.80k| 2501, 2339| | 2340| 2.80k| 1423, 2341| | 2342| 2.80k| 3765, 2343| | 2344| 2.80k| 1552, 2345| | 2346| 2.80k| 1708, 2347| | 2348| 2.80k| 4062, 2349| | 2350| 2.80k| 2123, 2351| | 2352| 2.80k| 1159, 2353| | 2354| 2.80k| 1717, 2355| | 2356| 2.80k| 405, 2357| | 2358| 2.80k| 1663, 2359| | 2360| 2.80k| 2822, 2361| | 2362| 2.80k| 2513, 2363| | 2364| 2.80k| 3747, 2365| | 2366| 2.80k| 3759, 2367| | 2368| 2.80k| 4170, 2369| | 2370| 2.80k| 3891, 2371| | 2372| 2.80k| 3795, 2373| | 2374| 2.80k| 3885, 2375| | 2376| 2.80k| 2414, 2377| | 2378| 2.80k| 1591, 2379| | 2380| 2.80k| 1672, 2381| | 2382| 2.80k| 3825, 2383| | 2384| 2.80k| 4056, 2385| 2.80k| -1, -1, 2386| | 2387| 2.80k| 1528, 2388| 2.80k| -1, 2389| | 2390| 2.80k| 1522, 2391| | 2392| 2.80k| 3828, 2393| 2.80k| -1, 2394| | 2395| 2.80k| 3819, 2396| | 2397| 2.80k| 1651, 2398| | 2399| 2.80k| 1666, 2400| | 2401| 2.80k| 3801, 2402| 2.80k| -1, 2403| | 2404| 2.80k| 56, 2405| 2.80k| -1, 2406| | 2407| 2.80k| 899, 2408| | 2409| 2.80k| 2096, 2410| | 2411| 2.80k| 1117, 2412| | 2413| 2.80k| 1411, 2414| | 2415| 2.80k| 2114, 2416| | 2417| 2.80k| 1150, 2418| | 2419| 2.80k| 2780, 2420| | 2421| 2.80k| 3285, 2422| | 2423| 2.80k| 3807, 2424| | 2425| 2.80k| 2813, 2426| | 2427| 2.80k| 3318, 2428| | 2429| 2.80k| 3729, 2430| | 2431| 2.80k| 1023, 2432| | 2433| 2.80k| 4284, 2434| | 2435| 2.80k| 816, 2436| 2.80k| -1, 2437| | 2438| 2.80k| 2699, 2439| | 2440| 2.80k| 4158, 2441| | 2442| 2.80k| 3129, 2443| | 2444| 2.80k| 848, 2445| | 2446| 2.80k| 2567, 2447| | 2448| 2.80k| 2402, 2449| | 2450| 2.80k| 2561, 2451| | 2452| 2.80k| 3816, 2453| | 2454| 2.80k| 3804, 2455| 2.80k| -1, 2456| | 2457| 2.80k| 622, 2458| | 2459| 2.80k| 3960, 2460| | 2461| 2.80k| 842, 2462| | 2463| 2.80k| 3789, 2464| | 2465| 2.80k| 1633, 2466| | 2467| 2.80k| 822, 2468| | 2469| 2.80k| 4014, 2470| | 2471| 2.80k| 3798, 2472| | 2473| 2.80k| 2111, 2474| | 2475| 2.80k| 1147, 2476| | 2477| 2.80k| 774, 2478| | 2479| 2.80k| 4044, 2480| | 2481| 2.80k| 2462, 2482| | 2483| 2.80k| 2810, 2484| | 2485| 2.80k| 3315, 2486| | 2487| 2.80k| 3723, 2488| | 2489| 2.80k| 3435, 2490| | 2491| 2.80k| 829, 2492| | 2493| 2.80k| 4047, 2494| 2.80k| -1, 2495| | 2496| 2.80k| 4038, 2497| | 2498| 2.80k| 1129, 2499| | 2500| 2.80k| 381, 2501| | 2502| 2.80k| 4020, 2503| | 2504| 2.80k| 2474, 2505| | 2506| 2.80k| 2792, 2507| | 2508| 2.80k| 3297, 2509| | 2510| 2.80k| 3690, 2511| | 2512| 2.80k| 3744, 2513| 2.80k| -1, -1, -1, 2514| | 2515| 2.80k| 839, 2516| | 2517| 2.80k| 826, 2518| | 2519| 2.80k| 1627, 2520| | 2521| 2.80k| 4026, 2522| 2.80k| -1, 2523| | 2524| 2.80k| 3141, 2525| | 2526| 2.80k| 43, 2527| 2.80k| -1, -1, 2528| | 2529| 2.80k| 3948, 2530| | 2531| 2.80k| 819, 2532| | 2533| 2.80k| 1399, 2534| | 2535| 2.80k| 758, 2536| 2.80k| -1, -1, 2537| | 2538| 2.80k| 1648, 2539| | 2540| 2.80k| 1126, 2541| | 2542| 2.80k| 375, 2543| | 2544| 2.80k| 4035, 2545| | 2546| 2.80k| 4023, 2547| | 2548| 2.80k| 2789, 2549| | 2550| 2.80k| 3294, 2551| | 2552| 2.80k| 3684, 2553| | 2554| 2.80k| 768, 2555| | 2556| 2.80k| 4008, 2557| | 2558| 2.80k| 4146, 2559| | 2560| 2.80k| 15, 2561| | 2562| 2.80k| 2735, 2563| | 2564| 2.80k| 4017, 2565| | 2566| 2.80k| 2390, 2567| 2.80k| -1, 2568| | 2569| 2.80k| 1369, 2570| | 2571| 2.80k| 3138, 2572| 2.80k| -1, 2573| | 2574| 2.80k| 748, 2575| | 2576| 2.80k| 761, 2577| 2.80k| -1, 2578| | 2579| 2.80k| 652, 2580| | 2581| 2.80k| 2017, 2582| | 2583| 2.80k| 1050, 2584| | 2585| 2.80k| 306, 2586| 2.80k| -1, -1, 2587| | 2588| 2.80k| 2726, 2589| | 2590| 2.80k| 3231, 2591| | 2592| 2.80k| 4116, 2593| | 2594| 2.80k| 2014, 2595| | 2596| 2.80k| 1044, 2597| | 2598| 2.80k| 303, 2599| | 2600| 2.80k| 2384, 2601| 2.80k| -1, 2602| | 2603| 2.80k| 2720, 2604| | 2605| 2.80k| 3228, 2606| 2.80k| -1, 2607| | 2608| 2.80k| 3534, 2609| | 2610| 2.80k| 3078, 2611| | 2612| 2.80k| 968, 2613| | 2614| 2.80k| 267, 2615| | 2616| 2.80k| 2294, 2617| | 2618| 2.80k| 3504, 2619| | 2620| 2.80k| 2645, 2621| | 2622| 2.80k| 934, 2623| | 2624| 2.80k| 252, 2625| | 2626| 2.80k| 3075, 2627| 2.80k| -1, 2628| | 2629| 2.80k| 2615, 2630| | 2631| 2.80k| 4281, 2632| | 2633| 2.80k| 3513, 2634| | 2635| 2.80k| 1966, 2636| | 2637| 2.80k| 943, 2638| | 2639| 2.80k| 3507, 2640| | 2641| 2.80k| 1963, 2642| | 2643| 2.80k| 937, 2644| | 2645| 2.80k| 2624, 2646| | 2647| 2.80k| 3180, 2648| | 2649| 2.80k| 3936, 2650| | 2651| 2.80k| 2618, 2652| | 2653| 2.80k| 3177, 2654| | 2655| 2.80k| 4233, 2656| | 2657| 2.80k| 3642, 2658| 2.80k| -1, -1, 2659| | 2660| 2.80k| 2348, 2661| | 2662| 2.80k| 4221, 2663| | 2664| 2.80k| 126, 2665| | 2666| 2.80k| 3510, 2667| | 2668| 2.80k| 3381, 2669| | 2670| 2.80k| 940, 2671| | 2672| 2.80k| 255, 2673| 2.80k| -1, -1, 2674| | 2675| 2.80k| 2621, 2676| | 2677| 2.80k| 3501, 2678| | 2679| 2.80k| 1960, 2680| | 2681| 2.80k| 931, 2682| | 2683| 2.80k| 1903, 2684| 2.80k| -1, 2685| | 2686| 2.80k| 198, 2687| | 2688| 2.80k| 2612, 2689| | 2690| 2.80k| 3174, 2691| | 2692| 2.80k| 1900, 2693| | 2694| 2.80k| 580, 2695| | 2696| 2.80k| 195, 2697| | 2698| 2.80k| 3624, 2699| | 2700| 2.80k| 1309, 2701| | 2702| 2.80k| 1885, 2703| | 2704| 2.80k| 1846, 2705| | 2706| 2.80k| 180, 2707| | 2708| 2.80k| 108, 2709| | 2710| 2.80k| 1306, 2711| | 2712| 2.80k| 532, 2713| 2.80k| -1, -1, 2714| | 2715| 2.80k| 745, 2716| | 2717| 2.80k| 1291, 2718| | 2719| 2.80k| 529, 2720| | 2721| 2.80k| 1882, 2722| | 2723| 2.80k| 351, 2724| | 2725| 2.80k| 177, 2726| | 2727| 2.80k| 1879, 2728| | 2729| 2.80k| 514, 2730| | 2731| 2.80k| 174, 2732| | 2733| 2.80k| 2279, 2734| 2.80k| -1, 2735| | 2736| 2.80k| 1441, 2737| | 2738| 2.80k| 1288, 2739| | 2740| 2.80k| 3014, 2741| | 2742| 2.80k| 2273, 2743| | 2744| 2.80k| 1285, 2745| 2.80k| -1, 2746| | 2747| 2.80k| 1828, 2748| | 2749| 2.80k| 511, 2750| | 2751| 2.80k| 2267, 2752| 2.80k| -1, 2753| | 2754| 2.80k| 508, 2755| | 2756| 2.80k| 2243, 2757| | 2758| 2.80k| 1279, 2759| | 2760| 2.80k| 502, 2761| | 2762| 2.80k| 4188, 2763| | 2764| 2.80k| 168, 2765| | 2766| 2.80k| 2240, 2767| | 2768| 2.80k| 1276, 2769| | 2770| 2.80k| 499, 2771| | 2772| 2.80k| 2261, 2773| | 2774| 2.80k| 162, 2775| | 2776| 2.80k| 1123, 2777| | 2778| 2.80k| 2255, 2779| | 2780| 2.80k| 2093, 2781| | 2782| 2.80k| 1114, 2783| | 2784| 2.80k| 2786, 2785| | 2786| 2.80k| 3291, 2787| | 2788| 2.80k| 3678, 2789| | 2790| 2.80k| 2777, 2791| | 2792| 2.80k| 3282, 2793| 2.80k| -1, 2794| | 2795| 2.80k| 2084, 2796| | 2797| 2.80k| 1105, 2798| 2.80k| -1, 2799| | 2800| 2.80k| 2480, 2801| 2.80k| -1, 2802| | 2803| 2.80k| 2768, 2804| | 2805| 2.80k| 3135, 2806| | 2807| 2.80k| 24, 2808| | 2809| 2.80k| 2741, 2810| | 2811| 2.80k| 3126, 2812| | 2813| 2.80k| 3738, 2814| 2.80k| -1, 2815| | 2816| 2.80k| 1381, 2817| 2.80k| -1, 2818| | 2819| 2.80k| 3927, 2820| | 2821| 2.80k| 706, 2822| 2.80k| -1, 2823| | 2824| 2.80k| 3117, 2825| | 2826| 2.80k| 661, 2827| | 2828| 2.80k| 1702, 2829| | 2830| 2.80k| 21, 2831| | 2832| 2.80k| 2738, 2833| 2.80k| -1, -1, 2834| | 2835| 2.80k| 1564, 2836| | 2837| 2.80k| 1375, 2838| | 2839| 2.80k| 4128, 2840| 2.80k| -1, -1, 2841| | 2842| 2.80k| 1642, 2843| | 2844| 2.80k| 3492, 2845| | 2846| 2.80k| 655, 2847| | 2848| 2.80k| 922, 2849| | 2850| 2.80k| 3978, 2851| 2.80k| -1, 2852| | 2853| 2.80k| 2969, 2854| | 2855| 2.80k| 2603, 2856| | 2857| 2.80k| 2081, 2858| | 2859| 2.80k| 3909, 2860| | 2861| 2.80k| 4122, 2862| | 2863| 2.80k| 2963, 2864| 2.80k| -1, 2865| | 2866| 2.80k| 2765, 2867| | 2868| 2.80k| 2468, 2869| | 2870| 2.80k| 3540, 2871| | 2872| 2.80k| 2933, 2873| | 2874| 2.80k| 974, 2875| | 2876| 2.80k| 270, 2877| | 2878| 2.80k| 1546, 2879| | 2880| 2.80k| 3486, 2881| | 2882| 2.80k| 2651, 2883| | 2884| 2.80k| 915, 2885| | 2886| 2.80k| 700, 2887| 2.80k| -1, 2888| | 2889| 2.80k| 3114, 2890| | 2891| 2.80k| 2597, 2892| | 2893| 2.80k| 2927, 2894| | 2895| 2.80k| 354, 2896| | 2897| 2.80k| 2330, 2898| | 2899| 2.80k| 2921, 2900| | 2901| 2.80k| 3480, 2902| | 2903| 2.80k| 3474, 2904| | 2905| 2.80k| 908, 2906| | 2907| 2.80k| 902, 2908| | 2909| 2.80k| 1447, 2910| 2.80k| -1, 2911| | 2912| 2.80k| 2591, 2913| | 2914| 2.80k| 2585, 2915| 2.80k| -1, -1, 2916| | 2917| 2.80k| 685, 2918| | 2919| 2.80k| 1921, 2920| | 2921| 2.80k| 1918, 2922| | 2923| 2.80k| 216, 2924| | 2925| 2.80k| 213, 2926| 2.80k| -1, 2927| | 2928| 2.80k| 3387, 2929| | 2930| 2.80k| 2324, 2931| 2.80k| -1, 2932| | 2933| 2.80k| 1603, 2934| | 2935| 2.80k| 1327, 2936| | 2937| 2.80k| 1324, 2938| | 2939| 2.80k| 3783, 2940| | 2941| 2.80k| 1909, 2942| | 2943| 2.80k| 1597, 2944| | 2945| 2.80k| 204, 2946| | 2947| 2.80k| 550, 2948| | 2949| 2.80k| 547, 2950| | 2951| 2.80k| 2318, 2952| | 2953| 2.80k| 2312, 2954| 2.80k| -1, 2955| | 2956| 2.80k| 1897, 2957| | 2958| 2.80k| 1315, 2959| | 2960| 2.80k| 192, 2961| 2.80k| -1, 2962| | 2963| 2.80k| 1891, 2964| | 2965| 2.80k| 3, 2966| | 2967| 2.80k| 186, 2968| | 2969| 2.80k| 538, 2970| | 2971| 2.80k| 1017, 2972| | 2973| 2.80k| 1303, 2974| | 2975| 2.80k| 1357, 2976| 2.80k| -1, 2977| | 2978| 2.80k| 2693, 2979| | 2980| 2.80k| 1297, 2981| 2.80k| -1, 2982| | 2983| 2.80k| 526, 2984| | 2985| 2.80k| 1011, 2986| | 2987| 2.80k| 1005, 2988| | 2989| 2.80k| 2456, 2990| | 2991| 2.80k| 520, 2992| | 2993| 2.80k| 2687, 2994| | 2995| 2.80k| 2681, 2996| | 2997| 2.80k| 619, 2998| | 2999| 2.80k| 3552, 3000| | 3001| 2.80k| 4104, 3002| | 3003| 2.80k| 986, 3004| | 3005| 2.80k| 804, 3006| 2.80k| -1, 3007| | 3008| 2.80k| 2372, 3009| | 3010| 2.80k| 2663, 3011| | 3012| 2.80k| 613, 3013| | 3014| 2.80k| 607, 3015| 2.80k| -1, 3016| | 3017| 2.80k| 3498, 3018| 2.80k| -1, 3019| | 3020| 2.80k| 928, 3021| | 3022| 2.80k| 739, 3023| | 3024| 2.80k| 3984, 3025| | 3026| 2.80k| 3429, 3027| | 3028| 2.80k| 2609, 3029| 2.80k| -1, -1, -1, -1, 3030| | 3031| 2.80k| 4002, 3032| 2.80k| -1, 3033| | 3034| 2.80k| 3423, 3035| | 3036| 2.80k| 3417, 3037| 2.80k| -1, -1, -1, -1, -1, -1, 3038| 2.80k| -1, 3039| | 3040| 2.80k| 3399, 3041| 2.80k| -1, -1, -1, -1, -1, -1, 3042| 2.80k| -1, -1, -1, -1, -1, -1, 3043| | 3044| 2.80k| 4194, 3045| 2.80k| -1, -1, -1, -1, -1, -1, 3046| | 3047| 2.80k| 3005, 3048| | 3049| 2.80k| 2999, 3050| 2.80k| -1, -1, -1, -1, -1, -1, 3051| 2.80k| -1, -1, -1, -1, 3052| | 3053| 2.80k| 2981, 3054| 2.80k| -1, -1, -1, -1, -1, -1, 3055| 2.80k| -1, 3056| | 3057| 2.80k| 2957, 3058| 2.80k| -1, 3059| | 3060| 2.80k| 4266, 3061| 2.80k| -1, 3062| | 3063| 2.80k| 2945, 3064| 2.80k| -1, -1, -1, -1, -1, 3065| | 3066| 2.80k| 4275, 3067| 2.80k| -1, -1, 3068| | 3069| 2.80k| 4269, 3070| 2.80k| -1, -1, -1, -1, -1, -1, 3071| 2.80k| -1, -1, -1, -1, -1, -1, 3072| 2.80k| -1, -1, 3073| | 3074| 2.80k| 4272, 3075| 2.80k| -1, -1, -1, -1, -1, -1, 3076| | 3077| 2.80k| 4263, 3078| | 3079| 2.80k| 2498, 3080| 2.80k| -1, -1, -1, -1, -1, -1, 3081| 2.80k| -1, -1, -1, -1, -1, -1, 3082| 2.80k| -1, -1, -1, -1, -1, -1, 3083| 2.80k| -1, -1, -1, -1, -1, -1, 3084| 2.80k| -1, -1, -1, -1, -1, -1, 3085| 2.80k| -1, -1, -1, -1, -1, -1, 3086| 2.80k| -1, -1, -1, -1, -1, -1, 3087| 2.80k| -1, -1, -1, -1, -1, -1, 3088| 2.80k| -1, -1, -1, -1, -1, -1, 3089| 2.80k| -1, -1, -1, -1, -1, -1, 3090| 2.80k| -1, -1, -1, -1, -1, -1, 3091| 2.80k| -1, -1, -1, -1, -1, -1, 3092| 2.80k| -1, -1, -1, -1, -1, -1, 3093| 2.80k| -1, -1, -1, -1, -1, -1, 3094| 2.80k| -1, -1, -1, -1, -1, -1, 3095| 2.80k| -1, 3096| | 3097| 2.80k| 4254, 3098| 2.80k| -1, -1, -1, -1, -1, -1, 3099| 2.80k| -1, -1, -1, -1, -1, -1, 3100| 2.80k| -1, -1, -1, -1, -1, -1, 3101| | 3102| 2.80k| 4248, 3103| 2.80k| -1, -1, -1, -1, -1, -1, 3104| 2.80k| -1, -1, -1, -1, 3105| | 3106| 2.80k| 4242, 3107| | 3108| 2.80k| 4236, 3109| 2.80k| -1, -1, -1, -1, -1, -1, 3110| 2.80k| -1, -1, -1, -1, -1, -1, 3111| 2.80k| -1, -1, -1, -1, -1, -1, 3112| 2.80k| -1, -1, -1, -1, -1, -1, 3113| 2.80k| -1, -1, -1, -1, -1, -1, 3114| 2.80k| -1, -1, -1, -1, -1, -1, 3115| 2.80k| -1, -1, -1, -1, -1, -1, 3116| 2.80k| -1, -1, -1, -1, -1, -1, 3117| 2.80k| -1, -1, -1, -1, -1, -1, 3118| 2.80k| -1, -1, -1, -1, -1, -1, 3119| 2.80k| -1, -1, 3120| | 3121| 2.80k| 4260 3122| 2.80k| }; 3123| | 3124| | 3125| 2.80k| { 3126| 2.80k| int key = hash(codes); 3127| | 3128| 2.80k| if (key <= MAX_HASH_VALUE) ------------------ | | 42| 2.80k|#define MAX_HASH_VALUE 1846 ------------------ | Branch (3128:11): [True: 2.80k, False: 0] ------------------ 3129| 2.80k| { 3130| 2.80k| int index = wordlist[key]; 3131| | 3132| 2.80k| if (index >= 0 && onig_codes_cmp(codes, OnigUnicodeFolds1 + index, 1) == 0) ------------------ | Branch (3132:15): [True: 2.80k, False: 0] | Branch (3132:29): [True: 2.69k, False: 112] ------------------ 3133| 2.69k| return index; 3134| 2.80k| } 3135| 2.80k| } 3136| 112| return -1; 3137| 2.80k|} unicode_fold1_key.c:hash: 55| 2.80k|{ 56| 2.80k| static const unsigned short asso_values[] = 57| 2.80k| { 58| 2.80k| 4, 2, 15, 124, 1, 9, 1398, 671, 1395, 664, 59| 2.80k| 1384, 84, 91, 75, 1529, 74, 99, 54, 1525, 26, 60| 2.80k| 1379, 552, 1374, 431, 144, 50, 1517, 24, 250, 557, 61| 2.80k| 0, 27, 1506, 262, 1505, 197, 131, 1310, 782, 350, 62| 2.80k| 781, 32, 771, 588, 5, 95, 1079, 463, 770, 455, 63| 2.80k| 1074, 1496, 824, 1495, 584, 1484, 762, 1465, 751, 1559, 64| 2.80k| 1372, 1339, 1350, 1365, 1347, 732, 1062, 951, 551, 701, 65| 2.80k| 543, 1334, 657, 1479, 743, 108, 724, 1549, 530, 7, 66| 2.80k| 522, 252, 503, 1541, 484, 1540, 425, 1532, 709, 1232, 67| 2.80k| 466, 1147, 666, 1138, 1041, 845, 1325, 36, 1317, 465, 68| 2.80k| 65, 1526, 301, 690, 45, 1301, 401, 1450, 381, 1437, 69| 2.80k| 25, 994, 636, 603, 591, 1281, 176, 997, 339, 1215, 70| 2.80k| 446, 1009, 571, 1175, 616, 473, 623, 386, 414, 1394, 71| 2.80k| 921, 1489, 1022, 612, 613, 173, 1002, 74, 308, 327, 72| 2.80k| 1471, 291, 1434, 202, 908, 1, 147, 1847, 1426, 226, 73| 2.80k| 1222, 73, 56, 1847, 1423, 48, 1294, 292, 1267, 14, 74| 2.80k| 275, 315, 205, 410, 990, 4, 17, 6, 974, 382, 75| 2.80k| 1255, 675, 1225, 26, 360, 1437, 886, 1268, 1189, 37, 76| 2.80k| 863, 267, 1167, 1190, 963, 1178, 936, 1133, 603, 137, 77| 2.80k| 933, 393, 897, 71, 853, 1427, 843, 1161, 831, 1111, 78| 2.80k| 1165, 1128, 1156, 1140, 830, 686, 1155, 1125, 507, 1116, 79| 2.80k| 1123, 818, 237, 1064, 576, 1046, 562, 1033, 196, 816, 80| 2.80k| 167, 815, 155, 793, 136, 131, 76, 795, 85, 1112, 81| 2.80k| 124, 1110, 116, 285, 232, 1026, 188, 1383, 371, 1087, 82| 2.80k| 350, 1045, 333, 1359, 812, 354, 270, 407, 801, 99, 83| 2.80k| 565, 555, 1104, 128, 1097, 31, 1419, 130, 1414 84| 2.80k| }; 85| 2.80k| return asso_values[(unsigned char)onig_codes_byte_at(codes, 2)+3] + asso_values[(unsigned char)onig_codes_byte_at(codes, 1)] + asso_values[(unsigned char)onig_codes_byte_at(codes, 0)]; 86| 2.80k|} onigenc_unicode_fold2_key: 90| 450|{ 91| 450| static const short int wordlist[] = 92| 450| { 93| | 94| 450| 101, 95| | 96| 450| 253, 97| | 98| 450| 76, 99| | 100| 450| 29, 101| | 102| 450| 24, 103| | 104| 450| 239, 105| | 106| 450| 96, 107| | 108| 450| 71, 109| | 110| 450| 92, 111| | 112| 450| 67, 113| | 114| 450| 4, 115| | 116| 450| 62, 117| | 118| 450| 8, 119| | 120| 450| 58, 121| | 122| 450| 234, 123| | 124| 450| 109, 125| | 126| 450| 164, 127| | 128| 450| 88, 129| | 130| 450| 84, 131| | 132| 450| 80, 133| | 134| 450| 214, 135| | 136| 450| 0, 137| | 138| 450| 54, 139| | 140| 450| 261, 141| | 142| 450| 50, 143| | 144| 450| 105, 145| | 146| 450| 121, 147| | 148| 450| 125, 149| | 150| 450| 257, 151| | 152| 450| 42, 153| | 154| 450| 38, 155| | 156| 450| 249, 157| | 158| 450| 46, 159| | 160| 450| 117, 161| | 162| 450| 12, 163| | 164| 450| 113, 165| | 166| 450| 244, 167| | 168| 450| 229, 169| | 170| 450| 224, 171| | 172| 450| 219, 173| | 174| 450| 209, 175| | 176| 450| 16, 177| | 178| 450| 204, 179| | 180| 450| 199, 181| | 182| 450| 194, 183| | 184| 450| 189, 185| | 186| 450| 184, 187| | 188| 450| 179, 189| | 190| 450| 174, 191| | 192| 450| 169, 193| | 194| 450| 20, 195| | 196| 450| 34, 197| | 198| 450| 159, 199| | 200| 450| 154, 201| | 202| 450| 149, 203| | 204| 450| 144, 205| | 206| 450| 139, 207| | 208| 450| 134, 209| | 210| 450| 129 211| 450| }; 212| | 213| | 214| 450| { 215| 450| int key = hash(codes); 216| | 217| 450| if (key <= MAX_HASH_VALUE) ------------------ | | 42| 450|#define MAX_HASH_VALUE 58 ------------------ | Branch (217:11): [True: 56, False: 394] ------------------ 218| 56| { 219| 56| int index = wordlist[key]; 220| | 221| 56| if (index >= 0 && onig_codes_cmp(codes, OnigUnicodeFolds2 + index, 2) == 0) ------------------ | Branch (221:15): [True: 56, False: 0] | Branch (221:29): [True: 0, False: 56] ------------------ 222| 0| return index; 223| 56| } 224| 450| } 225| 450| return -1; 226| 450|} unicode_fold2_key.c:hash: 55| 450|{ 56| 450| static const unsigned char asso_values[] = 57| 450| { 58| 450| 58, 57, 56, 55, 54, 53, 52, 16, 50, 59, 59| 450| 15, 59, 25, 59, 59, 59, 59, 59, 59, 3, 60| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 61| 450| 59, 59, 49, 48, 47, 46, 45, 44, 43, 42, 62| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 21, 63| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 64| 450| 59, 59, 59, 59, 59, 59, 2, 59, 59, 59, 65| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 66| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 67| 450| 59, 59, 59, 59, 59, 59, 40, 20, 39, 38, 68| 450| 37, 14, 5, 36, 20, 7, 25, 34, 29, 32, 69| 450| 16, 59, 31, 59, 59, 2, 1, 59, 25, 15, 70| 450| 59, 14, 59, 59, 28, 59, 2, 59, 59, 59, 71| 450| 11, 59, 59, 59, 59, 59, 59, 59, 59, 59, 72| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 73| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 74| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 75| 450| 59, 59, 24, 59, 22, 59, 59, 11, 59, 59, 76| 450| 59, 59, 59, 7, 59, 0, 59, 59, 16, 59, 77| 450| 1, 59, 59, 16, 59, 59, 59, 15, 59, 59, 78| 450| 59, 6, 59, 59, 59, 59, 0, 59, 59, 59, 79| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 80| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 81| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 82| 450| 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 83| 450| 59, 59, 59, 59, 59, 59 84| 450| }; 85| 450| return asso_values[(unsigned char)onig_codes_byte_at(codes, 5)] + asso_values[(unsigned char)onig_codes_byte_at(codes, 2)]; 86| 450|} onigenc_unicode_fold3_key: 90| 281|{ 91| 281| static const short int wordlist[] = 92| 281| { 93| | 94| 281| 62, 95| | 96| 281| 47, 97| | 98| 281| 31, 99| | 100| 281| 57, 101| | 102| 281| 41, 103| | 104| 281| 25, 105| | 106| 281| 52, 107| | 108| 281| 36, 109| | 110| 281| 20, 111| | 112| 281| 67, 113| | 114| 281| 15, 115| | 116| 281| 10, 117| | 118| 281| 5, 119| | 120| 281| 0 121| 281| }; 122| | 123| | 124| 281| { 125| 281| int key = hash(codes); 126| | 127| 281| if (key <= MAX_HASH_VALUE) ------------------ | | 42| 281|#define MAX_HASH_VALUE 13 ------------------ | Branch (127:11): [True: 0, False: 281] ------------------ 128| 0| { 129| 0| int index = wordlist[key]; 130| | 131| 0| if (index >= 0 && onig_codes_cmp(codes, OnigUnicodeFolds3 + index, 3) == 0) ------------------ | Branch (131:15): [True: 0, False: 0] | Branch (131:29): [True: 0, False: 0] ------------------ 132| 0| return index; 133| 0| } 134| 281| } 135| 281| return -1; 136| 281|} unicode_fold3_key.c:hash: 55| 281|{ 56| 281| static const unsigned char asso_values[] = 57| 281| { 58| 281| 6, 3, 14, 14, 14, 14, 14, 14, 1, 14, 59| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 60| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 61| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 62| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 63| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 64| 281| 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 65| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 66| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 67| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 68| 281| 14, 14, 4, 14, 14, 5, 14, 14, 4, 14, 69| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 70| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 71| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 72| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 73| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 74| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 75| 281| 14, 14, 14, 14, 14, 14, 14, 10, 14, 14, 76| 281| 14, 14, 14, 9, 14, 1, 14, 14, 14, 14, 77| 281| 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 78| 281| 14, 8, 14, 14, 14, 14, 14, 14, 14, 14, 79| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 80| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 81| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 82| 281| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 83| 281| 14, 14, 14, 14, 14, 14 84| 281| }; 85| 281| return asso_values[(unsigned char)onig_codes_byte_at(codes, 8)] + asso_values[(unsigned char)onig_codes_byte_at(codes, 5)] + asso_values[(unsigned char)onig_codes_byte_at(codes, 2)]; 86| 281|} onigenc_unicode_unfold_key: 94| 3.53k|{ 95| 3.53k| static const struct ByUnfoldKey wordlist[] = 96| 3.53k| { 97| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 98| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 99| | 100| 3.53k| {0x1040a, 3480, 1}, 101| | 102| 3.53k| {0x2c0a, 2615, 1}, 103| | 104| 3.53k| {0x040a, 1035, 1}, 105| | 106| 3.53k| {0x1e0a, 1891, 1}, 107| | 108| 3.53k| {0x1f0a, 2252, 1}, 109| | 110| 3.53k| {0x010a, 186, 1}, 111| | 112| 3.53k| {0x017d, 351, 1}, 113| | 114| 3.53k| {0xa77d, 1867, 1}, 115| | 116| 3.53k| {0xab7d, 1645, 1}, 117| | 118| 3.53k| {0x1f85, 154, 2}, 119| | 120| 3.53k| {0x1f89, 134, 2}, 121| | 122| 3.53k| {0x0189, 622, 1}, 123| | 124| 3.53k| {0xab85, 1669, 1}, 125| | 126| 3.53k| {0xab89, 1681, 1}, 127| | 128| 3.53k| {0x1c85, 960, 1}, 129| | 130| 3.53k| {0x1c89, 1864, 1}, 131| | 132| 3.53k| {0x2c84, 2759, 1}, 133| | 134| 3.53k| {0x1ffb, 2429, 1}, 135| | 136| 3.53k| {0x1e84, 2075, 1}, 137| | 138| 3.53k| {0x1f84, 149, 2}, 139| | 140| 3.53k| {0x0184, 360, 1}, 141| | 142| 3.53k| {0xa784, 3273, 1}, 143| | 144| 3.53k| {0xab84, 1666, 1}, 145| | 146| 3.53k| {0x1ff3, 96, 2}, 147| | 148| 3.53k| {0x1c84, 960, 1}, 149| | 150| 3.53k| {0x10c85, 3798, 1}, 151| | 152| 3.53k| {0x10c89, 3810, 1}, 153| | 154| 3.53k| {0x2ced, 2906, 1}, 155| | 156| 3.53k| {0x2c64, 682, 1}, 157| | 158| 3.53k| {0x0464, 1060, 1}, 159| | 160| 3.53k| {0x1e64, 2027, 1}, 161| | 162| 3.53k| {0xa684, 3108, 1}, 163| | 164| 3.53k| {0x0164, 315, 1}, 165| | 166| 3.53k| {0xa764, 3240, 1}, 167| | 168| 3.53k| {0x00dd, 162, 1}, 169| | 170| 3.53k| {0x10c84, 3795, 1}, 171| | 172| 3.53k| {0x2c90, 2777, 1}, 173| | 174| 3.53k| {0x0490, 1114, 1}, 175| | 176| 3.53k| {0x1e90, 2093, 1}, 177| | 178| 3.53k| {0x1f90, 169, 2}, 179| | 180| 3.53k| {0x0190, 631, 1}, 181| | 182| 3.53k| {0xa790, 3282, 1}, 183| | 184| 3.53k| {0xab90, 1702, 1}, 185| | 186| 3.53k| {0xa664, 3087, 1}, 187| | 188| 3.53k| {0x1c90, 1468, 1}, 189| | 190| 3.53k| {0x1fe9, 2447, 1}, 191| | 192| 3.53k| {0x1fd9, 2441, 1}, 193| | 194| 3.53k| {0x01d9, 450, 1}, 195| | 196| 3.53k| {0x1ff7, 67, 3}, 197| | 198| 3.53k| {0x01f7, 417, 1}, 199| | 200| 3.53k| {0x00d9, 150, 1}, 201| | 202| 3.53k| {0xa690, 3126, 1}, 203| | 204| 3.53k| {0xa7f5, 3366, 1}, 205| | 206| 3.53k| {0x020a, 520, 1}, 207| | 208| 3.53k| {0x1fe7, 47, 3}, 209| | 210| 3.53k| {0x10c90, 3831, 1}, 211| | 212| 3.53k| {0x104b2, 3576, 1}, 213| | 214| 3.53k| {0x2cb2, 2828, 1}, 215| | 216| 3.53k| {0x04b2, 1165, 1}, 217| | 218| 3.53k| {0x1eb2, 2129, 1}, 219| | 220| 3.53k| {0x1fb2, 249, 2}, 221| | 222| 3.53k| {0x01b2, 706, 1}, 223| | 224| 3.53k| {0xa7b2, 715, 1}, 225| | 226| 3.53k| {0xabb2, 1804, 1}, 227| | 228| 3.53k| {0x2c67, 2738, 1}, 229| | 230| 3.53k| {0x1cb2, 1570, 1}, 231| | 232| 3.53k| {0x104b8, 3594, 1}, 233| | 234| 3.53k| {0x2cb8, 2837, 1}, 235| | 236| 3.53k| {0x04b8, 1174, 1}, 237| | 238| 3.53k| {0x1eb8, 2138, 1}, 239| | 240| 3.53k| {0x1fb8, 2432, 1}, 241| | 242| 3.53k| {0x01b8, 411, 1}, 243| | 244| 3.53k| {0xa7b8, 3327, 1}, 245| | 246| 3.53k| {0xabb8, 1822, 1}, 247| | 248| 3.53k| {0x1fe3, 41, 3}, 249| | 250| 3.53k| {0x1cb8, 1588, 1}, 251| | 252| 3.53k| {0x10cb2, 3933, 1}, 253| | 254| 3.53k| {0x2ca6, 2810, 1}, 255| | 256| 3.53k| {0x04a6, 1147, 1}, 257| | 258| 3.53k| {0x1ea6, 2111, 1}, 259| | 260| 3.53k| {0x1fa6, 239, 2}, 261| | 262| 3.53k| {0x01a6, 685, 1}, 263| | 264| 3.53k| {0xa7a6, 3315, 1}, 265| | 266| 3.53k| {0xaba6, 1768, 1}, 267| | 268| 3.53k| {0x00df, 24, 2}, 269| | 270| 3.53k| {0x1ca6, 1534, 1}, 271| | 272| 3.53k| {0x2ca4, 2807, 1}, 273| | 274| 3.53k| {0x04a4, 1144, 1}, 275| | 276| 3.53k| {0x1ea4, 2108, 1}, 277| | 278| 3.53k| {0x1fa4, 229, 2}, 279| | 280| 3.53k| {0x01a4, 393, 1}, 281| | 282| 3.53k| {0xa7a4, 3312, 1}, 283| | 284| 3.53k| {0xaba4, 1762, 1}, 285| | 286| 3.53k| {0x01f1, 486, 1}, 287| | 288| 3.53k| {0x1ca4, 1528, 1}, 289| | 290| 3.53k| {0xff37, 3438, 1}, 291| | 292| 3.53k| {0x10ca6, 3897, 1}, 293| 3.53k| {0xffffffff, -1, 0}, 294| | 295| 3.53k| {0x2ca0, 2801, 1}, 296| | 297| 3.53k| {0x04a0, 1138, 1}, 298| | 299| 3.53k| {0x1ea0, 2102, 1}, 300| | 301| 3.53k| {0x1fa0, 209, 2}, 302| | 303| 3.53k| {0x01a0, 387, 1}, 304| | 305| 3.53k| {0xa7a0, 3306, 1}, 306| | 307| 3.53k| {0xaba0, 1750, 1}, 308| | 309| 3.53k| {0x10ca4, 3891, 1}, 310| | 311| 3.53k| {0x1ca0, 1516, 1}, 312| | 313| 3.53k| {0x2cae, 2822, 1}, 314| | 315| 3.53k| {0x04ae, 1159, 1}, 316| | 317| 3.53k| {0x1eae, 2123, 1}, 318| | 319| 3.53k| {0x1fae, 239, 2}, 320| | 321| 3.53k| {0x01ae, 697, 1}, 322| | 323| 3.53k| {0xa7ae, 661, 1}, 324| | 325| 3.53k| {0xabae, 1792, 1}, 326| | 327| 3.53k| {0x13fb, 1855, 1}, 328| | 329| 3.53k| {0x1cae, 1558, 1}, 330| 3.53k| {0xffffffff, -1, 0}, 331| | 332| 3.53k| {0x10ca0, 3879, 1}, 333| | 334| 3.53k| {0x13fd, 1861, 1}, 335| | 336| 3.53k| {0x2cac, 2819, 1}, 337| | 338| 3.53k| {0x04ac, 1156, 1}, 339| | 340| 3.53k| {0x1eac, 2120, 1}, 341| | 342| 3.53k| {0x1fac, 229, 2}, 343| | 344| 3.53k| {0x01ac, 399, 1}, 345| | 346| 3.53k| {0xa7ac, 640, 1}, 347| | 348| 3.53k| {0xabac, 1786, 1}, 349| | 350| 3.53k| {0x10cae, 3921, 1}, 351| | 352| 3.53k| {0x1cac, 1552, 1}, 353| | 354| 3.53k| {0x2ca2, 2804, 1}, 355| | 356| 3.53k| {0x04a2, 1141, 1}, 357| | 358| 3.53k| {0x1ea2, 2105, 1}, 359| | 360| 3.53k| {0x1fa2, 219, 2}, 361| | 362| 3.53k| {0x01a2, 390, 1}, 363| | 364| 3.53k| {0xa7a2, 3309, 1}, 365| | 366| 3.53k| {0xaba2, 1756, 1}, 367| | 368| 3.53k| {0x10b2, 2966, 1}, 369| | 370| 3.53k| {0x1ca2, 1522, 1}, 371| | 372| 3.53k| {0x0389, 745, 1}, 373| | 374| 3.53k| {0x10cac, 3915, 1}, 375| | 376| 3.53k| {0x118b2, 4056, 1}, 377| | 378| 3.53k| {0x03ff, 736, 1}, 379| | 380| 3.53k| {0x10402, 3456, 1}, 381| | 382| 3.53k| {0x2c02, 2591, 1}, 383| | 384| 3.53k| {0x0402, 1011, 1}, 385| | 386| 3.53k| {0x1e02, 1879, 1}, 387| | 388| 3.53k| {0x10b8, 2984, 1}, 389| | 390| 3.53k| {0x0102, 174, 1}, 391| | 392| 3.53k| {0x10ca2, 3885, 1}, 393| | 394| 3.53k| {0x03fd, 730, 1}, 395| | 396| 3.53k| {0x118b8, 4074, 1}, 397| 3.53k| {0xffffffff, -1, 0}, 398| | 399| 3.53k| {0x104b0, 3570, 1}, 400| | 401| 3.53k| {0x2cb0, 2825, 1}, 402| | 403| 3.53k| {0x04b0, 1162, 1}, 404| | 405| 3.53k| {0x1eb0, 2126, 1}, 406| | 407| 3.53k| {0x10a6, 2930, 1}, 408| 3.53k| {0xffffffff, -1, 0}, 409| | 410| 3.53k| {0xa7b0, 718, 1}, 411| | 412| 3.53k| {0xabb0, 1798, 1}, 413| | 414| 3.53k| {0x118a6, 4020, 1}, 415| | 416| 3.53k| {0x1cb0, 1564, 1}, 417| | 418| 3.53k| {0x1e97, 34, 2}, 419| | 420| 3.53k| {0x1f97, 204, 2}, 421| | 422| 3.53k| {0x0197, 655, 1}, 423| | 424| 3.53k| {0x10a4, 2924, 1}, 425| | 426| 3.53k| {0xab97, 1723, 1}, 427| | 428| 3.53k| {0x0390, 25, 3}, 429| | 430| 3.53k| {0x1c97, 1489, 1}, 431| | 432| 3.53k| {0x118a4, 4014, 1}, 433| | 434| 3.53k| {0x1057d, 3714, 1}, 435| | 436| 3.53k| {0x050a, 1297, 1}, 437| | 438| 3.53k| {0x10cb0, 3927, 1}, 439| 3.53k| {0xffffffff, -1, 0}, 440| | 441| 3.53k| {0x10585, 3738, 1}, 442| | 443| 3.53k| {0x10589, 3750, 1}, 444| | 445| 3.53k| {0x03f7, 896, 1}, 446| | 447| 3.53k| {0x10a0, 2912, 1}, 448| | 449| 3.53k| {0x03f5, 764, 1}, 450| | 451| 3.53k| {0x10c97, 3852, 1}, 452| 3.53k| {0xffffffff, -1, 0}, 453| | 454| 3.53k| {0x118a0, 4002, 1}, 455| | 456| 3.53k| {0x10d64, 3996, 1}, 457| | 458| 3.53k| {0x1f4d, 2351, 1}, 459| | 460| 3.53k| {0x10584, 3735, 1}, 461| | 462| 3.53k| {0xfb02, 12, 2}, 463| | 464| 3.53k| {0x10ae, 2954, 1}, 465| | 466| 3.53k| {0x004d, 34, 1}, 467| | 468| 3.53k| {0x1fd7, 31, 3}, 469| | 470| 3.53k| {0x01d7, 447, 1}, 471| | 472| 3.53k| {0x118ae, 4044, 1}, 473| | 474| 3.53k| {0x2caa, 2816, 1}, 475| | 476| 3.53k| {0x04aa, 1153, 1}, 477| | 478| 3.53k| {0x1eaa, 2117, 1}, 479| | 480| 3.53k| {0x1faa, 219, 2}, 481| | 482| 3.53k| {0x0202, 508, 1}, 483| | 484| 3.53k| {0xa7aa, 652, 1}, 485| | 486| 3.53k| {0xabaa, 1780, 1}, 487| | 488| 3.53k| {0x10ac, 2948, 1}, 489| | 490| 3.53k| {0x1caa, 1546, 1}, 491| | 492| 3.53k| {0x0478, 1090, 1}, 493| | 494| 3.53k| {0x1e78, 2057, 1}, 495| | 496| 3.53k| {0x118ac, 4038, 1}, 497| | 498| 3.53k| {0x0178, 168, 1}, 499| | 500| 3.53k| {0x10590, 3768, 1}, 501| | 502| 3.53k| {0xab78, 1630, 1}, 503| 3.53k| {0xffffffff, -1, 0}, 504| | 505| 3.53k| {0x10a2, 2918, 1}, 506| | 507| 3.53k| {0x03a6, 822, 1}, 508| | 509| 3.53k| {0x24b8, 2513, 1}, 510| | 511| 3.53k| {0x10caa, 3909, 1}, 512| | 513| 3.53k| {0x118a2, 4008, 1}, 514| | 515| 3.53k| {0x1ff9, 2417, 1}, 516| | 517| 3.53k| {0x2ca8, 2813, 1}, 518| | 519| 3.53k| {0x04a8, 1150, 1}, 520| | 521| 3.53k| {0x1ea8, 2114, 1}, 522| | 523| 3.53k| {0x1fa8, 209, 2}, 524| | 525| 3.53k| {0x03a4, 816, 1}, 526| | 527| 3.53k| {0xa7a8, 3318, 1}, 528| | 529| 3.53k| {0xaba8, 1774, 1}, 530| | 531| 3.53k| {0x03f1, 808, 1}, 532| | 533| 3.53k| {0x1ca8, 1540, 1}, 534| | 535| 3.53k| {0x2c98, 2789, 1}, 536| | 537| 3.53k| {0x0498, 1126, 1}, 538| | 539| 3.53k| {0x1e98, 38, 2}, 540| | 541| 3.53k| {0x1f98, 169, 2}, 542| | 543| 3.53k| {0x0198, 375, 1}, 544| | 545| 3.53k| {0xa798, 3294, 1}, 546| | 547| 3.53k| {0xab98, 1726, 1}, 548| | 549| 3.53k| {0x03a0, 804, 1}, 550| | 551| 3.53k| {0x1c98, 1492, 1}, 552| | 553| 3.53k| {0x10b0, 2960, 1}, 554| | 555| 3.53k| {0x10ca8, 3903, 1}, 556| | 557| 3.53k| {0x1f83, 144, 2}, 558| | 559| 3.53k| {0xff35, 3432, 1}, 560| | 561| 3.53k| {0x118b0, 4050, 1}, 562| | 563| 3.53k| {0xab83, 1663, 1}, 564| | 565| 3.53k| {0xa698, 3138, 1}, 566| | 567| 3.53k| {0x1c83, 956, 1}, 568| | 569| 3.53k| {0x0537, 1372, 1}, 570| 3.53k| {0xffffffff, -1, 0}, 571| | 572| 3.53k| {0x10c98, 3855, 1}, 573| | 574| 3.53k| {0x2c96, 2786, 1}, 575| | 576| 3.53k| {0x0496, 1123, 1}, 577| | 578| 3.53k| {0x1e96, 16, 2}, 579| | 580| 3.53k| {0x1f96, 199, 2}, 581| | 582| 3.53k| {0x0196, 658, 1}, 583| | 584| 3.53k| {0xa796, 3291, 1}, 585| | 586| 3.53k| {0xab96, 1720, 1}, 587| | 588| 3.53k| {0x10c83, 3792, 1}, 589| | 590| 3.53k| {0x1c96, 1486, 1}, 591| | 592| 3.53k| {0x1fdb, 2411, 1}, 593| | 594| 3.53k| {0x01db, 453, 1}, 595| | 596| 3.53k| {0x1e90a, 4224, 1}, 597| | 598| 3.53k| {0x104c7, 3639, 1}, 599| | 600| 3.53k| {0x00db, 156, 1}, 601| | 602| 3.53k| {0x04c7, 1195, 1}, 603| | 604| 3.53k| {0xa696, 3135, 1}, 605| | 606| 3.53k| {0x1fc7, 15, 3}, 607| | 608| 3.53k| {0x01c7, 424, 1}, 609| | 610| 3.53k| {0xa7c7, 3345, 1}, 611| | 612| 3.53k| {0x10c96, 3849, 1}, 613| | 614| 3.53k| {0x00c7, 99, 1}, 615| | 616| 3.53k| {0x2c2a, 2711, 1}, 617| | 618| 3.53k| {0x042a, 986, 1}, 619| | 620| 3.53k| {0x1e2a, 1939, 1}, 621| | 622| 3.53k| {0x1f2a, 2294, 1}, 623| | 624| 3.53k| {0x012a, 234, 1}, 625| | 626| 3.53k| {0xa72a, 3156, 1}, 627| | 628| 3.53k| {0x10aa, 2942, 1}, 629| | 630| 3.53k| {0x1041d, 3537, 1}, 631| | 632| 3.53k| {0x2c1d, 2672, 1}, 633| | 634| 3.53k| {0x041d, 943, 1}, 635| | 636| 3.53k| {0x118aa, 4032, 1}, 637| | 638| 3.53k| {0x1f1d, 2285, 1}, 639| | 640| 3.53k| {0x104be, 3612, 1}, 641| | 642| 3.53k| {0x2cbe, 2846, 1}, 643| | 644| 3.53k| {0x04be, 1183, 1}, 645| | 646| 3.53k| {0x1ebe, 2147, 1}, 647| | 648| 3.53k| {0x1fbe, 779, 1}, 649| | 650| 3.53k| {0xab77, 1627, 1}, 651| | 652| 3.53k| {0xa7be, 3336, 1}, 653| | 654| 3.53k| {0xabbe, 1840, 1}, 655| | 656| 3.53k| {0x03b0, 41, 3}, 657| | 658| 3.53k| {0x1cbe, 1600, 1}, 659| | 660| 3.53k| {0x017b, 348, 1}, 661| | 662| 3.53k| {0xa77b, 3261, 1}, 663| | 664| 3.53k| {0xab7b, 1639, 1}, 665| | 666| 3.53k| {0x2c7f, 586, 1}, 667| | 668| 3.53k| {0xff2a, 3399, 1}, 669| | 670| 3.53k| {0x0397, 771, 1}, 671| | 672| 3.53k| {0x10a8, 2936, 1}, 673| | 674| 3.53k| {0x017f, 52, 1}, 675| 3.53k| {0xffffffff, -1, 0}, 676| | 677| 3.53k| {0xab7f, 1651, 1}, 678| | 679| 3.53k| {0x118a8, 4026, 1}, 680| | 681| 3.53k| {0x104bc, 3606, 1}, 682| | 683| 3.53k| {0x2cbc, 2843, 1}, 684| | 685| 3.53k| {0x04bc, 1180, 1}, 686| | 687| 3.53k| {0x1ebc, 2144, 1}, 688| | 689| 3.53k| {0x1fbc, 62, 2}, 690| | 691| 3.53k| {0x01bc, 414, 1}, 692| | 693| 3.53k| {0xa7bc, 3333, 1}, 694| | 695| 3.53k| {0xabbc, 1834, 1}, 696| | 697| 3.53k| {0x104ba, 3600, 1}, 698| | 699| 3.53k| {0x2cba, 2840, 1}, 700| | 701| 3.53k| {0x04ba, 1177, 1}, 702| | 703| 3.53k| {0x1eba, 2141, 1}, 704| | 705| 3.53k| {0x1fba, 2390, 1}, 706| | 707| 3.53k| {0x13f9, 1849, 1}, 708| | 709| 3.53k| {0xa7ba, 3330, 1}, 710| | 711| 3.53k| {0xabba, 1828, 1}, 712| | 713| 3.53k| {0x0502, 1285, 1}, 714| | 715| 3.53k| {0x1cba, 1594, 1}, 716| | 717| 3.53k| {0xff33, 3426, 1}, 718| | 719| 3.53k| {0x022a, 565, 1}, 720| | 721| 3.53k| {0x104b6, 3588, 1}, 722| | 723| 3.53k| {0x2cb6, 2834, 1}, 724| | 725| 3.53k| {0x04b6, 1171, 1}, 726| | 727| 3.53k| {0x1eb6, 2135, 1}, 728| | 729| 3.53k| {0x1fb6, 58, 2}, 730| | 731| 3.53k| {0x03aa, 836, 1}, 732| | 733| 3.53k| {0xa7b6, 3324, 1}, 734| | 735| 3.53k| {0xabb6, 1816, 1}, 736| | 737| 3.53k| {0x10d65, 3999, 1}, 738| | 739| 3.53k| {0x1cb6, 1582, 1}, 740| | 741| 3.53k| {0x2c94, 2783, 1}, 742| | 743| 3.53k| {0x0494, 1120, 1}, 744| | 745| 3.53k| {0x1e94, 2099, 1}, 746| | 747| 3.53k| {0x1f94, 189, 2}, 748| | 749| 3.53k| {0x0194, 643, 1}, 750| 3.53k| {0xffffffff, -1, 0}, 751| | 752| 3.53k| {0xab94, 1714, 1}, 753| | 754| 3.53k| {0x10c7, 3026, 1}, 755| | 756| 3.53k| {0x1c94, 1480, 1}, 757| | 758| 3.53k| {0x1e4c, 1990, 1}, 759| | 760| 3.53k| {0x1f4c, 2348, 1}, 761| | 762| 3.53k| {0x014c, 279, 1}, 763| | 764| 3.53k| {0xa74c, 3204, 1}, 765| | 766| 3.53k| {0x03f9, 890, 1}, 767| | 768| 3.53k| {0x004c, 31, 1}, 769| | 770| 3.53k| {0xa694, 3132, 1}, 771| 3.53k| {0xffffffff, -1, 0}, 772| | 773| 3.53k| {0x03a8, 829, 1}, 774| | 775| 3.53k| {0x2ceb, 2903, 1}, 776| | 777| 3.53k| {0x10c94, 3843, 1}, 778| 3.53k| {0xffffffff, -1, 0}, 779| | 780| 3.53k| {0x1feb, 2423, 1}, 781| | 782| 3.53k| {0xa64c, 3051, 1}, 783| | 784| 3.53k| {0x054d, 1438, 1}, 785| | 786| 3.53k| {0x0474, 1084, 1}, 787| | 788| 3.53k| {0x1e74, 2051, 1}, 789| | 790| 3.53k| {0x0398, 774, 1}, 791| | 792| 3.53k| {0x0174, 339, 1}, 793| | 794| 3.53k| {0x10be, 3002, 1}, 795| | 796| 3.53k| {0xab74, 1618, 1}, 797| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 798| | 799| 3.53k| {0x118be, 4092, 1}, 800| | 801| 3.53k| {0x2c92, 2780, 1}, 802| | 803| 3.53k| {0x0492, 1117, 1}, 804| | 805| 3.53k| {0x1e92, 2096, 1}, 806| | 807| 3.53k| {0x1f92, 179, 2}, 808| 3.53k| {0xffffffff, -1, 0}, 809| | 810| 3.53k| {0xa792, 3285, 1}, 811| | 812| 3.53k| {0xab92, 1708, 1}, 813| | 814| 3.53k| {0x10578, 3702, 1}, 815| | 816| 3.53k| {0x1c92, 1474, 1}, 817| | 818| 3.53k| {0x1f8b, 144, 2}, 819| | 820| 3.53k| {0x018b, 366, 1}, 821| | 822| 3.53k| {0xa78b, 3279, 1}, 823| | 824| 3.53k| {0xab8b, 1687, 1}, 825| | 826| 3.53k| {0x0396, 768, 1}, 827| | 828| 3.53k| {0x2c6f, 607, 1}, 829| | 830| 3.53k| {0xa692, 3129, 1}, 831| | 832| 3.53k| {0x10bc, 2996, 1}, 833| | 834| 3.53k| {0x1f6f, 2387, 1}, 835| | 836| 3.53k| {0x0535, 1366, 1}, 837| | 838| 3.53k| {0x10c92, 3837, 1}, 839| | 840| 3.53k| {0x118bc, 4086, 1}, 841| | 842| 3.53k| {0x10427, 3567, 1}, 843| | 844| 3.53k| {0x2c27, 2702, 1}, 845| | 846| 3.53k| {0x0427, 977, 1}, 847| | 848| 3.53k| {0x10ba, 2990, 1}, 849| | 850| 3.53k| {0x10c8b, 3816, 1}, 851| | 852| 3.53k| {0x024c, 601, 1}, 853| | 854| 3.53k| {0x2c63, 1870, 1}, 855| | 856| 3.53k| {0x118ba, 4080, 1}, 857| | 858| 3.53k| {0x2c6e, 673, 1}, 859| | 860| 3.53k| {0x046e, 1075, 1}, 861| | 862| 3.53k| {0x1e6e, 2042, 1}, 863| | 864| 3.53k| {0x1f6e, 2384, 1}, 865| | 866| 3.53k| {0x016e, 330, 1}, 867| | 868| 3.53k| {0xa76e, 3255, 1}, 869| | 870| 3.53k| {0x1e902, 4200, 1}, 871| | 872| 3.53k| {0x10b6, 2978, 1}, 873| | 874| 3.53k| {0x24c7, 2558, 1}, 875| | 876| 3.53k| {0x10583, 3732, 1}, 877| | 878| 3.53k| {0x01d5, 444, 1}, 879| | 880| 3.53k| {0x118b6, 4068, 1}, 881| | 882| 3.53k| {0x2c86, 2762, 1}, 883| | 884| 3.53k| {0x00d5, 141, 1}, 885| | 886| 3.53k| {0x1e86, 2078, 1}, 887| | 888| 3.53k| {0x1f86, 159, 2}, 889| | 890| 3.53k| {0x0186, 619, 1}, 891| | 892| 3.53k| {0xa786, 3276, 1}, 893| | 894| 3.53k| {0xab86, 1672, 1}, 895| | 896| 3.53k| {0xff27, 3390, 1}, 897| | 898| 3.53k| {0x1c86, 986, 1}, 899| | 900| 3.53k| {0xff31, 3420, 1}, 901| 3.53k| {0xffffffff, -1, 0}, 902| | 903| 3.53k| {0x10416, 3516, 1}, 904| | 905| 3.53k| {0x2c16, 2651, 1}, 906| | 907| 3.53k| {0x0416, 922, 1}, 908| | 909| 3.53k| {0x1e16, 1909, 1}, 910| | 911| 3.53k| {0xa686, 3111, 1}, 912| | 913| 3.53k| {0x0116, 204, 1}, 914| | 915| 3.53k| {0x24be, 2531, 1}, 916| | 917| 3.53k| {0x037f, 893, 1}, 918| | 919| 3.53k| {0x10c86, 3801, 1}, 920| | 921| 3.53k| {0x104b4, 3582, 1}, 922| | 923| 3.53k| {0x2cb4, 2831, 1}, 924| | 925| 3.53k| {0x04b4, 1168, 1}, 926| | 927| 3.53k| {0x1eb4, 2132, 1}, 928| | 929| 3.53k| {0x1fb4, 50, 2}, 930| 3.53k| {0xffffffff, -1, 0}, 931| | 932| 3.53k| {0xa7b4, 3321, 1}, 933| | 934| 3.53k| {0xabb4, 1810, 1}, 935| 3.53k| {0xffffffff, -1, 0}, 936| | 937| 3.53k| {0x1cb4, 1576, 1}, 938| | 939| 3.53k| {0x04fe, 1279, 1}, 940| | 941| 3.53k| {0x1efe, 2243, 1}, 942| | 943| 3.53k| {0x052a, 1345, 1}, 944| | 945| 3.53k| {0x01fe, 502, 1}, 946| | 947| 3.53k| {0x2c9a, 2792, 1}, 948| | 949| 3.53k| {0x049a, 1129, 1}, 950| | 951| 3.53k| {0x1e9a, 0, 2}, 952| | 953| 3.53k| {0x1f9a, 179, 2}, 954| | 955| 3.53k| {0x24bc, 2525, 1}, 956| | 957| 3.53k| {0xa79a, 3297, 1}, 958| | 959| 3.53k| {0xab9a, 1732, 1}, 960| | 961| 3.53k| {0x10577, 3699, 1}, 962| | 963| 3.53k| {0x1c9a, 1498, 1}, 964| 3.53k| {0xffffffff, -1, 0}, 965| | 966| 3.53k| {0x104c2, 3624, 1}, 967| | 968| 3.53k| {0x2cc2, 2852, 1}, 969| | 970| 3.53k| {0x24ba, 2519, 1}, 971| | 972| 3.53k| {0x1ec2, 2153, 1}, 973| | 974| 3.53k| {0x1fc2, 253, 2}, 975| | 976| 3.53k| {0xa69a, 3141, 1}, 977| | 978| 3.53k| {0xa7c2, 3342, 1}, 979| 3.53k| {0xffffffff, -1, 0}, 980| | 981| 3.53k| {0x00c2, 83, 1}, 982| | 983| 3.53k| {0x10c9a, 3861, 1}, 984| | 985| 3.53k| {0xfb16, 125, 2}, 986| | 987| 3.53k| {0x1057f, 3720, 1}, 988| | 989| 3.53k| {0x0394, 761, 1}, 990| | 991| 3.53k| {0x0533, 1360, 1}, 992| | 993| 3.53k| {0x24b6, 2507, 1}, 994| | 995| 3.53k| {0x2c8e, 2774, 1}, 996| | 997| 3.53k| {0x048e, 1111, 1}, 998| | 999| 3.53k| {0x1e8e, 2090, 1}, 1000| | 1001| 3.53k| {0x1f8e, 159, 2}, 1002| | 1003| 3.53k| {0x018e, 456, 1}, 1004| | 1005| 3.53k| {0x0216, 538, 1}, 1006| | 1007| 3.53k| {0xab8e, 1696, 1}, 1008| | 1009| 3.53k| {0x2c8a, 2768, 1}, 1010| | 1011| 3.53k| {0x048a, 1105, 1}, 1012| | 1013| 3.53k| {0x1e8a, 2084, 1}, 1014| | 1015| 3.53k| {0x1f8a, 139, 2}, 1016| | 1017| 3.53k| {0x018a, 625, 1}, 1018| | 1019| 3.53k| {0x10d61, 3987, 1}, 1020| | 1021| 3.53k| {0xab8a, 1684, 1}, 1022| 3.53k| {0xffffffff, -1, 0}, 1023| | 1024| 3.53k| {0xa68e, 3123, 1}, 1025| | 1026| 3.53k| {0x2c62, 664, 1}, 1027| | 1028| 3.53k| {0x0462, 1056, 1}, 1029| | 1030| 3.53k| {0x1e62, 2024, 1}, 1031| | 1032| 3.53k| {0x10c8e, 3825, 1}, 1033| | 1034| 3.53k| {0x0162, 312, 1}, 1035| | 1036| 3.53k| {0xa762, 3237, 1}, 1037| | 1038| 3.53k| {0xa68a, 3117, 1}, 1039| 3.53k| {0xffffffff, -1, 0}, 1040| | 1041| 3.53k| {0x104ca, 3648, 1}, 1042| | 1043| 3.53k| {0x2cca, 2864, 1}, 1044| | 1045| 3.53k| {0x10c8a, 3813, 1}, 1046| | 1047| 3.53k| {0x1eca, 2165, 1}, 1048| | 1049| 3.53k| {0x1fca, 2402, 1}, 1050| | 1051| 3.53k| {0x01ca, 428, 1}, 1052| | 1053| 3.53k| {0x0392, 754, 1}, 1054| | 1055| 3.53k| {0xa662, 3084, 1}, 1056| | 1057| 3.53k| {0x00ca, 108, 1}, 1058| | 1059| 3.53k| {0x2c82, 2756, 1}, 1060| | 1061| 3.53k| {0x10594, 3777, 1}, 1062| | 1063| 3.53k| {0x1e82, 2072, 1}, 1064| | 1065| 3.53k| {0x1f82, 139, 2}, 1066| | 1067| 3.53k| {0x0182, 357, 1}, 1068| | 1069| 3.53k| {0xa782, 3270, 1}, 1070| | 1071| 3.53k| {0xab82, 1660, 1}, 1072| | 1073| 3.53k| {0x10b4, 2972, 1}, 1074| | 1075| 3.53k| {0x1c82, 946, 1}, 1076| 3.53k| {0xffffffff, -1, 0}, 1077| | 1078| 3.53k| {0x054c, 1435, 1}, 1079| | 1080| 3.53k| {0x118b4, 4062, 1}, 1081| 3.53k| {0xffffffff, -1, 0}, 1082| | 1083| 3.53k| {0x1fa9, 214, 2}, 1084| | 1085| 3.53k| {0x01a9, 691, 1}, 1086| | 1087| 3.53k| {0xa682, 3105, 1}, 1088| | 1089| 3.53k| {0xaba9, 1777, 1}, 1090| | 1091| 3.53k| {0x16e4d, 4137, 1}, 1092| | 1093| 3.53k| {0x1ca9, 1543, 1}, 1094| | 1095| 3.53k| {0x10c82, 3789, 1}, 1096| | 1097| 3.53k| {0x2c80, 2753, 1}, 1098| | 1099| 3.53k| {0x0480, 1102, 1}, 1100| | 1101| 3.53k| {0x1e80, 2069, 1}, 1102| | 1103| 3.53k| {0x1f80, 129, 2}, 1104| | 1105| 3.53k| {0x10574, 3690, 1}, 1106| | 1107| 3.53k| {0xa780, 3267, 1}, 1108| | 1109| 3.53k| {0xab80, 1654, 1}, 1110| | 1111| 3.53k| {0x0057, 65, 1}, 1112| | 1113| 3.53k| {0x1c80, 908, 1}, 1114| | 1115| 3.53k| {0x10ca9, 3906, 1}, 1116| | 1117| 3.53k| {0x1e91d, 4281, 1}, 1118| | 1119| 3.53k| {0x10c2, 3014, 1}, 1120| | 1121| 3.53k| {0x03d5, 822, 1}, 1122| 3.53k| {0xffffffff, -1, 0}, 1123| | 1124| 3.53k| {0x10592, 3774, 1}, 1125| | 1126| 3.53k| {0xa680, 3102, 1}, 1127| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 1128| | 1129| 3.53k| {0x0386, 739, 1}, 1130| | 1131| 3.53k| {0x10c80, 3783, 1}, 1132| | 1133| 3.53k| {0x104c4, 3630, 1}, 1134| | 1135| 3.53k| {0x2cc4, 2855, 1}, 1136| 3.53k| {0xffffffff, -1, 0}, 1137| | 1138| 3.53k| {0x1ec4, 2156, 1}, 1139| | 1140| 3.53k| {0x1fc4, 54, 2}, 1141| | 1142| 3.53k| {0x01c4, 420, 1}, 1143| | 1144| 3.53k| {0xa7c4, 3288, 1}, 1145| | 1146| 3.53k| {0x10d63, 3993, 1}, 1147| | 1148| 3.53k| {0x00c4, 89, 1}, 1149| | 1150| 3.53k| {0x2c9e, 2798, 1}, 1151| | 1152| 3.53k| {0x049e, 1135, 1}, 1153| | 1154| 3.53k| {0x1e9e, 24, 2}, 1155| | 1156| 3.53k| {0x1f9e, 199, 2}, 1157| 3.53k| {0xffffffff, -1, 0}, 1158| | 1159| 3.53k| {0xa79e, 3303, 1}, 1160| | 1161| 3.53k| {0xab9e, 1744, 1}, 1162| 3.53k| {0xffffffff, -1, 0}, 1163| | 1164| 3.53k| {0x1c9e, 1510, 1}, 1165| | 1166| 3.53k| {0x2c9c, 2795, 1}, 1167| | 1168| 3.53k| {0x049c, 1132, 1}, 1169| | 1170| 3.53k| {0x0531, 1354, 1}, 1171| | 1172| 3.53k| {0x1f9c, 189, 2}, 1173| | 1174| 3.53k| {0x019c, 670, 1}, 1175| | 1176| 3.53k| {0xa79c, 3300, 1}, 1177| | 1178| 3.53k| {0xab9c, 1738, 1}, 1179| 3.53k| {0xffffffff, -1, 0}, 1180| | 1181| 3.53k| {0x1c9c, 1504, 1}, 1182| | 1183| 3.53k| {0x03fe, 733, 1}, 1184| | 1185| 3.53k| {0x10c9e, 3873, 1}, 1186| 3.53k| {0xffffffff, -1, 0}, 1187| | 1188| 3.53k| {0x104cc, 3654, 1}, 1189| | 1190| 3.53k| {0x2ccc, 2867, 1}, 1191| | 1192| 3.53k| {0x039a, 784, 1}, 1193| | 1194| 3.53k| {0x1ecc, 2168, 1}, 1195| | 1196| 3.53k| {0x1fcc, 71, 2}, 1197| | 1198| 3.53k| {0x10586, 3741, 1}, 1199| | 1200| 3.53k| {0xa7cc, 3351, 1}, 1201| | 1202| 3.53k| {0x10c9c, 3867, 1}, 1203| | 1204| 3.53k| {0x00cc, 114, 1}, 1205| | 1206| 3.53k| {0x1f8d, 154, 2}, 1207| 3.53k| {0xffffffff, -1, 0}, 1208| | 1209| 3.53k| {0xa78d, 649, 1}, 1210| | 1211| 3.53k| {0xab8d, 1693, 1}, 1212| | 1213| 3.53k| {0x03c2, 812, 1}, 1214| | 1215| 3.53k| {0x2c8c, 2771, 1}, 1216| | 1217| 3.53k| {0x048c, 1108, 1}, 1218| | 1219| 3.53k| {0x1e8c, 2087, 1}, 1220| | 1221| 3.53k| {0x1f8c, 149, 2}, 1222| | 1223| 3.53k| {0x10a9, 2939, 1}, 1224| | 1225| 3.53k| {0x0516, 1315, 1}, 1226| | 1227| 3.53k| {0xab8c, 1690, 1}, 1228| 3.53k| {0xffffffff, -1, 0}, 1229| | 1230| 3.53k| {0x118a9, 4029, 1}, 1231| | 1232| 3.53k| {0x104b5, 3585, 1}, 1233| | 1234| 3.53k| {0x24c2, 2543, 1}, 1235| | 1236| 3.53k| {0x10c8d, 3822, 1}, 1237| 3.53k| {0xffffffff, -1, 0}, 1238| | 1239| 3.53k| {0x038e, 845, 1}, 1240| | 1241| 3.53k| {0x01b5, 408, 1}, 1242| | 1243| 3.53k| {0xa68c, 3120, 1}, 1244| | 1245| 3.53k| {0xabb5, 1813, 1}, 1246| | 1247| 3.53k| {0x00b5, 791, 1}, 1248| | 1249| 3.53k| {0x1cb5, 1579, 1}, 1250| | 1251| 3.53k| {0x10c8c, 3819, 1}, 1252| | 1253| 3.53k| {0x038a, 748, 1}, 1254| | 1255| 3.53k| {0x2c88, 2765, 1}, 1256| 3.53k| {0xffffffff, -1, 0}, 1257| | 1258| 3.53k| {0x1e88, 2081, 1}, 1259| | 1260| 3.53k| {0x1f88, 129, 2}, 1261| | 1262| 3.53k| {0x2c2f, 2726, 1}, 1263| | 1264| 3.53k| {0x042f, 1002, 1}, 1265| | 1266| 3.53k| {0xab88, 1678, 1}, 1267| | 1268| 3.53k| {0x1f2f, 2309, 1}, 1269| | 1270| 3.53k| {0x1c88, 3047, 1}, 1271| | 1272| 3.53k| {0x2ce2, 2900, 1}, 1273| | 1274| 3.53k| {0x04e2, 1237, 1}, 1275| | 1276| 3.53k| {0x1ee2, 2201, 1}, 1277| | 1278| 3.53k| {0x1fe2, 36, 3}, 1279| | 1280| 3.53k| {0x01e2, 465, 1}, 1281| | 1282| 3.53k| {0x10c4, 3020, 1}, 1283| | 1284| 3.53k| {0xa688, 3114, 1}, 1285| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 1286| | 1287| 3.53k| {0x2c75, 2750, 1}, 1288| | 1289| 3.53k| {0x10c88, 3807, 1}, 1290| | 1291| 3.53k| {0x1e4a, 1987, 1}, 1292| | 1293| 3.53k| {0x1f4a, 2342, 1}, 1294| | 1295| 3.53k| {0x014a, 276, 1}, 1296| | 1297| 3.53k| {0xa74a, 3201, 1}, 1298| | 1299| 3.53k| {0xab75, 1621, 1}, 1300| | 1301| 3.53k| {0x004a, 24, 1}, 1302| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 1303| | 1304| 3.53k| {0x24ca, 2567, 1}, 1305| | 1306| 3.53k| {0x1058e, 3762, 1}, 1307| | 1308| 3.53k| {0xff2f, 3414, 1}, 1309| | 1310| 3.53k| {0x10d62, 3990, 1}, 1311| 3.53k| {0xffffffff, -1, 0}, 1312| | 1313| 3.53k| {0xa64a, 3047, 1}, 1314| 3.53k| {0xffffffff, -1, 0}, 1315| | 1316| 3.53k| {0x03a9, 832, 1}, 1317| | 1318| 3.53k| {0x1058a, 3753, 1}, 1319| | 1320| 3.53k| {0x1041c, 3534, 1}, 1321| | 1322| 3.53k| {0x2c1c, 2669, 1}, 1323| | 1324| 3.53k| {0x041c, 940, 1}, 1325| | 1326| 3.53k| {0x1e1c, 1918, 1}, 1327| | 1328| 3.53k| {0x1f1c, 2282, 1}, 1329| | 1330| 3.53k| {0x011c, 213, 1}, 1331| | 1332| 3.53k| {0x1041a, 3528, 1}, 1333| | 1334| 3.53k| {0x2c1a, 2663, 1}, 1335| | 1336| 3.53k| {0x041a, 934, 1}, 1337| | 1338| 3.53k| {0x1e1a, 1915, 1}, 1339| | 1340| 3.53k| {0x1f1a, 2276, 1}, 1341| | 1342| 3.53k| {0x011a, 210, 1}, 1343| | 1344| 3.53k| {0x10418, 3522, 1}, 1345| | 1346| 3.53k| {0x2c18, 2657, 1}, 1347| | 1348| 3.53k| {0x0418, 928, 1}, 1349| | 1350| 3.53k| {0x1e18, 1912, 1}, 1351| | 1352| 3.53k| {0x1f18, 2270, 1}, 1353| | 1354| 3.53k| {0x0118, 207, 1}, 1355| | 1356| 3.53k| {0x1040e, 3492, 1}, 1357| | 1358| 3.53k| {0x2c0e, 2627, 1}, 1359| | 1360| 3.53k| {0x040e, 1047, 1}, 1361| | 1362| 3.53k| {0x1e0e, 1897, 1}, 1363| | 1364| 3.53k| {0x1f0e, 2264, 1}, 1365| | 1366| 3.53k| {0x010e, 192, 1}, 1367| | 1368| 3.53k| {0x104c1, 3621, 1}, 1369| | 1370| 3.53k| {0x10582, 3729, 1}, 1371| | 1372| 3.53k| {0x04c1, 1186, 1}, 1373| 3.53k| {0xffffffff, -1, 0}, 1374| | 1375| 3.53k| {0x16e4c, 4134, 1}, 1376| | 1377| 3.53k| {0x1e916, 4260, 1}, 1378| | 1379| 3.53k| {0x10b5, 2975, 1}, 1380| | 1381| 3.53k| {0x10d57, 3957, 1}, 1382| | 1383| 3.53k| {0x00c1, 80, 1}, 1384| | 1385| 3.53k| {0x024a, 598, 1}, 1386| | 1387| 3.53k| {0x118b5, 4065, 1}, 1388| | 1389| 3.53k| {0x04f0, 1258, 1}, 1390| | 1391| 3.53k| {0x1ef0, 2222, 1}, 1392| | 1393| 3.53k| {0x039e, 798, 1}, 1394| | 1395| 3.53k| {0x01f0, 20, 2}, 1396| 3.53k| {0xffffffff, -1, 0}, 1397| | 1398| 3.53k| {0x24c4, 2549, 1}, 1399| | 1400| 3.53k| {0x1e3e, 1969, 1}, 1401| | 1402| 3.53k| {0x1f3e, 2330, 1}, 1403| 3.53k| {0xffffffff, -1, 0}, 1404| | 1405| 3.53k| {0xa73e, 3183, 1}, 1406| | 1407| 3.53k| {0x10580, 3723, 1}, 1408| | 1409| 3.53k| {0x039c, 791, 1}, 1410| | 1411| 3.53k| {0x1040c, 3486, 1}, 1412| | 1413| 3.53k| {0x2c0c, 2621, 1}, 1414| | 1415| 3.53k| {0x040c, 1041, 1}, 1416| | 1417| 3.53k| {0x1e0c, 1894, 1}, 1418| | 1419| 3.53k| {0x1f0c, 2258, 1}, 1420| | 1421| 3.53k| {0x010c, 189, 1}, 1422| | 1423| 3.53k| {0x021c, 547, 1}, 1424| 3.53k| {0xffffffff, -1, 0}, 1425| | 1426| 3.53k| {0x10414, 3510, 1}, 1427| | 1428| 3.53k| {0x2c14, 2645, 1}, 1429| | 1430| 3.53k| {0x0414, 915, 1}, 1431| | 1432| 3.53k| {0x1e14, 1906, 1}, 1433| | 1434| 3.53k| {0x021a, 544, 1}, 1435| | 1436| 3.53k| {0x0114, 201, 1}, 1437| | 1438| 3.53k| {0x10406, 3468, 1}, 1439| | 1440| 3.53k| {0x2c06, 2603, 1}, 1441| | 1442| 3.53k| {0x0406, 1023, 1}, 1443| | 1444| 3.53k| {0x1e06, 1885, 1}, 1445| | 1446| 3.53k| {0x0218, 541, 1}, 1447| | 1448| 3.53k| {0x0106, 180, 1}, 1449| 3.53k| {0xffffffff, -1, 0}, 1450| | 1451| 3.53k| {0x1f3d, 2327, 1}, 1452| | 1453| 3.53k| {0x013d, 258, 1}, 1454| | 1455| 3.53k| {0x24cc, 2573, 1}, 1456| | 1457| 3.53k| {0x020e, 526, 1}, 1458| | 1459| 3.53k| {0x038c, 842, 1}, 1460| | 1461| 3.53k| {0x10408, 3474, 1}, 1462| | 1463| 3.53k| {0x2c08, 2609, 1}, 1464| | 1465| 3.53k| {0x0408, 1029, 1}, 1466| | 1467| 3.53k| {0x1e08, 1888, 1}, 1468| | 1469| 3.53k| {0x1f08, 2246, 1}, 1470| | 1471| 3.53k| {0x0108, 183, 1}, 1472| | 1473| 3.53k| {0x10404, 3462, 1}, 1474| | 1475| 3.53k| {0x2c04, 2597, 1}, 1476| | 1477| 3.53k| {0x0404, 1017, 1}, 1478| | 1479| 3.53k| {0x1e04, 1882, 1}, 1480| 3.53k| {0xffffffff, -1, 0}, 1481| | 1482| 3.53k| {0x0104, 177, 1}, 1483| | 1484| 3.53k| {0x10400, 3450, 1}, 1485| | 1486| 3.53k| {0x2c00, 2585, 1}, 1487| | 1488| 3.53k| {0x0400, 1005, 1}, 1489| | 1490| 3.53k| {0x1e00, 1876, 1}, 1491| | 1492| 3.53k| {0x0147, 273, 1}, 1493| | 1494| 3.53k| {0x0100, 171, 1}, 1495| | 1496| 3.53k| {0x023e, 2735, 1}, 1497| | 1498| 3.53k| {0x0047, 18, 1}, 1499| | 1500| 3.53k| {0x0388, 742, 1}, 1501| | 1502| 3.53k| {0x1e56, 2005, 1}, 1503| | 1504| 3.53k| {0x1f56, 62, 3}, 1505| | 1506| 3.53k| {0x0156, 294, 1}, 1507| | 1508| 3.53k| {0xa756, 3219, 1}, 1509| | 1510| 3.53k| {0xfb14, 109, 2}, 1511| | 1512| 3.53k| {0x0056, 62, 1}, 1513| | 1514| 3.53k| {0x020c, 523, 1}, 1515| | 1516| 3.53k| {0x1058d, 3759, 1}, 1517| | 1518| 3.53k| {0x03e2, 869, 1}, 1519| | 1520| 3.53k| {0x10c1, 3011, 1}, 1521| | 1522| 3.53k| {0xfb06, 29, 2}, 1523| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 1524| | 1525| 3.53k| {0xa656, 3066, 1}, 1526| | 1527| 3.53k| {0x0214, 535, 1}, 1528| | 1529| 3.53k| {0x1058c, 3756, 1}, 1530| | 1531| 3.53k| {0x10426, 3564, 1}, 1532| | 1533| 3.53k| {0x2c26, 2699, 1}, 1534| | 1535| 3.53k| {0x0426, 974, 1}, 1536| | 1537| 3.53k| {0x1e26, 1933, 1}, 1538| | 1539| 3.53k| {0x0206, 514, 1}, 1540| | 1541| 3.53k| {0x0126, 228, 1}, 1542| | 1543| 3.53k| {0xa726, 3150, 1}, 1544| | 1545| 3.53k| {0x023d, 378, 1}, 1546| | 1547| 3.53k| {0x10424, 3558, 1}, 1548| | 1549| 3.53k| {0x2c24, 2693, 1}, 1550| | 1551| 3.53k| {0x0424, 968, 1}, 1552| | 1553| 3.53k| {0x1e24, 1930, 1}, 1554| | 1555| 3.53k| {0xfb04, 5, 3}, 1556| | 1557| 3.53k| {0x0124, 225, 1}, 1558| | 1559| 3.53k| {0xa724, 3147, 1}, 1560| | 1561| 3.53k| {0x1f59, 2354, 1}, 1562| | 1563| 3.53k| {0x0208, 517, 1}, 1564| 3.53k| {0xffffffff, -1, 0}, 1565| | 1566| 3.53k| {0xfb00, 4, 2}, 1567| | 1568| 3.53k| {0x0059, 71, 1}, 1569| | 1570| 3.53k| {0x10588, 3747, 1}, 1571| | 1572| 3.53k| {0x1fad, 234, 2}, 1573| | 1574| 3.53k| {0x0204, 511, 1}, 1575| | 1576| 3.53k| {0xa7ad, 667, 1}, 1577| | 1578| 3.53k| {0xabad, 1789, 1}, 1579| | 1580| 3.53k| {0x1f5f, 2363, 1}, 1581| | 1582| 3.53k| {0x1cad, 1555, 1}, 1583| | 1584| 3.53k| {0xff26, 3387, 1}, 1585| | 1586| 3.53k| {0x0200, 505, 1}, 1587| | 1588| 3.53k| {0x2c2e, 2723, 1}, 1589| | 1590| 3.53k| {0x042e, 999, 1}, 1591| | 1592| 3.53k| {0x1e2e, 1945, 1}, 1593| | 1594| 3.53k| {0x1f2e, 2306, 1}, 1595| | 1596| 3.53k| {0x012e, 240, 1}, 1597| | 1598| 3.53k| {0xa72e, 3162, 1}, 1599| | 1600| 3.53k| {0xff24, 3381, 1}, 1601| 3.53k| {0xffffffff, -1, 0}, 1602| | 1603| 3.53k| {0x10cad, 3918, 1}, 1604| | 1605| 3.53k| {0x10575, 3693, 1}, 1606| | 1607| 3.53k| {0x004f, 40, 1}, 1608| | 1609| 3.53k| {0x054a, 1429, 1}, 1610| | 1611| 3.53k| {0x2c2c, 2717, 1}, 1612| | 1613| 3.53k| {0x042c, 993, 1}, 1614| | 1615| 3.53k| {0x1e2c, 1942, 1}, 1616| | 1617| 3.53k| {0x1f2c, 2300, 1}, 1618| | 1619| 3.53k| {0x012c, 237, 1}, 1620| | 1621| 3.53k| {0xa72c, 3159, 1}, 1622| | 1623| 3.53k| {0x2c28, 2705, 1}, 1624| | 1625| 3.53k| {0x0428, 980, 1}, 1626| | 1627| 3.53k| {0x1e28, 1936, 1}, 1628| | 1629| 3.53k| {0x1f28, 2288, 1}, 1630| | 1631| 3.53k| {0x0128, 231, 1}, 1632| | 1633| 3.53k| {0xa728, 3153, 1}, 1634| | 1635| 3.53k| {0x0226, 559, 1}, 1636| | 1637| 3.53k| {0x03f0, 784, 1}, 1638| | 1639| 3.53k| {0xff2e, 3411, 1}, 1640| | 1641| 3.53k| {0x24c1, 2540, 1}, 1642| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 1643| | 1644| 3.53k| {0x051c, 1324, 1}, 1645| | 1646| 3.53k| {0x0224, 556, 1}, 1647| | 1648| 3.53k| {0x104c0, 3618, 1}, 1649| | 1650| 3.53k| {0x2cc0, 2849, 1}, 1651| | 1652| 3.53k| {0x04c0, 1207, 1}, 1653| | 1654| 3.53k| {0x1ec0, 2150, 1}, 1655| | 1656| 3.53k| {0x051a, 1321, 1}, 1657| | 1658| 3.53k| {0xff2c, 3405, 1}, 1659| | 1660| 3.53k| {0xa7c0, 3339, 1}, 1661| 3.53k| {0xffffffff, -1, 0}, 1662| | 1663| 3.53k| {0x00c0, 77, 1}, 1664| | 1665| 3.53k| {0xab73, 1615, 1}, 1666| | 1667| 3.53k| {0x0518, 1318, 1}, 1668| | 1669| 3.53k| {0xff28, 3393, 1}, 1670| | 1671| 3.53k| {0x10422, 3552, 1}, 1672| | 1673| 3.53k| {0x2c22, 2687, 1}, 1674| | 1675| 3.53k| {0x0422, 960, 1}, 1676| | 1677| 3.53k| {0x1e22, 1927, 1}, 1678| | 1679| 3.53k| {0x050e, 1303, 1}, 1680| | 1681| 3.53k| {0x0122, 222, 1}, 1682| | 1683| 3.53k| {0xa722, 3144, 1}, 1684| | 1685| 3.53k| {0x022e, 571, 1}, 1686| | 1687| 3.53k| {0x1e54, 2002, 1}, 1688| | 1689| 3.53k| {0x1f54, 57, 3}, 1690| | 1691| 3.53k| {0x0154, 291, 1}, 1692| | 1693| 3.53k| {0xa754, 3216, 1}, 1694| | 1695| 3.53k| {0x1e30, 1948, 1}, 1696| | 1697| 3.53k| {0x0054, 56, 1}, 1698| | 1699| 3.53k| {0x0130, 261, 2}, 1700| | 1701| 3.53k| {0x1e52, 1999, 1}, 1702| | 1703| 3.53k| {0x1f52, 52, 3}, 1704| | 1705| 3.53k| {0x0152, 288, 1}, 1706| | 1707| 3.53k| {0xa752, 3213, 1}, 1708| | 1709| 3.53k| {0x022c, 568, 1}, 1710| | 1711| 3.53k| {0x0052, 49, 1}, 1712| | 1713| 3.53k| {0xa654, 3063, 1}, 1714| | 1715| 3.53k| {0x10ad, 2951, 1}, 1716| | 1717| 3.53k| {0x16e57, 4167, 1}, 1718| | 1719| 3.53k| {0x053e, 1393, 1}, 1720| | 1721| 3.53k| {0x0228, 562, 1}, 1722| | 1723| 3.53k| {0x118ad, 4041, 1}, 1724| | 1725| 3.53k| {0xff22, 3375, 1}, 1726| | 1727| 3.53k| {0xa652, 3060, 1}, 1728| | 1729| 3.53k| {0x1e50, 1996, 1}, 1730| | 1731| 3.53k| {0x1f50, 84, 2}, 1732| | 1733| 3.53k| {0x0150, 285, 1}, 1734| | 1735| 3.53k| {0xa750, 3210, 1}, 1736| | 1737| 3.53k| {0x050c, 1300, 1}, 1738| | 1739| 3.53k| {0x0050, 43, 1}, 1740| | 1741| 3.53k| {0x1fab, 224, 2}, 1742| | 1743| 3.53k| {0xff30, 3417, 1}, 1744| | 1745| 3.53k| {0xa7ab, 634, 1}, 1746| | 1747| 3.53k| {0xabab, 1783, 1}, 1748| | 1749| 3.53k| {0x104b7, 3591, 1}, 1750| | 1751| 3.53k| {0x1cab, 1549, 1}, 1752| | 1753| 3.53k| {0x0514, 1312, 1}, 1754| | 1755| 3.53k| {0xa650, 3057, 1}, 1756| | 1757| 3.53k| {0x1fb7, 10, 3}, 1758| | 1759| 3.53k| {0x01b7, 712, 1}, 1760| | 1761| 3.53k| {0x2164, 2468, 1}, 1762| | 1763| 3.53k| {0xabb7, 1819, 1}, 1764| | 1765| 3.53k| {0x0506, 1291, 1}, 1766| | 1767| 3.53k| {0x1cb7, 1585, 1}, 1768| | 1769| 3.53k| {0x104b1, 3573, 1}, 1770| | 1771| 3.53k| {0x053d, 1390, 1}, 1772| | 1773| 3.53k| {0x10cab, 3912, 1}, 1774| 3.53k| {0xffffffff, -1, 0}, 1775| | 1776| 3.53k| {0x0222, 553, 1}, 1777| | 1778| 3.53k| {0x01b1, 703, 1}, 1779| | 1780| 3.53k| {0xa7b1, 694, 1}, 1781| | 1782| 3.53k| {0xabb1, 1801, 1}, 1783| | 1784| 3.53k| {0x2c6d, 610, 1}, 1785| | 1786| 3.53k| {0x1cb1, 1567, 1}, 1787| | 1788| 3.53k| {0x0508, 1294, 1}, 1789| | 1790| 3.53k| {0x1f6d, 2381, 1}, 1791| | 1792| 3.53k| {0x10d56, 3954, 1}, 1793| | 1794| 3.53k| {0x0230, 574, 1}, 1795| | 1796| 3.53k| {0x2c6b, 2744, 1}, 1797| 3.53k| {0xffffffff, -1, 0}, 1798| | 1799| 3.53k| {0x0504, 1288, 1}, 1800| | 1801| 3.53k| {0x1f6b, 2375, 1}, 1802| | 1803| 3.53k| {0x10c0, 3008, 1}, 1804| | 1805| 3.53k| {0x1e91c, 4278, 1}, 1806| | 1807| 3.53k| {0x10cb1, 3930, 1}, 1808| | 1809| 3.53k| {0x0547, 1420, 1}, 1810| | 1811| 3.53k| {0x0500, 1282, 1}, 1812| | 1813| 3.53k| {0x2c69, 2741, 1}, 1814| 3.53k| {0xffffffff, -1, 0}, 1815| | 1816| 3.53k| {0x1e91a, 4272, 1}, 1817| | 1818| 3.53k| {0x1f69, 2369, 1}, 1819| 3.53k| {0xffffffff, -1, 0}, 1820| | 1821| 3.53k| {0x0556, 1465, 1}, 1822| | 1823| 3.53k| {0x104b3, 3579, 1}, 1824| 3.53k| {0xffffffff, -1, 0}, 1825| | 1826| 3.53k| {0x1e918, 4266, 1}, 1827| | 1828| 3.53k| {0x2167, 2477, 1}, 1829| | 1830| 3.53k| {0x1fb3, 62, 2}, 1831| | 1832| 3.53k| {0x01b3, 405, 1}, 1833| | 1834| 3.53k| {0xa7b3, 3369, 1}, 1835| | 1836| 3.53k| {0xabb3, 1807, 1}, 1837| | 1838| 3.53k| {0x1e90e, 4236, 1}, 1839| | 1840| 3.53k| {0x1cb3, 1573, 1}, 1841| 3.53k| {0xffffffff, -1, 0}, 1842| | 1843| 3.53k| {0x1fa7, 244, 2}, 1844| | 1845| 3.53k| {0x01a7, 396, 1}, 1846| | 1847| 3.53k| {0x10d59, 3963, 1}, 1848| | 1849| 3.53k| {0xaba7, 1771, 1}, 1850| | 1851| 3.53k| {0xab71, 1609, 1}, 1852| | 1853| 3.53k| {0x1ca7, 1537, 1}, 1854| | 1855| 3.53k| {0x1e4e, 1993, 1}, 1856| | 1857| 3.53k| {0x0526, 1339, 1}, 1858| | 1859| 3.53k| {0x014e, 282, 1}, 1860| | 1861| 3.53k| {0xa74e, 3207, 1}, 1862| 3.53k| {0xffffffff, -1, 0}, 1863| | 1864| 3.53k| {0x004e, 37, 1}, 1865| | 1866| 3.53k| {0x10d5f, 3981, 1}, 1867| | 1868| 3.53k| {0x1f39, 2315, 1}, 1869| | 1870| 3.53k| {0x0139, 252, 1}, 1871| | 1872| 3.53k| {0x0524, 1336, 1}, 1873| | 1874| 3.53k| {0x10ca7, 3900, 1}, 1875| | 1876| 3.53k| {0x1e48, 1984, 1}, 1877| | 1878| 3.53k| {0x1f48, 2336, 1}, 1879| | 1880| 3.53k| {0xa64e, 3054, 1}, 1881| | 1882| 3.53k| {0xa748, 3198, 1}, 1883| | 1884| 3.53k| {0x10ab, 2945, 1}, 1885| | 1886| 3.53k| {0x0048, 21, 1}, 1887| | 1888| 3.53k| {0x104d3, 3675, 1}, 1889| 3.53k| {0xffffffff, -1, 0}, 1890| | 1891| 3.53k| {0x118ab, 4035, 1}, 1892| | 1893| 3.53k| {0x1e90c, 4230, 1}, 1894| | 1895| 3.53k| {0x1fd3, 25, 3}, 1896| | 1897| 3.53k| {0x01d3, 441, 1}, 1898| | 1899| 3.53k| {0x10b7, 2981, 1}, 1900| | 1901| 3.53k| {0xa648, 3044, 1}, 1902| | 1903| 3.53k| {0x00d3, 135, 1}, 1904| 3.53k| {0xffffffff, -1, 0}, 1905| | 1906| 3.53k| {0x118b7, 4071, 1}, 1907| | 1908| 3.53k| {0x1e914, 4254, 1}, 1909| | 1910| 3.53k| {0x052e, 1351, 1}, 1911| | 1912| 3.53k| {0xff39, 3444, 1}, 1913| | 1914| 3.53k| {0x16e4a, 4128, 1}, 1915| | 1916| 3.53k| {0x054f, 1444, 1}, 1917| | 1918| 3.53k| {0x10b1, 2963, 1}, 1919| | 1920| 3.53k| {0x1e906, 4212, 1}, 1921| | 1922| 3.53k| {0x24c0, 2537, 1}, 1923| 3.53k| {0xffffffff, -1, 0}, 1924| | 1925| 3.53k| {0x118b1, 4053, 1}, 1926| | 1927| 3.53k| {0x2c60, 2729, 1}, 1928| | 1929| 3.53k| {0x0460, 1053, 1}, 1930| | 1931| 3.53k| {0x1e60, 2020, 1}, 1932| | 1933| 3.53k| {0x052c, 1348, 1}, 1934| | 1935| 3.53k| {0x0160, 309, 1}, 1936| | 1937| 3.53k| {0xa760, 3234, 1}, 1938| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 1939| | 1940| 3.53k| {0x1e908, 4218, 1}, 1941| | 1942| 3.53k| {0x0528, 1342, 1}, 1943| | 1944| 3.53k| {0x2c2b, 2714, 1}, 1945| | 1946| 3.53k| {0x042b, 990, 1}, 1947| | 1948| 3.53k| {0x024e, 604, 1}, 1949| | 1950| 3.53k| {0x1f2b, 2297, 1}, 1951| | 1952| 3.53k| {0x1e904, 4206, 1}, 1953| | 1954| 3.53k| {0xa660, 3081, 1}, 1955| | 1956| 3.53k| {0x10420, 3546, 1}, 1957| | 1958| 3.53k| {0x2c20, 2681, 1}, 1959| | 1960| 3.53k| {0x0420, 953, 1}, 1961| | 1962| 3.53k| {0x1e20, 1924, 1}, 1963| | 1964| 3.53k| {0x1e900, 4194, 1}, 1965| | 1966| 3.53k| {0x0120, 219, 1}, 1967| 3.53k| {0xffffffff, -1, 0}, 1968| | 1969| 3.53k| {0x0248, 595, 1}, 1970| | 1971| 3.53k| {0x10b3, 2969, 1}, 1972| | 1973| 3.53k| {0x10573, 3687, 1}, 1974| | 1975| 3.53k| {0x10d54, 3948, 1}, 1976| 3.53k| {0xffffffff, -1, 0}, 1977| | 1978| 3.53k| {0x118b3, 4059, 1}, 1979| | 1980| 3.53k| {0x03ab, 839, 1}, 1981| 3.53k| {0xffffffff, -1, 0}, 1982| | 1983| 3.53k| {0x10a7, 2933, 1}, 1984| 3.53k| {0xffffffff, -1, 0}, 1985| | 1986| 3.53k| {0x10d52, 3942, 1}, 1987| 3.53k| {0xffffffff, -1, 0}, 1988| | 1989| 3.53k| {0x118a7, 4023, 1}, 1990| | 1991| 3.53k| {0xff2b, 3402, 1}, 1992| | 1993| 3.53k| {0x0522, 1333, 1}, 1994| | 1995| 3.53k| {0x1041e, 3540, 1}, 1996| | 1997| 3.53k| {0x2c1e, 2675, 1}, 1998| | 1999| 3.53k| {0x041e, 946, 1}, 2000| | 2001| 3.53k| {0x1e1e, 1921, 1}, 2002| | 2003| 3.53k| {0x0554, 1459, 1}, 2004| | 2005| 3.53k| {0x011e, 216, 1}, 2006| | 2007| 3.53k| {0x10425, 3561, 1}, 2008| | 2009| 3.53k| {0x2c25, 2696, 1}, 2010| | 2011| 3.53k| {0x0425, 971, 1}, 2012| | 2013| 3.53k| {0x10d50, 3936, 1}, 2014| | 2015| 3.53k| {0x24b7, 2510, 1}, 2016| | 2017| 3.53k| {0x0552, 1453, 1}, 2018| | 2019| 3.53k| {0x10412, 3504, 1}, 2020| | 2021| 3.53k| {0x2c12, 2639, 1}, 2022| | 2023| 3.53k| {0x0412, 908, 1}, 2024| | 2025| 3.53k| {0x1e12, 1903, 1}, 2026| | 2027| 3.53k| {0x2165, 2471, 1}, 2028| | 2029| 3.53k| {0x0112, 198, 1}, 2030| | 2031| 3.53k| {0x10410, 3498, 1}, 2032| | 2033| 3.53k| {0x2c10, 2633, 1}, 2034| | 2035| 3.53k| {0x0410, 902, 1}, 2036| | 2037| 3.53k| {0x1e10, 1900, 1}, 2038| 3.53k| {0xffffffff, -1, 0}, 2039| | 2040| 3.53k| {0x0110, 195, 1}, 2041| 3.53k| {0xffffffff, -1, 0}, 2042| | 2043| 3.53k| {0x0550, 1447, 1}, 2044| 3.53k| {0xffffffff, -1, 0}, 2045| | 2046| 3.53k| {0x2cda, 2888, 1}, 2047| | 2048| 3.53k| {0x04da, 1225, 1}, 2049| | 2050| 3.53k| {0x1eda, 2189, 1}, 2051| | 2052| 3.53k| {0x1fda, 2408, 1}, 2053| | 2054| 3.53k| {0x0220, 384, 1}, 2055| | 2056| 3.53k| {0xa7da, 3363, 1}, 2057| | 2058| 3.53k| {0xff25, 3384, 1}, 2059| | 2060| 3.53k| {0x00da, 153, 1}, 2061| | 2062| 3.53k| {0x2cd8, 2885, 1}, 2063| | 2064| 3.53k| {0x04d8, 1222, 1}, 2065| | 2066| 3.53k| {0x1ed8, 2186, 1}, 2067| | 2068| 3.53k| {0x1fd8, 2438, 1}, 2069| 3.53k| {0xffffffff, -1, 0}, 2070| | 2071| 3.53k| {0xa7d8, 3360, 1}, 2072| 3.53k| {0xffffffff, -1, 0}, 2073| | 2074| 3.53k| {0x00d8, 147, 1}, 2075| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2076| | 2077| 3.53k| {0x03a7, 826, 1}, 2078| | 2079| 3.53k| {0x0055, 59, 1}, 2080| | 2081| 3.53k| {0x2cd6, 2882, 1}, 2082| | 2083| 3.53k| {0x04d6, 1219, 1}, 2084| | 2085| 3.53k| {0x1ed6, 2183, 1}, 2086| | 2087| 3.53k| {0x1fd6, 76, 2}, 2088| 3.53k| {0xffffffff, -1, 0}, 2089| | 2090| 3.53k| {0xa7d6, 3357, 1}, 2091| | 2092| 3.53k| {0x021e, 550, 1}, 2093| | 2094| 3.53k| {0x00d6, 144, 1}, 2095| | 2096| 3.53k| {0x104d0, 3666, 1}, 2097| | 2098| 3.53k| {0x2cd0, 2873, 1}, 2099| | 2100| 3.53k| {0x04d0, 1210, 1}, 2101| | 2102| 3.53k| {0x1ed0, 2174, 1}, 2103| | 2104| 3.53k| {0x16e47, 4119, 1}, 2105| | 2106| 3.53k| {0x104b9, 3597, 1}, 2107| | 2108| 3.53k| {0xa7d0, 3354, 1}, 2109| 3.53k| {0xffffffff, -1, 0}, 2110| | 2111| 3.53k| {0x00d0, 126, 1}, 2112| | 2113| 3.53k| {0x1fb9, 2435, 1}, 2114| | 2115| 3.53k| {0x0212, 532, 1}, 2116| | 2117| 3.53k| {0x16e56, 4164, 1}, 2118| | 2119| 3.53k| {0xabb9, 1825, 1}, 2120| | 2121| 3.53k| {0x104cb, 3651, 1}, 2122| | 2123| 3.53k| {0x1cb9, 1591, 1}, 2124| | 2125| 3.53k| {0x04cb, 1201, 1}, 2126| | 2127| 3.53k| {0x0210, 529, 1}, 2128| | 2129| 3.53k| {0x1fcb, 2405, 1}, 2130| | 2131| 3.53k| {0x01cb, 428, 1}, 2132| | 2133| 3.53k| {0xa7cb, 646, 1}, 2134| | 2135| 3.53k| {0x2183, 2504, 1}, 2136| | 2137| 3.53k| {0x00cb, 111, 1}, 2138| | 2139| 3.53k| {0x104c8, 3642, 1}, 2140| | 2141| 3.53k| {0x2cc8, 2861, 1}, 2142| 3.53k| {0xffffffff, -1, 0}, 2143| | 2144| 3.53k| {0x1ec8, 2162, 1}, 2145| | 2146| 3.53k| {0x1fc8, 2396, 1}, 2147| | 2148| 3.53k| {0x01c8, 424, 1}, 2149| | 2150| 3.53k| {0x10571, 3681, 1}, 2151| 3.53k| {0xffffffff, -1, 0}, 2152| | 2153| 3.53k| {0x00c8, 102, 1}, 2154| | 2155| 3.53k| {0x104c6, 3636, 1}, 2156| | 2157| 3.53k| {0x2cc6, 2858, 1}, 2158| | 2159| 3.53k| {0x1f5d, 2360, 1}, 2160| | 2161| 3.53k| {0x1ec6, 2159, 1}, 2162| | 2163| 3.53k| {0x1fc6, 67, 2}, 2164| | 2165| 3.53k| {0x054e, 1441, 1}, 2166| | 2167| 3.53k| {0xa7c6, 1873, 1}, 2168| | 2169| 3.53k| {0x104c5, 3633, 1}, 2170| | 2171| 3.53k| {0x00c6, 96, 1}, 2172| | 2173| 3.53k| {0x04c5, 1192, 1}, 2174| | 2175| 3.53k| {0x16e59, 4173, 1}, 2176| | 2177| 3.53k| {0x0539, 1378, 1}, 2178| | 2179| 3.53k| {0x01c5, 420, 1}, 2180| | 2181| 3.53k| {0xa7c5, 688, 1}, 2182| 3.53k| {0xffffffff, -1, 0}, 2183| | 2184| 3.53k| {0x00c5, 92, 1}, 2185| | 2186| 3.53k| {0x0548, 1423, 1}, 2187| 3.53k| {0xffffffff, -1, 0}, 2188| | 2189| 3.53k| {0x1faf, 244, 2}, 2190| | 2191| 3.53k| {0x01af, 402, 1}, 2192| | 2193| 3.53k| {0x16e5f, 4191, 1}, 2194| | 2195| 3.53k| {0xabaf, 1795, 1}, 2196| | 2197| 3.53k| {0x212a, 27, 1}, 2198| | 2199| 3.53k| {0x1caf, 1561, 1}, 2200| | 2201| 3.53k| {0x04fc, 1276, 1}, 2202| | 2203| 3.53k| {0x1efc, 2240, 1}, 2204| | 2205| 3.53k| {0x1ffc, 96, 2}, 2206| | 2207| 3.53k| {0x01fc, 499, 1}, 2208| | 2209| 3.53k| {0x1fa5, 234, 2}, 2210| | 2211| 3.53k| {0x10d60, 3984, 1}, 2212| | 2213| 3.53k| {0x16e4f, 4143, 1}, 2214| | 2215| 3.53k| {0xaba5, 1765, 1}, 2216| 3.53k| {0xffffffff, -1, 0}, 2217| | 2218| 3.53k| {0x1ca5, 1531, 1}, 2219| | 2220| 3.53k| {0x10caf, 3924, 1}, 2221| | 2222| 3.53k| {0x1fa3, 224, 2}, 2223| | 2224| 3.53k| {0x1fa1, 214, 2}, 2225| 3.53k| {0xffffffff, -1, 0}, 2226| | 2227| 3.53k| {0xaba3, 1759, 1}, 2228| | 2229| 3.53k| {0xaba1, 1753, 1}, 2230| | 2231| 3.53k| {0x1ca3, 1525, 1}, 2232| | 2233| 3.53k| {0x1ca1, 1519, 1}, 2234| | 2235| 3.53k| {0x1f91, 174, 2}, 2236| | 2237| 3.53k| {0x0191, 369, 1}, 2238| | 2239| 3.53k| {0x10ca5, 3894, 1}, 2240| | 2241| 3.53k| {0xab91, 1705, 1}, 2242| 3.53k| {0xffffffff, -1, 0}, 2243| | 2244| 3.53k| {0x1c91, 1471, 1}, 2245| | 2246| 3.53k| {0x10421, 3549, 1}, 2247| | 2248| 3.53k| {0x2c21, 2684, 1}, 2249| | 2250| 3.53k| {0x0421, 956, 1}, 2251| | 2252| 3.53k| {0x10ca3, 3888, 1}, 2253| | 2254| 3.53k| {0x10ca1, 3882, 1}, 2255| | 2256| 3.53k| {0x10b9, 2987, 1}, 2257| 3.53k| {0xffffffff, -1, 0}, 2258| | 2259| 3.53k| {0x1f49, 2339, 1}, 2260| | 2261| 3.53k| {0x0149, 46, 2}, 2262| | 2263| 3.53k| {0x118b9, 4077, 1}, 2264| | 2265| 3.53k| {0x10c91, 3834, 1}, 2266| | 2267| 3.53k| {0x0049, 4296, 1}, 2268| | 2269| 3.53k| {0x1f87, 164, 2}, 2270| | 2271| 3.53k| {0x0187, 363, 1}, 2272| | 2273| 3.53k| {0x0520, 1330, 1}, 2274| | 2275| 3.53k| {0xab87, 1675, 1}, 2276| 3.53k| {0xffffffff, -1, 0}, 2277| | 2278| 3.53k| {0x1c87, 1056, 1}, 2279| | 2280| 3.53k| {0x2c72, 2747, 1}, 2281| | 2282| 3.53k| {0x0472, 1081, 1}, 2283| | 2284| 3.53k| {0x1e72, 2048, 1}, 2285| 3.53k| {0xffffffff, -1, 0}, 2286| | 2287| 3.53k| {0x0172, 336, 1}, 2288| | 2289| 3.53k| {0x03da, 857, 1}, 2290| | 2291| 3.53k| {0xab72, 1612, 1}, 2292| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2293| | 2294| 3.53k| {0xff21, 3372, 1}, 2295| | 2296| 3.53k| {0x10c87, 3804, 1}, 2297| | 2298| 3.53k| {0x2161, 2459, 1}, 2299| | 2300| 3.53k| {0x16e54, 4158, 1}, 2301| | 2302| 3.53k| {0x03d8, 854, 1}, 2303| | 2304| 3.53k| {0x1e32, 1951, 1}, 2305| 3.53k| {0xffffffff, -1, 0}, 2306| | 2307| 3.53k| {0x0132, 243, 1}, 2308| | 2309| 3.53k| {0xa732, 3165, 1}, 2310| | 2311| 3.53k| {0x051e, 1327, 1}, 2312| | 2313| 3.53k| {0x16e52, 4152, 1}, 2314| | 2315| 3.53k| {0x10c5, 3023, 1}, 2316| 3.53k| {0xffffffff, -1, 0}, 2317| | 2318| 3.53k| {0x2c70, 613, 1}, 2319| | 2320| 3.53k| {0x0470, 1078, 1}, 2321| | 2322| 3.53k| {0x1e70, 2045, 1}, 2323| | 2324| 3.53k| {0x03d6, 804, 1}, 2325| | 2326| 3.53k| {0x0170, 333, 1}, 2327| | 2328| 3.53k| {0x10af, 2957, 1}, 2329| | 2330| 3.53k| {0xab70, 1606, 1}, 2331| 3.53k| {0xffffffff, -1, 0}, 2332| | 2333| 3.53k| {0x0512, 1309, 1}, 2334| | 2335| 3.53k| {0x118af, 4047, 1}, 2336| 3.53k| {0xffffffff, -1, 0}, 2337| | 2338| 3.53k| {0x16e50, 4146, 1}, 2339| | 2340| 3.53k| {0x03d0, 754, 1}, 2341| 3.53k| {0xffffffff, -1, 0}, 2342| | 2343| 3.53k| {0x0510, 1306, 1}, 2344| | 2345| 3.53k| {0x10a5, 2927, 1}, 2346| | 2347| 3.53k| {0xff32, 3423, 1}, 2348| 3.53k| {0xffffffff, -1, 0}, 2349| | 2350| 3.53k| {0x10d55, 3951, 1}, 2351| | 2352| 3.53k| {0x118a5, 4017, 1}, 2353| | 2354| 3.53k| {0x047c, 1096, 1}, 2355| | 2356| 3.53k| {0x1e7c, 2063, 1}, 2357| | 2358| 3.53k| {0x10a3, 2921, 1}, 2359| | 2360| 3.53k| {0x10a1, 2915, 1}, 2361| 3.53k| {0xffffffff, -1, 0}, 2362| | 2363| 3.53k| {0xab7c, 1642, 1}, 2364| | 2365| 3.53k| {0x118a3, 4011, 1}, 2366| | 2367| 3.53k| {0x118a1, 4005, 1}, 2368| | 2369| 3.53k| {0x24b9, 2516, 1}, 2370| | 2371| 3.53k| {0x046c, 1072, 1}, 2372| | 2373| 3.53k| {0x1e6c, 2039, 1}, 2374| | 2375| 3.53k| {0x1f6c, 2378, 1}, 2376| | 2377| 3.53k| {0x016c, 327, 1}, 2378| | 2379| 3.53k| {0xa76c, 3252, 1}, 2380| | 2381| 3.53k| {0x0555, 1462, 1}, 2382| | 2383| 3.53k| {0x13fc, 1858, 1}, 2384| | 2385| 3.53k| {0x24cb, 2570, 1}, 2386| | 2387| 3.53k| {0x046a, 1069, 1}, 2388| | 2389| 3.53k| {0x1e6a, 2036, 1}, 2390| | 2391| 3.53k| {0x1f6a, 2372, 1}, 2392| | 2393| 3.53k| {0x016a, 324, 1}, 2394| | 2395| 3.53k| {0xa76a, 3249, 1}, 2396| | 2397| 3.53k| {0x0232, 577, 1}, 2398| | 2399| 3.53k| {0xa66c, 3099, 1}, 2400| | 2401| 3.53k| {0x216f, 2501, 1}, 2402| | 2403| 3.53k| {0x24c8, 2561, 1}, 2404| | 2405| 3.53k| {0x0468, 1066, 1}, 2406| | 2407| 3.53k| {0x1e68, 2033, 1}, 2408| | 2409| 3.53k| {0x1f68, 2366, 1}, 2410| | 2411| 3.53k| {0x0168, 321, 1}, 2412| | 2413| 3.53k| {0xa768, 3246, 1}, 2414| | 2415| 3.53k| {0xa66a, 3096, 1}, 2416| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2417| | 2418| 3.53k| {0x24c6, 2555, 1}, 2419| 3.53k| {0xffffffff, -1, 0}, 2420| | 2421| 3.53k| {0x1e920, 4290, 1}, 2422| | 2423| 3.53k| {0x2163, 2465, 1}, 2424| 3.53k| {0xffffffff, -1, 0}, 2425| | 2426| 3.53k| {0x216e, 2498, 1}, 2427| | 2428| 3.53k| {0xa668, 3093, 1}, 2429| | 2430| 3.53k| {0x24c5, 2552, 1}, 2431| 3.53k| {0xffffffff, -1, 0}, 2432| | 2433| 3.53k| {0x1e5a, 2011, 1}, 2434| | 2435| 3.53k| {0x10d5d, 3975, 1}, 2436| | 2437| 3.53k| {0x015a, 300, 1}, 2438| | 2439| 3.53k| {0xa75a, 3225, 1}, 2440| | 2441| 3.53k| {0x03a5, 819, 1}, 2442| | 2443| 3.53k| {0x005a, 74, 1}, 2444| 3.53k| {0xffffffff, -1, 0}, 2445| | 2446| 3.53k| {0x1f8f, 164, 2}, 2447| | 2448| 3.53k| {0x018f, 628, 1}, 2449| 3.53k| {0xffffffff, -1, 0}, 2450| | 2451| 3.53k| {0xab8f, 1699, 1}, 2452| | 2453| 3.53k| {0x03a3, 812, 1}, 2454| | 2455| 3.53k| {0x03a1, 808, 1}, 2456| | 2457| 3.53k| {0xa65a, 3072, 1}, 2458| | 2459| 3.53k| {0x16e4e, 4140, 1}, 2460| | 2461| 3.53k| {0x1e91e, 4284, 1}, 2462| 3.53k| {0xffffffff, -1, 0}, 2463| | 2464| 3.53k| {0x1e58, 2008, 1}, 2465| | 2466| 3.53k| {0x0391, 751, 1}, 2467| | 2468| 3.53k| {0x0158, 297, 1}, 2469| | 2470| 3.53k| {0xa758, 3222, 1}, 2471| | 2472| 3.53k| {0x1e46, 1981, 1}, 2473| | 2474| 3.53k| {0x0058, 68, 1}, 2475| | 2476| 3.53k| {0x10c8f, 3828, 1}, 2477| | 2478| 3.53k| {0xa746, 3195, 1}, 2479| | 2480| 3.53k| {0x16e48, 4122, 1}, 2481| | 2482| 3.53k| {0x0046, 15, 1}, 2483| | 2484| 3.53k| {0x1e912, 4248, 1}, 2485| | 2486| 3.53k| {0x04ee, 1255, 1}, 2487| | 2488| 3.53k| {0x1eee, 2219, 1}, 2489| | 2490| 3.53k| {0xa658, 3069, 1}, 2491| | 2492| 3.53k| {0x01ee, 483, 1}, 2493| | 2494| 3.53k| {0x104bf, 3615, 1}, 2495| | 2496| 3.53k| {0x1e910, 4242, 1}, 2497| | 2498| 3.53k| {0xa646, 3041, 1}, 2499| | 2500| 3.53k| {0x1e44, 1978, 1}, 2501| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2502| | 2503| 3.53k| {0xa744, 3192, 1}, 2504| | 2505| 3.53k| {0xabbf, 1843, 1}, 2506| | 2507| 3.53k| {0x0044, 9, 1}, 2508| | 2509| 3.53k| {0x1cbf, 1603, 1}, 2510| | 2511| 3.53k| {0x2cde, 2894, 1}, 2512| | 2513| 3.53k| {0x04de, 1231, 1}, 2514| | 2515| 3.53k| {0x1ede, 2195, 1}, 2516| | 2517| 3.53k| {0x0372, 724, 1}, 2518| | 2519| 3.53k| {0x01de, 459, 1}, 2520| 3.53k| {0xffffffff, -1, 0}, 2521| | 2522| 3.53k| {0xa644, 3038, 1}, 2523| | 2524| 3.53k| {0x00de, 165, 1}, 2525| | 2526| 3.53k| {0x104bd, 3609, 1}, 2527| | 2528| 3.53k| {0x2cdc, 2891, 1}, 2529| | 2530| 3.53k| {0x04dc, 1228, 1}, 2531| | 2532| 3.53k| {0x1edc, 2192, 1}, 2533| 3.53k| {0xffffffff, -1, 0}, 2534| | 2535| 3.53k| {0x10591, 3771, 1}, 2536| | 2537| 3.53k| {0xa7dc, 381, 1}, 2538| | 2539| 3.53k| {0xabbd, 1837, 1}, 2540| | 2541| 3.53k| {0x00dc, 159, 1}, 2542| | 2543| 3.53k| {0x1cbd, 1597, 1}, 2544| | 2545| 3.53k| {0x104d2, 3672, 1}, 2546| | 2547| 3.53k| {0x2cd2, 2876, 1}, 2548| | 2549| 3.53k| {0x04d2, 1213, 1}, 2550| | 2551| 3.53k| {0x1ed2, 2177, 1}, 2552| | 2553| 3.53k| {0x1fd2, 20, 3}, 2554| | 2555| 3.53k| {0x104bb, 3603, 1}, 2556| 3.53k| {0xffffffff, -1, 0}, 2557| | 2558| 3.53k| {0x0370, 721, 1}, 2559| | 2560| 3.53k| {0x00d2, 132, 1}, 2561| | 2562| 3.53k| {0x1fbb, 2393, 1}, 2563| | 2564| 3.53k| {0x0549, 1426, 1}, 2565| | 2566| 3.53k| {0x0246, 592, 1}, 2567| | 2568| 3.53k| {0xabbb, 1831, 1}, 2569| | 2570| 3.53k| {0x10587, 3744, 1}, 2571| 3.53k| {0xffffffff, -1, 0}, 2572| | 2573| 3.53k| {0x0587, 105, 2}, 2574| | 2575| 3.53k| {0x104cd, 3657, 1}, 2576| 3.53k| {0xffffffff, -1, 0}, 2577| | 2578| 3.53k| {0x04cd, 1204, 1}, 2579| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2580| | 2581| 3.53k| {0x01cd, 432, 1}, 2582| | 2583| 3.53k| {0x10572, 3684, 1}, 2584| | 2585| 3.53k| {0x2162, 2462, 1}, 2586| | 2587| 3.53k| {0x00cd, 117, 1}, 2588| | 2589| 3.53k| {0x0244, 700, 1}, 2590| | 2591| 3.53k| {0x104c9, 3645, 1}, 2592| | 2593| 3.53k| {0x104c3, 3627, 1}, 2594| | 2595| 3.53k| {0x04c9, 1198, 1}, 2596| | 2597| 3.53k| {0x04c3, 1189, 1}, 2598| | 2599| 3.53k| {0x1fc9, 2399, 1}, 2600| | 2601| 3.53k| {0x1fc3, 71, 2}, 2602| | 2603| 3.53k| {0xa7c9, 3348, 1}, 2604| 3.53k| {0xffffffff, -1, 0}, 2605| | 2606| 3.53k| {0x00c9, 105, 1}, 2607| | 2608| 3.53k| {0x00c3, 86, 1}, 2609| | 2610| 3.53k| {0x0532, 1357, 1}, 2611| | 2612| 3.53k| {0x1f9f, 204, 2}, 2613| | 2614| 3.53k| {0x019f, 679, 1}, 2615| 3.53k| {0xffffffff, -1, 0}, 2616| | 2617| 3.53k| {0xab9f, 1747, 1}, 2618| 3.53k| {0xffffffff, -1, 0}, 2619| | 2620| 3.53k| {0x1c9f, 1513, 1}, 2621| | 2622| 3.53k| {0x1f5b, 2357, 1}, 2623| | 2624| 3.53k| {0x10570, 3678, 1}, 2625| | 2626| 3.53k| {0x1f9d, 194, 2}, 2627| | 2628| 3.53k| {0x019d, 676, 1}, 2629| 3.53k| {0xffffffff, -1, 0}, 2630| | 2631| 3.53k| {0xab9d, 1741, 1}, 2632| | 2633| 3.53k| {0x1f95, 194, 2}, 2634| | 2635| 3.53k| {0x1c9d, 1507, 1}, 2636| | 2637| 3.53k| {0x10bf, 3005, 1}, 2638| | 2639| 3.53k| {0xab95, 1717, 1}, 2640| | 2641| 3.53k| {0x10c9f, 3876, 1}, 2642| | 2643| 3.53k| {0x1c95, 1483, 1}, 2644| | 2645| 3.53k| {0x118bf, 4095, 1}, 2646| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2647| | 2648| 3.53k| {0x1e9b, 2020, 1}, 2649| | 2650| 3.53k| {0x1f9b, 184, 2}, 2651| 3.53k| {0xffffffff, -1, 0}, 2652| | 2653| 3.53k| {0x10c9d, 3870, 1}, 2654| | 2655| 3.53k| {0xab9b, 1735, 1}, 2656| | 2657| 3.53k| {0x1057c, 3711, 1}, 2658| | 2659| 3.53k| {0x1c9b, 1501, 1}, 2660| | 2661| 3.53k| {0x10c95, 3846, 1}, 2662| | 2663| 3.53k| {0x1e99, 42, 2}, 2664| | 2665| 3.53k| {0x1f99, 174, 2}, 2666| 3.53k| {0xffffffff, -1, 0}, 2667| | 2668| 3.53k| {0x10bd, 2999, 1}, 2669| | 2670| 3.53k| {0xab99, 1729, 1}, 2671| | 2672| 3.53k| {0x16e55, 4161, 1}, 2673| | 2674| 3.53k| {0x1c99, 1495, 1}, 2675| | 2676| 3.53k| {0x118bd, 4089, 1}, 2677| | 2678| 3.53k| {0x038f, 848, 1}, 2679| | 2680| 3.53k| {0x10c9b, 3864, 1}, 2681| | 2682| 3.53k| {0x1f93, 184, 2}, 2683| | 2684| 3.53k| {0x0193, 637, 1}, 2685| 3.53k| {0xffffffff, -1, 0}, 2686| | 2687| 3.53k| {0xab93, 1711, 1}, 2688| 3.53k| {0xffffffff, -1, 0}, 2689| | 2690| 3.53k| {0x1c93, 1477, 1}, 2691| | 2692| 3.53k| {0x1f4b, 2345, 1}, 2693| | 2694| 3.53k| {0x10c99, 3858, 1}, 2695| | 2696| 3.53k| {0x10bb, 2993, 1}, 2697| 3.53k| {0xffffffff, -1, 0}, 2698| | 2699| 3.53k| {0x004b, 27, 1}, 2700| | 2701| 3.53k| {0x0143, 267, 1}, 2702| | 2703| 3.53k| {0x118bb, 4083, 1}, 2704| | 2705| 3.53k| {0x1e921, 4293, 1}, 2706| | 2707| 3.53k| {0x0043, 6, 1}, 2708| | 2709| 3.53k| {0x10d5a, 3966, 1}, 2710| | 2711| 3.53k| {0x10c93, 3840, 1}, 2712| | 2713| 3.53k| {0x1f81, 134, 2}, 2714| | 2715| 3.53k| {0x0181, 616, 1}, 2716| | 2717| 3.53k| {0x10cd, 3029, 1}, 2718| | 2719| 3.53k| {0xab81, 1657, 1}, 2720| | 2721| 3.53k| {0x03ee, 887, 1}, 2722| | 2723| 3.53k| {0x1c81, 915, 1}, 2724| | 2725| 3.53k| {0x2c7e, 583, 1}, 2726| | 2727| 3.53k| {0x047e, 1099, 1}, 2728| | 2729| 3.53k| {0x1e7e, 2066, 1}, 2730| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2731| | 2732| 3.53k| {0xa77e, 3264, 1}, 2733| | 2734| 3.53k| {0xab7e, 1648, 1}, 2735| | 2736| 3.53k| {0x10c3, 3017, 1}, 2737| | 2738| 3.53k| {0x0145, 270, 1}, 2739| | 2740| 3.53k| {0x10d58, 3960, 1}, 2741| | 2742| 3.53k| {0x10c81, 3786, 1}, 2743| | 2744| 3.53k| {0x0045, 12, 1}, 2745| | 2746| 3.53k| {0x1058f, 3765, 1}, 2747| | 2748| 3.53k| {0x03de, 863, 1}, 2749| 3.53k| {0xffffffff, -1, 0}, 2750| | 2751| 3.53k| {0x24bf, 2534, 1}, 2752| | 2753| 3.53k| {0x0476, 1087, 1}, 2754| | 2755| 3.53k| {0x1e76, 2054, 1}, 2756| | 2757| 3.53k| {0x16e5d, 4185, 1}, 2758| | 2759| 3.53k| {0x0176, 342, 1}, 2760| 3.53k| {0xffffffff, -1, 0}, 2761| | 2762| 3.53k| {0xab76, 1624, 1}, 2763| | 2764| 3.53k| {0x03dc, 860, 1}, 2765| | 2766| 3.53k| {0x0466, 1063, 1}, 2767| | 2768| 3.53k| {0x1e66, 2030, 1}, 2769| 3.53k| {0xffffffff, -1, 0}, 2770| | 2771| 3.53k| {0x0166, 318, 1}, 2772| | 2773| 3.53k| {0xa766, 3243, 1}, 2774| | 2775| 3.53k| {0x1e5e, 2017, 1}, 2776| | 2777| 3.53k| {0x0546, 1417, 1}, 2778| | 2779| 3.53k| {0x015e, 306, 1}, 2780| | 2781| 3.53k| {0xa75e, 3231, 1}, 2782| | 2783| 3.53k| {0x1e5c, 2014, 1}, 2784| | 2785| 3.53k| {0x24bd, 2528, 1}, 2786| | 2787| 3.53k| {0x015c, 303, 1}, 2788| | 2789| 3.53k| {0xa75c, 3228, 1}, 2790| | 2791| 3.53k| {0x0243, 354, 1}, 2792| | 2793| 3.53k| {0xa666, 3090, 1}, 2794| 3.53k| {0xffffffff, -1, 0}, 2795| | 2796| 3.53k| {0x1e42, 1975, 1}, 2797| 3.53k| {0xffffffff, -1, 0}, 2798| | 2799| 3.53k| {0xa65e, 3078, 1}, 2800| | 2801| 3.53k| {0xa742, 3189, 1}, 2802| | 2803| 3.53k| {0x0544, 1411, 1}, 2804| | 2805| 3.53k| {0x0042, 3, 1}, 2806| | 2807| 3.53k| {0xa65c, 3075, 1}, 2808| | 2809| 3.53k| {0x0053, 52, 1}, 2810| 3.53k| {0xffffffff, -1, 0}, 2811| | 2812| 3.53k| {0x24bb, 2522, 1}, 2813| | 2814| 3.53k| {0x104cf, 3663, 1}, 2815| | 2816| 3.53k| {0x1e3a, 1963, 1}, 2817| | 2818| 3.53k| {0x1f3a, 2318, 1}, 2819| | 2820| 3.53k| {0xa642, 3035, 1}, 2821| | 2822| 3.53k| {0xa73a, 3177, 1}, 2823| | 2824| 3.53k| {0x01cf, 435, 1}, 2825| | 2826| 3.53k| {0x0141, 264, 1}, 2827| | 2828| 3.53k| {0x0245, 709, 1}, 2829| | 2830| 3.53k| {0x00cf, 123, 1}, 2831| | 2832| 3.53k| {0x0041, 0, 1}, 2833| | 2834| 3.53k| {0x24cd, 2576, 1}, 2835| 3.53k| {0xffffffff, -1, 0}, 2836| | 2837| 3.53k| {0x04fa, 1273, 1}, 2838| | 2839| 3.53k| {0x1efa, 2237, 1}, 2840| | 2841| 3.53k| {0x1ffa, 2426, 1}, 2842| | 2843| 3.53k| {0x01fa, 496, 1}, 2844| | 2845| 3.53k| {0x039f, 801, 1}, 2846| 3.53k| {0xffffffff, -1, 0}, 2847| | 2848| 3.53k| {0x047a, 1093, 1}, 2849| | 2850| 3.53k| {0x1e7a, 2060, 1}, 2851| | 2852| 3.53k| {0x24c9, 2564, 1}, 2853| | 2854| 3.53k| {0x24c3, 2546, 1}, 2855| | 2856| 3.53k| {0x16e49, 4125, 1}, 2857| | 2858| 3.53k| {0xab7a, 1636, 1}, 2859| | 2860| 3.53k| {0x039d, 795, 1}, 2861| | 2862| 3.53k| {0xff3a, 3447, 1}, 2863| | 2864| 3.53k| {0x0051, 46, 1}, 2865| 3.53k| {0xffffffff, -1, 0}, 2866| | 2867| 3.53k| {0x0395, 764, 1}, 2868| | 2869| 3.53k| {0x04f4, 1264, 1}, 2870| | 2871| 3.53k| {0x1ef4, 2228, 1}, 2872| | 2873| 3.53k| {0x1ff4, 101, 2}, 2874| | 2875| 3.53k| {0x01f4, 490, 1}, 2876| | 2877| 3.53k| {0x2cf2, 2909, 1}, 2878| | 2879| 3.53k| {0x04f2, 1261, 1}, 2880| | 2881| 3.53k| {0x1ef2, 2225, 1}, 2882| | 2883| 3.53k| {0x1ff2, 257, 2}, 2884| | 2885| 3.53k| {0x01f2, 486, 1}, 2886| | 2887| 3.53k| {0x039b, 788, 1}, 2888| 3.53k| {0xffffffff, -1, 0}, 2889| | 2890| 3.53k| {0x04ec, 1252, 1}, 2891| | 2892| 3.53k| {0x1eec, 2216, 1}, 2893| | 2894| 3.53k| {0x1fec, 2450, 1}, 2895| | 2896| 3.53k| {0x01ec, 480, 1}, 2897| 3.53k| {0xffffffff, -1, 0}, 2898| | 2899| 3.53k| {0x10d5b, 3969, 1}, 2900| | 2901| 3.53k| {0x0399, 779, 1}, 2902| | 2903| 3.53k| {0x04ea, 1249, 1}, 2904| | 2905| 3.53k| {0x1eea, 2213, 1}, 2906| | 2907| 3.53k| {0x1fea, 2420, 1}, 2908| | 2909| 3.53k| {0x01ea, 477, 1}, 2910| | 2911| 3.53k| {0x023a, 2732, 1}, 2912| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 2913| | 2914| 3.53k| {0x0241, 589, 1}, 2915| | 2916| 3.53k| {0x0393, 758, 1}, 2917| | 2918| 3.53k| {0x04e8, 1246, 1}, 2919| | 2920| 3.53k| {0x1ee8, 2210, 1}, 2921| | 2922| 3.53k| {0x1fe8, 2444, 1}, 2923| | 2924| 3.53k| {0x01e8, 474, 1}, 2925| | 2926| 3.53k| {0x04e6, 1243, 1}, 2927| | 2928| 3.53k| {0x1ee6, 2207, 1}, 2929| | 2930| 3.53k| {0x1fe6, 88, 2}, 2931| | 2932| 3.53k| {0x01e6, 471, 1}, 2933| 3.53k| {0xffffffff, -1, 0}, 2934| | 2935| 3.53k| {0x10595, 3780, 1}, 2936| | 2937| 3.53k| {0x04e4, 1240, 1}, 2938| | 2939| 3.53k| {0x1ee4, 2204, 1}, 2940| | 2941| 3.53k| {0x1fe4, 80, 2}, 2942| | 2943| 3.53k| {0x01e4, 468, 1}, 2944| | 2945| 3.53k| {0x2ce0, 2897, 1}, 2946| | 2947| 3.53k| {0x04e0, 1234, 1}, 2948| | 2949| 3.53k| {0x1ee0, 2198, 1}, 2950| 3.53k| {0xffffffff, -1, 0}, 2951| | 2952| 3.53k| {0x01e0, 462, 1}, 2953| | 2954| 3.53k| {0x104ce, 3660, 1}, 2955| | 2956| 3.53k| {0x2cce, 2870, 1}, 2957| | 2958| 3.53k| {0x1e40, 1972, 1}, 2959| | 2960| 3.53k| {0x1ece, 2171, 1}, 2961| 3.53k| {0xffffffff, -1, 0}, 2962| | 2963| 3.53k| {0xa740, 3186, 1}, 2964| | 2965| 3.53k| {0x1e38, 1960, 1}, 2966| | 2967| 3.53k| {0x1f38, 2312, 1}, 2968| | 2969| 3.53k| {0x00ce, 120, 1}, 2970| | 2971| 3.53k| {0xa738, 3174, 1}, 2972| | 2973| 3.53k| {0x0345, 779, 1}, 2974| | 2975| 3.53k| {0x1e36, 1957, 1}, 2976| | 2977| 3.53k| {0x104d1, 3669, 1}, 2978| | 2979| 3.53k| {0x0136, 249, 1}, 2980| | 2981| 3.53k| {0xa736, 3171, 1}, 2982| | 2983| 3.53k| {0xa640, 3032, 1}, 2984| | 2985| 3.53k| {0x1e34, 1954, 1}, 2986| | 2987| 3.53k| {0x01d1, 438, 1}, 2988| | 2989| 3.53k| {0x0134, 246, 1}, 2990| | 2991| 3.53k| {0xa734, 3168, 1}, 2992| | 2993| 3.53k| {0x00d1, 129, 1}, 2994| | 2995| 3.53k| {0x0376, 727, 1}, 2996| | 2997| 3.53k| {0x1041b, 3531, 1}, 2998| | 2999| 3.53k| {0x2c1b, 2666, 1}, 3000| | 3001| 3.53k| {0x041b, 937, 1}, 3002| | 3003| 3.53k| {0x054b, 1432, 1}, 3004| | 3005| 3.53k| {0x1f1b, 2279, 1}, 3006| | 3007| 3.53k| {0x1f3f, 2333, 1}, 3008| | 3009| 3.53k| {0x013f, 261, 1}, 3010| | 3011| 3.53k| {0x0543, 1408, 1}, 3012| | 3013| 3.53k| {0xff38, 3441, 1}, 3014| | 3015| 3.53k| {0x10417, 3519, 1}, 3016| | 3017| 3.53k| {0x2c17, 2654, 1}, 3018| | 3019| 3.53k| {0x0417, 925, 1}, 3020| | 3021| 3.53k| {0x10581, 3726, 1}, 3022| | 3023| 3.53k| {0xff36, 3435, 1}, 3024| | 3025| 3.53k| {0x13fa, 1852, 1}, 3026| | 3027| 3.53k| {0x10419, 3525, 1}, 3028| | 3029| 3.53k| {0x2c19, 2660, 1}, 3030| | 3031| 3.53k| {0x0419, 931, 1}, 3032| | 3033| 3.53k| {0xff34, 3429, 1}, 3034| | 3035| 3.53k| {0x1f19, 2273, 1}, 3036| 3.53k| {0xffffffff, -1, 0}, 3037| | 3038| 3.53k| {0x1057e, 3717, 1}, 3039| | 3040| 3.53k| {0x16e5a, 4176, 1}, 3041| | 3042| 3.53k| {0x10415, 3513, 1}, 3043| | 3044| 3.53k| {0x2c15, 2648, 1}, 3045| | 3046| 3.53k| {0x0415, 919, 1}, 3047| 3.53k| {0xffffffff, -1, 0}, 3048| | 3049| 3.53k| {0x0545, 1414, 1}, 3050| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3051| | 3052| 3.53k| {0x10413, 3507, 1}, 3053| | 3054| 3.53k| {0x2c13, 2642, 1}, 3055| | 3056| 3.53k| {0x0413, 912, 1}, 3057| | 3058| 3.53k| {0x10d5e, 3978, 1}, 3059| | 3060| 3.53k| {0x03cf, 851, 1}, 3061| 3.53k| {0xffffffff, -1, 0}, 3062| | 3063| 3.53k| {0x10576, 3696, 1}, 3064| | 3065| 3.53k| {0x10d5c, 3972, 1}, 3066| 3.53k| {0xffffffff, -1, 0}, 3067| | 3068| 3.53k| {0x16e58, 4170, 1}, 3069| | 3070| 3.53k| {0x10405, 3465, 1}, 3071| | 3072| 3.53k| {0x2c05, 2600, 1}, 3073| | 3074| 3.53k| {0x0405, 1020, 1}, 3075| | 3076| 3.53k| {0x16e46, 4116, 1}, 3077| | 3078| 3.53k| {0x03fa, 899, 1}, 3079| | 3080| 3.53k| {0x24cf, 2582, 1}, 3081| | 3082| 3.53k| {0x10d53, 3945, 1}, 3083| 3.53k| {0xffffffff, -1, 0}, 3084| | 3085| 3.53k| {0x2126, 832, 1}, 3086| | 3087| 3.53k| {0x1040f, 3495, 1}, 3088| | 3089| 3.53k| {0x2c0f, 2630, 1}, 3090| | 3091| 3.53k| {0x040f, 1050, 1}, 3092| | 3093| 3.53k| {0xfb17, 117, 2}, 3094| | 3095| 3.53k| {0x1f0f, 2267, 1}, 3096| | 3097| 3.53k| {0x1040d, 3489, 1}, 3098| | 3099| 3.53k| {0x2c0d, 2624, 1}, 3100| | 3101| 3.53k| {0x040d, 1044, 1}, 3102| | 3103| 3.53k| {0x16e44, 4110, 1}, 3104| | 3105| 3.53k| {0x1f0d, 2261, 1}, 3106| 3.53k| {0xffffffff, -1, 0}, 3107| | 3108| 3.53k| {0x0542, 1405, 1}, 3109| | 3110| 3.53k| {0x03f4, 774, 1}, 3111| | 3112| 3.53k| {0x0553, 1456, 1}, 3113| | 3114| 3.53k| {0x1040b, 3483, 1}, 3115| | 3116| 3.53k| {0x2c0b, 2618, 1}, 3117| | 3118| 3.53k| {0x040b, 1038, 1}, 3119| | 3120| 3.53k| {0xfb15, 113, 2}, 3121| | 3122| 3.53k| {0x1f0b, 2255, 1}, 3123| | 3124| 3.53k| {0x10403, 3459, 1}, 3125| | 3126| 3.53k| {0x2c03, 2594, 1}, 3127| | 3128| 3.53k| {0x0403, 1014, 1}, 3129| | 3130| 3.53k| {0x053a, 1381, 1}, 3131| | 3132| 3.53k| {0x03ec, 884, 1}, 3133| | 3134| 3.53k| {0xfb13, 121, 2}, 3135| | 3136| 3.53k| {0x0541, 1402, 1}, 3137| | 3138| 3.53k| {0x10d51, 3939, 1}, 3139| | 3140| 3.53k| {0x10409, 3477, 1}, 3141| | 3142| 3.53k| {0x2c09, 2612, 1}, 3143| | 3144| 3.53k| {0x0409, 1032, 1}, 3145| | 3146| 3.53k| {0x03ea, 881, 1}, 3147| | 3148| 3.53k| {0x1f09, 2249, 1}, 3149| | 3150| 3.53k| {0x1f3b, 2321, 1}, 3151| | 3152| 3.53k| {0x013b, 255, 1}, 3153| | 3154| 3.53k| {0xfb05, 29, 2}, 3155| | 3156| 3.53k| {0x10401, 3453, 1}, 3157| | 3158| 3.53k| {0x2c01, 2588, 1}, 3159| | 3160| 3.53k| {0x0401, 1008, 1}, 3161| | 3162| 3.53k| {0x1057a, 3708, 1}, 3163| | 3164| 3.53k| {0x03e8, 878, 1}, 3165| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3166| | 3167| 3.53k| {0x0551, 1450, 1}, 3168| | 3169| 3.53k| {0x03e6, 875, 1}, 3170| | 3171| 3.53k| {0x04f8, 1270, 1}, 3172| | 3173| 3.53k| {0x1ef8, 2234, 1}, 3174| | 3175| 3.53k| {0x1ff8, 2414, 1}, 3176| | 3177| 3.53k| {0x01f8, 493, 1}, 3178| 3.53k| {0xffffffff, -1, 0}, 3179| | 3180| 3.53k| {0x03e4, 872, 1}, 3181| | 3182| 3.53k| {0x04f6, 1267, 1}, 3183| | 3184| 3.53k| {0x1ef6, 2231, 1}, 3185| | 3186| 3.53k| {0x1ff6, 92, 2}, 3187| | 3188| 3.53k| {0x01f6, 372, 1}, 3189| | 3190| 3.53k| {0x03e0, 866, 1}, 3191| 3.53k| {0xffffffff, -1, 0}, 3192| | 3193| 3.53k| {0x2cd4, 2879, 1}, 3194| | 3195| 3.53k| {0x04d4, 1216, 1}, 3196| | 3197| 3.53k| {0x1ed4, 2180, 1}, 3198| | 3199| 3.53k| {0x0179, 345, 1}, 3200| | 3201| 3.53k| {0xa779, 3258, 1}, 3202| | 3203| 3.53k| {0xab79, 1633, 1}, 3204| | 3205| 3.53k| {0xfb03, 0, 3}, 3206| | 3207| 3.53k| {0x00d4, 138, 1}, 3208| | 3209| 3.53k| {0x1e3c, 1966, 1}, 3210| | 3211| 3.53k| {0x1f3c, 2324, 1}, 3212| 3.53k| {0xffffffff, -1, 0}, 3213| | 3214| 3.53k| {0xa73c, 3180, 1}, 3215| | 3216| 3.53k| {0x10423, 3555, 1}, 3217| | 3218| 3.53k| {0x2c23, 2690, 1}, 3219| | 3220| 3.53k| {0x0423, 965, 1}, 3221| | 3222| 3.53k| {0x24ce, 2579, 1}, 3223| | 3224| 3.53k| {0x03d1, 774, 1}, 3225| | 3226| 3.53k| {0x2c2d, 2720, 1}, 3227| | 3228| 3.53k| {0x042d, 996, 1}, 3229| | 3230| 3.53k| {0x16e5b, 4179, 1}, 3231| | 3232| 3.53k| {0x1f2d, 2303, 1}, 3233| 3.53k| {0xffffffff, -1, 0}, 3234| | 3235| 3.53k| {0xfb01, 8, 2}, 3236| | 3237| 3.53k| {0x2c29, 2708, 1}, 3238| | 3239| 3.53k| {0x0429, 983, 1}, 3240| | 3241| 3.53k| {0x023b, 580, 1}, 3242| | 3243| 3.53k| {0x1f29, 2291, 1}, 3244| | 3245| 3.53k| {0x1041f, 3543, 1}, 3246| | 3247| 3.53k| {0x2c1f, 2678, 1}, 3248| | 3249| 3.53k| {0x041f, 950, 1}, 3250| | 3251| 3.53k| {0x10411, 3501, 1}, 3252| | 3253| 3.53k| {0x2c11, 2636, 1}, 3254| | 3255| 3.53k| {0x0411, 905, 1}, 3256| | 3257| 3.53k| {0x10407, 3471, 1}, 3258| | 3259| 3.53k| {0x2c07, 2606, 1}, 3260| | 3261| 3.53k| {0x0407, 1026, 1}, 3262| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3263| | 3264| 3.53k| {0xff23, 3378, 1}, 3265| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3266| | 3267| 3.53k| {0x0540, 1399, 1}, 3268| | 3269| 3.53k| {0xff2d, 3408, 1}, 3270| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3271| | 3272| 3.53k| {0x0538, 1375, 1}, 3273| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3274| | 3275| 3.53k| {0xff29, 3396, 1}, 3276| 3.53k| {0xffffffff, -1, 0}, 3277| | 3278| 3.53k| {0x0536, 1369, 1}, 3279| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3280| | 3281| 3.53k| {0x0534, 1363, 1}, 3282| 3.53k| {0xffffffff, -1, 0}, 3283| | 3284| 3.53k| {0x16e4b, 4131, 1}, 3285| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3286| | 3287| 3.53k| {0x16e43, 4107, 1}, 3288| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3289| | 3290| 3.53k| {0x053f, 1396, 1}, 3291| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3292| 3.53k| {0xffffffff, -1, 0}, 3293| | 3294| 3.53k| {0x216d, 2495, 1}, 3295| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3296| | 3297| 3.53k| {0x216b, 2489, 1}, 3298| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3299| | 3300| 3.53k| {0x16e45, 4113, 1}, 3301| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3302| | 3303| 3.53k| {0x13f8, 1846, 1}, 3304| | 3305| 3.53k| {0x2169, 2483, 1}, 3306| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3307| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3308| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3309| | 3310| 3.53k| {0x16e5e, 4188, 1}, 3311| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3312| | 3313| 3.53k| {0x16e5c, 4182, 1}, 3314| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3315| 3.53k| {0xffffffff, -1, 0}, 3316| | 3317| 3.53k| {0x16e42, 4104, 1}, 3318| 3.53k| {0xffffffff, -1, 0}, 3319| | 3320| 3.53k| {0x16e53, 4155, 1}, 3321| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3322| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3323| 3.53k| {0xffffffff, -1, 0}, 3324| | 3325| 3.53k| {0x16e41, 4101, 1}, 3326| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3327| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3328| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3329| | 3330| 3.53k| {0x053b, 1384, 1}, 3331| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3332| | 3333| 3.53k| {0x16e51, 4149, 1}, 3334| | 3335| 3.53k| {0x1e91b, 4275, 1}, 3336| 3.53k| {0xffffffff, -1, 0}, 3337| | 3338| 3.53k| {0x2160, 2456, 1}, 3339| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3340| 3.53k| {0xffffffff, -1, 0}, 3341| | 3342| 3.53k| {0x1e917, 4263, 1}, 3343| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3344| | 3345| 3.53k| {0x212b, 92, 1}, 3346| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3347| | 3348| 3.53k| {0x1e919, 4269, 1}, 3349| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3350| | 3351| 3.53k| {0x10579, 3705, 1}, 3352| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3353| | 3354| 3.53k| {0x1e915, 4257, 1}, 3355| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3356| | 3357| 3.53k| {0x053c, 1387, 1}, 3358| 3.53k| {0xffffffff, -1, 0}, 3359| | 3360| 3.53k| {0x1e913, 4251, 1}, 3361| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3362| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3363| | 3364| 3.53k| {0x1e905, 4209, 1}, 3365| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3366| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3367| | 3368| 3.53k| {0x1e90f, 4239, 1}, 3369| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3370| | 3371| 3.53k| {0x1e90d, 4233, 1}, 3372| | 3373| 3.53k| {0x16e40, 4098, 1}, 3374| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3375| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3376| | 3377| 3.53k| {0x1e90b, 4227, 1}, 3378| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3379| | 3380| 3.53k| {0x1e903, 4203, 1}, 3381| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3382| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3383| | 3384| 3.53k| {0x1e909, 4221, 1}, 3385| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3386| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3387| | 3388| 3.53k| {0x1e901, 4197, 1}, 3389| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3390| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3391| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3392| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3393| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3394| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3395| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3396| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3397| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3398| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3399| | 3400| 3.53k| {0x1e91f, 4287, 1}, 3401| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3402| | 3403| 3.53k| {0x1e911, 4245, 1}, 3404| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3405| | 3406| 3.53k| {0x1e907, 4215, 1}, 3407| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3408| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3409| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3410| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3411| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3412| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3413| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3414| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3415| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3416| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3417| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3418| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3419| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3420| | 3421| 3.53k| {0x2132, 2453, 1}, 3422| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3423| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3424| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3425| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3426| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3427| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3428| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3429| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3430| | 3431| 3.53k| {0x216c, 2492, 1}, 3432| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3433| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3434| | 3435| 3.53k| {0x216a, 2486, 1}, 3436| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3437| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3438| | 3439| 3.53k| {0x2168, 2480, 1}, 3440| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3441| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3442| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3443| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3444| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3445| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3446| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3447| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3448| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3449| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3450| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3451| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3452| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3453| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3454| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3455| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3456| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3457| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3458| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3459| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3460| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3461| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3462| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3463| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3464| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3465| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3466| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3467| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3468| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3469| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3470| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3471| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3472| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3473| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3474| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3475| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3476| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3477| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3478| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3479| 3.53k| {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, {0xffffffff, -1, 0}, 3480| | 3481| 3.53k| {0x2166, 2474, 1} 3482| 3.53k| }; 3483| | 3484| | 3485| 3.53k| { 3486| 3.53k| int key = hash(&code); 3487| | 3488| 3.53k| if (key <= MAX_HASH_VALUE) ------------------ | | 42| 3.53k|#define MAX_HASH_VALUE 2248 ------------------ | Branch (3488:11): [True: 3.53k, False: 0] ------------------ 3489| 3.53k| { 3490| 3.53k| OnigCodePoint gcode = wordlist[key].code; 3491| | 3492| 3.53k| if (code == gcode && wordlist[key].index >= 0) ------------------ | Branch (3492:15): [True: 0, False: 3.53k] | Branch (3492:32): [True: 0, False: 0] ------------------ 3493| 0| return &wordlist[key]; 3494| 3.53k| } 3495| 3.53k| } 3496| 3.53k| return 0; 3497| 3.53k|} unicode_unfold_key.c:hash: 55| 3.53k|{ 56| 3.53k| static const unsigned short asso_values[] = 57| 3.53k| { 58| 3.53k| 9, 7, 4, 52, 130, 1, 169, 2249, 2249, 2249, 59| 3.53k| 2249, 2249, 2249, 21, 155, 2249, 2249, 78, 2249, 2249, 60| 3.53k| 100, 2249, 2249, 2249, 2249, 84, 2249, 2249, 2249, 8, 61| 3.53k| 2249, 2, 3, 2249, 834, 718, 1614, 141, 1598, 712, 62| 3.53k| 1570, 694, 1668, 706, 1606, 0, 1593, 680, 1584, 651, 63| 3.53k| 1579, 1006, 1665, 1000, 1560, 688, 1553, 410, 1539, 645, 64| 3.53k| 1545, 639, 1530, 633, 269, 988, 1662, 966, 1122, 817, 65| 3.53k| 1647, 751, 994, 743, 379, 789, 1657, 261, 959, 783, 66| 3.53k| 1651, 771, 599, 826, 381, 1151, 286, 1521, 206, 1516, 67| 3.53k| 68, 1511, 915, 1431, 1607, 1640, 697, 671, 1531, 1507, 68| 3.53k| 1434, 1420, 1367, 1257, 1387, 1243, 717, 920, 1125, 613, 69| 3.53k| 1363, 331, 178, 909, 774, 843, 1451, 829, 1422, 822, 70| 3.53k| 1026, 724, 510, 1239, 754, 1222, 1324, 1413, 1072, 1409, 71| 3.53k| 764, 949, 316, 473, 384, 27, 169, 1405, 63, 1206, 72| 3.53k| 888, 1197, 879, 1189, 873, 386, 371, 1161, 903, 1139, 73| 3.53k| 807, 347, 613, 1398, 272, 197, 1633, 1449, 279, 1180, 74| 3.53k| 1, 1383, 286, 510, 1374, 490, 228, 15, 5, 398, 75| 3.53k| 1130, 595, 6, 464, 363, 574, 566, 457, 1228, 35, 76| 3.53k| 1112, 357, 1357, 324, 1330, 240, 158, 220, 1348, 432, 77| 3.53k| 1340, 548, 1326, 539, 1318, 97, 1106, 127, 1105, 85, 78| 3.53k| 1098, 76, 902, 211, 500, 189, 848, 118, 760, 106, 79| 3.53k| 1088, 151, 866, 56, 895, 419, 584, 315, 856, 66, 80| 3.53k| 1048, 303, 1290, 295, 1275, 274, 1257, 805, 657, 443, 81| 3.53k| 1312, 531, 1081, 1074, 253, 1065, 1311, 482, 1056, 561, 82| 3.53k| 1301, 1508, 1433, 1043, 1520, 1285, 929, 1634, 392, 1034, 83| 3.53k| 183, 1022, 42, 1014, 246, 1275, 26, 1266, 76, 1502, 84| 3.53k| 2249, 604, 70, 1497, 2249, 1491, 50, 1487, 41, 1478, 85| 3.53k| 342, 1471, 26, 1251, 2249, 666, 88, 1465, 19, 1460, 86| 3.53k| 46, 1627, 44, 1621, 207, 1443, 13, 1096, 17, 427, 87| 3.53k| 9 88| 3.53k| }; 89| 3.53k| return asso_values[(unsigned char)onig_codes_byte_at(codes, 2)+35] + asso_values[(unsigned char)onig_codes_byte_at(codes, 1)+1] + asso_values[(unsigned char)onig_codes_byte_at(codes, 0)]; 90| 3.53k|} utf8.c:mbc_enc_len: 72| 93.1M|{ 73| 93.1M| return EncLen_UTF8[*p]; 74| 93.1M|} utf8.c:mbc_to_code: 102| 154k|{ 103| 154k| int c, len; 104| 154k| OnigCodePoint n; 105| | 106| 154k| len = mbc_enc_len(p); 107| 154k| if (len > (int )(end - p)) len = (int )(end - p); ------------------ | Branch (107:7): [True: 0, False: 154k] ------------------ 108| | 109| 154k| c = *p++; 110| 154k| if (len > 1) { ------------------ | Branch (110:7): [True: 19, False: 154k] ------------------ 111| 19| len--; 112| 19| n = c & ((1 << (6 - len)) - 1); 113| 38| while (len--) { ------------------ | Branch (113:12): [True: 19, False: 19] ------------------ 114| 19| c = *p++; 115| 19| n = (n << 6) | (c & ((1 << 6) - 1)); 116| 19| } 117| 19| return n; 118| 19| } 119| 154k| else { 120| |#ifdef USE_INVALID_CODE_SCHEME 121| | if (c > 0xfd) { 122| | return ((c == 0xfe) ? INVALID_CODE_FE : INVALID_CODE_FF); 123| | } 124| |#endif 125| 154k| return (OnigCodePoint )c; 126| 154k| } 127| 154k|} utf8.c:code_to_mbclen: 131| 6.18k|{ 132| 6.18k| if ((code & 0xffffff80) == 0) return 1; ------------------ | Branch (132:12): [True: 6.18k, False: 0] ------------------ 133| 0| else if ((code & 0xfffff800) == 0) return 2; ------------------ | Branch (133:12): [True: 0, False: 0] ------------------ 134| 0| else if ((code & 0xffff0000) == 0) return 3; ------------------ | Branch (134:12): [True: 0, False: 0] ------------------ 135| 0| else if ((code & 0xffe00000) == 0) return 4; ------------------ | Branch (135:12): [True: 0, False: 0] ------------------ 136| |#ifndef USE_RFC3629_RANGE 137| | else if ((code & 0xfc000000) == 0) return 5; 138| | else if ((code & 0x80000000) == 0) return 6; 139| |#endif 140| |#ifdef USE_INVALID_CODE_SCHEME 141| | else if (code == INVALID_CODE_FE) return 1; 142| | else if (code == INVALID_CODE_FF) return 1; 143| |#endif 144| 0| else 145| 0| return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 644| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ 146| 6.18k|} utf8.c:get_case_fold_codes_by_str: 259| 2.80k|{ 260| 2.80k| return onigenc_unicode_get_case_fold_codes_by_str(ONIG_ENCODING_UTF8, ------------------ | | 205| 2.80k|#define ONIG_ENCODING_UTF8 (&OnigEncodingUTF8) ------------------ 261| 2.80k| flag, p, end, items); 262| 2.80k|} utf8.c:left_adjust_char_head: 246| 43.0k|{ 247| 43.0k| const UChar *p; 248| | 249| 43.0k| if (s <= start) return (UChar* )s; ------------------ | Branch (249:7): [True: 8, False: 43.0k] ------------------ 250| 43.0k| p = s; 251| | 252| 45.4k| while (!utf8_islead(*p) && p > start) p--; ------------------ | | 44| 90.8k|#define utf8_islead(c) ((UChar )((c) & 0xc0) != 0x80) ------------------ | Branch (252:10): [True: 2.32k, False: 43.0k] | Branch (252:30): [True: 2.32k, False: 0] ------------------ 253| 43.0k| return (UChar* )p; 254| 43.0k|} utf8.c:is_valid_mbc_string: 78| 134k|{ 79| 134k| int i, len; 80| | 81| 366k| while (p < end) { ------------------ | Branch (81:10): [True: 232k, False: 134k] ------------------ 82| 232k| if (! utf8_islead(*p)) ------------------ | | 44| 232k|#define utf8_islead(c) ((UChar )((c) & 0xc0) != 0x80) ------------------ | Branch (82:9): [True: 0, False: 232k] ------------------ 83| 0| return FALSE; ------------------ | | 63| 0|#define FALSE 0 ------------------ 84| | 85| 232k| len = mbc_enc_len(p++); 86| 232k| if (len > 1) { ------------------ | Branch (86:9): [True: 38, False: 232k] ------------------ 87| 76| for (i = 1; i < len; i++) { ------------------ | Branch (87:19): [True: 38, False: 38] ------------------ 88| 38| if (p == end) ------------------ | Branch (88:13): [True: 0, False: 38] ------------------ 89| 0| return FALSE; ------------------ | | 63| 0|#define FALSE 0 ------------------ 90| | 91| 38| if (! utf8_istail(*p++)) ------------------ | | 45| 38|#define utf8_istail(c) ((UChar )((c) & 0xc0) == 0x80) ------------------ | Branch (91:13): [True: 0, False: 38] ------------------ 92| 0| return FALSE; ------------------ | | 63| 0|#define FALSE 0 ------------------ 93| 38| } 94| 38| } 95| 232k| } 96| | 97| 134k| return TRUE; ------------------ | | 59| 134k|#define TRUE 1 ------------------ 98| 134k|}