binop_plus: 85| 100k|jv binop_plus(jv a, jv b) { 86| 100k| if (jv_get_kind(a) == JV_KIND_NULL) { ------------------ | Branch (86:7): [True: 0, False: 100k] ------------------ 87| 0| jv_free(a); 88| 0| return b; 89| 100k| } else if (jv_get_kind(b) == JV_KIND_NULL) { ------------------ | Branch (89:14): [True: 39.0k, False: 61.2k] ------------------ 90| 39.0k| jv_free(b); 91| 39.0k| return a; 92| 61.2k| } else if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) { ------------------ | Branch (92:14): [True: 2.14k, False: 59.1k] | Branch (92:50): [True: 1.71k, False: 425] ------------------ 93| 1.71k| jv r = jv_number(jv_number_value(a) + 94| 1.71k| jv_number_value(b)); 95| 1.71k| jv_free(a); 96| 1.71k| jv_free(b); 97| 1.71k| return r; 98| 59.5k| } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) { ------------------ | Branch (98:14): [True: 57.8k, False: 1.71k] | Branch (98:50): [True: 57.8k, False: 1] ------------------ 99| 57.8k| return jv_string_concat(a, b); 100| 57.8k| } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) { ------------------ | Branch (100:14): [True: 980, False: 736] | Branch (100:49): [True: 213, False: 767] ------------------ 101| 213| return jv_array_concat(a, b); 102| 1.50k| } else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) { ------------------ | Branch (102:14): [True: 310, False: 1.19k] | Branch (102:50): [True: 310, False: 0] ------------------ 103| 310| return jv_object_merge(a, b); 104| 1.19k| } else { 105| 1.19k| return type_error2(a, b, "cannot be added"); 106| 1.19k| } 107| 100k|} binop_minus: 290| 17.9k|jv binop_minus(jv a, jv b) { 291| 17.9k| if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) { ------------------ | Branch (291:7): [True: 16.9k, False: 940] | Branch (291:43): [True: 16.6k, False: 323] ------------------ 292| 16.6k| jv r = jv_number(jv_number_value(a) - jv_number_value(b)); 293| 16.6k| jv_free(a); 294| 16.6k| jv_free(b); 295| 16.6k| return r; 296| 16.6k| } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) { ------------------ | Branch (296:14): [True: 762, False: 501] | Branch (296:49): [True: 557, False: 205] ------------------ 297| 557| jv out = jv_array(); 298| 5.50k| jv_array_foreach(a, i, x) { ------------------ | | 102| 557| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 1.11k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 557, False: 557] | | ------------------ | | 104| 557| for (jv x; \ | | 105| 6.06k| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 5.50k, False: 557] | | | Branch (105:10): [True: 5.50k, False: 557] | | ------------------ | | 106| 6.06k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 5.50k| i++) ------------------ 299| 5.50k| int include = 1; 300| 61.3k| jv_array_foreach(b, j, y) { ------------------ | | 102| 5.50k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 11.0k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 5.50k, False: 5.50k] | | ------------------ | | 104| 5.50k| for (jv x; \ | | 105| 66.4k| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 61.3k, False: 5.07k] | | | Branch (105:10): [True: 61.3k, False: 5.07k] | | ------------------ | | 106| 66.4k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 60.9k| i++) ------------------ 301| 61.3k| int equal = jv_equal(jv_copy(x), y); 302| 61.3k| if (equal < 0) { ------------------ | Branch (302:13): [True: 0, False: 61.3k] ------------------ 303| 0| jv_free(out); 304| 0| jv_free(x); 305| 0| jv_free(a); 306| 0| jv_free(b); 307| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 308| 0| } 309| 61.3k| if (equal) { ------------------ | Branch (309:13): [True: 429, False: 60.9k] ------------------ 310| 429| include = 0; 311| 429| break; 312| 429| } 313| 61.3k| } 314| 5.50k| if (include) ------------------ | Branch (314:11): [True: 5.07k, False: 429] ------------------ 315| 5.07k| out = jv_array_append(out, jv_copy(x)); 316| 5.50k| jv_free(x); 317| 5.50k| } 318| 557| jv_free(a); 319| 557| jv_free(b); 320| 557| return out; 321| 706| } else { 322| 706| return type_error2(a, b, "cannot be subtracted"); 323| 706| } 324| 17.9k|} binop_multiply: 326| 10.6k|jv binop_multiply(jv a, jv b) { 327| 10.6k| jv_kind ak = jv_get_kind(a); 328| 10.6k| jv_kind bk = jv_get_kind(b); 329| 10.6k| if (ak == JV_KIND_NUMBER && bk == JV_KIND_NUMBER) { ------------------ | Branch (329:7): [True: 5.04k, False: 5.56k] | Branch (329:31): [True: 4.18k, False: 861] ------------------ 330| 4.18k| jv r = jv_number(jv_number_value(a) * jv_number_value(b)); 331| 4.18k| jv_free(a); 332| 4.18k| jv_free(b); 333| 4.18k| return r; 334| 6.42k| } else if ((ak == JV_KIND_STRING && bk == JV_KIND_NUMBER) || ------------------ | Branch (334:15): [True: 496, False: 5.92k] | Branch (334:39): [True: 212, False: 284] ------------------ 335| 6.21k| (ak == JV_KIND_NUMBER && bk == JV_KIND_STRING)) { ------------------ | Branch (335:15): [True: 861, False: 5.35k] | Branch (335:39): [True: 718, False: 143] ------------------ 336| 930| jv str = a; 337| 930| jv num = b; 338| 930| if (ak == JV_KIND_NUMBER) { ------------------ | Branch (338:9): [True: 718, False: 212] ------------------ 339| 718| str = b; 340| 718| num = a; 341| 718| } 342| 930| double d = jv_number_value(num); 343| 930| jv_free(num); 344| 930| return jv_string_repeat(str, 345| 930| d < 0 || isnan(d) ? -1 : d > INT_MAX ? INT_MAX : (int)d); ------------------ | Branch (345:9): [True: 156, False: 774] | Branch (345:18): [True: 173, False: 601] | Branch (345:34): [True: 316, False: 285] ------------------ 346| 5.49k| } else if (ak == JV_KIND_OBJECT && bk == JV_KIND_OBJECT) { ------------------ | Branch (346:14): [True: 4.91k, False: 581] | Branch (346:38): [True: 4.60k, False: 307] ------------------ 347| 4.60k| return jv_object_merge_recursive(a, b); 348| 4.60k| } else { 349| 888| return type_error2(a, b, "cannot be multiplied"); 350| 888| } 351| 10.6k|} binop_divide: 353| 13.8k|jv binop_divide(jv a, jv b) { 354| 13.8k| if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) { ------------------ | Branch (354:7): [True: 13.6k, False: 195] | Branch (354:43): [True: 13.6k, False: 38] ------------------ 355| 13.6k| if (jv_number_value(b) == 0.0) ------------------ | Branch (355:9): [True: 2.32k, False: 11.2k] ------------------ 356| 2.32k| return type_error2(a, b, "cannot be divided because the divisor is zero"); 357| 11.2k| jv r = jv_number(jv_number_value(a) / jv_number_value(b)); 358| 11.2k| jv_free(a); 359| 11.2k| jv_free(b); 360| 11.2k| return r; 361| 13.6k| } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) { ------------------ | Branch (361:14): [True: 165, False: 68] | Branch (361:50): [True: 165, False: 0] ------------------ 362| 165| return jv_string_split(a, b); 363| 165| } else { 364| 68| return type_error2(a, b, "cannot be divided"); 365| 68| } 366| 13.8k|} binop_mod: 369| 9.72k|jv binop_mod(jv a, jv b) { 370| 9.72k| if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) { ------------------ | Branch (370:7): [True: 9.72k, False: 0] | Branch (370:43): [True: 9.72k, False: 0] ------------------ 371| 9.72k| double na = jv_number_value(a); 372| 9.72k| double nb = jv_number_value(b); 373| 9.72k| if (isnan(na) || isnan(nb)) { ------------------ | Branch (373:9): [True: 140, False: 9.58k] | Branch (373:22): [True: 130, False: 9.45k] ------------------ 374| 270| jv_free(a); 375| 270| jv_free(b); 376| 270| return jv_number(NAN); 377| 270| } 378| 9.45k| intmax_t bi = dtoi(nb); ------------------ | | 368| 9.45k|#define dtoi(n) ((n) < INTMAX_MIN ? INTMAX_MIN : -(n) <= INTMAX_MIN ? INTMAX_MAX : (intmax_t)(n)) | | ------------------ | | | Branch (368:18): [True: 2, False: 9.45k] | | | Branch (368:50): [True: 191, False: 9.26k] | | ------------------ ------------------ 379| 9.45k| if (bi == 0) ------------------ | Branch (379:9): [True: 1.00k, False: 8.45k] ------------------ 380| 1.00k| return type_error2(a, b, "cannot be divided (remainder) because the divisor is zero"); 381| | // Check if the divisor is -1 to avoid overflow when the dividend is INTMAX_MIN. 382| 8.45k| jv r = jv_number(bi == -1 ? 0 : dtoi(na) % bi); ------------------ | | 368| 4.19k|#define dtoi(n) ((n) < INTMAX_MIN ? INTMAX_MIN : -(n) <= INTMAX_MIN ? INTMAX_MAX : (intmax_t)(n)) | | ------------------ | | | Branch (368:18): [True: 144, False: 4.04k] | | | Branch (368:50): [True: 2, False: 4.04k] | | ------------------ ------------------ | Branch (382:22): [True: 4.26k, False: 4.19k] ------------------ 383| 8.45k| jv_free(a); 384| 8.45k| jv_free(b); 385| 8.45k| return r; 386| 9.45k| } else { 387| 0| return type_error2(a, b, "cannot be divided (remainder)"); 388| 0| } 389| 9.72k|} binop_equal: 392| 3.96k|jv binop_equal(jv a, jv b) { 393| 3.96k| int r = jv_equal(a, b); 394| 3.96k| if (r < 0) ------------------ | Branch (394:7): [True: 0, False: 3.96k] ------------------ 395| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 396| 3.96k| return jv_bool(r); 397| 3.96k|} binop_notequal: 399| 578|jv binop_notequal(jv a, jv b) { 400| 578| int r = jv_equal(a, b); 401| 578| if (r < 0) ------------------ | Branch (401:7): [True: 0, False: 578] ------------------ 402| 0| return jv_invalid_with_msg(jv_string("Equality check too deep")); 403| 578| return jv_bool(!r); 404| 578|} binop_less: 423| 558|jv binop_less(jv a, jv b) { 424| 558| return order_cmp(a, b, CMP_OP_LESS); 425| 558|} binop_greater: 427| 7.44k|jv binop_greater(jv a, jv b) { 428| 7.44k| return order_cmp(a, b, CMP_OP_GREATER); 429| 7.44k|} binop_lesseq: 431| 2|jv binop_lesseq(jv a, jv b) { 432| 2| return order_cmp(a, b, CMP_OP_LESSEQ); 433| 2|} binop_greatereq: 435| 194|jv binop_greatereq(jv a, jv b) { 436| 194| return order_cmp(a, b, CMP_OP_GREATEREQ); 437| 194|} builtins_bind: 2163| 181|int builtins_bind(jq_state *jq, block* bb) { 2164| 181| block builtins; 2165| 181| struct locfile* src = locfile_init(jq, "", jq_builtins, sizeof(jq_builtins)-1); 2166| 181| int nerrors = jq_parse_library(src, &builtins); 2167| 181| assert(!nerrors); ------------------ | Branch (2167:3): [True: 0, False: 181] | Branch (2167:3): [True: 181, False: 0] ------------------ 2168| 181| locfile_free(src); 2169| | 2170| 181| builtins = bind_bytecoded_builtins(builtins); 2171| 181| builtins = gen_cbinding(function_list, sizeof(function_list)/sizeof(function_list[0]), builtins); 2172| 181| builtins = gen_builtin_list(builtins); 2173| | 2174| 181| *bb = block_bind_referenced(builtins, *bb, OP_IS_CALL_PSEUDO); 2175| 181| return nerrors; 2176| 181|} builtin.c:type_error2: 62| 6.17k|static jv type_error2(jv bad1, jv bad2, const char* msg) { 63| 6.17k| char errbuf1[30], errbuf2[30]; 64| 6.17k| const char *badkind1 = jv_kind_name(jv_get_kind(bad1)); 65| 6.17k| const char *badkind2 = jv_kind_name(jv_get_kind(bad2)); 66| 6.17k| jv err = jv_invalid_with_msg(jv_string_fmt( 67| 6.17k| "%s (%s) and %s (%s) %s", badkind1, 68| 6.17k| jv_dump_string_trunc(bad1, errbuf1, sizeof(errbuf1)), 69| 6.17k| badkind2, 70| 6.17k| jv_dump_string_trunc(bad2, errbuf2, sizeof(errbuf2)), msg)); 71| 6.17k| return err; 72| 6.17k|} builtin.c:order_cmp: 413| 8.19k|static jv order_cmp(jv a, jv b, enum cmp_op op) { 414| 8.19k| int r = jv_cmp(a, b); 415| 8.19k| if (r == INT_MIN) ------------------ | Branch (415:7): [True: 0, False: 8.19k] ------------------ 416| 0| return jv_invalid_with_msg(jv_string("Comparison too deep")); 417| 8.19k| return jv_bool((op == CMP_OP_LESS && r < 0) || ------------------ | Branch (417:19): [True: 558, False: 7.63k] | Branch (417:40): [True: 159, False: 399] ------------------ 418| 8.03k| (op == CMP_OP_LESSEQ && r <= 0) || ------------------ | Branch (418:19): [True: 2, False: 8.03k] | Branch (418:42): [True: 0, False: 2] ------------------ 419| 8.03k| (op == CMP_OP_GREATEREQ && r >= 0) || ------------------ | Branch (419:19): [True: 194, False: 7.84k] | Branch (419:45): [True: 62, False: 132] ------------------ 420| 7.97k| (op == CMP_OP_GREATER && r > 0)); ------------------ | Branch (420:19): [True: 7.44k, False: 533] | Branch (420:43): [True: 1.52k, False: 5.92k] ------------------ 421| 8.19k|} builtin.c:bind_bytecoded_builtins: 2108| 181|static block bind_bytecoded_builtins(block b) { 2109| 181| block builtins = gen_noop(); 2110| 181| { 2111| 181| struct bytecoded_builtin builtin_defs[] = { 2112| 181| {"empty", gen_op_simple(BACKTRACK)}, 2113| 181| {"not", gen_condbranch(gen_const(jv_false()), 2114| 181| gen_const(jv_true()))} 2115| 181| }; 2116| 543| for (unsigned i=0; i= 0 && (int)op < NUM_OPCODES) { ------------------ | Branch (32:7): [True: 675M, False: 0] | Branch (32:23): [True: 675M, False: 0] ------------------ 33| 675M| return &opcode_descriptions[op]; 34| 675M| } else { 35| 0| return &invalid_opcode_description; 36| 0| } 37| 675M|} bytecode_operation_length: 40| 598k|int bytecode_operation_length(uint16_t* codeptr) { 41| 598k| int length = opcode_describe(*codeptr)->length; 42| 598k| if (*codeptr == CALL_JQ || *codeptr == TAIL_CALL_JQ) { ------------------ | Branch (42:7): [True: 10.0k, False: 588k] | Branch (42:30): [True: 1.84k, False: 586k] ------------------ 43| 11.9k| length += codeptr[1] * 2; 44| 11.9k| } 45| 598k| return length; 46| 598k|} dump_disassembly: 64| 7.81k|void dump_disassembly(int indent, struct bytecode* bc) { 65| 7.81k| if (bc->nclosures > 0) { ------------------ | Branch (65:7): [True: 37, False: 7.77k] ------------------ 66| 37| printf("%*s[params: ", indent, ""); 67| 37| jv params = jv_object_get(jv_copy(bc->debuginfo), jv_string("params")); 68| 91| for (int i=0; inclosures; i++) { ------------------ | Branch (68:19): [True: 54, False: 37] ------------------ 69| 54| if (i) printf(", "); ------------------ | Branch (69:11): [True: 17, False: 37] ------------------ 70| 54| jv name = jv_array_get(jv_copy(params), i); 71| 54| printf("%s", jv_string_value(name)); 72| 54| jv_free(name); 73| 54| } 74| 37| jv_free(params); 75| 37| printf("]\n"); 76| 37| } 77| 7.81k| dump_code(indent, bc); 78| 15.4k| for (int i=0; insubfunctions; i++) { ------------------ | Branch (78:17): [True: 7.66k, False: 7.81k] ------------------ 79| 7.66k| struct bytecode* subfn = bc->subfunctions[i]; 80| 7.66k| jv name = jv_object_get(jv_copy(subfn->debuginfo), jv_string("name")); 81| 7.66k| printf("%*s%s:%d:\n", indent, "", jv_string_value(name), i); 82| 7.66k| jv_free(name); 83| 7.66k| dump_disassembly(indent+2, subfn); 84| 7.66k| } 85| 7.81k|} dump_operation: 95| 299k|void dump_operation(struct bytecode* bc, uint16_t* codeptr) { 96| 299k| int pc = codeptr - bc->code; 97| 299k| printf("%04d ", pc); 98| 299k| const struct opcode_description* op = opcode_describe(bc->code[pc++]); 99| 299k| printf("%s", op->name); 100| 299k| if (op->length > 1) { ------------------ | Branch (100:7): [True: 185k, False: 114k] ------------------ 101| 185k| uint16_t imm = bc->code[pc++]; 102| 185k| if (op->op == CALL_JQ || op->op == TAIL_CALL_JQ) { ------------------ | Branch (102:9): [True: 5.03k, False: 179k] | Branch (102:30): [True: 924, False: 179k] ------------------ 103| 19.5k| for (int i=0; icode[pc++]; 105| 13.5k| uint16_t idx = bc->code[pc++]; 106| 13.5k| jv name; 107| 13.5k| if (idx & ARG_NEWCLOSURE) { ------------------ | | 70| 13.5k|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (107:13): [True: 13.5k, False: 54] ------------------ 108| 13.5k| idx &= ~ARG_NEWCLOSURE; ------------------ | | 70| 13.5k|#define ARG_NEWCLOSURE 0x1000 ------------------ 109| 13.5k| name = jv_object_get(jv_copy(getlevel(bc,level)->subfunctions[idx]->debuginfo), 110| 13.5k| jv_string("name")); 111| 13.5k| } else { 112| 54| name = jv_array_get(jv_object_get(jv_copy(getlevel(bc,level)->debuginfo), 113| 54| jv_string("params")), idx); 114| 54| } 115| 13.5k| printf(" %s:%d", 116| 13.5k| jv_string_value(name), 117| 13.5k| idx); 118| 13.5k| jv_free(name); 119| 13.5k| if (level) { ------------------ | Branch (119:13): [True: 3.22k, False: 10.3k] ------------------ 120| 3.22k| printf("^%d", level); 121| 3.22k| } 122| 13.5k| } 123| 179k| } else if (op->op == CALL_BUILTIN) { ------------------ | Branch (123:16): [True: 8.59k, False: 170k] ------------------ 124| 8.59k| int func = bc->code[pc++]; 125| 8.59k| jv name = jv_array_get(jv_copy(bc->globals->cfunc_names), func); 126| 8.59k| printf(" %s", jv_string_value(name)); 127| 8.59k| jv_free(name); 128| 170k| } else if (op->flags & OP_HAS_BRANCH) { ------------------ | Branch (128:16): [True: 66.2k, False: 104k] ------------------ 129| 66.2k| printf(" %04d", pc + imm); 130| 104k| } else if (op->flags & OP_HAS_CONSTANT) { ------------------ | Branch (130:16): [True: 55.2k, False: 48.9k] ------------------ 131| 55.2k| printf(" "); 132| 55.2k| jv_dump(jv_array_get(jv_copy(bc->constants), imm), 0); 133| 55.2k| } else if (op->flags & OP_HAS_VARIABLE) { ------------------ | Branch (133:16): [True: 48.9k, False: 0] ------------------ 134| 48.9k| uint16_t v = bc->code[pc++]; 135| 48.9k| jv name = jv_array_get(jv_object_get(jv_copy(getlevel(bc,imm)->debuginfo), jv_string("locals")), v); 136| 48.9k| printf(" $%s:%d", 137| 48.9k| jv_string_value(name), 138| 48.9k| v); 139| 48.9k| jv_free(name); 140| 48.9k| if (imm) { ------------------ | Branch (140:11): [True: 2.03k, False: 46.9k] ------------------ 141| 2.03k| printf("^%d", imm); 142| 2.03k| } 143| 48.9k| } else { 144| 0| printf(" %d", imm); 145| 0| } 146| 185k| } 147| 299k|} bytecode_free: 149| 9.52k|void bytecode_free(struct bytecode* bc) { 150| 9.52k| if (!bc) ------------------ | Branch (150:7): [True: 449, False: 9.07k] ------------------ 151| 449| return; 152| 9.07k| jv_mem_free(bc->code); 153| 9.07k| jv_free(bc->constants); 154| 17.9k| for (int i=0; insubfunctions; i++) ------------------ | Branch (154:17): [True: 8.89k, False: 9.07k] ------------------ 155| 8.89k| bytecode_free(bc->subfunctions[i]); 156| 9.07k| if (!bc->parent) ------------------ | Branch (156:7): [True: 181, False: 8.89k] ------------------ 157| 181| symbol_table_free(bc->globals); 158| 9.07k| jv_mem_free(bc->subfunctions); 159| 9.07k| jv_free(bc->debuginfo); 160| 9.07k| jv_mem_free(bc); 161| 9.07k|} bytecode.c:dump_code: 48| 7.81k|static void dump_code(int indent, struct bytecode* bc) { 49| 7.81k| int pc = 0; 50| 306k| while (pc < bc->codelen) { ------------------ | Branch (50:10): [True: 299k, False: 7.81k] ------------------ 51| 299k| printf("%*s", indent, ""); 52| 299k| dump_operation(bc, bc->code + pc); 53| 299k| printf("\n"); 54| 299k| pc += bytecode_operation_length(bc->code + pc); 55| 299k| } 56| 7.81k|} bytecode.c:getlevel: 87| 62.5k|static struct bytecode* getlevel(struct bytecode* bc, int level) { 88| 958k| while (level > 0) { ------------------ | Branch (88:10): [True: 896k, False: 62.5k] ------------------ 89| 896k| bc = bc->parent; 90| 896k| level--; 91| 896k| } 92| 62.5k| return bc; 93| 62.5k|} bytecode.c:symbol_table_free: 58| 181|static void symbol_table_free(struct symbol_table* syms) { 59| 181| jv_mem_free(syms->cfunctions); 60| 181| jv_free(syms->cfunc_names); 61| 181| jv_mem_free(syms); 62| 181|} block_is_single: 102| 446M|int block_is_single(block b) { 103| 446M| return b.first && b.first == b.last; ------------------ | Branch (103:10): [True: 446M, False: 57.6k] | Branch (103:21): [True: 446M, False: 40.3k] ------------------ 104| 446M|} gen_location: 120| 170k|block gen_location(location loc, struct locfile* l, block b) { 121| 937k| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (121:27): [True: 767k, False: 170k] ------------------ 122| 767k| if (i->source.start == UNKNOWN_LOCATION.start && ------------------ | Branch (122:9): [True: 204k, False: 563k] ------------------ 123| 204k| i->source.end == UNKNOWN_LOCATION.end) { ------------------ | Branch (123:9): [True: 204k, False: 0] ------------------ 124| 204k| i->source = loc; 125| 204k| i->locfile = locfile_retain(l); 126| 204k| } 127| 767k| } 128| 170k| return b; 129| 170k|} gen_noop: 131| 9.15M|block gen_noop(void) { 132| 9.15M| block b = {0,0}; 133| 9.15M| return b; 134| 9.15M|} block_is_noop: 136| 569k|int block_is_noop(block b) { 137| 569k| return (b.first == 0 && b.last == 0); ------------------ | Branch (137:11): [True: 168k, False: 401k] | Branch (137:27): [True: 168k, False: 0] ------------------ 138| 569k|} gen_op_simple: 140| 642k|block gen_op_simple(opcode op) { 141| 642k| assert(opcode_describe(op)->length == 1); ------------------ | Branch (141:3): [True: 0, False: 642k] | Branch (141:3): [True: 642k, False: 0] ------------------ 142| 642k| return inst_block(inst_new(op)); 143| 642k|} gen_error: 146| 6.46k|block gen_error(jv constant) { 147| 6.46k| assert(opcode_describe(ERRORK)->flags & OP_HAS_CONSTANT); ------------------ | Branch (147:3): [True: 0, False: 6.46k] | Branch (147:3): [True: 6.46k, False: 0] ------------------ 148| 6.46k| inst *i = inst_new(ERRORK); 149| 6.46k| i->imm.constant = constant; 150| 6.46k| return inst_block(i); 151| 6.46k|} gen_const: 153| 1.01M|block gen_const(jv constant) { 154| 1.01M| assert(opcode_describe(LOADK)->flags & OP_HAS_CONSTANT); ------------------ | Branch (154:3): [True: 0, False: 1.01M] | Branch (154:3): [True: 1.01M, False: 0] ------------------ 155| 1.01M| inst* i = inst_new(LOADK); 156| 1.01M| i->imm.constant = constant; 157| 1.01M| return inst_block(i); 158| 1.01M|} gen_op_pushk_under: 170| 166k|block gen_op_pushk_under(jv constant) { 171| 166k| assert(opcode_describe(PUSHK_UNDER)->flags & OP_HAS_CONSTANT); ------------------ | Branch (171:3): [True: 0, False: 166k] | Branch (171:3): [True: 166k, False: 0] ------------------ 172| 166k| inst* i = inst_new(PUSHK_UNDER); 173| 166k| i->imm.constant = constant; 174| 166k| return inst_block(i); 175| 166k|} block_is_const: 177| 934k|int block_is_const(block b) { 178| 934k| return (block_is_single(b) && (b.first->op == LOADK || b.first->op == PUSHK_UNDER)); ------------------ | Branch (178:11): [True: 934k, False: 811] | Branch (178:34): [True: 835k, False: 98.4k] | Branch (178:58): [True: 0, False: 98.4k] ------------------ 179| 934k|} block_const_kind: 181| 601|jv_kind block_const_kind(block b) { 182| 601| assert(block_is_const(b)); ------------------ | Branch (182:3): [True: 0, False: 601] | Branch (182:3): [True: 601, False: 0] ------------------ 183| 601| return jv_get_kind(b.first->imm.constant); 184| 601|} block_const: 186| 497k|jv block_const(block b) { 187| 497k| assert(block_is_const(b)); ------------------ | Branch (187:3): [True: 0, False: 497k] | Branch (187:3): [True: 497k, False: 0] ------------------ 188| 497k| return jv_copy(b.first->imm.constant); 189| 497k|} gen_op_target: 191| 258k|block gen_op_target(opcode op, block target) { 192| 258k| assert(opcode_describe(op)->flags & OP_HAS_BRANCH); ------------------ | Branch (192:3): [True: 0, False: 258k] | Branch (192:3): [True: 258k, False: 0] ------------------ 193| 258k| assert(target.last); ------------------ | Branch (193:3): [True: 0, False: 258k] | Branch (193:3): [True: 258k, False: 0] ------------------ 194| 258k| inst* i = inst_new(op); 195| 258k| i->imm.target = target.last; 196| 258k| return inst_block(i); 197| 258k|} gen_op_targetlater: 199| 78.0k|block gen_op_targetlater(opcode op) { 200| 78.0k| assert(opcode_describe(op)->flags & OP_HAS_BRANCH); ------------------ | Branch (200:3): [True: 0, False: 78.0k] | Branch (200:3): [True: 78.0k, False: 0] ------------------ 201| 78.0k| inst* i = inst_new(op); 202| 78.0k| i->imm.target = 0; 203| 78.0k| return inst_block(i); 204| 78.0k|} inst_set_target: 205| 78.0k|void inst_set_target(block b, block target) { 206| 78.0k| assert(block_is_single(b)); ------------------ | Branch (206:3): [True: 0, False: 78.0k] | Branch (206:3): [True: 78.0k, False: 0] ------------------ 207| 78.0k| assert(opcode_describe(b.first->op)->flags & OP_HAS_BRANCH); ------------------ | Branch (207:3): [True: 0, False: 78.0k] | Branch (207:3): [True: 78.0k, False: 0] ------------------ 208| 78.0k| assert(target.last); ------------------ | Branch (208:3): [True: 0, False: 78.0k] | Branch (208:3): [True: 78.0k, False: 0] ------------------ 209| 78.0k| b.first->imm.target = target.last; 210| 78.0k|} gen_op_unbound: 212| 908k|block gen_op_unbound(opcode op, const char* name) { 213| 908k| assert(opcode_describe(op)->flags & OP_HAS_BINDING); ------------------ | Branch (213:3): [True: 0, False: 908k] | Branch (213:3): [True: 908k, False: 0] ------------------ 214| 908k| inst* i = inst_new(op); 215| 908k| i->symbol = strdup(name); 216| 908k| i->any_unbound = 1; 217| 908k| return inst_block(i); 218| 908k|} gen_op_var_fresh: 220| 121k|block gen_op_var_fresh(opcode op, const char* name) { 221| 121k| assert(opcode_describe(op)->flags & OP_HAS_VARIABLE); ------------------ | Branch (221:3): [True: 0, False: 121k] | Branch (221:3): [True: 121k, False: 0] ------------------ 222| 121k| block b = gen_op_unbound(op, name); 223| 121k| b.first->bound_by = b.first; 224| 121k| return b; 225| 121k|} gen_op_bound: 227| 317k|block gen_op_bound(opcode op, block binder) { 228| 317k| assert(block_is_single(binder)); ------------------ | Branch (228:3): [True: 0, False: 317k] | Branch (228:3): [True: 317k, False: 0] ------------------ 229| 317k| block b = gen_op_unbound(op, binder.first->symbol); 230| 317k| b.first->bound_by = binder.first; 231| 317k| b.first->any_unbound = 0; 232| 317k| return b; 233| 317k|} gen_dictpair: 235| 72.2k|block gen_dictpair(block k, block v) { 236| 72.2k| return BLOCK(gen_subexp(k), gen_subexp(v), gen_op_simple(INSERT)); ------------------ | | 102| 72.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 72.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 72.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 72.2k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 72.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 237| 72.2k|} block_append: 248| 4.28M|void block_append(block* b, block b2) { 249| 4.28M| if (b2.first) { ------------------ | Branch (249:7): [True: 3.66M, False: 618k] ------------------ 250| 3.66M| if (b->last) { ------------------ | Branch (250:9): [True: 3.49M, False: 175k] ------------------ 251| 3.49M| inst_join(b->last, b2.first); 252| 3.49M| } else { 253| 175k| b->first = b2.first; 254| 175k| } 255| 3.66M| b->last = b2.last; 256| 3.66M| } 257| 4.28M|} block_join: 259| 4.03M|block block_join(block a, block b) { 260| 4.03M| block c = a; 261| 4.03M| block_append(&c, b); 262| 4.03M| return c; 263| 4.03M|} block_has_only_binders_and_imports: 265| 181|int block_has_only_binders_and_imports(block binders, int bindflags) { 266| 181| bindflags |= OP_HAS_BINDING; 267| 19.1k| for (inst* curr = binders.first; curr; curr = curr->next) { ------------------ | Branch (267:36): [True: 19.0k, False: 181] ------------------ 268| 19.0k| if ((opcode_describe(curr->op)->flags & bindflags) != bindflags && curr->op != DEPS && curr->op != MODULEMETA) { ------------------ | Branch (268:9): [True: 0, False: 19.0k] | Branch (268:72): [True: 0, False: 0] | Branch (268:92): [True: 0, False: 0] ------------------ 269| 0| return 0; 270| 0| } 271| 19.0k| } 272| 181| return 1; 273| 181|} block_has_only_binders: 279| 3.02k|int block_has_only_binders(block binders, int bindflags) { 280| 3.02k| bindflags |= OP_HAS_BINDING; 281| 3.02k| bindflags &= ~OP_BIND_WILDCARD; 282| 50.7k| for (inst* curr = binders.first; curr; curr = curr->next) { ------------------ | Branch (282:36): [True: 47.7k, False: 3.02k] ------------------ 283| 47.7k| if ((opcode_describe(curr->op)->flags & bindflags) != bindflags && curr->op != MODULEMETA) { ------------------ | Branch (283:9): [True: 0, False: 47.7k] | Branch (283:72): [True: 0, False: 0] ------------------ 284| 0| return 0; 285| 0| } 286| 47.7k| } 287| 3.02k| return 1; 288| 3.02k|} block_bind_referenced: 421| 1.44k|block block_bind_referenced(block binder, block body, int bindflags) { 422| 1.44k| assert(block_has_only_binders(binder, bindflags)); ------------------ | Branch (422:3): [True: 0, False: 1.44k] | Branch (422:3): [True: 1.44k, False: 0] ------------------ 423| 1.44k| bindflags |= OP_HAS_BINDING; 424| | 425| 1.44k| inst* curr; 426| 47.6k| while ((curr = block_take_last(&binder))) { ------------------ | Branch (426:10): [True: 46.1k, False: 1.44k] ------------------ 427| 46.1k| block b = inst_block(curr); 428| 46.1k| if (block_bind_subblock(b, body, bindflags, 0) == 0) { ------------------ | Branch (428:9): [True: 44.4k, False: 1.66k] ------------------ 429| 44.4k| block_free(b); 430| 44.4k| } else { 431| 1.66k| body = BLOCK(b, body); ------------------ | | 102| 1.66k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.66k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.66k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 1.66k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 432| 1.66k| } 433| 46.1k| } 434| 1.44k| return body; 435| 1.44k|} block_drop_unreferenced: 468| 181|block block_drop_unreferenced(block body) { 469| 181| block_mark_referenced(body); 470| | 471| 181| block refd = gen_noop(); 472| 181| inst* curr; 473| 612k| while ((curr = block_take(&body))) { ------------------ | Branch (473:10): [True: 611k, False: 181] ------------------ 474| 611k| if (curr->bound_by == curr && !curr->referenced) { ------------------ | Branch (474:9): [True: 65.1k, False: 546k] | Branch (474:35): [True: 0, False: 65.1k] ------------------ 475| 0| inst_free(curr); 476| 611k| } else { 477| 611k| refd = BLOCK(refd, inst_block(curr)); ------------------ | | 102| 611k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 611k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 611k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 611k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 478| 611k| } 479| 611k| } 480| 181| return refd; 481| 181|} block_take_imports: 483| 197|jv block_take_imports(block* body) { 484| 197| jv imports = jv_array(); 485| | 486| | /* Parser should never generate TOP before imports */ 487| 197| assert(!(body->first && body->first->op == TOP && body->first->next && ------------------ | Branch (487:3): [True: 0, False: 197] | 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: 197, False: 0] | Branch (487:3): [True: 0, False: 197] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 0, False: 0] | Branch (487:3): [True: 0, False: 0] ------------------ 488| 197| (body->first->next->op == MODULEMETA || body->first->next->op == DEPS))); 489| | 490| 410| while (body->first && (body->first->op == MODULEMETA || body->first->op == DEPS)) { ------------------ | Branch (490:10): [True: 410, False: 0] | Branch (490:26): [True: 0, False: 410] | Branch (490:59): [True: 213, False: 197] ------------------ 491| 213| inst* dep = block_take(body); 492| 213| if (dep->op == DEPS) { ------------------ | Branch (492:9): [True: 213, False: 0] ------------------ 493| 213| imports = jv_array_append(imports, jv_copy(dep->imm.constant)); 494| 213| } 495| 213| inst_free(dep); 496| 213| } 497| 197| return imports; 498| 197|} block_list_funcs: 500| 181|jv block_list_funcs(block body, int omit_underscores) { 501| 181| jv funcs = jv_object(); // Use the keys for set semantics. 502| 44.8k| for (inst *pos = body.first; pos != NULL; pos = pos->next) { ------------------ | Branch (502:32): [True: 44.7k, False: 181] ------------------ 503| 44.7k| if (pos->op == CLOSURE_CREATE || pos->op == CLOSURE_CREATE_C) { ------------------ | Branch (503:9): [True: 19.9k, False: 24.7k] | Branch (503:38): [True: 24.7k, False: 0] ------------------ 504| 44.7k| if (pos->symbol != NULL && (!omit_underscores || pos->symbol[0] != '_')) { ------------------ | Branch (504:11): [True: 44.7k, False: 0] | Branch (504:35): [True: 0, False: 44.7k] | Branch (504:56): [True: 40.7k, False: 3.98k] ------------------ 505| 40.7k| funcs = jv_object_set(funcs, jv_string_fmt("%s/%i", pos->symbol, pos->nformals), jv_null()); 506| 40.7k| } 507| 44.7k| } 508| 44.7k| } 509| 181| return jv_keys_unsorted(funcs); 510| 181|} gen_import: 528| 797|block gen_import(jv name, jv as, int is_data) { 529| 797| assert(jv_get_kind(name) == JV_KIND_STRING); ------------------ | Branch (529:3): [True: 0, False: 797] | Branch (529:3): [True: 797, False: 0] ------------------ 530| 797| assert(!jv_is_valid(as) || jv_get_kind(as) == JV_KIND_STRING); ------------------ | Branch (530:3): [True: 797, False: 0] | Branch (530:3): [True: 0, False: 0] | Branch (530:3): [True: 535, False: 262] | Branch (530:3): [True: 262, False: 0] ------------------ 531| 797| inst* i = inst_new(DEPS); 532| 797| jv meta = jv_object(); 533| 797| if (jv_is_valid(as)) ------------------ | Branch (533:7): [True: 262, False: 535] ------------------ 534| 262| meta = jv_object_set(meta, jv_string("as"), as); 535| 535| else 536| 535| jv_free(as); 537| 797| meta = jv_object_set(meta, jv_string("is_data"), is_data ? jv_true() : jv_false()); ------------------ | Branch (537:52): [True: 134, False: 663] ------------------ 538| 797| meta = jv_object_set(meta, jv_string("relpath"), name); 539| 797| i->imm.constant = meta; 540| 797| return inst_block(i); 541| 797|} gen_import_meta: 543| 380|block gen_import_meta(block import, block metadata) { 544| 380| assert(block_is_single(import) && import.first->op == DEPS); ------------------ | Branch (544:3): [True: 0, False: 380] | Branch (544:3): [True: 0, False: 0] | Branch (544:3): [True: 380, False: 0] | Branch (544:3): [True: 380, False: 0] ------------------ 545| 380| assert(block_is_const(metadata) && block_const_kind(metadata) == JV_KIND_OBJECT); ------------------ | Branch (545:3): [True: 0, False: 380] | Branch (545:3): [True: 0, False: 0] | Branch (545:3): [True: 380, False: 0] | Branch (545:3): [True: 380, False: 0] ------------------ 546| 380| inst *i = import.first; 547| 380| i->imm.constant = jv_object_merge(block_const(metadata), i->imm.constant); 548| 380| block_free(metadata); 549| 380| return import; 550| 380|} gen_function: 552| 575k|block gen_function(const char* name, block formals, block body) { 553| 575k| inst* i = inst_new(CLOSURE_CREATE); 554| 575k| int nformals = 0; 555| 594k| for (inst* i = formals.last; i; i = i->prev) { ------------------ | Branch (555:32): [True: 19.3k, False: 575k] ------------------ 556| 19.3k| nformals++; 557| 19.3k| i->nformals = 0; 558| 19.3k| if (i->op == CLOSURE_PARAM_REGULAR) { ------------------ | Branch (558:9): [True: 7.05k, False: 12.3k] ------------------ 559| 7.05k| i->op = CLOSURE_PARAM; 560| 7.05k| body = gen_var_binding(gen_call(i->symbol, gen_noop()), i->symbol, body); 561| 7.05k| } 562| 19.3k| block_bind_subblock(inst_block(i), body, OP_IS_CALL_PSEUDO | OP_HAS_BINDING, 0); 563| 19.3k| } 564| 575k| i->subfn = body; 565| 575k| i->symbol = strdup(name); 566| 575k| i->any_unbound = -1; 567| 575k| i->nformals = nformals; 568| 575k| i->arglist = formals; 569| 575k| block b = inst_block(i); 570| 575k| block_bind_subblock(b, b, OP_IS_CALL_PSEUDO | OP_HAS_BINDING, 0); 571| 575k| return b; 572| 575k|} gen_param_regular: 574| 7.05k|block gen_param_regular(const char* name) { 575| 7.05k| return gen_op_unbound(CLOSURE_PARAM_REGULAR, name); 576| 7.05k|} gen_param: 578| 12.3k|block gen_param(const char* name) { 579| 12.3k| return gen_op_unbound(CLOSURE_PARAM, name); 580| 12.3k|} gen_lambda: 582| 554k|block gen_lambda(block body) { 583| 554k| return gen_function("@lambda", gen_noop(), body); 584| 554k|} gen_call: 586| 387k|block gen_call(const char* name, block args) { 587| 387k| block b = gen_op_unbound(CALL_JQ, name); 588| 387k| b.first->arglist = args; 589| 387k| b.first->nactuals = block_count_actuals(b.first->arglist); 590| 387k| return b; 591| 387k|} gen_subexp: 593| 238k|block gen_subexp(block a) { 594| 238k| if (block_is_noop(a)) { ------------------ | Branch (594:7): [True: 6.66k, False: 231k] ------------------ 595| 6.66k| return gen_op_simple(DUP); 596| 6.66k| } 597| 231k| if (block_is_single(a) && a.first->op == LOADK) { ------------------ | Branch (597:7): [True: 198k, False: 33.0k] | Branch (597:29): [True: 166k, False: 32.1k] ------------------ 598| 166k| jv c = block_const(a); 599| 166k| block_free(a); 600| 166k| return gen_op_pushk_under(c); 601| 166k| } 602| 65.1k| return BLOCK(gen_op_simple(SUBEXP_BEGIN), a, gen_op_simple(SUBEXP_END)); ------------------ | | 102| 65.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 65.1k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 65.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 65.1k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 65.1k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 603| 231k|} gen_both: 605| 78.0k|block gen_both(block a, block b) { 606| 78.0k| block jump = gen_op_targetlater(JUMP); 607| 78.0k| block fork = gen_op_target(FORK, jump); 608| 78.0k| block c = BLOCK(fork, a, jump, b); ------------------ | | 102| 78.0k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 78.0k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 78.0k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 78.0k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 78.0k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 78.0k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 609| 78.0k| inst_set_target(jump, c); 610| 78.0k| return c; 611| 78.0k|} gen_const_object: 613| 66.3k|block gen_const_object(block expr) { 614| 66.3k| int is_const = 1; 615| 66.3k| jv o = jv_object(); 616| 66.3k| jv k = jv_null(); 617| 66.3k| jv v = jv_null(); 618| 99.7k| for (inst *i = expr.first; i; i = i->next) { ------------------ | Branch (618:30): [True: 43.6k, False: 56.0k] ------------------ 619| 43.6k| if (i->op == PUSHK_UNDER) { ------------------ | Branch (619:9): [True: 38.5k, False: 5.17k] ------------------ 620| 38.5k| k = jv_copy(i->imm.constant); 621| 38.5k| i = i->next; 622| 38.5k| } else if (i->op != SUBEXP_BEGIN || ------------------ | Branch (622:16): [True: 4.49k, False: 683] ------------------ 623| 683| i->next == NULL || ------------------ | Branch (623:9): [True: 0, False: 683] ------------------ 624| 683| i->next->op != LOADK || ------------------ | Branch (624:9): [True: 543, False: 140] ------------------ 625| 140| i->next->next == NULL || ------------------ | Branch (625:9): [True: 0, False: 140] ------------------ 626| 5.17k| i->next->next->op != SUBEXP_END) { ------------------ | Branch (626:9): [True: 140, False: 0] ------------------ 627| 5.17k| is_const = 0; 628| 5.17k| break; 629| 5.17k| } else { 630| 0| k = jv_copy(i->next->imm.constant); 631| 0| i = i->next->next->next; 632| 0| } 633| 38.5k| if (i != NULL && i->op == PUSHK_UNDER) { ------------------ | Branch (633:9): [True: 38.5k, False: 0] | Branch (633:22): [True: 34.7k, False: 3.73k] ------------------ 634| 34.7k| v = jv_copy(i->imm.constant); 635| 34.7k| i = i->next; 636| 34.7k| } else if (i == NULL || ------------------ | Branch (636:16): [True: 0, False: 3.73k] ------------------ 637| 3.73k| i->op != SUBEXP_BEGIN || ------------------ | Branch (637:9): [True: 563, False: 3.17k] ------------------ 638| 3.17k| i->next == NULL || ------------------ | Branch (638:9): [True: 0, False: 3.17k] ------------------ 639| 3.17k| i->next->op != LOADK || ------------------ | Branch (639:9): [True: 3.15k, False: 14] ------------------ 640| 14| i->next->next == NULL || ------------------ | Branch (640:9): [True: 0, False: 14] ------------------ 641| 3.73k| i->next->next->op != SUBEXP_END) { ------------------ | Branch (641:9): [True: 14, False: 0] ------------------ 642| 3.73k| is_const = 0; 643| 3.73k| break; 644| 3.73k| } else { 645| 0| v = jv_copy(i->next->imm.constant); 646| 0| i = i->next->next->next; 647| 0| } 648| 34.7k| if (i == NULL || i->op != INSERT) { ------------------ | Branch (648:9): [True: 0, False: 34.7k] | Branch (648:22): [True: 1.43k, False: 33.3k] ------------------ 649| 1.43k| is_const = 0; 650| 1.43k| break; 651| 1.43k| } 652| 33.3k| if (jv_get_kind(k) != JV_KIND_STRING) { ------------------ | Branch (652:9): [True: 0, False: 33.3k] ------------------ 653| 0| is_const = 0; 654| 0| break; 655| 0| } 656| 33.3k| o = jv_object_set(o, k, v); 657| 33.3k| k = jv_null(); 658| 33.3k| v = jv_null(); 659| 33.3k| } 660| 66.3k| if (!is_const) { ------------------ | Branch (660:7): [True: 10.3k, False: 56.0k] ------------------ 661| 10.3k| jv_free(o); 662| 10.3k| jv_free(k); 663| 10.3k| jv_free(v); 664| 10.3k| block b = {0,0}; 665| 10.3k| return b; 666| 10.3k| } 667| 56.0k| block_free(expr); 668| 56.0k| return gen_const(o); 669| 66.3k|} gen_collect: 730| 184k|block gen_collect(block expr) { 731| 184k| block const_array = gen_const_array(expr); 732| 184k| if (const_array.first != NULL) ------------------ | Branch (732:7): [True: 134k, False: 50.1k] ------------------ 733| 134k| return const_array; 734| | 735| 50.1k| block array_var = gen_op_var_fresh(STOREV, "collect"); 736| 50.1k| block c = BLOCK(gen_op_simple(DUP), gen_const(jv_array()), array_var); ------------------ | | 102| 50.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 50.1k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 50.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 50.1k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 50.1k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 737| | 738| 50.1k| block tail = BLOCK(gen_op_bound(APPEND, array_var), ------------------ | | 102| 50.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 50.1k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 50.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 50.1k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 739| 50.1k| gen_op_simple(BACKTRACK)); 740| | 741| 50.1k| return BLOCK(c, ------------------ | | 102| 50.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 50.1k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 50.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 95| 50.1k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | ------------------ | | | | | | | | | | 94| 50.1k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 93| 50.1k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 92| 50.1k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 742| 184k| gen_op_target(FORK, tail), 743| 184k| expr, 744| 184k| tail, 745| 184k| gen_op_bound(LOADVN, array_var)); 746| 184k|} gen_reduce: 833| 2.17k|block gen_reduce(block source, block matcher, block init, block body) { 834| 2.17k| block res_var = gen_op_var_fresh(STOREV, "reduce"); 835| 2.17k| block loop = BLOCK(source, ------------------ | | 102| 2.17k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 2.17k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 2.17k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 2.17k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 2.17k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 836| 2.17k| bind_alternation_matchers(matcher, 837| 2.17k| BLOCK(gen_op_bound(LOADVN, res_var), 838| 2.17k| body, 839| 2.17k| gen_op_bound(STOREV, res_var))), 840| 2.17k| gen_op_simple(BACKTRACK)); 841| 2.17k| return BLOCK(gen_op_simple(DUP), ------------------ | | 102| 2.17k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 2.17k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 2.17k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 98| 2.17k|#define BLOCK_8(b1,b2,b3,b4,b5,b6,b7,b8) (block_join(BLOCK_7(b1,b2,b3,b4,b5,b6,b7),(b8))) | | | | | | | | ------------------ | | | | | | | | | | 97| 2.17k|#define BLOCK_7(b1,b2,b3,b4,b5,b6,b7) (block_join(BLOCK_6(b1,b2,b3,b4,b5,b6),(b7))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 96| 2.17k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 95| 2.17k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 94| 2.17k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 93| 2.17k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 92| 2.17k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 842| 2.17k| init, 843| 2.17k| res_var, 844| 2.17k| gen_op_simple(DUP), 845| 2.17k| gen_op_target(FORK, loop), 846| 2.17k| loop, 847| 2.17k| gen_op_simple(POP), 848| 2.17k| gen_op_bound(LOADVN, res_var)); 849| 2.17k|} gen_foreach: 851| 724|block gen_foreach(block source, block matcher, block init, block update, block extract) { 852| 724| block state_var = gen_op_var_fresh(STOREV, "foreach"); 853| 724| return BLOCK(gen_op_simple(DUP), ------------------ | | 102| 724| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 724|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 724| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 96| 724|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | ------------------ | | | | | | | | | | 95| 724|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 94| 724|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 93| 724|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 92| 724|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 854| 724| init, 855| 724| state_var, 856| 724| gen_op_simple(DUP), 857| | // get a value from the source expression: 858| 724| source, 859| | // destructure the value into variable(s) for all the code 860| | // in the body to see 861| 724| bind_alternation_matchers(matcher, 862| | // load the loop state variable 863| 724| BLOCK(gen_op_bound(LOADVN, state_var), 864| | // generate updated state 865| 724| update, 866| | // save the updated state for value extraction 867| 724| gen_op_simple(DUP), 868| | // save new state 869| 724| gen_op_bound(STOREV, state_var), 870| | // extract an output... 871| 724| extract))); 872| 724|} gen_definedor: 874| 19.3k|block gen_definedor(block a, block b) { 875| | // var found := false 876| 19.3k| block found_var = gen_op_var_fresh(STOREV, "found"); 877| 19.3k| block init = BLOCK(gen_op_simple(DUP), gen_const(jv_false()), found_var); ------------------ | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 19.3k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 19.3k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 19.3k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 878| | 879| | // if found, backtrack. Otherwise execute b 880| 19.3k| block backtrack = gen_op_simple(BACKTRACK); 881| 19.3k| block tail = BLOCK(gen_op_simple(DUP), ------------------ | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 19.3k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 96| 19.3k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | ------------------ | | | | | | | | | | 95| 19.3k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 94| 19.3k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 93| 19.3k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 92| 19.3k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 882| 19.3k| gen_op_bound(LOADV, found_var), 883| 19.3k| gen_op_target(JUMP_F, backtrack), 884| 19.3k| backtrack, 885| 19.3k| gen_op_simple(POP), 886| 19.3k| b); 887| | 888| | // try again 889| 19.3k| block if_notfound = gen_op_simple(BACKTRACK); 890| | 891| | // found := true, produce result 892| 19.3k| block if_found = BLOCK(gen_op_simple(DUP), ------------------ | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 19.3k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 19.3k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 19.3k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 19.3k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 893| 19.3k| gen_const(jv_true()), 894| 19.3k| gen_op_bound(STOREV, found_var), 895| 19.3k| gen_op_target(JUMP, tail)); 896| | 897| 19.3k| return BLOCK(init, ------------------ | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 19.3k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 19.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 97| 19.3k|#define BLOCK_7(b1,b2,b3,b4,b5,b6,b7) (block_join(BLOCK_6(b1,b2,b3,b4,b5,b6),(b7))) | | | | | | | | ------------------ | | | | | | | | | | 96| 19.3k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 95| 19.3k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 94| 19.3k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 93| 19.3k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 92| 19.3k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 898| 19.3k| gen_op_target(FORK, if_notfound), 899| 19.3k| a, 900| 19.3k| gen_op_target(JUMP_F, if_found), 901| 19.3k| if_found, 902| 19.3k| if_notfound, 903| 19.3k| tail); 904| 19.3k|} block_has_main: 906| 378|int block_has_main(block top) { 907| 19.3k| for (inst *c = top.first; c; c = c->next) { ------------------ | Branch (907:29): [True: 19.2k, False: 181] ------------------ 908| 19.2k| if (c->op == TOP) ------------------ | Branch (908:9): [True: 197, False: 19.0k] ------------------ 909| 197| return 1; 910| 19.2k| } 911| 181| return 0; 912| 378|} gen_condbranch: 920| 16.9k|block gen_condbranch(block iftrue, block iffalse) { 921| 16.9k| iftrue = BLOCK(iftrue, gen_op_target(JUMP, iffalse)); ------------------ | | 102| 16.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 16.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 16.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 16.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 922| 16.9k| return BLOCK(gen_op_target(JUMP_F, iftrue), iftrue, iffalse); ------------------ | | 102| 16.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 16.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 16.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 16.9k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 16.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 923| 16.9k|} gen_and: 925| 3.21k|block gen_and(block a, block b) { 926| | // a and b = if a then (if b then true else false) else false 927| 3.21k| return BLOCK(gen_op_simple(DUP), a, ------------------ | | 102| 3.21k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 3.21k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 3.21k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 3.21k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 3.21k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 928| 3.21k| gen_condbranch(BLOCK(gen_op_simple(POP), 929| 3.21k| b, 930| 3.21k| gen_condbranch(gen_const(jv_true()), 931| 3.21k| gen_const(jv_false()))), 932| 3.21k| BLOCK(gen_op_simple(POP), gen_const(jv_false())))); 933| 3.21k|} gen_or: 935| 546|block gen_or(block a, block b) { 936| | // a or b = if a then true else (if b then true else false) 937| 546| return BLOCK(gen_op_simple(DUP), a, ------------------ | | 102| 546| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 546|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 546| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 546|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 546|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 938| 546| gen_condbranch(BLOCK(gen_op_simple(POP), gen_const(jv_true())), 939| 546| BLOCK(gen_op_simple(POP), 940| 546| b, 941| 546| gen_condbranch(gen_const(jv_true()), 942| 546| gen_const(jv_false()))))); 943| 546|} gen_destructure_alt: 945| 4.96k|block gen_destructure_alt(block matcher) { 946| 9.93k| for (inst *i = matcher.first; i; i = i->next) { ------------------ | Branch (946:33): [True: 4.96k, False: 4.96k] ------------------ 947| 4.96k| if (i->op == STOREV) { ------------------ | Branch (947:9): [True: 4.96k, False: 0] ------------------ 948| 4.96k| i->op = STOREVN; 949| 4.96k| } 950| 4.96k| } 951| 4.96k| inst* i = inst_new(DESTRUCTURE_ALT); 952| 4.96k| i->subfn = matcher; 953| 4.96k| return inst_block(i); 954| 4.96k|} gen_var_binding: 956| 7.05k|block gen_var_binding(block var, const char* name, block body) { 957| 7.05k| return gen_destructure(var, gen_op_unbound(STOREV, name), body); 958| 7.05k|} gen_array_matcher: 960| 165|block gen_array_matcher(block left, block curr) { 961| 165| int index; 962| 165| if (block_is_noop(left)) ------------------ | Branch (962:7): [True: 35, False: 130] ------------------ 963| 35| index = 0; 964| 130| else { 965| | // `left` was returned by this function, so the third inst is the 966| | // constant containing the previously used index 967| 130| assert(left.first->op == DUP); ------------------ | Branch (967:5): [True: 0, False: 130] | Branch (967:5): [True: 130, False: 0] ------------------ 968| 130| assert(left.first->next != NULL); ------------------ | Branch (968:5): [True: 0, False: 130] | Branch (968:5): [True: 130, False: 0] ------------------ 969| 130| inst *i = NULL; 970| 130| if (left.first->next->op == PUSHK_UNDER) { ------------------ | Branch (970:9): [True: 130, False: 0] ------------------ 971| 130| i = left.first->next; 972| 130| } else { 973| 0| assert(left.first->next->op == SUBEXP_BEGIN); ------------------ | Branch (973:7): [True: 0, False: 0] | Branch (973:7): [True: 0, False: 0] ------------------ 974| 0| assert(left.first->next->next->op == LOADK); ------------------ | Branch (974:7): [True: 0, False: 0] | Branch (974:7): [True: 0, False: 0] ------------------ 975| 0| i = left.first->next->next; 976| 0| } 977| 130| index = 1 + (int) jv_number_value(i->imm.constant); 978| 130| } 979| | 980| | // `left` goes at the end so that the const index is in a predictable place 981| 165| return BLOCK(gen_op_simple(DUP), gen_subexp(gen_const(jv_number(index))), ------------------ | | 102| 165| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 165|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 165| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 95| 165|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | ------------------ | | | | | | | | | | 94| 165|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 93| 165|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 92| 165|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 982| 165| gen_op_simple(INDEX), curr, left); 983| 165|} gen_object_matcher: 985| 2.58k|block gen_object_matcher(block name, block curr) { 986| 2.58k| return BLOCK(gen_op_simple(DUP), gen_subexp(name), gen_op_simple(INDEX), ------------------ | | 102| 2.58k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 2.58k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 2.58k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 2.58k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 2.58k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 2.58k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 987| 2.58k| curr); 988| 2.58k|} gen_destructure: 990| 12.5k|block gen_destructure(block var, block matchers, block body) { 991| | // var bindings can be added after coding the program; leave the TOP first. 992| 12.5k| block top = gen_noop(); 993| 12.5k| if (body.first && body.first->op == TOP) ------------------ | Branch (993:7): [True: 11.7k, False: 824] | Branch (993:21): [True: 0, False: 11.7k] ------------------ 994| 0| top = inst_block(block_take(&body)); 995| | 996| 12.5k| if (matchers.first && matchers.first->op == DESTRUCTURE_ALT) { ------------------ | Branch (996:7): [True: 12.5k, False: 0] | Branch (996:25): [True: 1.34k, False: 11.2k] ------------------ 997| 1.34k| block_append(&var, gen_op_simple(DUP)); 998| 11.2k| } else { 999| 11.2k| top = BLOCK(top, gen_op_simple(DUP)); ------------------ | | 102| 11.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 11.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 11.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 11.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1000| 11.2k| } 1001| | 1002| 12.5k| return BLOCK(top, gen_subexp(var), gen_op_simple(POP), bind_alternation_matchers(matchers, body)); ------------------ | | 102| 12.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 12.5k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 12.5k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 12.5k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 12.5k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 12.5k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1003| 12.5k|} gen_cond: 1012| 9.25k|block gen_cond(block cond, block iftrue, block iffalse) { 1013| 9.25k| return BLOCK(gen_op_simple(DUP), BLOCK(gen_subexp(cond), gen_op_simple(POP)), ------------------ | | 102| 9.25k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 9.25k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 9.25k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 9.25k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 9.25k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1014| 9.25k| gen_condbranch(BLOCK(gen_op_simple(POP), iftrue), 1015| 9.25k| BLOCK(gen_op_simple(POP), iffalse))); 1016| 9.25k|} gen_try: 1018| 4.53k|block gen_try(block exp, block handler) { 1019| | /* 1020| | * Produce: 1021| | * 1022| | * TRY_BEGIN handler 1023| | * 1024| | * TRY_END 1025| | * JUMP past_handler 1026| | * handler: 1027| | * past_handler: 1028| | * 1029| | * If backtracks then TRY_BEGIN will backtrack. 1030| | * 1031| | * If produces a value then we'll execute whatever bytecode follows 1032| | * this sequence. If that code raises an exception, then TRY_END will wrap 1033| | * and re-raise that exception, and TRY_BEGIN will unwrap and re-raise the 1034| | * exception (see jq_next()). 1035| | * 1036| | * If raises then the TRY_BEGIN will see a non-wrapped exception and 1037| | * will jump to the handler (note the TRY_END will not execute in this case), 1038| | * and if the handler produces any values, then we'll execute whatever 1039| | * bytecode follows this sequence. Note that TRY_END will not execute in 1040| | * this case, so if the handler raises an exception, or code past the handler 1041| | * raises an exception, then that exception won't be wrapped and re-raised, 1042| | * and the TRY_BEGIN will not catch it because it does not stack_save() when 1043| | * it branches to the handler. 1044| | */ 1045| | 1046| 4.53k| if (block_is_noop(handler)) ------------------ | Branch (1046:7): [True: 239, False: 4.29k] ------------------ 1047| 239| handler = BLOCK(gen_op_simple(DUP), gen_op_simple(POP)); ------------------ | | 102| 239| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 239|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 239| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 239|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1048| | 1049| 4.53k| block jump = gen_op_target(JUMP, handler); 1050| 4.53k| return BLOCK(gen_op_target(TRY_BEGIN, jump), exp, gen_op_simple(TRY_END), ------------------ | | 102| 4.53k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 4.53k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 4.53k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 95| 4.53k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | ------------------ | | | | | | | | | | 94| 4.53k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 93| 4.53k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 92| 4.53k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1051| 4.53k| jump, handler); 1052| 4.53k|} gen_label: 1054| 1.57k|block gen_label(const char *label, block exp) { 1055| 1.57k| block cond = gen_call("_equal", 1056| 1.57k| BLOCK(gen_lambda(gen_noop()), ------------------ | | 102| 1.57k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.57k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.57k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 1.57k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1057| 1.57k| gen_lambda(gen_op_unbound(LOADV, label)))); 1058| 1.57k| return gen_wildvar_binding(gen_op_simple(GENLABEL), label, 1059| 1.57k| BLOCK(gen_op_simple(POP), ------------------ | | 102| 1.57k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.57k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.57k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 1.57k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1060| | // try exp catch if . == $label 1061| | // then empty 1062| | // else error end 1063| | // 1064| | // Can't use gen_binop(), as that's firmly 1065| | // stuck in parser.y as it refers to things 1066| | // like EQ. 1067| 1.57k| gen_try(exp, 1068| 1.57k| gen_cond(cond, 1069| 1.57k| gen_op_simple(BACKTRACK), 1070| 1.57k| gen_call("error", gen_noop()))))); 1071| 1.57k|} gen_cbinding: 1073| 181|block gen_cbinding(const struct cfunction* cfunctions, int ncfunctions, block code) { 1074| 24.9k| for (int cfunc=0; cfuncimm.cfunc = &cfunctions[cfunc]; 1077| 24.7k| i->symbol = strdup(cfunctions[cfunc].name); 1078| 24.7k| i->nformals = cfunctions[cfunc].nargs - 1; 1079| 24.7k| i->any_unbound = 0; 1080| 24.7k| code = BLOCK(inst_block(i), code); ------------------ | | 102| 24.7k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 24.7k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 24.7k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 24.7k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1081| 24.7k| } 1082| 181| return code; 1083| 181|} block_compile: 1374| 181|int block_compile(block b, struct bytecode** out, struct locfile* lf, jv args) { 1375| 181| struct bytecode* bc = jv_mem_alloc(sizeof(struct bytecode)); 1376| 181| bc->parent = 0; 1377| 181| bc->nclosures = 0; 1378| 181| bc->globals = jv_mem_alloc(sizeof(struct symbol_table)); 1379| 181| int ncfunc = count_cfunctions(b); 1380| 181| bc->globals->ncfunctions = 0; 1381| 181| bc->globals->cfunctions = jv_mem_calloc(MAX(ncfunc, 1), sizeof(struct cfunction)); ------------------ | | 77| 181| ({ __typeof__ (a) _a = (a); \ | | 78| 181| __typeof__ (b) _b = (b); \ | | 79| 181| _a > _b ? _a : _b; }) | | ------------------ | | | Branch (79:4): [True: 58, False: 123] | | ------------------ ------------------ 1382| 181| bc->globals->cfunc_names = jv_array(); 1383| 181| bc->debuginfo = jv_object_set(jv_object(), jv_string("name"), jv_null()); 1384| 181| jv env = jv_invalid(); 1385| 181| int nerrors = compile(bc, b, lf, args, &env); 1386| 181| jv_free(args); 1387| 181| jv_free(env); 1388| 181| assert(bc->globals->ncfunctions == ncfunc); ------------------ | Branch (1388:3): [True: 0, False: 181] | Branch (1388:3): [True: 181, False: 0] ------------------ 1389| 181| if (nerrors > 0) { ------------------ | Branch (1389:7): [True: 34, False: 147] ------------------ 1390| 34| bytecode_free(bc); 1391| 34| *out = 0; 1392| 147| } else { 1393| 147| *out = bc; 1394| 147| } 1395| 181| return nerrors; 1396| 181|} block_free: 1398| 8.17M|void block_free(block b) { 1399| 8.17M| struct inst* next; 1400| 11.8M| for (struct inst* curr = b.first; curr; curr = next) { ------------------ | Branch (1400:37): [True: 3.65M, False: 8.17M] ------------------ 1401| 3.65M| next = curr->next; 1402| 3.65M| inst_free(curr); 1403| 3.65M| } 1404| 8.17M|} compile.c:inst_block: 97| 5.15M|static block inst_block(inst* i) { 98| 5.15M| block b = {i,i}; 99| 5.15M| return b; 100| 5.15M|} compile.c:inst_new: 67| 3.67M|static inst* inst_new(opcode op) { 68| 3.67M| inst* i = jv_mem_alloc(sizeof(inst)); 69| 3.67M| i->next = i->prev = 0; 70| 3.67M| i->op = op; 71| 3.67M| i->bytecode_pos = -1; 72| 3.67M| i->bound_by = 0; 73| 3.67M| i->symbol = 0; 74| 3.67M| i->any_unbound = 0; 75| 3.67M| i->referenced = 0; 76| 3.67M| i->nformals = -1; 77| 3.67M| i->nactuals = -1; 78| 3.67M| i->subfn = gen_noop(); 79| 3.67M| i->arglist = gen_noop(); 80| 3.67M| i->source = UNKNOWN_LOCATION; 81| 3.67M| i->locfile = 0; 82| 3.67M| return i; 83| 3.67M|} compile.c:inst_join: 240| 3.49M|static void inst_join(inst* a, inst* b) { 241| 3.49M| assert(a && b); ------------------ | Branch (241:3): [True: 0, False: 3.49M] | Branch (241:3): [True: 0, False: 0] | Branch (241:3): [True: 3.49M, False: 0] | Branch (241:3): [True: 3.49M, False: 0] ------------------ 242| 3.49M| assert(!a->next); ------------------ | Branch (242:3): [True: 0, False: 3.49M] | Branch (242:3): [True: 3.49M, False: 0] ------------------ 243| 3.49M| assert(!b->prev); ------------------ | Branch (243:3): [True: 0, False: 3.49M] | Branch (243:3): [True: 3.49M, False: 0] ------------------ 244| 3.49M| a->next = b; 245| 3.49M| b->prev = a; 246| 3.49M|} compile.c:block_bind_subblock: 352| 661k|static int block_bind_subblock(block binder, block body, int bindflags, int break_distance) { 353| 661k| int any_unbound; 354| 661k| return block_bind_subblock_inner(&any_unbound, binder, body, bindflags, break_distance); 355| 661k|} compile.c:block_bind_subblock_inner: 306| 444M|static int block_bind_subblock_inner(int* any_unbound, block binder, block body, int bindflags, int break_distance) { 307| 444M| assert(block_is_single(binder)); ------------------ | Branch (307:3): [True: 0, False: 444M] | Branch (307:3): [True: 444M, False: 0] ------------------ 308| 444M| assert((opcode_describe(binder.first->op)->flags & bindflags) == (bindflags & ~OP_BIND_WILDCARD)); ------------------ | Branch (308:3): [True: 0, False: 444M] | Branch (308:3): [True: 444M, False: 0] ------------------ 309| 444M| assert(binder.first->symbol); ------------------ | Branch (309:3): [True: 0, False: 444M] | Branch (309:3): [True: 444M, False: 0] ------------------ 310| 444M| assert(binder.first->bound_by == 0 || binder.first->bound_by == binder.first); ------------------ | Branch (310:3): [True: 444M, False: 0] | Branch (310:3): [True: 0, False: 0] | Branch (310:3): [True: 640k, False: 443M] | Branch (310:3): [True: 443M, False: 0] ------------------ 311| 444M| assert(break_distance >= 0); ------------------ | Branch (311:3): [True: 0, False: 444M] | Branch (311:3): [True: 444M, False: 0] ------------------ 312| | 313| 444M| binder.first->bound_by = binder.first; 314| 444M| int nrefs = 0; 315| 915M| for (inst* i = body.first; i; i = i->next) { ------------------ | Branch (315:30): [True: 471M, False: 444M] ------------------ 316| 471M| if (i->any_unbound == 0) ------------------ | Branch (316:9): [True: 249M, False: 221M] ------------------ 317| 249M| continue; 318| | 319| 221M| int flags = opcode_describe(i->op)->flags; 320| 221M| if ((flags & bindflags) == (bindflags & ~OP_BIND_WILDCARD) && i->bound_by == 0 && ------------------ | Branch (320:9): [True: 220M, False: 1.52M] | Branch (320:67): [True: 109M, False: 111M] ------------------ 321| 109M| (!strcmp(i->symbol, binder.first->symbol) || ------------------ | Branch (321:10): [True: 205k, False: 108M] ------------------ 322| | // Check for break/break2/break3; see parser.y 323| 108M| ((bindflags & OP_BIND_WILDCARD) && i->symbol[0] == '*' && ------------------ | Branch (323:11): [True: 2.21k, False: 108M] | Branch (323:45): [True: 318, False: 1.89k] ------------------ 324| 318| break_distance <= 3 && (i->symbol[1] == '1' + break_distance) && ------------------ | Branch (324:11): [True: 318, False: 0] | Branch (324:34): [True: 0, False: 318] ------------------ 325| 205k| i->symbol[2] == '\0'))) { ------------------ | Branch (325:11): [True: 0, False: 0] ------------------ 326| | // bind this instruction 327| 205k| if (i->nactuals == -1 || i->nactuals == binder.first->nformals) { ------------------ | Branch (327:11): [True: 33.5k, False: 171k] | Branch (327:32): [True: 165k, False: 6.40k] ------------------ 328| 198k| i->bound_by = binder.first; 329| 198k| nrefs++; 330| 198k| } 331| 221M| } else if ((flags & bindflags) == (bindflags & ~OP_BIND_WILDCARD) && i->bound_by != 0 && ------------------ | Branch (331:16): [True: 220M, False: 1.52M] | Branch (331:74): [True: 111M, False: 108M] ------------------ 332| 111M| !strncmp(binder.first->symbol, "*anonlabel", sizeof("*anonlabel") - 1) && ------------------ | Branch (332:16): [True: 0, False: 111M] ------------------ 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| 221M| i->any_unbound = (i->symbol && !i->bound_by); ------------------ | Branch (339:23): [True: 221M, False: 0] | Branch (339:36): [True: 110M, False: 111M] ------------------ 340| | 341| | // binding recurses into closures 342| 221M| nrefs += block_bind_subblock_inner(&i->any_unbound, binder, i->subfn, bindflags, break_distance); 343| | // binding recurses into argument list 344| 221M| nrefs += block_bind_subblock_inner(&i->any_unbound, binder, i->arglist, bindflags, break_distance); 345| | 346| 221M| if (i->any_unbound) ------------------ | Branch (346:9): [True: 221M, False: 688k] ------------------ 347| 221M| *any_unbound = 1; 348| 221M| } 349| 444M| return nrefs; 350| 444M|} compile.c:block_take_last: 404| 47.6k|static inst* block_take_last(block* b) { 405| 47.6k| inst* i = b->last; 406| 47.6k| if (i == 0) ------------------ | Branch (406:7): [True: 1.44k, False: 46.1k] ------------------ 407| 1.44k| return 0; 408| 46.1k| if (i->prev) { ------------------ | Branch (408:7): [True: 44.7k, False: 1.44k] ------------------ 409| 44.7k| i->prev->next = i->next; 410| 44.7k| b->last = i->prev; 411| 44.7k| i->prev = 0; 412| 44.7k| } else { 413| 1.44k| b->first = 0; 414| 1.44k| b->last = 0; 415| 1.44k| } 416| 46.1k| return i; 417| 47.6k|} compile.c:block_mark_referenced: 451| 2.44M|static void block_mark_referenced(block body) { 452| 2.44M| int saw_top = 0; 453| 3.66M| for (inst* i = body.last; i; i = i->prev) { ------------------ | Branch (453:29): [True: 1.22M, False: 2.44M] ------------------ 454| 1.22M| if (saw_top && i->bound_by == i && !i->referenced) ------------------ | Branch (454:9): [True: 0, False: 1.22M] | Branch (454:20): [True: 0, False: 0] | Branch (454:40): [True: 0, False: 0] ------------------ 455| 0| continue; 456| 1.22M| if (i->op == TOP) { ------------------ | Branch (456:9): [True: 181, False: 1.22M] ------------------ 457| 181| saw_top = 1; 458| 181| } 459| 1.22M| if (i->bound_by) { ------------------ | Branch (459:9): [True: 475k, False: 747k] ------------------ 460| 475k| i->bound_by->referenced = 1; 461| 475k| } 462| | 463| 1.22M| block_mark_referenced(i->arglist); 464| 1.22M| block_mark_referenced(i->subfn); 465| 1.22M| } 466| 2.44M|} compile.c:block_take: 106| 1.51M|static inst* block_take(block* b) { 107| 1.51M| if (b->first == 0) return 0; ------------------ | Branch (107:7): [True: 108k, False: 1.41M] ------------------ 108| 1.41M| inst* i = b->first; 109| 1.41M| if (i->next) { ------------------ | Branch (109:7): [True: 1.30M, False: 101k] ------------------ 110| 1.30M| i->next->prev = 0; 111| 1.30M| b->first = i->next; 112| 1.30M| i->next = 0; 113| 1.30M| } else { 114| 101k| b->first = 0; 115| 101k| b->last = 0; 116| 101k| } 117| 1.41M| return i; 118| 1.51M|} compile.c:inst_free: 85| 3.67M|static void inst_free(struct inst* i) { 86| 3.67M| jv_mem_free(i->symbol); 87| 3.67M| block_free(i->subfn); 88| 3.67M| block_free(i->arglist); 89| 3.67M| if (i->locfile) ------------------ | Branch (89:7): [True: 204k, False: 3.47M] ------------------ 90| 204k| locfile_free(i->locfile); 91| 3.67M| if (opcode_describe(i->op)->flags & OP_HAS_CONSTANT) { ------------------ | Branch (91:7): [True: 1.18M, False: 2.49M] ------------------ 92| 1.18M| jv_free(i->imm.constant); 93| 1.18M| } 94| 3.67M| jv_mem_free(i); 95| 3.67M|} compile.c:block_count_actuals: 291| 387k|static int block_count_actuals(block b) { 292| 387k| int args = 0; 293| 934k| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (293:27): [True: 546k, False: 387k] ------------------ 294| 546k| switch (i->op) { 295| 0| default: assert(0 && "Unknown function type"); break; ------------------ | Branch (295:5): [True: 0, False: 546k] | 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| 546k| case CLOSURE_CREATE: ------------------ | Branch (296:5): [True: 546k, False: 0] ------------------ 297| 546k| case CLOSURE_PARAM: ------------------ | Branch (297:5): [True: 0, False: 546k] ------------------ 298| 546k| case CLOSURE_CREATE_C: ------------------ | Branch (298:5): [True: 0, False: 546k] ------------------ 299| 546k| args++; 300| 546k| break; 301| 546k| } 302| 546k| } 303| 387k| return args; 304| 387k|} compile.c:gen_const_array: 671| 184k|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| 184k| int all_const = 1; 695| 184k| int commas = 0; 696| 184k| int normal = 1; 697| 184k| jv a = jv_array(); 698| 497k| for (inst *i = expr.first; i; i = i->next) { ------------------ | Branch (698:30): [True: 357k, False: 140k] ------------------ 699| 357k| if (i->op == FORK) { ------------------ | Branch (699:9): [True: 52.7k, False: 304k] ------------------ 700| 52.7k| commas++; 701| 52.7k| if (i->imm.target == NULL || i->imm.target->op != JUMP || ------------------ | Branch (701:11): [True: 0, False: 52.7k] | Branch (701:36): [True: 44.5k, False: 8.20k] ------------------ 702| 44.6k| jv_array_length(jv_copy(a)) > 0) { ------------------ | Branch (702:11): [True: 156, False: 8.04k] ------------------ 703| 44.6k| normal = 0; 704| 44.6k| break; 705| 44.6k| } 706| 304k| } else if (all_const && i->op == LOADK) { ------------------ | Branch (706:16): [True: 197k, False: 106k] | Branch (706:29): [True: 141k, False: 56.0k] ------------------ 707| 141k| if (i->next != NULL && i->next->op != JUMP) { ------------------ | Branch (707:11): [True: 6.56k, False: 134k] | Branch (707:30): [True: 14, False: 6.55k] ------------------ 708| 14| normal = 0; 709| 14| break; 710| 14| } 711| 141k| a = jv_array_append(a, jv_copy(i->imm.constant)); 712| 162k| } else if (i->op != JUMP || i->imm.target == NULL || ------------------ | Branch (712:16): [True: 154k, False: 8.59k] | Branch (712:33): [True: 0, False: 8.59k] ------------------ 713| 155k| i->imm.target->op != LOADK) { ------------------ | Branch (713:16): [True: 1.57k, False: 7.01k] ------------------ 714| 155k| all_const = 0; 715| 155k| } 716| 357k| } 717| | 718| 184k| if (all_const && normal && ------------------ | Branch (718:7): [True: 135k, False: 49.6k] | Branch (718:20): [True: 135k, False: 14] ------------------ 719| 135k| (expr.last == NULL || expr.last->op == LOADK) && ------------------ | Branch (719:8): [True: 252, False: 134k] | Branch (719:29): [True: 134k, False: 0] ------------------ 720| 135k| jv_array_length(jv_copy(a)) == commas + 1) { ------------------ | Branch (720:7): [True: 134k, False: 434] ------------------ 721| 134k| block_free(expr); 722| 134k| return gen_const(a); 723| 134k| } 724| | 725| 50.1k| jv_free(a); 726| 50.1k| block b = {0,0}; 727| 50.1k| return b; 728| 184k|} compile.c:bind_alternation_matchers: 782| 15.4k|static block bind_alternation_matchers(block matchers, block body) { 783| 15.4k| block preamble = {0}; 784| 15.4k| block altmatchers = {0}; 785| 15.4k| block mb = {0}; 786| 15.4k| block final_matcher = matchers; 787| | 788| | // Pass through the matchers to find all destructured names. 789| 19.1k| while (final_matcher.first && final_matcher.first->op == DESTRUCTURE_ALT) { ------------------ | Branch (789:10): [True: 19.1k, False: 0] | Branch (789:33): [True: 3.74k, False: 15.4k] ------------------ 790| 3.74k| block_append(&altmatchers, inst_block(block_take(&final_matcher))); 791| 3.74k| } 792| | 793| | // We don't have any alternations here, so we can use the simplest case. 794| 15.4k| if (altmatchers.first == NULL) { ------------------ | Branch (794:7): [True: 14.1k, False: 1.34k] ------------------ 795| 14.1k| return bind_matcher(final_matcher, body); 796| 14.1k| } 797| | 798| | // Collect var names 799| 1.34k| jv all_vars = jv_object(); 800| 1.34k| block_get_unbound_vars(altmatchers, &all_vars); 801| 1.34k| 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| 5.03k| jv_object_keys_foreach(all_vars, key) { ------------------ | | 180| 2.68k| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (180:52): [True: 1.34k, False: 1.34k] | | ------------------ | | 181| 1.34k| for (jv k; \ | | 182| 6.38k| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (182:10): [True: 5.03k, False: 1.34k] | | | Branch (182:10): [True: 5.03k, False: 1.34k] | | ------------------ | | 183| 6.38k| (k = jv_object_iter_key(t, jv_i__), \ | | 184| 5.03k| 1) \ | | 185| 6.38k| : 0; \ | | 186| 5.03k| jv_i__ = jv_object_iter_next(t, jv_i__)) ------------------ 805| 5.03k| preamble = BLOCK(preamble, ------------------ | | 102| 5.03k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 5.03k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 5.03k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 5.03k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 5.03k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 5.03k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 806| 5.03k| gen_op_simple(DUP), 807| 5.03k| gen_const(jv_null()), 808| 5.03k| gen_op_unbound(STOREV, jv_string_value(key))); 809| 5.03k| jv_free(key); 810| 5.03k| } 811| 1.34k| jv_free(all_vars); 812| | 813| | // Now we build each matcher in turn 814| 5.08k| for (inst *i = altmatchers.first; i; i = i->next) { ------------------ | Branch (814:37): [True: 3.74k, False: 1.34k] ------------------ 815| 3.74k| block submatcher = i->subfn; 816| | 817| | // If we're successful, jump to the end of the matchers 818| 3.74k| submatcher = BLOCK(submatcher, gen_op_target(JUMP, final_matcher)); ------------------ | | 102| 3.74k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 3.74k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 3.74k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 3.74k|#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| 3.74k| mb = BLOCK(mb, gen_op_target(DESTRUCTURE_ALT, submatcher), submatcher); ------------------ | | 102| 3.74k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 3.74k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 3.74k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 3.74k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 3.74k|#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| 3.74k| i->subfn.first = i->subfn.last = NULL; 826| 3.74k| } 827| | // We're done with these insts now. 828| 1.34k| block_free(altmatchers); 829| | 830| 1.34k| return bind_matcher(preamble, BLOCK(mb, final_matcher, body)); ------------------ | | 102| 1.34k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.34k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.34k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 1.34k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 1.34k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 831| 15.4k|} compile.c:bind_matcher: 748| 15.4k|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| 47.0k| for (inst* i = matcher.first; i; i = i->next) { ------------------ | Branch (752:33): [True: 31.6k, False: 15.4k] ------------------ 753| 31.6k| if ((i->op == STOREV || i->op == STOREVN) && !i->bound_by) ------------------ | Branch (753:10): [True: 19.4k, False: 12.1k] | Branch (753:29): [True: 128, False: 12.0k] | Branch (753:50): [True: 19.3k, False: 272] ------------------ 754| 19.3k| block_bind_subblock(inst_block(i), body, OP_HAS_VARIABLE, 0); 755| 31.6k| } 756| 15.4k| return BLOCK(matcher, body); ------------------ | | 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__) | | | | | | ------------------ | | | | | | | | 92| 15.4k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 757| 15.4k|} compile.c:block_get_unbound_vars: 762| 6.43k|static void block_get_unbound_vars(block b, jv *vars) { 763| 6.43k| assert(vars != NULL); ------------------ | Branch (763:3): [True: 0, False: 6.43k] | Branch (763:3): [True: 6.43k, False: 0] ------------------ 764| 6.43k| assert(jv_get_kind(*vars) == JV_KIND_OBJECT); ------------------ | Branch (764:3): [True: 0, False: 6.43k] | Branch (764:3): [True: 6.43k, False: 0] ------------------ 765| 15.2k| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (765:27): [True: 8.83k, False: 6.43k] ------------------ 766| 8.83k| if (i->subfn.first) { ------------------ | Branch (766:9): [True: 3.74k, False: 5.08k] ------------------ 767| 3.74k| block_get_unbound_vars(i->subfn, vars); 768| 3.74k| continue; 769| 3.74k| } 770| 5.08k| if ((i->op == STOREV || i->op == STOREVN) && i->bound_by == NULL) { ------------------ | Branch (770:10): [True: 1.34k, False: 3.74k] | Branch (770:29): [True: 3.74k, False: 0] | Branch (770:50): [True: 5.08k, False: 0] ------------------ 771| 5.08k| *vars = jv_object_set(*vars, jv_string(i->symbol), jv_true()); 772| 5.08k| } 773| 5.08k| } 774| 6.43k|} compile.c:gen_wildvar_binding: 1006| 1.57k|static block gen_wildvar_binding(block var, const char* name, block body) { 1007| 1.57k| return BLOCK(gen_op_simple(DUP), var, ------------------ | | 102| 1.57k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.57k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.57k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 1.57k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 1.57k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1008| 1.57k| block_bind(gen_op_unbound(STOREV, name), 1009| 1.57k| body, OP_HAS_VARIABLE | OP_BIND_WILDCARD)); 1010| 1.57k|} compile.c:block_bind: 367| 1.57k|static block block_bind(block binder, block body, int bindflags) { 368| 1.57k| block_bind_each(binder, body, bindflags); 369| 1.57k| return block_join(binder, body); 370| 1.57k|} compile.c:block_bind_each: 357| 1.57k|static int block_bind_each(block binder, block body, int bindflags) { 358| 1.57k| assert(block_has_only_binders(binder, bindflags)); ------------------ | Branch (358:3): [True: 0, False: 1.57k] | Branch (358:3): [True: 1.57k, False: 0] ------------------ 359| 1.57k| bindflags |= OP_HAS_BINDING; 360| 1.57k| int nrefs = 0; 361| 3.15k| for (inst* curr = binder.first; curr; curr = curr->next) { ------------------ | Branch (361:35): [True: 1.57k, False: 1.57k] ------------------ 362| 1.57k| nrefs += block_bind_subblock(inst_block(curr), body, bindflags, 0); 363| 1.57k| } 364| 1.57k| return nrefs; 365| 1.57k|} compile.c:count_cfunctions: 1096| 614k|static int count_cfunctions(block b) { 1097| 614k| int n = 0; 1098| 1.22M| for (inst* i = b.first; i; i = i->next) { ------------------ | Branch (1098:27): [True: 614k, False: 614k] ------------------ 1099| 614k| if (i->op == CLOSURE_CREATE_C) n++; ------------------ | Branch (1099:9): [True: 271, False: 613k] ------------------ 1100| 614k| n += count_cfunctions(i->subfn); 1101| 614k| } 1102| 614k| return n; 1103| 614k|} compile.c:compile: 1219| 9.07k|static int compile(struct bytecode* bc, block b, struct locfile* lf, jv args, jv *env) { 1220| 9.07k| int errors = 0; 1221| 9.07k| int pos = 0; 1222| 9.07k| int var_frame_idx = 0; 1223| 9.07k| bc->nsubfunctions = 0; 1224| 9.07k| errors += expand_call_arglist(&b, args, env); 1225| 9.07k| b = BLOCK(b, gen_op_simple(RET)); ------------------ | | 102| 9.07k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 9.07k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 9.07k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 9.07k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1226| 9.07k| jv localnames = jv_array(); 1227| 502k| for (inst* curr = b.first; curr; curr = curr->next) { ------------------ | Branch (1227:30): [True: 493k, False: 9.07k] ------------------ 1228| 493k| if (!curr->next) assert(curr == b.last); ------------------ | Branch (1228:9): [True: 9.07k, False: 484k] | Branch (1228:22): [True: 0, False: 9.07k] | Branch (1228:22): [True: 9.07k, False: 0] ------------------ 1229| 493k| int length = opcode_describe(curr->op)->length; 1230| 493k| if (curr->op == CALL_JQ) { ------------------ | Branch (1230:9): [True: 15.3k, False: 478k] ------------------ 1231| 97.4k| for (inst* arg = curr->arglist.first; arg; arg = arg->next) { ------------------ | Branch (1231:45): [True: 82.0k, False: 15.3k] ------------------ 1232| 82.0k| length += 2; 1233| 82.0k| } 1234| 15.3k| } 1235| 493k| pos += length; 1236| 493k| curr->bytecode_pos = pos; 1237| 493k| curr->compiled = bc; 1238| | 1239| 493k| assert(curr->op != CLOSURE_REF && curr->op != CLOSURE_PARAM); ------------------ | Branch (1239:5): [True: 0, False: 493k] | Branch (1239:5): [True: 0, False: 0] | Branch (1239:5): [True: 493k, False: 0] | Branch (1239:5): [True: 493k, False: 0] ------------------ 1240| | 1241| 493k| if ((opcode_describe(curr->op)->flags & OP_HAS_VARIABLE) && ------------------ | Branch (1241:9): [True: 66.7k, False: 426k] ------------------ 1242| 66.7k| curr->bound_by == curr) { ------------------ | Branch (1242:9): [True: 26.0k, False: 40.7k] ------------------ 1243| 26.0k| curr->imm.intval = var_frame_idx++; 1244| 26.0k| localnames = jv_array_append(localnames, jv_string(curr->symbol)); 1245| 26.0k| } 1246| | 1247| 493k| if (curr->op == CLOSURE_CREATE) { ------------------ | Branch (1247:9): [True: 23.3k, False: 470k] ------------------ 1248| 23.3k| assert(curr->bound_by == curr); ------------------ | Branch (1248:7): [True: 0, False: 23.3k] | Branch (1248:7): [True: 23.3k, False: 0] ------------------ 1249| | // Prevent subfunction index from overflowing into ARG_NEWCLOSURE flag 1250| 23.3k| if (bc->nsubfunctions >= ARG_NEWCLOSURE) { ------------------ | | 70| 23.3k|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (1250:11): [True: 3, False: 23.3k] ------------------ 1251| 3| locfile_locate(lf, curr->source, 1252| 3| "too many function parameters or local function definitions (max %d)", ARG_NEWCLOSURE - 1); ------------------ | | 70| 3|#define ARG_NEWCLOSURE 0x1000 ------------------ 1253| 3| errors++; 1254| 3| break; 1255| 3| } 1256| 23.3k| curr->imm.intval = bc->nsubfunctions++; 1257| 23.3k| } 1258| 493k| if (curr->op == CLOSURE_CREATE_C) { ------------------ | Branch (1258:9): [True: 271, False: 493k] ------------------ 1259| 271| assert(curr->bound_by == curr); ------------------ | Branch (1259:7): [True: 0, False: 271] | Branch (1259:7): [True: 271, False: 0] ------------------ 1260| 271| int idx = bc->globals->ncfunctions++; 1261| 271| bc->globals->cfunc_names = jv_array_append(bc->globals->cfunc_names, 1262| 271| jv_string(curr->symbol)); 1263| 271| bc->globals->cfunctions[idx] = *curr->imm.cfunc; 1264| 271| curr->imm.intval = idx; 1265| 271| } 1266| 493k| } 1267| 9.07k| if (pos > 0xFFFF) { ------------------ | Branch (1267:7): [True: 3, False: 9.07k] ------------------ 1268| | // too long for program counter to fit in uint16_t 1269| 3| locfile_locate(lf, UNKNOWN_LOCATION, 1270| 3| "function compiled to %d bytes which is too long", pos); 1271| 3| errors++; 1272| 3| } 1273| 9.07k| bc->codelen = pos; 1274| 9.07k| bc->debuginfo = jv_object_set(bc->debuginfo, jv_string("locals"), localnames); 1275| 9.07k| if (bc->nsubfunctions && !errors) { ------------------ | Branch (1275:7): [True: 1.68k, False: 7.38k] | Branch (1275:28): [True: 1.64k, False: 43] ------------------ 1276| 1.64k| bc->subfunctions = jv_mem_calloc(bc->nsubfunctions, sizeof(struct bytecode*)); 1277| 53.9k| for (inst* curr = b.first; curr; curr = curr->next) { ------------------ | Branch (1277:32): [True: 52.3k, False: 1.64k] ------------------ 1278| 52.3k| if (curr->op == CLOSURE_CREATE) { ------------------ | Branch (1278:11): [True: 8.89k, False: 43.4k] ------------------ 1279| 8.89k| struct bytecode* subfn = jv_mem_alloc(sizeof(struct bytecode)); 1280| 8.89k| bc->subfunctions[curr->imm.intval] = subfn; 1281| 8.89k| subfn->globals = bc->globals; 1282| 8.89k| subfn->parent = bc; 1283| 8.89k| subfn->nclosures = 0; 1284| 8.89k| subfn->debuginfo = jv_object_set(jv_object(), jv_string("name"), jv_string(curr->symbol)); 1285| 8.89k| jv params = jv_array(); 1286| 9.00k| for (inst* param = curr->arglist.first; param; param = param->next) { ------------------ | Branch (1286:49): [True: 109, False: 8.89k] ------------------ 1287| 109| assert(param->op == CLOSURE_PARAM); ------------------ | Branch (1287:11): [True: 0, False: 109] | Branch (1287:11): [True: 109, False: 0] ------------------ 1288| 109| assert(param->bound_by == param); ------------------ | Branch (1288:11): [True: 0, False: 109] | Branch (1288:11): [True: 109, False: 0] ------------------ 1289| | // Prevent closure index from overflowing into ARG_NEWCLOSURE flag 1290| 109| if (subfn->nclosures >= ARG_NEWCLOSURE) { ------------------ | | 70| 109|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (1290:15): [True: 0, False: 109] ------------------ 1291| 0| locfile_locate(lf, curr->source, 1292| 0| "function has too many parameters (max %d)", ARG_NEWCLOSURE - 1); ------------------ | | 70| 0|#define ARG_NEWCLOSURE 0x1000 ------------------ 1293| 0| errors++; 1294| 0| break; 1295| 0| } 1296| 109| param->imm.intval = subfn->nclosures++; 1297| 109| param->compiled = subfn; 1298| 109| params = jv_array_append(params, jv_string(param->symbol)); 1299| 109| } 1300| 8.89k| subfn->debuginfo = jv_object_set(subfn->debuginfo, jv_string("params"), params); 1301| 8.89k| errors += compile(subfn, curr->subfn, lf, args, env); 1302| 8.89k| curr->subfn = gen_noop(); 1303| 8.89k| } 1304| 52.3k| } 1305| 7.43k| } else { 1306| 7.43k| bc->nsubfunctions = 0; 1307| 7.43k| bc->subfunctions = 0; 1308| 7.43k| } 1309| 9.07k| if (errors) { ------------------ | Branch (1309:7): [True: 137, False: 8.93k] ------------------ 1310| 137| bc->code = 0; 1311| 137| bc->constants = jv_invalid(); 1312| 137| block_free(b); 1313| 137| return errors; 1314| 137| } 1315| 8.93k| uint16_t* code = jv_mem_calloc(bc->codelen, sizeof(uint16_t)); 1316| 8.93k| bc->code = code; 1317| 8.93k| pos = 0; 1318| 8.93k| jv constant_pool = jv_array(); 1319| 8.93k| int maxvar = -1; 1320| 323k| for (inst* curr = b.first; curr; curr = curr->next) { ------------------ | Branch (1320:30): [True: 314k, False: 8.93k] ------------------ 1321| 314k| const struct opcode_description* op = opcode_describe(curr->op); 1322| 314k| if (op->length == 0) ------------------ | Branch (1322:9): [True: 8.75k, False: 305k] ------------------ 1323| 8.75k| continue; 1324| 305k| code[pos++] = curr->op; 1325| 305k| assert(curr->op != CLOSURE_REF && curr->op != CLOSURE_PARAM); ------------------ | Branch (1325:5): [True: 0, False: 305k] | Branch (1325:5): [True: 0, False: 0] | Branch (1325:5): [True: 305k, False: 0] | Branch (1325:5): [True: 305k, False: 0] ------------------ 1326| 305k| if (curr->op == CALL_BUILTIN) { ------------------ | Branch (1326:9): [True: 9.40k, False: 296k] ------------------ 1327| 9.40k| assert(curr->bound_by->op == CLOSURE_CREATE_C); ------------------ | Branch (1327:7): [True: 0, False: 9.40k] | Branch (1327:7): [True: 9.40k, False: 0] ------------------ 1328| 9.40k| assert(!curr->arglist.first); ------------------ | Branch (1328:7): [True: 0, False: 9.40k] | Branch (1328:7): [True: 9.40k, False: 0] ------------------ 1329| 9.40k| code[pos++] = (uint16_t)curr->imm.intval; 1330| 9.40k| code[pos++] = curr->bound_by->imm.intval; 1331| 296k| } else if (curr->op == CALL_JQ) { ------------------ | Branch (1331:16): [True: 6.77k, False: 289k] ------------------ 1332| 6.77k| assert(curr->bound_by->op == CLOSURE_CREATE || ------------------ | Branch (1332:7): [True: 6.77k, False: 0] | Branch (1332:7): [True: 0, False: 0] | Branch (1332:7): [True: 6.66k, False: 109] | Branch (1332:7): [True: 109, False: 0] ------------------ 1333| 6.77k| curr->bound_by->op == CLOSURE_PARAM); 1334| 6.77k| code[pos++] = (uint16_t)curr->imm.intval; 1335| 6.77k| code[pos++] = nesting_level(bc, curr->bound_by); 1336| 6.77k| code[pos++] = curr->bound_by->imm.intval | 1337| 6.77k| (curr->bound_by->op == CLOSURE_CREATE ? ARG_NEWCLOSURE : 0); ------------------ | | 70| 6.66k|#define ARG_NEWCLOSURE 0x1000 ------------------ | Branch (1337:10): [True: 6.66k, False: 109] ------------------ 1338| 15.3k| for (inst* arg = curr->arglist.first; arg; arg = arg->next) { ------------------ | Branch (1338:45): [True: 8.57k, False: 6.77k] ------------------ 1339| 8.57k| assert(arg->op == CLOSURE_REF && arg->bound_by->op == CLOSURE_CREATE); ------------------ | Branch (1339:9): [True: 0, False: 8.57k] | Branch (1339:9): [True: 0, False: 0] | Branch (1339:9): [True: 8.57k, False: 0] | Branch (1339:9): [True: 8.57k, False: 0] ------------------ 1340| 8.57k| code[pos++] = nesting_level(bc, arg->bound_by); 1341| 8.57k| code[pos++] = arg->bound_by->imm.intval | ARG_NEWCLOSURE; ------------------ | | 70| 8.57k|#define ARG_NEWCLOSURE 0x1000 ------------------ 1342| 8.57k| } 1343| 289k| } else if ((op->flags & OP_HAS_CONSTANT) && (op->flags & OP_HAS_VARIABLE)) { ------------------ | Branch (1343:16): [True: 55.6k, False: 234k] | Branch (1343:49): [True: 0, False: 55.6k] ------------------ 1344| | // STORE_GLOBAL: constant global, basically 1345| 0| code[pos++] = jv_array_length(jv_copy(constant_pool)); 1346| 0| constant_pool = jv_array_append(constant_pool, jv_copy(curr->imm.constant)); 1347| 0| code[pos++] = nesting_level(bc, curr->bound_by); 1348| 0| uint16_t var = (uint16_t)curr->bound_by->imm.intval; 1349| 0| code[pos++] = var; 1350| 0| if (var > maxvar) maxvar = var; ------------------ | Branch (1350:11): [True: 0, False: 0] ------------------ 1351| 289k| } else if (op->flags & OP_HAS_CONSTANT) { ------------------ | Branch (1351:16): [True: 55.6k, False: 234k] ------------------ 1352| 55.6k| code[pos++] = jv_array_length(jv_copy(constant_pool)); 1353| 55.6k| constant_pool = jv_array_append(constant_pool, jv_copy(curr->imm.constant)); 1354| 234k| } else if (op->flags & OP_HAS_VARIABLE) { ------------------ | Branch (1354:16): [True: 49.7k, False: 184k] ------------------ 1355| 49.7k| code[pos++] = nesting_level(bc, curr->bound_by); 1356| 49.7k| uint16_t var = (uint16_t)curr->bound_by->imm.intval; 1357| 49.7k| code[pos++] = var; 1358| 49.7k| if (var > maxvar) maxvar = var; ------------------ | Branch (1358:11): [True: 19.8k, False: 29.9k] ------------------ 1359| 184k| } else if (op->flags & OP_HAS_BRANCH) { ------------------ | Branch (1359:16): [True: 66.3k, False: 117k] ------------------ 1360| 66.3k| assert(curr->imm.target->bytecode_pos != -1); ------------------ | Branch (1360:7): [True: 0, False: 66.3k] | Branch (1360:7): [True: 66.3k, False: 0] ------------------ 1361| 66.3k| assert(curr->imm.target->bytecode_pos > pos); // only forward branches ------------------ | Branch (1361:7): [True: 0, False: 66.3k] | Branch (1361:7): [True: 66.3k, False: 0] ------------------ 1362| 66.3k| code[pos] = curr->imm.target->bytecode_pos - (pos + 1); 1363| 66.3k| pos++; 1364| 117k| } else if (op->length > 1) { ------------------ | Branch (1364:16): [True: 0, False: 117k] ------------------ 1365| 0| assert(0 && "codegen not implemented for this operation"); ------------------ | Branch (1365:7): [Folded, False: 0] | Branch (1365:7): [True: 0, False: 0] | Branch (1365:7): [Folded, False: 0] | Branch (1365:7): [True: 0, False: 0] ------------------ 1366| 0| } 1367| 305k| } 1368| 8.93k| bc->constants = constant_pool; 1369| 8.93k| bc->nlocals = maxvar + 2; // FIXME: frames of size zero? 1370| 8.93k| block_free(b); 1371| 8.93k| return errors; 1372| 8.93k|} compile.c:expand_call_arglist: 1129| 32.0k|static int expand_call_arglist(block* b, jv args, jv *env) { 1130| 32.0k| int errors = 0; 1131| 32.0k| block ret = gen_noop(); 1132| 681k| for (inst* curr; (curr = block_take(b));) { ------------------ | Branch (1132:20): [True: 649k, False: 32.0k] ------------------ 1133| 649k| if (opcode_describe(curr->op)->flags & OP_HAS_BINDING) { ------------------ | Branch (1133:9): [True: 186k, False: 463k] ------------------ 1134| 186k| if (!curr->bound_by && curr->op == LOADV && strcmp(curr->symbol, "ENV") == 0) { ------------------ | Branch (1134:11): [True: 2.97k, False: 183k] | Branch (1134:30): [True: 1.86k, False: 1.11k] | Branch (1134:51): [True: 1.59k, False: 273] ------------------ 1135| 1.59k| curr->op = LOADK; 1136| 1.59k| *env = curr->imm.constant = make_env(*env); 1137| 184k| } else if (!curr->bound_by && curr->op == LOADV && jv_object_has(jv_copy(args), jv_string(curr->symbol))) { ------------------ | Branch (1137:18): [True: 1.38k, False: 183k] | Branch (1137:37): [True: 273, False: 1.11k] | Branch (1137:58): [True: 0, False: 273] ------------------ 1138| 0| curr->op = LOADK; 1139| 0| curr->imm.constant = jv_object_get(jv_copy(args), jv_string(curr->symbol)); 1140| 184k| } else if (!curr->bound_by) { ------------------ | Branch (1140:18): [True: 1.38k, False: 183k] ------------------ 1141| 1.38k| if (curr->symbol[0] == '*' && curr->symbol[1] >= '1' && curr->symbol[1] <= '3' && curr->symbol[2] == '\0') ------------------ | Branch (1141:13): [True: 206, False: 1.18k] | Branch (1141:39): [True: 206, False: 0] | Branch (1141:65): [True: 0, False: 206] | Branch (1141:91): [True: 0, False: 0] ------------------ 1142| 0| locfile_locate(curr->locfile, curr->source, "jq: error: break used outside labeled control structure"); 1143| 1.38k| else if (curr->op == LOADV) ------------------ | Branch (1143:18): [True: 273, False: 1.11k] ------------------ 1144| 273| locfile_locate(curr->locfile, curr->source, "jq: error: $%s is not defined", curr->symbol); 1145| 1.11k| else 1146| 1.11k| locfile_locate(curr->locfile, curr->source, "jq: error: %s/%d is not defined", curr->symbol, curr->nactuals); 1147| 1.38k| errors++; 1148| | // don't process this instruction if it's not well-defined 1149| 1.38k| ret = BLOCK(ret, inst_block(curr)); ------------------ | | 102| 1.38k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.38k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.38k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 1.38k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1150| 1.38k| continue; 1151| 1.38k| } 1152| 186k| } 1153| | 1154| 648k| block prelude = gen_noop(); 1155| 648k| if (curr->op == CALL_JQ) { ------------------ | Branch (1155:9): [True: 76.4k, False: 572k] ------------------ 1156| 76.4k| int actual_args = 0, desired_args = 0; 1157| | // We expand the argument list as a series of instructions 1158| 76.4k| switch (curr->bound_by->op) { 1159| 0| default: assert(0 && "Unknown function type"); break; ------------------ | Branch (1159:7): [True: 0, False: 76.4k] | Branch (1159:16): [Folded, False: 0] | Branch (1159:16): [True: 0, False: 0] | Branch (1159:16): [Folded, False: 0] | Branch (1159:16): [True: 0, False: 0] ------------------ 1160| 63.1k| case CLOSURE_CREATE: ------------------ | Branch (1160:7): [True: 63.1k, False: 13.2k] ------------------ 1161| 63.2k| case CLOSURE_PARAM: { ------------------ | Branch (1161:7): [True: 109, False: 76.3k] ------------------ 1162| 63.2k| block callargs = gen_noop(); 1163| 184k| for (inst* i; (i = block_take(&curr->arglist));) { ------------------ | Branch (1163:23): [True: 121k, False: 63.2k] ------------------ 1164| 121k| assert(opcode_describe(i->op)->flags & OP_IS_CALL_PSEUDO); ------------------ | Branch (1164:11): [True: 0, False: 121k] | Branch (1164:11): [True: 121k, False: 0] ------------------ 1165| 121k| block b = inst_block(i); 1166| 121k| switch (i->op) { 1167| 0| default: assert(0 && "Unknown type of parameter"); break; ------------------ | Branch (1167:11): [True: 0, False: 121k] | Branch (1167:20): [Folded, False: 0] | Branch (1167:20): [True: 0, False: 0] | Branch (1167:20): [Folded, False: 0] | Branch (1167:20): [True: 0, False: 0] ------------------ 1168| 0| case CLOSURE_REF: ------------------ | Branch (1168:11): [True: 0, False: 121k] ------------------ 1169| 0| block_append(&callargs, b); 1170| 0| break; 1171| 121k| case CLOSURE_CREATE: ------------------ | Branch (1171:11): [True: 121k, False: 0] ------------------ 1172| 121k| block_append(&prelude, b); 1173| 121k| block_append(&callargs, gen_op_bound(CLOSURE_REF, b)); 1174| 121k| break; 1175| 121k| } 1176| 121k| actual_args++; 1177| 121k| } 1178| 63.2k| curr->imm.intval = actual_args; 1179| 63.2k| curr->arglist = callargs; 1180| | 1181| 63.2k| if (curr->bound_by->op == CLOSURE_CREATE) { ------------------ | Branch (1181:13): [True: 63.1k, False: 109] ------------------ 1182| 184k| for (inst* i = curr->bound_by->arglist.first; i; i = i->next) { ------------------ | Branch (1182:57): [True: 121k, False: 63.1k] ------------------ 1183| 121k| assert(i->op == CLOSURE_PARAM); ------------------ | Branch (1183:13): [True: 0, False: 121k] | Branch (1183:13): [True: 121k, False: 0] ------------------ 1184| 121k| desired_args++; 1185| 121k| } 1186| 63.1k| } 1187| 63.2k| break; 1188| 63.2k| } 1189| | 1190| 63.2k| case CLOSURE_CREATE_C: { ------------------ | Branch (1190:7): [True: 13.1k, False: 63.2k] ------------------ 1191| 36.0k| for (inst* i; (i = block_take(&curr->arglist)); ) { ------------------ | Branch (1191:23): [True: 22.9k, False: 13.1k] ------------------ 1192| 22.9k| assert(i->op == CLOSURE_CREATE); // FIXME ------------------ | Branch (1192:11): [True: 0, False: 22.9k] | Branch (1192:11): [True: 22.9k, False: 0] ------------------ 1193| 22.9k| block body = i->subfn; 1194| 22.9k| i->subfn = gen_noop(); 1195| 22.9k| inst_free(i); 1196| | // arguments should be pushed in reverse order, prepend them to prelude 1197| 22.9k| errors += expand_call_arglist(&body, args, env); 1198| 22.9k| prelude = BLOCK(gen_subexp(body), prelude); ------------------ | | 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))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1199| 22.9k| actual_args++; 1200| 22.9k| } 1201| 13.1k| assert(curr->op == CALL_JQ); ------------------ | Branch (1201:9): [True: 0, False: 13.1k] | Branch (1201:9): [True: 13.1k, False: 0] ------------------ 1202| 13.1k| curr->op = CALL_BUILTIN; 1203| 13.1k| curr->imm.intval = actual_args + 1 /* include the implicit input in arg count */; 1204| 13.1k| assert(curr->bound_by->op == CLOSURE_CREATE_C); ------------------ | Branch (1204:9): [True: 0, False: 13.1k] | Branch (1204:9): [True: 13.1k, False: 0] ------------------ 1205| 13.1k| desired_args = curr->bound_by->imm.cfunc->nargs - 1; 1206| 13.1k| assert(!curr->arglist.first); ------------------ | Branch (1206:9): [True: 0, False: 13.1k] | Branch (1206:9): [True: 13.1k, False: 0] ------------------ 1207| 13.1k| break; 1208| 13.1k| } 1209| 76.4k| } 1210| | 1211| 76.4k| assert(actual_args == desired_args); // because now handle this above ------------------ | Branch (1211:7): [True: 0, False: 76.4k] | Branch (1211:7): [True: 76.4k, False: 0] ------------------ 1212| 76.4k| } 1213| 648k| ret = BLOCK(ret, prelude, inst_block(curr)); ------------------ | | 102| 648k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 648k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 648k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 648k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 648k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1214| 648k| } 1215| 32.0k| *b = ret; 1216| 32.0k| return errors; 1217| 32.0k|} compile.c:make_env: 1111| 1.59k|{ 1112| 1.59k| if (jv_is_valid(env)) ------------------ | Branch (1112:7): [True: 1.58k, False: 2] ------------------ 1113| 1.58k| return jv_copy(env); 1114| 2| jv r = jv_object(); 1115| 2| if (environ == NULL) ------------------ | Branch (1115:7): [True: 0, False: 2] ------------------ 1116| 0| return r; 1117| 68| for (size_t i = 0; environ[i] != NULL; i++) { ------------------ | Branch (1117:22): [True: 66, False: 2] ------------------ 1118| 66| const char *eq; 1119| | 1120| 66| if ((eq = strchr(environ[i], '=')) == NULL) ------------------ | Branch (1120:9): [True: 0, False: 66] ------------------ 1121| 0| r = jv_object_delete(r, jv_string(environ[i])); 1122| 66| else 1123| 66| r = jv_object_set(r, jv_string_sized(environ[i], eq - environ[i]), jv_string(eq + 1)); 1124| 66| } 1125| 2| return jv_copy(r); 1126| 2|} compile.c:nesting_level: 1085| 65.1k|static uint16_t nesting_level(struct bytecode* bc, inst* target) { 1086| 65.1k| uint16_t level = 0; 1087| 65.1k| assert(bc && target && target->compiled); ------------------ | Branch (1087:3): [True: 0, False: 65.1k] | Branch (1087:3): [True: 0, False: 0] | Branch (1087:3): [True: 0, False: 0] | Branch (1087:3): [True: 65.1k, False: 0] | Branch (1087:3): [True: 65.1k, False: 0] | Branch (1087:3): [True: 65.1k, False: 0] ------------------ 1088| 965k| while (bc && target->compiled != bc) { ------------------ | Branch (1088:10): [True: 965k, False: 0] | Branch (1088:16): [True: 900k, False: 65.1k] ------------------ 1089| 900k| level++; 1090| 900k| bc = bc->parent; 1091| 900k| } 1092| 65.1k| assert(bc && bc == target->compiled); ------------------ | Branch (1092:3): [True: 0, False: 65.1k] | Branch (1092:3): [True: 0, False: 0] | Branch (1092:3): [True: 65.1k, False: 0] | Branch (1092:3): [True: 65.1k, False: 0] ------------------ 1093| 65.1k| return level; 1094| 65.1k|} execute.c:stack_pop_will_free: 73| 1.19k|static int stack_pop_will_free(struct stack* s, stack_ptr p) { 74| 1.19k| return p == s->limit; 75| 1.19k|} execute.c:stack_init: 58| 1.78k|static void stack_init(struct stack* s) { 59| 1.78k| s->mem_end = 0; 60| 1.78k| s->bound = ALIGNMENT; 61| 1.78k| s->limit = 0; 62| 1.78k|} execute.c:stack_reset: 64| 1.19k|static void stack_reset(struct stack* s) { 65| 1.19k| assert(s->limit == 0 && "stack freed while not empty"); ------------------ | Branch (65:3): [True: 0, False: 1.19k] | Branch (65:3): [True: 0, False: 0] | Branch (65:3): [True: 1.19k, False: 0] | Branch (65:3): [True: 1.19k, False: 0] ------------------ 66| 1.19k| if(s->mem_end != NULL) { ------------------ | Branch (66:6): [True: 0, False: 1.19k] ------------------ 67| 0| char* mem_start = s->mem_end - ( -s->bound + ALIGNMENT); 68| 0| free(mem_start); 69| 0| } 70| 1.19k| stack_init(s); 71| 1.19k|} stack_restore: 270| 1.19k|uint16_t* stack_restore(jq_state *jq){ 271| 1.19k| while (!stack_pop_will_free(&jq->stk, jq->fork_top)) { ------------------ | Branch (271:10): [True: 0, False: 1.19k] ------------------ 272| 0| if (stack_pop_will_free(&jq->stk, jq->stk_top)) { ------------------ | Branch (272:9): [True: 0, False: 0] ------------------ 273| 0| jv_free(stack_pop(jq)); 274| 0| } else if (stack_pop_will_free(&jq->stk, jq->curr_frame)) { ------------------ | Branch (274:16): [True: 0, False: 0] ------------------ 275| 0| frame_pop(jq); 276| 0| } else { 277| 0| assert(0); ------------------ | Branch (277:7): [Folded, False: 0] | Branch (277:7): [Folded, False: 0] ------------------ 278| 0| } 279| 0| } 280| | 281| 1.19k| if (jq->fork_top == 0) { ------------------ | Branch (281:7): [True: 1.19k, False: 0] ------------------ 282| 1.19k| return 0; 283| 1.19k| } 284| | 285| 0| struct forkpoint* fork = stack_block(&jq->stk, jq->fork_top); 286| 0| uint16_t* retaddr = fork->return_address; 287| 0| jq->stk_top = fork->saved_data_stack; 288| 0| jq->curr_frame = fork->saved_curr_frame; 289| 0| int path_len = fork->path_len; 290| 0| if (jv_get_kind(jq->path) == JV_KIND_ARRAY) { ------------------ | Branch (290:7): [True: 0, False: 0] ------------------ 291| 0| assert(path_len >= 0); ------------------ | Branch (291:5): [True: 0, False: 0] | Branch (291:5): [True: 0, False: 0] ------------------ 292| 0| jq->path = jv_array_slice(jq->path, 0, path_len); 293| 0| } else { 294| 0| fork->path_len = 0; 295| 0| } 296| 0| jv_free(jq->value_at_path); 297| 0| jq->value_at_path = fork->value_at_path; 298| 0| jq->subexp_nest = fork->subexp_nest; 299| 0| jq->fork_top = stack_pop_block(&jq->stk, jq->fork_top, sizeof(struct forkpoint)); 300| 0| return retaddr; 301| 0|} jq_report_error: 326| 277k|void jq_report_error(jq_state *jq, jv value) { 327| 277k| assert(jq->err_cb); ------------------ | Branch (327:3): [True: 0, False: 277k] | Branch (327:3): [True: 277k, False: 0] ------------------ 328| | // callback must jv_free() its jv argument 329| 277k| jq->err_cb(jq->err_cb_data, value); 330| 277k|} jq_format_error: 1003| 277k|jv jq_format_error(jv msg) { 1004| 277k| if (jv_get_kind(msg) == JV_KIND_NULL || ------------------ | Branch (1004:7): [True: 0, False: 277k] ------------------ 1005| 277k| (jv_get_kind(msg) == JV_KIND_INVALID && !jv_invalid_has_msg(jv_copy(msg)))) { ------------------ | Branch (1005:8): [True: 0, False: 277k] | Branch (1005:47): [True: 0, False: 0] ------------------ 1006| 0| jv_free(msg); 1007| 0| fprintf(stderr, "jq: error: out of memory\n"); 1008| 0| return jv_null(); 1009| 0| } 1010| | 1011| 277k| if (jv_get_kind(msg) == JV_KIND_STRING) ------------------ | Branch (1011:7): [True: 277k, False: 0] ------------------ 1012| 277k| return msg; // expected to already be formatted 1013| | 1014| 0| if (jv_get_kind(msg) == JV_KIND_INVALID) ------------------ | Branch (1014:7): [True: 0, False: 0] ------------------ 1015| 0| msg = jv_invalid_get_msg(msg); 1016| | 1017| 0| if (jv_get_kind(msg) == JV_KIND_NULL) ------------------ | Branch (1017:7): [True: 0, False: 0] ------------------ 1018| 0| return jq_format_error(msg); // ENOMEM 1019| | 1020| | // Invalid with msg; prefix with "jq: error: " 1021| | 1022| 0| if (jv_get_kind(msg) != JV_KIND_INVALID) { ------------------ | Branch (1022:7): [True: 0, False: 0] ------------------ 1023| 0| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (1023:9): [True: 0, False: 0] ------------------ 1024| 0| jv r = jv_string_fmt("jq: error: %s", jv_string_value(msg)); 1025| 0| jv_free(msg); 1026| 0| return r; 1027| 0| } 1028| | 1029| 0| msg = jv_dump_string(msg, JV_PRINT_INVALID); 1030| 0| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (1030:9): [True: 0, False: 0] ------------------ 1031| 0| jv r = jv_string_fmt("jq: error: %s", jv_string_value(msg)); 1032| 0| jv_free(msg); 1033| 0| return r; 1034| 0| } 1035| 0| jv_free(msg); 1036| 0| return jq_format_error(jv_null()); // ENOMEM 1037| 0| } 1038| | 1039| | // An invalid inside an invalid! 1040| 0| return jq_format_error(jv_invalid_get_msg(msg)); 1041| 0|} jq_init: 1052| 596|jq_state *jq_init(void) { 1053| 596| jq_state *jq; 1054| 596| jq = jv_mem_alloc_unguarded(sizeof(*jq)); 1055| 596| if (jq == NULL) ------------------ | Branch (1055:7): [True: 0, False: 596] ------------------ 1056| 0| return NULL; 1057| | 1058| 596| jq->bc = 0; 1059| 596| jq->next_label = 0; 1060| | 1061| 596| stack_init(&jq->stk); 1062| 596| jq->stk_top = 0; 1063| 596| jq->fork_top = 0; 1064| 596| jq->curr_frame = 0; 1065| 596| jq->error = jv_null(); 1066| | 1067| 596| jq->halted = 0; 1068| 596| jq->exit_code = jv_invalid(); 1069| 596| jq->error_message = jv_invalid(); 1070| | 1071| 596| jq->input_cb = NULL; 1072| 596| jq->input_cb_data = NULL; 1073| | 1074| 596| jq->debug_cb = NULL; 1075| 596| jq->debug_cb_data = NULL; 1076| | 1077| 596| jq->stderr_cb = NULL; 1078| 596| jq->stderr_cb_data = NULL; 1079| | 1080| 596| jq->err_cb = default_err_cb; 1081| 596| jq->err_cb_data = stderr; 1082| | 1083| 596| jq->attrs = jv_object(); 1084| 596| jq->path = jv_null(); 1085| 596| jq->value_at_path = jv_null(); 1086| | 1087| 596| jq->nomem_handler = NULL; 1088| | jq->nomem_handler_data = NULL; 1089| 596| return jq; 1090| 596|} jq_teardown: 1129| 596|void jq_teardown(jq_state **jq) { 1130| 596| jq_state *old_jq = *jq; 1131| 596| if (old_jq == NULL) ------------------ | Branch (1131:7): [True: 0, False: 596] ------------------ 1132| 0| return; 1133| 596| *jq = NULL; 1134| | 1135| 596| jq_reset(old_jq); 1136| 596| bytecode_free(old_jq->bc); 1137| 596| old_jq->bc = 0; 1138| 596| jv_free(old_jq->attrs); 1139| | 1140| 596| jv_mem_free(old_jq); 1141| 596|} jq_compile_args: 1230| 596|int jq_compile_args(jq_state *jq, const char* str, jv args) { 1231| 596| jv_nomem_handler(jq->nomem_handler, jq->nomem_handler_data); 1232| 596| assert(jv_get_kind(args) == JV_KIND_ARRAY || jv_get_kind(args) == JV_KIND_OBJECT); ------------------ | Branch (1232:3): [True: 596, False: 0] | Branch (1232:3): [True: 0, False: 0] | Branch (1232:3): [True: 0, False: 596] | Branch (1232:3): [True: 596, False: 0] ------------------ 1233| 596| struct locfile* locations; 1234| 596| locations = locfile_init(jq, "", str, strlen(str)); 1235| 596| block program; 1236| 596| jq_reset(jq); 1237| 596| if (jq->bc) { ------------------ | Branch (1237:7): [True: 0, False: 596] ------------------ 1238| 0| bytecode_free(jq->bc); 1239| 0| jq->bc = 0; 1240| 0| } 1241| 596| int nerrors = load_program(jq, locations, &program); 1242| 596| if (nerrors == 0) { ------------------ | Branch (1242:7): [True: 181, False: 415] ------------------ 1243| 181| nerrors = builtins_bind(jq, &program); 1244| 181| if (nerrors == 0) ------------------ | Branch (1244:9): [True: 181, False: 0] ------------------ 1245| 181| nerrors = block_compile(program, &jq->bc, locations, args2obj(args)); 1246| 0| else 1247| 0| jv_free(args); 1248| 181| } else 1249| 415| jv_free(args); 1250| 596| if (nerrors) ------------------ | Branch (1250:7): [True: 449, False: 147] ------------------ 1251| 449| jq_report_error(jq, jv_string_fmt("jq: %d compile %s", nerrors, nerrors > 1 ? "errors" : "error")); ------------------ | Branch (1251:69): [True: 275, False: 174] ------------------ 1252| 596| if (jq->bc) ------------------ | Branch (1252:7): [True: 147, False: 449] ------------------ 1253| 147| jq->bc = optimize(jq->bc); 1254| 596| locfile_free(locations); 1255| | return jq->bc != NULL; 1256| 596|} jq_compile: 1258| 596|int jq_compile(jq_state *jq, const char* str) { 1259| 596| return jq_compile_args(jq, str, jv_object()); 1260| 596|} jq_get_jq_origin: 1262| 197|jv jq_get_jq_origin(jq_state *jq) { 1263| 197| return jq_get_attr(jq, jv_string("JQ_ORIGIN")); 1264| 197|} jq_get_prog_origin: 1266| 197|jv jq_get_prog_origin(jq_state *jq) { 1267| 197| return jq_get_attr(jq, jv_string("PROGRAM_ORIGIN")); 1268| 197|} jq_get_lib_dirs: 1270| 16|jv jq_get_lib_dirs(jq_state *jq) { 1271| 16| jv lib_dirs = jq_get_attr(jq, jv_string("JQ_LIBRARY_PATH")); 1272| 16| return jv_is_valid(lib_dirs) ? lib_dirs : jv_array(); ------------------ | Branch (1272:10): [True: 0, False: 16] ------------------ 1273| 16|} jq_get_attr: 1285| 410|jv jq_get_attr(jq_state *jq, jv attr) { 1286| 410| return jv_object_get(jv_copy(jq->attrs), attr); 1287| 410|} jq_dump_disassembly: 1289| 147|void jq_dump_disassembly(jq_state *jq, int indent) { 1290| 147| dump_disassembly(indent, jq->bc); 1291| 147|} execute.c:default_err_cb: 1046| 277k|static void default_err_cb(void *data, jv msg) { 1047| 277k| msg = jq_format_error(msg); 1048| 277k| fprintf((FILE *)data, "%s\n", jv_string_value(msg)); 1049| 277k| jv_free(msg); 1050| 277k|} execute.c:jq_reset: 303| 1.19k|static void jq_reset(jq_state *jq) { 304| 1.19k| while (stack_restore(jq)) {} ------------------ | Branch (304:10): [True: 0, False: 1.19k] ------------------ 305| | 306| 1.19k| assert(jq->stk_top == 0); ------------------ | Branch (306:3): [True: 0, False: 1.19k] | Branch (306:3): [True: 1.19k, False: 0] ------------------ 307| 1.19k| assert(jq->fork_top == 0); ------------------ | Branch (307:3): [True: 0, False: 1.19k] | Branch (307:3): [True: 1.19k, False: 0] ------------------ 308| 1.19k| assert(jq->curr_frame == 0); ------------------ | Branch (308:3): [True: 0, False: 1.19k] | Branch (308:3): [True: 1.19k, False: 0] ------------------ 309| 1.19k| stack_reset(&jq->stk); 310| 1.19k| jv_free(jq->error); 311| 1.19k| jq->error = jv_null(); 312| | 313| 1.19k| jq->halted = 0; 314| 1.19k| jv_free(jq->exit_code); 315| 1.19k| jq->exit_code = jv_invalid(); 316| 1.19k| jv_free(jq->error_message); 317| 1.19k| jq->error_message = jv_invalid(); 318| 1.19k| if (jv_get_kind(jq->path) != JV_KIND_INVALID) ------------------ | Branch (318:7): [True: 1.19k, False: 0] ------------------ 319| 1.19k| jv_free(jq->path); 320| 1.19k| jq->path = jv_null(); 321| 1.19k| jv_free(jq->value_at_path); 322| 1.19k| jq->value_at_path = jv_null(); 323| 1.19k| jq->subexp_nest = 0; 324| 1.19k|} execute.c:args2obj: 1215| 181|{ 1216| 181| if (jv_get_kind(args) == JV_KIND_OBJECT) ------------------ | Branch (1216:7): [True: 181, False: 0] ------------------ 1217| 181| return args; 1218| 181| assert(jv_get_kind(args) == JV_KIND_ARRAY); ------------------ | Branch (1218:3): [True: 0, False: 0] | Branch (1218:3): [True: 0, False: 0] ------------------ 1219| 0| jv r = jv_object(); 1220| 0| jv kk = jv_string("name"); 1221| 0| jv vk = jv_string("value"); 1222| 0| jv_array_foreach(args, i, v) ------------------ | | 102| 0| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 0| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 0, False: 0] | | ------------------ | | 104| 0| for (jv x; \ | | 105| 0| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 0, False: 0] | | | Branch (105:10): [True: 0, False: 0] | | ------------------ | | 106| 0| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 0| i++) ------------------ 1223| 0| r = jv_object_set(r, jv_object_get(jv_copy(v), jv_copy(kk)), jv_object_get(v, jv_copy(vk))); 1224| 0| jv_free(args); 1225| 0| jv_free(kk); 1226| 0| jv_free(vk); 1227| 0| return r; 1228| 0|} execute.c:optimize: 1206| 7.81k|static struct bytecode *optimize(struct bytecode *bc) { 1207| 15.4k| for (int i=0; insubfunctions; i++) { ------------------ | Branch (1207:17): [True: 7.66k, False: 7.81k] ------------------ 1208| 7.66k| bc->subfunctions[i] = optimize(bc->subfunctions[i]); 1209| 7.66k| } 1210| 7.81k| return optimize_code(bc); 1211| 7.81k|} execute.c:optimize_code: 1188| 7.81k|static struct bytecode *optimize_code(struct bytecode *bc) { 1189| 7.81k| uint16_t *pc = bc->code; 1190| | // FIXME: Don't mutate bc->code... 1191| 306k| while (pc < bc->code + bc->codelen) { ------------------ | Branch (1191:10): [True: 299k, False: 7.81k] ------------------ 1192| 299k| switch (*pc) { 1193| 5.95k| case CALL_JQ: ------------------ | Branch (1193:5): [True: 5.95k, False: 293k] ------------------ 1194| 5.95k| *pc = tail_call_analyze(pc); 1195| 5.95k| break; 1196| | 1197| | // Other bytecode optimizations here. A peephole optimizer would 1198| | // fit right in. 1199| 293k| default: break; ------------------ | Branch (1199:5): [True: 293k, False: 5.95k] ------------------ 1200| 299k| } 1201| 299k| pc += bytecode_operation_length(pc); 1202| 299k| } 1203| 7.81k| return bc; 1204| 7.81k|} execute.c:tail_call_analyze: 1175| 5.95k|static uint16_t tail_call_analyze(uint16_t *pc) { 1176| 5.95k| assert(*pc == CALL_JQ); ------------------ | Branch (1176:3): [True: 0, False: 5.95k] | Branch (1176:3): [True: 5.95k, False: 0] ------------------ 1177| 5.95k| pc++; 1178| | // + 1 for the callee closure 1179| 9.18k| for (uint16_t nclosures = *pc++ + 1; nclosures > 0; pc++, nclosures--) { ------------------ | Branch (1179:40): [True: 7.33k, False: 1.84k] ------------------ 1180| 7.33k| if (*pc++ == 0) ------------------ | Branch (1180:9): [True: 4.10k, False: 3.22k] ------------------ 1181| 4.10k| return CALL_JQ; 1182| 7.33k| } 1183| 1.84k| if (ret_follows(pc)) ------------------ | Branch (1183:7): [True: 924, False: 924] ------------------ 1184| 924| return TAIL_CALL_JQ; 1185| 924| return CALL_JQ; 1186| 1.84k|} execute.c:ret_follows: 1143| 1.84k|static int ret_follows(uint16_t *pc) { 1144| 1.84k| if (*pc == RET) ------------------ | Branch (1144:7): [True: 924, False: 924] ------------------ 1145| 924| return 1; 1146| 924| if (*pc++ != JUMP) ------------------ | Branch (1146:7): [True: 924, False: 0] ------------------ 1147| 924| return 0; 1148| 0| return ret_follows(pc + *pc + 1); // FIXME, might be ironic 1149| 924|} jv_get_kind: 102| 30.6M|jv_kind jv_get_kind(jv x) { 103| 30.6M| return JVP_KIND(x); ------------------ | | 90| 30.6M|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 89| 30.6M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 77| 30.6M|#define KIND_MASK 0xF | | ------------------ ------------------ 104| 30.6M|} jv_kind_name: 106| 12.3k|const char* jv_kind_name(jv_kind k) { 107| 12.3k| switch (k) { ------------------ | Branch (107:11): [True: 12.3k, False: 0] ------------------ 108| 0| case JV_KIND_INVALID: return ""; ------------------ | Branch (108:3): [True: 0, False: 12.3k] ------------------ 109| 6| case JV_KIND_NULL: return "null"; ------------------ | Branch (109:3): [True: 6, False: 12.3k] ------------------ 110| 28| case JV_KIND_FALSE: return "boolean"; ------------------ | Branch (110:3): [True: 28, False: 12.3k] ------------------ 111| 0| case JV_KIND_TRUE: return "boolean"; ------------------ | Branch (111:3): [True: 0, False: 12.3k] ------------------ 112| 9.09k| case JV_KIND_NUMBER: return "number"; ------------------ | Branch (112:3): [True: 9.09k, False: 3.27k] ------------------ 113| 860| case JV_KIND_STRING: return "string"; ------------------ | Branch (113:3): [True: 860, False: 11.5k] ------------------ 114| 1.89k| case JV_KIND_ARRAY: return "array"; ------------------ | Branch (114:3): [True: 1.89k, False: 10.4k] ------------------ 115| 489| case JV_KIND_OBJECT: return "object"; ------------------ | Branch (115:3): [True: 489, False: 11.8k] ------------------ 116| 12.3k| } 117| 12.3k| 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| 29.8k|jv jv_true(void) { 127| 29.8k| return JV_TRUE; 128| 29.8k|} jv_false: 130| 27.9k|jv jv_false(void) { 131| 27.9k| return JV_FALSE; 132| 27.9k|} jv_null: 134| 454k|jv jv_null(void) { 135| 454k| return JV_NULL; 136| 454k|} jv_bool: 138| 12.7k|jv jv_bool(int x) { 139| 12.7k| return x ? JV_TRUE : JV_FALSE; ------------------ | Branch (139:10): [True: 3.19k, False: 9.53k] ------------------ 140| 12.7k|} jv_invalid_with_msg: 153| 396k|jv jv_invalid_with_msg(jv err) { 154| 396k| jvp_invalid* i = jv_mem_alloc(sizeof(jvp_invalid)); 155| 396k| i->refcnt = JV_REFCNT_INIT; 156| 396k| i->errmsg = err; 157| | 158| 396k| jv x = {JVP_FLAGS_INVALID_MSG, 0, 0, 0, {&i->refcnt}}; ------------------ | | 146| 396k|#define JVP_FLAGS_INVALID_MSG JVP_MAKE_FLAGS(JV_KIND_INVALID, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 396k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 396k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 396k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 159| 396k| return x; 160| 396k|} jv_invalid: 162| 4.32M|jv jv_invalid(void) { 163| 4.32M| return JV_INVALID; 164| 4.32M|} jv_invalid_get_msg: 166| 396k|jv jv_invalid_get_msg(jv inv) { 167| 396k| assert(JVP_HAS_KIND(inv, JV_KIND_INVALID)); ------------------ | Branch (167:3): [True: 0, False: 396k] | Branch (167:3): [True: 396k, False: 0] ------------------ 168| | 169| 396k| jv x; 170| 396k| if (JVP_HAS_FLAGS(inv, JVP_FLAGS_INVALID_MSG)) { ------------------ | | 92| 396k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 396k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 396k, False: 0] | | ------------------ ------------------ 171| 396k| x = jv_copy(((jvp_invalid*)inv.u.ptr)->errmsg); 172| 396k| } 173| 0| else { 174| 0| x = jv_null(); 175| 0| } 176| | 177| 396k| jv_free(inv); 178| 396k| return x; 179| 396k|} jv_invalid_has_msg: 181| 698k|int jv_invalid_has_msg(jv inv) { 182| 698k| assert(JVP_HAS_KIND(inv, JV_KIND_INVALID)); ------------------ | Branch (182:3): [True: 0, False: 698k] | Branch (182:3): [True: 698k, False: 0] ------------------ 183| 698k| int r = JVP_HAS_FLAGS(inv, JVP_FLAGS_INVALID_MSG); ------------------ | | 92| 698k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 698k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ ------------------ 184| 698k| jv_free(inv); 185| 698k| return r; 186| 698k|} 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| 38.2k|const char* jv_number_get_literal(jv n) { 659| 38.2k| assert(JVP_HAS_KIND(n, JV_KIND_NUMBER)); ------------------ | Branch (659:3): [True: 0, False: 38.2k] | Branch (659:3): [True: 38.2k, False: 0] ------------------ 660| | 661| 38.2k| if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 76.4k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 38.2k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 31.5k, False: 6.65k] | | | Branch (92:50): [True: 38.2k, Folded] | | ------------------ ------------------ 662| 31.5k| return jvp_literal_number_literal(n); 663| 31.5k| } else { 664| | return NULL; 665| 6.65k| } 666| 38.2k|} jv_number_with_literal: 668| 307k|jv jv_number_with_literal(const char * literal) { 669| 307k| return jvp_literal_number_new(literal); 670| 307k|} jv_number: 673| 42.7k|jv jv_number(double x) { 674| 42.7k| jv j = { 675| 42.7k|#ifdef USE_DECNUM 676| 42.7k| JVP_FLAGS_NUMBER_NATIVE, ------------------ | | 205| 42.7k|#define JVP_FLAGS_NUMBER_NATIVE JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_NATIVE, 0)) | | ------------------ | | | | 87| 85.5k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 42.7k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 42.7k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | | | | Branch (87:61): [Folded, False: 42.7k] | | | | ------------------ | | ------------------ ------------------ 677| |#else 678| | JV_KIND_NUMBER, 679| |#endif 680| 42.7k| 0, 0, 0, {.number = x} 681| 42.7k| }; 682| 42.7k| return j; 683| 42.7k|} jv_number_value: 698| 131k|double jv_number_value(jv j) { 699| 131k| assert(JVP_HAS_KIND(j, JV_KIND_NUMBER)); ------------------ | Branch (699:3): [True: 0, False: 131k] | Branch (699:3): [True: 131k, False: 0] ------------------ 700| 131k|#ifdef USE_DECNUM 701| 131k| if (JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 263k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 131k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 87.9k, False: 43.8k] | | | Branch (92:50): [True: 131k, Folded] | | ------------------ ------------------ 702| 87.9k| jvp_literal_number* n = jvp_literal_number_ptr(j); 703| | 704| 87.9k| if (isnan(n->num_double)) { ------------------ | Branch (704:9): [True: 69.5k, False: 18.3k] ------------------ 705| 69.5k| n->num_double = jvp_literal_number_to_double(j); 706| 69.5k| } 707| | 708| 87.9k| return n->num_double; 709| 87.9k| } 710| 43.8k|#endif 711| 43.8k| return j.u.number; 712| 131k|} jvp_number_is_nan: 727| 49.7k|int jvp_number_is_nan(jv n) { 728| 49.7k| assert(JVP_HAS_KIND(n, JV_KIND_NUMBER)); ------------------ | Branch (728:3): [True: 0, False: 49.7k] | Branch (728:3): [True: 49.7k, False: 0] ------------------ 729| | 730| 49.7k|#ifdef USE_DECNUM 731| 49.7k| if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 99.5k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 49.7k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 42.5k, False: 7.23k] | | | Branch (92:50): [True: 49.7k, Folded] | | ------------------ ------------------ 732| 42.5k| decNumber *pdec = jvp_dec_number_ptr(n); 733| 42.5k| return decNumberIsNaN(pdec); ------------------ | | 172| 42.5k| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 42.5k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 42.5k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ 734| 42.5k| } 735| 7.23k|#endif 736| 7.23k| return isnan(n.u.number); 737| 49.7k|} jvp_number_cmp: 769| 43.8k|int jvp_number_cmp(jv a, jv b) { 770| 43.8k| assert(JVP_HAS_KIND(a, JV_KIND_NUMBER)); ------------------ | Branch (770:3): [True: 0, False: 43.8k] | Branch (770:3): [True: 43.8k, False: 0] ------------------ 771| 43.8k| assert(JVP_HAS_KIND(b, JV_KIND_NUMBER)); ------------------ | Branch (771:3): [True: 0, False: 43.8k] | Branch (771:3): [True: 43.8k, False: 0] ------------------ 772| | 773| 43.8k|#ifdef USE_DECNUM 774| 43.8k| if (JVP_HAS_FLAGS(a, JVP_FLAGS_NUMBER_LITERAL) && JVP_HAS_FLAGS(b, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 87.7k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 43.8k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 43.3k, False: 531] | | | Branch (92:50): [True: 43.8k, Folded] | | ------------------ ------------------ if (JVP_HAS_FLAGS(a, JVP_FLAGS_NUMBER_LITERAL) && JVP_HAS_FLAGS(b, JVP_FLAGS_NUMBER_LITERAL)) { ------------------ | | 92| 86.6k|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 43.3k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 32.4k, False: 10.8k] | | | Branch (92:50): [True: 43.3k, Folded] | | ------------------ ------------------ 775| 32.4k| struct { 776| 32.4k| decNumber number; 777| 32.4k| decNumberUnit units[1]; 778| 32.4k| } res; 779| | 780| 32.4k| decNumberCompare(&res.number, 781| 32.4k| jvp_dec_number_ptr(a), 782| 32.4k| jvp_dec_number_ptr(b), 783| 32.4k| DEC_CONTEXT() ------------------ | | 487| 32.4k|#define DEC_CONTEXT() tsd_dec_ctx_get(&dec_ctx_key) ------------------ 784| 32.4k| ); 785| 32.4k| if (decNumberIsZero(&res.number)) { ------------------ | | 177| 32.4k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | ------------------ | | | Branch (177:37): [True: 5.05k, False: 27.3k] | | ------------------ | | 178| 32.4k| && (dn)->digits==1 \ | | ------------------ | | | Branch (178:40): [True: 5.05k, False: 0] | | ------------------ | | 179| 32.4k| && (((dn)->bits&DECSPECIAL)==0)) | | ------------------ | | | | 36| 5.05k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 32| 5.05k| #define DECINF 0x40 /* 1=Infinity */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 33| 5.05k| #define DECNAN 0x20 /* 1=NaN */ | | | | ------------------ | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | ------------------ | | | | | | 34| 5.05k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | ------------------ | | ------------------ | | | Branch (179:40): [True: 5.05k, False: 0] | | ------------------ ------------------ 786| 5.05k| return 0; 787| 27.3k| } else if (decNumberIsNegative(&res.number)) { ------------------ | | 173| 27.3k| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 27.3k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 20.9k, False: 6.44k] | | ------------------ ------------------ 788| 20.9k| return -1; 789| 20.9k| } else { 790| 6.44k| return 1; 791| 6.44k| } 792| 32.4k| } 793| 11.3k|#endif 794| 11.3k| double da = jv_number_value(a), db = jv_number_value(b); 795| 11.3k| if (da < db) { ------------------ | Branch (795:7): [True: 9.37k, False: 2.02k] ------------------ 796| 9.37k| return -1; 797| 9.37k| } else if (da == db) { ------------------ | Branch (797:14): [True: 51, False: 1.97k] ------------------ 798| 51| return 0; 799| 1.97k| } else { 800| 1.97k| return 1; 801| 1.97k| } 802| 11.3k|} jv_array_sized: 982| 274k|jv jv_array_sized(int n) { 983| 274k| return jvp_array_new(n); 984| 274k|} jv_array: 986| 270k|jv jv_array(void) { 987| 270k| return jv_array_sized(16); 988| 270k|} jv_array_length: 990| 2.19M|int jv_array_length(jv j) { 991| 2.19M| assert(JVP_HAS_KIND(j, JV_KIND_ARRAY)); ------------------ | Branch (991:3): [True: 0, False: 2.19M] | Branch (991:3): [True: 2.19M, False: 0] ------------------ 992| 2.19M| int len = jvp_array_length(j); 993| 2.19M| jv_free(j); 994| 2.19M| return len; 995| 2.19M|} jv_array_get: 997| 2.39M|jv jv_array_get(jv j, int idx) { 998| 2.39M| assert(JVP_HAS_KIND(j, JV_KIND_ARRAY)); ------------------ | Branch (998:3): [True: 0, False: 2.39M] | Branch (998:3): [True: 2.39M, False: 0] ------------------ 999| 2.39M| jv* slot = jvp_array_read(j, idx); 1000| 2.39M| jv val; 1001| 2.39M| if (slot) { ------------------ | Branch (1001:7): [True: 2.39M, False: 0] ------------------ 1002| 2.39M| val = jv_copy(*slot); 1003| 2.39M| } else { 1004| 0| val = jv_invalid(); 1005| 0| } 1006| 2.39M| jv_free(j); 1007| 2.39M| return val; 1008| 2.39M|} jv_array_set: 1010| 1.73M|jv jv_array_set(jv j, int idx, jv val) { 1011| 1.73M| assert(JVP_HAS_KIND(j, JV_KIND_ARRAY)); ------------------ | Branch (1011:3): [True: 0, False: 1.73M] | Branch (1011:3): [True: 1.73M, False: 0] ------------------ 1012| | 1013| 1.73M| if (idx < 0) ------------------ | Branch (1013:7): [True: 0, False: 1.73M] ------------------ 1014| 0| idx = jvp_array_length(j) + idx; 1015| 1.73M| if (idx < 0) { ------------------ | Branch (1015:7): [True: 0, False: 1.73M] ------------------ 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| 1.73M| if (idx > (INT_MAX >> 2) - jvp_array_offset(j)) { ------------------ | Branch (1020:7): [True: 0, False: 1.73M] ------------------ 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| 1.73M| jv* slot = jvp_array_write(&j, idx); 1027| 1.73M| jv_free(*slot); 1028| 1.73M| *slot = val; 1029| 1.73M| return j; 1030| 1.73M|} jv_array_append: 1032| 1.73M|jv jv_array_append(jv j, jv val) { 1033| | // copy/free of val,j coalesced 1034| 1.73M| return jv_array_set(j, jv_array_length(jv_copy(j)), val); 1035| 1.73M|} jv_array_concat: 1037| 229|jv jv_array_concat(jv a, jv b) { 1038| 229| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (1038:3): [True: 0, False: 229] | Branch (1038:3): [True: 229, False: 0] ------------------ 1039| 229| assert(JVP_HAS_KIND(b, JV_KIND_ARRAY)); ------------------ | Branch (1039:3): [True: 0, False: 229] | Branch (1039:3): [True: 229, False: 0] ------------------ 1040| | 1041| | // FIXME: could be faster 1042| 274k| jv_array_foreach(b, i, elem) { ------------------ | | 102| 229| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 458| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 229, False: 229] | | ------------------ | | 104| 229| for (jv x; \ | | 105| 274k| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 274k, False: 229] | | | Branch (105:10): [True: 274k, False: 229] | | ------------------ | | 106| 274k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 274k| i++) ------------------ 1043| 274k| a = jv_array_append(a, elem); 1044| 274k| if (!jv_is_valid(a)) break; ------------------ | Branch (1044:9): [True: 0, False: 274k] ------------------ 1045| 274k| } 1046| 229| jv_free(b); 1047| 229| return a; 1048| 229|} jv_string_sized: 1317| 3.43M|jv jv_string_sized(const char* str, int len) { 1318| 3.43M| return 1319| 3.43M| jvp_utf8_is_valid(str, str+len) ? ------------------ | Branch (1319:5): [True: 3.27M, False: 164k] ------------------ 1320| 3.27M| jvp_string_new(str, len) : 1321| 3.43M| jvp_string_copy_replace_bad(str, len); 1322| 3.43M|} jv_string_empty: 1324| 277k|jv jv_string_empty(int len) { 1325| 277k| return jvp_string_empty_new(len); 1326| 277k|} jv_string: 1328| 1.22M|jv jv_string(const char* str) { 1329| 1.22M| return jv_string_sized(str, strlen(str)); 1330| 1.22M|} jv_string_length_bytes: 1332| 761k|int jv_string_length_bytes(jv j) { 1333| 761k| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1333:3): [True: 0, False: 761k] | Branch (1333:3): [True: 761k, False: 0] ------------------ 1334| 761k| int r = jvp_string_length(jvp_string_ptr(j)); 1335| 761k| jv_free(j); 1336| 761k| return r; 1337| 761k|} jv_string_repeat: 1379| 278k|jv jv_string_repeat(jv j, int n) { 1380| 278k| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1380:3): [True: 0, False: 278k] | Branch (1380:3): [True: 278k, False: 0] ------------------ 1381| 278k| if (n < 0) { ------------------ | Branch (1381:7): [True: 329, False: 278k] ------------------ 1382| 329| jv_free(j); 1383| 329| return jv_null(); 1384| 329| } 1385| 278k| int len = jv_string_length_bytes(jv_copy(j)); 1386| 278k| int64_t res_len = (int64_t)len * n; 1387| 278k| if ((uint64_t)res_len >= INT_MAX - sizeof(jvp_string) / 2) { ------------------ | Branch (1387:7): [True: 286, False: 277k] ------------------ 1388| 286| jv_free(j); 1389| 286| return jv_invalid_with_msg(jv_string("Repeat string result too long")); 1390| 286| } 1391| 277k| if (res_len == 0) { ------------------ | Branch (1391:7): [True: 70, False: 277k] ------------------ 1392| 70| jv_free(j); 1393| 70| return jv_string(""); 1394| 70| } 1395| 277k| jv res = jv_string_empty(res_len); 1396| 277k| res = jvp_string_append(res, jv_string_value(j), len); 1397| 483k| for (int curr = len, grow; curr < res_len; curr += grow) { ------------------ | Branch (1397:30): [True: 206k, False: 277k] ------------------ 1398| 206k| grow = MIN(res_len - curr, curr); ------------------ | | 71| 206k| ({ __typeof__ (a) _a = (a); \ | | 72| 206k| __typeof__ (b) _b = (b); \ | | 73| 206k| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (73:4): [True: 33.3k, False: 172k] | | ------------------ ------------------ 1399| 206k| res = jvp_string_append(res, jv_string_value(res), grow); 1400| 206k| } 1401| 277k| jv_free(j); 1402| 277k| return res; 1403| 277k|} jv_string_split: 1405| 362|jv jv_string_split(jv j, jv sep) { 1406| 362| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1406:3): [True: 0, False: 362] | Branch (1406:3): [True: 362, False: 0] ------------------ 1407| 362| assert(JVP_HAS_KIND(sep, JV_KIND_STRING)); ------------------ | Branch (1407:3): [True: 0, False: 362] | Branch (1407:3): [True: 362, False: 0] ------------------ 1408| 362| const char *jstr = jv_string_value(j); 1409| 362| const char *jend = jstr + jv_string_length_bytes(jv_copy(j)); 1410| 362| const char *sepstr = jv_string_value(sep); 1411| 362| const char *p, *s; 1412| 362| int seplen = jv_string_length_bytes(jv_copy(sep)); 1413| 362| jv a = jv_array(); 1414| | 1415| 362| assert(jv_get_refcnt(a) == 1); ------------------ | Branch (1415:3): [True: 0, False: 362] | Branch (1415:3): [True: 362, False: 0] ------------------ 1416| | 1417| 362| if (seplen == 0) { ------------------ | Branch (1417:7): [True: 16, False: 346] ------------------ 1418| 16| int c; 1419| 382k| while ((jstr = jvp_utf8_next(jstr, jend, &c))) { ------------------ | Branch (1419:12): [True: 382k, False: 16] ------------------ 1420| 382k| a = jv_array_append(a, jv_string_append_codepoint(jv_string(""), c)); 1421| 382k| if (!jv_is_valid(a)) break; ------------------ | Branch (1421:11): [True: 0, False: 382k] ------------------ 1422| 382k| } 1423| 346| } else { 1424| 804k| for (p = jstr; p < jend; p = s + seplen) { ------------------ | Branch (1424:20): [True: 804k, False: 346] ------------------ 1425| 804k| s = _jq_memmem(p, jend - p, sepstr, seplen); 1426| 804k| if (s == NULL) ------------------ | Branch (1426:11): [True: 23, False: 804k] ------------------ 1427| 23| s = jend; 1428| 804k| a = jv_array_append(a, jv_string_sized(p, s - p)); 1429| 804k| if (!jv_is_valid(a)) break; ------------------ | Branch (1429:11): [True: 0, False: 804k] ------------------ 1430| | // Add an empty string to denote that j ends on a sep 1431| 804k| if (s + seplen == jend && seplen != 0) ------------------ | Branch (1431:11): [True: 0, False: 804k] | Branch (1431:33): [True: 0, False: 0] ------------------ 1432| 0| a = jv_array_append(a, jv_string("")); 1433| 804k| } 1434| 346| } 1435| 362| jv_free(j); 1436| 362| jv_free(sep); 1437| 362| return a; 1438| 362|} jv_string_value: 1486| 3.62M|const char* jv_string_value(jv j) { 1487| 3.62M| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1487:3): [True: 0, False: 3.62M] | Branch (1487:3): [True: 3.62M, False: 0] ------------------ 1488| 3.62M| return jvp_string_ptr(j)->data; 1489| 3.62M|} jv_string_slice: 1491| 673|jv jv_string_slice(jv j, int start, int end) { 1492| 673| assert(JVP_HAS_KIND(j, JV_KIND_STRING)); ------------------ | Branch (1492:3): [True: 0, False: 673] | Branch (1492:3): [True: 673, False: 0] ------------------ 1493| 673| const char *s = jv_string_value(j); 1494| 673| int len = jv_string_length_bytes(jv_copy(j)); 1495| 673| int i; 1496| 673| const char *p, *e; 1497| 673| int c; 1498| 673| jv res; 1499| | 1500| 673| jvp_clamp_slice_params(len, &start, &end); 1501| 673| assert(0 <= start && start <= end && end <= len); ------------------ | Branch (1501:3): [True: 0, False: 673] | Branch (1501:3): [True: 0, False: 0] | Branch (1501:3): [True: 0, False: 0] | Branch (1501:3): [True: 673, False: 0] | Branch (1501:3): [True: 673, False: 0] | Branch (1501:3): [True: 673, False: 0] ------------------ 1502| | 1503| | /* Look for byte offset corresponding to start codepoints */ 1504| 673| for (p = s, i = 0; i < start; i++) { ------------------ | Branch (1504:22): [True: 0, False: 673] ------------------ 1505| 0| p = jvp_utf8_next(p, s + len, &c); 1506| 0| if (p == NULL) { ------------------ | Branch (1506:9): [True: 0, False: 0] ------------------ 1507| 0| jv_free(j); 1508| 0| return jv_string_empty(16); 1509| 0| } 1510| 0| if (c == -1) { ------------------ | Branch (1510:9): [True: 0, False: 0] ------------------ 1511| 0| jv_free(j); 1512| 0| return jv_invalid_with_msg(jv_string("Invalid UTF-8 string")); 1513| 0| } 1514| 0| } 1515| | /* Look for byte offset corresponding to end codepoints */ 1516| 14.7k| for (e = p; e != NULL && i < end; i++) { ------------------ | Branch (1516:15): [True: 14.7k, False: 0] | Branch (1516:28): [True: 14.6k, False: 147] ------------------ 1517| 14.6k| e = jvp_utf8_next(e, s + len, &c); 1518| 14.6k| if (e == NULL) { ------------------ | Branch (1518:9): [True: 526, False: 14.0k] ------------------ 1519| 526| e = s + len; 1520| 526| break; 1521| 526| } 1522| 14.0k| if (c == -1) { ------------------ | Branch (1522:9): [True: 0, False: 14.0k] ------------------ 1523| 0| jv_free(j); 1524| 0| return jv_invalid_with_msg(jv_string("Invalid UTF-8 string")); 1525| 0| } 1526| 14.0k| } 1527| | 1528| | /* 1529| | * NOTE: Ideally we should do here what jvp_array_slice() does instead 1530| | * of allocating a new string as we do! However, we assume NUL- 1531| | * terminated strings all over, and in the jv API, so for now we waste 1532| | * memory like a drunken navy programmer. There's probably nothing we 1533| | * can do about it. 1534| | */ 1535| 673| res = jv_string_sized(p, e - p); 1536| 673| jv_free(j); 1537| 673| return res; 1538| 673|} jv_string_concat: 1540| 57.8k|jv jv_string_concat(jv a, jv b) { 1541| 57.8k| a = jvp_string_append(a, jv_string_value(b), 1542| 57.8k| jvp_string_length(jvp_string_ptr(b))); 1543| 57.8k| jv_free(b); 1544| 57.8k| return a; 1545| 57.8k|} jv_string_append_buf: 1547| 43.8M|jv jv_string_append_buf(jv a, const char* buf, int len) { 1548| 43.8M| if (jvp_utf8_is_valid(buf, buf+len)) { ------------------ | Branch (1548:7): [True: 43.8M, False: 0] ------------------ 1549| 43.8M| a = jvp_string_append(a, buf, len); 1550| 43.8M| } else { 1551| 0| jv b = jvp_string_copy_replace_bad(buf, len); 1552| 0| a = jv_string_concat(a, b); 1553| 0| } 1554| 43.8M| return a; 1555| 43.8M|} jv_string_append_codepoint: 1557| 382k|jv jv_string_append_codepoint(jv a, uint32_t c) { 1558| 382k| char buf[5]; 1559| 382k| int len = jvp_utf8_encode(c, buf); 1560| 382k| a = jvp_string_append(a, buf, len); 1561| 382k| return a; 1562| 382k|} jv_string_vfmt: 1568| 1.19M|jv jv_string_vfmt(const char* fmt, va_list ap) { 1569| 1.19M| int size = 1024; 1570| 1.25M| while (1) { ------------------ | Branch (1570:10): [True: 1.25M, Folded] ------------------ 1571| 1.25M| char* buf = jv_mem_alloc(size); 1572| 1.25M| va_list ap2; 1573| 1.25M| va_copy(ap2, ap); 1574| 1.25M| int n = vsnprintf(buf, size, fmt, ap2); 1575| 1.25M| va_end(ap2); 1576| | /* 1577| | * NOTE: here we support old vsnprintf()s that return -1 because the 1578| | * buffer is too small. 1579| | */ 1580| 1.25M| if (n >= 0 && n < size) { ------------------ | Branch (1580:9): [True: 1.25M, False: 0] | Branch (1580:19): [True: 1.19M, False: 60.6k] ------------------ 1581| 1.19M| jv ret = jv_string_sized(buf, n); 1582| 1.19M| jv_mem_free(buf); 1583| 1.19M| return ret; 1584| 1.19M| } else { 1585| 60.6k| jv_mem_free(buf); 1586| 60.6k| size = (n > 0) ? /* standard */ (n * 2) : /* not standard */ (size * 2); ------------------ | Branch (1586:14): [True: 60.6k, False: 0] ------------------ 1587| 60.6k| } 1588| 1.25M| } 1589| 1.19M|} jv_string_fmt: 1591| 719k|jv jv_string_fmt(const char* fmt, ...) { 1592| 719k| va_list args; 1593| 719k| va_start(args, fmt); 1594| 719k| jv res = jv_string_vfmt(fmt, args); 1595| | va_end(args); 1596| 719k| return res; 1597| 719k|} jv_object: 1854| 91.2k|jv jv_object(void) { 1855| 91.2k| return jvp_object_new(8); 1856| 91.2k|} jv_object_get: 1858| 80.4k|jv jv_object_get(jv object, jv key) { 1859| 80.4k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1859:3): [True: 0, False: 80.4k] | Branch (1859:3): [True: 80.4k, False: 0] ------------------ 1860| 80.4k| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1860:3): [True: 0, False: 80.4k] | Branch (1860:3): [True: 80.4k, False: 0] ------------------ 1861| 80.4k| jv* slot = jvp_object_read(object, key); 1862| 80.4k| jv val; 1863| 80.4k| if (slot) { ------------------ | Branch (1863:7): [True: 74.3k, False: 6.02k] ------------------ 1864| 74.3k| val = jv_copy(*slot); 1865| 74.3k| } else { 1866| 6.02k| val = jv_invalid(); 1867| 6.02k| } 1868| 80.4k| jv_free(object); 1869| 80.4k| jv_free(key); 1870| 80.4k| return val; 1871| 80.4k|} jv_object_has: 1873| 273|int jv_object_has(jv object, jv key) { 1874| 273| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1874:3): [True: 0, False: 273] | Branch (1874:3): [True: 273, False: 0] ------------------ 1875| 273| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1875:3): [True: 0, False: 273] | Branch (1875:3): [True: 273, False: 0] ------------------ 1876| 273| jv* slot = jvp_object_read(object, key); 1877| 273| int res = slot ? 1 : 0; ------------------ | Branch (1877:13): [True: 0, False: 273] ------------------ 1878| 273| jv_free(object); 1879| 273| jv_free(key); 1880| 273| return res; 1881| 273|} jv_object_set: 1883| 116k|jv jv_object_set(jv object, jv key, jv value) { 1884| 116k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1884:3): [True: 0, False: 116k] | Branch (1884:3): [True: 116k, False: 0] ------------------ 1885| 116k| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1885:3): [True: 0, False: 116k] | Branch (1885:3): [True: 116k, False: 0] ------------------ 1886| | // copy/free of object, key, value coalesced 1887| 116k| jv* slot; 1888| 116k| if (!jvp_object_write(&object, key, &slot)) { ------------------ | Branch (1888:7): [True: 0, False: 116k] ------------------ 1889| 0| jv_free(object); 1890| 0| jv_free(value); 1891| 0| return jv_invalid_with_msg(jv_string("Object too big")); 1892| 0| } 1893| 116k| jv_free(*slot); 1894| 116k| *slot = value; 1895| 116k| return object; 1896| 116k|} jv_object_length: 1906| 9.10k|int jv_object_length(jv object) { 1907| 9.10k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1907:3): [True: 0, False: 9.10k] | Branch (1907:3): [True: 9.10k, False: 0] ------------------ 1908| 9.10k| int n = jvp_object_length(object); 1909| 9.10k| jv_free(object); 1910| 9.10k| return n; 1911| 9.10k|} jv_object_merge: 1913| 690|jv jv_object_merge(jv a, jv b) { 1914| 690| assert(JVP_HAS_KIND(a, JV_KIND_OBJECT)); ------------------ | Branch (1914:3): [True: 0, False: 690] | Branch (1914:3): [True: 690, False: 0] ------------------ 1915| 1.43k| jv_object_foreach(b, k, v) { ------------------ | | 170| 1.38k| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (170:52): [True: 690, False: 690] | | ------------------ | | 171| 690| for (jv k, v; \ | | 172| 2.12k| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (172:10): [True: 1.43k, False: 690] | | | Branch (172:10): [True: 1.43k, False: 690] | | ------------------ | | 173| 2.12k| (k = jv_object_iter_key(t, jv_i__), \ | | 174| 1.43k| v = jv_object_iter_value(t, jv_i__), \ | | 175| 1.43k| 1) \ | | 176| 2.12k| : 0; \ | | 177| 1.43k| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 1916| 1.43k| a = jv_object_set(a, k, v); 1917| 1.43k| if (!jv_is_valid(a)) break; ------------------ | Branch (1917:9): [True: 0, False: 1.43k] ------------------ 1918| 1.43k| } 1919| 690| jv_free(b); 1920| 690| return a; 1921| 690|} jv_object_merge_recursive: 1960| 4.60k|jv jv_object_merge_recursive(jv a, jv b) { 1961| 4.60k| return jvp_object_merge_recursive(a, b, 0); 1962| 4.60k|} jv_object_iter_valid: 1970| 74.5k|int jv_object_iter_valid(jv object, int i) { 1971| 74.5k| return i != ITER_FINISHED; 1972| 74.5k|} jv_object_iter: 1974| 13.7k|int jv_object_iter(jv object) { 1975| 13.7k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1975:3): [True: 0, False: 13.7k] | Branch (1975:3): [True: 13.7k, False: 0] ------------------ 1976| 13.7k| return jv_object_iter_next(object, -1); 1977| 13.7k|} jv_object_iter_next: 1979| 74.5k|int jv_object_iter_next(jv object, int iter) { 1980| 74.5k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1980:3): [True: 0, False: 74.5k] | Branch (1980:3): [True: 74.5k, False: 0] ------------------ 1981| 74.5k| assert(iter != ITER_FINISHED); ------------------ | Branch (1981:3): [True: 0, False: 74.5k] | Branch (1981:3): [True: 74.5k, False: 0] ------------------ 1982| 74.5k| struct object_slot* slot; 1983| 171k| do { 1984| 171k| iter++; 1985| 171k| if (iter >= jvp_object_size(object)) ------------------ | Branch (1985:9): [True: 13.7k, False: 158k] ------------------ 1986| 13.7k| return ITER_FINISHED; 1987| 158k| slot = jvp_object_get_slot(object, iter); 1988| 158k| } while (jv_get_kind(slot->string) == JV_KIND_NULL); ------------------ | Branch (1988:12): [True: 97.3k, False: 60.8k] ------------------ 1989| 74.5k| assert(jv_get_kind(jvp_object_get_slot(object,iter)->string) ------------------ | Branch (1989:3): [True: 0, False: 60.8k] | Branch (1989:3): [True: 60.8k, False: 0] ------------------ 1990| 60.8k| == JV_KIND_STRING); 1991| 60.8k| return iter; 1992| 60.8k|} jv_object_iter_key: 1994| 60.8k|jv jv_object_iter_key(jv object, int iter) { 1995| 60.8k| jv s = jvp_object_get_slot(object, iter)->string; 1996| 60.8k| assert(JVP_HAS_KIND(s, JV_KIND_STRING)); ------------------ | Branch (1996:3): [True: 0, False: 60.8k] | Branch (1996:3): [True: 60.8k, False: 0] ------------------ 1997| 60.8k| return jv_copy(s); 1998| 60.8k|} jv_object_iter_value: 2000| 55.7k|jv jv_object_iter_value(jv object, int iter) { 2001| 55.7k| return jv_copy(jvp_object_get_slot(object, iter)->value); 2002| 55.7k|} jv_copy: 2007| 14.5M|jv jv_copy(jv j) { 2008| 14.5M| if (JVP_IS_ALLOCATED(j)) { ------------------ | | 95| 14.5M|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 14.0M, False: 593k] | | ------------------ ------------------ 2009| 14.0M| jvp_refcnt_inc(j.u.ptr); 2010| 14.0M| } 2011| 14.5M| return j; 2012| 14.5M|} jv_free: 2019| 19.1M|void jv_free(jv j) { 2020| 19.1M| jv* pending = NULL; 2021| 19.1M| size_t len = 0, cap = 0; 2022| 25.0M| while (1) { ------------------ | Branch (2022:10): [True: 25.0M, Folded] ------------------ 2023| 25.0M| switch (JVP_KIND(j)) { ------------------ | | 90| 25.0M|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 89| 25.0M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | ------------------ | | | | 77| 25.0M|#define KIND_MASK 0xF | | ------------------ | | | Branch (90:23): [True: 22.7M, False: 2.29M] | | ------------------ ------------------ 2024| 5.13M| case JV_KIND_ARRAY: ------------------ | Branch (2024:7): [True: 5.13M, False: 19.8M] ------------------ 2025| 5.13M| if (jvp_refcnt_dec(j.u.ptr)) { ------------------ | Branch (2025:13): [True: 276k, False: 4.86M] ------------------ 2026| 276k| jvp_array* arr = jvp_array_ptr(j); 2027| 276k| if (len + arr->length > cap) { ------------------ | Branch (2027:15): [True: 15.4k, False: 260k] ------------------ 2028| 15.4k| cap = (len + arr->length) * 2; 2029| 15.4k| pending = jv_mem_realloc(pending, cap * sizeof(jv)); 2030| 15.4k| } 2031| 5.69M| for (int i = 0; i < arr->length; i++) ------------------ | Branch (2031:27): [True: 5.42M, False: 276k] ------------------ 2032| 5.42M| pending[len++] = arr->elements[i]; 2033| 276k| jv_mem_free(arr); 2034| 276k| } 2035| 5.13M| break; 2036| 284k| case JV_KIND_OBJECT: ------------------ | Branch (2036:7): [True: 284k, False: 24.7M] ------------------ 2037| 284k| if (jvp_refcnt_dec(j.u.ptr)) { ------------------ | Branch (2037:13): [True: 91.9k, False: 192k] ------------------ 2038| 91.9k| int sz = jvp_object_size(j); 2039| 91.9k| if (len + sz > cap) { ------------------ | Branch (2039:15): [True: 73.2k, False: 18.6k] ------------------ 2040| 73.2k| cap = (len + sz) * 2; 2041| 73.2k| pending = jv_mem_realloc(pending, cap * sizeof(jv)); 2042| 73.2k| } 2043| 877k| for (int i = 0; i < sz; i++) { ------------------ | Branch (2043:27): [True: 785k, False: 91.9k] ------------------ 2044| 785k| struct object_slot* slot = jvp_object_get_slot(j, i); 2045| 785k| if (jv_get_kind(slot->string) != JV_KIND_NULL) { ------------------ | Branch (2045:17): [True: 115k, False: 669k] ------------------ 2046| 115k| jvp_string_free(slot->string); 2047| 115k| pending[len++] = slot->value; 2048| 115k| } 2049| 785k| } 2050| 91.9k| jv_mem_free(jvp_object_ptr(j)); 2051| 91.9k| } 2052| 284k| break; 2053| 4.94M| case JV_KIND_INVALID: ------------------ | Branch (2053:7): [True: 4.94M, False: 20.0M] ------------------ 2054| 4.94M| if (JVP_HAS_FLAGS(j, JVP_FLAGS_INVALID_MSG) && jvp_refcnt_dec(j.u.ptr)) { ------------------ | | 92| 9.88M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 4.94M|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 980k, False: 3.96M] | | ------------------ ------------------ | Branch (2054:56): [True: 396k, False: 584k] ------------------ 2055| 396k| if (len + 1 > cap) { ------------------ | Branch (2055:15): [True: 396k, False: 0] ------------------ 2056| 396k| cap = (len + 1) * 2; 2057| 396k| pending = jv_mem_realloc(pending, cap * sizeof(jv)); 2058| 396k| } 2059| 396k| pending[len++] = ((jvp_invalid*)j.u.ptr)->errmsg; 2060| 396k| jv_mem_free(j.u.ptr); 2061| 396k| } 2062| 4.94M| break; 2063| 11.6M| case JV_KIND_STRING: ------------------ | Branch (2063:7): [True: 11.6M, False: 13.3M] ------------------ 2064| 11.6M| jvp_string_free(j); 2065| 11.6M| break; 2066| 701k| case JV_KIND_NUMBER: ------------------ | Branch (2066:7): [True: 701k, False: 24.3M] ------------------ 2067| 701k| jvp_number_free(j); 2068| 701k| break; 2069| 25.0M| } 2070| 25.0M| if (len == 0) break; ------------------ | Branch (2070:9): [True: 19.1M, False: 5.93M] ------------------ 2071| 5.93M| j = pending[--len]; 2072| 5.93M| } 2073| 19.1M| jv_mem_free(pending); 2074| 19.1M|} jv_get_refcnt: 2076| 362|int jv_get_refcnt(jv j) { 2077| 362| if (JVP_IS_ALLOCATED(j)) { ------------------ | | 95| 362|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 362, False: 0] | | ------------------ ------------------ 2078| 362| return j.u.ptr->count; 2079| 362| } else { 2080| 0| return 1; 2081| 0| } 2082| 362|} jv_equal: 2132| 834k|int jv_equal(jv a, jv b) { 2133| 834k| return jvp_equal(a, b, 0); 2134| 834k|} jv.c:jvp_literal_number_literal: 622| 31.5k|static const char* jvp_literal_number_literal(jv n) { 623| 31.5k| assert(JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (623:3): [True: 0, Folded] | Branch (623:3): [True: 0, False: 31.5k] | Branch (623:3): [True: 31.5k, Folded] | Branch (623:3): [True: 31.5k, False: 0] ------------------ 624| 31.5k| decNumber *pdec = jvp_dec_number_ptr(n); 625| 31.5k| jvp_literal_number* plit = jvp_literal_number_ptr(n); 626| | 627| 31.5k| if (decNumberIsNaN(pdec)) { ------------------ | | 172| 31.5k| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 31.5k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 31.5k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (172:36): [True: 0, False: 31.5k] | | ------------------ ------------------ 628| 0| return "null"; 629| 0| } 630| | 631| 31.5k| if (decNumberIsInfinite(pdec)) { ------------------ | | 171| 31.5k| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 31.5k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 515, False: 31.0k] | | ------------------ ------------------ 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| 515| return NULL; 638| 515| } 639| | 640| 31.0k| if (plit->literal_data == NULL) { ------------------ | Branch (640:7): [True: 31.0k, False: 0] ------------------ 641| 31.0k| int len = jvp_dec_number_ptr(n)->digits + 15 /* 14 + NUL */; 642| 31.0k| 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| 31.0k| decNumberToString(pdec, plit->literal_data); 648| 31.0k| } 649| | 650| 31.0k| return plit->literal_data; 651| 31.5k|} jv.c:jvp_literal_number_new: 572| 307k|static jv jvp_literal_number_new(const char * literal) { 573| 307k| size_t len = strlen(literal); 574| 307k| if (len > DEC_MAX_DIGITS) ------------------ | | 88| 307k| #define DEC_MAX_DIGITS 999999999 ------------------ | Branch (574:7): [True: 0, False: 307k] ------------------ 575| 0| return JV_INVALID; 576| 307k| jvp_literal_number* n = jvp_literal_number_alloc(len); 577| | 578| 307k| decContext *ctx = DEC_CONTEXT(); ------------------ | | 487| 307k|#define DEC_CONTEXT() tsd_dec_ctx_get(&dec_ctx_key) ------------------ 579| 307k| decContextClearStatus(ctx, DEC_Conversion_syntax); ------------------ | | 128| 307k| #define DEC_Conversion_syntax 0x00000001 ------------------ 580| 307k| decNumberFromString(&n->num_decimal, literal, ctx); 581| | 582| 307k| if (ctx->status & DEC_Conversion_syntax) { ------------------ | | 128| 307k| #define DEC_Conversion_syntax 0x00000001 ------------------ | Branch (582:7): [True: 0, False: 307k] ------------------ 583| 0| jv_mem_free(n); 584| 0| return JV_INVALID; 585| 0| } 586| 307k| if (decNumberIsNaN(&n->num_decimal)) { ------------------ | | 172| 307k| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 307k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 307k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (172:36): [True: 0, False: 307k] | | ------------------ ------------------ 587| | // Reject NaN with payload. 588| 0| if (n->num_decimal.digits > 1 || *n->num_decimal.lsu != 0) { ------------------ | Branch (588:9): [True: 0, False: 0] | Branch (588:38): [True: 0, False: 0] ------------------ 589| 0| jv_mem_free(n); 590| 0| return JV_INVALID; 591| 0| } 592| 0| jv_mem_free(n); 593| 0| return jv_number(NAN); 594| 0| } 595| | 596| 307k| jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, 0, {&n->refcnt}}; ------------------ | | 206| 307k|#define JVP_FLAGS_NUMBER_LITERAL JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_DECIMAL, 1)) | | ------------------ | | | | 87| 614k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 307k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 307k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | | | | Branch (87:61): [True: 307k, Folded] | | | | ------------------ | | ------------------ ------------------ 597| 307k| return r; 598| 307k|} jv.c:jvp_literal_number_ptr: 547| 426k|static jvp_literal_number* jvp_literal_number_ptr(jv j) { 548| 426k| assert(JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (548:3): [True: 0, Folded] | Branch (548:3): [True: 0, False: 426k] | Branch (548:3): [True: 426k, Folded] | Branch (548:3): [True: 426k, False: 0] ------------------ 549| 426k| return (jvp_literal_number*)j.u.ptr; 550| 426k|} jv.c:jvp_literal_number_to_double: 600| 69.5k|static double jvp_literal_number_to_double(jv j) { 601| 69.5k| assert(JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (601:3): [True: 0, Folded] | Branch (601:3): [True: 0, False: 69.5k] | Branch (601:3): [True: 69.5k, Folded] | Branch (601:3): [True: 69.5k, False: 0] ------------------ 602| 69.5k| decContext dblCtx; 603| | 604| | // init as decimal64 but change digits to allow conversion to binary64 (double) 605| 69.5k| decContextDefault(&dblCtx, DEC_INIT_DECIMAL64); ------------------ | | 229| 69.5k| #define DEC_INIT_DECIMAL64 64 ------------------ 606| 69.5k| dblCtx.digits = DEC_NUMBER_DOUBLE_PRECISION; ------------------ | | 209| 69.5k|#define DEC_NUMBER_DOUBLE_PRECISION (17) ------------------ 607| | 608| 69.5k| decNumber *p_dec_number = jvp_dec_number_ptr(j); 609| 69.5k| decNumberDoublePrecision dec_double; 610| 69.5k| 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| 69.5k| decNumberReduce(&dec_double.number, p_dec_number, &dblCtx); 615| | 616| 69.5k| decNumberToString(&dec_double.number, literal); 617| | 618| 69.5k| char *end; 619| 69.5k| return jvp_strtod(tsd_dtoa_context_get(), literal, &end); 620| 69.5k|} jv.c:jvp_dec_number_ptr: 552| 239k|static decNumber* jvp_dec_number_ptr(jv j) { 553| 239k| assert(JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)); ------------------ | Branch (553:3): [True: 0, Folded] | Branch (553:3): [True: 0, False: 239k] | Branch (553:3): [True: 239k, Folded] | Branch (553:3): [True: 239k, False: 0] ------------------ 554| 239k| return &(((jvp_literal_number*)j.u.ptr)->num_decimal); 555| 239k|} jv.c:jvp_literal_number_alloc: 557| 307k|static jvp_literal_number* jvp_literal_number_alloc(unsigned literal_length) { 558| | /* The number of units needed is ceil(DECNUMDIGITS/DECDPUN) */ 559| 307k| int units = ((literal_length+DECDPUN-1)/DECDPUN); ------------------ | | 43| 307k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ int units = ((literal_length+DECDPUN-1)/DECDPUN); ------------------ | | 43| 307k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 560| | 561| 307k| jvp_literal_number* n = jv_mem_alloc( 562| 307k| sizeof(jvp_literal_number) 563| 307k| + sizeof(decNumberUnit) * units 564| 307k| ); 565| | 566| 307k| n->refcnt = JV_REFCNT_INIT; 567| 307k| n->num_double = NAN; 568| | n->literal_data = NULL; 569| 307k| return n; 570| 307k|} jv.c:tsd_dec_ctx_get: 504| 339k|static decContext* tsd_dec_ctx_get(pthread_key_t *key) { 505| 339k| pthread_once(&dec_ctx_once, jv_tsd_dec_ctx_init); // cannot fail 506| 339k| decContext *ctx = (decContext*)pthread_getspecific(*key); 507| 339k| if (ctx) { ------------------ | Branch (507:7): [True: 339k, False: 1] ------------------ 508| 339k| return ctx; 509| 339k| } 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, ------------------ | | 71| 1| ({ __typeof__ (a) _a = (a); \ | | 72| 1| __typeof__ (b) _b = (b); \ | | 73| 1| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (73: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| 274k|static jv jvp_array_new(unsigned size) { 841| 274k| jv r = {JVP_FLAGS_ARRAY, 0, 0, 0, {&jvp_array_alloc(size)->refcnt}}; ------------------ | | 813| 274k|#define JVP_FLAGS_ARRAY JVP_MAKE_FLAGS(JV_KIND_ARRAY, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 274k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 274k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 274k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 842| 274k| return r; 843| 274k|} jv.c:jvp_array_alloc: 832| 276k|static jvp_array* jvp_array_alloc(unsigned size) { 833| 276k| jvp_array* a = jv_mem_alloc(sizeof(jvp_array) + sizeof(jv) * size); 834| 276k| a->refcnt.count = 1; 835| 276k| a->length = 0; 836| 276k| a->alloc_length = size; 837| 276k| return a; 838| 276k|} jv.c:jvp_array_length: 845| 8.28M|static int jvp_array_length(jv a) { 846| 8.28M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (846:3): [True: 0, False: 8.28M] | Branch (846:3): [True: 8.28M, False: 0] ------------------ 847| 8.28M| return a.size; 848| 8.28M|} jv.c:jvp_array_read: 855| 2.39M|static jv* jvp_array_read(jv a, int i) { 856| 2.39M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (856:3): [True: 0, False: 2.39M] | Branch (856:3): [True: 2.39M, False: 0] ------------------ 857| 2.39M| if (i >= 0 && i < jvp_array_length(a)) { ------------------ | Branch (857:7): [True: 2.39M, False: 0] | Branch (857:17): [True: 2.39M, False: 0] ------------------ 858| 2.39M| jvp_array* array = jvp_array_ptr(a); 859| 2.39M| assert(i + jvp_array_offset(a) < array->length); ------------------ | Branch (859:5): [True: 0, False: 2.39M] | Branch (859:5): [True: 2.39M, False: 0] ------------------ 860| 2.39M| return &array->elements[i + jvp_array_offset(a)]; 861| 2.39M| } else { 862| 0| return 0; 863| 0| } 864| 2.39M|} jv.c:jvp_array_offset: 850| 11.9M|static int jvp_array_offset(jv a) { 851| 11.9M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (851:3): [True: 0, False: 11.9M] | Branch (851:3): [True: 11.9M, False: 0] ------------------ 852| 11.9M| return a.offset; 853| 11.9M|} jv.c:jvp_array_write: 866| 1.73M|static jv* jvp_array_write(jv* a, int i) { 867| 1.73M| assert(i >= 0); ------------------ | Branch (867:3): [True: 0, False: 1.73M] | Branch (867:3): [True: 1.73M, False: 0] ------------------ 868| 1.73M| jvp_array* array = jvp_array_ptr(*a); 869| | 870| 1.73M| int pos = i + jvp_array_offset(*a); 871| 1.73M| if (pos < array->alloc_length && jvp_refcnt_unshared(a->u.ptr)) { ------------------ | Branch (871:7): [True: 1.73M, False: 1.92k] | Branch (871:36): [True: 1.73M, False: 0] ------------------ 872| | // use existing array space 873| 3.46M| for (int j = array->length; j <= pos; j++) { ------------------ | Branch (873:33): [True: 1.73M, False: 1.73M] ------------------ 874| 1.73M| array->elements[j] = JV_NULL; 875| 1.73M| } 876| 1.73M| array->length = imax(pos + 1, array->length); 877| 1.73M| a->size = imax(i + 1, a->size); 878| 1.73M| return &array->elements[pos]; 879| 1.73M| } else { 880| | // allocate a new array 881| 1.92k| int new_length = imax(i + 1, jvp_array_length(*a)); 882| 1.92k| jvp_array* new_array = jvp_array_alloc(ARRAY_SIZE_ROUND_UP(new_length)); ------------------ | | 812| 1.92k|#define ARRAY_SIZE_ROUND_UP(n) (((n)*3)/2) ------------------ 883| 1.92k| int j; 884| 3.68M| for (j = 0; j < jvp_array_length(*a); j++) { ------------------ | Branch (884:17): [True: 3.68M, False: 1.92k] ------------------ 885| 3.68M| new_array->elements[j] = 886| 3.68M| jv_copy(array->elements[j + jvp_array_offset(*a)]); 887| 3.68M| } 888| 3.85k| for (; j < new_length; j++) { ------------------ | Branch (888:12): [True: 1.92k, False: 1.92k] ------------------ 889| 1.92k| new_array->elements[j] = JV_NULL; 890| 1.92k| } 891| 1.92k| new_array->length = new_length; 892| 1.92k| jv_free(*a); 893| 1.92k| jv new_jv = {JVP_FLAGS_ARRAY, 0, 0, new_length, {&new_array->refcnt}}; ------------------ | | 813| 1.92k|#define JVP_FLAGS_ARRAY JVP_MAKE_FLAGS(JV_KIND_ARRAY, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 1.92k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 1.92k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 1.92k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 894| 1.92k| *a = new_jv; 895| 1.92k| return &new_array->elements[i]; 896| 1.92k| } 897| 1.73M|} jv.c:jvp_refcnt_unshared: 72| 46.5M|static int jvp_refcnt_unshared(jv_refcnt* c) { 73| 46.5M| assert(c->count > 0); ------------------ | Branch (73:3): [True: 0, False: 46.5M] | Branch (73:3): [True: 46.5M, False: 0] ------------------ 74| 46.5M| return c->count == 1; 75| 46.5M|} jv.c:imax: 815| 3.47M|static int imax(int a, int b) { 816| 3.47M| if (a>b) return a; ------------------ | Branch (816:7): [True: 3.47M, False: 0] ------------------ 817| 0| else return b; 818| 3.47M|} jv.c:jvp_string_new: 1141| 3.27M|static jv jvp_string_new(const char* data, uint32_t length) { 1142| 3.27M| jvp_string* s = jvp_string_alloc(length); 1143| 3.27M| s->length_hashed = length << 1; 1144| 3.27M| if (data != NULL) ------------------ | Branch (1144:7): [True: 3.27M, False: 0] ------------------ 1145| 3.27M| memcpy(s->data, data, length); 1146| 3.27M| s->data[length] = 0; 1147| 3.27M| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&s->refcnt}}; ------------------ | | 1087| 3.27M|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 3.27M|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 3.27M|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 3.27M|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1148| 3.27M| return r; 1149| 3.27M|} jv.c:jvp_string_alloc: 1104| 4.13M|static jvp_string* jvp_string_alloc(uint32_t size) { 1105| 4.13M| jvp_string* s = jv_mem_alloc(sizeof(jvp_string) + size + 1); 1106| 4.13M| s->refcnt.count = 1; 1107| 4.13M| s->alloc_length = size; 1108| 4.13M| return s; 1109| 4.13M|} jv.c:jvp_string_copy_replace_bad: 1112| 164k|static jv jvp_string_copy_replace_bad(const char* data, uint32_t length) { 1113| 164k| const char* end = data + length; 1114| 164k| const char* i = data; 1115| | 1116| | // worst case: all bad bytes, each becomes a 3-byte U+FFFD 1117| 164k| uint64_t maxlength = (uint64_t)length * 3 + 1; 1118| 164k| if (maxlength >= INT_MAX) { ------------------ | Branch (1118:7): [True: 0, False: 164k] ------------------ 1119| 0| return jv_invalid_with_msg(jv_string("String too long")); 1120| 0| } 1121| | 1122| 164k| jvp_string* s = jvp_string_alloc(maxlength); 1123| 164k| char* out = s->data; 1124| 164k| int c = 0; 1125| | 1126| 812M| while ((i = jvp_utf8_next(i, end, &c))) { ------------------ | Branch (1126:10): [True: 812M, False: 164k] ------------------ 1127| 812M| if (c == -1) { ------------------ | Branch (1127:9): [True: 66.0M, False: 746M] ------------------ 1128| 66.0M| c = 0xFFFD; // U+FFFD REPLACEMENT CHARACTER 1129| 66.0M| } 1130| 812M| out += jvp_utf8_encode(c, out); 1131| 812M| assert(out < s->data + maxlength); ------------------ | Branch (1131:5): [True: 0, False: 812M] | Branch (1131:5): [True: 812M, False: 0] ------------------ 1132| 812M| } 1133| 164k| length = out - s->data; 1134| 164k| s->data[length] = 0; 1135| 164k| s->length_hashed = length << 1; 1136| 164k| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&s->refcnt}}; ------------------ | | 1087| 164k|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 164k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 164k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 164k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1137| 164k| return r; 1138| 164k|} jv.c:jvp_string_empty_new: 1151| 277k|static jv jvp_string_empty_new(uint32_t length) { 1152| 277k| jvp_string* s = jvp_string_alloc(length); 1153| 277k| s->length_hashed = 0; 1154| 277k| memset(s->data, 0, length); 1155| 277k| s->data[length] = 0; 1156| 277k| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&s->refcnt}}; ------------------ | | 1087| 277k|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 277k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 277k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 277k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1157| 277k| return r; 1158| 277k|} jv.c:jvp_string_length: 1168| 137M|static uint32_t jvp_string_length(jvp_string* s) { 1169| 137M| return s->length_hashed >> 1; 1170| 137M|} jv.c:jvp_string_ptr: 1099| 63.8M|static jvp_string* jvp_string_ptr(jv a) { 1100| 63.8M| assert(JVP_HAS_KIND(a, JV_KIND_STRING)); ------------------ | Branch (1100:3): [True: 0, False: 63.8M] | Branch (1100:3): [True: 63.8M, False: 0] ------------------ 1101| 63.8M| return (jvp_string*)a.u.ptr; 1102| 63.8M|} jv.c:jvp_string_append: 1178| 44.7M|static jv jvp_string_append(jv string, const char* data, uint32_t len) { 1179| 44.7M| jvp_string* s = jvp_string_ptr(string); 1180| 44.7M| uint32_t currlen = jvp_string_length(s); 1181| 44.7M| if ((uint64_t)currlen + len >= INT_MAX - sizeof(jvp_string) / 2) { ------------------ | Branch (1181:7): [True: 0, False: 44.7M] ------------------ 1182| 0| jv_free(string); 1183| 0| return jv_invalid_with_msg(jv_string("String too long")); 1184| 0| } 1185| | 1186| 44.7M| if (jvp_refcnt_unshared(string.u.ptr) && ------------------ | Branch (1186:7): [True: 44.7M, False: 0] ------------------ 1187| 44.7M| jvp_string_remaining_space(s) >= len) { ------------------ | Branch (1187:7): [True: 44.3M, False: 415k] ------------------ 1188| | // the next string fits at the end of a 1189| 44.3M| memcpy(s->data + currlen, data, len); 1190| 44.3M| s->data[currlen + len] = 0; 1191| 44.3M| s->length_hashed = (currlen + len) << 1; 1192| 44.3M| return string; 1193| 44.3M| } else { 1194| | // allocate a bigger buffer and copy 1195| 415k| uint32_t allocsz = (currlen + len) * 2; 1196| 415k| if (allocsz < 32) allocsz = 32; ------------------ | Branch (1196:9): [True: 408k, False: 6.47k] ------------------ 1197| 415k| jvp_string* news = jvp_string_alloc(allocsz); 1198| 415k| news->length_hashed = (currlen + len) << 1; 1199| 415k| memcpy(news->data, s->data, currlen); 1200| 415k| memcpy(news->data + currlen, data, len); 1201| 415k| news->data[currlen + len] = 0; 1202| 415k| jvp_string_free(string); 1203| 415k| jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&news->refcnt}}; ------------------ | | 1087| 415k|#define JVP_FLAGS_STRING JVP_MAKE_FLAGS(JV_KIND_STRING, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 415k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 415k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 415k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1204| 415k| return r; 1205| 415k| } 1206| 44.7M|} jv.c:jvp_string_remaining_space: 1172| 44.7M|static uint32_t jvp_string_remaining_space(jvp_string* s) { 1173| 44.7M| assert(s->alloc_length >= jvp_string_length(s)); ------------------ | Branch (1173:3): [True: 0, False: 44.7M] | Branch (1173:3): [True: 44.7M, False: 0] ------------------ 1174| 44.7M| uint32_t r = s->alloc_length - jvp_string_length(s); 1175| 44.7M| return r; 1176| 44.7M|} jv.c:jvp_string_hash: 1245| 667k|static uint32_t jvp_string_hash(jv jstr) { 1246| 667k| jvp_string* str = jvp_string_ptr(jstr); 1247| 667k| if (str->length_hashed & 1) ------------------ | Branch (1247:7): [True: 487k, False: 180k] ------------------ 1248| 487k| return str->hash; 1249| | 1250| | /* The following is based on MurmurHash3. 1251| | MurmurHash3 was written by Austin Appleby, and is placed 1252| | in the public domain. */ 1253| | 1254| 180k| const uint8_t* data = (const uint8_t*)str->data; 1255| 180k| int len = (int)jvp_string_length(str); 1256| 180k| const int nblocks = len / 4; 1257| | 1258| 180k| uint32_t h1 = jvp_hash_seed(); 1259| | 1260| 180k| const uint32_t c1 = 0xcc9e2d51; 1261| 180k| const uint32_t c2 = 0x1b873593; 1262| 180k| const uint32_t* blocks = (const uint32_t *)(data + nblocks*4); 1263| | 1264| 364k| for(int i = -nblocks; i; i++) { ------------------ | Branch (1264:25): [True: 183k, False: 180k] ------------------ 1265| 183k| uint32_t k1 = blocks[i]; //FIXME: endianness/alignment 1266| | 1267| 183k| k1 *= c1; 1268| 183k| k1 = rotl32(k1,15); 1269| 183k| k1 *= c2; 1270| | 1271| 183k| h1 ^= k1; 1272| 183k| h1 = rotl32(h1,13); 1273| 183k| h1 = h1*5+0xe6546b64; 1274| 183k| } 1275| | 1276| 180k| const uint8_t* tail = (const uint8_t*)(data + nblocks*4); 1277| | 1278| 180k| uint32_t k1 = 0; 1279| | 1280| 180k| switch(len & 3) { ------------------ | Branch (1280:10): [True: 138k, False: 42.5k] ------------------ 1281| 14.1k| case 3: k1 ^= tail[2] << 16; ------------------ | Branch (1281:3): [True: 14.1k, False: 166k] ------------------ 1282| 14.1k| JQ_FALLTHROUGH; ------------------ | | 14| 14.1k|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1283| 99.8k| case 2: k1 ^= tail[1] << 8; ------------------ | Branch (1283:3): [True: 85.7k, False: 94.8k] ------------------ 1284| 99.8k| JQ_FALLTHROUGH; ------------------ | | 14| 99.8k|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 1285| 138k| case 1: k1 ^= tail[0]; ------------------ | Branch (1285:3): [True: 38.2k, False: 142k] ------------------ 1286| 138k| k1 *= c1; k1 = rotl32(k1,15); k1 *= c2; h1 ^= k1; 1287| 180k| } 1288| | 1289| 180k| h1 ^= len; 1290| | 1291| 180k| h1 ^= h1 >> 16; 1292| 180k| h1 *= 0x85ebca6b; 1293| 180k| h1 ^= h1 >> 13; 1294| 180k| h1 *= 0xc2b2ae35; 1295| 180k| h1 ^= h1 >> 16; 1296| | 1297| 180k| str->length_hashed |= 1; 1298| 180k| str->hash = h1; 1299| | 1300| 180k| return h1; 1301| 180k|} jv.c:jvp_hash_seed: 1236| 180k|static uint32_t jvp_hash_seed(void) { 1237| 180k| pthread_once(&hash_seed_once, jvp_hash_seed_init); 1238| 180k| return hash_seed; 1239| 180k|} jv.c:jvp_hash_seed_init: 1211| 1|static void jvp_hash_seed_init(void) { 1212| 1| uint32_t seed; 1213| | /* Prefer getentropy() over arc4random(): glibc's arc4random() aborts the 1214| | * process when the kernel lacks getrandom(2) (#3584), while getentropy() 1215| | * merely fails, letting us fall back to /dev/urandom. */ 1216| 1|#if defined(HAVE_GETENTROPY) 1217| 1| if (getentropy(&seed, sizeof(seed)) == 0) { ------------------ | Branch (1217:7): [True: 1, False: 0] ------------------ 1218| 1| hash_seed = seed; 1219| 1| return; 1220| 1| } 1221| |#elif defined(HAVE_ARC4RANDOM) 1222| | hash_seed = arc4random(); 1223| | return; 1224| |#endif 1225| 0| int fd = open("/dev/urandom", O_RDONLY); 1226| 0| if (fd >= 0) { ------------------ | Branch (1226:7): [True: 0, False: 0] ------------------ 1227| 0| if (read(fd, &seed, sizeof(seed)) != 4) ------------------ | Branch (1227:9): [True: 0, False: 0] ------------------ 1228| 0| seed = (uint32_t)getpid() ^ (uint32_t)time(NULL); 1229| 0| close(fd); 1230| 0| } else { 1231| | seed = (uint32_t)getpid() ^ (uint32_t)time(NULL); 1232| 0| } 1233| 0| hash_seed = seed; 1234| 0|} jv.c:rotl32: 1241| 505k|static uint32_t rotl32 (uint32_t x, int8_t r){ 1242| 505k| return (x << r) | (x >> (32 - r)); 1243| 505k|} jv.c:jvp_clamp_slice_params: 918| 673|{ 919| 673| if (*pstart < 0) *pstart = len + *pstart; ------------------ | Branch (919:7): [True: 0, False: 673] ------------------ 920| 673| if (*pend < 0) *pend = len + *pend; ------------------ | Branch (920:7): [True: 0, False: 673] ------------------ 921| | 922| 673| if (*pstart < 0) *pstart = 0; ------------------ | Branch (922:7): [True: 0, False: 673] ------------------ 923| 673| if (*pstart > len) *pstart = len; ------------------ | Branch (923:7): [True: 0, False: 673] ------------------ 924| 673| if (*pend > len) *pend = len; ------------------ | Branch (924:7): [True: 0, False: 673] ------------------ 925| 673| if (*pend < *pstart) *pend = *pstart; ------------------ | Branch (925:7): [True: 0, False: 673] ------------------ 926| 673|} jv.c:jvp_object_new: 1620| 93.4k|static jv jvp_object_new(int size) { 1621| | // Allocates an object of (size) slots and (size*2) hash buckets. 1622| | 1623| | // size must be a power of two 1624| 93.4k| assert(size > 0 && (size & (size - 1)) == 0); ------------------ | Branch (1624:3): [True: 0, False: 93.4k] | Branch (1624:3): [True: 0, False: 0] | Branch (1624:3): [True: 93.4k, False: 0] | Branch (1624:3): [True: 93.4k, False: 0] ------------------ 1625| | 1626| 93.4k| jvp_object* obj = jv_mem_alloc(sizeof(jvp_object) + 1627| 93.4k| sizeof(struct object_slot) * size + 1628| 93.4k| sizeof(int) * (size * 2)); 1629| 93.4k| obj->refcnt.count = 1; 1630| 928k| for (int i=0; ielements[i].next = i - 1; 1632| 835k| obj->elements[i].string = JV_NULL; 1633| 835k| obj->elements[i].hash = 0; 1634| 835k| obj->elements[i].value = JV_NULL; 1635| 835k| } 1636| 93.4k| obj->next_free = 0; 1637| 93.4k| int* hashbuckets = (int*)(&obj->elements[size]); 1638| 1.76M| for (int i=0; irefcnt}}; ------------------ | | 1603| 93.4k|#define JVP_FLAGS_OBJECT JVP_MAKE_FLAGS(JV_KIND_OBJECT, JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | | 87| 93.4k|#define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 77| 93.4k|#define KIND_MASK 0xF | | | | ------------------ | | | | #define JVP_MAKE_FLAGS(kind, pflags) ((kind & KIND_MASK) | (pflags & PFLAGS_MASK)) | | | | ------------------ | | | | | | 78| 93.4k|#define PFLAGS_MASK 0xF0 | | | | ------------------ | | ------------------ ------------------ 1642| 93.4k| return r; 1643| 93.4k|} jv.c:jvp_object_read: 1703| 83.8k|static jv* jvp_object_read(jv object, jv key) { 1704| 83.8k| assert(JVP_HAS_KIND(key, JV_KIND_STRING)); ------------------ | Branch (1704:3): [True: 0, False: 83.8k] | Branch (1704:3): [True: 83.8k, False: 0] ------------------ 1705| 83.8k| int* bucket = jvp_object_find_bucket(object, key); 1706| 83.8k| struct object_slot* slot = jvp_object_find_slot(object, key, bucket); 1707| 83.8k| if (slot == 0) return 0; ------------------ | Branch (1707:7): [True: 7.25k, False: 76.5k] ------------------ 1708| 76.5k| else return &slot->value; 1709| 83.8k|} jv.c:jvp_object_find_bucket: 1664| 251k|static int* jvp_object_find_bucket(jv object, jv key) { 1665| 251k| return jvp_object_buckets(object) + (jvp_object_mask(object) & jvp_string_hash(key)); 1666| 251k|} jv.c:jvp_object_buckets: 1660| 252k|static int* jvp_object_buckets(jv o) { 1661| 252k| return (int*)(&jvp_object_ptr(o)->elements[o.size]); 1662| 252k|} jv.c:jvp_object_mask: 1650| 251k|static uint32_t jvp_object_mask(jv o) { 1651| 251k| assert(JVP_HAS_KIND(o, JV_KIND_OBJECT)); ------------------ | Branch (1651:3): [True: 0, False: 251k] | Branch (1651:3): [True: 251k, False: 0] ------------------ 1652| 251k| return (o.size * 2) - 1; 1653| 251k|} jv.c:jvp_object_find_slot: 1678| 251k|static struct object_slot* jvp_object_find_slot(jv object, jv keystr, int* bucket) { 1679| 251k| uint32_t hash = jvp_string_hash(keystr); 1680| 251k| for (struct object_slot* curr = jvp_object_get_slot(object, *bucket); 1681| 283k| curr; ------------------ | Branch (1681:8): [True: 109k, False: 173k] ------------------ 1682| 251k| curr = jvp_object_next_slot(object, curr)) { 1683| 109k| if (curr->hash == hash && jvp_string_equal(keystr, curr->string)) { ------------------ | Branch (1683:9): [True: 78.0k, False: 31.8k] | Branch (1683:31): [True: 78.0k, False: 0] ------------------ 1684| 78.0k| return curr; 1685| 78.0k| } 1686| 109k| } 1687| 173k| return 0; 1688| 251k|} jv.c:jvp_string_equal: 1304| 870k|static int jvp_string_equal(jv a, jv b) { 1305| 870k| assert(JVP_HAS_KIND(a, JV_KIND_STRING)); ------------------ | Branch (1305:3): [True: 0, False: 870k] | Branch (1305:3): [True: 870k, False: 0] ------------------ 1306| 870k| assert(JVP_HAS_KIND(b, JV_KIND_STRING)); ------------------ | Branch (1306:3): [True: 0, False: 870k] | Branch (1306:3): [True: 870k, False: 0] ------------------ 1307| 870k| jvp_string* stra = jvp_string_ptr(a); 1308| 870k| jvp_string* strb = jvp_string_ptr(b); 1309| 870k| if (jvp_string_length(stra) != jvp_string_length(strb)) return 0; ------------------ | Branch (1309:7): [True: 698k, False: 172k] ------------------ 1310| 172k| return memcmp(stra->data, strb->data, jvp_string_length(stra)) == 0; 1311| 870k|} jv.c:jvp_object_next_slot: 1674| 31.8k|static struct object_slot* jvp_object_next_slot(jv object, struct object_slot* slot) { 1675| 31.8k| return jvp_object_get_slot(object, slot->next); 1676| 31.8k|} jv.c:jvp_object_write: 1760| 116k|static int jvp_object_write(jv* object, jv key, jv **valpp) { 1761| 116k| *object = jvp_object_unshare(*object); 1762| 116k| int* bucket = jvp_object_find_bucket(*object, key); 1763| 116k| struct object_slot* slot = jvp_object_find_slot(*object, key, bucket); 1764| 116k| if (slot) { ------------------ | Branch (1764:7): [True: 1.47k, False: 114k] ------------------ 1765| | // already has the key 1766| 1.47k| jvp_string_free(key); 1767| 1.47k| *valpp = &slot->value; 1768| 1.47k| return 1; 1769| 1.47k| } 1770| 114k| slot = jvp_object_add_slot(*object, key, bucket); 1771| 114k| if (slot) { ------------------ | Branch (1771:7): [True: 113k, False: 1.50k] ------------------ 1772| 113k| slot->value = jv_invalid(); 1773| 113k| } else { 1774| 1.50k| if (!jvp_object_rehash(object)) { ------------------ | Branch (1774:9): [True: 0, False: 1.50k] ------------------ 1775| 0| jvp_string_free(key); 1776| 0| *valpp = NULL; 1777| 0| return 0; 1778| 0| } 1779| 1.50k| bucket = jvp_object_find_bucket(*object, key); 1780| 1.50k| assert(!jvp_object_find_slot(*object, key, bucket)); ------------------ | Branch (1780:5): [True: 0, False: 1.50k] | Branch (1780:5): [True: 1.50k, False: 0] ------------------ 1781| 1.50k| slot = jvp_object_add_slot(*object, key, bucket); 1782| 1.50k| assert(slot); ------------------ | Branch (1782:5): [True: 0, False: 1.50k] | Branch (1782:5): [True: 1.50k, False: 0] ------------------ 1783| 1.50k| slot->value = jv_invalid(); 1784| 1.50k| } 1785| 114k| *valpp = &slot->value; 1786| 114k| return 1; 1787| 114k|} jv.c:jvp_object_unshare: 1734| 116k|static jv jvp_object_unshare(jv object) { 1735| 116k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1735:3): [True: 0, False: 116k] | Branch (1735:3): [True: 116k, False: 0] ------------------ 1736| 116k| if (jvp_refcnt_unshared(object.u.ptr)) ------------------ | Branch (1736:7): [True: 115k, False: 699] ------------------ 1737| 115k| return object; 1738| | 1739| 699| jv new_object = jvp_object_new(jvp_object_size(object)); 1740| 699| jvp_object_ptr(new_object)->next_free = jvp_object_ptr(object)->next_free; 1741| 6.29k| for (int i=0; istring) != JV_KIND_NULL) { ------------------ | Branch (1745:9): [True: 1.14k, False: 4.44k] ------------------ 1746| 1.14k| new_slot->string = jv_copy(old_slot->string); 1747| 1.14k| new_slot->value = jv_copy(old_slot->value); 1748| 1.14k| } 1749| 5.59k| } 1750| | 1751| 699| int* old_buckets = jvp_object_buckets(object); 1752| 699| int* new_buckets = jvp_object_buckets(new_object); 1753| 699| memcpy(new_buckets, old_buckets, sizeof(int) * jvp_object_size(new_object)*2); 1754| | 1755| 699| jv_free(object); 1756| 699| assert(jvp_refcnt_unshared(new_object.u.ptr)); ------------------ | Branch (1756:3): [True: 0, False: 699] | Branch (1756:3): [True: 699, False: 0] ------------------ 1757| 699| return new_object; 1758| 699|} jv.c:jvp_object_add_slot: 1690| 166k|static struct object_slot* jvp_object_add_slot(jv object, jv key, int* bucket) { 1691| 166k| jvp_object* o = jvp_object_ptr(object); 1692| 166k| int newslot_idx = o->next_free; 1693| 166k| if (newslot_idx == jvp_object_size(object)) return 0; ------------------ | Branch (1693:7): [True: 1.50k, False: 164k] ------------------ 1694| 164k| struct object_slot* newslot = jvp_object_get_slot(object, newslot_idx); 1695| 164k| o->next_free++; 1696| 164k| newslot->next = *bucket; 1697| 164k| *bucket = newslot_idx; 1698| 164k| newslot->hash = jvp_string_hash(key); 1699| 164k| newslot->string = key; 1700| 164k| return newslot; 1701| 166k|} jv.c:jvp_object_rehash: 1711| 1.50k|static int jvp_object_rehash(jv *objectp) { 1712| 1.50k| jv object = *objectp; 1713| 1.50k| assert(JVP_HAS_KIND(object, JV_KIND_OBJECT)); ------------------ | Branch (1713:3): [True: 0, False: 1.50k] | Branch (1713:3): [True: 1.50k, False: 0] ------------------ 1714| 1.50k| assert(jvp_refcnt_unshared(object.u.ptr)); ------------------ | Branch (1714:3): [True: 0, False: 1.50k] | Branch (1714:3): [True: 1.50k, False: 0] ------------------ 1715| 1.50k| int size = jvp_object_size(object); 1716| 1.50k| if (size > INT_MAX >> 2) ------------------ | Branch (1716:7): [True: 0, False: 1.50k] ------------------ 1717| 0| return 0; 1718| 1.50k| jv new_object = jvp_object_new(size * 2); 1719| 51.4k| for (int i=0; istring) == JV_KIND_NULL) continue; ------------------ | Branch (1721:9): [True: 0, False: 49.9k] ------------------ 1722| 49.9k| int* new_bucket = jvp_object_find_bucket(new_object, slot->string); 1723| 49.9k| assert(!jvp_object_find_slot(new_object, slot->string, new_bucket)); ------------------ | Branch (1723:5): [True: 0, False: 49.9k] | Branch (1723:5): [True: 49.9k, False: 0] ------------------ 1724| 49.9k| struct object_slot* new_slot = jvp_object_add_slot(new_object, slot->string, new_bucket); 1725| 49.9k| assert(new_slot); ------------------ | Branch (1725:5): [True: 0, False: 49.9k] | Branch (1725:5): [True: 49.9k, False: 0] ------------------ 1726| 49.9k| new_slot->value = slot->value; 1727| 49.9k| } 1728| | // references are transported, just drop the old table 1729| 1.50k| jv_mem_free(jvp_object_ptr(object)); 1730| 1.50k| *objectp = new_object; 1731| 1.50k| return 1; 1732| 1.50k|} jv.c:jvp_object_length: 1810| 13.2k|static int jvp_object_length(jv object) { 1811| 13.2k| int n = 0; 1812| 164k| for (int i=0; istring) != JV_KIND_NULL) n++; ------------------ | Branch (1814:9): [True: 50.6k, False: 101k] ------------------ 1815| 151k| } 1816| 13.2k| return n; 1817| 13.2k|} jv.c:jvp_object_merge_recursive: 1927| 5.11k|static jv jvp_object_merge_recursive(jv a, jv b, int depth) { 1928| 5.11k| assert(JVP_HAS_KIND(a, JV_KIND_OBJECT)); ------------------ | Branch (1928:3): [True: 0, False: 5.11k] | Branch (1928:3): [True: 5.11k, False: 0] ------------------ 1929| 5.11k| assert(JVP_HAS_KIND(b, JV_KIND_OBJECT)); ------------------ | Branch (1929:3): [True: 0, False: 5.11k] | Branch (1929:3): [True: 5.11k, False: 0] ------------------ 1930| | 1931| 5.11k| if (depth > MAX_OBJECT_MERGE_DEPTH) { ------------------ | | 1924| 5.11k|#define MAX_OBJECT_MERGE_DEPTH (10000) ------------------ | Branch (1931:7): [True: 0, False: 5.11k] ------------------ 1932| 0| jv_free(a); 1933| 0| jv_free(b); 1934| 0| return jv_invalid_with_msg(jv_string("Object merge too deep")); 1935| 0| } 1936| | 1937| 6.34k| jv_object_foreach(b, k, v) { ------------------ | | 170| 10.2k| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (170:52): [True: 5.11k, False: 5.11k] | | ------------------ | | 171| 5.11k| for (jv k, v; \ | | 172| 11.4k| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (172:10): [True: 6.34k, False: 5.11k] | | | Branch (172:10): [True: 6.34k, False: 5.11k] | | ------------------ | | 173| 11.4k| (k = jv_object_iter_key(t, jv_i__), \ | | 174| 6.34k| v = jv_object_iter_value(t, jv_i__), \ | | 175| 6.34k| 1) \ | | 176| 11.4k| : 0; \ | | 177| 6.34k| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 1938| 6.34k| jv elem = jv_object_get(jv_copy(a), jv_copy(k)); 1939| 6.34k| if (jv_is_valid(elem) && ------------------ | Branch (1939:9): [True: 1.15k, False: 5.18k] ------------------ 1940| 1.15k| JVP_HAS_KIND(elem, JV_KIND_OBJECT) && ------------------ | | 93| 7.50k|#define JVP_HAS_KIND(j, kind) (JVP_KIND(j) == kind) | | ------------------ | | | | 90| 1.15k|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 89| 1.15k|#define JVP_FLAGS(j) ((j).kind_flags) | | | | ------------------ | | | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 77| 1.15k|#define KIND_MASK 0xF | | | | ------------------ | | ------------------ | | | Branch (93:33): [True: 863, False: 295] | | ------------------ ------------------ 1941| 863| JVP_HAS_KIND(v, JV_KIND_OBJECT)) { ------------------ | | 93| 863|#define JVP_HAS_KIND(j, kind) (JVP_KIND(j) == kind) | | ------------------ | | | | 90| 863|#define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 89| 863|#define JVP_FLAGS(j) ((j).kind_flags) | | | | ------------------ | | | | #define JVP_KIND(j) (JVP_FLAGS(j) & KIND_MASK) | | | | ------------------ | | | | | | 77| 863|#define KIND_MASK 0xF | | | | ------------------ | | ------------------ | | | Branch (93:33): [True: 509, False: 354] | | ------------------ ------------------ 1942| 509| jv merged = jvp_object_merge_recursive(elem, v, depth + 1); 1943| 509| if (!jv_is_valid(merged)) { ------------------ | Branch (1943:11): [True: 0, False: 509] ------------------ 1944| 0| jv_free(k); 1945| 0| jv_free(a); 1946| 0| jv_free(b); 1947| 0| return merged; 1948| 0| } 1949| 509| a = jv_object_set(a, k, merged); 1950| 5.83k| } else { 1951| 5.83k| jv_free(elem); 1952| 5.83k| a = jv_object_set(a, k, v); 1953| 5.83k| } 1954| 6.34k| if (!jv_is_valid(a)) break; ------------------ | Branch (1954:9): [True: 0, False: 6.34k] ------------------ 1955| 6.34k| } 1956| 5.11k| jv_free(b); 1957| 5.11k| return a; 1958| 5.11k|} jv.c:jvp_object_size: 1655| 2.24M|static int jvp_object_size(jv o) { 1656| 2.24M| assert(JVP_HAS_KIND(o, JV_KIND_OBJECT)); ------------------ | Branch (1656:3): [True: 0, False: 2.24M] | Branch (1656:3): [True: 2.24M, False: 0] ------------------ 1657| 2.24M| return o.size; 1658| 2.24M|} jv.c:jvp_object_get_slot: 1668| 1.79M|static struct object_slot* jvp_object_get_slot(jv object, int slot) { 1669| 1.79M| assert(slot == -1 || (slot >= 0 && slot < jvp_object_size(object))); ------------------ | Branch (1669:3): [True: 0, False: 0] | Branch (1669:3): [True: 0, False: 0] | Branch (1669:3): [True: 1.79M, False: 0] | Branch (1669:3): [True: 1.62M, False: 0] | Branch (1669:3): [True: 1.62M, False: 0] | Branch (1669:3): [True: 173k, False: 1.62M] ------------------ 1670| 1.79M| if (slot == -1) return 0; ------------------ | Branch (1670:7): [True: 173k, False: 1.62M] ------------------ 1671| 1.62M| else return &jvp_object_ptr(object)->elements[slot]; 1672| 1.79M|} jv.c:jvp_refcnt_inc: 63| 14.0M|static void jvp_refcnt_inc(jv_refcnt* c) { 64| 14.0M| c->count++; 65| 14.0M|} jv.c:jvp_refcnt_dec: 67| 19.2M|static int jvp_refcnt_dec(jv_refcnt* c) { 68| 19.2M| c->count--; 69| 19.2M| return c->count == 0; 70| 19.2M|} jv.c:jvp_array_ptr: 827| 4.40M|static jvp_array* jvp_array_ptr(jv a) { 828| 4.40M| assert(JVP_HAS_KIND(a, JV_KIND_ARRAY)); ------------------ | Branch (828:3): [True: 0, False: 4.40M] | Branch (828:3): [True: 4.40M, False: 0] ------------------ 829| 4.40M| return (jvp_array*)a.u.ptr; 830| 4.40M|} jv.c:jvp_string_free: 1161| 12.2M|static void jvp_string_free(jv js) { 1162| 12.2M| jvp_string* s = jvp_string_ptr(js); 1163| 12.2M| if (jvp_refcnt_dec(&s->refcnt)) { ------------------ | Branch (1163:7): [True: 4.13M, False: 8.07M] ------------------ 1164| 4.13M| jv_mem_free(s); 1165| 4.13M| } 1166| 12.2M|} jv.c:jvp_object_ptr: 1645| 2.13M|static jvp_object* jvp_object_ptr(jv o) { 1646| 2.13M| assert(JVP_HAS_KIND(o, JV_KIND_OBJECT)); ------------------ | Branch (1646:3): [True: 0, False: 2.13M] | Branch (1646:3): [True: 2.13M, False: 0] ------------------ 1647| 2.13M| return (jvp_object*)o.u.ptr; 1648| 2.13M|} jv.c:jvp_number_free: 685| 701k|static void jvp_number_free(jv j) { 686| 701k| assert(JVP_HAS_KIND(j, JV_KIND_NUMBER)); ------------------ | Branch (686:3): [True: 0, False: 701k] | Branch (686:3): [True: 701k, False: 0] ------------------ 687| 701k|#ifdef USE_DECNUM 688| 701k| if (JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL) && jvp_refcnt_dec(j.u.ptr)) { ------------------ | | 92| 1.40M|#define JVP_HAS_FLAGS(j, flags) (JVP_FLAGS(j) == flags) | | ------------------ | | | | 89| 701k|#define JVP_FLAGS(j) ((j).kind_flags) | | ------------------ | | | Branch (92:33): [True: 597k, False: 103k] | | | Branch (92:50): [True: 701k, Folded] | | ------------------ ------------------ | Branch (688:53): [True: 307k, False: 290k] ------------------ 689| 307k| jvp_literal_number* n = jvp_literal_number_ptr(j); 690| 307k| if (n->literal_data) { ------------------ | Branch (690:9): [True: 31.0k, False: 276k] ------------------ 691| 31.0k| jv_mem_free(n->literal_data); 692| 31.0k| } 693| 307k| jv_mem_free(n); 694| 307k| } 695| 701k|#endif 696| 701k|} jv.c:jvp_equal: 2092| 837k|static int jvp_equal(jv a, jv b, int depth) { 2093| 837k| if (depth > MAX_EQUAL_DEPTH) { ------------------ | | 2089| 837k|#define MAX_EQUAL_DEPTH (10000) ------------------ | Branch (2093:7): [True: 0, False: 837k] ------------------ 2094| 0| jv_free(a); 2095| 0| jv_free(b); 2096| 0| return -1; 2097| 0| } 2098| 837k| int r; 2099| 837k| if (jv_get_kind(a) != jv_get_kind(b)) { ------------------ | Branch (2099:7): [True: 1.05k, False: 835k] ------------------ 2100| 1.05k| r = 0; 2101| 835k| } else if (JVP_IS_ALLOCATED(a) && ------------------ | | 95| 1.67M|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 835k, False: 635] | | ------------------ ------------------ 2102| 835k| JVP_IS_ALLOCATED(b) && ------------------ | | 95| 1.67M|#define JVP_IS_ALLOCATED(j) (j.kind_flags & JVP_PAYLOAD_ALLOCATED) | | ------------------ | | | Branch (95:29): [True: 824k, False: 10.7k] | | ------------------ ------------------ 2103| 824k| a.kind_flags == b.kind_flags && ------------------ | Branch (2103:14): [True: 824k, False: 0] ------------------ 2104| 824k| a.size == b.size && ------------------ | Branch (2104:14): [True: 824k, False: 245] ------------------ 2105| 824k| a.u.ptr == b.u.ptr) { ------------------ | Branch (2105:14): [True: 0, False: 824k] ------------------ 2106| 0| r = 1; 2107| 835k| } else { 2108| 835k| switch (jv_get_kind(a)) { 2109| 38.2k| case JV_KIND_NUMBER: ------------------ | Branch (2109:5): [True: 38.2k, False: 797k] ------------------ 2110| 38.2k| r = jvp_number_equal(a, b); 2111| 38.2k| break; 2112| 703| case JV_KIND_ARRAY: ------------------ | Branch (2112:5): [True: 703, False: 835k] ------------------ 2113| 703| r = jvp_array_equal(a, b, depth + 1); 2114| 703| break; 2115| 792k| case JV_KIND_STRING: ------------------ | Branch (2115:5): [True: 792k, False: 43.3k] ------------------ 2116| 792k| r = jvp_string_equal(a, b); 2117| 792k| break; 2118| 4.19k| case JV_KIND_OBJECT: ------------------ | Branch (2118:5): [True: 4.19k, False: 831k] ------------------ 2119| 4.19k| r = jvp_object_equal(a, b, depth + 1); 2120| 4.19k| break; 2121| 143| default: ------------------ | Branch (2121:5): [True: 143, False: 835k] ------------------ 2122| 143| r = 1; 2123| 143| break; 2124| 835k| } 2125| 835k| } 2126| 837k| jv_free(a); 2127| 837k| jv_free(b); 2128| 837k| return r; 2129| 837k|} jv.c:jvp_number_equal: 804| 38.2k|static int jvp_number_equal(jv a, jv b) { 805| 38.2k| return jvp_number_cmp(a, b) == 0; 806| 38.2k|} jv.c:jvp_array_equal: 901| 703|static int jvp_array_equal(jv a, jv b, int depth) { 902| 703| if (jvp_array_length(a) != jvp_array_length(b)) ------------------ | Branch (902:7): [True: 245, False: 458] ------------------ 903| 245| return 0; 904| 458| if (jvp_array_ptr(a) == jvp_array_ptr(b) && ------------------ | Branch (904:7): [True: 0, False: 458] ------------------ 905| 0| jvp_array_offset(a) == jvp_array_offset(b)) ------------------ | Branch (905:7): [True: 0, False: 0] ------------------ 906| 0| return 1; 907| 472| for (int i=0; istring) == JV_KIND_NULL) continue; ------------------ | Branch (1824:9): [True: 11.9k, False: 3.16k] ------------------ 1825| 3.16k| jv* slot2 = jvp_object_read(o2, slot->string); 1826| 3.16k| if (!slot2) return 0; ------------------ | Branch (1826:9): [True: 961, False: 2.20k] ------------------ 1827| | // FIXME: do less refcounting here 1828| 2.20k| int r = jvp_equal(jv_copy(slot->value), jv_copy(*slot2), depth); 1829| 2.20k| if (r <= 0) return r; ------------------ | Branch (1829:9): [True: 1.67k, False: 530] ------------------ 1830| 530| len1++; 1831| 530| } 1832| 1.55k| return len1 == len2; 1833| 4.19k|} execute.c:jv_is_valid: 56| 16|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } jv.c:jv_is_valid: 56| 1.47M|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } linker.c:jv_is_valid: 56| 1.36k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } locfile.c:jv_is_valid: 56| 277k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } parser.c:jv_is_valid: 56| 887k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } compile.c:jv_is_valid: 56| 3.18k|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } jv_parse.c:jv_is_valid: 56| 21.6M|static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; } jv_nomem_handler: 92| 596|void jv_nomem_handler(jv_nomem_handler_f handler, void *data) { 93| 596| pthread_once(&mem_once, tsd_init); // cannot fail 94| 596| tsd_init_nomem_handler(); 95| | 96| 596| struct nomem_handler *nomem_handler; 97| | 98| 596| nomem_handler = pthread_getspecific(nomem_handler_key); 99| 596| if (nomem_handler == NULL) { ------------------ | Branch (99:7): [True: 0, False: 596] ------------------ 100| 0| handler(data); 101| 0| fprintf(stderr, "jq: error: cannot allocate memory\n"); 102| 0| abort(); 103| 0| } 104| 596| nomem_handler->handler = handler; 105| 596| nomem_handler->data = data; 106| 596|} jv_mem_alloc: 141| 10.6M|void* jv_mem_alloc(size_t sz) { 142| 10.6M| void* p = malloc(sz); 143| 10.6M| if (!p) { ------------------ | Branch (143:7): [True: 0, False: 10.6M] ------------------ 144| 0| memory_exhausted(); 145| 0| } 146| 10.6M| return p; 147| 10.6M|} jv_mem_alloc_unguarded: 149| 596|void* jv_mem_alloc_unguarded(size_t sz) { 150| 596| return malloc(sz); 151| 596|} jv_mem_calloc: 153| 15.1k|void* jv_mem_calloc(size_t nemb, size_t sz) { 154| 15.1k| assert(nemb > 0 && sz > 0); ------------------ | Branch (154:3): [True: 0, False: 15.1k] | Branch (154:3): [True: 0, False: 0] | Branch (154:3): [True: 15.1k, False: 0] | Branch (154:3): [True: 15.1k, False: 0] ------------------ 155| 15.1k| void* p = calloc(nemb, sz); 156| 15.1k| if (!p) { ------------------ | Branch (156:7): [True: 0, False: 15.1k] ------------------ 157| 0| memory_exhausted(); 158| 0| } 159| 15.1k| return p; 160| 15.1k|} jv_mem_free: 179| 33.9M|void jv_mem_free(void* p) { 180| 33.9M| free(p); 181| 33.9M|} jv_mem_realloc: 183| 508k|void* jv_mem_realloc(void* p, size_t sz) { 184| 508k| p = realloc(p, sz); 185| 508k| if (!p) { ------------------ | Branch (185:7): [True: 0, False: 508k] ------------------ 186| 0| memory_exhausted(); 187| 0| } 188| 508k| return p; 189| 508k|} 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| 596|{ 83| 596| if (pthread_getspecific(nomem_handler_key) == NULL) { ------------------ | Branch (83:7): [True: 1, False: 595] ------------------ 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| 596|} jv_keys_unsorted: 576| 181|jv jv_keys_unsorted(jv x) { 577| 181| if (jv_get_kind(x) != JV_KIND_OBJECT) ------------------ | Branch (577:7): [True: 0, False: 181] ------------------ 578| 0| return jv_keys(x); 579| 181| jv answer = jv_array_sized(jv_object_length(jv_copy(x))); 580| 40.7k| jv_object_foreach(x, key, value) { ------------------ | | 170| 362| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (170:52): [True: 181, False: 181] | | ------------------ | | 171| 181| for (jv k, v; \ | | 172| 40.9k| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (172:10): [True: 40.7k, False: 181] | | | Branch (172:10): [True: 40.7k, False: 181] | | ------------------ | | 173| 40.9k| (k = jv_object_iter_key(t, jv_i__), \ | | 174| 40.7k| v = jv_object_iter_value(t, jv_i__), \ | | 175| 40.7k| 1) \ | | 176| 40.9k| : 0; \ | | 177| 40.7k| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 581| 40.7k| answer = jv_array_append(answer, key); 582| 40.7k| jv_free(value); 583| 40.7k| } 584| 181| jv_free(x); 585| 181| return answer; 586| 181|} jv_keys: 588| 5.83k|jv jv_keys(jv x) { 589| 5.83k| if (jv_get_kind(x) == JV_KIND_OBJECT) { ------------------ | Branch (589:7): [True: 5.83k, False: 0] ------------------ 590| 5.83k| int nkeys = jv_object_length(jv_copy(x)); 591| 5.83k| if (nkeys == 0) { ------------------ | Branch (591:9): [True: 2.27k, False: 3.56k] ------------------ 592| 2.27k| jv_free(x); 593| 2.27k| return jv_array(); 594| 2.27k| } 595| 3.56k| jv* keys = jv_mem_calloc(nkeys, sizeof(jv)); 596| 3.56k| int kidx = 0; 597| 3.77k| jv_object_foreach(x, key, value) { ------------------ | | 170| 7.12k| for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (170:52): [True: 3.56k, False: 3.56k] | | ------------------ | | 171| 3.56k| for (jv k, v; \ | | 172| 7.33k| jv_object_iter_valid((t), jv_i__) ? \ | | ------------------ | | | Branch (172:10): [True: 3.77k, False: 3.56k] | | | Branch (172:10): [True: 3.77k, False: 3.56k] | | ------------------ | | 173| 7.33k| (k = jv_object_iter_key(t, jv_i__), \ | | 174| 3.77k| v = jv_object_iter_value(t, jv_i__), \ | | 175| 3.77k| 1) \ | | 176| 7.33k| : 0; \ | | 177| 3.77k| jv_i__ = jv_object_iter_next(t, jv_i__)) \ ------------------ 598| 3.77k| keys[kidx++] = key; 599| 3.77k| jv_free(value); 600| 3.77k| } 601| 3.56k| qsort(keys, nkeys, sizeof(jv), string_cmp); 602| 3.56k| jv answer = jv_array_sized(nkeys); 603| 7.33k| for (int i = 0; i MAX_CMP_DEPTH) { ------------------ | | 20| 14.0k|#define MAX_CMP_DEPTH (10000) ------------------ | Branch (623:7): [True: 0, False: 14.0k] ------------------ 624| 0| jv_free(a); 625| 0| jv_free(b); 626| 0| return INT_MIN; 627| 0| } 628| | 629| 14.0k| if (jv_get_kind(a) != jv_get_kind(b)) { ------------------ | Branch (629:7): [True: 260, False: 13.8k] ------------------ 630| 260| int r = (int)jv_get_kind(a) - (int)jv_get_kind(b); 631| 260| jv_free(a); 632| 260| jv_free(b); 633| 260| return r; 634| 260| } 635| 13.8k| int r = 0; 636| 13.8k| switch (jv_get_kind(a)) { 637| 0| default: ------------------ | Branch (637:3): [True: 0, False: 13.8k] ------------------ 638| 0| assert(0 && "invalid kind passed to jv_cmp"); ------------------ | Branch (638:5): [Folded, False: 0] | Branch (638:5): [True: 0, False: 0] | Branch (638:5): [Folded, False: 0] | Branch (638:5): [True: 0, False: 0] ------------------ 639| 131| case JV_KIND_NULL: ------------------ | Branch (639:3): [True: 131, False: 13.6k] ------------------ 640| 259| case JV_KIND_FALSE: ------------------ | Branch (640:3): [True: 128, False: 13.6k] ------------------ 641| 389| case JV_KIND_TRUE: ------------------ | Branch (641:3): [True: 130, False: 13.6k] ------------------ 642| | // there's only one of each of these values 643| 389| break; 644| | 645| 5.82k| case JV_KIND_NUMBER: { ------------------ | Branch (645:3): [True: 5.82k, False: 8.00k] ------------------ 646| 5.82k| if (jvp_number_is_nan(a)) { ------------------ | Branch (646:9): [True: 128, False: 5.69k] ------------------ 647| 128| r = jvp_cmp(jv_null(), jv_copy(b), depth); 648| 5.69k| } else if (jvp_number_is_nan(b)) { ------------------ | Branch (648:16): [True: 128, False: 5.56k] ------------------ 649| 128| r = jvp_cmp(jv_copy(a), jv_null(), depth); 650| 5.56k| } else { 651| 5.56k| r = jvp_number_cmp(a, b); 652| 5.56k| } 653| 5.82k| break; 654| 259| } 655| | 656| 1.35k| case JV_KIND_STRING: { ------------------ | Branch (656:3): [True: 1.35k, False: 12.4k] ------------------ 657| 1.35k| r = string_cmp(&a, &b); 658| 1.35k| break; 659| 259| } 660| | 661| 3.34k| case JV_KIND_ARRAY: { ------------------ | Branch (661:3): [True: 3.34k, False: 10.4k] ------------------ 662| | // Lexical ordering of arrays 663| 3.34k| int i = 0; 664| 4.94k| while (r == 0) { ------------------ | Branch (664:12): [True: 4.72k, False: 228] ------------------ 665| 4.72k| int a_done = i >= jv_array_length(jv_copy(a)); 666| 4.72k| int b_done = i >= jv_array_length(jv_copy(b)); 667| 4.72k| if (a_done || b_done) { ------------------ | Branch (667:11): [True: 2.25k, False: 2.46k] | Branch (667:21): [True: 854, False: 1.60k] ------------------ 668| 3.11k| r = b_done - a_done; //suddenly, logic 669| 3.11k| break; 670| 3.11k| } 671| 1.60k| jv xa = jv_array_get(jv_copy(a), i); 672| 1.60k| jv xb = jv_array_get(jv_copy(b), i); 673| 1.60k| r = jvp_cmp(xa, xb, depth + 1); 674| 1.60k| if (r == INT_MIN) ------------------ | Branch (674:11): [True: 0, False: 1.60k] ------------------ 675| 0| break; 676| 1.60k| i++; 677| 1.60k| } 678| 3.34k| break; 679| 259| } 680| | 681| 2.91k| case JV_KIND_OBJECT: { ------------------ | Branch (681:3): [True: 2.91k, False: 10.9k] ------------------ 682| 2.91k| jv keys_a = jv_keys(jv_copy(a)); 683| 2.91k| jv keys_b = jv_keys(jv_copy(b)); 684| 2.91k| r = jvp_cmp(jv_copy(keys_a), keys_b, depth + 1); 685| 2.91k| if (r == 0) { ------------------ | Branch (685:9): [True: 1.74k, False: 1.17k] ------------------ 686| 1.74k| jv_array_foreach(keys_a, i, key) { ------------------ | | 102| 1.74k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 3.49k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 1.74k, False: 1.74k] | | ------------------ | | 104| 1.74k| for (jv x; \ | | 105| 2.45k| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 1.10k, False: 1.34k] | | | Branch (105:10): [True: 1.10k, False: 1.34k] | | ------------------ | | 106| 2.45k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 1.74k| i++) ------------------ 687| 1.10k| jv xa = jv_object_get(jv_copy(a), jv_copy(key)); 688| 1.10k| jv xb = jv_object_get(jv_copy(b), key); 689| 1.10k| r = jvp_cmp(xa, xb, depth + 1); 690| 1.10k| if (r != 0) ------------------ | Branch (690:13): [True: 400, False: 701] ------------------ 691| 400| break; 692| 1.10k| } 693| 1.74k| } 694| 2.91k| jv_free(keys_a); 695| 2.91k| break; 696| 259| } 697| 13.8k| } 698| | 699| 13.8k| jv_free(a); 700| 13.8k| jv_free(b); 701| 13.8k| return r; 702| 13.8k|} jvp_dtoa_context_init: 522| 504k|void jvp_dtoa_context_init(struct dtoa_context* C) { 523| 504k| int i; 524| 4.53M| for (i=0; i<(int)(sizeof(C->freelist)/sizeof(C->freelist[0])); i++) { ------------------ | Branch (524:13): [True: 4.03M, False: 504k] ------------------ 525| 4.03M| C->freelist[i] = 0; 526| 4.03M| } 527| 504k| C->p5s = 0; 528| 504k|} jvp_dtoa_context_free: 569| 504k|void jvp_dtoa_context_free(struct dtoa_context* C) { 570| 504k| int k; 571| 504k| while (C->p5s) { ------------------ | Branch (571:10): [True: 7, False: 504k] ------------------ 572| 7| Bigint* p5 = C->p5s; 573| 7| C->p5s = p5->next; 574| 7| Bfree(C, p5); 575| 7| } 576| 4.53M| for (k=0; k<(int)(sizeof(C->freelist)/sizeof(C->freelist[0])); k++) { ------------------ | Branch (576:13): [True: 4.03M, False: 504k] ------------------ 577| 4.03M| while (C->freelist[k]) { ------------------ | Branch (577:12): [True: 31, False: 4.03M] ------------------ 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.03M| } 583| 504k|} jvp_strtod: 2331| 69.5k|{ 2332| 69.5k| int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1; 2333| |#ifdef Honor_FLT_ROUNDS 2334| | int test_scale; 2335| |#endif 2336| 69.5k| int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign; 2337| 69.5k| CONST char *s, *s0, *s1; ------------------ | | 298| 69.5k|#define CONST const ------------------ 2338| 69.5k| double aadj, aadj1; 2339| 69.5k| Long L; ------------------ | | 193| 69.5k|#define Long int ------------------ 2340| 69.5k| U aadj2, adj, rv, rv0; 2341| 69.5k| ULong y, z; 2342| 69.5k| BCinfo bc; 2343| 69.5k| Bigint *bb=0, *bb1, *bd=0, *bd0, *bs=0, *delta=0; 2344| 69.5k|#ifdef Avoid_Underflow 2345| 69.5k| ULong Lsb, Lsb1; 2346| 69.5k|#endif 2347| |#ifdef SET_INEXACT 2348| | int oldinexact; 2349| |#endif 2350| 69.5k|#ifndef NO_STRTOD_BIGCOMP 2351| 69.5k| int req_bigcomp = 0; 2352| 69.5k|#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| 69.5k| sign = nz0 = nz1 = nz = bc.dplen = bc.uflchk = 0; 2370| 69.5k| dval(&rv) = 0.; ------------------ | | 314| 69.5k|#define dval(x) (x)->d ------------------ 2371| 69.5k| switch(*(s = s00)) { 2372| 0| case '-': ------------------ | Branch (2372:3): [True: 0, False: 69.5k] ------------------ 2373| 0| sign = 1; 2374| | /* no break */ 2375| 0| JQ_FALLTHROUGH; ------------------ | | 14| 0|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 2376| 0| case '+': ------------------ | Branch (2376:3): [True: 0, False: 69.5k] ------------------ 2377| 0| if (*++s) ------------------ | Branch (2377:8): [True: 0, False: 0] ------------------ 2378| 0| 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: 69.5k] ------------------ 2382| 0| goto ret0; 2383| 69.5k| default: ------------------ | Branch (2383:3): [True: 69.5k, False: 0] ------------------ 2384| 69.5k| break; 2385| 69.5k| } 2386| 69.5k| if (*s == '0') { ------------------ | Branch (2386:6): [True: 15.2k, False: 54.2k] ------------------ 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| 15.2k| nz0 = 1; 2400| 15.2k| while(*++s == '0') ; ------------------ | Branch (2400:9): [True: 0, False: 15.2k] ------------------ 2401| 15.2k| if (!*s) ------------------ | Branch (2401:7): [True: 13.9k, False: 1.34k] ------------------ 2402| 13.9k| goto ret; 2403| 15.2k| } 2404| 55.5k| s0 = s; 2405| 55.5k| y = z = 0; 2406| 173k| for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++) ------------------ | Branch (2406:19): [True: 125k, False: 47.6k] | Branch (2406:38): [True: 117k, False: 7.94k] ------------------ 2407| 117k| if (nd < 9) ------------------ | Branch (2407:7): [True: 101k, False: 16.2k] ------------------ 2408| 101k| y = 10*y + c - '0'; 2409| 16.2k| else if (nd < 16) ------------------ | Branch (2409:12): [True: 15.1k, False: 1.06k] ------------------ 2410| 15.1k| z = 10*z + c - '0'; 2411| 55.5k| nd0 = nd; 2412| 55.5k| bc.dp0 = bc.dp1 = s - s0; 2413| 55.6k| for(s1 = s; s1 > s0 && *--s1 == '0'; ) ------------------ | Branch (2413:14): [True: 51.6k, False: 3.98k] | Branch (2413:25): [True: 41, False: 51.6k] ------------------ 2414| 41| ++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| 55.5k| if (c == '.') { ------------------ | Branch (2434:6): [True: 8.52k, False: 47.0k] ------------------ 2435| 8.52k| c = *++s; 2436| 8.52k| bc.dp1 = s - s0; 2437| 8.52k| bc.dplen = bc.dp1 - bc.dp0; 2438| 8.52k| if (!nd) { ------------------ | Branch (2438:7): [True: 1.34k, False: 7.17k] ------------------ 2439| 2.64k| for(; c == '0'; c = *++s) ------------------ | Branch (2439:10): [True: 1.29k, False: 1.34k] ------------------ 2440| 1.29k| nz++; 2441| 1.34k| if (c > '0' && c <= '9') { ------------------ | Branch (2441:8): [True: 1.34k, False: 0] | Branch (2441:19): [True: 1.34k, False: 0] ------------------ 2442| 1.34k| bc.dp0 = s0 - s; 2443| 1.34k| bc.dp1 = bc.dp0 + bc.dplen; 2444| 1.34k| s0 = s; 2445| 1.34k| nf += nz; 2446| 1.34k| nz = 0; 2447| 1.34k| goto have_dig; 2448| 1.34k| } 2449| 0| goto dig_done; 2450| 1.34k| } 2451| 78.0k| for(; c >= '0' && c <= '9'; c = *++s) { ------------------ | Branch (2451:9): [True: 75.8k, False: 2.18k] | Branch (2451:21): [True: 69.5k, False: 6.33k] ------------------ 2452| 70.8k| have_dig: 2453| 70.8k| nz++; 2454| 70.8k| if (c -= '0') { ------------------ | Branch (2454:8): [True: 47.0k, False: 23.8k] ------------------ 2455| 47.0k| nf += nz; 2456| 64.3k| for(i = 1; i < nz; i++) ------------------ | Branch (2456:16): [True: 17.2k, False: 47.0k] ------------------ 2457| 17.2k| if (nd++ < 9) ------------------ | Branch (2457:10): [True: 12.3k, False: 4.94k] ------------------ 2458| 12.3k| y *= 10; 2459| 4.94k| else if (nd <= DBL_DIG + 1) ------------------ | Branch (2459:15): [True: 4.94k, False: 0] ------------------ 2460| 4.94k| z *= 10; 2461| 47.0k| if (nd++ < 9) ------------------ | Branch (2461:9): [True: 28.3k, False: 18.6k] ------------------ 2462| 28.3k| y = 10*y + c; 2463| 18.6k| else if (nd <= DBL_DIG + 1) ------------------ | Branch (2463:14): [True: 16.8k, False: 1.86k] ------------------ 2464| 16.8k| z = 10*z + c; 2465| 47.0k| nz = nz1 = 0; 2466| 47.0k| } 2467| 70.8k| } 2468| 7.17k| } 2469| 55.5k| dig_done: 2470| 55.5k| e = 0; 2471| 55.5k| if (c == 'e' || c == 'E') { ------------------ | Branch (2471:6): [True: 0, False: 55.5k] | Branch (2471:18): [True: 11.6k, False: 43.9k] ------------------ 2472| 11.6k| if (!nd && !nz && !nz0) { ------------------ | Branch (2472:7): [True: 0, False: 11.6k] | Branch (2472:14): [True: 0, False: 0] | Branch (2472:21): [True: 0, False: 0] ------------------ 2473| 0| goto ret0; 2474| 0| } 2475| 11.6k| s00 = s; 2476| 11.6k| esign = 0; 2477| 11.6k| switch(c = *++s) { ------------------ | Branch (2477:10): [True: 11.6k, False: 0] ------------------ 2478| 4.07k| case '-': ------------------ | Branch (2478:4): [True: 4.07k, False: 7.57k] ------------------ 2479| 4.07k| esign = 1; 2480| 4.07k| JQ_FALLTHROUGH; ------------------ | | 14| 4.07k|# define JQ_FALLTHROUGH __attribute__((fallthrough)) ------------------ 2481| 11.6k| case '+': ------------------ | Branch (2481:4): [True: 7.57k, False: 4.07k] ------------------ 2482| 11.6k| c = *++s; 2483| 11.6k| } 2484| 11.6k| if (c >= '0' && c <= '9') { ------------------ | Branch (2484:7): [True: 11.6k, False: 0] | Branch (2484:19): [True: 11.6k, False: 0] ------------------ 2485| 11.6k| while(c == '0') ------------------ | Branch (2485:10): [True: 0, False: 11.6k] ------------------ 2486| 0| c = *++s; 2487| 11.6k| if (c > '0' && c <= '9') { ------------------ | Branch (2487:8): [True: 11.6k, False: 0] | Branch (2487:19): [True: 11.6k, False: 0] ------------------ 2488| 11.6k| L = c - '0'; 2489| 11.6k| s1 = s; 2490| 26.6k| while((c = *++s) >= '0' && c <= '9') ------------------ | Branch (2490:11): [True: 14.9k, False: 11.6k] | Branch (2490:32): [True: 14.9k, False: 0] ------------------ 2491| 14.9k| L = 10*L + c - '0'; 2492| 11.6k| if (s - s1 > 8 || L > 19999) ------------------ | Branch (2492:9): [True: 0, False: 11.6k] | Branch (2492:23): [True: 0, False: 11.6k] ------------------ 2493| | /* Avoid confusion from exponents 2494| | * so large that e might overflow. 2495| | */ 2496| 0| e = 19999; /* safe for 16 bit ints */ 2497| 11.6k| else 2498| 11.6k| e = (int)L; 2499| 11.6k| if (esign) ------------------ | Branch (2499:9): [True: 4.07k, False: 7.57k] ------------------ 2500| 4.07k| e = -e; 2501| 11.6k| } 2502| 0| else 2503| 0| e = 0; 2504| 11.6k| } 2505| 0| else 2506| 0| s = s00; 2507| 11.6k| } 2508| 55.5k| if (!nd) { ------------------ | Branch (2508:6): [True: 2.63k, False: 52.9k] ------------------ 2509| 2.63k| if (!nz && !nz0) { ------------------ | Branch (2509:7): [True: 2.63k, False: 0] | Branch (2509:14): [True: 2.63k, False: 0] ------------------ 2510| 2.63k|#ifdef INFNAN_CHECK 2511| | /* Check for Nan and Infinity */ 2512| 2.63k| if (!bc.dplen) ------------------ | Branch (2512:8): [True: 2.63k, False: 0] ------------------ 2513| 2.63k| switch(c) { ------------------ | Branch (2513:12): [True: 2.63k, False: 0] ------------------ 2514| 0| case 'i': ------------------ | Branch (2514:6): [True: 0, False: 2.63k] ------------------ 2515| 2.63k| case 'I': ------------------ | Branch (2515:6): [True: 2.63k, False: 0] ------------------ 2516| 2.63k| if (match(C, &s,"nf")) { ------------------ | Branch (2516:9): [True: 2.63k, False: 0] ------------------ 2517| 2.63k| --s; 2518| 2.63k| if (!match(C, &s,"inity")) ------------------ | Branch (2518:10): [True: 0, False: 2.63k] ------------------ 2519| 0| ++s; 2520| 2.63k| word0(&rv) = 0x7ff00000; ------------------ | | 308| 2.63k|#define word0(x) (x)->L[1] ------------------ 2521| 2.63k| word1(&rv) = 0; ------------------ | | 309| 2.63k|#define word1(x) (x)->L[0] ------------------ 2522| 2.63k| goto ret; 2523| 2.63k| } 2524| 0| break; 2525| 0| case 'n': ------------------ | Branch (2525:6): [True: 0, False: 2.63k] ------------------ 2526| 0| case 'N': ------------------ | Branch (2526:6): [True: 0, False: 2.63k] ------------------ 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| 2.63k| } 2537| 0|#endif /* INFNAN_CHECK */ 2538| 0| ret0: 2539| 0| s = s00; 2540| 0| sign = 0; 2541| 0| } 2542| 0| goto ret; 2543| 2.63k| } 2544| 52.9k| 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| 52.9k| if (!nd0) ------------------ | Branch (2551:6): [True: 1.34k, False: 51.6k] ------------------ 2552| 1.34k| nd0 = nd; 2553| 52.9k| k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1; ------------------ | Branch (2553:6): [True: 48.9k, False: 3.95k] ------------------ 2554| 52.9k| dval(&rv) = y; ------------------ | | 314| 52.9k|#define dval(x) (x)->d ------------------ 2555| 52.9k| if (k > 9) { ------------------ | Branch (2555:6): [True: 6.96k, False: 45.9k] ------------------ 2556| |#ifdef SET_INEXACT 2557| | if (k > DBL_DIG) 2558| | oldinexact = get_inexact(); 2559| |#endif 2560| 6.96k| dval(&rv) = tens[k - 9] * dval(&rv) + z; ------------------ | | 314| 6.96k|#define dval(x) (x)->d ------------------ dval(&rv) = tens[k - 9] * dval(&rv) + z; ------------------ | | 314| 6.96k|#define dval(x) (x)->d ------------------ 2561| 6.96k| } 2562| 52.9k| bd0 = 0; 2563| 52.9k| if (nd <= DBL_DIG ------------------ | Branch (2563:6): [True: 48.9k, False: 3.95k] ------------------ 2564| 48.9k|#ifndef RND_PRODQUOT 2565| 48.9k|#ifndef Honor_FLT_ROUNDS 2566| 48.9k| && Flt_Rounds == 1 ------------------ | | 380| 48.9k|#define Flt_Rounds FLT_ROUNDS ------------------ | Branch (2566:6): [True: 48.9k, False: 0] ------------------ 2567| 52.9k|#endif 2568| 52.9k|#endif 2569| 52.9k| ) { 2570| 48.9k| if (!e) ------------------ | Branch (2570:7): [True: 37.4k, False: 11.5k] ------------------ 2571| 37.4k| goto ret; 2572| 11.5k|#ifndef ROUND_BIASED_without_Round_Up 2573| 11.5k| if (e > 0) { ------------------ | Branch (2573:7): [True: 6.31k, False: 5.22k] ------------------ 2574| 6.31k| if (e <= Ten_pmax) { ------------------ | | 360| 6.31k|#define Ten_pmax 22 ------------------ | Branch (2574:8): [True: 3.56k, False: 2.74k] ------------------ 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| 3.56k| /* rv = */ rounded_product(dval(&rv), tens[e]); ------------------ | | 474| 3.56k|#define rounded_product(a,b) a *= b ------------------ 2586| 3.56k| goto ret; 2587| 3.56k|#endif 2588| 3.56k| } 2589| 2.74k| i = DBL_DIG - nd; 2590| 2.74k| if (e <= Ten_pmax + i) { ------------------ | | 360| 2.74k|#define Ten_pmax 22 ------------------ | Branch (2590:8): [True: 494, False: 2.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| 494| e -= i; 2602| 494| dval(&rv) *= tens[i]; ------------------ | | 314| 494|#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| 494| /* rv = */ rounded_product(dval(&rv), tens[e]); ------------------ | | 474| 494|#define rounded_product(a,b) a *= b ------------------ 2616| 494|#endif 2617| 494| goto ret; 2618| 494| } 2619| 2.74k| } 2620| 5.22k|#ifndef Inaccurate_Divide 2621| 5.22k| else if (e >= -Ten_pmax) { ------------------ | | 360| 5.22k|#define Ten_pmax 22 ------------------ | Branch (2621:12): [True: 1.27k, False: 3.94k] ------------------ 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| 1.27k| /* rv = */ rounded_quotient(dval(&rv), tens[-e]); ------------------ | | 475| 1.27k|#define rounded_quotient(a,b) a /= b ------------------ 2630| 1.27k| goto ret; 2631| 1.27k| } 2632| 11.5k|#endif 2633| 11.5k|#endif /* ROUND_BIASED_without_Round_Up */ 2634| 11.5k| } 2635| 10.1k| e1 += nd - k; 2636| | 2637| 10.1k|#ifdef IEEE_Arith 2638| |#ifdef SET_INEXACT 2639| | bc.inexact = 1; 2640| | if (k <= DBL_DIG) 2641| | oldinexact = get_inexact(); 2642| |#endif 2643| 10.1k|#ifdef Avoid_Underflow 2644| 10.1k| bc.scale = 0; 2645| 10.1k|#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| 10.1k|#endif /*IEEE_Arith*/ 2656| | 2657| | /* Get starting approximation = rv * 10**e1 */ 2658| | 2659| 10.1k| if (e1 > 0) { ------------------ | Branch (2659:6): [True: 4.57k, False: 5.58k] ------------------ 2660| 4.57k| if ((i = e1 & 15)) ------------------ | Branch (2660:7): [True: 4.41k, False: 154] ------------------ 2661| 4.41k| dval(&rv) *= tens[i]; ------------------ | | 314| 4.41k|#define dval(x) (x)->d ------------------ 2662| 4.57k| if (e1 &= ~15) { ------------------ | Branch (2662:7): [True: 2.48k, False: 2.09k] ------------------ 2663| 2.48k| if (e1 > DBL_MAX_10_EXP) { ------------------ | Branch (2663:8): [True: 928, False: 1.55k] ------------------ 2664| 1.08k| ovfl: 2665| | /* Can't trust HUGE_VAL */ 2666| 1.08k|#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| 1.08k| word0(&rv) = Exp_mask; ------------------ | | 308| 1.08k|#define word0(x) (x)->L[1] ------------------ word0(&rv) = Exp_mask; ------------------ | | 349| 1.08k|#define Exp_mask 0x7ff00000 ------------------ 2680| 1.08k| word1(&rv) = 0; ------------------ | | 309| 1.08k|#define word1(x) (x)->L[0] ------------------ 2681| 1.08k|#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| 2.89k| range_err: 2692| 2.89k| if (bd0) { ------------------ | Branch (2692:9): [True: 0, False: 2.89k] ------------------ 2693| 0| Bfree(C, bb); 2694| 0| Bfree(C, bd); 2695| 0| Bfree(C, bs); 2696| 0| Bfree(C, bd0); 2697| 0| Bfree(C, delta); 2698| 0| } 2699| |#ifndef NO_ERRNO 2700| | errno = ERANGE; 2701| |#endif 2702| 2.89k| goto ret; 2703| 1.08k| } 2704| 1.55k| e1 >>= 4; 2705| 4.86k| for(j = 0; e1 > 1; j++, e1 >>= 1) ------------------ | Branch (2705:15): [True: 3.30k, False: 1.55k] ------------------ 2706| 3.30k| if (e1 & 1) ------------------ | Branch (2706:9): [True: 1.53k, False: 1.77k] ------------------ 2707| 1.53k| dval(&rv) *= bigtens[j]; ------------------ | | 314| 1.53k|#define dval(x) (x)->d ------------------ 2708| | /* The last multiplication could overflow. */ 2709| 1.55k| word0(&rv) -= P*Exp_msk1; ------------------ | | 308| 1.55k|#define word0(x) (x)->L[1] ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 350| 1.55k|#define P 53 ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 347| 1.55k|#define Exp_msk1 0x100000 ------------------ 2710| 1.55k| dval(&rv) *= bigtens[j]; ------------------ | | 314| 1.55k|#define dval(x) (x)->d ------------------ 2711| 1.55k| if ((z = word0(&rv) & Exp_mask) ------------------ | | 308| 1.55k|#define word0(x) (x)->L[1] ------------------ if ((z = word0(&rv) & Exp_mask) ------------------ | | 349| 1.55k|#define Exp_mask 0x7ff00000 ------------------ | Branch (2711:8): [True: 161, False: 1.39k] ------------------ 2712| 1.55k| > Exp_msk1*(DBL_MAX_EXP+Bias-P)) ------------------ | | 347| 1.55k|#define Exp_msk1 0x100000 ------------------ > Exp_msk1*(DBL_MAX_EXP+Bias-P)) ------------------ | | 352| 1.55k|#define Bias 1023 ------------------ > Exp_msk1*(DBL_MAX_EXP+Bias-P)) ------------------ | | 350| 1.55k|#define P 53 ------------------ 2713| 161| goto ovfl; 2714| 1.39k| if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) { ------------------ | | 347| 1.39k|#define Exp_msk1 0x100000 ------------------ if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) { ------------------ | | 352| 1.39k|#define Bias 1023 ------------------ if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) { ------------------ | | 350| 1.39k|#define P 53 ------------------ | Branch (2714:8): [True: 0, False: 1.39k] ------------------ 2715| | /* set to largest number */ 2716| | /* (Can't trust DBL_MAX) */ 2717| 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 | | ------------------ ------------------ 2718| 0| word1(&rv) = Big1; ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ word1(&rv) = Big1; ------------------ | | 479| 0|#define Big1 0xffffffff ------------------ 2719| 0| } 2720| 1.39k| else 2721| 1.39k| word0(&rv) += P*Exp_msk1; ------------------ | | 308| 1.39k|#define word0(x) (x)->L[1] ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 350| 1.39k|#define P 53 ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 347| 1.39k|#define Exp_msk1 0x100000 ------------------ 2722| 1.39k| } 2723| 4.57k| } 2724| 5.58k| else if (e1 < 0) { ------------------ | Branch (2724:11): [True: 4.97k, False: 607] ------------------ 2725| 4.97k| e1 = -e1; 2726| 4.97k| if ((i = e1 & 15)) ------------------ | Branch (2726:7): [True: 4.48k, False: 487] ------------------ 2727| 4.48k| dval(&rv) /= tens[i]; ------------------ | | 314| 4.48k|#define dval(x) (x)->d ------------------ 2728| 4.97k| if (e1 >>= 4) { ------------------ | Branch (2728:7): [True: 4.32k, False: 648] ------------------ 2729| 4.32k| if (e1 >= 1 << n_bigtens) ------------------ | | 1375| 4.32k|#define n_bigtens 5 ------------------ | Branch (2729:8): [True: 0, False: 4.32k] ------------------ 2730| 0| goto undfl; 2731| 4.32k|#ifdef Avoid_Underflow 2732| 4.32k| if (e1 & Scale_Bit) ------------------ | | 1374| 4.32k|#define Scale_Bit 0x10 ------------------ | Branch (2732:8): [True: 3.78k, False: 544] ------------------ 2733| 3.78k| bc.scale = 2*P; ------------------ | | 350| 3.78k|#define P 53 ------------------ 2734| 23.8k| for(j = 0; e1 > 0; j++, e1 >>= 1) ------------------ | Branch (2734:15): [True: 19.5k, False: 4.32k] ------------------ 2735| 19.5k| if (e1 & 1) ------------------ | Branch (2735:9): [True: 9.20k, False: 10.3k] ------------------ 2736| 9.20k| dval(&rv) *= tinytens[j]; ------------------ | | 314| 9.20k|#define dval(x) (x)->d ------------------ 2737| 4.32k| if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask) ------------------ | | 350| 3.78k|#define P 53 ------------------ if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask) ------------------ | | 308| 3.78k|#define word0(x) (x)->L[1] ------------------ if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask) ------------------ | | 349| 3.78k|#define Exp_mask 0x7ff00000 ------------------ | Branch (2737:8): [True: 3.78k, False: 544] | Branch (2737:20): [True: 3.59k, False: 187] ------------------ 2738| 3.78k| >> Exp_shift)) > 0) { ------------------ | | 345| 3.78k|#define Exp_shift 20 ------------------ 2739| | /* scaled rv is denormal; clear j low bits */ 2740| 3.59k| if (j >= 32) { ------------------ | Branch (2740:9): [True: 2.39k, False: 1.19k] ------------------ 2741| 2.39k| if (j > 54) ------------------ | Branch (2741:10): [True: 1.80k, False: 597] ------------------ 2742| 1.80k| goto undfl; 2743| 597| word1(&rv) = 0; ------------------ | | 309| 597|#define word1(x) (x)->L[0] ------------------ 2744| 597| if (j >= 53) ------------------ | Branch (2744:10): [True: 153, False: 444] ------------------ 2745| 153| word0(&rv) = (P+2)*Exp_msk1; ------------------ | | 308| 153|#define word0(x) (x)->L[1] ------------------ word0(&rv) = (P+2)*Exp_msk1; ------------------ | | 350| 153|#define P 53 ------------------ word0(&rv) = (P+2)*Exp_msk1; ------------------ | | 347| 153|#define Exp_msk1 0x100000 ------------------ 2746| 444| else 2747| 444| word0(&rv) &= 0xffffffff << (j-32); ------------------ | | 308| 444|#define word0(x) (x)->L[1] ------------------ 2748| 597| } 2749| 1.19k| else 2750| 1.19k| word1(&rv) &= 0xffffffff << j; ------------------ | | 309| 1.19k|#define word1(x) (x)->L[0] ------------------ 2751| 3.59k| } 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| 2.52k| if (!dval(&rv)) { ------------------ | | 314| 2.52k|#define dval(x) (x)->d ------------------ | Branch (2763:9): [True: 0, False: 2.52k] ------------------ 2764| 1.80k| undfl: 2765| 1.80k| dval(&rv) = 0.; ------------------ | | 314| 1.80k|#define dval(x) (x)->d ------------------ 2766| 1.80k| 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| 2.52k| } 2777| 4.97k| } 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| 7.26k| bc.nd = nd - nz1; 2784| 7.26k|#ifndef NO_STRTOD_BIGCOMP 2785| 7.26k| 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| 7.26k| if (nd > strtod_diglim) { ------------------ | | 323| 7.26k|#define strtod_diglim STRTOD_DIGLIM | | ------------------ | | | | 317| 7.26k|#define STRTOD_DIGLIM 40 | | ------------------ ------------------ | Branch (2788:6): [True: 0, False: 7.26k] ------------------ 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| 7.26k|#endif 2815| 7.26k| bd0 = s2b(C, s0, nd0, nd, y, bc.dplen); 2816| | 2817| 9.39k| for(;;) { 2818| 9.39k| bd = Balloc(C, bd0->k); 2819| 9.39k| Bcopy(bd, bd0); ------------------ | | 586| 9.39k|#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ | | 587| 9.39k|y->wds*sizeof(Long) + 2*sizeof(int)) ------------------ 2820| 9.39k| bb = d2b(C, &rv, &bbe, &bbbits); /* rv = bb * 2^bbe */ 2821| 9.39k| bs = i2b(C, 1); 2822| | 2823| 9.39k| if (e >= 0) { ------------------ | Branch (2823:7): [True: 4.51k, False: 4.88k] ------------------ 2824| 4.51k| bb2 = bb5 = 0; 2825| 4.51k| bd2 = bd5 = e; 2826| 4.51k| } 2827| 4.88k| else { 2828| 4.88k| bb2 = bb5 = -e; 2829| 4.88k| bd2 = bd5 = 0; 2830| 4.88k| } 2831| 9.39k| if (bbe >= 0) ------------------ | Branch (2831:7): [True: 5.26k, False: 4.13k] ------------------ 2832| 5.26k| bb2 += bbe; 2833| 4.13k| else 2834| 4.13k| bd2 -= bbe; 2835| 9.39k| bs2 = bb2; 2836| |#ifdef Honor_FLT_ROUNDS 2837| | if (bc.rounding != 1) 2838| | bs2++; 2839| |#endif 2840| 9.39k|#ifdef Avoid_Underflow 2841| 9.39k| Lsb = LSB; ------------------ | | 364| 9.39k|#define LSB 1 ------------------ 2842| 9.39k| Lsb1 = 0; 2843| 9.39k| j = bbe - bc.scale; 2844| 9.39k| i = j + bbbits - 1; /* logb(rv) */ 2845| 9.39k| j = P + 1 - bbbits; ------------------ | | 350| 9.39k|#define P 53 ------------------ 2846| 9.39k| if (i < Emin) { /* denormal */ ------------------ | | 354| 9.39k|#define Emin (-1022) ------------------ | Branch (2846:7): [True: 3.20k, False: 6.19k] ------------------ 2847| 3.20k| i = Emin - i; ------------------ | | 354| 3.20k|#define Emin (-1022) ------------------ 2848| 3.20k| j -= i; 2849| 3.20k| if (i < 32) ------------------ | Branch (2849:8): [True: 2.29k, False: 906] ------------------ 2850| 2.29k| Lsb <<= i; 2851| 906| else if (i < 52) ------------------ | Branch (2851:13): [True: 753, False: 153] ------------------ 2852| 753| Lsb1 = Lsb << (i-32); 2853| 153| else 2854| 153| Lsb1 = Exp_mask; ------------------ | | 349| 153|#define Exp_mask 0x7ff00000 ------------------ 2855| 3.20k| } 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| 9.39k| bb2 += j; 2873| 9.39k| bd2 += j; 2874| 9.39k|#ifdef Avoid_Underflow 2875| 9.39k| bd2 += bc.scale; 2876| 9.39k|#endif 2877| 9.39k| i = bb2 < bd2 ? bb2 : bd2; ------------------ | Branch (2877:7): [True: 4.13k, False: 5.26k] ------------------ 2878| 9.39k| if (i > bs2) ------------------ | Branch (2878:7): [True: 4.90k, False: 4.49k] ------------------ 2879| 4.90k| i = bs2; 2880| 9.39k| if (i > 0) { ------------------ | Branch (2880:7): [True: 9.39k, False: 4] ------------------ 2881| 9.39k| bb2 -= i; 2882| 9.39k| bd2 -= i; 2883| 9.39k| bs2 -= i; 2884| 9.39k| } 2885| 9.39k| if (bb5 > 0) { ------------------ | Branch (2885:7): [True: 4.88k, False: 4.51k] ------------------ 2886| 4.88k| bs = pow5mult(C, bs, bb5); 2887| 4.88k| bb1 = mult(C, bs, bb); 2888| 4.88k| Bfree(C, bb); 2889| 4.88k| bb = bb1; 2890| 4.88k| } 2891| 9.39k| if (bb2 > 0) ------------------ | Branch (2891:7): [True: 9.39k, False: 0] ------------------ 2892| 9.39k| bb = lshift(C, bb, bb2); 2893| 9.39k| if (bd5 > 0) ------------------ | Branch (2893:7): [True: 2.43k, False: 6.96k] ------------------ 2894| 2.43k| bd = pow5mult(C, bd, bd5); 2895| 9.39k| if (bd2 > 0) ------------------ | Branch (2895:7): [True: 4.90k, False: 4.49k] ------------------ 2896| 4.90k| bd = lshift(C, bd, bd2); 2897| 9.39k| if (bs2 > 0) ------------------ | Branch (2897:7): [True: 3.90k, False: 5.49k] ------------------ 2898| 3.90k| bs = lshift(C, bs, bs2); 2899| 9.39k| delta = diff(C, bb, bd); 2900| 9.39k| bc.dsign = delta->sign; 2901| 9.39k| delta->sign = 0; 2902| 9.39k| i = cmp(C, delta, bs); 2903| 9.39k|#ifndef NO_STRTOD_BIGCOMP /*{*/ 2904| 9.39k| if (bc.nd > nd && i <= 0) { ------------------ | Branch (2904:7): [True: 0, False: 9.39k] | 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| 9.39k|#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| 9.39k| if (i < 0) { ------------------ | Branch (3015:7): [True: 3.81k, False: 5.58k] ------------------ 3016| | /* Error is less than half an ulp -- check for 3017| | * special case of mantissa a power of two. 3018| | */ 3019| 3.81k| if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask ------------------ | | 309| 6.65k|#define word1(x) (x)->L[0] | | ------------------ | | | Branch (309:18): [True: 1.76k, False: 1.08k] | | ------------------ ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask ------------------ | | 308| 1.08k|#define word0(x) (x)->L[1] ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask ------------------ | | 362| 4.89k|#define Bndry_mask 0xfffff ------------------ | Branch (3019:8): [True: 965, False: 2.84k] | Branch (3019:34): [True: 291, False: 792] ------------------ 3020| 792|#ifdef IEEE_Arith /*{*/ 3021| 792|#ifdef Avoid_Underflow 3022| 792| || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 308| 792|#define word0(x) (x)->L[1] ------------------ || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 349| 792|#define Exp_mask 0x7ff00000 ------------------ || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 350| 792|#define P 53 ------------------ || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1 ------------------ | | 347| 792|#define Exp_msk1 0x100000 ------------------ | Branch (3022:8): [True: 133, False: 659] ------------------ 3023| |#else 3024| | || (word0(&rv) & Exp_mask) <= Exp_msk1 3025| |#endif 3026| 3.81k|#endif /*}*/ 3027| 3.81k| ) { 3028| |#ifdef SET_INEXACT 3029| | if (!delta->x[0] && delta->wds <= 1) 3030| | bc.inexact = 0; 3031| |#endif 3032| 3.15k| break; 3033| 3.15k| } 3034| 659| if (!delta->x[0] && delta->wds <= 1) { ------------------ | Branch (3034:8): [True: 384, False: 275] | Branch (3034:24): [True: 129, False: 255] ------------------ 3035| | /* exact result */ 3036| |#ifdef SET_INEXACT 3037| | bc.inexact = 0; 3038| |#endif 3039| 129| break; 3040| 129| } 3041| 530| delta = lshift(C, delta,Log2P); ------------------ | | 366| 530|#define Log2P 1 ------------------ 3042| 530| if (cmp(C, delta, bs) > 0) ------------------ | Branch (3042:8): [True: 255, False: 275] ------------------ 3043| 255| goto drop_down; 3044| 275| break; 3045| 530| } 3046| 5.58k| if (i == 0) { ------------------ | Branch (3046:7): [True: 1.23k, False: 4.35k] ------------------ 3047| | /* exactly half-way between */ 3048| 1.23k| if (bc.dsign) { ------------------ | Branch (3048:8): [True: 602, False: 634] ------------------ 3049| 602| if ((word0(&rv) & Bndry_mask1) == Bndry_mask1 ------------------ | | 308| 602|#define word0(x) (x)->L[1] ------------------ if ((word0(&rv) & Bndry_mask1) == Bndry_mask1 ------------------ | | 363| 602|#define Bndry_mask1 0xfffff ------------------ if ((word0(&rv) & Bndry_mask1) == Bndry_mask1 ------------------ | | 363| 1.20k|#define Bndry_mask1 0xfffff ------------------ | Branch (3049:9): [True: 292, False: 310] ------------------ 3050| 292| && word1(&rv) == ( ------------------ | | 309| 292|#define word1(x) (x)->L[0] ------------------ | Branch (3050:10): [True: 160, False: 132] ------------------ 3051| 292|#ifdef Avoid_Underflow 3052| 292| (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: 292] | Branch (3052:17): [True: 0, False: 0] ------------------ 3053| 292| ? (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| 292|#endif 3055| 292| 0xffffffff)) { 3056| | /*boundary case -- increment exponent*/ 3057| 160| if (word0(&rv) == Big0 && word1(&rv) == Big1) ------------------ | | 308| 160|#define word0(x) (x)->L[1] ------------------ if (word0(&rv) == Big0 && word1(&rv) == Big1) ------------------ | | 478| 320|#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 359| 160|#define Frac_mask1 0xfffff | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 347| 160|#define Exp_msk1 0x100000 | | ------------------ | | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | | ------------------ | | | | 352| 160|#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: 160] | Branch (3057:32): [True: 0, False: 0] ------------------ 3058| 0| goto ovfl; 3059| 160| word0(&rv) = (word0(&rv) & Exp_mask) ------------------ | | 308| 160|#define word0(x) (x)->L[1] ------------------ word0(&rv) = (word0(&rv) & Exp_mask) ------------------ | | 308| 160|#define word0(x) (x)->L[1] ------------------ word0(&rv) = (word0(&rv) & Exp_mask) ------------------ | | 349| 160|#define Exp_mask 0x7ff00000 ------------------ 3060| 160| + Exp_msk1 ------------------ | | 347| 160|#define Exp_msk1 0x100000 ------------------ 3061| |#ifdef IBM 3062| | | Exp_msk1 >> 4 3063| |#endif 3064| 160| ; 3065| 160| word1(&rv) = 0; ------------------ | | 309| 160|#define word1(x) (x)->L[0] ------------------ 3066| 160|#ifdef Avoid_Underflow 3067| 160| bc.dsign = 0; 3068| 160|#endif 3069| 160| break; 3070| 160| } 3071| 602| } 3072| 634| else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) { ------------------ | | 308| 634|#define word0(x) (x)->L[1] ------------------ else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) { ------------------ | | 362| 634|#define Bndry_mask 0xfffff ------------------ else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) { ------------------ | | 309| 380|#define word1(x) (x)->L[0] ------------------ | Branch (3072:13): [True: 380, False: 254] | Branch (3072:43): [True: 0, False: 380] ------------------ 3073| 255| 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| 255|#ifdef Avoid_Underflow 3096| 255| if (bc.scale) { ------------------ | Branch (3096:9): [True: 0, False: 255] ------------------ 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| 255|#endif /*Avoid_Underflow*/ 3112| 255| L = (word0(&rv) & Exp_mask) - Exp_msk1; ------------------ | | 308| 255|#define word0(x) (x)->L[1] ------------------ L = (word0(&rv) & Exp_mask) - Exp_msk1; ------------------ | | 349| 255|#define Exp_mask 0x7ff00000 ------------------ L = (word0(&rv) & Exp_mask) - Exp_msk1; ------------------ | | 347| 255|#define Exp_msk1 0x100000 ------------------ 3113| 255|#endif /*Sudden_Underflow}}*/ 3114| 255| word0(&rv) = L | Bndry_mask1; ------------------ | | 308| 255|#define word0(x) (x)->L[1] ------------------ word0(&rv) = L | Bndry_mask1; ------------------ | | 363| 255|#define Bndry_mask1 0xfffff ------------------ 3115| 255| word1(&rv) = 0xffffffff; ------------------ | | 309| 255|#define word1(x) (x)->L[0] ------------------ 3116| |#ifdef IBM 3117| | goto cont; 3118| |#else 3119| 255|#ifndef NO_STRTOD_BIGCOMP 3120| 255| if (bc.nd > nd) ------------------ | Branch (3120:9): [True: 0, False: 255] ------------------ 3121| 0| goto cont; 3122| 255|#endif 3123| 255| break; 3124| 255|#endif 3125| 255| } 3126| 1.07k|#ifndef ROUND_BIASED 3127| 1.07k|#ifdef Avoid_Underflow 3128| 1.07k| if (Lsb1) { ------------------ | Branch (3128:8): [True: 0, False: 1.07k] ------------------ 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| 1.07k| else if (!(word1(&rv) & Lsb)) ------------------ | | 309| 1.07k|#define word1(x) (x)->L[0] ------------------ | Branch (3132:13): [True: 740, False: 336] ------------------ 3133| 740| break; 3134| |#else 3135| | if (!(word1(&rv) & LSB)) 3136| | break; 3137| |#endif 3138| 336|#endif 3139| 336| if (bc.dsign) ------------------ | Branch (3139:8): [True: 158, False: 178] ------------------ 3140| 158|#ifdef Avoid_Underflow 3141| 158| dval(&rv) += sulp(C, &rv, &bc); ------------------ | | 314| 158|#define dval(x) (x)->d ------------------ 3142| |#else 3143| | dval(&rv) += ulp(C, &rv); 3144| |#endif 3145| 178|#ifndef ROUND_BIASED 3146| 178| else { 3147| 178|#ifdef Avoid_Underflow 3148| 178| dval(&rv) -= sulp(C, &rv, &bc); ------------------ | | 314| 178|#define dval(x) (x)->d ------------------ 3149| |#else 3150| | dval(&rv) -= ulp(C, &rv); 3151| |#endif 3152| 178|#ifndef Sudden_Underflow 3153| 178| if (!dval(&rv)) { ------------------ | | 314| 178|#define dval(x) (x)->d ------------------ | Branch (3153:9): [True: 0, False: 178] ------------------ 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| 178|#endif 3161| 178| } 3162| 336|#ifdef Avoid_Underflow 3163| 336| bc.dsign = 1 - bc.dsign; 3164| 336|#endif 3165| 336|#endif 3166| 336| break; 3167| 336| } 3168| 4.35k| if ((aadj = ratio(C, delta, bs)) <= 2.) { ------------------ | Branch (3168:7): [True: 2.99k, False: 1.36k] ------------------ 3169| 2.99k| if (bc.dsign) ------------------ | Branch (3169:8): [True: 1.80k, False: 1.18k] ------------------ 3170| 1.80k| aadj = aadj1 = 1.; 3171| 1.18k| else if (word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 309| 2.36k|#define word1(x) (x)->L[0] | | ------------------ | | | Branch (309:18): [True: 662, False: 521] | | ------------------ ------------------ else if (word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 308| 521|#define word0(x) (x)->L[1] ------------------ else if (word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 362| 521|#define Bndry_mask 0xfffff ------------------ | Branch (3171:27): [True: 368, False: 153] ------------------ 3172| 1.03k|#ifndef Sudden_Underflow 3173| 1.03k| if (word1(&rv) == Tiny1 && !word0(&rv)) { ------------------ | | 309| 1.03k|#define word1(x) (x)->L[0] ------------------ if (word1(&rv) == Tiny1 && !word0(&rv)) { ------------------ | | 368| 2.06k|#define Tiny1 1 ------------------ if (word1(&rv) == Tiny1 && !word0(&rv)) { ------------------ | | 308| 132|#define word0(x) (x)->L[1] ------------------ | Branch (3173:9): [True: 132, False: 898] | Branch (3173:32): [True: 0, False: 132] ------------------ 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| 1.03k|#endif 3181| 1.03k| aadj = 1.; 3182| 1.03k| aadj1 = -1.; 3183| 1.03k| } 3184| 153| else { 3185| | /* special case -- power of FLT_RADIX to be */ 3186| | /* rounded down... */ 3187| | 3188| 153| if (aadj < 2./FLT_RADIX) ------------------ | Branch (3188:9): [True: 0, False: 153] ------------------ 3189| 0| aadj = 1./FLT_RADIX; 3190| 153| else 3191| 153| aadj *= 0.5; 3192| 153| aadj1 = -aadj; 3193| 153| } 3194| 2.99k| } 3195| 1.36k| else { 3196| 1.36k| aadj *= 0.5; 3197| 1.36k| aadj1 = bc.dsign ? aadj : -aadj; ------------------ | Branch (3197:12): [True: 1.15k, False: 201] ------------------ 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| 1.36k| if (Flt_Rounds == 0) ------------------ | | 380| 1.36k|#define Flt_Rounds FLT_ROUNDS ------------------ | Branch (3208:8): [True: 0, False: 1.36k] ------------------ 3209| 0| aadj1 += 0.5; 3210| 1.36k|#endif /*Check_FLT_ROUNDS*/ 3211| 1.36k| } 3212| 4.35k| y = word0(&rv) & Exp_mask; ------------------ | | 308| 4.35k|#define word0(x) (x)->L[1] ------------------ y = word0(&rv) & Exp_mask; ------------------ | | 349| 4.35k|#define Exp_mask 0x7ff00000 ------------------ 3213| | 3214| | /* Check for overflow */ 3215| | 3216| 4.35k| if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) { ------------------ | | 347| 4.35k|#define Exp_msk1 0x100000 ------------------ if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) { ------------------ | | 352| 4.35k|#define Bias 1023 ------------------ | Branch (3216:7): [True: 0, False: 4.35k] ------------------ 3217| 0| dval(&rv0) = dval(&rv); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ dval(&rv0) = dval(&rv); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3218| 0| word0(&rv) -= P*Exp_msk1; ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 350| 0|#define P 53 ------------------ word0(&rv) -= P*Exp_msk1; ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ 3219| 0| adj.d = aadj1 * ulp(C, &rv); 3220| 0| dval(&rv) += adj.d; ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ 3221| 0| if ((word0(&rv) & Exp_mask) >= ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ if ((word0(&rv) & Exp_mask) >= ------------------ | | 349| 0|#define Exp_mask 0x7ff00000 ------------------ | Branch (3221:8): [True: 0, False: 0] ------------------ 3222| 0| Exp_msk1*(DBL_MAX_EXP+Bias-P)) { ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ Exp_msk1*(DBL_MAX_EXP+Bias-P)) { ------------------ | | 352| 0|#define Bias 1023 ------------------ Exp_msk1*(DBL_MAX_EXP+Bias-P)) { ------------------ | | 350| 0|#define P 53 ------------------ 3223| 0| if (word0(&rv0) == Big0 && word1(&rv0) == Big1) ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ if (word0(&rv0) == Big0 && word1(&rv0) == 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(&rv0) == Big0 && word1(&rv0) == Big1) ------------------ | | 309| 0|#define word1(x) (x)->L[0] ------------------ if (word0(&rv0) == Big0 && word1(&rv0) == Big1) ------------------ | | 479| 0|#define Big1 0xffffffff ------------------ | Branch (3223:9): [True: 0, False: 0] | Branch (3223:32): [True: 0, False: 0] ------------------ 3224| 0| 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| 0| } 3229| 0| else 3230| 0| word0(&rv) += P*Exp_msk1; ------------------ | | 308| 0|#define word0(x) (x)->L[1] ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 350| 0|#define P 53 ------------------ word0(&rv) += P*Exp_msk1; ------------------ | | 347| 0|#define Exp_msk1 0x100000 ------------------ 3231| 0| } 3232| 4.35k| else { 3233| 4.35k|#ifdef Avoid_Underflow 3234| 4.35k| if (bc.scale && y <= 2*P*Exp_msk1) { ------------------ | | 350| 1.73k|#define P 53 ------------------ if (bc.scale && y <= 2*P*Exp_msk1) { ------------------ | | 347| 1.73k|#define Exp_msk1 0x100000 ------------------ | Branch (3234:8): [True: 1.73k, False: 2.61k] | Branch (3234:20): [True: 1.56k, False: 178] ------------------ 3235| 1.56k| if (aadj <= 0x7fffffff) { ------------------ | Branch (3235:9): [True: 1.56k, False: 0] ------------------ 3236| 1.56k| if ((z = aadj) <= 0) ------------------ | Branch (3236:10): [True: 153, False: 1.40k] ------------------ 3237| 153| z = 1; 3238| 1.56k| aadj = z; 3239| 1.56k| aadj1 = bc.dsign ? aadj : -aadj; ------------------ | Branch (3239:14): [True: 1.40k, False: 153] ------------------ 3240| 1.56k| } 3241| 1.56k| dval(&aadj2) = aadj1; ------------------ | | 314| 1.56k|#define dval(x) (x)->d ------------------ 3242| 1.56k| word0(&aadj2) += (2*P+1)*Exp_msk1 - y; ------------------ | | 308| 1.56k|#define word0(x) (x)->L[1] ------------------ word0(&aadj2) += (2*P+1)*Exp_msk1 - y; ------------------ | | 350| 1.56k|#define P 53 ------------------ word0(&aadj2) += (2*P+1)*Exp_msk1 - y; ------------------ | | 347| 1.56k|#define Exp_msk1 0x100000 ------------------ 3243| 1.56k| aadj1 = dval(&aadj2); ------------------ | | 314| 1.56k|#define dval(x) (x)->d ------------------ 3244| 1.56k| adj.d = aadj1 * ulp(C, &rv); 3245| 1.56k| dval(&rv) += adj.d; ------------------ | | 314| 1.56k|#define dval(x) (x)->d ------------------ 3246| 1.56k| if (rv.d == 0.) ------------------ | Branch (3246:9): [True: 153, False: 1.40k] ------------------ 3247| |#ifdef NO_STRTOD_BIGCOMP 3248| | goto undfl; 3249| |#else 3250| 153| { 3251| 153| if (bc.nd > nd) ------------------ | Branch (3251:10): [True: 0, False: 153] ------------------ 3252| 0| bc.dsign = 1; 3253| 153| break; 3254| 153| } 3255| 1.56k|#endif 3256| 1.56k| } 3257| 2.79k| else { 3258| 2.79k| adj.d = aadj1 * ulp(C, &rv); 3259| 2.79k| dval(&rv) += adj.d; ------------------ | | 314| 2.79k|#define dval(x) (x)->d ------------------ 3260| 2.79k| } 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| 4.35k| } 3311| 4.19k| z = word0(&rv) & Exp_mask; ------------------ | | 308| 4.19k|#define word0(x) (x)->L[1] ------------------ z = word0(&rv) & Exp_mask; ------------------ | | 349| 4.19k|#define Exp_mask 0x7ff00000 ------------------ 3312| 4.19k|#ifndef SET_INEXACT 3313| 4.19k| if (bc.nd == nd) { ------------------ | Branch (3313:7): [True: 4.19k, False: 0] ------------------ 3314| 4.19k|#ifdef Avoid_Underflow 3315| 4.19k| if (!bc.scale) ------------------ | Branch (3315:7): [True: 2.61k, False: 1.58k] ------------------ 3316| 2.61k|#endif 3317| 2.61k| if (y == z) { ------------------ | Branch (3317:7): [True: 2.21k, False: 396] ------------------ 3318| | /* Can we stop now? */ 3319| 2.21k| L = (Long)aadj; 3320| 2.21k| aadj -= L; 3321| | /* The tolerances below are conservative. */ 3322| 2.21k| if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 309| 3.42k|#define word1(x) (x)->L[0] | | ------------------ | | | Branch (309:18): [True: 1.07k, False: 132] | | ------------------ ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 308| 132|#define word0(x) (x)->L[1] ------------------ if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) { ------------------ | | 362| 132|#define Bndry_mask 0xfffff ------------------ | Branch (3322:8): [True: 1.00k, False: 1.20k] | Branch (3322:34): [True: 132, False: 0] ------------------ 3323| 2.21k| if (aadj < .4999999 || aadj > .5000001) ------------------ | Branch (3323:9): [True: 1.48k, False: 729] | Branch (3323:28): [True: 578, False: 151] ------------------ 3324| 2.06k| break; 3325| 2.21k| } 3326| 0| else if (aadj < .4999999/FLT_RADIX) ------------------ | Branch (3326:13): [True: 0, False: 0] ------------------ 3327| 0| break; 3328| 2.21k| } 3329| 4.19k| } 3330| 2.13k|#endif 3331| 2.13k| cont: 3332| 2.13k| Bfree(C, bb); 3333| 2.13k| Bfree(C, bd); 3334| 2.13k| Bfree(C, bs); 3335| 2.13k| Bfree(C, delta); 3336| 2.13k| } 3337| 7.26k| Bfree(C, bb); 3338| 7.26k| Bfree(C, bd); 3339| 7.26k| Bfree(C, bs); 3340| 7.26k| Bfree(C, bd0); 3341| 7.26k| Bfree(C, delta); 3342| 7.26k|#ifndef NO_STRTOD_BIGCOMP 3343| 7.26k| if (req_bigcomp) { ------------------ | Branch (3343:6): [True: 0, False: 7.26k] ------------------ 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| 7.26k|#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| 7.26k|#ifdef Avoid_Underflow 3366| 7.26k| if (bc.scale) { ------------------ | Branch (3366:6): [True: 1.98k, False: 5.28k] ------------------ 3367| 1.98k| word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 308| 1.98k|#define word0(x) (x)->L[1] ------------------ word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 355| 1.98k|#define Exp_1 0x3ff00000 ------------------ word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 350| 1.98k|#define P 53 ------------------ word0(&rv0) = Exp_1 - 2*P*Exp_msk1; ------------------ | | 347| 1.98k|#define Exp_msk1 0x100000 ------------------ 3368| 1.98k| word1(&rv0) = 0; ------------------ | | 309| 1.98k|#define word1(x) (x)->L[0] ------------------ 3369| 1.98k| dval(&rv) *= dval(&rv0); ------------------ | | 314| 1.98k|#define dval(x) (x)->d ------------------ dval(&rv) *= dval(&rv0); ------------------ | | 314| 1.98k|#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| 1.98k| } 3380| 7.26k|#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| 69.5k| ret: 3389| 69.5k| if (se) ------------------ | Branch (3389:6): [True: 69.5k, False: 0] ------------------ 3390| 69.5k| *se = (char *)s; 3391| 69.5k| return sign ? -dval(&rv) : dval(&rv); ------------------ | | 314| 0|#define dval(x) (x)->d ------------------ return sign ? -dval(&rv) : dval(&rv); ------------------ | | 314| 69.5k|#define dval(x) (x)->d ------------------ | Branch (3391:9): [True: 0, False: 69.5k] ------------------ 3392| 7.26k| } jvp_freedtoa: 3430| 7.16k|{ 3431| 7.16k| Bigint *b = (Bigint *)((int *)s - 1); 3432| 7.16k| b->maxwds = 1 << (b->k = *(int*)b); 3433| 7.16k| Bfree(C, b); 3434| 7.16k| } jvp_dtoa: 3473| 7.16k|{ 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| 7.16k| int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1, 3509| 7.16k| j, j1=0, k, k0, k_check, leftright, m2, m5, s2, s5, 3510| 7.16k| spec_case, try_quick; 3511| 7.16k| Long L; ------------------ | | 193| 7.16k|#define Long int ------------------ 3512| 7.16k|#ifndef Sudden_Underflow 3513| 7.16k| int denorm; 3514| 7.16k| ULong x; 3515| 7.16k|#endif 3516| 7.16k| Bigint *b, *b1, *delta, *mlo, *mhi, *S; 3517| 7.16k| U d2, eps, u; 3518| 7.16k| double ds; 3519| 7.16k| char *s, *s0; 3520| 7.16k|#ifndef No_leftright 3521| 7.16k|#ifdef IEEE_Arith 3522| 7.16k| U eps1; 3523| 7.16k|#endif 3524| 7.16k|#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| 7.16k| u.d = dd; 3544| 7.16k| if (word0(&u) & Sign_bit) { ------------------ | | 308| 7.16k|#define word0(x) (x)->L[1] ------------------ if (word0(&u) & Sign_bit) { ------------------ | | 365| 7.16k|#define Sign_bit 0x80000000 ------------------ | Branch (3544:6): [True: 1.38k, False: 5.77k] ------------------ 3545| | /* set sign for everything, including 0's and NaNs */ 3546| 1.38k| *sign = 1; 3547| 1.38k| word0(&u) &= ~Sign_bit; /* clear sign bit */ ------------------ | | 308| 1.38k|#define word0(x) (x)->L[1] ------------------ word0(&u) &= ~Sign_bit; /* clear sign bit */ ------------------ | | 365| 1.38k|#define Sign_bit 0x80000000 ------------------ 3548| 1.38k| } 3549| 5.77k| else 3550| 5.77k| *sign = 0; 3551| | 3552| 7.16k|#if defined(IEEE_Arith) + defined(VAX) 3553| 7.16k|#ifdef IEEE_Arith 3554| 7.16k| if ((word0(&u) & Exp_mask) == Exp_mask) ------------------ | | 308| 7.16k|#define word0(x) (x)->L[1] ------------------ if ((word0(&u) & Exp_mask) == Exp_mask) ------------------ | | 349| 7.16k|#define Exp_mask 0x7ff00000 ------------------ if ((word0(&u) & Exp_mask) == Exp_mask) ------------------ | | 349| 7.16k|#define Exp_mask 0x7ff00000 ------------------ | Branch (3554:6): [True: 0, False: 7.16k] ------------------ 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| 7.16k|#endif 3568| |#ifdef IBM 3569| | dval(&u) += 0; /* normalize */ 3570| |#endif 3571| 7.16k| if (!dval(&u)) { ------------------ | | 314| 7.16k|#define dval(x) (x)->d ------------------ | Branch (3571:6): [True: 642, False: 6.52k] ------------------ 3572| 642| *decpt = 1; 3573| 642| return nrv_alloc(C, "0", rve, 1); 3574| 642| } 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| 6.52k| b = d2b(C, &u, &be, &bbits); 3591| |#ifdef Sudden_Underflow 3592| | i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)); 3593| |#else 3594| 6.52k| if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 308| 6.52k|#define word0(x) (x)->L[1] ------------------ if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 346| 6.52k|#define Exp_shift1 20 ------------------ if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 349| 6.52k|#define Exp_mask 0x7ff00000 ------------------ if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) { ------------------ | | 346| 6.52k|#define Exp_shift1 20 ------------------ | Branch (3594:6): [True: 5.76k, False: 763] ------------------ 3595| 5.76k|#endif 3596| 5.76k| dval(&d2) = dval(&u); ------------------ | | 314| 5.76k|#define dval(x) (x)->d ------------------ dval(&d2) = dval(&u); ------------------ | | 314| 5.76k|#define dval(x) (x)->d ------------------ 3597| 5.76k| word0(&d2) &= Frac_mask1; ------------------ | | 308| 5.76k|#define word0(x) (x)->L[1] ------------------ word0(&d2) &= Frac_mask1; ------------------ | | 359| 5.76k|#define Frac_mask1 0xfffff ------------------ 3598| 5.76k| word0(&d2) |= Exp_11; ------------------ | | 308| 5.76k|#define word0(x) (x)->L[1] ------------------ word0(&d2) |= Exp_11; ------------------ | | 356| 5.76k|#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| 5.76k| i -= Bias; ------------------ | | 352| 5.76k|#define Bias 1023 ------------------ 3627| |#ifdef IBM 3628| | i <<= 2; 3629| | i += j; 3630| |#endif 3631| 5.76k|#ifndef Sudden_Underflow 3632| 5.76k| denorm = 0; 3633| 5.76k| } 3634| 763| else { 3635| | /* d is denormalized */ 3636| | 3637| 763| i = bbits + be + (Bias + (P-1) - 1); ------------------ | | 352| 763|#define Bias 1023 ------------------ i = bbits + be + (Bias + (P-1) - 1); ------------------ | | 350| 763|#define P 53 ------------------ 3638| 763| x = i > 32 ? word0(&u) << (64 - i) | word1(&u) >> (i - 32) ------------------ | | 308| 243|#define word0(x) (x)->L[1] ------------------ x = i > 32 ? word0(&u) << (64 - i) | word1(&u) >> (i - 32) ------------------ | | 309| 243|#define word1(x) (x)->L[0] ------------------ | Branch (3638:7): [True: 243, False: 520] ------------------ 3639| 763| : word1(&u) << (32 - i); ------------------ | | 309| 520|#define word1(x) (x)->L[0] ------------------ 3640| 763| dval(&d2) = x; ------------------ | | 314| 763|#define dval(x) (x)->d ------------------ 3641| 763| word0(&d2) -= 31*Exp_msk1; /* adjust exponent */ ------------------ | | 308| 763|#define word0(x) (x)->L[1] ------------------ word0(&d2) -= 31*Exp_msk1; /* adjust exponent */ ------------------ | | 347| 763|#define Exp_msk1 0x100000 ------------------ 3642| 763| i -= (Bias + (P-1) - 1) + 1; ------------------ | | 352| 763|#define Bias 1023 ------------------ i -= (Bias + (P-1) - 1) + 1; ------------------ | | 350| 763|#define P 53 ------------------ 3643| 763| denorm = 1; 3644| 763| } 3645| 6.52k|#endif 3646| 6.52k| ds = (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981; ------------------ | | 314| 6.52k|#define dval(x) (x)->d ------------------ 3647| 6.52k| k = (int)ds; 3648| 6.52k| if (ds < 0. && ds != k) ------------------ | Branch (3648:6): [True: 2.49k, False: 4.02k] | Branch (3648:17): [True: 2.49k, False: 0] ------------------ 3649| 2.49k| k--; /* want k = floor(ds) */ 3650| 6.52k| k_check = 1; 3651| 6.52k| if (k >= 0 && k <= Ten_pmax) { ------------------ | | 360| 4.02k|#define Ten_pmax 22 ------------------ | Branch (3651:6): [True: 4.02k, False: 2.49k] | Branch (3651:16): [True: 2.00k, False: 2.02k] ------------------ 3652| 2.00k| if (dval(&u) < tens[k]) ------------------ | | 314| 2.00k|#define dval(x) (x)->d ------------------ | Branch (3652:7): [True: 310, False: 1.69k] ------------------ 3653| 310| k--; 3654| 2.00k| k_check = 0; 3655| 2.00k| } 3656| 6.52k| j = bbits - i - 1; 3657| 6.52k| if (j >= 0) { ------------------ | Branch (3657:6): [True: 3.74k, False: 2.78k] ------------------ 3658| 3.74k| b2 = 0; 3659| 3.74k| s2 = j; 3660| 3.74k| } 3661| 2.78k| else { 3662| 2.78k| b2 = -j; 3663| 2.78k| s2 = 0; 3664| 2.78k| } 3665| 6.52k| if (k >= 0) { ------------------ | Branch (3665:6): [True: 4.01k, False: 2.50k] ------------------ 3666| 4.01k| b5 = 0; 3667| 4.01k| s5 = k; 3668| 4.01k| s2 += k; 3669| 4.01k| } 3670| 2.50k| else { 3671| 2.50k| b2 -= k; 3672| 2.50k| b5 = -k; 3673| 2.50k| s5 = 0; 3674| 2.50k| } 3675| 6.52k| if (mode < 0 || mode > 9) ------------------ | Branch (3675:6): [True: 0, False: 6.52k] | Branch (3675:18): [True: 0, False: 6.52k] ------------------ 3676| 0| mode = 0; 3677| | 3678| 6.52k|#ifndef SET_INEXACT 3679| |#ifdef Check_FLT_ROUNDS 3680| | try_quick = Rounding == 1; 3681| |#else 3682| 6.52k| try_quick = 1; 3683| 6.52k|#endif 3684| 6.52k|#endif /*SET_INEXACT*/ 3685| | 3686| 6.52k| if (mode > 5) { ------------------ | Branch (3686:6): [True: 0, False: 6.52k] ------------------ 3687| 0| mode -= 4; 3688| 0| try_quick = 0; 3689| 0| } 3690| 6.52k| leftright = 1; 3691| 6.52k| ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */ 3692| | /* silence erroneous "gcc -Wall" warning. */ 3693| 6.52k| switch(mode) { ------------------ | Branch (3693:9): [True: 6.52k, False: 0] ------------------ 3694| 6.52k| case 0: ------------------ | Branch (3694:3): [True: 6.52k, False: 0] ------------------ 3695| 6.52k| case 1: ------------------ | Branch (3695:3): [True: 0, False: 6.52k] ------------------ 3696| 6.52k| i = 18; 3697| 6.52k| ndigits = 0; 3698| 6.52k| break; 3699| 0| case 2: ------------------ | Branch (3699:3): [True: 0, False: 6.52k] ------------------ 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: 6.52k] ------------------ 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: 6.52k] ------------------ 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: 6.52k] ------------------ 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| 6.52k| } 3719| 6.52k| 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| 6.52k| if (ilim >= 0 && ilim <= Quick_max && try_quick) { ------------------ | | 369| 6.52k|#define Quick_max 14 ------------------ | Branch (3726:6): [True: 0, False: 6.52k] | 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| 6.52k| if (be >= 0 && k <= Int_max) { ------------------ | | 370| 3.64k|#define Int_max 14 ------------------ | Branch (3842:6): [True: 3.64k, False: 2.87k] | Branch (3842:17): [True: 1.00k, False: 2.63k] ------------------ 3843| | /* Yes. */ 3844| 1.00k| ds = tens[k]; 3845| 1.00k| if (ndigits < 0 && ilim <= 0) { ------------------ | Branch (3845:7): [True: 0, False: 1.00k] | 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.88k| for(i = 1;; i++, dval(&u) *= 10.) { ------------------ | | 314| 876|#define dval(x) (x)->d ------------------ 3852| 1.88k| L = (Long)(dval(&u) / ds); ------------------ | | 314| 1.88k|#define dval(x) (x)->d ------------------ 3853| 1.88k| dval(&u) -= L*ds; ------------------ | | 314| 1.88k|#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.88k| *s++ = '0' + (int)L; 3862| 1.88k| if (!dval(&u)) { ------------------ | | 314| 1.88k|#define dval(x) (x)->d ------------------ | Branch (3862:8): [True: 1.00k, False: 876] ------------------ 3863| |#ifdef SET_INEXACT 3864| | inexact = 0; 3865| |#endif 3866| 1.00k| break; 3867| 1.00k| } 3868| 876| if (i == ilim) { ------------------ | Branch (3868:8): [True: 0, False: 876] ------------------ 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| 876| } 3895| 1.00k| goto ret1; 3896| 1.00k| } 3897| | 3898| 5.51k| m2 = b2; 3899| 5.51k| m5 = b5; 3900| 5.51k| mhi = mlo = 0; 3901| 5.51k| if (leftright) { ------------------ | Branch (3901:6): [True: 5.51k, False: 0] ------------------ 3902| 5.51k| i = 3903| 5.51k|#ifndef Sudden_Underflow 3904| 5.51k| denorm ? be + (Bias + (P-1) - 1 + 1) : ------------------ | | 352| 763|#define Bias 1023 ------------------ denorm ? be + (Bias + (P-1) - 1 + 1) : ------------------ | | 350| 763|#define P 53 ------------------ | Branch (3904:4): [True: 763, False: 4.75k] ------------------ 3905| 5.51k|#endif 3906| |#ifdef IBM 3907| | 1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3); 3908| |#else 3909| 5.51k| 1 + P - bbits; ------------------ | | 350| 4.75k|#define P 53 ------------------ 3910| 5.51k|#endif 3911| 5.51k| b2 += i; 3912| 5.51k| s2 += i; 3913| 5.51k| mhi = i2b(C, 1); 3914| 5.51k| } 3915| 5.51k| if (m2 > 0 && s2 > 0) { ------------------ | Branch (3915:6): [True: 5.14k, False: 374] | Branch (3915:16): [True: 5.14k, False: 0] ------------------ 3916| 5.14k| i = m2 < s2 ? m2 : s2; ------------------ | Branch (3916:7): [True: 3.10k, False: 2.03k] ------------------ 3917| 5.14k| b2 -= i; 3918| 5.14k| m2 -= i; 3919| 5.14k| s2 -= i; 3920| 5.14k| } 3921| 5.51k| if (b5 > 0) { ------------------ | Branch (3921:6): [True: 2.50k, False: 3.01k] ------------------ 3922| 2.50k| if (leftright) { ------------------ | Branch (3922:7): [True: 2.50k, False: 0] ------------------ 3923| 2.50k| if (m5 > 0) { ------------------ | Branch (3923:8): [True: 2.50k, False: 0] ------------------ 3924| 2.50k| mhi = pow5mult(C, mhi, m5); 3925| 2.50k| b1 = mult(C, mhi, b); 3926| 2.50k| Bfree(C, b); 3927| 2.50k| b = b1; 3928| 2.50k| } 3929| 2.50k| if ((j = b5 - m5)) ------------------ | Branch (3929:8): [True: 0, False: 2.50k] ------------------ 3930| 0| b = pow5mult(C, b, j); 3931| 2.50k| } 3932| 0| else 3933| 0| b = pow5mult(C, b, b5); 3934| 2.50k| } 3935| 5.51k| S = i2b(C, 1); 3936| 5.51k| if (s5 > 0) ------------------ | Branch (3936:6): [True: 3.00k, False: 2.51k] ------------------ 3937| 3.00k| S = pow5mult(C, S, s5); 3938| | 3939| | /* Check for special case that d is a normalized power of 2. */ 3940| | 3941| 5.51k| spec_case = 0; 3942| 5.51k| if ((mode < 2 || leftright) ------------------ | Branch (3942:7): [True: 5.51k, False: 0] | Branch (3942:19): [True: 0, False: 0] ------------------ 3943| |#ifdef Honor_FLT_ROUNDS 3944| | && Rounding == 1 3945| |#endif 3946| 5.51k| ) { 3947| 5.51k| if (!word1(&u) && !(word0(&u) & Bndry_mask) ------------------ | | 309| 11.0k|#define word1(x) (x)->L[0] ------------------ if (!word1(&u) && !(word0(&u) & Bndry_mask) ------------------ | | 308| 636|#define word0(x) (x)->L[1] ------------------ if (!word1(&u) && !(word0(&u) & Bndry_mask) ------------------ | | 362| 636|#define Bndry_mask 0xfffff ------------------ | Branch (3947:7): [True: 636, False: 4.88k] | Branch (3947:21): [True: 7, False: 629] ------------------ 3948| 7|#ifndef Sudden_Underflow 3949| 7| && word0(&u) & (Exp_mask & ~Exp_msk1) ------------------ | | 308| 7|#define word0(x) (x)->L[1] ------------------ && word0(&u) & (Exp_mask & ~Exp_msk1) ------------------ | | 349| 7|#define Exp_mask 0x7ff00000 ------------------ && word0(&u) & (Exp_mask & ~Exp_msk1) ------------------ | | 347| 7|#define Exp_msk1 0x100000 ------------------ | Branch (3949:7): [True: 7, False: 0] ------------------ 3950| 5.51k|#endif 3951| 5.51k| ) { 3952| | /* The special case */ 3953| 7| b2 += Log2P; ------------------ | | 366| 7|#define Log2P 1 ------------------ 3954| 7| s2 += Log2P; ------------------ | | 366| 7|#define Log2P 1 ------------------ 3955| 7| spec_case = 1; 3956| 7| } 3957| 5.51k| } 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| 5.51k| i = dshift(C, S, s2); 3967| 5.51k| b2 += i; 3968| 5.51k| m2 += i; 3969| 5.51k| s2 += i; 3970| 5.51k| if (b2 > 0) ------------------ | Branch (3970:6): [True: 5.51k, False: 0] ------------------ 3971| 5.51k| b = lshift(C, b, b2); 3972| 5.51k| if (s2 > 0) ------------------ | Branch (3972:6): [True: 5.51k, False: 0] ------------------ 3973| 5.51k| S = lshift(C, S, s2); 3974| 5.51k| if (k_check) { ------------------ | Branch (3974:6): [True: 4.52k, False: 995] ------------------ 3975| 4.52k| if (cmp(C, b,S) < 0) { ------------------ | Branch (3975:7): [True: 364, False: 4.15k] ------------------ 3976| 364| k--; 3977| 364| b = multadd(C, b, 10, 0); /* we botched the k estimate */ 3978| 364| if (leftright) ------------------ | Branch (3978:8): [True: 364, False: 0] ------------------ 3979| 364| mhi = multadd(C, mhi, 10, 0); 3980| 364| ilim = ilim1; 3981| 364| } 3982| 4.52k| } 3983| 5.51k| if (ilim <= 0 && (mode == 3 || mode == 5)) { ------------------ | Branch (3983:6): [True: 5.51k, False: 0] | Branch (3983:20): [True: 0, False: 5.51k] | Branch (3983:33): [True: 0, False: 5.51k] ------------------ 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| 5.51k| if (leftright) { ------------------ | Branch (3995:6): [True: 5.51k, False: 0] ------------------ 3996| 5.51k| if (m2 > 0) ------------------ | Branch (3996:7): [True: 5.48k, False: 28] ------------------ 3997| 5.48k| 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| 5.51k| mlo = mhi; 4004| 5.51k| if (spec_case) { ------------------ | Branch (4004:7): [True: 7, False: 5.50k] ------------------ 4005| 7| mhi = Balloc(C, mhi->k); 4006| 7| Bcopy(mhi, mlo); ------------------ | | 586| 7|#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ | | 587| 7|y->wds*sizeof(Long) + 2*sizeof(int)) ------------------ 4007| 7| mhi = lshift(C, mhi, Log2P); ------------------ | | 366| 7|#define Log2P 1 ------------------ 4008| 7| } 4009| | 4010| 58.0k| for(i = 1;;i++) { 4011| 58.0k| dig = quorem(C, b,S) + '0'; 4012| | /* Do we yet have the shortest decimal string 4013| | * that will round to d? 4014| | */ 4015| 58.0k| j = cmp(C, b, mlo); 4016| 58.0k| delta = diff(C, S, mhi); 4017| 58.0k| j1 = delta->sign ? 1 : cmp(C, b, delta); ------------------ | Branch (4017:9): [True: 573, False: 57.4k] ------------------ 4018| 58.0k| Bfree(C, delta); 4019| 58.0k|#ifndef ROUND_BIASED 4020| 58.0k| if (j1 == 0 && mode != 1 && !(word1(&u) & 1) ------------------ | | 309| 422|#define word1(x) (x)->L[0] ------------------ | Branch (4020:8): [True: 422, False: 57.6k] | Branch (4020:19): [True: 422, False: 0] | Branch (4020:32): [True: 422, False: 0] ------------------ 4021| |#ifdef Honor_FLT_ROUNDS 4022| | && Rounding >= 1 4023| |#endif 4024| 58.0k| ) { 4025| 422| if (dig == '9') ------------------ | Branch (4025:9): [True: 144, False: 278] ------------------ 4026| 144| goto round_9_up; 4027| 278| if (j > 0) ------------------ | Branch (4027:9): [True: 271, False: 7] ------------------ 4028| 271| dig++; 4029| |#ifdef SET_INEXACT 4030| | else if (!b->x[0] && b->wds <= 1) 4031| | inexact = 0; 4032| |#endif 4033| 278| *s++ = dig; 4034| 278| goto ret; 4035| 422| } 4036| 57.6k|#endif 4037| 57.6k| if (j < 0 || (j == 0 && mode != 1 ------------------ | Branch (4037:8): [True: 4.37k, False: 53.2k] | Branch (4037:18): [True: 374, False: 52.8k] | Branch (4037:28): [True: 374, False: 0] ------------------ 4038| 374|#ifndef ROUND_BIASED 4039| 374| && !(word1(&u) & 1) ------------------ | | 309| 374|#define word1(x) (x)->L[0] ------------------ | Branch (4039:11): [True: 241, False: 133] ------------------ 4040| 53.2k|#endif 4041| 53.2k| )) { 4042| 4.61k| if (!b->x[0] && b->wds <= 1) { ------------------ | Branch (4042:9): [True: 1.42k, False: 3.19k] | Branch (4042:21): [True: 673, False: 753] ------------------ 4043| |#ifdef SET_INEXACT 4044| | inexact = 0; 4045| |#endif 4046| 673| goto accept_dig; 4047| 673| } 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| 3.94k| if (j1 > 0) { ------------------ | Branch (4055:9): [True: 2.31k, False: 1.63k] ------------------ 4056| 2.31k| b = lshift(C, b, 1); 4057| 2.31k| j1 = cmp(C, b, S); 4058| |#ifdef ROUND_BIASED 4059| | if (j1 >= 0 /*)*/ 4060| |#else 4061| 2.31k| if ((j1 > 0 || (j1 == 0 && dig & 1)) ------------------ | Branch (4061:11): [True: 272, False: 2.04k] | Branch (4061:22): [True: 137, False: 1.90k] | Branch (4061:33): [True: 0, False: 137] ------------------ 4062| 272|#endif 4063| 272| && dig++ == '9') ------------------ | Branch (4063:9): [True: 128, False: 144] ------------------ 4064| 128| goto round_9_up; 4065| 2.31k| } 4066| 4.49k| accept_dig: 4067| 4.49k| *s++ = dig; 4068| 4.49k| goto ret; 4069| 3.94k| } 4070| 53.0k| if (j1 > 0) { ------------------ | Branch (4070:8): [True: 476, False: 52.5k] ------------------ 4071| |#ifdef Honor_FLT_ROUNDS 4072| | if (!Rounding) 4073| | goto accept_dig; 4074| |#endif 4075| 476| if (dig == '9') { /* possible if i == 1 */ ------------------ | Branch (4075:9): [True: 18, False: 458] ------------------ 4076| 290| round_9_up: 4077| 290| *s++ = '9'; 4078| 290| goto roundoff; 4079| 18| } 4080| 458| *s++ = dig + 1; 4081| 458| goto ret; 4082| 476| } 4083| |#ifdef Honor_FLT_ROUNDS 4084| | keep_dig: 4085| |#endif 4086| 52.5k| *s++ = dig; 4087| 52.5k| if (i == ilim) ------------------ | Branch (4087:8): [True: 0, False: 52.5k] ------------------ 4088| 0| break; 4089| 52.5k| b = multadd(C, b, 10, 0); 4090| 52.5k| if (mlo == mhi) ------------------ | Branch (4090:8): [True: 52.4k, False: 77] ------------------ 4091| 52.4k| mlo = mhi = multadd(C, mhi, 10, 0); 4092| 77| else { 4093| 77| mlo = multadd(C, mlo, 10, 0); 4094| 77| mhi = multadd(C, mhi, 10, 0); 4095| 77| } 4096| 52.5k| } 4097| 5.51k| } 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| 290| roundoff: 4129| 290| while(*--s == '9') ------------------ | Branch (4129:9): [True: 290, False: 0] ------------------ 4130| 290| if (s == s0) { ------------------ | Branch (4130:8): [True: 290, False: 0] ------------------ 4131| 290| k++; 4132| 290| *s++ = '1'; 4133| 290| goto ret; 4134| 290| } 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| 5.51k| ret: 4145| 5.51k| Bfree(C, S); 4146| 5.51k| if (mhi) { ------------------ | Branch (4146:6): [True: 5.51k, False: 0] ------------------ 4147| 5.51k| if (mlo && mlo != mhi) ------------------ | Branch (4147:7): [True: 5.51k, False: 0] | Branch (4147:14): [True: 7, False: 5.50k] ------------------ 4148| 7| Bfree(C, mlo); 4149| 5.51k| Bfree(C, mhi); 4150| 5.51k| } 4151| 6.52k| 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| 6.52k| Bfree(C, b); 4164| 6.52k| *s = 0; 4165| 6.52k| *decpt = k + 1; 4166| 6.52k| if (rve) ------------------ | Branch (4166:6): [True: 6.52k, False: 0] ------------------ 4167| 6.52k| *rve = s; 4168| 6.52k| return s0; 4169| 5.51k| } jvp_dtoa_fmt: 4207| 7.16k|{ 4208| 7.16k| register int i, k; 4209| 7.16k| register char *s; 4210| 7.16k| int decpt, j, sign; 4211| 7.16k| char *b0, *s0, *se; 4212| | 4213| 7.16k| b0 = b; 4214| |#ifdef IGNORE_ZERO_SIGN 4215| | if (!x) { 4216| | *b++ = '0'; 4217| | *b = 0; 4218| | goto done; 4219| | } 4220| |#endif 4221| 7.16k| s = s0 = jvp_dtoa(C, x, 0, 0, &decpt, &sign, &se); 4222| 7.16k| if (sign) ------------------ | Branch (4222:6): [True: 1.38k, False: 5.77k] ------------------ 4223| 1.38k| *b++ = '-'; 4224| 7.16k| if (decpt == 9999) /* Infinity or Nan */ { ------------------ | Branch (4224:6): [True: 0, False: 7.16k] ------------------ 4225| 0| while((*b++ = *s++)); ------------------ | Branch (4225:9): [True: 0, False: 0] ------------------ 4226| 0| goto done0; 4227| 0| } 4228| 7.16k| if (decpt <= -4 || decpt > se - s + 15) { ------------------ | Branch (4228:6): [True: 1.62k, False: 5.53k] | Branch (4228:21): [True: 2.23k, False: 3.30k] ------------------ 4229| 3.86k| *b++ = *s++; 4230| 3.86k| if (*s) { ------------------ | Branch (4230:7): [True: 3.26k, False: 594] ------------------ 4231| 3.26k| *b++ = '.'; 4232| 40.7k| while((*b = *s++)) ------------------ | Branch (4232:10): [True: 37.4k, False: 3.26k] ------------------ 4233| 37.4k| b++; 4234| 3.26k| } 4235| 3.86k| *b++ = 'e'; 4236| | /* sprintf(b, "%+.2d", decpt - 1); */ 4237| 3.86k| if (--decpt < 0) { ------------------ | Branch (4237:7): [True: 1.62k, False: 2.23k] ------------------ 4238| 1.62k| *b++ = '-'; 4239| 1.62k| decpt = -decpt; 4240| 1.62k| } 4241| 2.23k| else 4242| 2.23k| *b++ = '+'; 4243| 5.95k| for(j = 2, k = 10; 10*k <= decpt; j++, k *= 10); ------------------ | Branch (4243:22): [True: 2.08k, False: 3.86k] ------------------ 4244| 9.81k| for(;;) { 4245| 9.81k| i = decpt / k; 4246| 9.81k| *b++ = i + '0'; 4247| 9.81k| if (--j <= 0) ------------------ | Branch (4247:8): [True: 3.86k, False: 5.95k] ------------------ 4248| 3.86k| break; 4249| 5.95k| decpt -= i*k; 4250| 5.95k| decpt *= 10; 4251| 5.95k| } 4252| 3.86k| *b = 0; 4253| 3.86k| } 4254| 3.30k| else if (decpt <= 0) { ------------------ | Branch (4254:11): [True: 877, False: 2.42k] ------------------ 4255| 877| *b++ = '0'; 4256| 877| *b++ = '.'; 4257| 1.10k| for(; decpt < 0; decpt++) ------------------ | Branch (4257:9): [True: 227, False: 877] ------------------ 4258| 227| *b++ = '0'; 4259| 6.10k| while((*b++ = *s++)); ------------------ | Branch (4259:9): [True: 5.23k, False: 877] ------------------ 4260| 877| } 4261| 2.42k| else { 4262| 16.4k| while((*b = *s++)) { ------------------ | Branch (4262:9): [True: 14.0k, False: 2.42k] ------------------ 4263| 14.0k| b++; 4264| 14.0k| if (--decpt == 0 && *s) ------------------ | Branch (4264:8): [True: 1.98k, False: 12.0k] | Branch (4264:24): [True: 373, False: 1.61k] ------------------ 4265| 373| *b++ = '.'; 4266| 14.0k| } 4267| 5.67k| for(; decpt > 0; decpt--) ------------------ | Branch (4267:9): [True: 3.24k, False: 2.42k] ------------------ 4268| 3.24k| *b++ = '0'; 4269| 2.42k| *b = 0; 4270| 2.42k| } 4271| 7.16k| done0: 4272| 7.16k| jvp_freedtoa(C, s0); 4273| 7.16k| goto done; 4274| 7.16k| done: 4275| 7.16k| return b0; 4276| 7.16k| } jv_dtoa.c:Bfree: 553| 206k|{ 554| 206k| if (v) { ------------------ | Branch (554:6): [True: 206k, False: 0] ------------------ 555| 206k| if (v->k > Kmax) ------------------ | | 3| 206k|#define Kmax 7 ------------------ | Branch (555:7): [True: 0, False: 206k] ------------------ 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| 206k| else { 562| 206k| v->next = C->freelist[v->k]; 563| 206k| C->freelist[v->k] = v; 564| 206k| } 565| 206k| } 566| 206k| } jv_dtoa.c:match: 1435| 5.27k|{ 1436| 5.27k| int c, d; 1437| 5.27k| CONST char *s = *sp; ------------------ | | 298| 5.27k|#define CONST const ------------------ 1438| | 1439| 23.7k| while((d = *t++)) { ------------------ | Branch (1439:8): [True: 18.4k, False: 5.27k] ------------------ 1440| 18.4k| if ((c = *++s) >= 'A' && c <= 'Z') ------------------ | Branch (1440:7): [True: 18.4k, False: 0] | Branch (1440:28): [True: 0, False: 18.4k] ------------------ 1441| 0| c += 'a' - 'A'; 1442| 18.4k| if (c != d) ------------------ | Branch (1442:7): [True: 0, False: 18.4k] ------------------ 1443| 0| return 0; 1444| 18.4k| } 1445| 5.27k| *sp = s + 1; 1446| 5.27k| return 1; 1447| 5.27k| } jv_dtoa.c:s2b: 645| 7.26k|{ 646| 7.26k| Bigint *b; 647| 7.26k| int i, k; 648| 7.26k| Long x, y; ------------------ | | 193| 7.26k|#define Long int ------------------ 649| | 650| 7.26k| x = (nd + 8) / 9; 651| 11.2k| for(k = 0, y = 1; x > y; y <<= 1, k++) ; ------------------ | Branch (651:20): [True: 4.00k, False: 7.26k] ------------------ 652| 7.26k|#ifdef Pack_32 653| 7.26k| b = Balloc(C, k); 654| 7.26k| b->x[0] = y9; 655| 7.26k| 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| 7.26k| i = 9; 663| 7.26k| if (9 < nd0) { ------------------ | Branch (663:6): [True: 2.00k, False: 5.26k] ------------------ 664| 2.00k| s += 9; 665| 15.3k| do b = multadd(C, b, 10, *s++ - '0'); 666| 15.3k| while(++i < nd0); ------------------ | Branch (666:10): [True: 13.3k, False: 2.00k] ------------------ 667| 2.00k| s += dplen; 668| 2.00k| } 669| 5.26k| else 670| 5.26k| s += dplen + 9; 671| 22.2k| for(; i < nd; i++) ------------------ | Branch (671:8): [True: 14.9k, False: 7.26k] ------------------ 672| 14.9k| b = multadd(C, b, 10, *s++ - '0'); 673| 7.26k| return b; 674| 7.26k| } jv_dtoa.c:Balloc: 532| 206k|{ 533| 206k| int x; 534| 206k| Bigint *rv; 535| | 536| | /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */ 537| | /* but this case seems very unlikely. */ 538| 206k| if (k <= Kmax && (rv = C->freelist[k])) ------------------ | | 3| 412k|#define Kmax 7 ------------------ | Branch (538:6): [True: 206k, False: 0] | Branch (538:19): [True: 206k, False: 31] ------------------ 539| 206k| 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| 206k| rv->sign = rv->wds = 0; 547| 206k| return rv; 548| 206k| } jv_dtoa.c:d2b: 1187| 15.9k|{ 1188| 15.9k| Bigint *b; 1189| 15.9k| int de, k; 1190| 15.9k| ULong *x, y, z; 1191| 15.9k|#ifndef Sudden_Underflow 1192| 15.9k| int i; 1193| 15.9k|#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| 15.9k|#define d0 word0(d) 1200| 15.9k|#define d1 word1(d) 1201| 15.9k|#endif 1202| | 1203| 15.9k|#ifdef Pack_32 1204| 15.9k| b = Balloc(C, 1); 1205| |#else 1206| | b = Balloc(C, 2); 1207| |#endif 1208| 15.9k| x = b->x; 1209| | 1210| 15.9k| z = d0 & Frac_mask; ------------------ | | 1199| 15.9k|#define d0 word0(d) | | ------------------ | | | | 308| 15.9k|#define word0(x) (x)->L[1] | | ------------------ ------------------ z = d0 & Frac_mask; ------------------ | | 358| 15.9k|#define Frac_mask 0xfffff ------------------ 1211| 15.9k| d0 &= 0x7fffffff; /* clear sign bit, which we ignore */ ------------------ | | 1199| 15.9k|#define d0 word0(d) | | ------------------ | | | | 308| 15.9k|#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| 15.9k| if ((de = (int)(d0 >> Exp_shift))) ------------------ | | 1199| 15.9k|#define d0 word0(d) | | ------------------ | | | | 308| 15.9k|#define word0(x) (x)->L[1] | | ------------------ ------------------ if ((de = (int)(d0 >> Exp_shift))) ------------------ | | 345| 15.9k|#define Exp_shift 20 ------------------ | Branch (1218:6): [True: 15.1k, False: 763] ------------------ 1219| 15.1k| z |= Exp_msk1; ------------------ | | 347| 15.1k|#define Exp_msk1 0x100000 ------------------ 1220| 15.9k|#endif 1221| 15.9k|#ifdef Pack_32 1222| 15.9k| if ((y = d1)) { ------------------ | | 1200| 15.9k|#define d1 word1(d) | | ------------------ | | | | 309| 15.9k|#define word1(x) (x)->L[0] | | ------------------ ------------------ | Branch (1222:6): [True: 12.2k, False: 3.66k] ------------------ 1223| 12.2k| if ((k = lo0bits(C, &y))) { ------------------ | Branch (1223:7): [True: 6.81k, False: 5.43k] ------------------ 1224| 6.81k| x[0] = y | z << (32 - k); 1225| 6.81k| z >>= k; 1226| 6.81k| } 1227| 5.43k| else 1228| 5.43k| x[0] = y; 1229| 12.2k|#ifndef Sudden_Underflow 1230| 12.2k| i = 1231| 12.2k|#endif 1232| 12.2k| b->wds = (x[1] = z) ? 2 : 1; ------------------ | Branch (1232:16): [True: 9.96k, False: 2.29k] ------------------ 1233| 12.2k| } 1234| 3.66k| else { 1235| 3.66k| k = lo0bits(C, &z); 1236| 3.66k| x[0] = z; 1237| 3.66k|#ifndef Sudden_Underflow 1238| 3.66k| i = 1239| 3.66k|#endif 1240| 3.66k| b->wds = 1; 1241| 3.66k| k += 32; 1242| 3.66k| } 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| 15.9k|#ifndef Sudden_Underflow 1289| 15.9k| if (de) { ------------------ | Branch (1289:6): [True: 15.1k, False: 763] ------------------ 1290| 15.1k|#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| 15.1k| *e = de - Bias - (P-1) + k; ------------------ | | 352| 15.1k|#define Bias 1023 ------------------ *e = de - Bias - (P-1) + k; ------------------ | | 350| 15.1k|#define P 53 ------------------ 1296| 15.1k| *bits = P - k; ------------------ | | 350| 15.1k|#define P 53 ------------------ 1297| 15.1k|#endif 1298| 15.1k|#ifndef Sudden_Underflow 1299| 15.1k| } 1300| 763| else { 1301| 763| *e = de - Bias - (P-1) + 1 + k; ------------------ | | 352| 763|#define Bias 1023 ------------------ *e = de - Bias - (P-1) + 1 + k; ------------------ | | 350| 763|#define P 53 ------------------ 1302| 763|#ifdef Pack_32 1303| 763| *bits = 32*i - hi0bits(C, x[i-1]); 1304| |#else 1305| | *bits = (i+2)*16 - hi0bits(C, x[i]); 1306| |#endif 1307| 763| } 1308| 15.9k|#endif 1309| 15.9k| return b; 1310| 15.9k| } jv_dtoa.c:lo0bits: 709| 15.9k|{ 710| 15.9k| int k; 711| 15.9k| ULong x = *y; 712| | 713| 15.9k| if (x & 7) { ------------------ | Branch (713:6): [True: 9.18k, False: 6.73k] ------------------ 714| 9.18k| if (x & 1) ------------------ | Branch (714:7): [True: 5.55k, False: 3.63k] ------------------ 715| 5.55k| return 0; 716| 3.63k| if (x & 2) { ------------------ | Branch (716:7): [True: 2.26k, False: 1.37k] ------------------ 717| 2.26k| *y = x >> 1; 718| 2.26k| return 1; 719| 2.26k| } 720| 1.37k| *y = x >> 2; 721| 1.37k| return 2; 722| 3.63k| } 723| 6.73k| k = 0; 724| 6.73k| if (!(x & 0xffff)) { ------------------ | Branch (724:6): [True: 4.48k, False: 2.24k] ------------------ 725| 4.48k| k = 16; 726| 4.48k| x >>= 16; 727| 4.48k| } 728| 6.73k| if (!(x & 0xff)) { ------------------ | Branch (728:6): [True: 2.55k, False: 4.17k] ------------------ 729| 2.55k| k += 8; 730| 2.55k| x >>= 8; 731| 2.55k| } 732| 6.73k| if (!(x & 0xf)) { ------------------ | Branch (732:6): [True: 3.42k, False: 3.30k] ------------------ 733| 3.42k| k += 4; 734| 3.42k| x >>= 4; 735| 3.42k| } 736| 6.73k| if (!(x & 0x3)) { ------------------ | Branch (736:6): [True: 3.22k, False: 3.50k] ------------------ 737| 3.22k| k += 2; 738| 3.22k| x >>= 2; 739| 3.22k| } 740| 6.73k| if (!(x & 1)) { ------------------ | Branch (740:6): [True: 3.93k, False: 2.80k] ------------------ 741| 3.93k| k++; 742| 3.93k| x >>= 1; 743| 3.93k| if (!x) ------------------ | Branch (743:7): [True: 0, False: 3.93k] ------------------ 744| 0| return 32; 745| 3.93k| } 746| 6.73k| *y = x; 747| 6.73k| return k; 748| 6.73k| } jv_dtoa.c:hi0bits: 679| 14.9k|{ 680| 14.9k| int k = 0; 681| | 682| 14.9k| if (!(x & 0xffff0000)) { ------------------ | Branch (682:6): [True: 9.60k, False: 5.37k] ------------------ 683| 9.60k| k = 16; 684| 9.60k| x <<= 16; 685| 9.60k| } 686| 14.9k| if (!(x & 0xff000000)) { ------------------ | Branch (686:6): [True: 9.71k, False: 5.26k] ------------------ 687| 9.71k| k += 8; 688| 9.71k| x <<= 8; 689| 9.71k| } 690| 14.9k| if (!(x & 0xf0000000)) { ------------------ | Branch (690:6): [True: 10.3k, False: 4.64k] ------------------ 691| 10.3k| k += 4; 692| 10.3k| x <<= 4; 693| 10.3k| } 694| 14.9k| if (!(x & 0xc0000000)) { ------------------ | Branch (694:6): [True: 9.94k, False: 5.03k] ------------------ 695| 9.94k| k += 2; 696| 9.94k| x <<= 2; 697| 9.94k| } 698| 14.9k| if (!(x & 0x80000000)) { ------------------ | Branch (698:6): [True: 8.78k, False: 6.19k] ------------------ 699| 8.78k| k++; 700| 8.78k| if (!(x & 0x40000000)) ------------------ | Branch (700:7): [True: 0, False: 8.78k] ------------------ 701| 0| return 32; 702| 8.78k| } 703| 14.9k| return k; 704| 14.9k| } jv_dtoa.c:i2b: 753| 20.4k|{ 754| 20.4k| Bigint *b; 755| | 756| 20.4k| b = Balloc(C, 1); 757| 20.4k| b->x[0] = i; 758| 20.4k| b->wds = 1; 759| 20.4k| return b; 760| 20.4k| } jv_dtoa.c:pow5mult: 872| 12.8k|{ 873| 12.8k| Bigint *b1, *p5, *p51; 874| 12.8k| int i; 875| 12.8k| static const int p05[3] = { 5, 25, 125 }; 876| | 877| 12.8k| if ((i = k & 3)) ------------------ | Branch (877:6): [True: 8.00k, False: 4.82k] ------------------ 878| 8.00k| b = multadd(C, b, p05[i-1], 0); 879| | 880| 12.8k| if (!(k >>= 2)) ------------------ | Branch (880:6): [True: 1.55k, False: 11.2k] ------------------ 881| 1.55k| return b; 882| 11.2k| if (!(p5 = C->p5s)) { ------------------ | Branch (882:6): [True: 1, False: 11.2k] ------------------ 883| | /* first time */ 884| 1| p5 = C->p5s = i2b(C, 625); 885| 1| p5->next = 0; 886| 1| } 887| 56.3k| for(;;) { 888| 56.3k| if (k & 1) { ------------------ | Branch (888:7): [True: 32.9k, False: 23.3k] ------------------ 889| 32.9k| b1 = mult(C, b, p5); 890| 32.9k| Bfree(C, b); 891| 32.9k| b = b1; 892| 32.9k| } 893| 56.3k| if (!(k >>= 1)) ------------------ | Branch (893:7): [True: 11.2k, False: 45.0k] ------------------ 894| 11.2k| break; 895| 45.0k| if (!(p51 = p5->next)) { ------------------ | Branch (895:7): [True: 6, False: 45.0k] ------------------ 896| 6| p51 = p5->next = mult(C, p5,p5); 897| 6| p51->next = 0; 898| 6| } 899| 45.0k| p5 = p51; 900| 45.0k| } 901| 11.2k| return b; 902| 12.8k| } jv_dtoa.c:mult: 765| 40.3k|{ 766| 40.3k| Bigint *c; 767| 40.3k| int k, wa, wb, wc; 768| 40.3k| ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0; 769| 40.3k| ULong y; 770| 40.3k|#ifdef ULLong 771| 40.3k| ULLong carry, z; ------------------ | | 506| 40.3k|#define ULLong unsigned Llong ------------------ 772| |#else 773| | ULong carry, z; 774| |#ifdef Pack_32 775| | ULong z2; 776| |#endif 777| |#endif 778| | 779| 40.3k| if (a->wds < b->wds) { ------------------ | Branch (779:6): [True: 18.5k, False: 21.8k] ------------------ 780| 18.5k| c = a; 781| 18.5k| a = b; 782| 18.5k| b = c; 783| 18.5k| } 784| 40.3k| k = a->k; 785| 40.3k| wa = a->wds; 786| 40.3k| wb = b->wds; 787| 40.3k| wc = wa + wb; 788| 40.3k| if (wc > a->maxwds) ------------------ | Branch (788:6): [True: 14.6k, False: 25.7k] ------------------ 789| 14.6k| k++; 790| 40.3k| c = Balloc(C, k); 791| 387k| for(x = c->x, xa = x + wc; x < xa; x++) ------------------ | Branch (791:29): [True: 347k, False: 40.3k] ------------------ 792| 347k| *x = 0; 793| 40.3k| xa = a->x; 794| 40.3k| xae = xa + wa; 795| 40.3k| xb = b->x; 796| 40.3k| xbe = xb + wb; 797| 40.3k| xc0 = c->x; 798| 40.3k|#ifdef ULLong 799| 114k| for(; xb < xbe; xc0++) { ------------------ | Branch (799:8): [True: 74.5k, False: 40.3k] ------------------ 800| 74.5k| if ((y = *xb++)) { ------------------ | Branch (800:7): [True: 74.3k, False: 132] ------------------ 801| 74.3k| x = xa; 802| 74.3k| xc = xc0; 803| 74.3k| carry = 0; 804| 739k| do { 805| 739k| z = *x++ * (ULLong)y + *xc + carry; 806| 739k| carry = z >> 32; 807| 739k| *xc++ = z & FFFFFFFF; ------------------ | | 489| 739k|#define FFFFFFFF 0xffffffffUL ------------------ 808| 739k| } 809| 739k| while(x < xae); ------------------ | Branch (809:11): [True: 665k, False: 74.3k] ------------------ 810| 74.3k| *xc = carry; 811| 74.3k| } 812| 74.5k| } 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| 69.1k| for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ; ------------------ | Branch (863:33): [True: 69.1k, False: 0] | Branch (863:43): [True: 28.7k, False: 40.3k] ------------------ 864| 40.3k| c->wds = wc; 865| 40.3k| return c; 866| 40.3k| } jv_dtoa.c:lshift: 907| 37.5k|{ 908| 37.5k| int i, k1, n, n1; 909| 37.5k| Bigint *b1; 910| 37.5k| ULong *x, *x1, *xe, z; 911| | 912| 37.5k|#ifdef Pack_32 913| 37.5k| n = k >> 5; 914| |#else 915| | n = k >> 4; 916| |#endif 917| 37.5k| k1 = b->k; 918| 37.5k| n1 = n + b->wds + 1; 919| 86.2k| for(i = b->maxwds; n1 > i; i <<= 1) ------------------ | Branch (919:21): [True: 48.6k, False: 37.5k] ------------------ 920| 48.6k| k1++; 921| 37.5k| b1 = Balloc(C, k1); 922| 37.5k| x1 = b1->x; 923| 218k| for(i = 0; i < n; i++) ------------------ | Branch (923:13): [True: 181k, False: 37.5k] ------------------ 924| 181k| *x1++ = 0; 925| 37.5k| x = b->x; 926| 37.5k| xe = x + b->wds; 927| 37.5k|#ifdef Pack_32 928| 37.5k| if (k &= 0x1f) { ------------------ | Branch (928:6): [True: 37.2k, False: 360] ------------------ 929| 37.2k| k1 = 32 - k; 930| 37.2k| z = 0; 931| 226k| do { 932| 226k| *x1++ = *x << k | z; 933| 226k| z = *x++ >> k1; 934| 226k| } 935| 226k| while(x < xe); ------------------ | Branch (935:10): [True: 188k, False: 37.2k] ------------------ 936| 37.2k| if ((*x1 = z)) ------------------ | Branch (936:7): [True: 3.03k, False: 34.1k] ------------------ 937| 3.03k| ++n1; 938| 37.2k| } 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| 360| else do 953| 3.71k| *x1++ = *x++; 954| 3.71k| while(x < xe); ------------------ | Branch (954:9): [True: 3.35k, False: 360] ------------------ 955| 37.5k| b1->wds = n1 - 1; 956| 37.5k| Bfree(C, b); 957| 37.5k| return b1; 958| 37.5k| } jv_dtoa.c:diff: 993| 67.4k|{ 994| 67.4k| Bigint *c; 995| 67.4k| int i, wa, wb; 996| 67.4k| ULong *xa, *xae, *xb, *xbe, *xc; 997| 67.4k|#ifdef ULLong 998| 67.4k| ULLong borrow, y; ------------------ | | 506| 67.4k|#define ULLong unsigned Llong ------------------ 999| |#else 1000| | ULong borrow, y; 1001| |#ifdef Pack_32 1002| | ULong z; 1003| |#endif 1004| |#endif 1005| | 1006| 67.4k| i = cmp(C, a,b); 1007| 67.4k| if (!i) { ------------------ | Branch (1007:6): [True: 158, False: 67.2k] ------------------ 1008| 158| c = Balloc(C, 0); 1009| 158| c->wds = 1; 1010| 158| c->x[0] = 0; 1011| 158| return c; 1012| 158| } 1013| 67.2k| if (i < 0) { ------------------ | Branch (1013:6): [True: 5.10k, False: 62.1k] ------------------ 1014| 5.10k| c = a; 1015| 5.10k| a = b; 1016| 5.10k| b = c; 1017| 5.10k| i = 1; 1018| 5.10k| } 1019| 62.1k| else 1020| 62.1k| i = 0; 1021| 67.2k| c = Balloc(C, a->k); 1022| 67.2k| c->sign = i; 1023| 67.2k| wa = a->wds; 1024| 67.2k| xa = a->x; 1025| 67.2k| xae = xa + wa; 1026| 67.2k| wb = b->wds; 1027| 67.2k| xb = b->x; 1028| 67.2k| xbe = xb + wb; 1029| 67.2k| xc = c->x; 1030| 67.2k| borrow = 0; 1031| 67.2k|#ifdef ULLong 1032| 744k| do { 1033| 744k| y = (ULLong)*xa++ - *xb++ - borrow; 1034| 744k| borrow = y >> 32 & (ULong)1; 1035| 744k| *xc++ = y & FFFFFFFF; ------------------ | | 489| 744k|#define FFFFFFFF 0xffffffffUL ------------------ 1036| 744k| } 1037| 744k| while(xb < xbe); ------------------ | Branch (1037:9): [True: 677k, False: 67.2k] ------------------ 1038| 97.1k| while(xa < xae) { ------------------ | Branch (1038:8): [True: 29.8k, False: 67.2k] ------------------ 1039| 29.8k| y = *xa++ - borrow; 1040| 29.8k| borrow = y >> 32 & (ULong)1; 1041| 29.8k| *xc++ = y & FFFFFFFF; ------------------ | | 489| 29.8k|#define FFFFFFFF 0xffffffffUL ------------------ 1042| 29.8k| } 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| 77.3k| while(!*--xc) ------------------ | Branch (1074:8): [True: 10.0k, False: 67.2k] ------------------ 1075| 10.0k| wa--; 1076| 67.2k| c->wds = wa; 1077| 67.2k| return c; 1078| 67.4k| } jv_dtoa.c:cmp: 963| 257k|{ 964| 257k| ULong *xa, *xa0, *xb, *xb0; 965| 257k| int i, j; 966| | 967| 257k| i = a->wds; 968| 257k| 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| 257k| if (i -= j) ------------------ | Branch (975:6): [True: 61.6k, False: 195k] ------------------ 976| 61.6k| return i; 977| 195k| xa0 = a->x; 978| 195k| xa = xa0 + j; 979| 195k| xb0 = b->x; 980| 195k| xb = xb0 + j; 981| 207k| for(;;) { 982| 207k| if (*--xa != *--xb) ------------------ | Branch (982:7): [True: 192k, False: 15.1k] ------------------ 983| 192k| return *xa < *xb ? -1 : 1; ------------------ | Branch (983:11): [True: 122k, False: 70.1k] ------------------ 984| 15.1k| if (xa <= xa0) ------------------ | Branch (984:7): [True: 3.13k, False: 12.0k] ------------------ 985| 3.13k| break; 986| 15.1k| } 987| 3.13k| return 0; 988| 195k| } jv_dtoa.c:sulp: 2109| 336|{ 2110| 336| U u; 2111| 336| double rv; 2112| 336| int i; 2113| | 2114| 336| rv = ulp(C, x); 2115| 336| 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: 336, False: 0] | Branch (2115:20): [True: 0, False: 0] ------------------ 2116| 336| 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| 336| } jv_dtoa.c:ratio: 1317| 4.35k|{ 1318| 4.35k| U da, db; 1319| 4.35k| int k, ka, kb; 1320| | 1321| 4.35k| dval(&da) = b2d(C, a, &ka); ------------------ | | 314| 4.35k|#define dval(x) (x)->d ------------------ 1322| 4.35k| dval(&db) = b2d(C, b, &kb); ------------------ | | 314| 4.35k|#define dval(x) (x)->d ------------------ 1323| 4.35k|#ifdef Pack_32 1324| 4.35k| 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| 4.35k| if (k > 0) ------------------ | Branch (1341:6): [True: 2.80k, False: 1.54k] ------------------ 1342| 2.80k| word0(&da) += k*Exp_msk1; ------------------ | | 308| 2.80k|#define word0(x) (x)->L[1] ------------------ word0(&da) += k*Exp_msk1; ------------------ | | 347| 2.80k|#define Exp_msk1 0x100000 ------------------ 1343| 1.54k| else { 1344| 1.54k| k = -k; 1345| 1.54k| word0(&db) += k*Exp_msk1; ------------------ | | 308| 1.54k|#define word0(x) (x)->L[1] ------------------ word0(&db) += k*Exp_msk1; ------------------ | | 347| 1.54k|#define Exp_msk1 0x100000 ------------------ 1346| 1.54k| } 1347| 4.35k|#endif 1348| 4.35k| return dval(&da) / dval(&db); ------------------ | | 314| 4.35k|#define dval(x) (x)->d ------------------ return dval(&da) / dval(&db); ------------------ | | 314| 4.35k|#define dval(x) (x)->d ------------------ 1349| 4.35k| } jv_dtoa.c:b2d: 1121| 8.70k|{ 1122| 8.70k| ULong *xa, *xa0, w, y, z; 1123| 8.70k| int k; 1124| 8.70k| U d; 1125| |#ifdef VAX 1126| | ULong d0, d1; 1127| |#else 1128| 8.70k|#define d0 word0(&d) 1129| 8.70k|#define d1 word1(&d) 1130| 8.70k|#endif 1131| | 1132| 8.70k| xa0 = a->x; 1133| 8.70k| xa = xa0 + a->wds; 1134| 8.70k| y = *--xa; 1135| |#ifdef DEBUG 1136| | if (!y) Bug("zero y in b2d"); 1137| |#endif 1138| 8.70k| k = hi0bits(C, y); 1139| 8.70k| *e = 32 - k; 1140| 8.70k|#ifdef Pack_32 1141| 8.70k| if (k < Ebits) { ------------------ | | 357| 8.70k|#define Ebits 11 ------------------ | Branch (1141:6): [True: 2.66k, False: 6.03k] ------------------ 1142| 2.66k| d0 = Exp_1 | y >> (Ebits - k); ------------------ | | 1128| 2.66k|#define d0 word0(&d) | | ------------------ | | | | 308| 2.66k|#define word0(x) (x)->L[1] | | ------------------ ------------------ d0 = Exp_1 | y >> (Ebits - k); ------------------ | | 355| 2.66k|#define Exp_1 0x3ff00000 ------------------ d0 = Exp_1 | y >> (Ebits - k); ------------------ | | 357| 2.66k|#define Ebits 11 ------------------ 1143| 2.66k| w = xa > xa0 ? *--xa : 0; ------------------ | Branch (1143:7): [True: 1.93k, False: 726] ------------------ 1144| 2.66k| d1 = y << ((32-Ebits) + k) | w >> (Ebits - k); ------------------ | | 1129| 2.66k|#define d1 word1(&d) | | ------------------ | | | | 309| 2.66k|#define word1(x) (x)->L[0] | | ------------------ ------------------ d1 = y << ((32-Ebits) + k) | w >> (Ebits - k); ------------------ | | 357| 2.66k|#define Ebits 11 ------------------ d1 = y << ((32-Ebits) + k) | w >> (Ebits - k); ------------------ | | 357| 2.66k|#define Ebits 11 ------------------ 1145| 2.66k| goto ret_d; 1146| 2.66k| } 1147| 6.03k| z = xa > xa0 ? *--xa : 0; ------------------ | Branch (1147:6): [True: 3.88k, False: 2.15k] ------------------ 1148| 6.03k| if (k -= Ebits) { ------------------ | | 357| 6.03k|#define Ebits 11 ------------------ | Branch (1148:6): [True: 5.74k, False: 294] ------------------ 1149| 5.74k| d0 = Exp_1 | y << k | z >> (32 - k); ------------------ | | 1128| 5.74k|#define d0 word0(&d) | | ------------------ | | | | 308| 5.74k|#define word0(x) (x)->L[1] | | ------------------ ------------------ d0 = Exp_1 | y << k | z >> (32 - k); ------------------ | | 355| 5.74k|#define Exp_1 0x3ff00000 ------------------ 1150| 5.74k| y = xa > xa0 ? *--xa : 0; ------------------ | Branch (1150:7): [True: 2.12k, False: 3.61k] ------------------ 1151| 5.74k| d1 = z << k | y >> (32 - k); ------------------ | | 1129| 5.74k|#define d1 word1(&d) | | ------------------ | | | | 309| 5.74k|#define word1(x) (x)->L[0] | | ------------------ ------------------ 1152| 5.74k| } 1153| 294| else { 1154| 294| d0 = Exp_1 | y; ------------------ | | 1128| 294|#define d0 word0(&d) | | ------------------ | | | | 308| 294|#define word0(x) (x)->L[1] | | ------------------ ------------------ d0 = Exp_1 | y; ------------------ | | 355| 294|#define Exp_1 0x3ff00000 ------------------ 1155| 294| d1 = z; ------------------ | | 1129| 294|#define d1 word1(&d) | | ------------------ | | | | 309| 294|#define word1(x) (x)->L[0] | | ------------------ ------------------ 1156| 294| } 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| 8.70k| ret_d: 1174| |#ifdef VAX 1175| | word0(&d) = d0 >> 16 | d0 << 16; 1176| | word1(&d) = d1 >> 16 | d1 << 16; 1177| |#else 1178| 8.70k|#undef d0 1179| 8.70k|#undef d1 1180| 8.70k|#endif 1181| 8.70k| return dval(&d); ------------------ | | 314| 8.70k|#define dval(x) (x)->d ------------------ 1182| 6.03k| } jv_dtoa.c:ulp: 1083| 4.68k|{ 1084| 4.68k| Long L; ------------------ | | 193| 4.68k|#define Long int ------------------ 1085| 4.68k| U u; 1086| | 1087| 4.68k| L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 308| 4.68k|#define word0(x) (x)->L[1] ------------------ L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 349| 4.68k|#define Exp_mask 0x7ff00000 ------------------ L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 350| 4.68k|#define P 53 ------------------ L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; ------------------ | | 347| 4.68k|#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| 4.68k| word0(&u) = L; ------------------ | | 308| 4.68k|#define word0(x) (x)->L[1] ------------------ 1097| 4.68k| word1(&u) = 0; ------------------ | | 309| 4.68k|#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| 4.68k| return dval(&u); ------------------ | | 314| 4.68k|#define dval(x) (x)->d ------------------ 1116| 4.68k| } jv_dtoa.c:nrv_alloc: 3412| 642|{ 3413| 642| char *rv, *t; 3414| | 3415| 642| t = rv = rv_alloc(C, n); 3416| 1.28k| while((*t = *s++)) t++; ------------------ | Branch (3416:8): [True: 642, False: 642] ------------------ 3417| 642| if (rve) ------------------ | Branch (3417:6): [True: 642, False: 0] ------------------ 3418| 642| *rve = t; 3419| 642| return rv; 3420| 642| } jv_dtoa.c:rv_alloc: 3396| 7.16k|{ 3397| 7.16k| int j, k, *r; 3398| | 3399| 7.16k| j = sizeof(ULong); 3400| 7.16k| for(k = 0; 3401| 7.16k| (int)(sizeof(Bigint) - sizeof(ULong) - sizeof(int)) + j <= i; ------------------ | Branch (3401:13): [True: 0, False: 7.16k] ------------------ 3402| 7.16k| j <<= 1) 3403| 0| k++; 3404| 7.16k| r = (int*)Balloc(C, k); 3405| 7.16k| *r = k; 3406| 7.16k| return 3407| 7.16k| (char *)(r+1); 3408| 7.16k| } jv_dtoa.c:dshift: 1978| 5.51k|{ 1979| 5.51k| int rv = hi0bits(C, b->x[b->wds-1]) - 4; 1980| 5.51k| if (p2 > 0) ------------------ | Branch (1980:6): [True: 3.47k, False: 2.03k] ------------------ 1981| 3.47k| rv -= p2; 1982| 5.51k| return rv & kmask; ------------------ | | 1518| 5.51k|#define kmask 31 ------------------ 1983| 5.51k| } jv_dtoa.c:multadd: 592| 144k|{ 593| 144k| int i, wds; 594| 144k|#ifdef ULLong 595| 144k| ULong *x; 596| 144k| ULLong carry, y; ------------------ | | 506| 144k|#define ULLong unsigned Llong ------------------ 597| |#else 598| | ULong carry, *x, y; 599| |#ifdef Pack_32 600| | ULong xi, z; 601| |#endif 602| |#endif 603| 144k| Bigint *b1; 604| | 605| 144k| wds = b->wds; 606| 144k| x = b->x; 607| 144k| i = 0; 608| 144k| carry = a; 609| 1.26M| do { 610| 1.26M|#ifdef ULLong 611| 1.26M| y = *x * (ULLong)m + carry; 612| 1.26M| carry = y >> 32; 613| 1.26M| *x++ = y & FFFFFFFF; ------------------ | | 489| 1.26M|#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.26M| } 628| 1.26M| while(++i < wds); ------------------ | Branch (628:9): [True: 1.11M, False: 144k] ------------------ 629| 144k| if (carry) { ------------------ | Branch (629:6): [True: 7.93k, False: 136k] ------------------ 630| 7.93k| if (wds >= b->maxwds) { ------------------ | Branch (630:7): [True: 754, False: 7.17k] ------------------ 631| 754| b1 = Balloc(C, b->k+1); 632| 754| Bcopy(b1, b); ------------------ | | 586| 754|#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ | | 587| 754|y->wds*sizeof(Long) + 2*sizeof(int)) ------------------ 633| 754| Bfree(C, b); 634| 754| b = b1; 635| 754| } 636| 7.93k| b->x[wds++] = carry; 637| 7.93k| b->wds = wds; 638| 7.93k| } 639| 144k| return b; 640| 144k| } jv_dtoa.c:quorem: 1988| 58.0k|{ 1989| 58.0k| int n; 1990| 58.0k| ULong *bx, *bxe, q, *sx, *sxe; 1991| 58.0k|#ifdef ULLong 1992| 58.0k| ULLong borrow, carry, y, ys; ------------------ | | 506| 58.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| 58.0k| n = S->wds; 2001| |#ifdef DEBUG 2002| | /*debug*/ if (b->wds > n) 2003| | /*debug*/ Bug("oversize b in quorem"); 2004| |#endif 2005| 58.0k| if (b->wds < n) ------------------ | Branch (2005:6): [True: 396, False: 57.6k] ------------------ 2006| 396| return 0; 2007| 57.6k| sx = S->x; 2008| 57.6k| sxe = sx + --n; 2009| 57.6k| bx = b->x; 2010| 57.6k| bxe = bx + n; 2011| 57.6k| 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| 57.6k| if (q) { ------------------ | Branch (2022:6): [True: 49.2k, False: 8.45k] ------------------ 2023| 49.2k| borrow = 0; 2024| 49.2k| carry = 0; 2025| 578k| do { 2026| 578k|#ifdef ULLong 2027| 578k| ys = *sx++ * (ULLong)q + carry; 2028| 578k| carry = ys >> 32; 2029| 578k| y = *bx - (ys & FFFFFFFF) - borrow; ------------------ | | 489| 578k|#define FFFFFFFF 0xffffffffUL ------------------ 2030| 578k| borrow = y >> 32 & (ULong)1; 2031| 578k| *bx++ = y & FFFFFFFF; ------------------ | | 489| 578k|#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| 578k| } 2052| 578k| while(sx <= sxe); ------------------ | Branch (2052:10): [True: 528k, False: 49.2k] ------------------ 2053| 49.2k| if (!*bxe) { ------------------ | Branch (2053:7): [True: 325, False: 48.8k] ------------------ 2054| 325| bx = b->x; 2055| 325| while(--bxe > bx && !*bxe) ------------------ | Branch (2055:10): [True: 197, False: 128] | Branch (2055:24): [True: 0, False: 197] ------------------ 2056| 0| --n; 2057| 325| b->wds = n; 2058| 325| } 2059| 49.2k| } 2060| 57.6k| if (cmp(C, b, S) >= 0) { ------------------ | Branch (2060:6): [True: 1.82k, False: 55.8k] ------------------ 2061| 1.82k| q++; 2062| 1.82k| borrow = 0; 2063| 1.82k| carry = 0; 2064| 1.82k| bx = b->x; 2065| 1.82k| sx = S->x; 2066| 16.5k| do { 2067| 16.5k|#ifdef ULLong 2068| 16.5k| ys = *sx++ + carry; 2069| 16.5k| carry = ys >> 32; 2070| 16.5k| y = *bx - (ys & FFFFFFFF) - borrow; ------------------ | | 489| 16.5k|#define FFFFFFFF 0xffffffffUL ------------------ 2071| 16.5k| borrow = y >> 32 & (ULong)1; 2072| 16.5k| *bx++ = y & FFFFFFFF; ------------------ | | 489| 16.5k|#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| 16.5k| } 2093| 16.5k| while(sx <= sxe); ------------------ | Branch (2093:10): [True: 14.7k, False: 1.82k] ------------------ 2094| 1.82k| bx = b->x; 2095| 1.82k| bxe = bx + n; 2096| 1.82k| if (!*bxe) { ------------------ | Branch (2096:7): [True: 1.60k, False: 219] ------------------ 2097| 1.73k| while(--bxe > bx && !*bxe) ------------------ | Branch (2097:10): [True: 672, False: 1.06k] | Branch (2097:24): [True: 131, False: 541] ------------------ 2098| 131| --n; 2099| 1.60k| b->wds = n; 2100| 1.60k| } 2101| 1.82k| } 2102| 57.6k| return q; 2103| 58.0k| } tsd_dtoa_context_get: 39| 137k|inline struct dtoa_context *tsd_dtoa_context_get(void) { 40| 137k| pthread_once(&dtoa_ctx_once, jv_tsd_dtoa_ctx_init); // cannot fail 41| 137k| struct dtoa_context *ctx = (struct dtoa_context*)pthread_getspecific(dtoa_ctx_key); 42| 137k| if (!ctx) { ------------------ | Branch (42:7): [True: 1, False: 137k] ------------------ 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| 137k| return ctx; 52| 137k|} 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: 736| 504k|void jv_parser_set_buf(struct jv_parser* p, const char* buf, int length, int is_partial) { 737| 504k| assert((p->curr_buf == 0 || p->curr_buf_pos == p->curr_buf_length) ------------------ | Branch (737:3): [True: 504k, False: 0] | Branch (737:3): [True: 0, False: 0] | Branch (737:3): [True: 0, False: 0] | Branch (737:3): [True: 504k, False: 0] | Branch (737:3): [True: 0, False: 0] | Branch (737:3): [True: 504k, False: 0] ------------------ 738| 504k| && "previous buffer not exhausted"); 739| 504k| p->curr_buf = buf; 740| 504k| p->curr_buf_length = length; 741| 504k| p->curr_buf_pos = 0; 742| 504k| p->curr_buf_is_partial = is_partial; 743| 504k|} jv_parser_next: 757| 813k|jv jv_parser_next(struct jv_parser* p) { 758| 813k| if (p->eof) ------------------ | Branch (758:7): [True: 307k, False: 505k] ------------------ 759| 307k| return jv_invalid(); 760| 505k| if (!p->curr_buf) ------------------ | Branch (760:7): [True: 0, False: 505k] ------------------ 761| 0| return jv_invalid(); // Need a buffer 762| 505k| jv value = jv_invalid(); 763| 505k| if ((p->flags & JV_PARSE_STREAMING) && stream_check_done(p, &value)) ------------------ | Branch (763:7): [True: 0, False: 505k] | Branch (763:42): [True: 0, False: 0] ------------------ 764| 0| return value; 765| 505k| char ch; 766| 505k| presult msg = 0; 767| 21.6M| while (!msg && p->curr_buf_pos < p->curr_buf_length) { ------------------ | Branch (767:10): [True: 21.4M, False: 171k] | Branch (767:18): [True: 21.1M, False: 334k] ------------------ 768| 21.1M| ch = p->curr_buf[p->curr_buf_pos++]; 769| 21.1M| if (p->st == JV_PARSER_WAITING_FOR_RS) { ------------------ | Branch (769:9): [True: 0, False: 21.1M] ------------------ 770| 0| if (ch == '\n') { ------------------ | Branch (770:11): [True: 0, False: 0] ------------------ 771| 0| p->line++; 772| 0| p->column = 0; 773| 0| } else { 774| 0| p->column++; 775| 0| } 776| 0| if (ch == '\036') ------------------ | Branch (776:11): [True: 0, False: 0] ------------------ 777| 0| p->st = JV_PARSER_NORMAL; 778| 0| continue; // need to resync, wait for RS 779| 0| } 780| 21.1M| msg = scan(p, ch, &value); 781| 21.1M| } 782| 505k| if (msg == OK) { ------------------ | Branch (782:7): [True: 1.86k, False: 504k] ------------------ 783| 1.86k| return value; 784| 504k| } else if (msg) { ------------------ | Branch (784:14): [True: 169k, False: 334k] ------------------ 785| 169k| jv_free(value); 786| 169k| if (ch != '\036' && (p->flags & JV_PARSE_SEQ)) { ------------------ | Branch (786:9): [True: 169k, False: 0] | Branch (786:25): [True: 0, False: 169k] ------------------ 787| | // Skip to the next RS 788| 0| value = make_error(p, "%s at line %d, column %d (need RS to resync)", msg, p->line, p->column); 789| 0| parser_reset(p); 790| 0| p->st = JV_PARSER_WAITING_FOR_RS; 791| 0| return value; 792| 0| } 793| 169k| value = make_error(p, "%s at line %d, column %d", msg, p->line, p->column); 794| 169k| parser_reset(p); 795| 169k| if (!(p->flags & JV_PARSE_SEQ)) { ------------------ | Branch (795:9): [True: 169k, False: 0] ------------------ 796| | // We're not parsing a JSON text sequence; throw this buffer away. 797| | // XXX We should fail permanently here. 798| 169k| p->curr_buf = 0; 799| 169k| p->curr_buf_pos = 0; 800| 169k| } // Else ch must be RS; don't clear buf so we can start parsing again after this ch 801| 169k| return value; 802| 334k| } else if (p->curr_buf_is_partial) { ------------------ | Branch (802:14): [True: 0, False: 334k] ------------------ 803| 0| assert(p->curr_buf_pos == p->curr_buf_length); ------------------ | Branch (803:5): [True: 0, False: 0] | Branch (803:5): [True: 0, False: 0] ------------------ 804| | // need another buffer 805| 0| return jv_invalid(); 806| 334k| } else { 807| | // at EOF 808| 334k| p->eof = 1; 809| 334k| assert(p->curr_buf_pos == p->curr_buf_length); ------------------ | Branch (809:5): [True: 0, False: 334k] | Branch (809:5): [True: 334k, False: 0] ------------------ 810| 334k| jv_free(value); 811| 334k| if (p->st == JV_PARSER_WAITING_FOR_RS) ------------------ | Branch (811:9): [True: 0, False: 334k] ------------------ 812| 0| return make_error(p, "Unfinished abandoned text at EOF at line %d, column %d", p->line, p->column); 813| 334k| if (p->st != JV_PARSER_NORMAL) { ------------------ | Branch (813:9): [True: 24.8k, False: 309k] ------------------ 814| 24.8k| value = make_error(p, "Unfinished string at EOF at line %d, column %d", p->line, p->column); 815| 24.8k| parser_reset(p); 816| 24.8k| p->st = JV_PARSER_WAITING_FOR_RS; 817| 24.8k| return value; 818| 24.8k| } 819| 309k| if ((msg = check_literal(p))) { ------------------ | Branch (819:9): [True: 0, False: 309k] ------------------ 820| 0| value = make_error(p, "%s at EOF at line %d, column %d", msg, p->line, p->column); 821| 0| parser_reset(p); 822| 0| p->st = JV_PARSER_WAITING_FOR_RS; 823| 0| return value; 824| 0| } 825| 309k| if (((p->flags & JV_PARSE_STREAMING) && p->stacklen != 0) || ------------------ | Branch (825:10): [True: 0, False: 309k] | Branch (825:45): [True: 0, False: 0] ------------------ 826| 309k| (!(p->flags & JV_PARSE_STREAMING) && p->stackpos != 0)) { ------------------ | Branch (826:10): [True: 309k, False: 0] | Branch (826:46): [True: 0, False: 309k] ------------------ 827| 0| value = make_error(p, "Unfinished JSON term at EOF at line %d, column %d", p->line, p->column); 828| 0| parser_reset(p); 829| 0| p->st = JV_PARSER_WAITING_FOR_RS; 830| 0| return value; 831| 0| } 832| | // p->next is either invalid (nothing here, but no syntax error) 833| | // or valid (this is the value). either way it's the thing to return 834| 309k| if ((p->flags & JV_PARSE_STREAMING) && jv_is_valid(p->next)) { ------------------ | Branch (834:9): [True: 0, False: 309k] | Branch (834:44): [True: 0, False: 0] ------------------ 835| 0| value = JV_ARRAY(jv_copy(p->path), p->next); // except in streaming mode we've got to make it [path,value] ------------------ | | 120| 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__) | | ------------------ | | | | 118| 0|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 120| 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__) | | | | | | ------------------ | | | | | | | | 110| 0|#define JV_ARRAY_2(e1,e2) (jv_array_append(JV_ARRAY_1(e1),e2)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 836| 309k| } else { 837| 309k| value = p->next; 838| 309k| } 839| 309k| p->next = jv_invalid(); 840| 309k| if ((p->flags & JV_PARSE_SEQ) && !p->last_ch_was_ws && jv_get_kind(value) == JV_KIND_NUMBER) { ------------------ | Branch (840:9): [True: 0, False: 309k] | Branch (840:38): [True: 0, False: 0] | Branch (840:60): [True: 0, False: 0] ------------------ 841| 0| jv_free(value); 842| 0| return make_error(p, "Potentially truncated top-level numeric value at EOF at line %d, column %d", p->line, p->column); 843| 0| } 844| 309k| return value; 845| 309k| } 846| 505k|} jv_parse_sized_custom_flags: 848| 504k|jv jv_parse_sized_custom_flags(const char* string, int length, int flags) { 849| 504k| struct jv_parser parser; 850| 504k| parser_init(&parser, flags); 851| 504k| jv_parser_set_buf(&parser, string, length, 0); 852| 504k| jv value = jv_parser_next(&parser); 853| 504k| if (jv_is_valid(value)) { ------------------ | Branch (853:7): [True: 309k, False: 194k] ------------------ 854| 309k| jv next = jv_parser_next(&parser); 855| 309k| if (jv_is_valid(next)) { ------------------ | Branch (855:9): [True: 0, False: 309k] ------------------ 856| | // multiple JSON values, we only wanted one 857| 0| jv_free(value); 858| 0| jv_free(next); 859| 0| value = jv_invalid_with_msg(jv_string("Unexpected extra JSON values")); 860| 309k| } else if (jv_invalid_has_msg(jv_copy(next))) { ------------------ | Branch (860:16): [True: 0, False: 309k] ------------------ 861| | // parser error after the first JSON value 862| 0| jv_free(value); 863| 0| value = next; 864| 309k| } else { 865| | // a single valid JSON value 866| 309k| jv_free(next); 867| 309k| } 868| 309k| } else if (jv_invalid_has_msg(jv_copy(value))) { ------------------ | Branch (868:14): [True: 194k, False: 0] ------------------ 869| | // parse error, we'll return it 870| 194k| } else { 871| | // no value at all 872| 0| jv_free(value); 873| 0| value = jv_invalid_with_msg(jv_string("Expected JSON value")); 874| 0| } 875| 504k| parser_free(&parser); 876| | 877| 504k| if (!jv_is_valid(value) && jv_invalid_has_msg(jv_copy(value))) { ------------------ | Branch (877:7): [True: 194k, False: 309k] | Branch (877:30): [True: 194k, False: 0] ------------------ 878| 194k| jv msg = jv_invalid_get_msg(value); 879| 194k| value = jv_invalid_with_msg(jv_string_fmt("%s (while parsing '%.*s')", 880| 194k| jv_string_value(msg), 881| 194k| length, 882| 194k| string)); 883| 194k| jv_free(msg); 884| 194k| } 885| 504k| return value; 886| 504k|} jv_parse_sized: 888| 504k|jv jv_parse_sized(const char* string, int length) { 889| 504k| return jv_parse_sized_custom_flags(string, length, 0); 890| 504k|} jv_parse.c:parser_init: 69| 504k|static void parser_init(struct jv_parser* p, int flags) { 70| 504k| p->flags = flags; 71| 504k| if ((p->flags & JV_PARSE_STREAMING)) { ------------------ | Branch (71:7): [True: 0, False: 504k] ------------------ 72| 0| p->path = jv_array(); 73| 504k| } else { 74| 504k| p->path = jv_invalid(); 75| 504k| p->flags &= ~(JV_PARSE_STREAM_ERRORS); 76| 504k| } 77| 504k| p->stack = 0; 78| 504k| p->stacklen = p->stackpos = 0; 79| 504k| p->last_seen = JV_LAST_NONE; 80| 504k| p->output = jv_invalid(); 81| 504k| p->next = jv_invalid(); 82| 504k| p->tokenlen = 256; 83| 504k| p->tokenbuf = jv_mem_alloc(p->tokenlen); 84| 504k| p->tokenpos = 0; 85| 504k| if ((p->flags & JV_PARSE_SEQ)) ------------------ | Branch (85:7): [True: 0, False: 504k] ------------------ 86| 0| p->st = JV_PARSER_WAITING_FOR_RS; 87| 504k| else 88| 504k| p->st = JV_PARSER_NORMAL; 89| 504k| p->eof = 0; 90| 504k| p->curr_buf = 0; 91| 504k| p->curr_buf_length = p->curr_buf_pos = p->curr_buf_is_partial = 0; 92| 504k| p->last_ch_was_ws = 0; 93| 504k| p->line = 1; 94| 504k| p->column = 0; 95| 504k| jvp_dtoa_context_init(&p->dtoa); 96| 504k|} jv_parse.c:parser_free: 116| 504k|static void parser_free(struct jv_parser* p) { 117| 504k| parser_reset(p); 118| 504k| jv_free(p->path); 119| 504k| jv_free(p->output); 120| 504k| jv_mem_free(p->stack); 121| 504k| jv_mem_free(p->tokenbuf); 122| 504k| jvp_dtoa_context_free(&p->dtoa); 123| 504k|} jv_parse.c:scan: 652| 21.1M|static pfunc scan(struct jv_parser* p, char ch, jv* out) { 653| 21.1M| p->column++; 654| 21.1M| if (ch == '\n') { ------------------ | Branch (654:7): [True: 166k, False: 20.9M] ------------------ 655| 166k| p->line++; 656| 166k| p->column = 0; 657| 166k| } 658| 21.1M| if ((p->flags & JV_PARSE_SEQ) ------------------ | Branch (658:7): [True: 0, False: 21.1M] ------------------ 659| 0| && ch == '\036' /* ASCII RS; see draft-ietf-json-sequence-07 */) { ------------------ | Branch (659:10): [True: 0, False: 0] ------------------ 660| 0| if (check_truncation(p)) { ------------------ | | 647| 0| (((p)->flags & JV_PARSE_STREAMING) ? stream_seq_check_truncation((p)) : seq_check_truncation((p))) | | ------------------ | | | Branch (647:4): [True: 0, False: 0] | | | Branch (647:5): [True: 0, False: 0] | | ------------------ ------------------ 661| 0| if (check_literal(p) == 0 && is_top_num(p)) ------------------ | | 650| 0| (((p)->flags & JV_PARSE_STREAMING) ? stream_is_top_num((p)) : parse_is_top_num((p))) | | ------------------ | | | Branch (650:4): [True: 0, False: 0] | | | Branch (650:5): [True: 0, False: 0] | | ------------------ ------------------ | Branch (661:11): [True: 0, False: 0] ------------------ 662| 0| return "Potentially truncated top-level numeric value"; 663| 0| return "Truncated value"; 664| 0| } 665| 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] | | ------------------ ------------------ 666| 0| if (p->st == JV_PARSER_NORMAL && check_done(p, out)) ------------------ | | 641| 0| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (641:4): [True: 0, False: 0] | | | Branch (641:5): [True: 0, False: 0] | | ------------------ ------------------ | Branch (666:9): [True: 0, False: 0] ------------------ 667| 0| return OK; 668| | // shouldn't happen? 669| 0| assert(!jv_is_valid(*out)); ------------------ | Branch (669:5): [True: 0, False: 0] | Branch (669:5): [True: 0, False: 0] ------------------ 670| 0| parser_reset(p); 671| 0| jv_free(*out); 672| 0| *out = jv_invalid(); 673| 0| return OK; 674| 0| } 675| 21.1M| presult answer = 0; 676| 21.1M| p->last_ch_was_ws = 0; 677| 21.1M| if (p->st == JV_PARSER_NORMAL) { ------------------ | Branch (677:7): [True: 19.7M, False: 1.37M] ------------------ 678| 19.7M| chclass cls = classify(ch); 679| 19.7M| if (cls == WHITESPACE) ------------------ | Branch (679:9): [True: 0, False: 19.7M] ------------------ 680| 0| p->last_ch_was_ws = 1; 681| 19.7M| if (cls != LITERAL) { ------------------ | Branch (681:9): [True: 196k, False: 19.5M] ------------------ 682| 196k| TRY(check_literal(p)); ------------------ | | 18| 196k|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 196k] | | | Branch (18:74): [Folded, False: 196k] | | ------------------ ------------------ 683| 196k| if (check_done(p, out)) answer = OK; ------------------ | | 641| 196k| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (641:4): [True: 0, False: 196k] | | | Branch (641:5): [True: 0, False: 196k] | | ------------------ ------------------ 684| 196k| } 685| 19.7M| switch (cls) { ------------------ | Branch (685:13): [True: 19.7M, False: 0] ------------------ 686| 19.5M| case LITERAL: ------------------ | Branch (686:5): [True: 19.5M, False: 196k] ------------------ 687| 19.5M| TRY(tokenadd(p, ch)); ------------------ | | 18| 19.5M|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 19.5M] | | | Branch (18:74): [Folded, False: 19.5M] | | ------------------ ------------------ 688| 19.5M| break; 689| 19.5M| case WHITESPACE: ------------------ | Branch (689:5): [True: 0, False: 19.7M] ------------------ 690| 0| break; 691| 196k| case QUOTE: ------------------ | Branch (691:5): [True: 196k, False: 19.5M] ------------------ 692| 196k| p->st = JV_PARSER_STRING; 693| 196k| break; 694| 0| case STRUCTURE: ------------------ | Branch (694:5): [True: 0, False: 19.7M] ------------------ 695| 0| TRY(token(p, ch)); ------------------ | | 18| 0|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:37): [True: 0, False: 0] | | | Branch (18:45): [True: 0, False: 0] | | | Branch (18:74): [Folded, False: 0] | | ------------------ ------------------ 696| 0| break; 697| 0| case INVALID: ------------------ | Branch (697:5): [True: 0, False: 19.7M] ------------------ 698| 0| return "Invalid character"; 699| 19.7M| } 700| 19.7M| if (check_done(p, out)) answer = OK; ------------------ | | 641| 19.7M| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (641:4): [True: 0, False: 19.7M] | | | Branch (641:5): [True: 0, False: 19.7M] | | ------------------ ------------------ 701| 19.7M| } else { 702| 1.37M| if (ch == '"' && p->st == JV_PARSER_STRING) { ------------------ | Branch (702:9): [True: 178k, False: 1.19M] | Branch (702:22): [True: 171k, False: 7.23k] ------------------ 703| 171k| TRY(found_string(p)); ------------------ | | 18| 171k|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 169k, False: 1.86k] | | | Branch (18:74): [Folded, False: 1.86k] | | ------------------ ------------------ 704| 1.86k| p->st = JV_PARSER_NORMAL; 705| 1.86k| if (check_done(p, out)) answer = OK; ------------------ | | 641| 1.86k| (((p)->flags & JV_PARSE_STREAMING) ? stream_check_done((p), (o)) : parse_check_done((p), (o))) | | ------------------ | | | Branch (641:4): [True: 1.86k, False: 0] | | | Branch (641:5): [True: 0, False: 1.86k] | | ------------------ ------------------ 706| 1.20M| } else { 707| 1.20M| TRY(tokenadd(p, ch)); ------------------ | | 18| 1.20M|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 1.20M] | | | Branch (18:74): [Folded, False: 1.20M] | | ------------------ ------------------ 708| 1.20M| if (ch == '\\' && p->st == JV_PARSER_STRING) { ------------------ | Branch (708:11): [True: 410k, False: 790k] | Branch (708:25): [True: 408k, False: 1.96k] ------------------ 709| 408k| p->st = JV_PARSER_STRING_ESCAPE; 710| 792k| } else { 711| 792k| p->st = JV_PARSER_STRING; 712| 792k| } 713| 1.20M| } 714| 1.37M| } 715| 20.9M| return answer; 716| 21.1M|} jv_parse.c:parse_check_done: 591| 19.9M|static int parse_check_done(struct jv_parser* p, jv* out) { 592| 19.9M| if (p->stackpos == 0 && jv_is_valid(p->next)) { ------------------ | Branch (592:7): [True: 19.9M, False: 0] | Branch (592:27): [True: 1.86k, False: 19.9M] ------------------ 593| 1.86k| *out = p->next; 594| 1.86k| p->next = jv_invalid(); 595| 1.86k| return 1; 596| 19.9M| } else { 597| 19.9M| return 0; 598| 19.9M| } 599| 19.9M|} jv_parse.c:classify: 562| 19.7M|static chclass classify(char c) { 563| 19.7M| switch (c) { 564| 0| case '\0': ------------------ | Branch (564:3): [True: 0, False: 19.7M] ------------------ 565| | // RFC 8259 forbids raw NUL in JSON text. Treating it as a literal lets it 566| | // slip into the token buffer, where check_literal() reads the buffer as a 567| | // NUL-terminated C string and silently truncates the token. Reject it. 568| 0| return INVALID; 569| 0| case ' ': ------------------ | Branch (569:3): [True: 0, False: 19.7M] ------------------ 570| 0| case '\t': ------------------ | Branch (570:3): [True: 0, False: 19.7M] ------------------ 571| 0| case '\r': ------------------ | Branch (571:3): [True: 0, False: 19.7M] ------------------ 572| 0| case '\n': ------------------ | Branch (572:3): [True: 0, False: 19.7M] ------------------ 573| 0| return WHITESPACE; 574| 196k| case '"': ------------------ | Branch (574:3): [True: 196k, False: 19.5M] ------------------ 575| 196k| return QUOTE; 576| 0| case '[': ------------------ | Branch (576:3): [True: 0, False: 19.7M] ------------------ 577| 0| case ',': ------------------ | Branch (577:3): [True: 0, False: 19.7M] ------------------ 578| 0| case ']': ------------------ | Branch (578:3): [True: 0, False: 19.7M] ------------------ 579| 0| case '{': ------------------ | Branch (579:3): [True: 0, False: 19.7M] ------------------ 580| 0| case ':': ------------------ | Branch (580:3): [True: 0, False: 19.7M] ------------------ 581| 0| case '}': ------------------ | Branch (581:3): [True: 0, False: 19.7M] ------------------ 582| 0| return STRUCTURE; 583| 19.5M| default: ------------------ | Branch (583:3): [True: 19.5M, False: 196k] ------------------ 584| 19.5M| return LITERAL; 585| 19.7M| } 586| 19.7M|} jv_parse.c:tokenadd: 421| 20.7M|static pfunc tokenadd(struct jv_parser* p, char c) { 422| 20.7M| assert(p->tokenpos <= p->tokenlen); ------------------ | Branch (422:3): [True: 0, False: 20.7M] | Branch (422:3): [True: 20.7M, False: 0] ------------------ 423| 20.7M| if (p->tokenpos >= (p->tokenlen - 1)) { ------------------ | Branch (423:7): [True: 2.46k, False: 20.7M] ------------------ 424| 2.46k| if (p->tokenlen > INT_MAX / 2) ------------------ | Branch (424:9): [True: 0, False: 2.46k] ------------------ 425| 0| return "Token too long"; 426| 2.46k| p->tokenlen *= 2; 427| 2.46k| p->tokenbuf = jv_mem_realloc(p->tokenbuf, p->tokenlen); 428| 2.46k| } 429| 20.7M| assert(p->tokenpos < p->tokenlen); ------------------ | Branch (429:3): [True: 0, False: 20.7M] | Branch (429:3): [True: 20.7M, False: 0] ------------------ 430| 20.7M| p->tokenbuf[p->tokenpos++] = c; 431| 20.7M| return 0; 432| 20.7M|} jv_parse.c:found_string: 449| 171k|static pfunc found_string(struct jv_parser* p) { 450| 171k| char* in = p->tokenbuf; 451| 171k| char* out = p->tokenbuf; 452| 171k| char* end = p->tokenbuf + p->tokenpos; 453| | 454| 194k| while (in < end) { ------------------ | Branch (454:10): [True: 192k, False: 1.86k] ------------------ 455| 192k| char c = *in++; 456| 192k| if (c == '\\') { ------------------ | Branch (456:9): [True: 192k, False: 0] ------------------ 457| 192k| if (in >= end) ------------------ | Branch (457:11): [True: 0, False: 192k] ------------------ 458| 0| return "Expected escape character at end of string"; 459| 192k| c = *in++; 460| 192k| switch (c) { 461| 1.52k| case '\\': ------------------ | Branch (461:7): [True: 1.52k, False: 190k] ------------------ 462| 8.70k| case '"': ------------------ | Branch (462:7): [True: 7.18k, False: 185k] ------------------ 463| 8.72k| case '/': *out++ = c; break; ------------------ | Branch (463:7): [True: 22, False: 192k] ------------------ 464| 13.2k| case 'b': *out++ = '\b'; break; ------------------ | Branch (464:7): [True: 13.2k, False: 179k] ------------------ 465| 6| case 'f': *out++ = '\f'; break; ------------------ | Branch (465:7): [True: 6, False: 192k] ------------------ 466| 37| case 't': *out++ = '\t'; break; ------------------ | Branch (466:7): [True: 37, False: 192k] ------------------ 467| 16| case 'n': *out++ = '\n'; break; ------------------ | Branch (467:7): [True: 16, False: 192k] ------------------ 468| 157| case 'r': *out++ = '\r'; break; ------------------ | Branch (468:7): [True: 157, False: 192k] ------------------ 469| | 470| 3.38k| case 'u': ------------------ | Branch (470:7): [True: 3.38k, False: 188k] ------------------ 471| | /* ahh, the complicated case */ 472| 3.38k| if (in + 4 > end) ------------------ | Branch (472:13): [True: 1.44k, False: 1.93k] ------------------ 473| 1.44k| return "Invalid \\uXXXX escape"; 474| 1.93k| int hexvalue = unhex4(in); 475| 1.93k| if (hexvalue < 0) ------------------ | Branch (475:13): [True: 580, False: 1.35k] ------------------ 476| 580| return "Invalid characters in \\uXXXX escape"; 477| 1.35k| unsigned long codepoint = (unsigned long)hexvalue; 478| 1.35k| in += 4; 479| 1.35k| if (0xD800 <= codepoint && codepoint <= 0xDBFF) { ------------------ | Branch (479:13): [True: 1.34k, False: 15] | Branch (479:36): [True: 1.30k, False: 37] ------------------ 480| | /* who thought UTF-16 surrogate pairs were a good idea? */ 481| 1.30k| if (in + 6 > end || in[0] != '\\' || in[1] != 'u') ------------------ | Branch (481:15): [True: 224, False: 1.08k] | Branch (481:31): [True: 0, False: 1.08k] | Branch (481:48): [True: 162, False: 921] ------------------ 482| 386| return "Invalid \\uXXXX\\uXXXX surrogate pair escape"; 483| 921| unsigned long surrogate = unhex4(in+2); 484| 921| if (!(0xDC00 <= surrogate && surrogate <= 0xDFFF)) ------------------ | Branch (484:17): [True: 560, False: 361] | Branch (484:40): [True: 132, False: 428] ------------------ 485| 789| return "Invalid \\uXXXX\\uXXXX surrogate pair escape"; 486| 132| in += 6; 487| 132| codepoint = 0x10000 + (((codepoint - 0xD800) << 10) 488| 132| |(surrogate - 0xDC00)); 489| 132| } 490| 184| if (codepoint > 0x10FFFF) ------------------ | Branch (490:13): [True: 0, False: 184] ------------------ 491| 0| codepoint = 0xFFFD; // U+FFFD REPLACEMENT CHARACTER 492| 184| out += jvp_utf8_encode(codepoint, out); 493| 184| break; 494| | 495| 166k| default: ------------------ | Branch (495:7): [True: 166k, False: 25.5k] ------------------ 496| 166k| return "Invalid escape"; 497| 192k| } 498| 192k| } else { 499| 0| if (!(c & ~0x1F)) ------------------ | Branch (499:11): [True: 0, False: 0] ------------------ 500| 0| return "Invalid string: control characters from U+0000 through U+001F must be escaped"; 501| 0| *out++ = c; 502| 0| } 503| 192k| } 504| 1.86k| TRY(value(p, jv_string_sized(p->tokenbuf, out - p->tokenbuf))); ------------------ | | 18| 1.86k|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 1.86k] | | | Branch (18:74): [Folded, False: 1.86k] | | ------------------ ------------------ 505| 1.86k| p->tokenpos = 0; 506| 1.86k| return 0; 507| 1.86k|} jv_parse.c:unhex4: 434| 2.86k|static int unhex4(char* hex) { 435| 2.86k| int r = 0; 436| 11.4k| for (int i=0; i<4; i++) { ------------------ | Branch (436:17): [True: 9.55k, False: 1.85k] ------------------ 437| 9.55k| char c = *hex++; 438| 9.55k| int n; 439| 9.55k| if ('0' <= c && c <= '9') n = c - '0'; ------------------ | Branch (439:9): [True: 9.55k, False: 0] | Branch (439:21): [True: 3.33k, False: 6.22k] ------------------ 440| 6.22k| else if ('a' <= c && c <= 'f') n = c - 'a' + 10; ------------------ | Branch (440:14): [True: 4.46k, False: 1.76k] | Branch (440:26): [True: 3.59k, False: 863] ------------------ 441| 2.62k| else if ('A' <= c && c <= 'F') n = c - 'A' + 10; ------------------ | Branch (441:14): [True: 2.62k, False: 0] | Branch (441:26): [True: 1.62k, False: 1.00k] ------------------ 442| 1.00k| else return -1; 443| 8.55k| r <<= 4; 444| 8.55k| r |= n; 445| 8.55k| } 446| 1.85k| return r; 447| 2.86k|} jv_parse.c:value: 125| 309k|static pfunc value(struct jv_parser* p, jv val) { 126| 309k| if ((p->flags & JV_PARSE_STREAMING)) { ------------------ | Branch (126:7): [True: 0, False: 309k] ------------------ 127| 0| if (jv_is_valid(p->next) || p->last_seen == JV_LAST_VALUE) { ------------------ | Branch (127:9): [True: 0, False: 0] | Branch (127:33): [True: 0, False: 0] ------------------ 128| 0| jv_free(val); 129| 0| return "Expected separator between values"; 130| 0| } 131| 0| if (p->stacklen > 0) ------------------ | Branch (131:9): [True: 0, False: 0] ------------------ 132| 0| p->last_seen = JV_LAST_VALUE; 133| 0| else 134| 0| p->last_seen = JV_LAST_NONE; 135| 309k| } else { 136| 309k| if (jv_is_valid(p->next)) { ------------------ | Branch (136:9): [True: 0, False: 309k] ------------------ 137| 0| jv_free(val); 138| 0| return "Expected separator between values"; 139| 0| } 140| 309k| } 141| 309k| jv_free(p->next); 142| 309k| p->next = val; 143| 309k| return 0; 144| 309k|} jv_parse.c:make_error: 747| 194k|static jv make_error(struct jv_parser* p, const char *fmt, ...) { 748| 194k| va_list ap; 749| 194k| va_start(ap, fmt); 750| 194k| jv e = jv_string_vfmt(fmt, ap); 751| 194k| va_end(ap); 752| 194k| if ((p->flags & JV_PARSE_STREAM_ERRORS)) ------------------ | Branch (752:7): [True: 0, False: 194k] ------------------ 753| 0| return JV_ARRAY(e, jv_copy(p->path)); ------------------ | | 120| 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__) | | ------------------ | | | | 118| 0|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 120| 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__) | | | | | | ------------------ | | | | | | | | 110| 0|#define JV_ARRAY_2(e1,e2) (jv_array_append(JV_ARRAY_1(e1),e2)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 754| 194k| return jv_invalid_with_msg(e); 755| 194k|} jv_parse.c:parser_reset: 98| 698k|static void parser_reset(struct jv_parser* p) { 99| 698k| if ((p->flags & JV_PARSE_STREAMING)) { ------------------ | Branch (99:7): [True: 0, False: 698k] ------------------ 100| 0| jv_free(p->path); 101| 0| p->path = jv_array(); 102| 0| p->stacklen = 0; 103| 0| } 104| 698k| p->last_seen = JV_LAST_NONE; 105| 698k| jv_free(p->output); 106| 698k| p->output = jv_invalid(); 107| 698k| jv_free(p->next); 108| 698k| p->next = jv_invalid(); 109| 698k| for (int i=0; istackpos; i++) ------------------ | Branch (109:17): [True: 0, False: 698k] ------------------ 110| 0| jv_free(p->stack[i]); 111| 698k| p->stackpos = 0; 112| 698k| p->tokenpos = 0; 113| 698k| p->st = JV_PARSER_NORMAL; 114| 698k|} jv_parse.c:check_literal: 509| 505k|static pfunc check_literal(struct jv_parser* p) { 510| 505k| if (p->tokenpos == 0) return 0; ------------------ | Branch (510:7): [True: 198k, False: 307k] ------------------ 511| | 512| 307k| const char* pattern = 0; 513| 307k| int plen; 514| 307k| jv v; 515| 307k| switch (p->tokenbuf[0]) { ------------------ | Branch (515:11): [True: 0, False: 307k] ------------------ 516| 0| case 't': pattern = "true"; plen = 4; v = jv_true(); break; ------------------ | Branch (516:3): [True: 0, False: 307k] ------------------ 517| 0| case 'f': pattern = "false"; plen = 5; v = jv_false(); break; ------------------ | Branch (517:3): [True: 0, False: 307k] ------------------ 518| 0| case '\'': ------------------ | Branch (518:3): [True: 0, False: 307k] ------------------ 519| 0| return "Invalid string literal; expected \", but got '"; 520| 0| case 'n': ------------------ | Branch (520:3): [True: 0, False: 307k] ------------------ 521| | // if it starts with 'n', it could be a literal "nan" 522| 0| if (p->tokenpos > 1 && p->tokenbuf[1] == 'u') { ------------------ | Branch (522:9): [True: 0, False: 0] | Branch (522:28): [True: 0, False: 0] ------------------ 523| 0| pattern = "null"; plen = 4; v = jv_null(); 524| 0| } 525| 307k| } 526| 307k| if (pattern) { ------------------ | Branch (526:7): [True: 0, False: 307k] ------------------ 527| 0| if (p->tokenpos != plen) return "Invalid literal"; ------------------ | Branch (527:9): [True: 0, False: 0] ------------------ 528| 0| for (int i=0; itokenbuf[i] != pattern[i]) ------------------ | Branch (529:11): [True: 0, False: 0] ------------------ 530| 0| return "Invalid literal"; 531| 0| TRY(value(p, v)); ------------------ | | 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] | | ------------------ ------------------ 532| 307k| } else { 533| | // FIXME: better parser 534| 307k| p->tokenbuf[p->tokenpos] = 0; 535| 307k|#ifdef USE_DECNUM 536| 307k| jv number = jv_number_with_literal(p->tokenbuf); 537| 307k| if (jv_get_kind(number) == JV_KIND_INVALID) { ------------------ | Branch (537:9): [True: 0, False: 307k] ------------------ 538| 0| return "Invalid numeric literal"; 539| 0| } 540| 307k| TRY(value(p, number)); ------------------ | | 18| 307k|#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0) | | ------------------ | | | Branch (18:45): [True: 0, False: 307k] | | | Branch (18:74): [Folded, False: 307k] | | ------------------ ------------------ 541| |#else 542| | char *end = 0; 543| | double d = jvp_strtod(&p->dtoa, p->tokenbuf, &end); 544| | if (end == 0 || *end != 0) { 545| | return "Invalid numeric literal"; 546| | } 547| | TRY(value(p, jv_number(d))); 548| |#endif 549| 307k| } 550| 307k| p->tokenpos = 0; 551| 307k| return 0; 552| 307k|} jv_dumpf: 377| 55.2k|void jv_dumpf(jv x, FILE *f, int flags) { 378| 55.2k| jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, f, 0); 379| 55.2k|} jv_dump: 381| 55.2k|void jv_dump(jv x, int flags) { 382| | jv_dumpf(x, stdout, flags); 383| 55.2k|} jv_dump_string: 393| 12.3k|jv jv_dump_string(jv x, int flags) { 394| 12.3k| jv s = jv_string(""); 395| 12.3k| jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, 0, &s); 396| 12.3k| return s; 397| 12.3k|} jv_dump_string_trunc: 399| 12.3k|char *jv_dump_string_trunc(jv x, char *outbuf, size_t bufsize) { 400| 12.3k| assert(bufsize > 0); ------------------ | Branch (400:3): [True: 0, False: 12.3k] | Branch (400:3): [True: 12.3k, False: 0] ------------------ 401| 12.3k| if (jv_get_kind(x) == JV_KIND_STRING && ------------------ | Branch (401:7): [True: 860, False: 11.5k] ------------------ 402| 860| (size_t)jv_string_length_bytes(jv_copy(x)) > bufsize) { ------------------ | Branch (402:7): [True: 673, False: 187] ------------------ 403| 673| x = jv_string_slice(x, 0, bufsize); 404| 673| } 405| 12.3k| x = jv_dump_string(x, 0); 406| 12.3k| const char *str = jv_string_value(x); 407| 12.3k| const size_t len = strlen(str); 408| 12.3k| if (len > bufsize - 1 && bufsize >= 8) { ------------------ | Branch (408:7): [True: 1.52k, False: 10.8k] | Branch (408:28): [True: 1.52k, False: 0] ------------------ 409| 1.52k| char delim = 0; 410| 1.52k| switch (str[0]) { ------------------ | Branch (410:13): [True: 1.14k, False: 379] ------------------ 411| 707| case '"': delim = '"'; break; ------------------ | Branch (411:5): [True: 707, False: 816] ------------------ 412| 268| case '[': delim = ']'; break; ------------------ | Branch (412:5): [True: 268, False: 1.25k] ------------------ 413| 169| case '{': delim = '}'; break; ------------------ | Branch (413:5): [True: 169, False: 1.35k] ------------------ 414| 1.52k| } 415| 1.52k| size_t l = bufsize - (delim ? 5 : 4); // "...", delim (if any), '\0' ------------------ | Branch (415:27): [True: 1.14k, False: 379] ------------------ 416| 1.52k| const char *s = jvp_utf8_backtrack(str + l, str, NULL); 417| 1.52k| if (s) l = s - str; ------------------ | Branch (417:9): [True: 1.52k, False: 0] ------------------ 418| 1.52k| memcpy(outbuf, str, l); 419| 1.52k| outbuf[l++] = '.'; 420| 1.52k| outbuf[l++] = '.'; 421| 1.52k| outbuf[l++] = '.'; 422| 1.52k| if (delim) outbuf[l++] = delim; ------------------ | Branch (422:9): [True: 1.14k, False: 379] ------------------ 423| 1.52k| outbuf[l] = '\0'; 424| 10.8k| } else { 425| 10.8k| size_t l = MIN(len, bufsize - 1); ------------------ | | 71| 10.8k| ({ __typeof__ (a) _a = (a); \ | | 72| 10.8k| __typeof__ (b) _b = (b); \ | | 73| 10.8k| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (73:4): [True: 10.6k, False: 168] | | ------------------ ------------------ 426| 10.8k| memcpy(outbuf, str, l); 427| 10.8k| outbuf[l] = '\0'; 428| 10.8k| } 429| 12.3k| jv_free(x); 430| 12.3k| return outbuf; 431| 12.3k|} jv_print.c:jv_dump_term: 207| 469k|static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FILE* F, jv* S) { 208| 469k| char buf[JVP_DTOA_FMT_MAX_LEN]; 209| 469k| const char* color = 0; 210| 469k| double refcnt = (flags & JV_PRINT_REFCOUNT) ? jv_get_refcnt(x) - 1 : -1; ------------------ | Branch (210:19): [True: 0, False: 469k] ------------------ 211| 469k| if ((flags & JV_PRINT_COLOR) && jv_get_kind(x) != JV_KIND_INVALID) { ------------------ | Branch (211:7): [True: 0, False: 469k] | Branch (211:35): [True: 0, False: 0] ------------------ 212| 0| color = colors[(int)jv_get_kind(x) - 1]; 213| 0| put_str(color, F, S, flags & JV_PRINT_ISATTY); 214| 0| } 215| 469k| if (indent > MAX_PRINT_DEPTH) { ------------------ | | 15| 469k|#define MAX_PRINT_DEPTH (10000) ------------------ | Branch (215:7): [True: 0, False: 469k] ------------------ 216| 0| put_str("", F, S, flags & JV_PRINT_ISATTY); 217| 469k| } else switch (jv_get_kind(x)) { 218| 0| default: ------------------ | Branch (218:3): [True: 0, False: 469k] ------------------ 219| 0| case JV_KIND_INVALID: ------------------ | Branch (219:3): [True: 0, False: 469k] ------------------ 220| 0| if (flags & JV_PRINT_INVALID) { ------------------ | Branch (220:9): [True: 0, False: 0] ------------------ 221| 0| jv msg = jv_invalid_get_msg(jv_copy(x)); 222| 0| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (222:11): [True: 0, False: 0] ------------------ 223| 0| put_str("', F, S, flags & JV_PRINT_ISATTY); 226| 0| } else { 227| 0| put_str("", F, S, flags & JV_PRINT_ISATTY); 228| 0| } 229| 0| } else { 230| 0| assert(0 && "Invalid value"); ------------------ | Branch (230:7): [Folded, False: 0] | Branch (230:7): [True: 0, False: 0] | Branch (230:7): [Folded, False: 0] | Branch (230:7): [True: 0, False: 0] ------------------ 231| 0| } 232| 0| break; 233| 315| case JV_KIND_NULL: ------------------ | Branch (233:3): [True: 315, False: 468k] ------------------ 234| 315| put_str("null", F, S, flags & JV_PRINT_ISATTY); 235| 315| break; 236| 13.5k| case JV_KIND_FALSE: ------------------ | Branch (236:3): [True: 13.5k, False: 455k] ------------------ 237| 13.5k| put_str("false", F, S, flags & JV_PRINT_ISATTY); 238| 13.5k| break; 239| 13.5k| case JV_KIND_TRUE: ------------------ | Branch (239:3): [True: 13.5k, False: 455k] ------------------ 240| 13.5k| put_str("true", F, S, flags & JV_PRINT_ISATTY); 241| 13.5k| break; 242| 38.2k| case JV_KIND_NUMBER: { ------------------ | Branch (242:3): [True: 38.2k, False: 430k] ------------------ 243| 38.2k| if (jvp_number_is_nan(x)) { ------------------ | Branch (243:9): [True: 39, False: 38.2k] ------------------ 244| 39| jv_dump_term(C, jv_null(), flags, indent, F, S); 245| 38.2k| } else { 246| 38.2k|#ifdef USE_DECNUM 247| 38.2k| const char * literal_data = jv_number_get_literal(x); 248| 38.2k| if (literal_data) { ------------------ | Branch (248:11): [True: 31.0k, False: 7.16k] ------------------ 249| 31.0k| put_str(literal_data, F, S, flags & JV_PRINT_ISATTY); 250| 31.0k| } else { 251| 7.16k|#endif 252| 7.16k| double d = jv_number_value(x); 253| 7.16k| if (d != d) { ------------------ | Branch (253:13): [True: 0, False: 7.16k] ------------------ 254| | // JSON doesn't have NaN, so we'll render it as "null" 255| 0| put_str("null", F, S, flags & JV_PRINT_ISATTY); 256| 7.16k| } else { 257| | // Normalise infinities to something we can print in valid JSON 258| 7.16k| if (d > DBL_MAX) d = DBL_MAX; ------------------ | Branch (258:15): [True: 897, False: 6.26k] ------------------ 259| 7.16k| if (d < -DBL_MAX) d = -DBL_MAX; ------------------ | Branch (259:15): [True: 247, False: 6.91k] ------------------ 260| 7.16k| put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY); 261| 7.16k| } 262| 7.16k| } 263| 38.2k|#ifdef USE_DECNUM 264| 38.2k| } 265| 38.2k|#endif 266| 38.2k| break; 267| 0| } 268| 277k| case JV_KIND_STRING: ------------------ | Branch (268:3): [True: 277k, False: 191k] ------------------ 269| 277k| jvp_dump_string(x, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY); 270| 277k| if (flags & JV_PRINT_REFCOUNT) ------------------ | Branch (270:9): [True: 0, False: 277k] ------------------ 271| 0| put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY); 272| 277k| break; 273| 122k| case JV_KIND_ARRAY: { ------------------ | Branch (273:3): [True: 122k, False: 346k] ------------------ 274| 122k| if (jv_array_length(jv_copy(x)) == 0) { ------------------ | Branch (274:9): [True: 3.06k, False: 119k] ------------------ 275| 3.06k| put_str("[]", F, S, flags & JV_PRINT_ISATTY); 276| 3.06k| break; 277| 3.06k| } 278| 119k| put_char('[', F, S, flags & JV_PRINT_ISATTY); 279| 397k| jv_array_foreach(x, i, elem) { ------------------ | | 102| 119k| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 239k| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 119k, False: 119k] | | ------------------ | | 104| 119k| for (jv x; \ | | 105| 517k| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 397k, False: 119k] | | | Branch (105:10): [True: 397k, False: 119k] | | ------------------ | | 106| 517k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 397k| i++) ------------------ 280| 397k| if (i!=0) { ------------------ | Branch (280:11): [True: 277k, False: 119k] ------------------ 281| 277k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (281:13): [True: 0, False: 277k] ------------------ 282| 277k| put_char(',', F, S, flags & JV_PRINT_ISATTY); 283| 277k| } 284| 397k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 20| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 18| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (284:11): [True: 0, False: 397k] ------------------ 285| 397k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (285:11): [True: 0, False: 397k] ------------------ 286| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 287| 0| put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY); 288| 0| } 289| 397k| jv_dump_term(C, elem, flags, indent + 1, F, S); 290| 397k| } 291| 119k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (291:9): [True: 0, False: 119k] ------------------ 292| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 293| 0| put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY); 294| 0| } 295| 119k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (295:9): [True: 0, False: 119k] ------------------ 296| 119k| put_char(']', F, S, flags & JV_PRINT_ISATTY); 297| 119k| if (flags & JV_PRINT_REFCOUNT) ------------------ | Branch (297:9): [True: 0, False: 119k] ------------------ 298| 0| put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY); 299| 119k| break; 300| 122k| } 301| 3.08k| case JV_KIND_OBJECT: { ------------------ | Branch (301:3): [True: 3.08k, False: 465k] ------------------ 302| 3.08k| if (jv_object_length(jv_copy(x)) == 0) { ------------------ | Branch (302:9): [True: 268, False: 2.81k] ------------------ 303| 268| put_str("{}", F, S, flags & JV_PRINT_ISATTY); 304| 268| break; 305| 268| } 306| 2.81k| put_char('{', F, S, flags & JV_PRINT_ISATTY); 307| 2.81k| int first = 1; 308| 2.81k| int i = 0; 309| 2.81k| jv keyset = jv_null(); 310| 6.30k| while (1) { ------------------ | Branch (310:12): [True: 6.30k, Folded] ------------------ 311| 6.30k| jv key, value; 312| 6.30k| if (flags & JV_PRINT_SORTED) { ------------------ | Branch (312:11): [True: 0, False: 6.30k] ------------------ 313| 0| if (first) { ------------------ | Branch (313:13): [True: 0, False: 0] ------------------ 314| 0| keyset = jv_keys(jv_copy(x)); 315| 0| i = 0; 316| 0| } else { 317| 0| i++; 318| 0| } 319| 0| if (i >= jv_array_length(jv_copy(keyset))) { ------------------ | Branch (319:13): [True: 0, False: 0] ------------------ 320| 0| jv_free(keyset); 321| 0| break; 322| 0| } 323| 0| key = jv_array_get(jv_copy(keyset), i); 324| 0| value = jv_object_get(jv_copy(x), jv_copy(key)); 325| 6.30k| } else { 326| 6.30k| if (first) { ------------------ | Branch (326:13): [True: 2.81k, False: 3.49k] ------------------ 327| 2.81k| i = jv_object_iter(x); 328| 3.49k| } else { 329| 3.49k| i = jv_object_iter_next(x, i); 330| 3.49k| } 331| 6.30k| if (!jv_object_iter_valid(x, i)) break; ------------------ | Branch (331:13): [True: 2.81k, False: 3.49k] ------------------ 332| 3.49k| key = jv_object_iter_key(x, i); 333| 3.49k| value = jv_object_iter_value(x, i); 334| 3.49k| } 335| | 336| 3.49k| if (!first) { ------------------ | Branch (336:11): [True: 675, False: 2.81k] ------------------ 337| 675| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (337:13): [True: 0, False: 675] ------------------ 338| 675| put_char(',', F, S, flags & JV_PRINT_ISATTY); 339| 675| } 340| 3.49k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 20| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 18| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (340:11): [True: 0, False: 3.49k] ------------------ 341| 3.49k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (341:11): [True: 0, False: 3.49k] ------------------ 342| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 343| 0| put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY); 344| 0| } 345| | 346| 3.49k| first = 0; 347| 3.49k| if (color) put_str(FIELD_COLOR, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 31| 0|#define FIELD_COLOR (colors[7]) ------------------ | Branch (347:11): [True: 0, False: 3.49k] ------------------ 348| 3.49k| jvp_dump_string(key, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY); 349| 3.49k| jv_free(key); 350| 3.49k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 20| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 18| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (350:11): [True: 0, False: 3.49k] ------------------ 351| | 352| 3.49k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (352:11): [True: 0, False: 3.49k] ------------------ 353| 3.49k| put_char(':', F, S, flags & JV_PRINT_ISATTY); 354| 3.49k| if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 20| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 18| 0|#define ESC "\033" | | ------------------ ------------------ | Branch (354:11): [True: 0, False: 3.49k] ------------------ 355| 3.49k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (355:11): [True: 0, False: 3.49k] ------------------ 356| 0| put_char(' ', F, S, flags & JV_PRINT_ISATTY); 357| 0| } 358| | 359| 3.49k| jv_dump_term(C, value, flags, indent + 1, F, S); 360| 3.49k| } 361| 2.81k| if (flags & JV_PRINT_PRETTY) { ------------------ | Branch (361:9): [True: 0, False: 2.81k] ------------------ 362| 0| put_char('\n', F, S, flags & JV_PRINT_ISATTY); 363| 0| put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY); 364| 0| } 365| 2.81k| if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY); ------------------ | Branch (365:9): [True: 0, False: 2.81k] ------------------ 366| 2.81k| put_char('}', F, S, flags & JV_PRINT_ISATTY); 367| 2.81k| if (flags & JV_PRINT_REFCOUNT) ------------------ | Branch (367:9): [True: 0, False: 2.81k] ------------------ 368| 0| put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY); 369| 2.81k| } 370| 469k| } 371| 469k| jv_free(x); 372| 469k| if (color) { ------------------ | Branch (372:7): [True: 0, False: 469k] ------------------ 373| 0| put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY); ------------------ | | 20| 0|#define COLRESET (ESC "[0m") | | ------------------ | | | | 18| 0|#define ESC "\033" | | ------------------ ------------------ 374| 0| } 375| 469k|} jv_print.c:put_str: 106| 81.3k|static void put_str(const char* s, FILE* fout, jv* strout, int T) { 107| 81.3k| put_buf(s, strlen(s), fout, strout, T); 108| 81.3k|} jv_print.c:put_buf: 92| 44.0M|static void put_buf(const char *s, int len, FILE *fout, jv *strout, int is_tty) { 93| 44.0M| if (strout) { ------------------ | Branch (93:7): [True: 43.8M, False: 208k] ------------------ 94| 43.8M| *strout = jv_string_append_buf(*strout, s, len); 95| 43.8M| } else { 96| 208k| if (len == -1) ------------------ | Branch (96:9): [True: 0, False: 208k] ------------------ 97| 0| len = strlen(s); 98| 208k| priv_fwrite(s, len, fout, is_tty); /* see util.h */ 99| 208k| } 100| 44.0M|} jv_print.c:jvp_dump_string: 121| 280k|static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S, int T) { 122| 280k| assert(jv_get_kind(str) == JV_KIND_STRING); ------------------ | Branch (122:3): [True: 0, False: 280k] | Branch (122:3): [True: 280k, False: 0] ------------------ 123| 280k| const char* i = jv_string_value(str); 124| 280k| const char* end = i + jv_string_length_bytes(jv_copy(str)); 125| 280k| const char* cstart; 126| 280k| int c = 0; 127| 280k| char buf[32]; 128| 280k| put_char('"', F, S, T); 129| 21.5M| while (i < end) { ------------------ | Branch (129:10): [True: 21.5M, False: 772] ------------------ 130| | // Write each run of bytes that need no escaping with a single call. 131| 22.8M| for (cstart = i; cstart < end; cstart++) { ------------------ | Branch (131:22): [True: 22.5M, False: 280k] ------------------ 132| 22.5M| unsigned char b = *cstart; 133| 22.5M| if (b < 0x20 || b == '"' || b == '\\' || b == 0x7F || (ascii_only && b >= 0x80)) ------------------ | Branch (133:11): [True: 21.2M, False: 1.25M] | Branch (133:23): [True: 856, False: 1.25M] | Branch (133:35): [True: 4.60k, False: 1.25M] | Branch (133:48): [True: 510, False: 1.24M] | Branch (133:62): [True: 0, False: 1.24M] | Branch (133:76): [True: 0, False: 0] ------------------ 134| 21.2M| break; 135| 22.5M| } 136| 21.5M| if (cstart > i) ------------------ | Branch (136:9): [True: 284k, False: 21.2M] ------------------ 137| 284k| put_buf(i, cstart - i, F, S, T); 138| 21.5M| if (cstart == end) ------------------ | Branch (138:9): [True: 280k, False: 21.2M] ------------------ 139| 280k| break; 140| 21.2M| i = jvp_utf8_next(cstart, end, &c); 141| 21.2M| assert(c != -1); ------------------ | Branch (141:5): [True: 0, False: 21.2M] | Branch (141:5): [True: 21.2M, False: 0] ------------------ 142| 21.2M| int unicode_escape = 0; 143| 21.2M| if (0x20 <= c && c <= 0x7E) { ------------------ | Branch (143:9): [True: 5.96k, False: 21.2M] | Branch (143:22): [True: 5.45k, False: 510] ------------------ 144| | // printable ASCII 145| 5.45k| if (c == '"' || c == '\\') { ------------------ | Branch (145:11): [True: 856, False: 4.60k] | Branch (145:23): [True: 4.60k, False: 0] ------------------ 146| 5.45k| put_char('\\', F, S, T); 147| 5.45k| } 148| 5.45k| put_char(c, F, S, T); 149| 21.2M| } else if (c < 0x20 || c == 0x7F) { ------------------ | Branch (149:16): [True: 21.2M, False: 510] | Branch (149:28): [True: 510, False: 0] ------------------ 150| | // ASCII control character 151| 21.2M| switch (c) { 152| 0| case '\b': ------------------ | Branch (152:7): [True: 0, False: 21.2M] ------------------ 153| 0| put_char('\\', F, S, T); 154| 0| put_char('b', F, S, T); 155| 0| break; 156| 207| case '\t': ------------------ | Branch (156:7): [True: 207, False: 21.2M] ------------------ 157| 207| put_char('\\', F, S, T); 158| 207| put_char('t', F, S, T); 159| 207| break; 160| 0| case '\r': ------------------ | Branch (160:7): [True: 0, False: 21.2M] ------------------ 161| 0| put_char('\\', F, S, T); 162| 0| put_char('r', F, S, T); 163| 0| break; 164| 21.2M| case '\n': ------------------ | Branch (164:7): [True: 21.2M, False: 12.6k] ------------------ 165| 21.2M| put_char('\\', F, S, T); 166| 21.2M| put_char('n', F, S, T); 167| 21.2M| break; 168| 2| case '\f': ------------------ | Branch (168:7): [True: 2, False: 21.2M] ------------------ 169| 2| put_char('\\', F, S, T); 170| 2| put_char('f', F, S, T); 171| 2| break; 172| 12.4k| default: ------------------ | Branch (172:7): [True: 12.4k, False: 21.2M] ------------------ 173| 12.4k| unicode_escape = 1; 174| 12.4k| break; 175| 21.2M| } 176| 21.2M| } else { 177| 0| if (ascii_only) { ------------------ | Branch (177:11): [True: 0, False: 0] ------------------ 178| 0| unicode_escape = 1; 179| 0| } else { 180| 0| put_buf(cstart, i - cstart, F, S, T); 181| 0| } 182| 0| } 183| 21.2M| if (unicode_escape) { ------------------ | Branch (183:9): [True: 12.4k, False: 21.2M] ------------------ 184| 12.4k| if (c <= 0xffff) { ------------------ | Branch (184:11): [True: 12.4k, False: 0] ------------------ 185| 12.4k| snprintf(buf, sizeof(buf), "\\u%04x", c); 186| 12.4k| } else { 187| 0| c -= 0x10000; 188| 0| snprintf(buf, sizeof(buf), "\\u%04x\\u%04x", 189| 0| 0xD800 | ((c & 0xffc00) >> 10), 190| 0| 0xDC00 | (c & 0x003ff)); 191| 0| } 192| 12.4k| put_str(buf, F, S, T); 193| 12.4k| } 194| 21.2M| } 195| 280k| assert(c != -1); ------------------ | Branch (195:3): [True: 0, False: 280k] | Branch (195:3): [True: 280k, False: 0] ------------------ 196| 280k| put_char('"', F, S, T); 197| 280k|} jv_print.c:put_char: 102| 43.6M|static void put_char(char c, FILE* fout, jv* strout, int T) { 103| 43.6M| put_buf(&c, 1, fout, strout, T); 104| 43.6M|} jvp_utf8_backtrack: 11| 1.52k|const char* jvp_utf8_backtrack(const char* start, const char* min, int *missing_bytes) { 12| 1.52k| assert(min <= start); ------------------ | Branch (12:3): [True: 0, False: 1.52k] | Branch (12:3): [True: 1.52k, False: 0] ------------------ 13| 1.52k| if (min == start) { ------------------ | Branch (13:7): [True: 0, False: 1.52k] ------------------ 14| 0| return min; 15| 0| } 16| 1.52k| int length = 0; 17| 1.52k| int seen = 1; 18| 2.01k| while ((length = utf8_coding_length[(unsigned char)*start]) == UTF8_CONTINUATION_BYTE) { ------------------ | | 1| 2.01k|#define UTF8_CONTINUATION_BYTE ((unsigned char)255) ------------------ | Branch (18:10): [True: 494, False: 1.52k] ------------------ 19| 494| if (start == min) break; ------------------ | Branch (19:9): [True: 0, False: 494] ------------------ 20| 494| start--; 21| 494| seen++; 22| 494| } 23| 1.52k| if (length == 0 || length == UTF8_CONTINUATION_BYTE || length - seen < 0) { ------------------ | | 1| 3.04k|#define UTF8_CONTINUATION_BYTE ((unsigned char)255) ------------------ | Branch (23:7): [True: 0, False: 1.52k] | Branch (23:22): [True: 0, False: 1.52k] | Branch (23:58): [True: 0, False: 1.52k] ------------------ 24| 0| return NULL; 25| 0| } 26| 1.52k| if (missing_bytes) *missing_bytes = length - seen; ------------------ | Branch (26:7): [True: 0, False: 1.52k] ------------------ 27| 1.52k| return start; 28| 1.52k|} jvp_utf8_next: 30| 1.12G|const char* jvp_utf8_next(const char* in, const char* end, int* codepoint_ret) { 31| 1.12G| assert(in <= end); ------------------ | Branch (31:3): [True: 0, False: 1.12G] | Branch (31:3): [True: 1.12G, False: 0] ------------------ 32| 1.12G| if (in == end) { ------------------ | Branch (32:7): [True: 47.2M, False: 1.07G] ------------------ 33| 47.2M| return 0; 34| 47.2M| } 35| 1.07G| int codepoint = -1; 36| 1.07G| unsigned char first = (unsigned char)in[0]; 37| 1.07G| int length = utf8_coding_length[first]; 38| 1.07G| if ((first & 0x80) == 0) { ------------------ | Branch (38:7): [True: 1.00G, False: 71.0M] ------------------ 39| | /* Fast-path for ASCII */ 40| 1.00G| codepoint = first; 41| 1.00G| length = 1; 42| 1.00G| } else if (length == 0 || length == UTF8_CONTINUATION_BYTE) { ------------------ | | 1| 61.6M|#define UTF8_CONTINUATION_BYTE ((unsigned char)255) ------------------ | Branch (42:14): [True: 9.40M, False: 61.6M] | Branch (42:29): [True: 13.1M, False: 48.4M] ------------------ 43| | /* Bad single byte - either an invalid byte or an out-of-place continuation byte */ 44| 22.5M| length = 1; 45| 48.4M| } else if (length > end - in) { ------------------ | Branch (45:14): [True: 52.8k, False: 48.4M] ------------------ 46| | /* String ends before UTF8 sequence ends */ 47| 52.8k| length = end - in; 48| 48.4M| } else { 49| 48.4M| codepoint = ((unsigned)in[0]) & utf8_coding_bits[first]; 50| 92.4M| for (int i=1; i 0x10FFFF) { ------------------ | Branch (68:9): [True: 1.40k, False: 48.4M] ------------------ 69| | /* Outside Unicode range */ 70| 1.40k| codepoint = -1; 71| 1.40k| } 72| 48.4M| } 73| 1.07G| assert(length > 0); ------------------ | Branch (73:3): [True: 0, False: 1.07G] | Branch (73:3): [True: 1.07G, False: 0] ------------------ 74| 1.07G| *codepoint_ret = codepoint; 75| 1.07G| return in + length; 76| 1.07G|} jvp_utf8_is_valid: 78| 47.2M|int jvp_utf8_is_valid(const char* in, const char* end) { 79| 47.2M| int codepoint; 80| 292M| while ((in = jvp_utf8_next(in, end, &codepoint))) { ------------------ | Branch (80:10): [True: 245M, False: 47.0M] ------------------ 81| 245M| if (codepoint == -1) return 0; ------------------ | Branch (81:9): [True: 164k, False: 244M] ------------------ 82| 245M| } 83| 47.0M| return 1; 84| 47.2M|} jvp_utf8_encode_length: 94| 812M|int jvp_utf8_encode_length(int codepoint) { 95| 812M| if (codepoint <= 0x7F) return 1; ------------------ | Branch (95:7): [True: 745M, False: 67.6M] ------------------ 96| 67.6M| else if (codepoint <= 0x7FF) return 2; ------------------ | Branch (96:12): [True: 223k, False: 67.3M] ------------------ 97| 67.3M| else if (codepoint <= 0xFFFF) return 3; ------------------ | Branch (97:12): [True: 66.5M, False: 881k] ------------------ 98| 881k| else return 4; 99| 812M|} jvp_utf8_encode: 101| 812M|int jvp_utf8_encode(int codepoint, char* out) { 102| 812M| assert(codepoint >= 0 && codepoint <= 0x10FFFF); ------------------ | Branch (102:3): [True: 0, False: 812M] | Branch (102:3): [True: 0, False: 0] | Branch (102:3): [True: 812M, False: 0] | Branch (102:3): [True: 812M, False: 0] ------------------ 103| 812M| char* start = out; 104| 812M| if (codepoint <= 0x7F) { ------------------ | Branch (104:7): [True: 745M, False: 67.6M] ------------------ 105| 745M| *out++ = codepoint; 106| 745M| } else if (codepoint <= 0x7FF) { ------------------ | Branch (106:14): [True: 223k, False: 67.3M] ------------------ 107| 223k| *out++ = 0xC0 + ((codepoint & 0x7C0) >> 6); 108| 223k| *out++ = 0x80 + ((codepoint & 0x03F)); 109| 67.3M| } else if(codepoint <= 0xFFFF) { ------------------ | Branch (109:13): [True: 66.5M, False: 881k] ------------------ 110| 66.5M| *out++ = 0xE0 + ((codepoint & 0xF000) >> 12); 111| 66.5M| *out++ = 0x80 + ((codepoint & 0x0FC0) >> 6); 112| 66.5M| *out++ = 0x80 + ((codepoint & 0x003F)); 113| 66.5M| } else { 114| 881k| *out++ = 0xF0 + ((codepoint & 0x1C0000) >> 18); 115| 881k| *out++ = 0x80 + ((codepoint & 0x03F000) >> 12); 116| 881k| *out++ = 0x80 + ((codepoint & 0x000FC0) >> 6); 117| 881k| *out++ = 0x80 + ((codepoint & 0x00003F)); 118| 881k| } 119| 812M| assert(out - start == jvp_utf8_encode_length(codepoint)); ------------------ | Branch (119:3): [True: 0, False: 812M] | Branch (119:3): [True: 812M, False: 0] ------------------ 120| 812M| return out - start; 121| 812M|} jq_yylex: 1079| 3.18M|{ 1080| 3.18M| yy_state_type yy_current_state; 1081| 3.18M| char *yy_cp, *yy_bp; 1082| 3.18M| int yy_act; 1083| 3.18M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1084| | 1085| 3.18M| yylval = yylval_param; ------------------ | | 886| 3.18M| # define yylval yyg->yylval_r ------------------ 1086| | 1087| 3.18M| yylloc = yylloc_param; ------------------ | | 888| 3.18M| # define yylloc yyg->yylloc_r ------------------ 1088| | 1089| 3.18M| if ( !yyg->yy_init ) ------------------ | Branch (1089:7): [True: 777, False: 3.18M] ------------------ 1090| 777| { 1091| 777| yyg->yy_init = 1; 1092| | 1093| |#ifdef YY_USER_INIT 1094| | YY_USER_INIT; 1095| |#endif 1096| | 1097| 777| if ( ! yyg->yy_start ) ------------------ | Branch (1097:8): [True: 777, False: 0] ------------------ 1098| 777| yyg->yy_start = 1; /* first start state */ 1099| | 1100| 777| if ( ! yyin ) ------------------ | | 356| 777|#define yyin yyg->yyin_r ------------------ | Branch (1100:8): [True: 777, False: 0] ------------------ 1101| 777| yyin = stdin; ------------------ | | 356| 777|#define yyin yyg->yyin_r ------------------ 1102| | 1103| 777| if ( ! yyout ) ------------------ | | 357| 777|#define yyout yyg->yyout_r ------------------ | Branch (1103:8): [True: 777, False: 0] ------------------ 1104| 777| yyout = stdout; ------------------ | | 357| 777|#define yyout yyg->yyout_r ------------------ 1105| | 1106| 777| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 502| 777|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 777, False: 0] | | ------------------ | | 503| 777| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 777| : NULL) ------------------ | Branch (1106:8): [True: 0, False: 777] ------------------ 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| 777| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 777|#define yy_load_buffer_state jq_yy_load_buffer_state ------------------ 1113| 777| } 1114| | 1115| 3.18M| { 1116| 3.18M|#line 39 "src/lexer.l" 1117| | 1118| | 1119| 3.18M|#line 1119 "src/lexer.c" 1120| | 1121| 3.62M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1121:23): [True: 3.62M, Folded] ------------------ 1122| 3.62M| { 1123| 3.62M| yy_cp = yyg->yy_c_buf_p; 1124| | 1125| | /* Support of yytext. */ 1126| 3.62M| *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| 3.62M| yy_bp = yy_cp; 1132| | 1133| 3.62M| yy_current_state = yyg->yy_start; 1134| 3.62M|yy_match: 1135| 3.62M| do 1136| 34.1M| { 1137| 34.1M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 34.1M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1138| 34.1M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1138:9): [True: 30.2M, False: 3.94M] ------------------ 1139| 30.2M| { 1140| 30.2M| yyg->yy_last_accepting_state = yy_current_state; 1141| 30.2M| yyg->yy_last_accepting_cpos = yy_cp; 1142| 30.2M| } 1143| 47.6M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1143:12): [True: 13.4M, False: 34.1M] ------------------ 1144| 13.4M| { 1145| 13.4M| yy_current_state = (int) yy_def[yy_current_state]; 1146| 13.4M| if ( yy_current_state >= 168 ) ------------------ | Branch (1146:10): [True: 9.53M, False: 3.91M] ------------------ 1147| 9.53M| yy_c = yy_meta[yy_c]; 1148| 13.4M| } 1149| 34.1M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1150| 34.1M| ++yy_cp; 1151| 34.1M| } 1152| 34.1M| while ( yy_base[yy_current_state] != 339 ); ------------------ | Branch (1152:11): [True: 30.5M, False: 3.62M] ------------------ 1153| | 1154| 3.62M|yy_find_action: 1155| 3.62M| yy_act = yy_accept[yy_current_state]; 1156| 3.62M| if ( yy_act == 0 ) ------------------ | Branch (1156:8): [True: 1.66M, False: 1.96M] ------------------ 1157| 1.66M| { /* have to back up */ 1158| 1.66M| yy_cp = yyg->yy_last_accepting_cpos; 1159| 1.66M| yy_current_state = yyg->yy_last_accepting_state; 1160| 1.66M| yy_act = yy_accept[yy_current_state]; 1161| 1.66M| } 1162| | 1163| 3.62M| YY_DO_BEFORE_ACTION; ------------------ | | 571| 3.62M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 560| 3.62M|#define yytext_ptr yytext_r | | ------------------ | | 572| 3.62M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 3.62M|#define yyleng yyg->yyleng_r | | ------------------ | | 573| 3.62M| yyg->yy_hold_char = *yy_cp; \ | | 574| 3.62M| *yy_cp = '\0'; \ | | 575| 3.62M| yyg->yy_c_buf_p = yy_cp; ------------------ 1164| | 1165| 3.62M|do_action: /* This label is used only to access EOF actions. */ 1166| | 1167| 3.62M| switch ( yy_act ) 1168| 3.62M| { /* beginning of action switch */ 1169| 0| case 0: /* must back up */ ------------------ | Branch (1169:4): [True: 0, False: 3.62M] ------------------ 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| 4.20k|case 1: ------------------ | Branch (1176:1): [True: 4.20k, False: 3.62M] ------------------ 1177| 4.20k|YY_RULE_SETUP ------------------ | | 1074| 4.20k| YY_USER_ACTION | | ------------------ | | | | 811| 4.20k| do { \ | | | | 812| 4.20k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 4.20k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 4.20k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 4.20k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 4.20k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 4.20k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 4.20k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 4.20k] | | | | ------------------ | | ------------------ ------------------ 1178| 4.20k|#line 41 "src/lexer.l" 1179| 4.20k|{ yy_push_state(IN_COMMENT, yyscanner); } ------------------ | | 832| 4.20k|#define IN_COMMENT 6 ------------------ 1180| 4.20k| YY_BREAK ------------------ | | 1070| 4.20k|#define YY_BREAK /*LINTED*/break; ------------------ 1181| | 1182| 195k|case 2: ------------------ | Branch (1182:1): [True: 195k, False: 3.43M] ------------------ 1183| |/* rule 2 can match eol */ 1184| 195k|YY_RULE_SETUP ------------------ | | 1074| 195k| YY_USER_ACTION | | ------------------ | | | | 811| 195k| do { \ | | | | 812| 195k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 195k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 195k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 195k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 195k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 195k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 195k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 195k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 195k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 195k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 195k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 195k] | | | | ------------------ | | ------------------ ------------------ 1185| 195k|#line 43 "src/lexer.l" 1186| 195k|{ } 1187| 195k| YY_BREAK ------------------ | | 1070| 195k|#define YY_BREAK /*LINTED*/break; ------------------ 1188| 4.20k|case 3: ------------------ | Branch (1188:1): [True: 4.20k, False: 3.62M] ------------------ 1189| |/* rule 3 can match eol */ 1190| 4.20k|YY_RULE_SETUP ------------------ | | 1074| 4.20k| YY_USER_ACTION | | ------------------ | | | | 811| 4.20k| do { \ | | | | 812| 4.20k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 4.20k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 4.20k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 4.20k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 4.20k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 4.20k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 4.20k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 4.20k] | | | | ------------------ | | ------------------ ------------------ 1191| 4.20k|#line 44 "src/lexer.l" 1192| 4.20k|{ yy_pop_state(yyscanner); } 1193| 4.20k| YY_BREAK ------------------ | | 1070| 4.20k|#define YY_BREAK /*LINTED*/break; ------------------ 1194| | 1195| 2|case YY_STATE_EOF(IN_COMMENT): ------------------ | | 377| 2|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 2|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ | Branch (1195:1): [True: 2, False: 3.62M] ------------------ 1196| 2|#line 46 "src/lexer.l" 1197| 2|{ yy_pop_state(yyscanner); } 1198| 2| YY_BREAK ------------------ | | 1070| 2|#define YY_BREAK /*LINTED*/break; ------------------ 1199| 1.75k|case 4: ------------------ | Branch (1199:1): [True: 1.75k, False: 3.62M] ------------------ 1200| 1.75k|YY_RULE_SETUP ------------------ | | 1074| 1.75k| YY_USER_ACTION | | ------------------ | | | | 811| 1.75k| do { \ | | | | 812| 1.75k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1.75k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1.75k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1.75k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1.75k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1.75k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1.75k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1.75k] | | | | ------------------ | | ------------------ ------------------ 1201| 1.75k|#line 48 "src/lexer.l" 1202| 1.75k|{ return NEQ; } ------------------ | | 138| 1.75k|#define NEQ 267 ------------------ 1203| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1204| 14.3k|case 5: ------------------ | Branch (1204:1): [True: 14.3k, False: 3.61M] ------------------ 1205| 14.3k|YY_RULE_SETUP ------------------ | | 1074| 14.3k| YY_USER_ACTION | | ------------------ | | | | 811| 14.3k| do { \ | | | | 812| 14.3k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 14.3k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 14.3k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 14.3k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 14.3k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 14.3k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 14.3k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 14.3k] | | | | ------------------ | | ------------------ ------------------ 1206| 14.3k|#line 49 "src/lexer.l" 1207| 14.3k|{ return EQ; } ------------------ | | 137| 14.3k|#define EQ 266 ------------------ 1208| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1209| 11.6k|case 6: ------------------ | Branch (1209:1): [True: 11.6k, False: 3.61M] ------------------ 1210| 11.6k|YY_RULE_SETUP ------------------ | | 1074| 11.6k| YY_USER_ACTION | | ------------------ | | | | 811| 11.6k| do { \ | | | | 812| 11.6k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 11.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 11.6k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 11.6k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 11.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 11.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 11.6k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 11.6k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 11.6k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 11.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 11.6k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 11.6k] | | | | ------------------ | | ------------------ ------------------ 1211| 11.6k|#line 50 "src/lexer.l" 1212| 11.6k|{ return AS; } ------------------ | | 140| 11.6k|#define AS 269 ------------------ 1213| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1214| 1.29k|case 7: ------------------ | Branch (1214:1): [True: 1.29k, False: 3.62M] ------------------ 1215| 1.29k|YY_RULE_SETUP ------------------ | | 1074| 1.29k| YY_USER_ACTION | | ------------------ | | | | 811| 1.29k| do { \ | | | | 812| 1.29k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1.29k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1.29k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1.29k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1.29k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1.29k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1.29k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1.29k] | | | | ------------------ | | ------------------ ------------------ 1216| 1.29k|#line 51 "src/lexer.l" 1217| 1.29k|{ return IMPORT; } ------------------ | | 143| 1.29k|#define IMPORT 272 ------------------ 1218| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1219| 472|case 8: ------------------ | Branch (1219:1): [True: 472, False: 3.62M] ------------------ 1220| 472|YY_RULE_SETUP ------------------ | | 1074| 472| YY_USER_ACTION | | ------------------ | | | | 811| 472| do { \ | | | | 812| 472| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 472| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 472|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 472| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 472| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 472| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 472|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 472| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 472|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 472| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 472| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 472] | | | | ------------------ | | ------------------ ------------------ 1221| 472|#line 52 "src/lexer.l" 1222| 472|{ return INCLUDE; } ------------------ | | 144| 472|#define INCLUDE 273 ------------------ 1223| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1224| 289|case 9: ------------------ | Branch (1224:1): [True: 289, False: 3.62M] ------------------ 1225| 289|YY_RULE_SETUP ------------------ | | 1074| 289| YY_USER_ACTION | | ------------------ | | | | 811| 289| do { \ | | | | 812| 289| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 289| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 289|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 289| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 289| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 289| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 289|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 289| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 289|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 289| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 289| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 289] | | | | ------------------ | | ------------------ ------------------ 1226| 289|#line 53 "src/lexer.l" 1227| 289|{ return MODULE; } ------------------ | | 142| 289|#define MODULE 271 ------------------ 1228| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1229| 20.6k|case 10: ------------------ | Branch (1229:1): [True: 20.6k, False: 3.60M] ------------------ 1230| 20.6k|YY_RULE_SETUP ------------------ | | 1074| 20.6k| YY_USER_ACTION | | ------------------ | | | | 811| 20.6k| do { \ | | | | 812| 20.6k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 20.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 20.6k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 20.6k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 20.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 20.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 20.6k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 20.6k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 20.6k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 20.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 20.6k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 20.6k] | | | | ------------------ | | ------------------ ------------------ 1231| 20.6k|#line 54 "src/lexer.l" 1232| 20.6k|{ return DEF; } ------------------ | | 141| 20.6k|#define DEF 270 ------------------ 1233| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1234| 6.44k|case 11: ------------------ | Branch (1234:1): [True: 6.44k, False: 3.62M] ------------------ 1235| 6.44k|YY_RULE_SETUP ------------------ | | 1074| 6.44k| YY_USER_ACTION | | ------------------ | | | | 811| 6.44k| do { \ | | | | 812| 6.44k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 6.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 6.44k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 6.44k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 6.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 6.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 6.44k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 6.44k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 6.44k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 6.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 6.44k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 6.44k] | | | | ------------------ | | ------------------ ------------------ 1236| 6.44k|#line 55 "src/lexer.l" 1237| 6.44k|{ return IF; } ------------------ | | 145| 6.44k|#define IF 274 ------------------ 1238| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1239| 8.49k|case 12: ------------------ | Branch (1239:1): [True: 8.49k, False: 3.61M] ------------------ 1240| 8.49k|YY_RULE_SETUP ------------------ | | 1074| 8.49k| YY_USER_ACTION | | ------------------ | | | | 811| 8.49k| do { \ | | | | 812| 8.49k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 8.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 8.49k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 8.49k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 8.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 8.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 8.49k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 8.49k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 8.49k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 8.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 8.49k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 8.49k] | | | | ------------------ | | ------------------ ------------------ 1241| 8.49k|#line 56 "src/lexer.l" 1242| 8.49k|{ return THEN; } ------------------ | | 146| 8.49k|#define THEN 275 ------------------ 1243| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1244| 4.89k|case 13: ------------------ | Branch (1244:1): [True: 4.89k, False: 3.62M] ------------------ 1245| 4.89k|YY_RULE_SETUP ------------------ | | 1074| 4.89k| YY_USER_ACTION | | ------------------ | | | | 811| 4.89k| do { \ | | | | 812| 4.89k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 4.89k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 4.89k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 4.89k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 4.89k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 4.89k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 4.89k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 4.89k] | | | | ------------------ | | ------------------ ------------------ 1246| 4.89k|#line 57 "src/lexer.l" 1247| 4.89k|{ return ELSE; } ------------------ | | 147| 4.89k|#define ELSE 276 ------------------ 1248| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1249| 2.24k|case 14: ------------------ | Branch (1249:1): [True: 2.24k, False: 3.62M] ------------------ 1250| 2.24k|YY_RULE_SETUP ------------------ | | 1074| 2.24k| YY_USER_ACTION | | ------------------ | | | | 811| 2.24k| do { \ | | | | 812| 2.24k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 2.24k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 2.24k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 2.24k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 2.24k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 2.24k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 2.24k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 2.24k] | | | | ------------------ | | ------------------ ------------------ 1251| 2.24k|#line 58 "src/lexer.l" 1252| 2.24k|{ return ELSE_IF; } ------------------ | | 148| 2.24k|#define ELSE_IF 277 ------------------ 1253| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1254| 4.19k|case 15: ------------------ | Branch (1254:1): [True: 4.19k, False: 3.62M] ------------------ 1255| 4.19k|YY_RULE_SETUP ------------------ | | 1074| 4.19k| YY_USER_ACTION | | ------------------ | | | | 811| 4.19k| do { \ | | | | 812| 4.19k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 4.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 4.19k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 4.19k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 4.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 4.19k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 4.19k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 4.19k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 4.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 4.19k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 4.19k] | | | | ------------------ | | ------------------ ------------------ 1256| 4.19k|#line 59 "src/lexer.l" 1257| 4.19k|{ return AND; } ------------------ | | 152| 4.19k|#define AND 281 ------------------ 1258| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1259| 604|case 16: ------------------ | Branch (1259:1): [True: 604, False: 3.62M] ------------------ 1260| 604|YY_RULE_SETUP ------------------ | | 1074| 604| YY_USER_ACTION | | ------------------ | | | | 811| 604| do { \ | | | | 812| 604| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 604|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 604| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 604|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 604| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 604|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 604| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 604] | | | | ------------------ | | ------------------ ------------------ 1261| 604|#line 60 "src/lexer.l" 1262| 604|{ return OR; } ------------------ | | 153| 604|#define OR 282 ------------------ 1263| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1264| 5.88k|case 17: ------------------ | Branch (1264:1): [True: 5.88k, False: 3.62M] ------------------ 1265| 5.88k|YY_RULE_SETUP ------------------ | | 1074| 5.88k| YY_USER_ACTION | | ------------------ | | | | 811| 5.88k| do { \ | | | | 812| 5.88k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 5.88k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 5.88k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 5.88k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 5.88k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 5.88k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 5.88k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 5.88k] | | | | ------------------ | | ------------------ ------------------ 1266| 5.88k|#line 61 "src/lexer.l" 1267| 5.88k|{ return END; } ------------------ | | 151| 5.88k|#define END 280 ------------------ 1268| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1269| 2.17k|case 18: ------------------ | Branch (1269:1): [True: 2.17k, False: 3.62M] ------------------ 1270| 2.17k|YY_RULE_SETUP ------------------ | | 1074| 2.17k| YY_USER_ACTION | | ------------------ | | | | 811| 2.17k| do { \ | | | | 812| 2.17k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 2.17k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 2.17k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 2.17k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 2.17k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 2.17k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 2.17k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 2.17k] | | | | ------------------ | | ------------------ ------------------ 1271| 2.17k|#line 62 "src/lexer.l" 1272| 2.17k|{ return REDUCE; } ------------------ | | 149| 2.17k|#define REDUCE 278 ------------------ 1273| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1274| 725|case 19: ------------------ | Branch (1274:1): [True: 725, False: 3.62M] ------------------ 1275| 725|YY_RULE_SETUP ------------------ | | 1074| 725| YY_USER_ACTION | | ------------------ | | | | 811| 725| do { \ | | | | 812| 725| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 725|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 725| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 725|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 725| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 725|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 725| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 725] | | | | ------------------ | | ------------------ ------------------ 1276| 725|#line 63 "src/lexer.l" 1277| 725|{ return FOREACH; } ------------------ | | 150| 725|#define FOREACH 279 ------------------ 1278| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1279| 30.2k|case 20: ------------------ | Branch (1279:1): [True: 30.2k, False: 3.59M] ------------------ 1280| 30.2k|YY_RULE_SETUP ------------------ | | 1074| 30.2k| YY_USER_ACTION | | ------------------ | | | | 811| 30.2k| do { \ | | | | 812| 30.2k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 30.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 30.2k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 30.2k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 30.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 30.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 30.2k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 30.2k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 30.2k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 30.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 30.2k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 30.2k] | | | | ------------------ | | ------------------ ------------------ 1281| 30.2k|#line 64 "src/lexer.l" 1282| 30.2k|{ return DEFINEDOR; } ------------------ | | 139| 30.2k|#define DEFINEDOR 268 ------------------ 1283| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1284| 624|case 21: ------------------ | Branch (1284:1): [True: 624, False: 3.62M] ------------------ 1285| 624|YY_RULE_SETUP ------------------ | | 1074| 624| YY_USER_ACTION | | ------------------ | | | | 811| 624| do { \ | | | | 812| 624| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 624| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 624|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 624| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 624| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 624| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 624|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 624| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 624|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 624| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 624| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 624] | | | | ------------------ | | ------------------ ------------------ 1286| 624|#line 65 "src/lexer.l" 1287| 624|{ return TRY; } ------------------ | | 154| 624|#define TRY 283 ------------------ 1288| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1289| 635|case 22: ------------------ | Branch (1289:1): [True: 635, False: 3.62M] ------------------ 1290| 635|YY_RULE_SETUP ------------------ | | 1074| 635| YY_USER_ACTION | | ------------------ | | | | 811| 635| do { \ | | | | 812| 635| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 635| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 635|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 635| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 635| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 635| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 635|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 635| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 635|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 635| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 635| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 635] | | | | ------------------ | | ------------------ ------------------ 1291| 635|#line 66 "src/lexer.l" 1292| 635|{ return CATCH; } ------------------ | | 155| 635|#define CATCH 284 ------------------ 1293| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1294| 2.36k|case 23: ------------------ | Branch (1294:1): [True: 2.36k, False: 3.62M] ------------------ 1295| 2.36k|YY_RULE_SETUP ------------------ | | 1074| 2.36k| YY_USER_ACTION | | ------------------ | | | | 811| 2.36k| do { \ | | | | 812| 2.36k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 2.36k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 2.36k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 2.36k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 2.36k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 2.36k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 2.36k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 2.36k] | | | | ------------------ | | ------------------ ------------------ 1296| 2.36k|#line 67 "src/lexer.l" 1297| 2.36k|{ return LABEL; } ------------------ | | 156| 2.36k|#define LABEL 285 ------------------ 1298| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1299| 1.18k|case 24: ------------------ | Branch (1299:1): [True: 1.18k, False: 3.62M] ------------------ 1300| 1.18k|YY_RULE_SETUP ------------------ | | 1074| 1.18k| YY_USER_ACTION | | ------------------ | | | | 811| 1.18k| do { \ | | | | 812| 1.18k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1.18k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1.18k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1.18k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1.18k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1.18k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1.18k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1.18k] | | | | ------------------ | | ------------------ ------------------ 1301| 1.18k|#line 68 "src/lexer.l" 1302| 1.18k|{ return BREAK; } ------------------ | | 157| 1.18k|#define BREAK 286 ------------------ 1303| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1304| 0|case 25: ------------------ | Branch (1304:1): [True: 0, False: 3.62M] ------------------ 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; } ------------------ | | 158| 0|#define LOC 287 ------------------ 1308| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1309| 389|case 26: ------------------ | Branch (1309:1): [True: 389, False: 3.62M] ------------------ 1310| 389|YY_RULE_SETUP ------------------ | | 1074| 389| YY_USER_ACTION | | ------------------ | | | | 811| 389| do { \ | | | | 812| 389| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 389|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 389| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 389|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 389| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 389|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 389| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 389] | | | | ------------------ | | ------------------ ------------------ 1311| 389|#line 70 "src/lexer.l" 1312| 389|{ return SETPIPE; } ------------------ | | 159| 389|#define SETPIPE 288 ------------------ 1313| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1314| 46.7k|case 27: ------------------ | Branch (1314:1): [True: 46.7k, False: 3.58M] ------------------ 1315| 46.7k|YY_RULE_SETUP ------------------ | | 1074| 46.7k| YY_USER_ACTION | | ------------------ | | | | 811| 46.7k| do { \ | | | | 812| 46.7k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 46.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 46.7k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 46.7k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 46.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 46.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 46.7k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 46.7k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 46.7k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 46.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 46.7k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 46.7k] | | | | ------------------ | | ------------------ ------------------ 1316| 46.7k|#line 71 "src/lexer.l" 1317| 46.7k|{ return SETPLUS; } ------------------ | | 160| 46.7k|#define SETPLUS 289 ------------------ 1318| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1319| 1.08k|case 28: ------------------ | Branch (1319:1): [True: 1.08k, False: 3.62M] ------------------ 1320| 1.08k|YY_RULE_SETUP ------------------ | | 1074| 1.08k| YY_USER_ACTION | | ------------------ | | | | 811| 1.08k| do { \ | | | | 812| 1.08k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1.08k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1.08k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1.08k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1.08k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1.08k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1.08k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1.08k] | | | | ------------------ | | ------------------ ------------------ 1321| 1.08k|#line 72 "src/lexer.l" 1322| 1.08k|{ return SETMINUS; } ------------------ | | 161| 1.08k|#define SETMINUS 290 ------------------ 1323| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1324| 1|case 29: ------------------ | Branch (1324:1): [True: 1, False: 3.62M] ------------------ 1325| 1|YY_RULE_SETUP ------------------ | | 1074| 1| YY_USER_ACTION | | ------------------ | | | | 811| 1| do { \ | | | | 812| 1| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1326| 1|#line 73 "src/lexer.l" 1327| 1|{ return SETMULT; } ------------------ | | 162| 1|#define SETMULT 291 ------------------ 1328| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1329| 2.31k|case 30: ------------------ | Branch (1329:1): [True: 2.31k, False: 3.62M] ------------------ 1330| 2.31k|YY_RULE_SETUP ------------------ | | 1074| 2.31k| YY_USER_ACTION | | ------------------ | | | | 811| 2.31k| do { \ | | | | 812| 2.31k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 2.31k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 2.31k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 2.31k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 2.31k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 2.31k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 2.31k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ ------------------ 1331| 2.31k|#line 74 "src/lexer.l" 1332| 2.31k|{ return SETDIV; } ------------------ | | 163| 2.31k|#define SETDIV 292 ------------------ 1333| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1334| 160|case 31: ------------------ | Branch (1334:1): [True: 160, False: 3.62M] ------------------ 1335| 160|YY_RULE_SETUP ------------------ | | 1074| 160| YY_USER_ACTION | | ------------------ | | | | 811| 160| do { \ | | | | 812| 160| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 160| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 160|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 160| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 160| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 160| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 160|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 160| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 160|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 160| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 160| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 160] | | | | ------------------ | | ------------------ ------------------ 1336| 160|#line 75 "src/lexer.l" 1337| 160|{ return SETMOD; } ------------------ | | 136| 160|#define SETMOD 265 ------------------ 1338| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1339| 658|case 32: ------------------ | Branch (1339:1): [True: 658, False: 3.62M] ------------------ 1340| 658|YY_RULE_SETUP ------------------ | | 1074| 658| YY_USER_ACTION | | ------------------ | | | | 811| 658| do { \ | | | | 812| 658| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 658| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 658|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 658| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 658| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 658| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 658|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 658| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 658|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 658| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 658| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 658] | | | | ------------------ | | ------------------ ------------------ 1341| 658|#line 76 "src/lexer.l" 1342| 658|{ return SETDEFINEDOR; } ------------------ | | 164| 658|#define SETDEFINEDOR 293 ------------------ 1343| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1344| 1.07k|case 33: ------------------ | Branch (1344:1): [True: 1.07k, False: 3.62M] ------------------ 1345| 1.07k|YY_RULE_SETUP ------------------ | | 1074| 1.07k| YY_USER_ACTION | | ------------------ | | | | 811| 1.07k| do { \ | | | | 812| 1.07k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1.07k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1.07k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1.07k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1.07k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1.07k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1.07k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1.07k] | | | | ------------------ | | ------------------ ------------------ 1346| 1.07k|#line 77 "src/lexer.l" 1347| 1.07k|{ return LESSEQ; } ------------------ | | 165| 1.07k|#define LESSEQ 294 ------------------ 1348| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1349| 325|case 34: ------------------ | Branch (1349:1): [True: 325, False: 3.62M] ------------------ 1350| 325|YY_RULE_SETUP ------------------ | | 1074| 325| YY_USER_ACTION | | ------------------ | | | | 811| 325| do { \ | | | | 812| 325| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 325| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 325|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 325| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 325| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 325| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 325|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 325| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 325|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 325| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 325| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 325] | | | | ------------------ | | ------------------ ------------------ 1351| 325|#line 78 "src/lexer.l" 1352| 325|{ return GREATEREQ; } ------------------ | | 166| 325|#define GREATEREQ 295 ------------------ 1353| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1354| 2.23k|case 35: ------------------ | Branch (1354:1): [True: 2.23k, False: 3.62M] ------------------ 1355| 2.23k|YY_RULE_SETUP ------------------ | | 1074| 2.23k| YY_USER_ACTION | | ------------------ | | | | 811| 2.23k| do { \ | | | | 812| 2.23k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 2.23k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 2.23k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 2.23k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 2.23k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 2.23k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 2.23k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 2.23k] | | | | ------------------ | | ------------------ ------------------ 1356| 2.23k|#line 79 "src/lexer.l" 1357| 2.23k|{ return REC; } ------------------ | | 135| 2.23k|#define REC 264 ------------------ 1358| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1359| 611k|case 36: ------------------ | Branch (1359:1): [True: 611k, False: 3.01M] ------------------ 1360| 611k|YY_RULE_SETUP ------------------ | | 1074| 611k| YY_USER_ACTION | | ------------------ | | | | 811| 611k| do { \ | | | | 812| 611k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 611k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 611k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 611k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 611k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 611k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 611k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 611k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 611k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 611k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 611k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 611k] | | | | ------------------ | | ------------------ ------------------ 1361| 611k|#line 80 "src/lexer.l" 1362| 611k|{ return yytext[0];} ------------------ | | 360| 611k|#define yytext yyg->yytext_r ------------------ 1363| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1364| 776k|case 37: ------------------ | Branch (1364:1): [True: 776k, False: 2.85M] ------------------ 1365| 776k|YY_RULE_SETUP ------------------ | | 1074| 776k| YY_USER_ACTION | | ------------------ | | | | 811| 776k| do { \ | | | | 812| 776k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 776k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 776k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 776k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 776k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 776k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 776k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 776k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 776k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 776k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 776k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 776k] | | | | ------------------ | | ------------------ ------------------ 1366| 776k|#line 82 "src/lexer.l" 1367| 776k|{ 1368| 776k| return enter(yytext[0], YY_START, yyscanner); ------------------ | | 360| 776k|#define yytext yyg->yytext_r ------------------ return enter(yytext[0], YY_START, yyscanner); ------------------ | | 374| 776k|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 1369| 0|} 1370| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1371| 387k|case 38: ------------------ | Branch (1371:1): [True: 387k, False: 3.24M] ------------------ 1372| 387k|YY_RULE_SETUP ------------------ | | 1074| 387k| YY_USER_ACTION | | ------------------ | | | | 811| 387k| do { \ | | | | 812| 387k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 387k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 387k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 387k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 387k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 387k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 387k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 387k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 387k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 387k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 387k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 387k] | | | | ------------------ | | ------------------ ------------------ 1373| 387k|#line 86 "src/lexer.l" 1374| 387k|{ 1375| 387k| return try_exit(yytext[0], YY_START, yyscanner); ------------------ | | 360| 387k|#define yytext yyg->yytext_r ------------------ return try_exit(yytext[0], YY_START, yyscanner); ------------------ | | 374| 387k|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 1376| 0|} 1377| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1378| 1.45k|case 39: ------------------ | Branch (1378:1): [True: 1.45k, False: 3.62M] ------------------ 1379| 1.45k|YY_RULE_SETUP ------------------ | | 1074| 1.45k| YY_USER_ACTION | | ------------------ | | | | 811| 1.45k| do { \ | | | | 812| 1.45k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 1.45k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 1.45k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 1.45k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 1.45k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 1.45k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 1.45k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 1.45k] | | | | ------------------ | | ------------------ ------------------ 1380| 1.45k|#line 90 "src/lexer.l" 1381| 1.45k|{ 1382| 1.45k| yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 886| 1.45k| # define yylval yyg->yylval_r ------------------ yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 360| 1.45k|#define yytext yyg->yytext_r ------------------ yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 359| 1.45k|#define yyleng yyg->yyleng_r ------------------ yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT; ------------------ | | 134| 1.45k|#define FORMAT 263 ------------------ 1383| 0|} 1384| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1385| 307k|case 40: ------------------ | Branch (1385:1): [True: 307k, False: 3.32M] ------------------ 1386| 307k|YY_RULE_SETUP ------------------ | | 1074| 307k| YY_USER_ACTION | | ------------------ | | | | 811| 307k| do { \ | | | | 812| 307k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 307k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 307k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 307k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 307k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 307k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 307k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 307k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 307k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 307k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 307k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 307k] | | | | ------------------ | | ------------------ ------------------ 1387| 307k|#line 94 "src/lexer.l" 1388| 307k|{ 1389| 307k| yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 886| 307k| # define yylval yyg->yylval_r ------------------ yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 360| 307k|#define yytext yyg->yytext_r ------------------ yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 359| 307k|#define yyleng yyg->yyleng_r ------------------ yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; ------------------ | | 133| 307k|#define LITERAL 262 ------------------ 1390| 0|} 1391| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1392| 35.8k|case 41: ------------------ | Branch (1392:1): [True: 35.8k, False: 3.59M] ------------------ 1393| 35.8k|YY_RULE_SETUP ------------------ | | 1074| 35.8k| YY_USER_ACTION | | ------------------ | | | | 811| 35.8k| do { \ | | | | 812| 35.8k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 35.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 35.8k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 35.8k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 35.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 35.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 35.8k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 35.8k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 35.8k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 35.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 35.8k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 35.8k] | | | | ------------------ | | ------------------ ------------------ 1394| 35.8k|#line 98 "src/lexer.l" 1395| 35.8k|{ 1396| 35.8k| yy_push_state(IN_QQSTRING, yyscanner); ------------------ | | 831| 35.8k|#define IN_QQSTRING 5 ------------------ 1397| 35.8k| return QQSTRING_START; ------------------ | | 167| 35.8k|#define QQSTRING_START 296 ------------------ 1398| 0|} 1399| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1400| | 1401| 6.03k|case 42: ------------------ | Branch (1401:1): [True: 6.03k, False: 3.62M] ------------------ 1402| 6.03k|YY_RULE_SETUP ------------------ | | 1074| 6.03k| YY_USER_ACTION | | ------------------ | | | | 811| 6.03k| do { \ | | | | 812| 6.03k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 6.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 6.03k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 6.03k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 6.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 6.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 6.03k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 6.03k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 6.03k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 6.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 6.03k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 6.03k] | | | | ------------------ | | ------------------ ------------------ 1403| 6.03k|#line 104 "src/lexer.l" 1404| 6.03k|{ 1405| 6.03k| return enter(QQSTRING_INTERP_START, YY_START, yyscanner); ------------------ | | 169| 6.03k|#define QQSTRING_INTERP_START 298 ------------------ return enter(QQSTRING_INTERP_START, YY_START, yyscanner); ------------------ | | 374| 6.03k|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 1406| 0| } 1407| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1408| 30.0k|case 43: ------------------ | Branch (1408:1): [True: 30.0k, False: 3.59M] ------------------ 1409| 30.0k|YY_RULE_SETUP ------------------ | | 1074| 30.0k| YY_USER_ACTION | | ------------------ | | | | 811| 30.0k| do { \ | | | | 812| 30.0k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 30.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 30.0k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 30.0k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 30.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 30.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 30.0k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 30.0k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 30.0k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 30.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 30.0k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 30.0k] | | | | ------------------ | | ------------------ ------------------ 1410| 30.0k|#line 107 "src/lexer.l" 1411| 30.0k|{ 1412| 30.0k| yy_pop_state(yyscanner); 1413| 30.0k| return QQSTRING_END; ------------------ | | 171| 30.0k|#define QQSTRING_END 300 ------------------ 1414| 0| } 1415| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1416| 196k|case 44: ------------------ | Branch (1416:1): [True: 196k, False: 3.43M] ------------------ 1417| |/* rule 44 can match eol */ 1418| 196k|YY_RULE_SETUP ------------------ | | 1074| 196k| YY_USER_ACTION | | ------------------ | | | | 811| 196k| do { \ | | | | 812| 196k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 196k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 196k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 196k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 196k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 196k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 196k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 196k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 196k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 196k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 196k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 196k] | | | | ------------------ | | ------------------ ------------------ 1419| 196k|#line 111 "src/lexer.l" 1420| 196k|{ 1421| | /* pass escapes to the json parser */ 1422| 196k| jv escapes = jv_string_fmt("\"%.*s\"", (int)yyleng, yytext); ------------------ | | 359| 196k|#define yyleng yyg->yyleng_r ------------------ jv escapes = jv_string_fmt("\"%.*s\"", (int)yyleng, yytext); ------------------ | | 360| 196k|#define yytext yyg->yytext_r ------------------ 1423| 196k| yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length_bytes(jv_copy(escapes))); ------------------ | | 886| 196k| # define yylval yyg->yylval_r ------------------ 1424| 196k| jv_free(escapes); 1425| 196k| return QQSTRING_TEXT; ------------------ | | 168| 196k|#define QQSTRING_TEXT 297 ------------------ 1426| 0| } 1427| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1428| 216k|case 45: ------------------ | Branch (1428:1): [True: 216k, False: 3.41M] ------------------ 1429| |/* rule 45 can match eol */ 1430| 216k|YY_RULE_SETUP ------------------ | | 1074| 216k| YY_USER_ACTION | | ------------------ | | | | 811| 216k| do { \ | | | | 812| 216k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 216k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 216k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 216k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 216k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 216k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 216k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 216k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 216k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 216k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 216k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 216k] | | | | ------------------ | | ------------------ ------------------ 1431| 216k|#line 118 "src/lexer.l" 1432| 216k|{ 1433| 216k| yylval->literal = jv_string_sized(yytext, yyleng); ------------------ | | 886| 216k| # define yylval yyg->yylval_r ------------------ yylval->literal = jv_string_sized(yytext, yyleng); ------------------ | | 360| 216k|#define yytext yyg->yytext_r ------------------ yylval->literal = jv_string_sized(yytext, yyleng); ------------------ | | 359| 216k|#define yyleng yyg->yyleng_r ------------------ 1434| 216k| return QQSTRING_TEXT; ------------------ | | 168| 216k|#define QQSTRING_TEXT 297 ------------------ 1435| 0| } 1436| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1437| 16|case 46: ------------------ | Branch (1437:1): [True: 16, False: 3.62M] ------------------ 1438| 16|YY_RULE_SETUP ------------------ | | 1074| 16| YY_USER_ACTION | | ------------------ | | | | 811| 16| do { \ | | | | 812| 16| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 16|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 16| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 16|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 16| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 16|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 16| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 16] | | | | ------------------ | | ------------------ ------------------ 1439| 16|#line 122 "src/lexer.l" 1440| 16|{ 1441| 16| return INVALID_CHARACTER; ------------------ | | 129| 16|#define INVALID_CHARACTER 258 ------------------ 1442| 0| } 1443| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1444| | 1445| 278k|case 47: ------------------ | Branch (1445:1): [True: 278k, False: 3.35M] ------------------ 1446| 278k|YY_RULE_SETUP ------------------ | | 1074| 278k| YY_USER_ACTION | | ------------------ | | | | 811| 278k| do { \ | | | | 812| 278k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 278k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 278k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 278k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 278k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 278k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 278k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 278k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 278k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 278k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 278k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 278k] | | | | ------------------ | | ------------------ ------------------ 1447| 278k|#line 128 "src/lexer.l" 1448| 278k|{ yylval->literal = jv_string(yytext); return IDENT;} ------------------ | | 886| 278k| # define yylval yyg->yylval_r ------------------ { yylval->literal = jv_string(yytext); return IDENT;} ------------------ | | 360| 278k|#define yytext yyg->yytext_r ------------------ { yylval->literal = jv_string(yytext); return IDENT;} ------------------ | | 130| 278k|#define IDENT 259 ------------------ 1449| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1450| 5.99k|case 48: ------------------ | Branch (1450:1): [True: 5.99k, False: 3.62M] ------------------ 1451| 5.99k|YY_RULE_SETUP ------------------ | | 1074| 5.99k| YY_USER_ACTION | | ------------------ | | | | 811| 5.99k| do { \ | | | | 812| 5.99k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 5.99k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 5.99k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 5.99k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 5.99k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 5.99k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 5.99k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 5.99k] | | | | ------------------ | | ------------------ ------------------ 1452| 5.99k|#line 129 "src/lexer.l" 1453| 5.99k|{ yylval->literal = jv_string(yytext+1); return FIELD;} ------------------ | | 886| 5.99k| # define yylval yyg->yylval_r ------------------ { yylval->literal = jv_string(yytext+1); return FIELD;} ------------------ | | 360| 5.99k|#define yytext yyg->yytext_r ------------------ { yylval->literal = jv_string(yytext+1); return FIELD;} ------------------ | | 131| 5.99k|#define FIELD 260 ------------------ 1454| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1455| 62.5k|case 49: ------------------ | Branch (1455:1): [True: 62.5k, False: 3.56M] ------------------ 1456| 62.5k|YY_RULE_SETUP ------------------ | | 1074| 62.5k| YY_USER_ACTION | | ------------------ | | | | 811| 62.5k| do { \ | | | | 812| 62.5k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 62.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 62.5k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 62.5k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 62.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 62.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 62.5k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 62.5k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 62.5k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 62.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 62.5k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 62.5k] | | | | ------------------ | | ------------------ ------------------ 1457| 62.5k|#line 130 "src/lexer.l" 1458| 62.5k|{ yylval->literal = jv_string(yytext+1); return BINDING;} ------------------ | | 886| 62.5k| # define yylval yyg->yylval_r ------------------ { yylval->literal = jv_string(yytext+1); return BINDING;} ------------------ | | 360| 62.5k|#define yytext yyg->yytext_r ------------------ { yylval->literal = jv_string(yytext+1); return BINDING;} ------------------ | | 132| 62.5k|#define BINDING 261 ------------------ 1459| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1460| 237k|case 50: ------------------ | Branch (1460:1): [True: 237k, False: 3.39M] ------------------ 1461| |/* rule 50 can match eol */ 1462| 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] | | | | ------------------ | | ------------------ ------------------ 1463| 237k|#line 132 "src/lexer.l" 1464| 237k|{} 1465| 237k| YY_BREAK ------------------ | | 1070| 237k|#define YY_BREAK /*LINTED*/break; ------------------ 1466| 92.1k|case 51: ------------------ | Branch (1466:1): [True: 92.1k, False: 3.53M] ------------------ 1467| 92.1k|YY_RULE_SETUP ------------------ | | 1074| 92.1k| YY_USER_ACTION | | ------------------ | | | | 811| 92.1k| do { \ | | | | 812| 92.1k| yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 888| 92.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->start = yyget_extra(yyscanner); \ | | | | ------------------ | | | | | | 134| 92.1k|#define yyget_extra jq_yyget_extra | | | | ------------------ | | | | 813| 92.1k| yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 92.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 888| 92.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->end = yylloc->start + yyleng; \ | | | | ------------------ | | | | | | 359| 92.1k|#define yyleng yyg->yyleng_r | | | | ------------------ | | | | 814| 92.1k| yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 140| 92.1k|#define yyset_extra jq_yyset_extra | | | | ------------------ | | | | yyset_extra(yylloc->end, yyscanner); \ | | | | ------------------ | | | | | | 888| 92.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 815| 92.1k| } while (0); | | | | ------------------ | | | | | Branch (815:12): [Folded, False: 92.1k] | | | | ------------------ | | ------------------ ------------------ 1468| 92.1k|#line 134 "src/lexer.l" 1469| 92.1k|{ return INVALID_CHARACTER; } ------------------ | | 129| 92.1k|#define INVALID_CHARACTER 258 ------------------ 1470| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1471| 0|case 52: ------------------ | Branch (1471:1): [True: 0, False: 3.62M] ------------------ 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 136 "src/lexer.l" 1474| 0|YY_FATAL_ERROR( "flex scanner jammed" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1475| 0| YY_BREAK ------------------ | | 1070| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1476| 0|#line 1476 "src/lexer.c" 1477| 385|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 385|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 385|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ | Branch (1477:1): [True: 385, False: 3.62M] ------------------ 1478| 421|case YY_STATE_EOF(IN_PAREN): ------------------ | | 377| 421|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 421|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ | Branch (1478:1): [True: 36, False: 3.62M] ------------------ 1479| 522|case YY_STATE_EOF(IN_BRACKET): ------------------ | | 377| 522|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 522|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ | Branch (1479:1): [True: 101, False: 3.62M] ------------------ 1480| 599|case YY_STATE_EOF(IN_BRACE): ------------------ | | 377| 599|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 599|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ | Branch (1480:1): [True: 77, False: 3.62M] ------------------ 1481| 599|case YY_STATE_EOF(IN_QQINTERP): ------------------ | | 377| 599|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 599|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ | Branch (1481:1): [True: 0, False: 3.62M] ------------------ 1482| 662|case YY_STATE_EOF(IN_QQSTRING): ------------------ | | 377| 662|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 662|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ | Branch (1482:1): [True: 63, False: 3.62M] ------------------ 1483| 662| yyterminate(); ------------------ | | 1033| 662|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 662|#define YY_NULL 0 | | ------------------ ------------------ 1484| | 1485| 1.24k| case YY_END_OF_BUFFER: ------------------ | | 577| 1.24k|#define YY_END_OF_BUFFER 53 ------------------ | Branch (1485:2): [True: 1.24k, False: 3.62M] ------------------ 1486| 1.24k| { 1487| | /* Amount of text matched not including the EOB char. */ 1488| 1.24k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 560| 1.24k|#define yytext_ptr yytext_r ------------------ 1489| | 1490| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1491| 1.24k| *yy_cp = yyg->yy_hold_char; 1492| 1.24k| YY_RESTORE_YY_MORE_OFFSET 1493| | 1494| 1.24k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 508| 1.24k|#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| 1.24k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1494:8): [True: 683, False: 563] ------------------ 1495| 683| { 1496| | /* We're scanning a new file or input source. It's 1497| | * possible that this happened because the user 1498| | * just pointed yyin at a new source and called 1499| | * yylex(). If so, then we have to assure 1500| | * consistency between YY_CURRENT_BUFFER and our 1501| | * globals. Here is the right place to do so, because 1502| | * this is the first action (other than possibly a 1503| | * back-up) that will match for the new input source. 1504| | */ 1505| 683| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 683|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1506| 683| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 508| 683|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 683|#define yyin yyg->yyin_r ------------------ 1507| 683| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 508| 683|#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| 683|#define YY_BUFFER_NORMAL 1 ------------------ 1508| 683| } 1509| | 1510| | /* Note that here we test for yy_c_buf_p "<=" to the position 1511| | * of the first EOB in the buffer, since yy_c_buf_p will 1512| | * already have been incremented past the NUL character 1513| | * (since all states make transitions on EOB to the 1514| | * end-of-buffer state). Contrast this with the test 1515| | * in input(). 1516| | */ 1517| 1.24k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 508| 1.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1517:8): [True: 0, False: 1.24k] ------------------ 1518| 0| { /* This was really a NUL. */ 1519| 0| yy_state_type yy_next_state; 1520| | 1521| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 1522| | 1523| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1524| | 1525| | /* Okay, we're now positioned to make the NUL 1526| | * transition. We couldn't have 1527| | * yy_get_previous_state() go ahead and do it 1528| | * for us because it doesn't know how to deal 1529| | * with the possibility of jamming (and we don't 1530| | * want to build jamming into it because then it 1531| | * will run more slowly). 1532| | */ 1533| | 1534| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1535| | 1536| 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 ------------------ 1537| | 1538| 0| if ( yy_next_state ) ------------------ | Branch (1538:9): [True: 0, False: 0] ------------------ 1539| 0| { 1540| | /* Consume the NUL. */ 1541| 0| yy_cp = ++yyg->yy_c_buf_p; 1542| 0| yy_current_state = yy_next_state; 1543| 0| goto yy_match; 1544| 0| } 1545| | 1546| 0| else 1547| 0| { 1548| 0| yy_cp = yyg->yy_c_buf_p; 1549| 0| goto yy_find_action; 1550| 0| } 1551| 0| } 1552| | 1553| 1.24k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1553:17): [True: 1.24k, False: 0] ------------------ 1554| 1.24k| { 1555| 664| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 664|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1555:4): [True: 664, False: 582] ------------------ 1556| 664| { 1557| 664| yyg->yy_did_buffer_switch_on_eof = 0; 1558| | 1559| 664| if ( yywrap( yyscanner ) ) ------------------ | | 206| 664|#define yywrap jq_yywrap | | ------------------ | | | | 554| 664|#define jq_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (554:30): [True: 664, Folded] | | | | ------------------ | | ------------------ ------------------ 1560| 664| { 1561| | /* Note: because we've taken care in 1562| | * yy_get_next_buffer() to have set up 1563| | * yytext, we can now set up 1564| | * yy_c_buf_p so that if some total 1565| | * hoser (like flex itself) wants to 1566| | * call the scanner after we return the 1567| | * YY_NULL, it'll still work - another 1568| | * YY_NULL will get returned. 1569| | */ 1570| 664| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 664|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 798| 664|#define YY_MORE_ADJ 0 ------------------ 1571| | 1572| 664| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 664|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 664|#define YY_END_OF_BUFFER 53 | | ------------------ ------------------ 1573| 664| goto do_action; 1574| 664| } 1575| | 1576| 0| else 1577| 0| { 1578| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1578:11): [True: 0, False: 0] ------------------ 1579| 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 | | ------------------ ------------------ 1580| 0| } 1581| 0| break; 1582| 664| } 1583| | 1584| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1584:4): [True: 0, False: 1.24k] ------------------ 1585| 0| yyg->yy_c_buf_p = 1586| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 1587| | 1588| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1589| | 1590| 0| yy_cp = yyg->yy_c_buf_p; 1591| 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 ------------------ 1592| 0| goto yy_match; 1593| | 1594| 582| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 582|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1594:4): [True: 582, False: 664] ------------------ 1595| 582| yyg->yy_c_buf_p = 1596| 582| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 508| 582|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1597| | 1598| 582| yy_current_state = yy_get_previous_state( yyscanner ); 1599| | 1600| 582| yy_cp = yyg->yy_c_buf_p; 1601| 582| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 582|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 798| 582|#define YY_MORE_ADJ 0 ------------------ 1602| 582| goto yy_find_action; 1603| 1.24k| } 1604| 0| break; 1605| 1.24k| } 1606| | 1607| 0| default: ------------------ | Branch (1607:2): [True: 0, False: 3.62M] ------------------ 1608| 0| YY_FATAL_ERROR( ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1609| 3.62M| "fatal flex scanner internal error--no action found" ); 1610| 3.62M| } /* end of action switch */ 1611| 3.62M| } /* end of scanning one token */ 1612| 3.18M| } /* end of user's declarations */ 1613| 3.18M|} /* end of yylex */ jq_yy_switch_to_buffer: 1922| 777|{ 1923| 777| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1924| | 1925| | /* TODO. We should be able to replace this entire function body 1926| | * with 1927| | * yypop_buffer_state(); 1928| | * yypush_buffer_state(new_buffer); 1929| | */ 1930| 777| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 777|#define yyensure_buffer_stack jq_yyensure_buffer_stack ------------------ 1931| 777| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 502| 777|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 777, False: 0] | | ------------------ | | 503| 777| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 777| : NULL) ------------------ | Branch (1931:7): [True: 0, False: 777] ------------------ 1932| 0| return; 1933| | 1934| 777| if ( YY_CURRENT_BUFFER ) ------------------ | | 502| 777|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 777] | | | Branch (502:29): [True: 777, False: 0] | | ------------------ | | 503| 777| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 777| : NULL) ------------------ 1935| 0| { 1936| | /* Flush out information for old buffer. */ 1937| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 1938| 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] ------------------ 1939| 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] ------------------ 1940| 0| } 1941| | 1942| 777| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 508| 777|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1943| 777| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 777|#define yy_load_buffer_state jq_yy_load_buffer_state ------------------ 1944| | 1945| | /* We don't actually know whether we did this switch during 1946| | * EOF (yywrap()) processing, but the only time this flag 1947| | * is looked at is after yywrap() is called, so it's safe 1948| | * to go ahead and always set it. 1949| | */ 1950| 777| yyg->yy_did_buffer_switch_on_eof = 1; 1951| 777|} jq_yy_delete_buffer: 1997| 777|{ 1998| 777| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1999| | 2000| 777| if ( ! b ) ------------------ | Branch (2000:7): [True: 0, False: 777] ------------------ 2001| 0| return; 2002| | 2003| 777| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 502| 777|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 777, False: 0] | | ------------------ | | 503| 777| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 777| : NULL) ------------------ | Branch (2003:7): [True: 777, False: 0] ------------------ 2004| 777| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 508| 777|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2005| | 2006| 777| if ( b->yy_is_our_buffer ) ------------------ | Branch (2006:7): [True: 777, False: 0] ------------------ 2007| 777| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 777|#define yyfree jq_yyfree ------------------ 2008| | 2009| 777| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 777|#define yyfree jq_yyfree ------------------ 2010| 777|} jq_yy_scan_buffer: 2177| 777|{ 2178| 777| YY_BUFFER_STATE b; 2179| | 2180| 777| if ( size < 2 || ------------------ | Branch (2180:7): [True: 0, False: 777] ------------------ 2181| 777| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 380| 1.55k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2181:7): [True: 0, False: 777] ------------------ 2182| 777| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 380| 777|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2182:7): [True: 0, False: 777] ------------------ 2183| | /* They forgot to leave room for the EOB's. */ 2184| 0| return NULL; 2185| | 2186| 777| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 777|#define yyalloc jq_yyalloc ------------------ 2187| 777| if ( ! b ) ------------------ | Branch (2187:7): [True: 0, False: 777] ------------------ 2188| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2189| | 2190| 777| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2191| 777| b->yy_buf_pos = b->yy_ch_buf = base; 2192| 777| b->yy_is_our_buffer = 0; 2193| 777| b->yy_input_file = NULL; 2194| 777| b->yy_n_chars = b->yy_buf_size; 2195| 777| b->yy_is_interactive = 0; 2196| 777| b->yy_at_bol = 1; 2197| 777| b->yy_fill_buffer = 0; 2198| 777| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 479| 777|#define YY_BUFFER_NEW 0 ------------------ 2199| | 2200| 777| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 777|#define yy_switch_to_buffer jq_yy_switch_to_buffer ------------------ 2201| | 2202| 777| return b; 2203| 777|} jq_yy_scan_bytes: 2227| 777|{ 2228| 777| YY_BUFFER_STATE b; 2229| 777| char *buf; 2230| 777| yy_size_t n; 2231| 777| int i; 2232| | 2233| | /* Get memory for full buffer, including space for trailing EOB's. */ 2234| 777| n = (yy_size_t) (_yybytes_len + 2); 2235| 777| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 236| 777|#define yyalloc jq_yyalloc ------------------ 2236| 777| if ( ! buf ) ------------------ | Branch (2236:7): [True: 0, False: 777] ------------------ 2237| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2238| | 2239| 40.4M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (2239:15): [True: 40.4M, False: 777] ------------------ 2240| 40.4M| buf[i] = yybytes[i]; 2241| | 2242| 777| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 777|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2243| | 2244| 777| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 777|#define yy_scan_buffer jq_yy_scan_buffer ------------------ 2245| 777| if ( ! b ) ------------------ | Branch (2245:7): [True: 0, False: 777] ------------------ 2246| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2247| | 2248| | /* It's okay to grow etc. this buffer, and we should throw it 2249| | * away when we're done. 2250| | */ 2251| 777| b->yy_is_our_buffer = 1; 2252| | 2253| 777| return b; 2254| 777|} jq_yyget_extra: 2332| 3.62M|{ 2333| 3.62M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2334| 3.62M| return yyextra; ------------------ | | 358| 3.62M|#define yyextra yyg->yyextra_r ------------------ 2335| 3.62M|} jq_yyset_extra: 2405| 3.62M|{ 2406| 3.62M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2407| 3.62M| yyextra = user_defined ; ------------------ | | 358| 3.62M|#define yyextra yyg->yyextra_r ------------------ 2408| 3.62M|} jq_yylex_init_extra: 2530| 777|{ 2531| 777| struct yyguts_t dummy_yyguts; 2532| | 2533| 777| yyset_extra (yy_user_defined, &dummy_yyguts); ------------------ | | 140| 777|#define yyset_extra jq_yyset_extra ------------------ 2534| | 2535| 777| if (ptr_yy_globals == NULL){ ------------------ | Branch (2535:9): [True: 0, False: 777] ------------------ 2536| 0| errno = EINVAL; 2537| 0| return 1; 2538| 0| } 2539| | 2540| 777| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); ------------------ | | 236| 777|#define yyalloc jq_yyalloc ------------------ 2541| | 2542| 777| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2542:9): [True: 0, False: 777] ------------------ 2543| 0| errno = ENOMEM; 2544| 0| return 1; 2545| 0| } 2546| | 2547| | /* By setting to 0xAA, we expose bugs in 2548| | yy_init_globals. Leave at 0x00 for releases. */ 2549| 777| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2550| | 2551| 777| yyset_extra (yy_user_defined, *ptr_yy_globals); ------------------ | | 140| 777|#define yyset_extra jq_yyset_extra ------------------ 2552| | 2553| 777| return yy_init_globals ( *ptr_yy_globals ); 2554| 777|} jq_yylex_destroy: 2591| 777|{ 2592| 777| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2593| | 2594| | /* Pop the buffer stack, destroying each element. */ 2595| 777| while(YY_CURRENT_BUFFER){ ------------------ | | 502| 777|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 777] | | | Branch (502:29): [True: 777, False: 0] | | ------------------ | | 503| 777| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 777| : NULL) ------------------ 2596| 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) ------------------ 2597| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2598| 0| yypop_buffer_state(yyscanner); ------------------ | | 80| 0|#define yypop_buffer_state jq_yypop_buffer_state ------------------ 2599| 0| } 2600| | 2601| | /* Destroy the stack itself. */ 2602| 777| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 777|#define yyfree jq_yyfree ------------------ 2603| 777| yyg->yy_buffer_stack = NULL; 2604| | 2605| | /* Destroy the start condition stack. */ 2606| 777| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 777|#define yyfree jq_yyfree ------------------ 2607| 777| yyg->yy_start_stack = NULL; 2608| | 2609| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2610| | * yylex() is called, initialization will occur. */ 2611| 777| yy_init_globals( yyscanner); 2612| | 2613| | /* Destroy the main struct (reentrant only). */ 2614| 777| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 777|#define yyfree jq_yyfree ------------------ 2615| | yyscanner = NULL; 2616| 777| return 0; 2617| 777|} jq_yyalloc: 2696| 3.67k|void* yyalloc(size_t sz, void* extra) { 2697| 3.67k| return jv_mem_alloc(sz); 2698| 3.67k|} jq_yyrealloc: 2699| 21.1k|void* yyrealloc(void* p, size_t sz, void* extra) { 2700| 21.1k| return jv_mem_realloc(p, sz); 2701| 21.1k|} jq_yyfree: 2702| 3.88k|void yyfree(void* p, void* extra) { 2703| 3.88k| jv_mem_free(p); 2704| 3.88k|} lexer.c:yy_get_next_buffer: 1623| 1.24k|{ 1624| 1.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1625| 1.24k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 508| 1.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1626| 1.24k| char *source = yyg->yytext_ptr; ------------------ | | 560| 1.24k|#define yytext_ptr yytext_r ------------------ 1627| 1.24k| int number_to_move, i; 1628| 1.24k| int ret_val; 1629| | 1630| 1.24k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 508| 1.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1630:7): [True: 0, False: 1.24k] ------------------ 1631| 0| YY_FATAL_ERROR( ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1632| 1.24k| "fatal flex scanner internal error--end of buffer missed" ); 1633| | 1634| 1.24k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 508| 1.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1634:7): [True: 1.24k, False: 0] ------------------ 1635| 1.24k| { /* Don't try to fill the buffer, so this is an EOF. */ 1636| 1.24k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 560| 1.24k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 798| 1.24k|#define YY_MORE_ADJ 0 ------------------ | Branch (1636:8): [True: 664, False: 582] ------------------ 1637| 664| { 1638| | /* We matched a single character, the EOB, so 1639| | * treat this as a final EOF. 1640| | */ 1641| 664| return EOB_ACT_END_OF_FILE; ------------------ | | 410| 664|#define EOB_ACT_END_OF_FILE 1 ------------------ 1642| 664| } 1643| | 1644| 582| else 1645| 582| { 1646| | /* We matched some text prior to the EOB, first 1647| | * process it. 1648| | */ 1649| 582| return EOB_ACT_LAST_MATCH; ------------------ | | 411| 582|#define EOB_ACT_LAST_MATCH 2 ------------------ 1650| 582| } 1651| 1.24k| } 1652| | 1653| | /* Try to read more data. */ 1654| | 1655| | /* First move last chars to start of buffer. */ 1656| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 1657| | 1658| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1658:15): [True: 0, False: 0] ------------------ 1659| 0| *(dest++) = *(source++); 1660| | 1661| 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 (1661:7): [True: 0, False: 0] ------------------ 1662| | /* don't do the read, it's not guaranteed to return an EOF, 1663| | * just force an EOF 1664| | */ 1665| 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] ------------------ 1666| | 1667| 0| else 1668| 0| { 1669| 0| int num_to_read = 1670| 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] ------------------ 1671| | 1672| 0| while ( num_to_read <= 0 ) ------------------ | Branch (1672:11): [True: 0, False: 0] ------------------ 1673| 0| { /* Not enough room in the buffer - grow it. */ 1674| | 1675| | /* just a shorter name for the current buffer */ 1676| 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] ------------------ 1677| | 1678| 0| int yy_c_buf_p_offset = 1679| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1680| | 1681| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (1681:9): [True: 0, False: 0] ------------------ 1682| 0| { 1683| 0| int new_size = b->yy_buf_size * 2; 1684| | 1685| 0| if ( new_size <= 0 ) ------------------ | Branch (1685:10): [True: 0, False: 0] ------------------ 1686| 0| b->yy_buf_size += b->yy_buf_size / 8; 1687| 0| else 1688| 0| b->yy_buf_size *= 2; 1689| | 1690| 0| b->yy_ch_buf = (char *) 1691| | /* Include room in for 2 EOB chars. */ 1692| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 0|#define yyrealloc jq_yyrealloc ------------------ 1693| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1694| 0| } 1695| 0| else 1696| | /* Can't grow it, we don't own it. */ 1697| 0| b->yy_ch_buf = NULL; 1698| | 1699| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (1699:9): [True: 0, False: 0] ------------------ 1700| 0| YY_FATAL_ERROR( ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 1701| 0| "fatal error - scanner input buffer overflow" ); 1702| | 1703| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1704| | 1705| 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] ------------------ 1706| 0| number_to_move - 1; 1707| | 1708| 0| } 1709| | 1710| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 980| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1710:8): [True: 0, False: 0] ------------------ 1711| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 980| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 1712| | 1713| | /* Read in more data. */ 1714| 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| }\ ------------------ 1715| 0| yyg->yy_n_chars, num_to_read ); 1716| | 1717| 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] ------------------ 1718| 0| } 1719| | 1720| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1720:7): [True: 0, False: 0] ------------------ 1721| 0| { 1722| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 798| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1722:8): [True: 0, False: 0] ------------------ 1723| 0| { 1724| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1725| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart jq_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 1726| 0| } 1727| | 1728| 0| else 1729| 0| { 1730| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1731| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1732| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 491| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1733| 0| } 1734| 0| } 1735| | 1736| 0| else 1737| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1738| | 1739| 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 (1739:6): [True: 0, False: 0] ------------------ 1740| | /* Extend the array by 50%, plus the number we really need. */ 1741| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1742| 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 ------------------ 1743| 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] ------------------ 1744| 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 (1744:8): [True: 0, False: 0] ------------------ 1745| 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) ------------------ 1746| | /* "- 2" to take care of EOB's */ 1747| 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] ------------------ 1748| 0| } 1749| | 1750| 0| yyg->yy_n_chars += number_to_move; 1751| 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 ------------------ 1752| 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 ------------------ 1753| | 1754| 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] ------------------ 1755| | 1756| 0| return ret_val; 1757| 0|} lexer.c:yy_get_previous_state: 1762| 582|{ 1763| 582| yy_state_type yy_current_state; 1764| 582| char *yy_cp; 1765| 582| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1766| | 1767| 582| yy_current_state = yyg->yy_start; 1768| | 1769| 10.1M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 560| 582|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 798| 582|#define YY_MORE_ADJ 0 ------------------ | Branch (1769:47): [True: 10.1M, False: 582] ------------------ 1770| 10.1M| { 1771| 10.1M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 346| 10.1M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1771:19): [True: 10.1M, False: 0] ------------------ 1772| 10.1M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1772:8): [True: 10.1M, False: 45.8k] ------------------ 1773| 10.1M| { 1774| 10.1M| yyg->yy_last_accepting_state = yy_current_state; 1775| 10.1M| yyg->yy_last_accepting_cpos = yy_cp; 1776| 10.1M| } 1777| 11.9M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1777:11): [True: 1.79M, False: 10.1M] ------------------ 1778| 1.79M| { 1779| 1.79M| yy_current_state = (int) yy_def[yy_current_state]; 1780| 1.79M| if ( yy_current_state >= 168 ) ------------------ | Branch (1780:9): [True: 1.79M, False: 132] ------------------ 1781| 1.79M| yy_c = yy_meta[yy_c]; 1782| 1.79M| } 1783| 10.1M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1784| 10.1M| } 1785| | 1786| 582| return yy_current_state; 1787| 582|} lexer.c:jq_yy_load_buffer_state: 1954| 1.55k|{ 1955| 1.55k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1956| 1.55k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 1.55k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1957| 1.55k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 560| 1.55k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 508| 1.55k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1958| 1.55k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 1.55k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 508| 1.55k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1959| 1.55k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1960| 1.55k|} lexer.c:jq_yyensure_buffer_stack: 2127| 777|{ 2128| 777| yy_size_t num_to_alloc; 2129| 777| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2130| | 2131| 777| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2131:6): [True: 777, False: 0] ------------------ 2132| | 2133| | /* First allocation is just for 2 elements, since we don't know if this 2134| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2135| | * immediate realloc on the next call. 2136| | */ 2137| 777| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2138| 777| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 777|#define yyalloc jq_yyalloc ------------------ 2139| 777| (num_to_alloc * sizeof(struct yy_buffer_state*) 2140| 777| , yyscanner); 2141| 777| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2141:8): [True: 0, False: 777] ------------------ 2142| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2143| | 2144| 777| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2145| | 2146| 777| yyg->yy_buffer_stack_max = num_to_alloc; 2147| 777| yyg->yy_buffer_stack_top = 0; 2148| 777| return; 2149| 777| } 2150| | 2151| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2151:6): [True: 0, False: 0] ------------------ 2152| | 2153| | /* Increase the buffer to prepare for a possible push. */ 2154| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2155| | 2156| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2157| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 242| 0|#define yyrealloc jq_yyrealloc ------------------ 2158| 0| (yyg->yy_buffer_stack, 2159| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2160| 0| , yyscanner); 2161| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2161:8): [True: 0, False: 0] ------------------ 2162| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2163| | 2164| | /* zero only the new slots.*/ 2165| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2166| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2167| 0| } 2168| 0|} lexer.c:yy_push_state: 2257| 822k|{ 2258| 822k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2259| 822k| if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) ------------------ | Branch (2259:7): [True: 21.7k, False: 800k] ------------------ 2260| 21.7k| { 2261| 21.7k| yy_size_t new_size; 2262| | 2263| 21.7k| yyg->yy_start_stack_depth += YY_START_STACK_INCR; ------------------ | | 1038| 21.7k|#define YY_START_STACK_INCR 25 ------------------ 2264| 21.7k| new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int ); 2265| | 2266| 21.7k| if ( ! yyg->yy_start_stack ) ------------------ | Branch (2266:8): [True: 568, False: 21.1k] ------------------ 2267| 568| yyg->yy_start_stack = (int *) yyalloc( new_size , yyscanner ); ------------------ | | 236| 568|#define yyalloc jq_yyalloc ------------------ 2268| | 2269| 21.1k| else 2270| 21.1k| yyg->yy_start_stack = (int *) yyrealloc( ------------------ | | 242| 21.1k|#define yyrealloc jq_yyrealloc ------------------ 2271| 21.1k| (void *) yyg->yy_start_stack, new_size , yyscanner ); 2272| | 2273| 21.7k| if ( ! yyg->yy_start_stack ) ------------------ | Branch (2273:8): [True: 0, False: 21.7k] ------------------ 2274| 0| YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2275| 21.7k| } 2276| | 2277| 822k| yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START; ------------------ | | 374| 822k|#define YY_START ((yyg->yy_start - 1) / 2) ------------------ 2278| | 2279| 822k| BEGIN(_new_state); ------------------ | | 369| 822k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ 2280| 822k|} lexer.c:yy_pop_state: 2283| 416k|{ 2284| 416k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2285| 416k| if ( --yyg->yy_start_stack_ptr < 0 ) ------------------ | Branch (2285:7): [True: 0, False: 416k] ------------------ 2286| 0| YY_FATAL_ERROR( "start-condition stack underflow" ); ------------------ | | 1043| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 2287| | 2288| 416k| BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]); ------------------ | | 369| 416k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ 2289| 416k|} lexer.c:yy_init_globals: 2557| 1.55k|{ 2558| 1.55k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2559| | /* Initialization is the same as for the non-reentrant scanner. 2560| | * This function is called from yylex_destroy(), so don't allocate here. 2561| | */ 2562| | 2563| 1.55k| yyg->yy_buffer_stack = NULL; 2564| 1.55k| yyg->yy_buffer_stack_top = 0; 2565| 1.55k| yyg->yy_buffer_stack_max = 0; 2566| 1.55k| yyg->yy_c_buf_p = NULL; 2567| 1.55k| yyg->yy_init = 0; 2568| 1.55k| yyg->yy_start = 0; 2569| | 2570| 1.55k| yyg->yy_start_stack_ptr = 0; 2571| 1.55k| yyg->yy_start_stack_depth = 0; 2572| 1.55k| yyg->yy_start_stack = NULL; 2573| | 2574| |/* Defined in main.c */ 2575| |#ifdef YY_STDINIT 2576| | yyin = stdin; 2577| | yyout = stdout; 2578| |#else 2579| 1.55k| yyin = NULL; ------------------ | | 356| 1.55k|#define yyin yyg->yyin_r ------------------ 2580| 1.55k| yyout = NULL; ------------------ | | 357| 1.55k|#define yyout yyg->yyout_r ------------------ 2581| 1.55k|#endif 2582| | 2583| | /* For future reference: Set errno on error, since we are called by 2584| | * yylex_init() 2585| | */ 2586| 1.55k| return 0; 2587| 1.55k|} lexer.c:try_exit: 2656| 387k|static int try_exit(int c, int state, yyscan_t yyscanner) { 2657| 387k| char match = 0; 2658| 387k| int ret; 2659| 387k| switch (state) { 2660| 59.8k| case IN_PAREN: match = ret = ')'; break; ------------------ | | 827| 59.8k|#define IN_PAREN 1 ------------------ | Branch (2660:3): [True: 59.8k, False: 327k] ------------------ 2661| 235k| case IN_BRACKET: match = ret = ']'; break; ------------------ | | 828| 235k|#define IN_BRACKET 2 ------------------ | Branch (2661:3): [True: 235k, False: 151k] ------------------ 2662| 91.6k| case IN_BRACE: match = ret = '}'; break; ------------------ | | 829| 91.6k|#define IN_BRACE 3 ------------------ | Branch (2662:3): [True: 91.6k, False: 295k] ------------------ 2663| | 2664| 348| case IN_QQINTERP: ------------------ | | 830| 348|#define IN_QQINTERP 4 ------------------ | Branch (2664:3): [True: 348, False: 386k] ------------------ 2665| 348| match = ')'; 2666| 348| ret = QQSTRING_INTERP_END; ------------------ | | 170| 348|#define QQSTRING_INTERP_END 299 ------------------ 2667| 348| break; 2668| | 2669| 22| default: ------------------ | Branch (2669:3): [True: 22, False: 387k] ------------------ 2670| | // may not be the best error to give 2671| 22| return INVALID_CHARACTER; ------------------ | | 129| 22|#define INVALID_CHARACTER 258 ------------------ 2672| 387k| } 2673| 387k| assert(match); ------------------ | Branch (2673:3): [True: 0, False: 387k] | Branch (2673:3): [True: 387k, False: 0] ------------------ 2674| 387k| if (match == c) { ------------------ | Branch (2674:7): [True: 382k, False: 5.12k] ------------------ 2675| 382k| yy_pop_state(yyscanner); 2676| 382k| return ret; 2677| 382k| } else { 2678| | // FIXME: should we pop? Give a better error at least 2679| 5.12k| return INVALID_CHARACTER; ------------------ | | 129| 5.12k|#define INVALID_CHARACTER 258 ------------------ 2680| 5.12k| } 2681| 387k|} lexer.c:enter: 2683| 782k|static int enter(int c, int currstate, yyscan_t yyscanner) { 2684| 782k| int state = 0; 2685| 782k| switch (c) { ------------------ | Branch (2685:11): [True: 782k, False: 0] ------------------ 2686| 70.7k| case '(': state = IN_PAREN; break; ------------------ | | 827| 70.7k|#define IN_PAREN 1 ------------------ | Branch (2686:3): [True: 70.7k, False: 711k] ------------------ 2687| 573k| case '[': state = IN_BRACKET; break; ------------------ | | 828| 573k|#define IN_BRACKET 2 ------------------ | Branch (2687:3): [True: 573k, False: 208k] ------------------ 2688| 132k| case '{': state = IN_BRACE; break; ------------------ | | 829| 132k|#define IN_BRACE 3 ------------------ | Branch (2688:3): [True: 132k, False: 650k] ------------------ 2689| 6.03k| case QQSTRING_INTERP_START: state = IN_QQINTERP; break; ------------------ | | 169| 6.03k|#define QQSTRING_INTERP_START 298 ------------------ case QQSTRING_INTERP_START: state = IN_QQINTERP; break; ------------------ | | 830| 6.03k|#define IN_QQINTERP 4 ------------------ | Branch (2689:3): [True: 6.03k, False: 776k] ------------------ 2690| 782k| } 2691| 782k| assert(state); ------------------ | Branch (2691:3): [True: 0, False: 782k] | Branch (2691:3): [True: 782k, False: 0] ------------------ 2692| 782k| yy_push_state(state, yyscanner); 2693| 782k| return c; 2694| 782k|} load_program: 442| 596|int load_program(jq_state *jq, struct locfile* src, block *out_block) { 443| 596| int nerrors = 0; 444| 596| block program; 445| 596| struct lib_loading_state lib_state = {0,0,0}; 446| 596| nerrors = jq_parse(src, &program); 447| 596| if (nerrors) ------------------ | Branch (447:7): [True: 399, False: 197] ------------------ 448| 399| return nerrors; 449| | 450| 197| if (!block_has_main(program)) { ------------------ | Branch (450:7): [True: 0, False: 197] ------------------ 451| 0| jq_report_error(jq, jv_string("jq: error: Top-level program not given (try \".\")")); 452| 0| block_free(program); 453| 0| return 1; 454| 0| } 455| | 456| 197| jv home = get_home(); 457| 197| if (jv_is_valid(home)) { ------------------ | Branch (457:7): [True: 197, False: 0] ------------------ 458| | /* Import ~/.jq as a library named "" found in $HOME or %USERPROFILE% */ 459| 197| block import = gen_import_meta(gen_import(jv_string(""), jv_invalid(), 0), 460| 197| gen_const(JV_OBJECT( ------------------ | | 218| 197| JV_OBJECT_IDX(__VA_ARGS__, \ | | ------------------ | | | | 216| 197|#define JV_OBJECT_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,NAME,...) NAME | | | | ------------------ | | | | | | 222| 197| JV_OBJECT_6, JV_OBJECT_5, JV_OBJECT_4, JV_OBJECT_3, \ | | | | | | ------------------ | | | | | | | | 191| 197|#define JV_OBJECT_4(k1,v1,k2,v2) (jv_object_set(JV_OBJECT_2((k1),(v1)),(k2),(v2))) | | | | | | | | ------------------ | | | | | | | | | | 189| 197|#define JV_OBJECT_2(k1,v1) (jv_object_set(jv_object(),(k1),(v1))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 219| 197| JV_OBJECT_18, JV_OBJECT_17, JV_OBJECT_16, JV_OBJECT_15, \ | | 220| 197| JV_OBJECT_14, JV_OBJECT_13, JV_OBJECT_12, JV_OBJECT_11, \ | | 221| 197| JV_OBJECT_10, JV_OBJECT_9, JV_OBJECT_8, JV_OBJECT_7, \ | | 222| 197| JV_OBJECT_6, JV_OBJECT_5, JV_OBJECT_4, JV_OBJECT_3, \ | | 223| 197| JV_OBJECT_2, JV_OBJECT_1)(__VA_ARGS__) ------------------ 461| 197| jv_string("optional"), jv_true(), 462| 197| jv_string("search"), home))); 463| 197| program = BLOCK(import, program); ------------------ | | 102| 197| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 197|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 197| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 197|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 464| 197| } else { // silently ignore if home dir not determined 465| 0| jv_free(home); 466| 0| } 467| | 468| 197| nerrors = process_dependencies(jq, jq_get_jq_origin(jq), jq_get_prog_origin(jq), &program, &lib_state); 469| 197| block libs = gen_noop(); 470| 197| for (uint64_t i = 0; i < lib_state.ct; ++i) { ------------------ | Branch (470:24): [True: 0, False: 197] ------------------ 471| 0| free(lib_state.entries[i].name); 472| 0| if (nerrors == 0 && !block_is_const(lib_state.entries[i].def)) ------------------ | Branch (472:9): [True: 0, False: 0] | Branch (472:25): [True: 0, False: 0] ------------------ 473| 0| libs = block_join(libs, lib_state.entries[i].def); 474| 0| else 475| 0| block_free(lib_state.entries[i].def); 476| 0| } 477| 197| free(lib_state.entries); 478| 197| if (nerrors) ------------------ | Branch (478:7): [True: 16, False: 181] ------------------ 479| 16| block_free(program); 480| 181| else 481| 181| *out_block = block_drop_unreferenced(block_join(libs, program)); 482| | 483| 197| return nerrors; 484| 197|} linker.c:find_lib: 148| 197|static jv find_lib(jq_state *jq, jv rel_path, jv search, const char *suffix, jv jq_origin, jv lib_origin) { 149| 197| if (!jv_is_valid(rel_path)) { ------------------ | Branch (149:7): [True: 8, False: 189] ------------------ 150| 8| jv_free(search); 151| 8| jv_free(jq_origin); 152| 8| jv_free(lib_origin); 153| 8| return rel_path; 154| 8| } 155| 189| if (jv_get_kind(rel_path) != JV_KIND_STRING) { ------------------ | Branch (155:7): [True: 0, False: 189] ------------------ 156| 0| jv_free(rel_path); 157| 0| jv_free(search); 158| 0| jv_free(jq_origin); 159| 0| jv_free(lib_origin); 160| 0| return jv_invalid_with_msg(jv_string_fmt("Module path must be a string")); 161| 0| } 162| 189| if (jv_get_kind(search) != JV_KIND_ARRAY) { ------------------ | Branch (162:7): [True: 0, False: 189] ------------------ 163| 0| jv_free(rel_path); 164| 0| jv_free(search); 165| 0| jv_free(jq_origin); 166| 0| jv_free(lib_origin); 167| 0| return jv_invalid_with_msg(jv_string_fmt("Module search path must be an array")); 168| 0| } 169| | 170| 189| struct stat st; 171| 189| int ret; 172| | 173| | // Ideally we should cache this somewhere 174| 189| search = build_lib_search_chain(jq, search, jq_origin, lib_origin); 175| 189| jv err = jv_array_get(jv_copy(search), 1); 176| 189| search = jv_array_get(search, 0); 177| | 178| 189| jv bname = jv_basename(jv_copy(rel_path)); 179| | 180| 189| jv_array_foreach(search, i, spath) { ------------------ | | 102| 189| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 378| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 189, False: 189] | | ------------------ | | 104| 189| for (jv x; \ | | 105| 378| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 189, False: 189] | | | Branch (105:10): [True: 189, False: 189] | | ------------------ | | 106| 378| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 189| i++) ------------------ 181| 189| if (jv_get_kind(spath) == JV_KIND_NULL) { ------------------ | Branch (181:9): [True: 0, False: 189] ------------------ 182| 0| jv_free(spath); 183| 0| break; 184| 0| } 185| 189| if (jv_get_kind(spath) != JV_KIND_STRING || ------------------ | Branch (185:9): [True: 0, False: 189] ------------------ 186| 189| strcmp(jv_string_value(spath), "") == 0) { ------------------ | Branch (186:9): [True: 0, False: 189] ------------------ 187| 0| jv_free(spath); 188| 0| continue; /* XXX report non-strings in search path?? */ 189| 0| } 190| | // Try ${search_dir}/${rel_path}.jq 191| 189| jv testpath = jq_realpath(jv_string_fmt("%s/%s%s", 192| 189| jv_string_value(spath), 193| 189| jv_string_value(rel_path), 194| 189| suffix)); 195| 189| ret = stat(jv_string_value(testpath),&st); 196| 189| if (ret == -1 && errno == ENOENT) { ------------------ | Branch (196:9): [True: 189, False: 0] | Branch (196:22): [True: 181, False: 8] ------------------ 197| 181| jv_free(testpath); 198| | // Try ${search_dir}/$(dirname ${rel_path})/jq/main.jq 199| 181| testpath = jq_realpath(jv_string_fmt("%s/%s/%s%s", 200| 181| jv_string_value(spath), 201| 181| jv_string_value(rel_path), 202| 181| "jq/main", 203| 181| suffix)); 204| 181| ret = stat(jv_string_value(testpath),&st); 205| 181| } 206| 189| if (ret == -1 && errno == ENOENT) { ------------------ | Branch (206:9): [True: 189, False: 0] | Branch (206:22): [True: 181, False: 8] ------------------ 207| 181| jv_free(testpath); 208| | // Try ${search_dir}/${rel_path}/$(basename ${rel_path}).jq 209| 181| testpath = jq_realpath(jv_string_fmt("%s/%s/%s%s", 210| 181| jv_string_value(spath), 211| 181| jv_string_value(rel_path), 212| 181| jv_string_value(bname), 213| 181| suffix)); 214| 181| ret = stat(jv_string_value(testpath),&st); 215| 181| } 216| 189| if (ret == 0) { ------------------ | Branch (216:9): [True: 0, False: 189] ------------------ 217| 0| jv_free(err); 218| 0| jv_free(rel_path); 219| 0| jv_free(search); 220| 0| jv_free(bname); 221| 0| jv_free(spath); 222| 0| return testpath; 223| 0| } 224| 189| jv_free(testpath); 225| 189| jv_free(spath); 226| 189| } 227| 189| jv output; 228| 189| if (!jv_is_valid(err)) { ------------------ | Branch (228:7): [True: 0, False: 189] ------------------ 229| 0| err = jv_invalid_get_msg(err); 230| 0| output = jv_invalid_with_msg(jv_string_fmt("module not found: %s (%s)", 231| 0| jv_string_value(rel_path), 232| 0| jv_string_value(err))); 233| 189| } else { 234| 189| output = jv_invalid_with_msg(jv_string_fmt("module not found: %s", 235| 189| jv_string_value(rel_path))); 236| 189| } 237| 189| jv_free(err); 238| 189| jv_free(rel_path); 239| 189| jv_free(search); 240| 189| jv_free(bname); 241| 189| return output; 242| 189|} linker.c:build_lib_search_chain: 58| 189|static jv build_lib_search_chain(jq_state *jq, jv search_path, jv jq_origin, jv lib_origin) { 59| 189| assert(jv_get_kind(search_path) == JV_KIND_ARRAY); ------------------ | Branch (59:3): [True: 0, False: 189] | Branch (59:3): [True: 189, False: 0] ------------------ 60| 189| jv expanded = jv_array(); 61| 189| jv expanded_elt; 62| 189| jv err = jv_null(); 63| 189| jv_array_foreach(search_path, i, path) { ------------------ | | 102| 189| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 378| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 189, False: 189] | | ------------------ | | 104| 189| for (jv x; \ | | 105| 378| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 189, False: 189] | | | Branch (105:10): [True: 189, False: 189] | | ------------------ | | 106| 378| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 189| i++) ------------------ 64| 189| if (jv_get_kind(path) != JV_KIND_STRING) { ------------------ | Branch (64:9): [True: 0, False: 189] ------------------ 65| 0| jv_free(path); 66| 0| continue; 67| 0| } 68| 189| path = expand_path(path); 69| 189| if (!jv_is_valid(path)) { ------------------ | Branch (69:9): [True: 0, False: 189] ------------------ 70| 0| jv_free(err); 71| 0| err = path; 72| 0| path = jv_null(); 73| 0| continue; 74| 0| } 75| 189| if (strcmp(".",jv_string_value(path)) == 0) { ------------------ | Branch (75:9): [True: 8, False: 181] ------------------ 76| 8| expanded_elt = jv_copy(path); 77| 181| } else if (strncmp("$ORIGIN/",jv_string_value(path),sizeof("$ORIGIN/") - 1) == 0) { ------------------ | Branch (77:16): [True: 0, False: 181] ------------------ 78| 0| expanded_elt = jv_string_fmt("%s/%s", 79| 0| jv_string_value(jq_origin), 80| 0| jv_string_value(path) + sizeof ("$ORIGIN/") - 1); 81| 181| } else if (jv_get_kind(lib_origin) == JV_KIND_STRING && ------------------ | Branch (81:16): [True: 0, False: 181] ------------------ 82| 0| path_is_relative(jv_copy(path))) { ------------------ | Branch (82:16): [True: 0, False: 0] ------------------ 83| 0| expanded_elt = jv_string_fmt("%s/%s", 84| 0| jv_string_value(lib_origin), 85| 0| jv_string_value(path)); 86| 181| } else { 87| 181| expanded_elt = path; 88| 181| path = jv_invalid(); 89| 181| } 90| 189| expanded = jv_array_append(expanded, expanded_elt); 91| 189| jv_free(path); 92| 189| } 93| 189| jv_free(jq_origin); 94| 189| jv_free(lib_origin); 95| 189| jv_free(search_path); 96| 189| return JV_ARRAY(expanded, err); ------------------ | | 120| 189| 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__) | | ------------------ | | | | 118| 189|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 120| 189| 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__) | | | | | | ------------------ | | | | | | | | 110| 189|#define JV_ARRAY_2(e1,e2) (jv_array_append(JV_ARRAY_1(e1),e2)) | | | | | | | | ------------------ | | | | | | | | | | 109| 189|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 97| 189|} linker.c:jv_basename: 137| 189|static jv jv_basename(jv name) { 138| 189| const char *s = jv_string_value(name); 139| 189| const char *p = strrchr(s, '/'); 140| 189| if (!p) ------------------ | Branch (140:7): [True: 181, False: 8] ------------------ 141| 181| return name; 142| 8| jv res = jv_string_fmt("%s", p); 143| 8| jv_free(name); 144| 8| return res; 145| 189|} linker.c:validate_relpath: 102| 197|static jv validate_relpath(jv name) { 103| 197| const char *s = jv_string_value(name); 104| 197| if (strlen(s) != (size_t)jv_string_length_bytes(jv_copy(name))) { ------------------ | Branch (104:7): [True: 0, False: 197] ------------------ 105| 0| jv_free(name); 106| 0| return jv_invalid_with_msg(jv_string("Module path contains a NUL byte")); 107| 0| } 108| 197| if (strchr(s, '\\')) { ------------------ | Branch (108:7): [True: 0, False: 197] ------------------ 109| 0| jv res = jv_invalid_with_msg(jv_string_fmt("Modules must be named by relative paths using '/', not '\\' (%s)", s)); 110| 0| jv_free(name); 111| 0| return res; 112| 0| } 113| 197| jv components = jv_string_split(jv_copy(name), jv_string("/")); 114| 768k| jv_array_foreach(components, i, x) { ------------------ | | 102| 197| for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1; \ | | 103| 386| jv_j__; jv_j__ = 0) \ | | ------------------ | | | Branch (103:8): [True: 197, False: 189] | | ------------------ | | 104| 197| for (jv x; \ | | 105| 768k| i < jv_len__ ? \ | | ------------------ | | | Branch (105:10): [True: 768k, False: 189] | | | Branch (105:10): [True: 768k, False: 189] | | ------------------ | | 106| 768k| (x = jv_array_get(jv_copy(a), i), 1) : 0; \ | | 107| 768k| i++) ------------------ 115| 768k| if (!strcmp(jv_string_value(x), "..")) { ------------------ | Branch (115:9): [True: 0, False: 768k] ------------------ 116| 0| jv_free(x); 117| 0| jv_free(components); 118| 0| jv res = jv_invalid_with_msg(jv_string_fmt("Relative paths to modules may not traverse to parent directories (%s)", s)); 119| 0| jv_free(name); 120| 0| return res; 121| 0| } 122| 768k| if (i > 0 && jv_equal(jv_copy(x), jv_array_get(jv_copy(components), i - 1))) { ------------------ | Branch (122:9): [True: 768k, False: 16] | Branch (122:18): [True: 8, False: 768k] ------------------ 123| 8| jv_free(x); 124| 8| jv_free(components); 125| 8| jv res = jv_invalid_with_msg(jv_string_fmt("module names must not have equal consecutive components: %s", 126| 8| jv_string_value(name))); 127| 8| jv_free(name); 128| 8| return res; 129| 8| } 130| 768k| jv_free(x); 131| 768k| } 132| 189| jv_free(components); 133| 189| return name; 134| 197|} linker.c:process_dependencies: 256| 197|static int process_dependencies(jq_state *jq, jv jq_origin, jv lib_origin, block *src_block, struct lib_loading_state *lib_state) { 257| 197| jv deps = block_take_imports(src_block); 258| 197| block bk = *src_block; 259| 197| int nerrors = 0; 260| | 261| | // XXX This is a backward jv_array_foreach because bindings go in reverse 262| 378| for (int i = jv_array_length(jv_copy(deps)); i > 0; ) { ------------------ | Branch (262:48): [True: 197, False: 181] ------------------ 263| 197| i--; 264| 197| jv dep = jv_array_get(jv_copy(deps), i); 265| | 266| 197| const char *as_str = NULL; 267| 197| int is_data = jv_get_kind(jv_object_get(jv_copy(dep), jv_string("is_data"))) == JV_KIND_TRUE; 268| 197| int raw = 0; 269| 197| jv v = jv_object_get(jv_copy(dep), jv_string("raw")); 270| 197| if (jv_get_kind(v) == JV_KIND_TRUE) ------------------ | Branch (270:9): [True: 0, False: 197] ------------------ 271| 0| raw = 1; 272| 197| int optional = 0; 273| 197| if (jv_get_kind(jv_object_get(jv_copy(dep), jv_string("optional"))) == JV_KIND_TRUE) ------------------ | Branch (273:9): [True: 181, False: 16] ------------------ 274| 181| optional = 1; 275| 197| jv_free(v); 276| 197| jv relpath = validate_relpath(jv_object_get(jv_copy(dep), jv_string("relpath"))); 277| 197| jv as = jv_object_get(jv_copy(dep), jv_string("as")); 278| 197| assert(!jv_is_valid(as) || jv_get_kind(as) == JV_KIND_STRING); ------------------ | Branch (278:5): [True: 197, False: 0] | Branch (278:5): [True: 0, False: 0] | Branch (278:5): [True: 197, False: 0] | Branch (278:5): [True: 0, False: 0] ------------------ 279| 197| if (jv_get_kind(as) == JV_KIND_STRING) ------------------ | Branch (279:9): [True: 0, False: 197] ------------------ 280| 0| as_str = jv_string_value(as); 281| 197| jv search = default_search(jq, jv_object_get(dep, jv_string("search"))); 282| | // dep is now freed; do not reuse 283| | 284| | // find_lib does a lot of work that could be cached... 285| 197| jv resolved = find_lib(jq, relpath, search, is_data ? ".json" : ".jq", jv_copy(jq_origin), jv_copy(lib_origin)); ------------------ | Branch (285:49): [True: 0, False: 197] ------------------ 286| | // XXX ...move the rest of this into a callback. 287| 197| if (!jv_is_valid(resolved)) { ------------------ | Branch (287:9): [True: 197, False: 0] ------------------ 288| 197| jv_free(as); 289| 197| if (optional) { ------------------ | Branch (289:11): [True: 181, False: 16] ------------------ 290| 181| jv_free(resolved); 291| 181| continue; 292| 181| } 293| 16| jv emsg = jv_invalid_get_msg(resolved); 294| 16| jq_report_error(jq, jv_string_fmt("jq: error: %s\n",jv_string_value(emsg))); 295| 16| jv_free(emsg); 296| 16| jv_free(deps); 297| 16| jv_free(jq_origin); 298| 16| jv_free(lib_origin); 299| 16| return 1; 300| 197| } 301| | 302| 0| if (is_data) { ------------------ | Branch (302:9): [True: 0, False: 0] ------------------ 303| | // Can't reuse data libs because the wrong name is bound 304| 0| block dep_def_block; 305| 0| nerrors += load_library(jq, resolved, is_data, raw, optional, as_str, &dep_def_block, lib_state); 306| 0| if (nerrors == 0) { ------------------ | Branch (306:11): [True: 0, False: 0] ------------------ 307| | // Bind as both $data::data and $data for backward compatibility vs common sense 308| 0| bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, as_str); 309| 0| bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, NULL); 310| 0| } 311| 0| } else { 312| 0| uint64_t state_idx = 0; 313| 0| for (; state_idx < lib_state->ct; ++state_idx) { ------------------ | Branch (313:14): [True: 0, False: 0] ------------------ 314| 0| if (strcmp(lib_state->entries[state_idx].name, jv_string_value(resolved)) == 0) ------------------ | Branch (314:13): [True: 0, False: 0] ------------------ 315| 0| break; 316| 0| } 317| | 318| 0| if (state_idx < lib_state->ct) { // Found ------------------ | Branch (318:11): [True: 0, False: 0] ------------------ 319| 0| jv_free(resolved); 320| | // Bind the library to the program 321| 0| bk = block_bind_library(lib_state->entries[state_idx].def, bk, OP_IS_CALL_PSEUDO, as_str); 322| 0| } else { // Not found. Add it to the table before binding. 323| 0| block dep_def_block = gen_noop(); 324| 0| nerrors += load_library(jq, resolved, is_data, raw, optional, as_str, &dep_def_block, lib_state); 325| | // resolved has been freed 326| 0| if (nerrors == 0) { ------------------ | Branch (326:13): [True: 0, False: 0] ------------------ 327| | // Bind the library to the program 328| 0| bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, as_str); 329| 0| } 330| 0| } 331| 0| } 332| | 333| 0| jv_free(as); 334| 0| } 335| 181| jv_free(lib_origin); 336| 181| jv_free(jq_origin); 337| 181| jv_free(deps); 338| 181| return nerrors; 339| 197|} linker.c:default_search: 244| 197|static jv default_search(jq_state *jq, jv value) { 245| 197| if (!jv_is_valid(value)) { ------------------ | Branch (245:7): [True: 16, False: 181] ------------------ 246| | // dependent didn't say; prepend . to system search path listj 247| 16| jv_free(value); 248| 16| return jv_array_concat(JV_ARRAY(jv_string(".")), jq_get_lib_dirs(jq)); ------------------ | | 120| 16| 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__) | | ------------------ | | | | 118| 16|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 120| 16| 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| 16|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 249| 16| } 250| 181| if (jv_get_kind(value) != JV_KIND_ARRAY) ------------------ | Branch (250:7): [True: 181, False: 0] ------------------ 251| 181| return JV_ARRAY(value); ------------------ | | 120| 181| 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__) | | ------------------ | | | | 118| 181|#define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME | | | | ------------------ | | | | | | 120| 181| 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| 181|#define JV_ARRAY_1(e) (jv_array_append(jv_array(),e)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 252| 0| return value; 253| 181|} locfile_init: 12| 777|struct locfile* locfile_init(jq_state *jq, const char *fname, const char* data, int length) { 13| 777| struct locfile* l = jv_mem_alloc(sizeof(struct locfile)); 14| 777| l->jq = jq; 15| 777| l->fname = jv_string(fname); 16| 777| l->data = jv_mem_alloc(length); 17| 777| memcpy((char*)l->data,data,length); 18| 777| l->length = length; 19| 777| l->nlines = 1; 20| 777| l->refct = 1; 21| 40.4M| for (int i=0; inlines++; ------------------ | Branch (22:9): [True: 4.16M, False: 36.2M] ------------------ 23| 40.4M| } 24| 777| l->linemap = jv_mem_calloc(l->nlines + 1, sizeof(int)); 25| 777| l->linemap[0] = 0; 26| 777| int line = 1; 27| 40.4M| for (int i=0; ilinemap[line] = i+1; // at start of line, not of \n 30| 4.16M| line++; 31| 4.16M| } 32| 40.4M| } 33| 777| l->linemap[l->nlines] = length+1; // virtual last \n 34| 777| return l; 35| 777|} locfile_retain: 37| 204k|struct locfile* locfile_retain(struct locfile* l) { 38| 204k| l->refct++; 39| 204k| return l; 40| 204k|} locfile_free: 41| 205k|void locfile_free(struct locfile* l) { 42| 205k| if (--(l->refct) == 0) { ------------------ | Branch (42:7): [True: 777, False: 204k] ------------------ 43| 777| jv_free(l->fname); 44| 777| jv_mem_free(l->linemap); 45| 777| jv_mem_free((char*)l->data); 46| 777| jv_mem_free(l); 47| 777| } 48| 205k|} locfile_get_line: 50| 277k|int locfile_get_line(struct locfile* l, int pos) { 51| 277k| assert(pos < l->length); ------------------ | Branch (51:3): [True: 0, False: 277k] | Branch (51:3): [True: 277k, False: 0] ------------------ 52| 277k| int line = 1; 53| 4.10G| while (l->linemap[line] <= pos) line++; // == if pos at start (before, never ==, because pos never on \n) ------------------ | Branch (53:10): [True: 4.10G, False: 277k] ------------------ 54| 277k| assert(line-1 < l->nlines); ------------------ | Branch (54:3): [True: 0, False: 277k] | Branch (54:3): [True: 277k, False: 0] ------------------ 55| 277k| return line-1; 56| 277k|} locfile_locate: 63| 277k|void locfile_locate(struct locfile* l, location loc, const char* fmt, ...) { 64| 277k| va_list fmtargs; 65| 277k| va_start(fmtargs, fmt); 66| | 67| 277k| jv m1 = jv_string_vfmt(fmt, fmtargs); 68| 277k| va_end(fmtargs); 69| 277k| if (!jv_is_valid(m1)) { ------------------ | Branch (69:7): [True: 0, False: 277k] ------------------ 70| 0| jq_report_error(l->jq, m1); 71| 0| return; 72| 0| } 73| 277k| if (loc.start == -1) { ------------------ | Branch (73:7): [True: 6, False: 277k] ------------------ 74| 6| jq_report_error(l->jq, jv_string_fmt("jq: error: %s", jv_string_value(m1))); 75| 6| jv_free(m1); 76| 6| return; 77| 6| } 78| | 79| 277k| int startline = locfile_get_line(l, loc.start); 80| 277k| int offset = l->linemap[startline]; 81| 277k| int end = MIN(loc.end, MAX(l->linemap[startline+1] - 1, loc.start + 1)); ------------------ | | 71| 277k| ({ __typeof__ (a) _a = (a); \ | | 72| 554k| __typeof__ (b) _b = (b); \ | | ------------------ | | | Branch (72:25): [True: 114k, False: 163k] | | ------------------ | | 73| 277k| _a < _b ? _a : _b; }) | | ------------------ | | | Branch (73:4): [True: 103k, False: 174k] | | ------------------ ------------------ 82| 277k| jv underline = jv_string_repeat(jv_string("^"), end - loc.start); 83| 277k| jv m2 = jv_string_fmt("%s at %s, line %d, column %d:\n %.*s\n %*s", 84| 277k| jv_string_value(m1), jv_string_value(l->fname), 85| 277k| startline + 1, loc.start - offset + 1, 86| 277k| locfile_line_length(l, startline), l->data + offset, 87| 277k| end - offset, jv_string_value(underline)); 88| 277k| jv_free(m1); 89| 277k| jv_free(underline); 90| 277k| jq_report_error(l->jq, m2); 91| 277k| return; 92| 277k|} locfile.c:locfile_line_length: 58| 277k|static int locfile_line_length(struct locfile* l, int line) { 59| 277k| assert(line < l->nlines); ------------------ | Branch (59:3): [True: 0, False: 277k] | Branch (59:3): [True: 277k, False: 0] ------------------ 60| 277k| return l->linemap[line+1] - l->linemap[line] -1; // -1 to omit \n 61| 277k|} yyerror: 404| 276k| struct locfile* locations, struct lexer_param* lexer_param_ptr, const char *s){ 405| 276k| (*errors)++; 406| 276k| locfile_locate(locations, *loc, "jq: error: %s", s); 407| 276k|} yylex: 410| 3.18M| struct locfile* locations, struct lexer_param* lexer_param_ptr) { 411| 3.18M| yyscan_t lexer = lexer_param_ptr->lexer; 412| 3.18M| int tok = jq_yylex(yylval, yylloc, lexer); 413| 3.18M| if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) { ------------------ | | 202| 6.37M|#define LITERAL 262 ------------------ if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) { ------------------ | | 237| 2.87M|#define QQSTRING_TEXT 297 ------------------ | Branch (413:8): [True: 307k, False: 2.87M] | Branch (413:26): [True: 413k, False: 2.46M] | Branch (413:51): [True: 194k, False: 525k] ------------------ 414| 194k| jv msg = jv_invalid_get_msg(jv_copy(yylval->literal)); 415| 194k| if (jv_get_kind(msg) == JV_KIND_STRING) { ------------------ | Branch (415:9): [True: 194k, False: 0] ------------------ 416| 194k| FAIL(*yylloc, jv_string_value(msg)); ------------------ | | 397| 194k| do { \ | | 398| 194k| location l = loc; \ | | 399| 194k| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 194k| /*YYERROR*/; \ | | 401| 194k| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 194k] | | ------------------ ------------------ 417| 194k| } else { 418| 0| FAIL(*yylloc, "Invalid literal"); ------------------ | | 397| 0| do { \ | | 398| 0| location l = loc; \ | | 399| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 0| /*YYERROR*/; \ | | 401| 0| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 0] | | ------------------ ------------------ 419| 0| } 420| 194k| jv_free(msg); 421| 194k| jv_free(yylval->literal); 422| 194k| yylval->literal = jv_null(); 423| 194k| } 424| 3.18M| return tok; 425| 3.18M|} yyparse: 2205| 777|{ 2206| |/* Lookahead token kind. */ 2207| 777|int yychar; 2208| | 2209| | 2210| |/* The semantic value of the lookahead symbol. */ 2211| |/* Default value used for initialization, for pacifying older GCCs 2212| | or non-GCC compilers. */ 2213| 777|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 712| 777|# define YY_INITIAL_VALUE(Value) Value ------------------ 2214| 777|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 712| 777|# define YY_INITIAL_VALUE(Value) Value ------------------ 2215| | 2216| |/* Location data for the lookahead symbol. */ 2217| 777|static YYLTYPE yyloc_default 2218| |# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 2219| | = { 1, 1, 1, 1 } 2220| |# endif 2221| 777|; 2222| 777|YYLTYPE yylloc = yyloc_default; ------------------ | | 122| 777|#define YYLTYPE location ------------------ 2223| | 2224| | /* Number of syntax errors so far. */ 2225| 777| int yynerrs = 0; 2226| | 2227| 777| yy_state_fast_t yystate = 0; 2228| | /* Number of tokens to shift before error messages enabled. */ 2229| 777| int yyerrstatus = 0; 2230| | 2231| | /* Refer to the stacks through separate pointers, to allow yyoverflow 2232| | to reallocate them elsewhere. */ 2233| | 2234| | /* Their size. */ 2235| 777| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 619| 777|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1676| 777|# define YYINITDEPTH 200 ------------------ 2236| | 2237| | /* The state stack: array, bottom, top. */ 2238| 777| yy_state_t yyssa[YYINITDEPTH]; 2239| 777| yy_state_t *yyss = yyssa; 2240| 777| yy_state_t *yyssp = yyss; 2241| | 2242| | /* The semantic value stack: array, bottom, top. */ 2243| 777| YYSTYPE yyvsa[YYINITDEPTH]; 2244| 777| YYSTYPE *yyvs = yyvsa; 2245| 777| YYSTYPE *yyvsp = yyvs; 2246| | 2247| | /* The location stack: array, bottom, top. */ 2248| 777| YYLTYPE yylsa[YYINITDEPTH]; ------------------ | | 122| 777|#define YYLTYPE location ------------------ 2249| 777| YYLTYPE *yyls = yylsa; ------------------ | | 122| 777|#define YYLTYPE location ------------------ 2250| 777| YYLTYPE *yylsp = yyls; ------------------ | | 122| 777|#define YYLTYPE location ------------------ 2251| | 2252| 777| int yyn; 2253| | /* The return value of yyparse. */ 2254| 777| int yyresult; 2255| | /* Lookahead symbol kind. */ 2256| 777| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 2257| | /* The variables used to return semantic value and location from the 2258| | action routines. */ 2259| 777| YYSTYPE yyval; 2260| 777| YYLTYPE yyloc; ------------------ | | 122| 777|#define YYLTYPE location ------------------ 2261| | 2262| | /* The locations where the error started and ended. */ 2263| 777| YYLTYPE yyerror_range[3]; ------------------ | | 122| 777|#define YYLTYPE location ------------------ 2264| | 2265| | /* Buffer for error messages, and its allocated size. */ 2266| 777| char yymsgbuf[128]; 2267| 777| char *yymsg = yymsgbuf; 2268| 777| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 619| 777|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 2269| | 2270| 777|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 2271| | 2272| | /* The number of symbols on the RHS of the reduced rule. 2273| | Keep to zero when no symbol should be popped. */ 2274| 777| int yylen = 0; 2275| | 2276| 777| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1667| 777|# define YYDPRINTF(Args) ((void) 0) ------------------ 2277| | 2278| 777| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 194| 777|#define YYEMPTY -2 ------------------ 2279| | 2280| 777| yylsp[0] = yylloc; 2281| 777| goto yysetstate; 2282| | 2283| | 2284| |/*------------------------------------------------------------. 2285| || yynewstate -- push a new state, which is found in yystate. | 2286| |`------------------------------------------------------------*/ 2287| 6.54M|yynewstate: 2288| | /* In all cases, when you get here, the value and location stacks 2289| | have just been pushed. So pushing a state here evens the stacks. */ 2290| 6.54M| yyssp++; 2291| | 2292| | 2293| |/*--------------------------------------------------------------------. 2294| || yysetstate -- set current state (the top of the stack) to yystate. | 2295| |`--------------------------------------------------------------------*/ 2296| 6.54M|yysetstate: 2297| 6.54M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1667| 6.54M|# define YYDPRINTF(Args) ((void) 0) ------------------ 2298| 6.54M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 735| 6.54M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (735:31): [Folded, False: 6.54M] | | | Branch (735:37): [True: 0, False: 0] | | | Branch (735:37): [True: 0, False: 0] | | ------------------ ------------------ 2299| 6.54M| YY_IGNORE_USELESS_CAST_BEGIN 2300| 6.54M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 89| 6.54M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2301| 6.54M| YY_IGNORE_USELESS_CAST_END 2302| 6.54M| YY_STACK_PRINT (yyss, yyssp); 2303| | 2304| 6.54M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (2304:7): [True: 374, False: 6.54M] ------------------ 2305| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 2306| | YYNOMEM; 2307| |#else 2308| 374| { 2309| | /* Get the current used size of the three stacks, in elements. */ 2310| 374| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 619| 374|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 2311| | 2312| |# if defined yyoverflow 2313| | { 2314| | /* Give user a chance to reallocate the stack. Use copies of 2315| | these so that the &'s don't force the real ones into 2316| | memory. */ 2317| | yy_state_t *yyss1 = yyss; 2318| | YYSTYPE *yyvs1 = yyvs; 2319| | YYLTYPE *yyls1 = yyls; 2320| | 2321| | /* Each stack pointer address is followed by the size of the 2322| | data in use in that stack, in bytes. This used to be a 2323| | conditional around just the two extra args, but that might 2324| | be undefined if yyoverflow is a macro. */ 2325| | yyoverflow (YY_("memory exhausted"), 2326| | &yyss1, yysize * YYSIZEOF (*yyssp), 2327| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 2328| | &yyls1, yysize * YYSIZEOF (*yylsp), 2329| | &yystacksize); 2330| | yyss = yyss1; 2331| | yyvs = yyvs1; 2332| | yyls = yyls1; 2333| | } 2334| |# else /* defined YYSTACK_RELOCATE */ 2335| | /* Extend the stack our own way. */ 2336| 374| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1687| 374|# define YYMAXDEPTH 10000 ------------------ | Branch (2336:11): [True: 1, False: 373] ------------------ 2337| 1| YYNOMEM; ------------------ | | 1429| 1|#define YYNOMEM goto yyexhaustedlab ------------------ 2338| 373| yystacksize *= 2; 2339| 373| if (YYMAXDEPTH < yystacksize) ------------------ | | 1687| 373|# define YYMAXDEPTH 10000 ------------------ | Branch (2339:11): [True: 15, False: 358] ------------------ 2340| 15| yystacksize = YYMAXDEPTH; ------------------ | | 1687| 15|# define YYMAXDEPTH 10000 ------------------ 2341| | 2342| 373| { 2343| 373| yy_state_t *yyss1 = yyss; 2344| 373| union yyalloc *yyptr = 2345| 373| YY_CAST (union yyalloc *, ------------------ | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2346| 373| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 2347| 373| if (! yyptr) ------------------ | Branch (2347:13): [True: 0, False: 373] ------------------ 2348| 0| YYNOMEM; ------------------ | | 1429| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 2349| 373| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 835| 373| do \ | | 836| 373| { \ | | 837| 373| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 619| 373|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 838| 373| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 853| 373| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 839| 373| Stack = &yyptr->Stack_alloc; \ | | 840| 373| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 818| 373|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 841| 373| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 842| 373| } \ | | 843| 373| while (0) | | ------------------ | | | Branch (843:12): [Folded, False: 373] | | ------------------ ------------------ 2350| 373| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 835| 373| do \ | | 836| 373| { \ | | 837| 373| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 619| 373|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 838| 373| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 853| 373| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 839| 373| Stack = &yyptr->Stack_alloc; \ | | 840| 373| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 818| 373|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 841| 373| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 842| 373| } \ | | 843| 373| while (0) | | ------------------ | | | Branch (843:12): [Folded, False: 373] | | ------------------ ------------------ 2351| 373| YYSTACK_RELOCATE (yyls_alloc, yyls); ------------------ | | 835| 373| do \ | | 836| 373| { \ | | 837| 373| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 619| 373|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 838| 373| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 853| 373| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 839| 373| Stack = &yyptr->Stack_alloc; \ | | 840| 373| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 818| 373|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 841| 373| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 652| 373|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 89| 373|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 842| 373| } \ | | 843| 373| while (0) | | ------------------ | | | Branch (843:12): [Folded, False: 373] | | ------------------ ------------------ 2352| 373|# undef YYSTACK_RELOCATE 2353| 373| if (yyss1 != yyssa) ------------------ | Branch (2353:13): [True: 244, False: 129] ------------------ 2354| 244| YYSTACK_FREE (yyss1); ------------------ | | 777| 244|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 244|#define YYFREE jv_mem_free | | ------------------ ------------------ 2355| 373| } 2356| 0|# endif 2357| | 2358| 0| yyssp = yyss + yysize - 1; 2359| 373| yyvsp = yyvs + yysize - 1; 2360| 373| yylsp = yyls + yysize - 1; 2361| | 2362| 373| YY_IGNORE_USELESS_CAST_BEGIN 2363| 373| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 1667| 373|# define YYDPRINTF(Args) ((void) 0) ------------------ 2364| 373| YY_CAST (long, yystacksize))); 2365| 373| YY_IGNORE_USELESS_CAST_END 2366| | 2367| 373| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (2367:11): [True: 0, False: 373] ------------------ 2368| 0| YYABORT; ------------------ | | 1427| 0|#define YYABORT goto yyabortlab ------------------ 2369| 373| } 2370| 6.54M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 2371| | 2372| | 2373| 6.54M| if (yystate == YYFINAL) ------------------ | | 868| 6.54M|#define YYFINAL 31 ------------------ | Branch (2373:7): [True: 383, False: 6.54M] ------------------ 2374| 383| YYACCEPT; ------------------ | | 1426| 383|#define YYACCEPT goto yyacceptlab ------------------ 2375| | 2376| 6.54M| goto yybackup; 2377| | 2378| | 2379| |/*-----------. 2380| || yybackup. | 2381| |`-----------*/ 2382| 6.54M|yybackup: 2383| | /* Do appropriate processing given the current state. Read a 2384| | lookahead token if we need one and don't already have one. */ 2385| | 2386| | /* First try to decide what to do without reference to lookahead token. */ 2387| 6.54M| yyn = yypact[yystate]; 2388| 6.54M| if (yypact_value_is_default (yyn)) ------------------ | | 993| 6.54M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 990| 6.54M|#define YYPACT_NINF (-146) | | ------------------ | | | Branch (993:3): [True: 1.22M, False: 5.32M] | | ------------------ ------------------ 2389| 1.22M| goto yydefault; 2390| | 2391| | /* Not known => get a lookahead token if don't already have one. */ 2392| | 2393| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 2394| 5.32M| if (yychar == YYEMPTY) ------------------ | | 194| 5.32M|#define YYEMPTY -2 ------------------ | Branch (2394:7): [True: 3.18M, False: 2.13M] ------------------ 2395| 3.18M| { 2396| 3.18M| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1667| 3.18M|# define YYDPRINTF(Args) ((void) 0) ------------------ 2397| 3.18M| yychar = yylex (&yylval, &yylloc, answer, errors, locations, lexer_param_ptr); 2398| 3.18M| } 2399| | 2400| 5.32M| if (yychar <= YYEOF) ------------------ | | 195| 5.32M|#define YYEOF 0 ------------------ | Branch (2400:7): [True: 19.7k, False: 5.30M] ------------------ 2401| 19.7k| { 2402| 19.7k| yychar = YYEOF; ------------------ | | 195| 19.7k|#define YYEOF 0 ------------------ 2403| 19.7k| yytoken = YYSYMBOL_YYEOF; 2404| 19.7k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1667| 19.7k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2405| 19.7k| } 2406| 5.30M| else if (yychar == YYerror) ------------------ | | 196| 5.30M|#define YYerror 256 ------------------ | Branch (2406:12): [True: 0, False: 5.30M] ------------------ 2407| 0| { 2408| | /* The scanner already issued an error message, process directly 2409| | to error recovery. But do not keep the error token as 2410| | lookahead, it is too special and may lead us to an endless 2411| | loop in error recovery. */ 2412| 0| yychar = YYUNDEF; ------------------ | | 197| 0|#define YYUNDEF 257 ------------------ 2413| 0| yytoken = YYSYMBOL_YYerror; 2414| 0| yyerror_range[1] = yylloc; 2415| 0| goto yyerrlab1; 2416| 0| } 2417| 5.30M| else 2418| 5.30M| { 2419| 5.30M| yytoken = YYTRANSLATE (yychar); ------------------ | | 888| 5.30M| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 882| 5.30M|#define YYMAXUTOK 302 | | ------------------ | | | Branch (888:4): [True: 5.30M, False: 0] | | | Branch (888:18): [True: 5.30M, False: 0] | | ------------------ | | 889| 5.30M| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 89| 5.30M|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 890| 5.30M| : YYSYMBOL_YYUNDEF) ------------------ 2420| 5.30M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2421| 5.30M| } 2422| | 2423| | /* If the proper action on seeing token YYTOKEN is to reduce or to 2424| | detect an error, take that action. */ 2425| 5.32M| yyn += yytoken; 2426| 5.32M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 870| 5.32M|#define YYLAST 1165 ------------------ | Branch (2426:7): [True: 219, False: 5.32M] | Branch (2426:18): [True: 2.19k, False: 5.31M] | Branch (2426:34): [True: 3.00M, False: 2.30M] ------------------ 2427| 3.01M| goto yydefault; 2428| 2.30M| yyn = yytable[yyn]; 2429| 2.30M| if (yyn <= 0) ------------------ | Branch (2429:7): [True: 54.7k, False: 2.25M] ------------------ 2430| 54.7k| { 2431| 54.7k| if (yytable_value_is_error (yyn)) ------------------ | | 998| 54.7k| ((Yyn) == YYTABLE_NINF) | | ------------------ | | | | 995| 54.7k|#define YYTABLE_NINF (-154) | | ------------------ | | | Branch (998:3): [True: 219, False: 54.5k] | | ------------------ ------------------ 2432| 219| goto yyerrlab; 2433| 54.5k| yyn = -yyn; 2434| 54.5k| goto yyreduce; 2435| 54.7k| } 2436| | 2437| | /* Count tokens shifted since error; after three, turn off error 2438| | status. */ 2439| 2.25M| if (yyerrstatus) ------------------ | Branch (2439:7): [True: 187k, False: 2.06M] ------------------ 2440| 187k| yyerrstatus--; 2441| | 2442| | /* Shift the lookahead token. */ 2443| 2.25M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2444| 2.25M| yystate = yyn; 2445| 2.25M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2446| 2.25M| *++yyvsp = yylval; 2447| 2.25M| YY_IGNORE_MAYBE_UNINITIALIZED_END 2448| 2.25M| *++yylsp = yylloc; 2449| | 2450| | /* Discard the shifted token. */ 2451| 2.25M| yychar = YYEMPTY; ------------------ | | 194| 2.25M|#define YYEMPTY -2 ------------------ 2452| 2.25M| goto yynewstate; 2453| | 2454| | 2455| |/*-----------------------------------------------------------. 2456| || yydefault -- do the default action for the current state. | 2457| |`-----------------------------------------------------------*/ 2458| 4.23M|yydefault: 2459| 4.23M| yyn = yydefact[yystate]; 2460| 4.23M| if (yyn == 0) ------------------ | Branch (2460:7): [True: 1.00M, False: 3.22M] ------------------ 2461| 1.00M| goto yyerrlab; 2462| 3.22M| goto yyreduce; 2463| | 2464| | 2465| |/*-----------------------------. 2466| || yyreduce -- do a reduction. | 2467| |`-----------------------------*/ 2468| 3.28M|yyreduce: 2469| | /* yyn is the number of a rule to reduce with. */ 2470| 3.28M| yylen = yyr2[yyn]; 2471| | 2472| | /* If YYLEN is nonzero, implement the default value of the action: 2473| | '$$ = $1'. 2474| | 2475| | Otherwise, the following line sets YYVAL to garbage. 2476| | This behavior is undocumented and Bison 2477| | users should not rely upon it. Assigning to YYVAL 2478| | unconditionally makes the parser a bit smaller, and it avoids a 2479| | GCC warning that YYVAL may be used uninitialized. */ 2480| 3.28M| yyval = yyvsp[1-yylen]; 2481| | 2482| | /* Default location. */ 2483| 3.28M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 124| 3.28M| do { \ | | 125| 3.28M| if (N) { \ | | ------------------ | | | Branch (125:9): [True: 3.23M, False: 51.7k] | | ------------------ | | 126| 3.23M| (Loc).start = YYRHSLOC(Rhs, 1).start; \ | | ------------------ | | | | 1479| 3.23M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 127| 3.23M| (Loc).end = YYRHSLOC(Rhs, N).end; \ | | ------------------ | | | | 1479| 3.23M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 128| 3.23M| } else { \ | | 129| 51.7k| (Loc).start = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1479| 51.7k|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 130| 51.7k| (Loc).end = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1479| 51.7k|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 131| 51.7k| } \ | | 132| 3.28M| } while (0) | | ------------------ | | | Branch (132:12): [Folded, False: 3.28M] | | ------------------ ------------------ 2484| 3.28M| yyerror_range[1] = yyloc; 2485| 3.28M| YY_REDUCE_PRINT (yyn); 2486| 3.28M| switch (yyn) 2487| 3.28M| { 2488| 290| case 2: /* TopLevel: Module Imports Query */ ------------------ | Branch (2488:3): [True: 290, False: 3.28M] ------------------ 2489| 290|#line 281 "src/parser.y" 2490| 290| { 2491| 290| *answer = BLOCK((yyvsp[-2].blk), (yyvsp[-1].blk), gen_op_simple(TOP), (yyvsp[0].blk)); ------------------ | | 102| 290| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 290|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 290| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 290|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 290|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 290|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2492| 290|} 2493| 290|#line 2494 "src/parser.c" 2494| 290| break; 2495| | 2496| 190| case 3: /* TopLevel: Module Imports FuncDefs */ ------------------ | Branch (2496:3): [True: 190, False: 3.28M] ------------------ 2497| 190|#line 284 "src/parser.y" 2498| 190| { 2499| 190| *answer = BLOCK((yyvsp[-2].blk), (yyvsp[-1].blk), (yyvsp[0].blk)); ------------------ | | 102| 190| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 190|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 190| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 190|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 190|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2500| 190|} 2501| 190|#line 2502 "src/parser.c" 2502| 190| break; 2503| | 2504| 777| case 4: /* Module: %empty */ ------------------ | Branch (2504:3): [True: 777, False: 3.28M] ------------------ 2505| 777|#line 289 "src/parser.y" 2506| 777| { 2507| 777| (yyval.blk) = gen_noop(); 2508| 777|} 2509| 777|#line 2510 "src/parser.c" 2510| 777| break; 2511| | 2512| 0| case 5: /* Module: "module" Query ';' */ ------------------ | Branch (2512:3): [True: 0, False: 3.28M] ------------------ 2513| 0|#line 292 "src/parser.y" 2514| 0| { 2515| 0| if (!block_is_const((yyvsp[-1].blk))) { ------------------ | Branch (2515:7): [True: 0, False: 0] ------------------ 2516| 0| FAIL((yylsp[-1]), "Module metadata must be constant"); ------------------ | | 397| 0| do { \ | | 398| 0| location l = loc; \ | | 399| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 0| /*YYERROR*/; \ | | 401| 0| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 0] | | ------------------ ------------------ 2517| 0| (yyval.blk) = gen_noop(); 2518| 0| block_free((yyvsp[-1].blk)); 2519| 0| } else if (block_const_kind((yyvsp[-1].blk)) != JV_KIND_OBJECT) { ------------------ | Branch (2519:14): [True: 0, False: 0] ------------------ 2520| 0| FAIL((yylsp[-1]), "Module metadata must be an object"); ------------------ | | 397| 0| do { \ | | 398| 0| location l = loc; \ | | 399| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 0| /*YYERROR*/; \ | | 401| 0| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 0] | | ------------------ ------------------ 2521| 0| (yyval.blk) = gen_noop(); 2522| 0| block_free((yyvsp[-1].blk)); 2523| 0| } else { 2524| 0| (yyval.blk) = gen_module((yyvsp[-1].blk)); 2525| 0| } 2526| 0|} 2527| 0|#line 2528 "src/parser.c" 2528| 0| break; 2529| | 2530| 775| case 6: /* Imports: %empty */ ------------------ | Branch (2530:3): [True: 775, False: 3.28M] ------------------ 2531| 775|#line 307 "src/parser.y" 2532| 775| { 2533| 775| (yyval.blk) = gen_noop(); 2534| 775|} 2535| 775|#line 2536 "src/parser.c" 2536| 775| break; 2537| | 2538| 334| case 7: /* Imports: Import Imports */ ------------------ | Branch (2538:3): [True: 334, False: 3.28M] ------------------ 2539| 334|#line 310 "src/parser.y" 2540| 334| { 2541| 334| (yyval.blk) = BLOCK((yyvsp[-1].blk), (yyvsp[0].blk)); ------------------ | | 102| 334| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 334|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 334| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 334|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2542| 334|} 2543| 334|#line 2544 "src/parser.c" 2544| 334| break; 2545| | 2546| 190| case 8: /* FuncDefs: %empty */ ------------------ | Branch (2546:3): [True: 190, False: 3.28M] ------------------ 2547| 190|#line 315 "src/parser.y" 2548| 190| { 2549| 190| (yyval.blk) = gen_noop(); 2550| 190|} 2551| 190|#line 2552 "src/parser.c" 2552| 190| break; 2553| | 2554| 19.0k| case 9: /* FuncDefs: FuncDef FuncDefs */ ------------------ | Branch (2554:3): [True: 19.0k, False: 3.26M] ------------------ 2555| 19.0k|#line 318 "src/parser.y" 2556| 19.0k| { 2557| 19.0k| (yyval.blk) = block_join((yyvsp[-1].blk), (yyvsp[0].blk)); 2558| 19.0k|} 2559| 19.0k|#line 2560 "src/parser.c" 2560| 19.0k| break; 2561| | 2562| 1.26k| case 10: /* Query: FuncDef Query */ ------------------ | Branch (2562:3): [True: 1.26k, False: 3.28M] ------------------ 2563| 1.26k|#line 324 "src/parser.y" 2564| 1.26k| { 2565| 1.26k| (yyval.blk) = block_bind_referenced((yyvsp[-1].blk), (yyvsp[0].blk), OP_IS_CALL_PSEUDO); 2566| 1.26k|} 2567| 1.26k|#line 2568 "src/parser.c" 2568| 1.26k| break; 2569| | 2570| 5.49k| case 11: /* Query: Expr "as" Patterns '|' Query */ ------------------ | Branch (2570:3): [True: 5.49k, False: 3.27M] ------------------ 2571| 5.49k|#line 327 "src/parser.y" 2572| 5.49k| { 2573| 5.49k| (yyval.blk) = gen_destructure((yyvsp[-4].blk), (yyvsp[-2].blk), (yyvsp[0].blk)); 2574| 5.49k|} 2575| 5.49k|#line 2576 "src/parser.c" 2576| 5.49k| break; 2577| | 2578| 1.57k| case 12: /* Query: "label" BINDING '|' Query */ ------------------ | Branch (2578:3): [True: 1.57k, False: 3.28M] ------------------ 2579| 1.57k|#line 330 "src/parser.y" 2580| 1.57k| { 2581| 1.57k| jv v = jv_string_fmt("*label-%s", jv_string_value((yyvsp[-2].literal))); 2582| 1.57k| (yyval.blk) = gen_location((yyloc), locations, gen_label(jv_string_value(v), (yyvsp[0].blk))); 2583| 1.57k| jv_free((yyvsp[-2].literal)); 2584| 1.57k| jv_free(v); 2585| 1.57k|} 2586| 1.57k|#line 2587 "src/parser.c" 2587| 1.57k| break; 2588| | 2589| 20.9k| case 13: /* Query: Query '|' Query */ ------------------ | Branch (2589:3): [True: 20.9k, False: 3.26M] ------------------ 2590| 20.9k|#line 336 "src/parser.y" 2591| 20.9k| { 2592| 20.9k| (yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk)); 2593| 20.9k|} 2594| 20.9k|#line 2595 "src/parser.c" 2595| 20.9k| break; 2596| | 2597| 78.0k| case 14: /* Query: Query ',' Query */ ------------------ | Branch (2597:3): [True: 78.0k, False: 3.20M] ------------------ 2598| 78.0k|#line 339 "src/parser.y" 2599| 78.0k| { 2600| 78.0k| (yyval.blk) = gen_both((yyvsp[-2].blk), (yyvsp[0].blk)); 2601| 78.0k|} 2602| 78.0k|#line 2603 "src/parser.c" 2603| 78.0k| break; 2604| | 2605| 463k| case 15: /* Query: Expr */ ------------------ | Branch (2605:3): [True: 463k, False: 2.82M] ------------------ 2606| 463k|#line 342 "src/parser.y" 2607| 463k| { 2608| 463k| (yyval.blk) = (yyvsp[0].blk); 2609| 463k|} 2610| 463k|#line 2611 "src/parser.c" 2611| 463k| break; 2612| | 2613| 19.1k| case 16: /* Expr: Expr "//" Expr */ ------------------ | Branch (2613:3): [True: 19.1k, False: 3.26M] ------------------ 2614| 19.1k|#line 348 "src/parser.y" 2615| 19.1k| { 2616| 19.1k| (yyval.blk) = gen_definedor((yyvsp[-2].blk), (yyvsp[0].blk)); 2617| 19.1k|} 2618| 19.1k|#line 2619 "src/parser.c" 2619| 19.1k| break; 2620| | 2621| 15.3k| case 17: /* Expr: Expr '=' Expr */ ------------------ | Branch (2621:3): [True: 15.3k, False: 3.26M] ------------------ 2622| 15.3k|#line 351 "src/parser.y" 2623| 15.3k| { 2624| 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))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2625| 15.3k|} 2626| 15.3k|#line 2627 "src/parser.c" 2627| 15.3k| break; 2628| | 2629| 546| case 18: /* Expr: Expr "or" Expr */ ------------------ | Branch (2629:3): [True: 546, False: 3.28M] ------------------ 2630| 546|#line 354 "src/parser.y" 2631| 546| { 2632| 546| (yyval.blk) = gen_or((yyvsp[-2].blk), (yyvsp[0].blk)); 2633| 546|} 2634| 546|#line 2635 "src/parser.c" 2635| 546| break; 2636| | 2637| 3.21k| case 19: /* Expr: Expr "and" Expr */ ------------------ | Branch (2637:3): [True: 3.21k, False: 3.28M] ------------------ 2638| 3.21k|#line 357 "src/parser.y" 2639| 3.21k| { 2640| 3.21k| (yyval.blk) = gen_and((yyvsp[-2].blk), (yyvsp[0].blk)); 2641| 3.21k|} 2642| 3.21k|#line 2643 "src/parser.c" 2643| 3.21k| break; 2644| | 2645| 163| case 20: /* Expr: Expr "//=" Expr */ ------------------ | Branch (2645:3): [True: 163, False: 3.28M] ------------------ 2646| 163|#line 360 "src/parser.y" 2647| 163| { 2648| 163| (yyval.blk) = gen_definedor_assign((yyvsp[-2].blk), (yyvsp[0].blk)); 2649| 163|} 2650| 163|#line 2651 "src/parser.c" 2651| 163| break; 2652| | 2653| 365| case 21: /* Expr: Expr "|=" Expr */ ------------------ | Branch (2653:3): [True: 365, False: 3.28M] ------------------ 2654| 365|#line 363 "src/parser.y" 2655| 365| { 2656| 365| (yyval.blk) = gen_call("_modify", BLOCK(gen_lambda((yyvsp[-2].blk)), gen_lambda((yyvsp[0].blk)))); ------------------ | | 102| 365| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 365|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 365| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 365|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2657| 365|} 2658| 365|#line 2659 "src/parser.c" 2659| 365| break; 2660| | 2661| 8.77k| case 22: /* Expr: Expr '+' Expr */ ------------------ | Branch (2661:3): [True: 8.77k, False: 3.27M] ------------------ 2662| 8.77k|#line 366 "src/parser.y" 2663| 8.77k| { 2664| 8.77k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '+'); 2665| 8.77k|} 2666| 8.77k|#line 2667 "src/parser.c" 2667| 8.77k| break; 2668| | 2669| 46.3k| case 23: /* Expr: Expr "+=" Expr */ ------------------ | Branch (2669:3): [True: 46.3k, False: 3.23M] ------------------ 2670| 46.3k|#line 369 "src/parser.y" 2671| 46.3k| { 2672| 46.3k| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '+'); 2673| 46.3k|} 2674| 46.3k|#line 2675 "src/parser.c" 2675| 46.3k| break; 2676| | 2677| 46.0k| case 24: /* Expr: Expr '-' Expr */ ------------------ | Branch (2677:3): [True: 46.0k, False: 3.23M] ------------------ 2678| 46.0k|#line 372 "src/parser.y" 2679| 46.0k| { 2680| 46.0k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '-'); 2681| 46.0k|} 2682| 46.0k|#line 2683 "src/parser.c" 2683| 46.0k| break; 2684| | 2685| 871| case 25: /* Expr: Expr "-=" Expr */ ------------------ | Branch (2685:3): [True: 871, False: 3.28M] ------------------ 2686| 871|#line 375 "src/parser.y" 2687| 871| { 2688| 871| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '-'); 2689| 871|} 2690| 871|#line 2691 "src/parser.c" 2691| 871| break; 2692| | 2693| 15.3k| case 26: /* Expr: Expr '*' Expr */ ------------------ | Branch (2693:3): [True: 15.3k, False: 3.26M] ------------------ 2694| 15.3k|#line 378 "src/parser.y" 2695| 15.3k| { 2696| 15.3k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '*'); 2697| 15.3k|} 2698| 15.3k|#line 2699 "src/parser.c" 2699| 15.3k| break; 2700| | 2701| 1| case 27: /* Expr: Expr "*=" Expr */ ------------------ | Branch (2701:3): [True: 1, False: 3.28M] ------------------ 2702| 1|#line 381 "src/parser.y" 2703| 1| { 2704| 1| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '*'); 2705| 1|} 2706| 1|#line 2707 "src/parser.c" 2707| 1| break; 2708| | 2709| 17.8k| case 28: /* Expr: Expr '/' Expr */ ------------------ | Branch (2709:3): [True: 17.8k, False: 3.26M] ------------------ 2710| 17.8k|#line 384 "src/parser.y" 2711| 17.8k| { 2712| 17.8k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '/'); 2713| 17.8k|} 2714| 17.8k|#line 2715 "src/parser.c" 2715| 17.8k| break; 2716| | 2717| 12.0k| case 29: /* Expr: Expr '%' Expr */ ------------------ | Branch (2717:3): [True: 12.0k, False: 3.27M] ------------------ 2718| 12.0k|#line 387 "src/parser.y" 2719| 12.0k| { 2720| 12.0k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '%'); 2721| 12.0k|} 2722| 12.0k|#line 2723 "src/parser.c" 2723| 12.0k| break; 2724| | 2725| 963| case 30: /* Expr: Expr "/=" Expr */ ------------------ | Branch (2725:3): [True: 963, False: 3.28M] ------------------ 2726| 963|#line 390 "src/parser.y" 2727| 963| { 2728| 963| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '/'); 2729| 963|} 2730| 963|#line 2731 "src/parser.c" 2731| 963| break; 2732| | 2733| 78| case 31: /* Expr: Expr "%=" Expr */ ------------------ | Branch (2733:3): [True: 78, False: 3.28M] ------------------ 2734| 78|#line 393 "src/parser.y" 2735| 78| { 2736| 78| (yyval.blk) = gen_update((yyvsp[-2].blk), (yyvsp[0].blk), '%'); 2737| 78|} 2738| 78|#line 2739 "src/parser.c" 2739| 78| break; 2740| | 2741| 12.2k| case 32: /* Expr: Expr "==" Expr */ ------------------ | Branch (2741:3): [True: 12.2k, False: 3.27M] ------------------ 2742| 12.2k|#line 396 "src/parser.y" 2743| 12.2k| { 2744| 12.2k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), EQ); ------------------ | | 206| 12.2k|#define EQ 266 ------------------ 2745| 12.2k|} 2746| 12.2k|#line 2747 "src/parser.c" 2747| 12.2k| break; 2748| | 2749| 1.67k| case 33: /* Expr: Expr "!=" Expr */ ------------------ | Branch (2749:3): [True: 1.67k, False: 3.28M] ------------------ 2750| 1.67k|#line 399 "src/parser.y" 2751| 1.67k| { 2752| 1.67k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), NEQ); ------------------ | | 207| 1.67k|#define NEQ 267 ------------------ 2753| 1.67k|} 2754| 1.67k|#line 2755 "src/parser.c" 2755| 1.67k| break; 2756| | 2757| 1.37k| case 34: /* Expr: Expr '<' Expr */ ------------------ | Branch (2757:3): [True: 1.37k, False: 3.28M] ------------------ 2758| 1.37k|#line 402 "src/parser.y" 2759| 1.37k| { 2760| 1.37k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '<'); 2761| 1.37k|} 2762| 1.37k|#line 2763 "src/parser.c" 2763| 1.37k| break; 2764| | 2765| 12.5k| case 35: /* Expr: Expr '>' Expr */ ------------------ | Branch (2765:3): [True: 12.5k, False: 3.27M] ------------------ 2766| 12.5k|#line 405 "src/parser.y" 2767| 12.5k| { 2768| 12.5k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), '>'); 2769| 12.5k|} 2770| 12.5k|#line 2771 "src/parser.c" 2771| 12.5k| break; 2772| | 2773| 1.04k| case 36: /* Expr: Expr "<=" Expr */ ------------------ | Branch (2773:3): [True: 1.04k, False: 3.28M] ------------------ 2774| 1.04k|#line 408 "src/parser.y" 2775| 1.04k| { 2776| 1.04k| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), LESSEQ); ------------------ | | 234| 1.04k|#define LESSEQ 294 ------------------ 2777| 1.04k|} 2778| 1.04k|#line 2779 "src/parser.c" 2779| 1.04k| break; 2780| | 2781| 323| case 37: /* Expr: Expr ">=" Expr */ ------------------ | Branch (2781:3): [True: 323, False: 3.28M] ------------------ 2782| 323|#line 411 "src/parser.y" 2783| 323| { 2784| 323| (yyval.blk) = gen_binop((yyvsp[-2].blk), (yyvsp[0].blk), GREATEREQ); ------------------ | | 235| 323|#define GREATEREQ 295 ------------------ 2785| 323|} 2786| 323|#line 2787 "src/parser.c" 2787| 323| break; 2788| | 2789| 795k| case 38: /* Expr: Term */ ------------------ | Branch (2789:3): [True: 795k, False: 2.48M] ------------------ 2790| 795k|#line 414 "src/parser.y" 2791| 795k| { 2792| 795k| (yyval.blk) = (yyvsp[0].blk); 2793| 795k|} 2794| 795k|#line 2795 "src/parser.c" 2795| 795k| break; 2796| | 2797| 277| case 39: /* Import: ImportWhat ';' */ ------------------ | Branch (2797:3): [True: 277, False: 3.28M] ------------------ 2798| 277|#line 420 "src/parser.y" 2799| 277| { 2800| 277| (yyval.blk) = (yyvsp[-1].blk); 2801| 277|} 2802| 277|#line 2803 "src/parser.c" 2803| 277| break; 2804| | 2805| 323| case 40: /* Import: ImportWhat Query ';' */ ------------------ | Branch (2805:3): [True: 323, False: 3.28M] ------------------ 2806| 323|#line 423 "src/parser.y" 2807| 323| { 2808| 323| if (!block_is_const((yyvsp[-1].blk))) { ------------------ | Branch (2808:7): [True: 140, False: 183] ------------------ 2809| 140| FAIL((yylsp[-1]), "Module metadata must be constant"); ------------------ | | 397| 140| do { \ | | 398| 140| location l = loc; \ | | 399| 140| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 140| /*YYERROR*/; \ | | 401| 140| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 140] | | ------------------ ------------------ 2810| 140| (yyval.blk) = gen_noop(); 2811| 140| block_free((yyvsp[-2].blk)); 2812| 140| block_free((yyvsp[-1].blk)); 2813| 183| } else if (block_const_kind((yyvsp[-1].blk)) != JV_KIND_OBJECT) { ------------------ | Branch (2813:14): [True: 0, False: 183] ------------------ 2814| 0| FAIL((yylsp[-1]), "Module metadata must be an object"); ------------------ | | 397| 0| do { \ | | 398| 0| location l = loc; \ | | 399| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 0| /*YYERROR*/; \ | | 401| 0| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 0] | | ------------------ ------------------ 2815| 0| (yyval.blk) = gen_noop(); 2816| 0| block_free((yyvsp[-2].blk)); 2817| 0| block_free((yyvsp[-1].blk)); 2818| 183| } else { 2819| 183| (yyval.blk) = gen_import_meta((yyvsp[-2].blk), (yyvsp[-1].blk)); 2820| 183| } 2821| 323|} 2822| 323|#line 2823 "src/parser.c" 2823| 323| break; 2824| | 2825| 134| case 41: /* ImportWhat: "import" ImportFrom "as" BINDING */ ------------------ | Branch (2825:3): [True: 134, False: 3.28M] ------------------ 2826| 134|#line 440 "src/parser.y" 2827| 134| { 2828| 134| (yyval.blk) = gen_import(block_const((yyvsp[-2].blk)), (yyvsp[0].literal), 1); 2829| 134| block_free((yyvsp[-2].blk)); 2830| 134|} 2831| 134|#line 2832 "src/parser.c" 2832| 134| break; 2833| | 2834| 128| case 42: /* ImportWhat: "import" ImportFrom "as" IDENT */ ------------------ | Branch (2834:3): [True: 128, False: 3.28M] ------------------ 2835| 128|#line 444 "src/parser.y" 2836| 128| { 2837| 128| (yyval.blk) = gen_import(block_const((yyvsp[-2].blk)), (yyvsp[0].literal), 0); 2838| 128| block_free((yyvsp[-2].blk)); 2839| 128|} 2840| 128|#line 2841 "src/parser.c" 2841| 128| break; 2842| | 2843| 338| case 43: /* ImportWhat: "include" ImportFrom */ ------------------ | Branch (2843:3): [True: 338, False: 3.28M] ------------------ 2844| 338|#line 448 "src/parser.y" 2845| 338| { 2846| 338| (yyval.blk) = gen_import(block_const((yyvsp[0].blk)), jv_invalid(), 0); 2847| 338| block_free((yyvsp[0].blk)); 2848| 338|} 2849| 338|#line 2850 "src/parser.c" 2850| 338| break; 2851| | 2852| 601| case 44: /* ImportFrom: String */ ------------------ | Branch (2852:3): [True: 601, False: 3.28M] ------------------ 2853| 601|#line 454 "src/parser.y" 2854| 601| { 2855| 601| if (!block_is_const((yyvsp[0].blk))) { ------------------ | Branch (2855:7): [True: 138, False: 463] ------------------ 2856| 138| FAIL((yylsp[0]), "Import path must be constant"); ------------------ | | 397| 138| do { \ | | 398| 138| location l = loc; \ | | 399| 138| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 138| /*YYERROR*/; \ | | 401| 138| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 138] | | ------------------ ------------------ 2857| 138| (yyval.blk) = gen_const(jv_string("")); 2858| 138| block_free((yyvsp[0].blk)); 2859| 463| } else { 2860| 463| (yyval.blk) = (yyvsp[0].blk); 2861| 463| } 2862| 601|} 2863| 601|#line 2864 "src/parser.c" 2864| 601| break; 2865| | 2866| 7.42k| case 45: /* FuncDef: "def" IDENT ':' Query ';' */ ------------------ | Branch (2866:3): [True: 7.42k, False: 3.27M] ------------------ 2867| 7.42k|#line 465 "src/parser.y" 2868| 7.42k| { 2869| 7.42k| (yyval.blk) = gen_function(jv_string_value((yyvsp[-3].literal)), gen_noop(), (yyvsp[-1].blk)); 2870| 7.42k| jv_free((yyvsp[-3].literal)); 2871| 7.42k|} 2872| 7.42k|#line 2873 "src/parser.c" 2873| 7.42k| break; 2874| | 2875| 12.8k| case 46: /* FuncDef: "def" IDENT '(' Params ')' ':' Query ';' */ ------------------ | Branch (2875:3): [True: 12.8k, False: 3.27M] ------------------ 2876| 12.8k|#line 470 "src/parser.y" 2877| 12.8k| { 2878| 12.8k| (yyval.blk) = gen_function(jv_string_value((yyvsp[-6].literal)), (yyvsp[-4].blk), (yyvsp[-1].blk)); 2879| 12.8k| jv_free((yyvsp[-6].literal)); 2880| 12.8k|} 2881| 12.8k|#line 2882 "src/parser.c" 2882| 12.8k| break; 2883| | 2884| 12.8k| case 47: /* Params: Param */ ------------------ | Branch (2884:3): [True: 12.8k, False: 3.27M] ------------------ 2885| 12.8k|#line 476 "src/parser.y" 2886| 12.8k| { 2887| 12.8k| (yyval.blk) = (yyvsp[0].blk); 2888| 12.8k|} 2889| 12.8k|#line 2890 "src/parser.c" 2890| 12.8k| break; 2891| | 2892| 5.61k| case 48: /* Params: Params ';' Param */ ------------------ | Branch (2892:3): [True: 5.61k, False: 3.27M] ------------------ 2893| 5.61k|#line 479 "src/parser.y" 2894| 5.61k| { 2895| 5.61k| (yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk)); ------------------ | | 102| 5.61k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 5.61k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 5.61k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 5.61k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2896| 5.61k|} 2897| 5.61k|#line 2898 "src/parser.c" 2898| 5.61k| break; 2899| | 2900| 6.51k| case 49: /* Param: BINDING */ ------------------ | Branch (2900:3): [True: 6.51k, False: 3.27M] ------------------ 2901| 6.51k|#line 484 "src/parser.y" 2902| 6.51k| { 2903| 6.51k| (yyval.blk) = gen_param_regular(jv_string_value((yyvsp[0].literal))); 2904| 6.51k| jv_free((yyvsp[0].literal)); 2905| 6.51k|} 2906| 6.51k|#line 2907 "src/parser.c" 2907| 6.51k| break; 2908| | 2909| 11.9k| case 50: /* Param: IDENT */ ------------------ | Branch (2909:3): [True: 11.9k, False: 3.27M] ------------------ 2910| 11.9k|#line 488 "src/parser.y" 2911| 11.9k| { 2912| 11.9k| (yyval.blk) = gen_param(jv_string_value((yyvsp[0].literal))); 2913| 11.9k| jv_free((yyvsp[0].literal)); 2914| 11.9k|} 2915| 11.9k|#line 2916 "src/parser.c" 2916| 11.9k| break; 2917| | 2918| 21| case 51: /* StringStart: FORMAT QQSTRING_START */ ------------------ | Branch (2918:3): [True: 21, False: 3.28M] ------------------ 2919| 21|#line 495 "src/parser.y" 2920| 21| { 2921| 21| (yyval.literal) = (yyvsp[-1].literal); 2922| 21|} 2923| 21|#line 2924 "src/parser.c" 2924| 21| break; 2925| | 2926| 26.7k| case 52: /* StringStart: QQSTRING_START */ ------------------ | Branch (2926:3): [True: 26.7k, False: 3.25M] ------------------ 2927| 26.7k|#line 498 "src/parser.y" 2928| 26.7k| { 2929| 26.7k| (yyval.literal) = jv_string("text"); 2930| 26.7k|} 2931| 26.7k|#line 2932 "src/parser.c" 2932| 26.7k| break; 2933| | 2934| 26.5k| case 53: /* String: StringStart QQString QQSTRING_END */ ------------------ | Branch (2934:3): [True: 26.5k, False: 3.25M] ------------------ 2935| 26.5k|#line 504 "src/parser.y" 2936| 26.5k| { 2937| 26.5k| (yyval.blk) = (yyvsp[-1].blk); 2938| 26.5k| jv_free((yyvsp[-2].literal)); 2939| 26.5k|} 2940| 26.5k|#line 2941 "src/parser.c" 2941| 26.5k| break; 2942| | 2943| 26.7k| case 54: /* QQString: %empty */ ------------------ | Branch (2943:3): [True: 26.7k, False: 3.25M] ------------------ 2944| 26.7k|#line 511 "src/parser.y" 2945| 26.7k| { 2946| 26.7k| (yyval.blk) = gen_const(jv_string("")); 2947| 26.7k|} 2948| 26.7k|#line 2949 "src/parser.c" 2949| 26.7k| break; 2950| | 2951| 148k| case 55: /* QQString: QQString QQSTRING_TEXT */ ------------------ | Branch (2951:3): [True: 148k, False: 3.13M] ------------------ 2952| 148k|#line 514 "src/parser.y" 2953| 148k| { 2954| 148k| (yyval.blk) = gen_binop((yyvsp[-1].blk), gen_const((yyvsp[0].literal)), '+'); 2955| 148k|} 2956| 148k|#line 2957 "src/parser.c" 2957| 148k| break; 2958| | 2959| 312| case 56: /* QQString: QQString QQSTRING_INTERP_START Query QQSTRING_INTERP_END */ ------------------ | Branch (2959:3): [True: 312, False: 3.28M] ------------------ 2960| 312|#line 517 "src/parser.y" 2961| 312| { 2962| 312| (yyval.blk) = gen_binop((yyvsp[-3].blk), gen_format((yyvsp[-1].blk), jv_copy((yyvsp[-4].literal))), '+'); 2963| 312|} 2964| 312|#line 2965 "src/parser.c" 2965| 312| break; 2966| | 2967| 2.04k| case 57: /* ElseBody: "elif" Query "then" Query ElseBody */ ------------------ | Branch (2967:3): [True: 2.04k, False: 3.28M] ------------------ 2968| 2.04k|#line 523 "src/parser.y" 2969| 2.04k| { 2970| 2.04k| (yyval.blk) = gen_cond((yyvsp[-3].blk), (yyvsp[-1].blk), (yyvsp[0].blk)); 2971| 2.04k|} 2972| 2.04k|#line 2973 "src/parser.c" 2973| 2.04k| break; 2974| | 2975| 4.88k| case 58: /* ElseBody: "else" Query "end" */ ------------------ | Branch (2975:3): [True: 4.88k, False: 3.27M] ------------------ 2976| 4.88k|#line 526 "src/parser.y" 2977| 4.88k| { 2978| 4.88k| (yyval.blk) = (yyvsp[-1].blk); 2979| 4.88k|} 2980| 4.88k|#line 2981 "src/parser.c" 2981| 4.88k| break; 2982| | 2983| 750| case 59: /* ElseBody: "end" */ ------------------ | Branch (2983:3): [True: 750, False: 3.28M] ------------------ 2984| 750|#line 529 "src/parser.y" 2985| 750| { 2986| 750| (yyval.blk) = gen_noop(); 2987| 750|} 2988| 750|#line 2989 "src/parser.c" 2989| 750| break; 2990| | 2991| 26.3k| case 60: /* Term: '.' */ ------------------ | Branch (2991:3): [True: 26.3k, False: 3.25M] ------------------ 2992| 26.3k|#line 535 "src/parser.y" 2993| 26.3k| { 2994| 26.3k| (yyval.blk) = gen_noop(); 2995| 26.3k|} 2996| 26.3k|#line 2997 "src/parser.c" 2997| 26.3k| break; 2998| | 2999| 2.15k| case 61: /* Term: ".." */ ------------------ | Branch (2999:3): [True: 2.15k, False: 3.28M] ------------------ 3000| 2.15k|#line 538 "src/parser.y" 3001| 2.15k| { 3002| 2.15k| (yyval.blk) = gen_call("recurse", gen_noop()); 3003| 2.15k|} 3004| 2.15k|#line 3005 "src/parser.c" 3005| 2.15k| break; 3006| | 3007| 880| case 62: /* Term: "break" BINDING */ ------------------ | Branch (3007:3): [True: 880, False: 3.28M] ------------------ 3008| 880|#line 541 "src/parser.y" 3009| 880| { 3010| 880| jv v = jv_string_fmt("*label-%s", jv_string_value((yyvsp[0].literal))); // impossible symbol 3011| 880| (yyval.blk) = gen_location((yyloc), locations, 3012| 880| BLOCK(gen_op_unbound(LOADV, jv_string_value(v)), ------------------ | | 102| 880| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 880|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 880| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 880|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3013| 880| gen_call("error", gen_noop()))); 3014| 880| jv_free(v); 3015| 880| jv_free((yyvsp[0].literal)); 3016| 880|} 3017| 880|#line 3018 "src/parser.c" 3018| 880| break; 3019| | 3020| 44| case 63: /* Term: "break" error */ ------------------ | Branch (3020:3): [True: 44, False: 3.28M] ------------------ 3021| 44|#line 549 "src/parser.y" 3022| 44| { 3023| 44| FAIL((yyloc), "break requires a label to break to"); ------------------ | | 397| 44| do { \ | | 398| 44| location l = loc; \ | | 399| 44| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 44| /*YYERROR*/; \ | | 401| 44| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 44] | | ------------------ ------------------ 3024| 44| (yyval.blk) = gen_noop(); 3025| 44|} 3026| 44|#line 3027 "src/parser.c" 3027| 44| break; 3028| | 3029| 19| case 64: /* Term: Term FIELD '?' */ ------------------ | Branch (3029:3): [True: 19, False: 3.28M] ------------------ 3030| 19|#line 553 "src/parser.y" 3031| 19| { 3032| 19| (yyval.blk) = gen_index_opt((yyvsp[-2].blk), gen_const((yyvsp[-1].literal))); 3033| 19|} 3034| 19|#line 3035 "src/parser.c" 3035| 19| break; 3036| | 3037| 10| case 65: /* Term: FIELD '?' */ ------------------ | Branch (3037:3): [True: 10, False: 3.28M] ------------------ 3038| 10|#line 556 "src/parser.y" 3039| 10| { 3040| 10| (yyval.blk) = gen_index_opt(gen_noop(), gen_const((yyvsp[-1].literal))); 3041| 10|} 3042| 10|#line 3043 "src/parser.c" 3043| 10| break; 3044| | 3045| 0| case 66: /* Term: Term '.' String '?' */ ------------------ | Branch (3045:3): [True: 0, False: 3.28M] ------------------ 3046| 0|#line 559 "src/parser.y" 3047| 0| { 3048| 0| (yyval.blk) = gen_index_opt((yyvsp[-3].blk), (yyvsp[-1].blk)); 3049| 0|} 3050| 0|#line 3051 "src/parser.c" 3051| 0| break; 3052| | 3053| 0| case 67: /* Term: '.' String '?' */ ------------------ | Branch (3053:3): [True: 0, False: 3.28M] ------------------ 3054| 0|#line 562 "src/parser.y" 3055| 0| { 3056| 0| (yyval.blk) = gen_index_opt(gen_noop(), (yyvsp[-1].blk)); 3057| 0|} 3058| 0|#line 3059 "src/parser.c" 3059| 0| break; 3060| | 3061| 200| case 68: /* Term: Term FIELD */ ------------------ | Branch (3061:3): [True: 200, False: 3.28M] ------------------ 3062| 200|#line 565 "src/parser.y" 3063| 200| { 3064| 200| (yyval.blk) = gen_index((yyvsp[-1].blk), gen_const((yyvsp[0].literal))); 3065| 200|} 3066| 200|#line 3067 "src/parser.c" 3067| 200| break; 3068| | 3069| 5.57k| case 69: /* Term: FIELD */ ------------------ | Branch (3069:3): [True: 5.57k, False: 3.27M] ------------------ 3070| 5.57k|#line 568 "src/parser.y" 3071| 5.57k| { 3072| 5.57k| (yyval.blk) = gen_index(gen_noop(), gen_const((yyvsp[0].literal))); 3073| 5.57k|} 3074| 5.57k|#line 3075 "src/parser.c" 3075| 5.57k| break; 3076| | 3077| 0| case 70: /* Term: Term '.' String */ ------------------ | Branch (3077:3): [True: 0, False: 3.28M] ------------------ 3078| 0|#line 571 "src/parser.y" 3079| 0| { 3080| 0| (yyval.blk) = gen_index((yyvsp[-2].blk), (yyvsp[0].blk)); 3081| 0|} 3082| 0|#line 3083 "src/parser.c" 3083| 0| break; 3084| | 3085| 0| case 71: /* Term: '.' String */ ------------------ | Branch (3085:3): [True: 0, False: 3.28M] ------------------ 3086| 0|#line 574 "src/parser.y" 3087| 0| { 3088| 0| (yyval.blk) = gen_index(gen_noop(), (yyvsp[0].blk)); 3089| 0|} 3090| 0|#line 3091 "src/parser.c" 3091| 0| break; 3092| | 3093| 1.75k| case 72: /* Term: '.' error */ ------------------ | Branch (3093:3): [True: 1.75k, False: 3.28M] ------------------ 3094| 1.75k|#line 577 "src/parser.y" 3095| 1.75k| { 3096| 1.75k| FAIL((yyloc), "try .[\"field\"] instead of .field for unusually named fields"); ------------------ | | 397| 1.75k| do { \ | | 398| 1.75k| location l = loc; \ | | 399| 1.75k| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 1.75k| /*YYERROR*/; \ | | 401| 1.75k| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 1.75k] | | ------------------ ------------------ 3097| 1.75k| (yyval.blk) = gen_noop(); 3098| 1.75k|} 3099| 1.75k|#line 3100 "src/parser.c" 3100| 1.75k| break; 3101| | 3102| 0| case 73: /* Term: '.' IDENT error */ ------------------ | Branch (3102:3): [True: 0, False: 3.28M] ------------------ 3103| 0|#line 581 "src/parser.y" 3104| 0| { 3105| 0| jv_free((yyvsp[-1].literal)); 3106| 0| FAIL((yyloc), "try .[\"field\"] instead of .field for unusually named fields"); ------------------ | | 397| 0| do { \ | | 398| 0| location l = loc; \ | | 399| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 0| /*YYERROR*/; \ | | 401| 0| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 0] | | ------------------ ------------------ 3107| 0| (yyval.blk) = gen_noop(); 3108| 0|} 3109| 0|#line 3110 "src/parser.c" 3110| 0| break; 3111| | 3112| 287| case 74: /* Term: Term '[' Query ']' '?' */ ------------------ | Branch (3112:3): [True: 287, False: 3.28M] ------------------ 3113| 287|#line 587 "src/parser.y" 3114| 287| { 3115| 287| (yyval.blk) = gen_index_opt((yyvsp[-4].blk), (yyvsp[-2].blk)); 3116| 287|} 3117| 287|#line 3118 "src/parser.c" 3118| 287| break; 3119| | 3120| 8.36k| case 75: /* Term: Term '[' Query ']' */ ------------------ | Branch (3120:3): [True: 8.36k, False: 3.27M] ------------------ 3121| 8.36k|#line 590 "src/parser.y" 3122| 8.36k| { 3123| 8.36k| (yyval.blk) = gen_index((yyvsp[-3].blk), (yyvsp[-1].blk)); 3124| 8.36k|} 3125| 8.36k|#line 3126 "src/parser.c" 3126| 8.36k| break; 3127| | 3128| 1| case 76: /* Term: Term '.' '[' Query ']' '?' */ ------------------ | Branch (3128:3): [True: 1, False: 3.28M] ------------------ 3129| 1|#line 593 "src/parser.y" 3130| 1| { 3131| 1| (yyval.blk) = gen_index_opt((yyvsp[-5].blk), (yyvsp[-2].blk)); 3132| 1|} 3133| 1|#line 3134 "src/parser.c" 3134| 1| break; 3135| | 3136| 301| case 77: /* Term: Term '.' '[' Query ']' */ ------------------ | Branch (3136:3): [True: 301, False: 3.28M] ------------------ 3137| 301|#line 596 "src/parser.y" 3138| 301| { 3139| 301| (yyval.blk) = gen_index((yyvsp[-4].blk), (yyvsp[-1].blk)); 3140| 301|} 3141| 301|#line 3142 "src/parser.c" 3142| 301| break; 3143| | 3144| 837| case 78: /* Term: Term '[' ']' '?' */ ------------------ | Branch (3144:3): [True: 837, False: 3.28M] ------------------ 3145| 837|#line 599 "src/parser.y" 3146| 837| { 3147| 837| (yyval.blk) = block_join((yyvsp[-3].blk), gen_op_simple(EACH_OPT)); 3148| 837|} 3149| 837|#line 3150 "src/parser.c" 3150| 837| break; 3151| | 3152| 3.68k| case 79: /* Term: Term '[' ']' */ ------------------ | Branch (3152:3): [True: 3.68k, False: 3.28M] ------------------ 3153| 3.68k|#line 602 "src/parser.y" 3154| 3.68k| { 3155| 3.68k| (yyval.blk) = block_join((yyvsp[-2].blk), gen_op_simple(EACH)); 3156| 3.68k|} 3157| 3.68k|#line 3158 "src/parser.c" 3158| 3.68k| break; 3159| | 3160| 2| case 80: /* Term: Term '.' '[' ']' '?' */ ------------------ | Branch (3160:3): [True: 2, False: 3.28M] ------------------ 3161| 2|#line 605 "src/parser.y" 3162| 2| { 3163| 2| (yyval.blk) = block_join((yyvsp[-4].blk), gen_op_simple(EACH_OPT)); 3164| 2|} 3165| 2|#line 3166 "src/parser.c" 3166| 2| break; 3167| | 3168| 1| case 81: /* Term: Term '.' '[' ']' */ ------------------ | Branch (3168:3): [True: 1, False: 3.28M] ------------------ 3169| 1|#line 608 "src/parser.y" 3170| 1| { 3171| 1| (yyval.blk) = block_join((yyvsp[-3].blk), gen_op_simple(EACH)); 3172| 1|} 3173| 1|#line 3174 "src/parser.c" 3174| 1| break; 3175| | 3176| 154| case 82: /* Term: Term '[' Query ':' Query ']' '?' */ ------------------ | Branch (3176:3): [True: 154, False: 3.28M] ------------------ 3177| 154|#line 611 "src/parser.y" 3178| 154| { 3179| 154| (yyval.blk) = gen_slice_index((yyvsp[-6].blk), (yyvsp[-4].blk), (yyvsp[-2].blk), INDEX_OPT); 3180| 154|} 3181| 154|#line 3182 "src/parser.c" 3182| 154| break; 3183| | 3184| 0| case 83: /* Term: Term '[' Query ':' ']' '?' */ ------------------ | Branch (3184:3): [True: 0, False: 3.28M] ------------------ 3185| 0|#line 614 "src/parser.y" 3186| 0| { 3187| 0| (yyval.blk) = gen_slice_index((yyvsp[-5].blk), (yyvsp[-3].blk), gen_const(jv_null()), INDEX_OPT); 3188| 0|} 3189| 0|#line 3190 "src/parser.c" 3190| 0| break; 3191| | 3192| 0| case 84: /* Term: Term '[' ':' Query ']' '?' */ ------------------ | Branch (3192:3): [True: 0, False: 3.28M] ------------------ 3193| 0|#line 617 "src/parser.y" 3194| 0| { 3195| 0| (yyval.blk) = gen_slice_index((yyvsp[-5].blk), gen_const(jv_null()), (yyvsp[-2].blk), INDEX_OPT); 3196| 0|} 3197| 0|#line 3198 "src/parser.c" 3198| 0| break; 3199| | 3200| 315| case 85: /* Term: Term '[' Query ':' Query ']' */ ------------------ | Branch (3200:3): [True: 315, False: 3.28M] ------------------ 3201| 315|#line 620 "src/parser.y" 3202| 315| { 3203| 315| (yyval.blk) = gen_slice_index((yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk), INDEX); 3204| 315|} 3205| 315|#line 3206 "src/parser.c" 3206| 315| break; 3207| | 3208| 1.03k| case 86: /* Term: Term '[' Query ':' ']' */ ------------------ | Branch (3208:3): [True: 1.03k, False: 3.28M] ------------------ 3209| 1.03k|#line 623 "src/parser.y" 3210| 1.03k| { 3211| 1.03k| (yyval.blk) = gen_slice_index((yyvsp[-4].blk), (yyvsp[-2].blk), gen_const(jv_null()), INDEX); 3212| 1.03k|} 3213| 1.03k|#line 3214 "src/parser.c" 3214| 1.03k| break; 3215| | 3216| 184| case 87: /* Term: Term '[' ':' Query ']' */ ------------------ | Branch (3216:3): [True: 184, False: 3.28M] ------------------ 3217| 184|#line 626 "src/parser.y" 3218| 184| { 3219| 184| (yyval.blk) = gen_slice_index((yyvsp[-4].blk), gen_const(jv_null()), (yyvsp[-1].blk), INDEX); 3220| 184|} 3221| 184|#line 3222 "src/parser.c" 3222| 184| break; 3223| | 3224| 2.47k| case 88: /* Term: Term '?' */ ------------------ | Branch (3224:3): [True: 2.47k, False: 3.28M] ------------------ 3225| 2.47k|#line 629 "src/parser.y" 3226| 2.47k| { 3227| 2.47k| (yyval.blk) = gen_try((yyvsp[-1].blk), gen_op_simple(BACKTRACK)); 3228| 2.47k|} 3229| 2.47k|#line 3230 "src/parser.c" 3230| 2.47k| break; 3231| | 3232| 269k| case 89: /* Term: LITERAL */ ------------------ | Branch (3232:3): [True: 269k, False: 3.01M] ------------------ 3233| 269k|#line 632 "src/parser.y" 3234| 269k| { 3235| 269k| (yyval.blk) = gen_const((yyvsp[0].literal)); 3236| 269k|} 3237| 269k|#line 3238 "src/parser.c" 3238| 269k| break; 3239| | 3240| 15.0k| case 90: /* Term: String */ ------------------ | Branch (3240:3): [True: 15.0k, False: 3.26M] ------------------ 3241| 15.0k|#line 635 "src/parser.y" 3242| 15.0k| { 3243| 15.0k| (yyval.blk) = (yyvsp[0].blk); 3244| 15.0k|} 3245| 15.0k|#line 3246 "src/parser.c" 3246| 15.0k| break; 3247| | 3248| 1.11k| case 91: /* Term: FORMAT */ ------------------ | Branch (3248:3): [True: 1.11k, False: 3.28M] ------------------ 3249| 1.11k|#line 638 "src/parser.y" 3250| 1.11k| { 3251| 1.11k| (yyval.blk) = gen_format(gen_noop(), (yyvsp[0].literal)); 3252| 1.11k|} 3253| 1.11k|#line 3254 "src/parser.c" 3254| 1.11k| break; 3255| | 3256| 8.65k| case 92: /* Term: '-' Term */ ------------------ | Branch (3256:3): [True: 8.65k, False: 3.27M] ------------------ 3257| 8.65k|#line 641 "src/parser.y" 3258| 8.65k| { 3259| 8.65k| (yyval.blk) = BLOCK((yyvsp[0].blk), gen_call("_negate", gen_noop())); ------------------ | | 102| 8.65k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 8.65k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 8.65k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 8.65k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3260| 8.65k|} 3261| 8.65k|#line 3262 "src/parser.c" 3262| 8.65k| break; 3263| | 3264| 13.5k| case 93: /* Term: '(' Query ')' */ ------------------ | Branch (3264:3): [True: 13.5k, False: 3.27M] ------------------ 3265| 13.5k|#line 644 "src/parser.y" 3266| 13.5k| { 3267| 13.5k| (yyval.blk) = (yyvsp[-1].blk); 3268| 13.5k|} 3269| 13.5k|#line 3270 "src/parser.c" 3270| 13.5k| break; 3271| | 3272| 184k| case 94: /* Term: '[' Query ']' */ ------------------ | Branch (3272:3): [True: 184k, False: 3.09M] ------------------ 3273| 184k|#line 647 "src/parser.y" 3274| 184k| { 3275| 184k| (yyval.blk) = gen_collect((yyvsp[-1].blk)); 3276| 184k|} 3277| 184k|#line 3278 "src/parser.c" 3278| 184k| break; 3279| | 3280| 4.76k| case 95: /* Term: '[' ']' */ ------------------ | Branch (3280:3): [True: 4.76k, False: 3.27M] ------------------ 3281| 4.76k|#line 650 "src/parser.y" 3282| 4.76k| { 3283| 4.76k| (yyval.blk) = gen_const(jv_array()); 3284| 4.76k|} 3285| 4.76k|#line 3286 "src/parser.c" 3286| 4.76k| break; 3287| | 3288| 66.3k| case 96: /* Term: '{' DictPairs '}' */ ------------------ | Branch (3288:3): [True: 66.3k, False: 3.21M] ------------------ 3289| 66.3k|#line 653 "src/parser.y" 3290| 66.3k| { 3291| 66.3k| block o = gen_const_object((yyvsp[-1].blk)); 3292| 66.3k| if (o.first != NULL) ------------------ | Branch (3292:7): [True: 56.0k, False: 10.3k] ------------------ 3293| 56.0k| (yyval.blk) = o; 3294| 10.3k| else 3295| 10.3k| (yyval.blk) = BLOCK(gen_subexp(gen_const(jv_object())), (yyvsp[-1].blk), gen_op_simple(POP)); ------------------ | | 102| 10.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 10.3k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 10.3k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 10.3k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 10.3k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3296| 66.3k|} 3297| 66.3k|#line 3298 "src/parser.c" 3298| 66.3k| break; 3299| | 3300| 2.17k| case 97: /* Term: "reduce" Expr "as" Patterns '(' Query ';' Query ')' */ ------------------ | Branch (3300:3): [True: 2.17k, False: 3.28M] ------------------ 3301| 2.17k|#line 660 "src/parser.y" 3302| 2.17k| { 3303| 2.17k| (yyval.blk) = gen_reduce((yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk)); 3304| 2.17k|} 3305| 2.17k|#line 3306 "src/parser.c" 3306| 2.17k| break; 3307| | 3308| 543| case 98: /* Term: "foreach" Expr "as" Patterns '(' Query ';' Query ';' Query ')' */ ------------------ | Branch (3308:3): [True: 543, False: 3.28M] ------------------ 3309| 543|#line 663 "src/parser.y" 3310| 543| { 3311| 543| (yyval.blk) = gen_foreach((yyvsp[-9].blk), (yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk)); 3312| 543|} 3313| 543|#line 3314 "src/parser.c" 3314| 543| break; 3315| | 3316| 181| case 99: /* Term: "foreach" Expr "as" Patterns '(' Query ';' Query ')' */ ------------------ | Branch (3316:3): [True: 181, False: 3.28M] ------------------ 3317| 181|#line 666 "src/parser.y" 3318| 181| { 3319| 181| (yyval.blk) = gen_foreach((yyvsp[-7].blk), (yyvsp[-5].blk), (yyvsp[-3].blk), (yyvsp[-1].blk), gen_noop()); 3320| 181|} 3321| 181|#line 3322 "src/parser.c" 3322| 181| break; 3323| | 3324| 5.63k| case 100: /* Term: "if" Query "then" Query ElseBody */ ------------------ | Branch (3324:3): [True: 5.63k, False: 3.27M] ------------------ 3325| 5.63k|#line 669 "src/parser.y" 3326| 5.63k| { 3327| 5.63k| (yyval.blk) = gen_cond((yyvsp[-3].blk), (yyvsp[-1].blk), (yyvsp[0].blk)); 3328| 5.63k|} 3329| 5.63k|#line 3330 "src/parser.c" 3330| 5.63k| break; 3331| | 3332| 631| case 101: /* Term: "if" Query "then" error */ ------------------ | Branch (3332:3): [True: 631, False: 3.28M] ------------------ 3333| 631|#line 672 "src/parser.y" 3334| 631| { 3335| 631| FAIL((yyloc), "Possibly unterminated 'if' statement"); ------------------ | | 397| 631| do { \ | | 398| 631| location l = loc; \ | | 399| 631| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 631| /*YYERROR*/; \ | | 401| 631| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 631] | | ------------------ ------------------ 3336| 631| (yyval.blk) = (yyvsp[-2].blk); 3337| 631|} 3338| 631|#line 3339 "src/parser.c" 3339| 631| break; 3340| | 3341| 456| case 102: /* Term: "try" Expr "catch" Expr */ ------------------ | Branch (3341:3): [True: 456, False: 3.28M] ------------------ 3342| 456|#line 676 "src/parser.y" 3343| 456| { 3344| 456| (yyval.blk) = gen_try((yyvsp[-2].blk), (yyvsp[0].blk)); 3345| 456|} 3346| 456|#line 3347 "src/parser.c" 3347| 456| break; 3348| | 3349| 133| case 103: /* Term: "try" Expr "catch" error */ ------------------ | Branch (3349:3): [True: 133, False: 3.28M] ------------------ 3350| 133|#line 679 "src/parser.y" 3351| 133| { 3352| 133| FAIL((yyloc), "Possibly unterminated 'try' statement"); ------------------ | | 397| 133| do { \ | | 398| 133| location l = loc; \ | | 399| 133| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 133| /*YYERROR*/; \ | | 401| 133| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 133] | | ------------------ ------------------ 3353| 133| (yyval.blk) = (yyvsp[-2].blk); 3354| 133|} 3355| 133|#line 3356 "src/parser.c" 3356| 133| break; 3357| | 3358| 20| case 104: /* Term: "try" Expr */ ------------------ | Branch (3358:3): [True: 20, False: 3.28M] ------------------ 3359| 20|#line 683 "src/parser.y" 3360| 20| { 3361| 20| (yyval.blk) = gen_try((yyvsp[0].blk), gen_op_simple(BACKTRACK)); 3362| 20|} 3363| 20|#line 3364 "src/parser.c" 3364| 20| break; 3365| | 3366| 1.77k| case 105: /* Term: '$' '$' '$' BINDING */ ------------------ | Branch (3366:3): [True: 1.77k, False: 3.28M] ------------------ 3367| 1.77k|#line 701 "src/parser.y" 3368| 1.77k| { 3369| 1.77k| (yyval.blk) = gen_location((yyloc), locations, gen_op_unbound(LOADVN, jv_string_value((yyvsp[0].literal)))); 3370| 1.77k| jv_free((yyvsp[0].literal)); 3371| 1.77k|} 3372| 1.77k|#line 3373 "src/parser.c" 3373| 1.77k| break; 3374| | 3375| 27.2k| case 106: /* Term: BINDING */ ------------------ | Branch (3375:3): [True: 27.2k, False: 3.25M] ------------------ 3376| 27.2k|#line 705 "src/parser.y" 3377| 27.2k| { 3378| 27.2k| (yyval.blk) = gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[0].literal)))); 3379| 27.2k| jv_free((yyvsp[0].literal)); 3380| 27.2k|} 3381| 27.2k|#line 3382 "src/parser.c" 3382| 27.2k| break; 3383| | 3384| 0| case 107: /* Term: "$__loc__" */ ------------------ | Branch (3384:3): [True: 0, False: 3.28M] ------------------ 3385| 0|#line 709 "src/parser.y" 3386| 0| { 3387| 0| (yyval.blk) = gen_loc_object(&(yyloc), locations); 3388| 0|} 3389| 0|#line 3390 "src/parser.c" 3390| 0| break; 3391| | 3392| 120k| case 108: /* Term: IDENT */ ------------------ | Branch (3392:3): [True: 120k, False: 3.16M] ------------------ 3393| 120k|#line 712 "src/parser.y" 3394| 120k| { 3395| 120k| const char *s = jv_string_value((yyvsp[0].literal)); 3396| 120k| if (strcmp(s, "false") == 0) ------------------ | Branch (3396:7): [True: 576, False: 120k] ------------------ 3397| 576| (yyval.blk) = gen_const(jv_false()); 3398| 120k| else if (strcmp(s, "true") == 0) ------------------ | Branch (3398:12): [True: 386, False: 119k] ------------------ 3399| 386| (yyval.blk) = gen_const(jv_true()); 3400| 119k| else if (strcmp(s, "null") == 0) ------------------ | Branch (3400:12): [True: 4.29k, False: 115k] ------------------ 3401| 4.29k| (yyval.blk) = gen_const(jv_null()); 3402| 115k| else 3403| 115k| (yyval.blk) = gen_location((yyloc), locations, gen_call(s, gen_noop())); 3404| 120k| jv_free((yyvsp[0].literal)); 3405| 120k|} 3406| 120k|#line 3407 "src/parser.c" 3407| 120k| break; 3408| | 3409| 23.1k| case 109: /* Term: IDENT '(' Args ')' */ ------------------ | Branch (3409:3): [True: 23.1k, False: 3.26M] ------------------ 3410| 23.1k|#line 724 "src/parser.y" 3411| 23.1k| { 3412| 23.1k| (yyval.blk) = gen_call(jv_string_value((yyvsp[-3].literal)), (yyvsp[-1].blk)); 3413| 23.1k| (yyval.blk) = gen_location((yylsp[-3]), locations, (yyval.blk)); 3414| 23.1k| jv_free((yyvsp[-3].literal)); 3415| 23.1k|} 3416| 23.1k|#line 3417 "src/parser.c" 3417| 23.1k| break; 3418| | 3419| 3.19k| case 110: /* Term: '(' error ')' */ ------------------ | Branch (3419:3): [True: 3.19k, False: 3.28M] ------------------ 3420| 3.19k|#line 729 "src/parser.y" 3421| 3.19k| { (yyval.blk) = gen_noop(); } 3422| 3.19k|#line 3423 "src/parser.c" 3423| 3.19k| break; 3424| | 3425| 2.10k| case 111: /* Term: '[' error ']' */ ------------------ | Branch (3425:3): [True: 2.10k, False: 3.28M] ------------------ 3426| 2.10k|#line 730 "src/parser.y" 3427| 2.10k| { (yyval.blk) = gen_noop(); } 3428| 2.10k|#line 3429 "src/parser.c" 3429| 2.10k| break; 3430| | 3431| 926| case 112: /* Term: Term '[' error ']' */ ------------------ | Branch (3431:3): [True: 926, False: 3.28M] ------------------ 3432| 926|#line 731 "src/parser.y" 3433| 926| { (yyval.blk) = (yyvsp[-3].blk); } 3434| 926|#line 3435 "src/parser.c" 3435| 926| break; 3436| | 3437| 17.5k| case 113: /* Term: '{' error '}' */ ------------------ | Branch (3437:3): [True: 17.5k, False: 3.26M] ------------------ 3438| 17.5k|#line 732 "src/parser.y" 3439| 17.5k| { (yyval.blk) = gen_noop(); } 3440| 17.5k|#line 3441 "src/parser.c" 3441| 17.5k| break; 3442| | 3443| 23.3k| case 114: /* Args: Arg */ ------------------ | Branch (3443:3): [True: 23.3k, False: 3.26M] ------------------ 3444| 23.3k|#line 735 "src/parser.y" 3445| 23.3k| { 3446| 23.3k| (yyval.blk) = (yyvsp[0].blk); 3447| 23.3k|} 3448| 23.3k|#line 3449 "src/parser.c" 3449| 23.3k| break; 3450| | 3451| 75.1k| case 115: /* Args: Args ';' Arg */ ------------------ | Branch (3451:3): [True: 75.1k, False: 3.20M] ------------------ 3452| 75.1k|#line 738 "src/parser.y" 3453| 75.1k| { 3454| 75.1k| (yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk)); ------------------ | | 102| 75.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 75.1k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 75.1k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 75.1k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3455| 75.1k|} 3456| 75.1k|#line 3457 "src/parser.c" 3457| 75.1k| break; 3458| | 3459| 98.5k| case 116: /* Arg: Query */ ------------------ | Branch (3459:3): [True: 98.5k, False: 3.18M] ------------------ 3460| 98.5k|#line 743 "src/parser.y" 3461| 98.5k| { 3462| 98.5k| (yyval.blk) = gen_lambda((yyvsp[0].blk)); 3463| 98.5k|} 3464| 98.5k|#line 3465 "src/parser.c" 3465| 98.5k| break; 3466| | 3467| 3.19k| case 117: /* RepPatterns: RepPatterns '?' "//" Pattern */ ------------------ | Branch (3467:3): [True: 3.19k, False: 3.28M] ------------------ 3468| 3.19k|#line 748 "src/parser.y" 3469| 3.19k| { 3470| 3.19k| (yyval.blk) = BLOCK((yyvsp[-3].blk), gen_destructure_alt((yyvsp[0].blk))); ------------------ | | 102| 3.19k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 3.19k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 3.19k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 3.19k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3471| 3.19k|} 3472| 3.19k|#line 3473 "src/parser.c" 3473| 3.19k| break; 3474| | 3475| 1.77k| case 118: /* RepPatterns: Pattern */ ------------------ | Branch (3475:3): [True: 1.77k, False: 3.28M] ------------------ 3476| 1.77k|#line 751 "src/parser.y" 3477| 1.77k| { 3478| 1.77k| (yyval.blk) = gen_destructure_alt((yyvsp[0].blk)); 3479| 1.77k|} 3480| 1.77k|#line 3481 "src/parser.c" 3481| 1.77k| break; 3482| | 3483| 1.42k| case 119: /* Patterns: RepPatterns '?' "//" Pattern */ ------------------ | Branch (3483:3): [True: 1.42k, False: 3.28M] ------------------ 3484| 1.42k|#line 756 "src/parser.y" 3485| 1.42k| { 3486| 1.42k| (yyval.blk) = BLOCK((yyvsp[-3].blk), (yyvsp[0].blk)); ------------------ | | 102| 1.42k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.42k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.42k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 1.42k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3487| 1.42k|} 3488| 1.42k|#line 3489 "src/parser.c" 3489| 1.42k| break; 3490| | 3491| 7.10k| case 120: /* Patterns: Pattern */ ------------------ | Branch (3491:3): [True: 7.10k, False: 3.27M] ------------------ 3492| 7.10k|#line 759 "src/parser.y" 3493| 7.10k| { 3494| 7.10k| (yyval.blk) = (yyvsp[0].blk); 3495| 7.10k|} 3496| 7.10k|#line 3497 "src/parser.c" 3497| 7.10k| break; 3498| | 3499| 15.8k| case 121: /* Pattern: BINDING */ ------------------ | Branch (3499:3): [True: 15.8k, False: 3.26M] ------------------ 3500| 15.8k|#line 764 "src/parser.y" 3501| 15.8k| { 3502| 15.8k| (yyval.blk) = gen_op_unbound(STOREV, jv_string_value((yyvsp[0].literal))); 3503| 15.8k| jv_free((yyvsp[0].literal)); 3504| 15.8k|} 3505| 15.8k|#line 3506 "src/parser.c" 3506| 15.8k| break; 3507| | 3508| 2| case 122: /* Pattern: '[' ArrayPats ']' */ ------------------ | Branch (3508:3): [True: 2, False: 3.28M] ------------------ 3509| 2|#line 768 "src/parser.y" 3510| 2| { 3511| 2| (yyval.blk) = BLOCK((yyvsp[-1].blk), gen_op_simple(POP)); ------------------ | | 102| 2| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 2|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 2| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 2|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3512| 2|} 3513| 2|#line 3514 "src/parser.c" 3514| 2| break; 3515| | 3516| 204| case 123: /* Pattern: '{' ObjPats '}' */ ------------------ | Branch (3516:3): [True: 204, False: 3.28M] ------------------ 3517| 204|#line 771 "src/parser.y" 3518| 204| { 3519| 204| (yyval.blk) = BLOCK((yyvsp[-1].blk), gen_op_simple(POP)); ------------------ | | 102| 204| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 204|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 204| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 204|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3520| 204|} 3521| 204|#line 3522 "src/parser.c" 3522| 204| break; 3523| | 3524| 35| case 124: /* ArrayPats: Pattern */ ------------------ | Branch (3524:3): [True: 35, False: 3.28M] ------------------ 3525| 35|#line 776 "src/parser.y" 3526| 35| { 3527| 35| (yyval.blk) = gen_array_matcher(gen_noop(), (yyvsp[0].blk)); 3528| 35|} 3529| 35|#line 3530 "src/parser.c" 3530| 35| break; 3531| | 3532| 130| case 125: /* ArrayPats: ArrayPats ',' Pattern */ ------------------ | Branch (3532:3): [True: 130, False: 3.28M] ------------------ 3533| 130|#line 779 "src/parser.y" 3534| 130| { 3535| 130| (yyval.blk) = gen_array_matcher((yyvsp[-2].blk), (yyvsp[0].blk)); 3536| 130|} 3537| 130|#line 3538 "src/parser.c" 3538| 130| break; 3539| | 3540| 698| case 126: /* ObjPats: ObjPat */ ------------------ | Branch (3540:3): [True: 698, False: 3.28M] ------------------ 3541| 698|#line 784 "src/parser.y" 3542| 698| { 3543| 698| (yyval.blk) = (yyvsp[0].blk); 3544| 698|} 3545| 698|#line 3546 "src/parser.c" 3546| 698| break; 3547| | 3548| 3.01k| case 127: /* ObjPats: ObjPats ',' ObjPat */ ------------------ | Branch (3548:3): [True: 3.01k, False: 3.28M] ------------------ 3549| 3.01k|#line 787 "src/parser.y" 3550| 3.01k| { 3551| 3.01k| (yyval.blk) = BLOCK((yyvsp[-2].blk), (yyvsp[0].blk)); ------------------ | | 102| 3.01k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 3.01k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 3.01k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 3.01k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3552| 3.01k|} 3553| 3.01k|#line 3554 "src/parser.c" 3554| 3.01k| break; 3555| | 3556| 1.29k| case 128: /* ObjPat: BINDING */ ------------------ | Branch (3556:3): [True: 1.29k, False: 3.28M] ------------------ 3557| 1.29k|#line 792 "src/parser.y" 3558| 1.29k| { 3559| 1.29k| (yyval.blk) = gen_object_matcher(gen_const((yyvsp[0].literal)), gen_op_unbound(STOREV, jv_string_value((yyvsp[0].literal)))); 3560| 1.29k|} 3561| 1.29k|#line 3562 "src/parser.c" 3562| 1.29k| break; 3563| | 3564| 4| case 129: /* ObjPat: BINDING ':' Pattern */ ------------------ | Branch (3564:3): [True: 4, False: 3.28M] ------------------ 3565| 4|#line 795 "src/parser.y" 3566| 4| { 3567| 4| (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| 4| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 4|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 4| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 4|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 4|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3568| 4|} 3569| 4|#line 3570 "src/parser.c" 3570| 4| break; 3571| | 3572| 69| case 130: /* ObjPat: IDENT ':' Pattern */ ------------------ | Branch (3572:3): [True: 69, False: 3.28M] ------------------ 3573| 69|#line 798 "src/parser.y" 3574| 69| { 3575| 69| (yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3576| 69|} 3577| 69|#line 3578 "src/parser.c" 3578| 69| break; 3579| | 3580| 129| case 131: /* ObjPat: Keyword ':' Pattern */ ------------------ | Branch (3580:3): [True: 129, False: 3.28M] ------------------ 3581| 129|#line 801 "src/parser.y" 3582| 129| { 3583| 129| (yyval.blk) = gen_object_matcher(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3584| 129|} 3585| 129|#line 3586 "src/parser.c" 3586| 129| break; 3587| | 3588| 0| case 132: /* ObjPat: String ':' Pattern */ ------------------ | Branch (3588:3): [True: 0, False: 3.28M] ------------------ 3589| 0|#line 804 "src/parser.y" 3590| 0| { 3591| 0| (yyval.blk) = gen_object_matcher((yyvsp[-2].blk), (yyvsp[0].blk)); 3592| 0|} 3593| 0|#line 3594 "src/parser.c" 3594| 0| break; 3595| | 3596| 1.09k| case 133: /* ObjPat: '(' Query ')' ':' Pattern */ ------------------ | Branch (3596:3): [True: 1.09k, False: 3.28M] ------------------ 3597| 1.09k|#line 807 "src/parser.y" 3598| 1.09k| { 3599| 1.09k| jv msg = check_object_key((yyvsp[-3].blk)); 3600| 1.09k| if (jv_is_valid(msg)) { ------------------ | Branch (3600:7): [True: 0, False: 1.09k] ------------------ 3601| 0| FAIL((yylsp[-3]), jv_string_value(msg)); ------------------ | | 397| 0| do { \ | | 398| 0| location l = loc; \ | | 399| 0| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 0| /*YYERROR*/; \ | | 401| 0| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 0] | | ------------------ ------------------ 3602| 0| } 3603| 1.09k| jv_free(msg); 3604| 1.09k| (yyval.blk) = gen_object_matcher((yyvsp[-3].blk), (yyvsp[0].blk)); 3605| 1.09k|} 3606| 1.09k|#line 3607 "src/parser.c" 3607| 1.09k| break; 3608| | 3609| 1.12k| case 134: /* ObjPat: error ':' Pattern */ ------------------ | Branch (3609:3): [True: 1.12k, False: 3.28M] ------------------ 3610| 1.12k|#line 815 "src/parser.y" 3611| 1.12k| { 3612| 1.12k| FAIL((yyloc), "May need parentheses around object key expression"); ------------------ | | 397| 1.12k| do { \ | | 398| 1.12k| location l = loc; \ | | 399| 1.12k| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 1.12k| /*YYERROR*/; \ | | 401| 1.12k| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 1.12k] | | ------------------ ------------------ 3613| 1.12k| (yyval.blk) = (yyvsp[0].blk); 3614| 1.12k|} 3615| 1.12k|#line 3616 "src/parser.c" 3616| 1.12k| break; 3617| | 3618| 169| case 135: /* Keyword: "as" */ ------------------ | Branch (3618:3): [True: 169, False: 3.28M] ------------------ 3619| 169|#line 821 "src/parser.y" 3620| 169| { 3621| 169| (yyval.literal) = jv_string("as"); 3622| 169|} 3623| 169|#line 3624 "src/parser.c" 3624| 169| break; 3625| | 3626| 136| case 136: /* Keyword: "def" */ ------------------ | Branch (3626:3): [True: 136, False: 3.28M] ------------------ 3627| 136|#line 824 "src/parser.y" 3628| 136| { 3629| 136| (yyval.literal) = jv_string("def"); 3630| 136|} 3631| 136|#line 3632 "src/parser.c" 3632| 136| break; 3633| | 3634| 278| case 137: /* Keyword: "module" */ ------------------ | Branch (3634:3): [True: 278, False: 3.28M] ------------------ 3635| 278|#line 827 "src/parser.y" 3636| 278| { 3637| 278| (yyval.literal) = jv_string("module"); 3638| 278|} 3639| 278|#line 3640 "src/parser.c" 3640| 278| break; 3641| | 3642| 1.02k| case 138: /* Keyword: "import" */ ------------------ | Branch (3642:3): [True: 1.02k, False: 3.28M] ------------------ 3643| 1.02k|#line 830 "src/parser.y" 3644| 1.02k| { 3645| 1.02k| (yyval.literal) = jv_string("import"); 3646| 1.02k|} 3647| 1.02k|#line 3648 "src/parser.c" 3648| 1.02k| break; 3649| | 3650| 129| case 139: /* Keyword: "include" */ ------------------ | Branch (3650:3): [True: 129, False: 3.28M] ------------------ 3651| 129|#line 833 "src/parser.y" 3652| 129| { 3653| 129| (yyval.literal) = jv_string("include"); 3654| 129|} 3655| 129|#line 3656 "src/parser.c" 3656| 129| break; 3657| | 3658| 1| case 140: /* Keyword: "if" */ ------------------ | Branch (3658:3): [True: 1, False: 3.28M] ------------------ 3659| 1|#line 836 "src/parser.y" 3660| 1| { 3661| 1| (yyval.literal) = jv_string("if"); 3662| 1|} 3663| 1|#line 3664 "src/parser.c" 3664| 1| break; 3665| | 3666| 0| case 141: /* Keyword: "then" */ ------------------ | Branch (3666:3): [True: 0, False: 3.28M] ------------------ 3667| 0|#line 839 "src/parser.y" 3668| 0| { 3669| 0| (yyval.literal) = jv_string("then"); 3670| 0|} 3671| 0|#line 3672 "src/parser.c" 3672| 0| break; 3673| | 3674| 0| case 142: /* Keyword: "else" */ ------------------ | Branch (3674:3): [True: 0, False: 3.28M] ------------------ 3675| 0|#line 842 "src/parser.y" 3676| 0| { 3677| 0| (yyval.literal) = jv_string("else"); 3678| 0|} 3679| 0|#line 3680 "src/parser.c" 3680| 0| break; 3681| | 3682| 162| case 143: /* Keyword: "elif" */ ------------------ | Branch (3682:3): [True: 162, False: 3.28M] ------------------ 3683| 162|#line 845 "src/parser.y" 3684| 162| { 3685| 162| (yyval.literal) = jv_string("elif"); 3686| 162|} 3687| 162|#line 3688 "src/parser.c" 3688| 162| break; 3689| | 3690| 0| case 144: /* Keyword: "reduce" */ ------------------ | Branch (3690:3): [True: 0, False: 3.28M] ------------------ 3691| 0|#line 848 "src/parser.y" 3692| 0| { 3693| 0| (yyval.literal) = jv_string("reduce"); 3694| 0|} 3695| 0|#line 3696 "src/parser.c" 3696| 0| break; 3697| | 3698| 1| case 145: /* Keyword: "foreach" */ ------------------ | Branch (3698:3): [True: 1, False: 3.28M] ------------------ 3699| 1|#line 851 "src/parser.y" 3700| 1| { 3701| 1| (yyval.literal) = jv_string("foreach"); 3702| 1|} 3703| 1|#line 3704 "src/parser.c" 3704| 1| break; 3705| | 3706| 221| case 146: /* Keyword: "end" */ ------------------ | Branch (3706:3): [True: 221, False: 3.28M] ------------------ 3707| 221|#line 854 "src/parser.y" 3708| 221| { 3709| 221| (yyval.literal) = jv_string("end"); 3710| 221|} 3711| 221|#line 3712 "src/parser.c" 3712| 221| break; 3713| | 3714| 135| case 147: /* Keyword: "and" */ ------------------ | Branch (3714:3): [True: 135, False: 3.28M] ------------------ 3715| 135|#line 857 "src/parser.y" 3716| 135| { 3717| 135| (yyval.literal) = jv_string("and"); 3718| 135|} 3719| 135|#line 3720 "src/parser.c" 3720| 135| break; 3721| | 3722| 0| case 148: /* Keyword: "or" */ ------------------ | Branch (3722:3): [True: 0, False: 3.28M] ------------------ 3723| 0|#line 860 "src/parser.y" 3724| 0| { 3725| 0| (yyval.literal) = jv_string("or"); 3726| 0|} 3727| 0|#line 3728 "src/parser.c" 3728| 0| break; 3729| | 3730| 0| case 149: /* Keyword: "try" */ ------------------ | Branch (3730:3): [True: 0, False: 3.28M] ------------------ 3731| 0|#line 863 "src/parser.y" 3732| 0| { 3733| 0| (yyval.literal) = jv_string("try"); 3734| 0|} 3735| 0|#line 3736 "src/parser.c" 3736| 0| break; 3737| | 3738| 0| case 150: /* Keyword: "catch" */ ------------------ | Branch (3738:3): [True: 0, False: 3.28M] ------------------ 3739| 0|#line 866 "src/parser.y" 3740| 0| { 3741| 0| (yyval.literal) = jv_string("catch"); 3742| 0|} 3743| 0|#line 3744 "src/parser.c" 3744| 0| break; 3745| | 3746| 0| case 151: /* Keyword: "label" */ ------------------ | Branch (3746:3): [True: 0, False: 3.28M] ------------------ 3747| 0|#line 869 "src/parser.y" 3748| 0| { 3749| 0| (yyval.literal) = jv_string("label"); 3750| 0|} 3751| 0|#line 3752 "src/parser.c" 3752| 0| break; 3753| | 3754| 175| case 152: /* Keyword: "break" */ ------------------ | Branch (3754:3): [True: 175, False: 3.28M] ------------------ 3755| 175|#line 872 "src/parser.y" 3756| 175| { 3757| 175| (yyval.literal) = jv_string("break"); 3758| 175|} 3759| 175|#line 3760 "src/parser.c" 3760| 175| break; 3761| | 3762| 23.2k| case 153: /* DictPairs: %empty */ ------------------ | Branch (3762:3): [True: 23.2k, False: 3.26M] ------------------ 3763| 23.2k|#line 878 "src/parser.y" 3764| 23.2k| { 3765| 23.2k| (yyval.blk) = gen_noop(); 3766| 23.2k|} 3767| 23.2k|#line 3768 "src/parser.c" 3768| 23.2k| break; 3769| | 3770| 89.1k| case 154: /* DictPairs: DictPair */ ------------------ | Branch (3770:3): [True: 89.1k, False: 3.19M] ------------------ 3771| 89.1k|#line 881 "src/parser.y" 3772| 89.1k| { 3773| 89.1k| (yyval.blk) = (yyvsp[0].blk); 3774| 89.1k|} 3775| 89.1k|#line 3776 "src/parser.c" 3776| 89.1k| break; 3777| | 3778| 11.2k| case 155: /* DictPairs: DictPair ',' DictPairs */ ------------------ | Branch (3778:3): [True: 11.2k, False: 3.27M] ------------------ 3779| 11.2k|#line 884 "src/parser.y" 3780| 11.2k| { 3781| 11.2k| (yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk)); 3782| 11.2k|} 3783| 11.2k|#line 3784 "src/parser.c" 3784| 11.2k| break; 3785| | 3786| 48.4k| case 156: /* DictPair: IDENT ':' DictExpr */ ------------------ | Branch (3786:3): [True: 48.4k, False: 3.23M] ------------------ 3787| 48.4k|#line 889 "src/parser.y" 3788| 48.4k| { 3789| 48.4k| (yyval.blk) = gen_dictpair(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3790| 48.4k|} 3791| 48.4k|#line 3792 "src/parser.c" 3792| 48.4k| break; 3793| | 3794| 219| case 157: /* DictPair: Keyword ':' DictExpr */ ------------------ | Branch (3794:3): [True: 219, False: 3.28M] ------------------ 3795| 219|#line 892 "src/parser.y" 3796| 219| { 3797| 219| (yyval.blk) = gen_dictpair(gen_const((yyvsp[-2].literal)), (yyvsp[0].blk)); 3798| 219|} 3799| 219|#line 3800 "src/parser.c" 3800| 219| break; 3801| | 3802| 9.84k| case 158: /* DictPair: String ':' DictExpr */ ------------------ | Branch (3802:3): [True: 9.84k, False: 3.27M] ------------------ 3803| 9.84k|#line 895 "src/parser.y" 3804| 9.84k| { 3805| 9.84k| (yyval.blk) = gen_dictpair((yyvsp[-2].blk), (yyvsp[0].blk)); 3806| 9.84k|} 3807| 9.84k|#line 3808 "src/parser.c" 3808| 9.84k| break; 3809| | 3810| 413| case 159: /* DictPair: String */ ------------------ | Branch (3810:3): [True: 413, False: 3.28M] ------------------ 3811| 413|#line 898 "src/parser.y" 3812| 413| { 3813| 413| (yyval.blk) = gen_dictpair((yyvsp[0].blk), BLOCK(gen_op_simple(POP), gen_op_simple(DUP2), ------------------ | | 102| 413| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 413|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 413| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 413|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 413|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 413|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3814| 413| gen_op_simple(DUP2), gen_op_simple(INDEX))); 3815| 413|} 3816| 413|#line 3817 "src/parser.c" 3817| 413| break; 3818| | 3819| 0| case 160: /* DictPair: BINDING ':' DictExpr */ ------------------ | Branch (3819:3): [True: 0, False: 3.28M] ------------------ 3820| 0|#line 902 "src/parser.y" 3821| 0| { 3822| 0| (yyval.blk) = gen_dictpair(gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[-2].literal)))), 3823| 0| (yyvsp[0].blk)); 3824| 0| jv_free((yyvsp[-2].literal)); 3825| 0|} 3826| 0|#line 3827 "src/parser.c" 3827| 0| break; 3828| | 3829| 0| case 161: /* DictPair: BINDING */ ------------------ | Branch (3829:3): [True: 0, False: 3.28M] ------------------ 3830| 0|#line 907 "src/parser.y" 3831| 0| { 3832| 0| (yyval.blk) = gen_dictpair(gen_const((yyvsp[0].literal)), 3833| 0| gen_location((yyloc), locations, gen_op_unbound(LOADV, jv_string_value((yyvsp[0].literal))))); 3834| 0|} 3835| 0|#line 3836 "src/parser.c" 3836| 0| break; 3837| | 3838| 10.7k| case 162: /* DictPair: IDENT */ ------------------ | Branch (3838:3): [True: 10.7k, False: 3.27M] ------------------ 3839| 10.7k|#line 911 "src/parser.y" 3840| 10.7k| { 3841| 10.7k| (yyval.blk) = gen_dictpair(gen_const(jv_copy((yyvsp[0].literal))), 3842| 10.7k| gen_index(gen_noop(), gen_const((yyvsp[0].literal)))); 3843| 10.7k|} 3844| 10.7k|#line 3845 "src/parser.c" 3845| 10.7k| break; 3846| | 3847| 0| case 163: /* DictPair: "$__loc__" */ ------------------ | Branch (3847:3): [True: 0, False: 3.28M] ------------------ 3848| 0|#line 915 "src/parser.y" 3849| 0| { 3850| 0| (yyval.blk) = gen_dictpair(gen_const(jv_string("__loc__")), 3851| 0| gen_loc_object(&(yyloc), locations)); 3852| 0|} 3853| 0|#line 3854 "src/parser.c" 3854| 0| break; 3855| | 3856| 1.81k| case 164: /* DictPair: Keyword */ ------------------ | Branch (3856:3): [True: 1.81k, False: 3.28M] ------------------ 3857| 1.81k|#line 919 "src/parser.y" 3858| 1.81k| { 3859| 1.81k| (yyval.blk) = gen_dictpair(gen_const(jv_copy((yyvsp[0].literal))), 3860| 1.81k| gen_index(gen_noop(), gen_const((yyvsp[0].literal)))); 3861| 1.81k|} 3862| 1.81k|#line 3863 "src/parser.c" 3863| 1.81k| break; 3864| | 3865| 813| case 165: /* DictPair: '(' Query ')' ':' DictExpr */ ------------------ | Branch (3865:3): [True: 813, False: 3.28M] ------------------ 3866| 813|#line 923 "src/parser.y" 3867| 813| { 3868| 813| jv msg = check_object_key((yyvsp[-3].blk)); 3869| 813| if (jv_is_valid(msg)) { ------------------ | Branch (3869:7): [True: 19, False: 794] ------------------ 3870| 19| FAIL((yylsp[-3]), jv_string_value(msg)); ------------------ | | 397| 19| do { \ | | 398| 19| location l = loc; \ | | 399| 19| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 19| /*YYERROR*/; \ | | 401| 19| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 19] | | ------------------ ------------------ 3871| 19| } 3872| 813| jv_free(msg); 3873| 813| (yyval.blk) = gen_dictpair((yyvsp[-3].blk), (yyvsp[0].blk)); 3874| 813|} 3875| 813|#line 3876 "src/parser.c" 3876| 813| break; 3877| | 3878| 30.4k| case 166: /* DictPair: error ':' DictExpr */ ------------------ | Branch (3878:3): [True: 30.4k, False: 3.25M] ------------------ 3879| 30.4k|#line 931 "src/parser.y" 3880| 30.4k| { 3881| 30.4k| FAIL((yylsp[-2]), "May need parentheses around object key expression"); ------------------ | | 397| 30.4k| do { \ | | 398| 30.4k| location l = loc; \ | | 399| 30.4k| yyerror(&l, answer, errors, locations, lexer_param_ptr, msg); \ | | 400| 30.4k| /*YYERROR*/; \ | | 401| 30.4k| } while (0) | | ------------------ | | | Branch (401:12): [Folded, False: 30.4k] | | ------------------ ------------------ 3882| 30.4k| (yyval.blk) = (yyvsp[0].blk); 3883| 30.4k|} 3884| 30.4k|#line 3885 "src/parser.c" 3885| 30.4k| break; 3886| | 3887| 1.53k| case 167: /* DictExpr: DictExpr '|' DictExpr */ ------------------ | Branch (3887:3): [True: 1.53k, False: 3.28M] ------------------ 3888| 1.53k|#line 937 "src/parser.y" 3889| 1.53k| { 3890| 1.53k| (yyval.blk) = block_join((yyvsp[-2].blk), (yyvsp[0].blk)); 3891| 1.53k|} 3892| 1.53k|#line 3893 "src/parser.c" 3893| 1.53k| break; 3894| | 3895| 94.6k| case 168: /* DictExpr: Expr */ ------------------ | Branch (3895:3): [True: 94.6k, False: 3.18M] ------------------ 3896| 94.6k|#line 940 "src/parser.y" 3897| 94.6k| { 3898| 94.6k| (yyval.blk) = (yyvsp[0].blk); 3899| 94.6k|} 3900| 94.6k|#line 3901 "src/parser.c" 3901| 94.6k| break; 3902| | 3903| | 3904| 0|#line 3905 "src/parser.c" 3905| | 3906| 0| default: break; ------------------ | Branch (3906:7): [True: 0, False: 3.28M] ------------------ 3907| 3.28M| } 3908| | /* User semantic actions sometimes alter yychar, and that requires 3909| | that yytoken be updated with the new translation. We take the 3910| | approach of translating immediately before every use of yytoken. 3911| | One alternative is translating here after every semantic action, 3912| | but that translation would be missed if the semantic action invokes 3913| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 3914| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 3915| | incorrect destructor might then be invoked immediately. In the 3916| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 3917| | to an incorrect destructor call or verbose syntax error message 3918| | before the lookahead is translated. */ 3919| 3.28M| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 3920| | 3921| 3.28M| YYPOPSTACK (yylen); ------------------ | | 2270| 3.28M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 3922| 3.28M| yylen = 0; 3923| | 3924| 3.28M| *++yyvsp = yyval; 3925| 3.28M| *++yylsp = yyloc; 3926| | 3927| | /* Now 'shift' the result of the reduction. Determine what state 3928| | that goes to, based on the state we popped back to and the rule 3929| | number reduced by. */ 3930| 3.28M| { 3931| 3.28M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 873| 3.28M|#define YYNTOKENS 69 ------------------ 3932| 3.28M| const int yyi = yypgoto[yylhs] + *yyssp; 3933| 3.28M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 870| 6.15M|#define YYLAST 1165 ------------------ | Branch (3933:16): [True: 2.86M, False: 416k] | Branch (3933:28): [True: 2.86M, False: 0] | Branch (3933:45): [True: 1.18M, False: 1.68M] ------------------ 3934| 3.28M| ? yytable[yyi] 3935| 3.28M| : yydefgoto[yylhs]); 3936| 3.28M| } 3937| | 3938| 3.28M| goto yynewstate; 3939| | 3940| | 3941| |/*--------------------------------------. 3942| || yyerrlab -- here on detecting error. | 3943| |`--------------------------------------*/ 3944| 1.00M|yyerrlab: 3945| | /* Make sure we have latest lookahead translation. See comments at 3946| | user semantic actions for why this is necessary. */ 3947| 1.00M| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 194| 1.00M|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 888| 2.01M| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 882| 1.00M|#define YYMAXUTOK 302 | | ------------------ | | | Branch (888:4): [True: 1.00M, False: 0] | | | Branch (888:18): [True: 1.00M, False: 0] | | ------------------ | | 889| 2.01M| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 89| 1.00M|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 890| 2.01M| : YYSYMBOL_YYUNDEF) ------------------ | Branch (3947:13): [True: 0, False: 1.00M] ------------------ 3948| | /* If not already recovering from an error, report this error. */ 3949| 1.00M| if (!yyerrstatus) ------------------ | Branch (3949:7): [True: 46.8k, False: 958k] ------------------ 3950| 46.8k| { 3951| 46.8k| ++yynerrs; 3952| 46.8k| { 3953| 46.8k| yypcontext_t yyctx 3954| 46.8k| = {yyssp, yytoken, &yylloc}; 3955| 46.8k| char const *yymsgp = YY_("syntax error"); ------------------ | | 669| 46.8k|# define YY_(Msgid) Msgid ------------------ 3956| 46.8k| int yysyntax_error_status; 3957| 46.8k| yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 3958| 46.8k| if (yysyntax_error_status == 0) ------------------ | Branch (3958:13): [True: 46.8k, False: 0] ------------------ 3959| 46.8k| yymsgp = yymsg; 3960| 0| else if (yysyntax_error_status == -1) ------------------ | Branch (3960:18): [True: 0, False: 0] ------------------ 3961| 0| { 3962| 0| if (yymsg != yymsgbuf) ------------------ | Branch (3962:17): [True: 0, False: 0] ------------------ 3963| 0| YYSTACK_FREE (yymsg); ------------------ | | 777| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 0|#define YYFREE jv_mem_free | | ------------------ ------------------ 3964| 0| yymsg = YY_CAST (char *, ------------------ | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 3965| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 3966| 0| if (yymsg) ------------------ | Branch (3966:17): [True: 0, False: 0] ------------------ 3967| 0| { 3968| 0| yysyntax_error_status 3969| 0| = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 3970| 0| yymsgp = yymsg; 3971| 0| } 3972| 0| else 3973| 0| { 3974| 0| yymsg = yymsgbuf; 3975| 0| yymsg_alloc = sizeof yymsgbuf; 3976| 0| yysyntax_error_status = YYENOMEM; 3977| 0| } 3978| 0| } 3979| 46.8k| yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, yymsgp); 3980| 46.8k| if (yysyntax_error_status == YYENOMEM) ------------------ | Branch (3980:13): [True: 0, False: 46.8k] ------------------ 3981| 0| YYNOMEM; ------------------ | | 1429| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 3982| 46.8k| } 3983| 46.8k| } 3984| | 3985| 1.00M| yyerror_range[1] = yylloc; 3986| 1.00M| if (yyerrstatus == 3) ------------------ | Branch (3986:7): [True: 930k, False: 74.4k] ------------------ 3987| 930k| { 3988| | /* If just tried and failed to reuse lookahead token after an 3989| | error, discard it. */ 3990| | 3991| 930k| if (yychar <= YYEOF) ------------------ | | 195| 930k|#define YYEOF 0 ------------------ | Branch (3991:11): [True: 241, False: 930k] ------------------ 3992| 241| { 3993| | /* Return failure if at end of input. */ 3994| 241| if (yychar == YYEOF) ------------------ | | 195| 241|#define YYEOF 0 ------------------ | Branch (3994:15): [True: 241, False: 0] ------------------ 3995| 241| YYABORT; ------------------ | | 1427| 241|#define YYABORT goto yyabortlab ------------------ 3996| 241| } 3997| 930k| else 3998| 930k| { 3999| 930k| yydestruct ("Error: discarding", 4000| 930k| yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr); 4001| 930k| yychar = YYEMPTY; ------------------ | | 194| 930k|#define YYEMPTY -2 ------------------ 4002| 930k| } 4003| 930k| } 4004| | 4005| | /* Else will try to reuse lookahead token after shifting the error 4006| | token. */ 4007| 1.00M| goto yyerrlab1; 4008| | 4009| | 4010| |/*---------------------------------------------------. 4011| || yyerrorlab -- error raised explicitly by YYERROR. | 4012| |`---------------------------------------------------*/ 4013| 1.00M|yyerrorlab: 4014| | /* Pacify compilers when the user code never invokes YYERROR and the 4015| | label yyerrorlab therefore never appears in user code. */ 4016| 0| if (0) ------------------ | Branch (4016:7): [Folded, False: 0] ------------------ 4017| 0| YYERROR; ------------------ | | 1428| 0|#define YYERROR goto yyerrorlab ------------------ 4018| 0| ++yynerrs; 4019| | 4020| | /* Do not reclaim the symbols of the rule whose action triggered 4021| | this YYERROR. */ 4022| 0| YYPOPSTACK (yylen); ------------------ | | 2270| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4023| 0| yylen = 0; 4024| 0| YY_STACK_PRINT (yyss, yyssp); 4025| 0| yystate = *yyssp; 4026| 0| goto yyerrlab1; 4027| | 4028| | 4029| |/*-------------------------------------------------------------. 4030| || yyerrlab1 -- common code for both syntax error and YYERROR. | 4031| |`-------------------------------------------------------------*/ 4032| 1.00M|yyerrlab1: 4033| 1.00M| yyerrstatus = 3; /* Each real token shifted decrements this. */ 4034| | 4035| | /* Pop stack until we find a state that shifts the error token. */ 4036| 1.00M| for (;;) 4037| 2.01M| { 4038| 2.01M| yyn = yypact[yystate]; 4039| 2.01M| if (!yypact_value_is_default (yyn)) ------------------ | | 993| 2.01M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 990| 2.01M|#define YYPACT_NINF (-146) | | ------------------ ------------------ | Branch (4039:11): [True: 2.01M, False: 91] ------------------ 4040| 2.01M| { 4041| 2.01M| yyn += YYSYMBOL_YYerror; 4042| 2.01M| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 870| 4.03M|#define YYLAST 1165 ------------------ | Branch (4042:15): [True: 2.01M, False: 2.10k] | Branch (4042:27): [True: 2.01M, False: 0] | Branch (4042:44): [True: 1.00M, False: 1.01M] ------------------ 4043| 1.00M| { 4044| 1.00M| yyn = yytable[yyn]; 4045| 1.00M| if (0 < yyn) ------------------ | Branch (4045:19): [True: 1.00M, False: 0] ------------------ 4046| 1.00M| break; 4047| 1.00M| } 4048| 2.01M| } 4049| | 4050| | /* Pop the current state because it cannot handle the error token. */ 4051| 1.01M| if (yyssp == yyss) ------------------ | Branch (4051:11): [True: 152, False: 1.01M] ------------------ 4052| 152| YYABORT; ------------------ | | 1427| 152|#define YYABORT goto yyabortlab ------------------ 4053| | 4054| 1.01M| yyerror_range[1] = *yylsp; 4055| 1.01M| yydestruct ("Error: popping", 4056| 1.01M| YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, answer, errors, locations, lexer_param_ptr); ------------------ | | 954| 1.01M|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 89| 1.01M|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 4057| 1.01M| YYPOPSTACK (1); ------------------ | | 2270| 1.01M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4058| 1.01M| yystate = *yyssp; 4059| 1.01M| YY_STACK_PRINT (yyss, yyssp); 4060| 1.01M| } 4061| | 4062| 1.00M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 4063| 1.00M| *++yyvsp = yylval; 4064| 1.00M| YY_IGNORE_MAYBE_UNINITIALIZED_END 4065| | 4066| 1.00M| yyerror_range[2] = yylloc; 4067| 1.00M| ++yylsp; 4068| 1.00M| YYLLOC_DEFAULT (*yylsp, yyerror_range, 2); ------------------ | | 124| 1.00M| do { \ | | 125| 1.00M| if (N) { \ | | ------------------ | | | Branch (125:9): [True: 1.00M, Folded] | | ------------------ | | 126| 1.00M| (Loc).start = YYRHSLOC(Rhs, 1).start; \ | | ------------------ | | | | 1479| 1.00M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 127| 1.00M| (Loc).end = YYRHSLOC(Rhs, N).end; \ | | ------------------ | | | | 1479| 1.00M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 128| 1.00M| } else { \ | | 129| 0| (Loc).start = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1479| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 130| 0| (Loc).end = YYRHSLOC(Rhs, 0).end; \ | | ------------------ | | | | 1479| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 131| 0| } \ | | 132| 1.00M| } while (0) | | ------------------ | | | Branch (132:12): [Folded, False: 1.00M] | | ------------------ ------------------ 4069| | 4070| | /* Shift the error token. */ 4071| 1.00M| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 4072| | 4073| 1.00M| yystate = yyn; 4074| 1.00M| goto yynewstate; 4075| | 4076| | 4077| |/*-------------------------------------. 4078| || yyacceptlab -- YYACCEPT comes here. | 4079| |`-------------------------------------*/ 4080| 383|yyacceptlab: 4081| 383| yyresult = 0; 4082| 383| goto yyreturnlab; 4083| | 4084| | 4085| |/*-----------------------------------. 4086| || yyabortlab -- YYABORT comes here. | 4087| |`-----------------------------------*/ 4088| 393|yyabortlab: 4089| 393| yyresult = 1; 4090| 393| goto yyreturnlab; 4091| | 4092| | 4093| |/*-----------------------------------------------------------. 4094| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 4095| |`-----------------------------------------------------------*/ 4096| 1|yyexhaustedlab: 4097| 1| yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("memory exhausted")); ------------------ | | 669| 1|# define YY_(Msgid) Msgid ------------------ 4098| 1| yyresult = 2; 4099| 1| goto yyreturnlab; 4100| | 4101| | 4102| |/*----------------------------------------------------------. 4103| || yyreturnlab -- parsing is finished, clean up and return. | 4104| |`----------------------------------------------------------*/ 4105| 777|yyreturnlab: 4106| 777| if (yychar != YYEMPTY) ------------------ | | 194| 777|#define YYEMPTY -2 ------------------ | Branch (4106:7): [True: 391, False: 386] ------------------ 4107| 391| { 4108| | /* Make sure we have latest lookahead translation. See comments at 4109| | user semantic actions for why this is necessary. */ 4110| 391| yytoken = YYTRANSLATE (yychar); ------------------ | | 888| 391| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 882| 391|#define YYMAXUTOK 302 | | ------------------ | | | Branch (888:4): [True: 391, False: 0] | | | Branch (888:18): [True: 391, False: 0] | | ------------------ | | 889| 391| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 89| 391|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 890| 391| : YYSYMBOL_YYUNDEF) ------------------ 4111| 391| yydestruct ("Cleanup: discarding lookahead", 4112| 391| yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr); 4113| 391| } 4114| | /* Do not reclaim the symbols of the rule whose action triggered 4115| | this YYABORT or YYACCEPT. */ 4116| 777| YYPOPSTACK (yylen); ------------------ | | 2270| 777|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4117| 777| YY_STACK_PRINT (yyss, yyssp); 4118| 114k| while (yyssp != yyss) ------------------ | Branch (4118:10): [True: 113k, False: 777] ------------------ 4119| 113k| { 4120| 113k| yydestruct ("Cleanup: popping", 4121| 113k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, answer, errors, locations, lexer_param_ptr); ------------------ | | 954| 113k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 89| 113k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 4122| 113k| YYPOPSTACK (1); ------------------ | | 2270| 113k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 4123| 113k| } 4124| 777|#ifndef yyoverflow 4125| 777| if (yyss != yyssa) ------------------ | Branch (4125:7): [True: 129, False: 648] ------------------ 4126| 129| YYSTACK_FREE (yyss); ------------------ | | 777| 129|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 129|#define YYFREE jv_mem_free | | ------------------ ------------------ 4127| 777|#endif 4128| 777| if (yymsg != yymsgbuf) ------------------ | Branch (4128:7): [True: 0, False: 777] ------------------ 4129| 0| YYSTACK_FREE (yymsg); ------------------ | | 777| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 80| 0|#define YYFREE jv_mem_free | | ------------------ ------------------ 4130| 777| return yyresult; 4131| 1.00M|} jq_parse: 4136| 777|int jq_parse(struct locfile* locations, block* answer) { 4137| 777| struct lexer_param scanner; 4138| 777| YY_BUFFER_STATE buf; 4139| 777| jq_yylex_init_extra(0, &scanner.lexer); 4140| 777| buf = jq_yy_scan_bytes(locations->data, locations->length, scanner.lexer); 4141| 777| int errors = 0; 4142| 777| *answer = gen_noop(); 4143| 777| yyparse(answer, &errors, locations, &scanner); 4144| 777| jq_yy_delete_buffer(buf, scanner.lexer); 4145| 777| jq_yylex_destroy(scanner.lexer); 4146| 777| if (errors > 0) { ------------------ | Branch (4146:7): [True: 399, False: 378] ------------------ 4147| 399| block_free(*answer); 4148| 399| *answer = gen_noop(); 4149| 399| } 4150| 777| return errors; 4151| 777|} jq_parse_library: 4153| 181|int jq_parse_library(struct locfile* locations, block* answer) { 4154| 181| int errs = jq_parse(locations, answer); 4155| 181| if (errs) return errs; ------------------ | Branch (4155:7): [True: 0, False: 181] ------------------ 4156| 181| if (block_has_main(*answer)) { ------------------ | Branch (4156:7): [True: 0, False: 181] ------------------ 4157| 0| locfile_locate(locations, UNKNOWN_LOCATION, "jq: error: library should only have function definitions, not a main expression"); 4158| 0| return 1; 4159| 0| } 4160| 181| assert(block_has_only_binders_and_imports(*answer, OP_IS_CALL_PSEUDO)); ------------------ | Branch (4160:3): [True: 0, False: 181] | Branch (4160:3): [True: 181, False: 0] ------------------ 4161| 181| return 0; 4162| 181|} parser.c:gen_definedor_assign: 517| 163|static block gen_definedor_assign(block object, block val) { 518| 163| block tmp = gen_op_var_fresh(STOREV, "tmp"); 519| 163| return BLOCK(gen_op_simple(DUP), ------------------ | | 102| 163| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 163|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 163| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 163|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 163|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 163|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 520| 163| val, tmp, 521| 163| gen_call("_modify", BLOCK(gen_lambda(object), 522| 163| gen_lambda(gen_definedor(gen_noop(), 523| 163| gen_op_bound(LOADV, tmp)))))); 524| 163|} parser.c:gen_binop: 489| 326k|static block gen_binop(block a, block b, int op) { 490| 326k| block folded = constant_fold(a, b, op); 491| 326k| if (!block_is_noop(folded)) ------------------ | Branch (491:7): [True: 165k, False: 161k] ------------------ 492| 165k| return folded; 493| | 494| 161k| const char* funcname = 0; 495| 161k| switch (op) { ------------------ | Branch (495:11): [True: 161k, False: 0] ------------------ 496| 103k| case '+': funcname = "_plus"; break; ------------------ | Branch (496:3): [True: 103k, False: 57.4k] ------------------ 497| 29.0k| case '-': funcname = "_minus"; break; ------------------ | Branch (497:3): [True: 29.0k, False: 132k] ------------------ 498| 4.70k| case '*': funcname = "_multiply"; break; ------------------ | Branch (498:3): [True: 4.70k, False: 156k] ------------------ 499| 4.91k| case '/': funcname = "_divide"; break; ------------------ | Branch (499:3): [True: 4.91k, False: 156k] ------------------ 500| 2.45k| case '%': funcname = "_mod"; break; ------------------ | Branch (500:3): [True: 2.45k, False: 158k] ------------------ 501| 8.23k| case EQ: funcname = "_equal"; break; ------------------ | | 206| 8.23k|#define EQ 266 ------------------ | Branch (501:3): [True: 8.23k, False: 153k] ------------------ 502| 1.10k| case NEQ: funcname = "_notequal"; break; ------------------ | | 207| 1.10k|#define NEQ 267 ------------------ | Branch (502:3): [True: 1.10k, False: 160k] ------------------ 503| 817| case '<': funcname = "_less"; break; ------------------ | Branch (503:3): [True: 817, False: 160k] ------------------ 504| 5.06k| case '>': funcname = "_greater"; break; ------------------ | Branch (504:3): [True: 5.06k, False: 156k] ------------------ 505| 1.03k| case LESSEQ: funcname = "_lesseq"; break; ------------------ | | 234| 1.03k|#define LESSEQ 294 ------------------ | Branch (505:3): [True: 1.03k, False: 160k] ------------------ 506| 129| case GREATEREQ: funcname = "_greatereq"; break; ------------------ | | 235| 129|#define GREATEREQ 295 ------------------ | Branch (506:3): [True: 129, False: 161k] ------------------ 507| 161k| } 508| 161k| assert(funcname); ------------------ | Branch (508:3): [True: 0, False: 161k] | Branch (508:3): [True: 161k, False: 0] ------------------ 509| | 510| 161k| return gen_call(funcname, BLOCK(gen_lambda(a), gen_lambda(b))); ------------------ | | 102| 161k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 161k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 161k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 161k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 161k|} parser.c:constant_fold: 458| 326k|static block constant_fold(block a, block b, int op) { 459| 326k| if (!block_is_single(a) || !block_is_const(a) || ------------------ | Branch (459:7): [True: 59.7k, False: 266k] | Branch (459:30): [True: 95.4k, False: 171k] ------------------ 460| 171k| !block_is_single(b) || !block_is_const(b)) ------------------ | Branch (460:7): [True: 4.41k, False: 166k] | Branch (460:30): [True: 1.69k, False: 165k] ------------------ 461| 161k| return gen_noop(); 462| | 463| 165k| jv jv_a = block_const(a); 464| 165k| block_free(a); 465| 165k| jv jv_b = block_const(b); 466| 165k| block_free(b); 467| | 468| 165k| jv res = jv_invalid(); 469| 165k| switch (op) { ------------------ | Branch (469:11): [True: 165k, False: 0] ------------------ 470| 100k| case '+': res = binop_plus(jv_a, jv_b); break; ------------------ | Branch (470:3): [True: 100k, False: 64.8k] ------------------ 471| 17.9k| case '-': res = binop_minus(jv_a, jv_b); break; ------------------ | Branch (471:3): [True: 17.9k, False: 147k] ------------------ 472| 10.6k| case '*': res = binop_multiply(jv_a, jv_b); break; ------------------ | Branch (472:3): [True: 10.6k, False: 154k] ------------------ 473| 13.8k| case '/': res = binop_divide(jv_a, jv_b); break; ------------------ | Branch (473:3): [True: 13.8k, False: 151k] ------------------ 474| 9.72k| case '%': res = binop_mod(jv_a, jv_b); break; ------------------ | Branch (474:3): [True: 9.72k, False: 155k] ------------------ 475| 3.96k| case EQ: res = binop_equal(jv_a, jv_b); break; ------------------ | | 206| 3.96k|#define EQ 266 ------------------ | Branch (475:3): [True: 3.96k, False: 161k] ------------------ 476| 578| case NEQ: res = binop_notequal(jv_a, jv_b); break; ------------------ | | 207| 578|#define NEQ 267 ------------------ | Branch (476:3): [True: 578, False: 164k] ------------------ 477| 558| case '<': res = binop_less(jv_a, jv_b); break; ------------------ | Branch (477:3): [True: 558, False: 164k] ------------------ 478| 7.44k| case '>': res = binop_greater(jv_a, jv_b); break; ------------------ | Branch (478:3): [True: 7.44k, False: 157k] ------------------ 479| 2| case LESSEQ: res = binop_lesseq(jv_a, jv_b); break; ------------------ | | 234| 2|#define LESSEQ 294 ------------------ | Branch (479:3): [True: 2, False: 165k] ------------------ 480| 194| case GREATEREQ: res = binop_greatereq(jv_a, jv_b); break; ------------------ | | 235| 194|#define GREATEREQ 295 ------------------ | Branch (480:3): [True: 194, False: 164k] ------------------ 481| 165k| } 482| | 483| 165k| if (jv_is_valid(res)) ------------------ | Branch (483:7): [True: 158k, False: 6.46k] ------------------ 484| 158k| return gen_const(res); 485| | 486| 6.46k| return gen_error(jv_invalid_get_msg(res)); 487| 165k|} parser.c:gen_update: 526| 48.2k|static block gen_update(block object, block val, int optype) { 527| 48.2k| block tmp = gen_op_var_fresh(STOREV, "tmp"); 528| 48.2k| return BLOCK(gen_op_simple(DUP), ------------------ | | 102| 48.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 48.2k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 48.2k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 94| 48.2k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | ------------------ | | | | | | | | | | 93| 48.2k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 92| 48.2k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 529| 48.2k| val, 530| 48.2k| tmp, 531| 48.2k| gen_call("_modify", BLOCK(gen_lambda(object), 532| 48.2k| gen_lambda(gen_binop(gen_noop(), 533| 48.2k| gen_op_bound(LOADV, tmp), 534| 48.2k| optype))))); 535| 48.2k|} parser.c:gen_format: 513| 1.42k|static block gen_format(block a, jv fmt) { 514| 1.42k| return BLOCK(a, gen_call("format", gen_lambda(gen_const(fmt)))); ------------------ | | 102| 1.42k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.42k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.42k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 92| 1.42k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 515| 1.42k|} parser.c:gen_index_opt: 443| 317|static block gen_index_opt(block obj, block key) { 444| 317| return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX_OPT)); ------------------ | | 102| 317| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 317|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 317| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 317|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 317|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 445| 317|} parser.c:gen_index: 439| 26.9k|static block gen_index(block obj, block key) { 440| 26.9k| return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX)); ------------------ | | 102| 26.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 26.9k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 26.9k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 26.9k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 26.9k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 441| 26.9k|} parser.c:gen_slice_index: 447| 1.69k|static block gen_slice_index(block obj, block start, block end, opcode idx_op) { 448| 1.69k| block key = BLOCK(gen_subexp(gen_const(jv_object())), ------------------ | | 102| 1.69k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.69k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.69k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 97| 1.69k|#define BLOCK_7(b1,b2,b3,b4,b5,b6,b7) (block_join(BLOCK_6(b1,b2,b3,b4,b5,b6),(b7))) | | | | | | | | ------------------ | | | | | | | | | | 96| 1.69k|#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 95| 1.69k|#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5))) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 94| 1.69k|#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4))) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 93| 1.69k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 92| 1.69k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 449| 1.69k| gen_subexp(gen_const(jv_string("start"))), 450| 1.69k| gen_subexp(start), 451| 1.69k| gen_op_simple(INSERT), 452| 1.69k| gen_subexp(gen_const(jv_string("end"))), 453| 1.69k| gen_subexp(end), 454| 1.69k| gen_op_simple(INSERT)); 455| 1.69k| return BLOCK(key, obj, gen_op_simple(idx_op)); ------------------ | | 102| 1.69k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | ------------------ | | | | 100| 1.69k|#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME | | | | ------------------ | | | | | | 102| 1.69k| BLOCK_IDX(__VA_ARGS__, BLOCK_8, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__) | | | | | | ------------------ | | | | | | | | 93| 1.69k|#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3))) | | | | | | | | ------------------ | | | | | | | | | | 92| 1.69k|#define BLOCK_2(b1,b2) (block_join((b1),(b2))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 456| 1.69k|} parser.c:check_object_key: 429| 1.90k|static jv check_object_key(block k) { 430| 1.90k| if (block_is_const(k) && block_const_kind(k) != JV_KIND_STRING) { ------------------ | Branch (430:7): [True: 19, False: 1.88k] | Branch (430:28): [True: 19, False: 0] ------------------ 431| 19| char errbuf[30]; 432| 19| return jv_string_fmt("Cannot use %s (%s) as object key", 433| 19| jv_kind_name(block_const_kind(k)), 434| 19| jv_dump_string_trunc(block_const(k), errbuf, sizeof(errbuf))); 435| 19| } 436| 1.88k| return jv_invalid(); 437| 1.90k|} parser.c:yysyntax_error: 1885| 46.8k|{ 1886| 46.8k| enum { YYARGS_MAX = 5 }; 1887| | /* Internationalized format string. */ 1888| 46.8k| const char *yyformat = YY_NULLPTR; ------------------ | | 101| 46.8k|# define YY_NULLPTR ((void*)0) ------------------ 1889| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1890| | one per "expected"). */ 1891| 46.8k| yysymbol_kind_t yyarg[YYARGS_MAX]; 1892| | /* Cumulated lengths of YYARG. */ 1893| 46.8k| YYPTRDIFF_T yysize = 0; ------------------ | | 619| 46.8k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1894| | 1895| | /* Actual size of YYARG. */ 1896| 46.8k| int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); 1897| 46.8k| if (yycount == YYENOMEM) ------------------ | Branch (1897:7): [True: 0, False: 46.8k] ------------------ 1898| 0| return YYENOMEM; 1899| | 1900| 46.8k| switch (yycount) 1901| 46.8k| { 1902| 0|#define YYCASE_(N, S) \ 1903| 0| case N: \ 1904| 0| yyformat = S; \ 1905| 0| break 1906| 0| default: /* Avoid compiler warnings. */ ------------------ | Branch (1906:5): [True: 0, False: 46.8k] ------------------ 1907| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1903| 0| case N: \ | | ------------------ | | | Branch (1903:7): [True: 0, False: 46.8k] | | ------------------ | | 1904| 0| yyformat = S; \ | | 1905| 0| break ------------------ 1908| 9.89k| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1903| 9.89k| case N: \ | | ------------------ | | | Branch (1903:7): [True: 9.89k, False: 36.9k] | | ------------------ | | 1904| 9.89k| yyformat = S; \ | | 1905| 9.89k| break ------------------ 1909| 33.5k| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1903| 33.5k| case N: \ | | ------------------ | | | Branch (1903:7): [True: 33.5k, False: 13.2k] | | ------------------ | | 1904| 33.5k| yyformat = S; \ | | 1905| 33.5k| break ------------------ 1910| 616| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1903| 616| case N: \ | | ------------------ | | | Branch (1903:7): [True: 616, False: 46.2k] | | ------------------ | | 1904| 616| yyformat = S; \ | | 1905| 616| break ------------------ 1911| 2.45k| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1903| 2.45k| case N: \ | | ------------------ | | | Branch (1903:7): [True: 2.45k, False: 44.3k] | | ------------------ | | 1904| 2.45k| yyformat = S; \ | | 1905| 2.45k| break ------------------ 1912| 46.8k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1903| 314| case N: \ | | ------------------ | | | Branch (1903:7): [True: 314, False: 46.5k] | | ------------------ | | 1904| 314| yyformat = S; \ | | 1905| 314| break ------------------ 1913| 46.8k|#undef YYCASE_ 1914| 46.8k| } 1915| | 1916| | /* Compute error message size. Don't count the "%s"s, but reserve 1917| | room for the terminator. */ 1918| 46.8k| yysize = yystrlen (yyformat) - 2 * yycount + 1; ------------------ | | 1744| 46.8k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 89| 46.8k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1919| 46.8k| { 1920| 46.8k| int yyi; 1921| 137k| for (yyi = 0; yyi < yycount; ++yyi) ------------------ | Branch (1921:19): [True: 90.2k, False: 46.8k] ------------------ 1922| 90.2k| { 1923| 90.2k| YYPTRDIFF_T yysize1 ------------------ | | 619| 90.2k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1924| 90.2k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); ------------------ | | 101| 90.2k|# define YY_NULLPTR ((void*)0) ------------------ 1925| 90.2k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 779| 90.2k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 647| 90.2k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 89| 180k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (89:40): [True: 90.2k, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1925:13): [True: 90.2k, False: 0] | Branch (1925:34): [True: 90.2k, False: 0] ------------------ 1926| 90.2k| yysize = yysize1; 1927| 0| else 1928| 0| return YYENOMEM; 1929| 90.2k| } 1930| 46.8k| } 1931| | 1932| 46.8k| if (*yymsg_alloc < yysize) ------------------ | Branch (1932:7): [True: 0, False: 46.8k] ------------------ 1933| 0| { 1934| 0| *yymsg_alloc = 2 * yysize; 1935| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (1935:14): [True: 0, False: 0] ------------------ 1936| 0| && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 779| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 647| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (89:40): [True: 0, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1936:17): [True: 0, False: 0] ------------------ 1937| 0| *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ------------------ | | 779| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 647| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 89| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (89:40): [True: 0, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1938| 0| return -1; 1939| 0| } 1940| | 1941| | /* Avoid sprintf, as that infringes on the user's name space. 1942| | Don't have undefined behavior even if the translation 1943| | produced a string with the wrong number of "%s"s. */ 1944| 46.8k| { 1945| 46.8k| char *yyp = *yymsg; 1946| 46.8k| int yyi = 0; 1947| 1.77M| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1947:12): [True: 1.72M, False: 46.8k] ------------------ 1948| 1.72M| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1948:11): [True: 90.2k, False: 1.63M] | Branch (1948:26): [True: 90.2k, False: 0] | Branch (1948:48): [True: 90.2k, False: 0] ------------------ 1949| 90.2k| { 1950| 90.2k| yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); 1951| 90.2k| yyformat += 2; 1952| 90.2k| } 1953| 1.63M| else 1954| 1.63M| { 1955| 1.63M| ++yyp; 1956| 1.63M| ++yyformat; 1957| 1.63M| } 1958| 46.8k| } 1959| 46.8k| return 0; 1960| 46.8k|} parser.c:yy_syntax_error_arguments: 1832| 46.8k|{ 1833| | /* Actual size of YYARG. */ 1834| 46.8k| int yycount = 0; 1835| | /* There are many possibilities here to consider: 1836| | - If this state is a consistent state with a default action, then 1837| | the only way this function was invoked is if the default action 1838| | is an error action. In that case, don't check for expected 1839| | tokens because there are none. 1840| | - The only way there can be no lookahead present (in yychar) is if 1841| | this state is a consistent state with a default action. Thus, 1842| | detecting the absence of a lookahead is sufficient to determine 1843| | that there is no unexpected or expected token to report. In that 1844| | case, just report a simple "syntax error". 1845| | - Don't assume there isn't a lookahead just because this state is a 1846| | consistent state with a default action. There might have been a 1847| | previous inconsistent state, consistent state with a non-default 1848| | action, or user semantic action that manipulated yychar. 1849| | - Of course, the expected token list depends on states to have 1850| | correct lookahead information, and it depends on the parser not 1851| | to perform extra reductions after fetching a lookahead from the 1852| | scanner and before detecting a syntax error. Thus, state merging 1853| | (from LALR or IELR) and default reductions corrupt the expected 1854| | token list. However, the list is correct for canonical LR with 1855| | one exception: it will still contain any token that will not be 1856| | accepted due to an error action in a later state. 1857| | */ 1858| 46.8k| if (yyctx->yytoken != YYSYMBOL_YYEMPTY) ------------------ | Branch (1858:7): [True: 46.8k, False: 0] ------------------ 1859| 46.8k| { 1860| 46.8k| int yyn; 1861| 46.8k| if (yyarg) ------------------ | Branch (1861:11): [True: 46.8k, False: 0] ------------------ 1862| 46.8k| yyarg[yycount] = yyctx->yytoken; 1863| 46.8k| ++yycount; 1864| 46.8k| yyn = yypcontext_expected_tokens (yyctx, 1865| 46.8k| yyarg ? yyarg + 1 : yyarg, yyargn - 1); ------------------ | Branch (1865:41): [True: 46.8k, False: 0] ------------------ 1866| 46.8k| if (yyn == YYENOMEM) ------------------ | Branch (1866:11): [True: 0, False: 46.8k] ------------------ 1867| 0| return YYENOMEM; 1868| 46.8k| else 1869| 46.8k| yycount += yyn; 1870| 46.8k| } 1871| 46.8k| return yycount; 1872| 46.8k|} parser.c:yypcontext_expected_tokens: 1708| 46.8k|{ 1709| | /* Actual size of YYARG. */ 1710| 46.8k| int yycount = 0; 1711| 46.8k| int yyn = yypact[+*yyctx->yyssp]; 1712| 46.8k| if (!yypact_value_is_default (yyn)) ------------------ | | 993| 46.8k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 990| 46.8k|#define YYPACT_NINF (-146) | | ------------------ ------------------ | Branch (1712:7): [True: 46.8k, False: 0] ------------------ 1713| 46.8k| { 1714| | /* Start YYX at -YYN if negative to avoid negative indexes in 1715| | YYCHECK. In other words, skip the first -YYN actions for 1716| | this state because they are default actions. */ 1717| 46.8k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1717:22): [True: 809, False: 46.0k] ------------------ 1718| | /* Stay within bounds of both yycheck and yytname. */ 1719| 46.8k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 870| 46.8k|#define YYLAST 1165 ------------------ 1720| 46.8k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 873| 46.8k|#define YYNTOKENS 69 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 873| 46.8k|#define YYNTOKENS 69 ------------------ | Branch (1720:20): [True: 1, False: 46.8k] ------------------ 1721| 46.8k| int yyx; 1722| 2.70M| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1722:28): [True: 2.66M, False: 36.9k] ------------------ 1723| 2.66M| if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror ------------------ | Branch (1723:13): [True: 101k, False: 2.56M] | Branch (1723:42): [True: 93.9k, False: 7.39k] ------------------ 1724| 93.9k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 998| 93.9k| ((Yyn) == YYTABLE_NINF) | | ------------------ | | | | 995| 93.9k|#define YYTABLE_NINF (-154) | | ------------------ ------------------ | Branch (1724:16): [True: 92.8k, False: 1.11k] ------------------ 1725| 92.8k| { 1726| 92.8k| if (!yyarg) ------------------ | Branch (1726:17): [True: 0, False: 92.8k] ------------------ 1727| 0| ++yycount; 1728| 92.8k| else if (yycount == yyargn) ------------------ | Branch (1728:22): [True: 9.89k, False: 82.9k] ------------------ 1729| 9.89k| return 0; 1730| 82.9k| else 1731| 82.9k| yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); ------------------ | | 89| 82.9k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1732| 92.8k| } 1733| 46.8k| } 1734| 36.9k| if (yyarg && yycount == 0 && 0 < yyargn) ------------------ | Branch (1734:7): [True: 36.9k, False: 0] | Branch (1734:16): [True: 0, False: 36.9k] | Branch (1734:32): [True: 0, False: 0] ------------------ 1735| 0| yyarg[0] = YYSYMBOL_YYEMPTY; 1736| 36.9k| return yycount; 1737| 46.8k|} parser.c:yytnamerr: 1788| 180k|{ 1789| 180k| if (*yystr == '"') ------------------ | Branch (1789:7): [True: 2.80k, False: 177k] ------------------ 1790| 2.80k| { 1791| 2.80k| YYPTRDIFF_T yyn = 0; ------------------ | | 619| 2.80k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1792| 2.80k| char const *yyp = yystr; 1793| 2.80k| for (;;) 1794| 14.3k| switch (*++yyp) 1795| 14.3k| { 1796| 0| case '\'': ------------------ | Branch (1796:11): [True: 0, False: 14.3k] ------------------ 1797| 0| case ',': ------------------ | Branch (1797:11): [True: 0, False: 14.3k] ------------------ 1798| 0| goto do_not_strip_quotes; 1799| | 1800| 0| case '\\': ------------------ | Branch (1800:11): [True: 0, False: 14.3k] ------------------ 1801| 0| if (*++yyp != '\\') ------------------ | Branch (1801:17): [True: 0, False: 0] ------------------ 1802| 0| goto do_not_strip_quotes; 1803| 0| else 1804| 0| goto append; 1805| | 1806| 0| append: 1807| 11.5k| default: ------------------ | Branch (1807:11): [True: 11.5k, False: 2.80k] ------------------ 1808| 11.5k| if (yyres) ------------------ | Branch (1808:17): [True: 5.75k, False: 5.75k] ------------------ 1809| 5.75k| yyres[yyn] = *yyp; 1810| 11.5k| yyn++; 1811| 11.5k| break; 1812| | 1813| 2.80k| case '"': ------------------ | Branch (1813:11): [True: 2.80k, False: 11.5k] ------------------ 1814| 2.80k| if (yyres) ------------------ | Branch (1814:17): [True: 1.40k, False: 1.40k] ------------------ 1815| 1.40k| yyres[yyn] = '\0'; 1816| 2.80k| return yyn; 1817| 14.3k| } 1818| 0| do_not_strip_quotes: ; 1819| 0| } 1820| | 1821| 177k| if (yyres) ------------------ | Branch (1821:7): [True: 88.8k, False: 88.8k] ------------------ 1822| 88.8k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1760| 88.8k|# define yystpcpy stpcpy ------------------ 1823| 88.8k| else 1824| 88.8k| return yystrlen (yystr); ------------------ | | 1744| 88.8k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 89| 88.8k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1825| 177k|} parser.c:yydestruct: 1970| 2.05M|{ 1971| 2.05M| YY_USE (yyvaluep); ------------------ | | 692| 2.05M|# define YY_USE(E) ((void) (E)) ------------------ 1972| 2.05M| YY_USE (yylocationp); ------------------ | | 692| 2.05M|# define YY_USE(E) ((void) (E)) ------------------ 1973| 2.05M| YY_USE (answer); ------------------ | | 692| 2.05M|# define YY_USE(E) ((void) (E)) ------------------ 1974| 2.05M| YY_USE (errors); ------------------ | | 692| 2.05M|# define YY_USE(E) ((void) (E)) ------------------ 1975| 2.05M| YY_USE (locations); ------------------ | | 692| 2.05M|# define YY_USE(E) ((void) (E)) ------------------ 1976| 2.05M| YY_USE (lexer_param_ptr); ------------------ | | 692| 2.05M|# define YY_USE(E) ((void) (E)) ------------------ 1977| 2.05M| if (!yymsg) ------------------ | Branch (1977:7): [True: 0, False: 2.05M] ------------------ 1978| 0| yymsg = "Deleting"; 1979| 2.05M| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1980| | 1981| 2.05M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1982| 2.05M| switch (yykind) 1983| 2.05M| { 1984| 42.7k| case YYSYMBOL_IDENT: /* IDENT */ ------------------ | Branch (1984:5): [True: 42.7k, False: 2.01M] ------------------ 1985| 42.7k|#line 37 "src/parser.y" 1986| 42.7k| { jv_free(((*yyvaluep).literal)); } 1987| 42.7k|#line 1988 "src/parser.c" 1988| 42.7k| break; 1989| | 1990| 198| case YYSYMBOL_FIELD: /* FIELD */ ------------------ | Branch (1990:5): [True: 198, False: 2.05M] ------------------ 1991| 198|#line 37 "src/parser.y" 1992| 198| { jv_free(((*yyvaluep).literal)); } 1993| 198|#line 1994 "src/parser.c" 1994| 198| break; 1995| | 1996| 7.25k| case YYSYMBOL_BINDING: /* BINDING */ ------------------ | Branch (1996:5): [True: 7.25k, False: 2.05M] ------------------ 1997| 7.25k|#line 37 "src/parser.y" 1998| 7.25k| { jv_free(((*yyvaluep).literal)); } 1999| 7.25k|#line 2000 "src/parser.c" 2000| 7.25k| break; 2001| | 2002| 37.5k| case YYSYMBOL_LITERAL: /* LITERAL */ ------------------ | Branch (2002:5): [True: 37.5k, False: 2.02M] ------------------ 2003| 37.5k|#line 37 "src/parser.y" 2004| 37.5k| { jv_free(((*yyvaluep).literal)); } 2005| 37.5k|#line 2006 "src/parser.c" 2006| 37.5k| break; 2007| | 2008| 314| case YYSYMBOL_FORMAT: /* FORMAT */ ------------------ | Branch (2008:5): [True: 314, False: 2.05M] ------------------ 2009| 314|#line 37 "src/parser.y" 2010| 314| { jv_free(((*yyvaluep).literal)); } 2011| 314|#line 2012 "src/parser.c" 2012| 314| break; 2013| | 2014| 264k| case YYSYMBOL_QQSTRING_TEXT: /* QQSTRING_TEXT */ ------------------ | Branch (2014:5): [True: 264k, False: 1.79M] ------------------ 2015| 264k|#line 37 "src/parser.y" 2016| 264k| { jv_free(((*yyvaluep).literal)); } 2017| 264k|#line 2018 "src/parser.c" 2018| 264k| break; 2019| | 2020| 297| case YYSYMBOL_Module: /* Module */ ------------------ | Branch (2020:5): [True: 297, False: 2.05M] ------------------ 2021| 297|#line 38 "src/parser.y" 2022| 297| { block_free(((*yyvaluep).blk)); } 2023| 297|#line 2024 "src/parser.c" 2024| 297| break; 2025| | 2026| 295| case YYSYMBOL_Imports: /* Imports */ ------------------ | Branch (2026:5): [True: 295, False: 2.05M] ------------------ 2027| 295|#line 38 "src/parser.y" 2028| 295| { block_free(((*yyvaluep).blk)); } 2029| 295|#line 2030 "src/parser.c" 2030| 295| break; 2031| | 2032| 0| case YYSYMBOL_FuncDefs: /* FuncDefs */ ------------------ | Branch (2032:5): [True: 0, False: 2.05M] ------------------ 2033| 0|#line 38 "src/parser.y" 2034| 0| { block_free(((*yyvaluep).blk)); } 2035| 0|#line 2036 "src/parser.c" 2036| 0| break; 2037| | 2038| 6.12k| case YYSYMBOL_Query: /* Query */ ------------------ | Branch (2038:5): [True: 6.12k, False: 2.05M] ------------------ 2039| 6.12k|#line 38 "src/parser.y" 2040| 6.12k| { block_free(((*yyvaluep).blk)); } 2041| 6.12k|#line 2042 "src/parser.c" 2042| 6.12k| break; 2043| | 2044| 11.2k| case YYSYMBOL_Expr: /* Expr */ ------------------ | Branch (2044:5): [True: 11.2k, False: 2.04M] ------------------ 2045| 11.2k|#line 38 "src/parser.y" 2046| 11.2k| { block_free(((*yyvaluep).blk)); } 2047| 11.2k|#line 2048 "src/parser.c" 2048| 11.2k| break; 2049| | 2050| 266| case YYSYMBOL_Import: /* Import */ ------------------ | Branch (2050:5): [True: 266, False: 2.05M] ------------------ 2051| 266|#line 38 "src/parser.y" 2052| 266| { block_free(((*yyvaluep).blk)); } 2053| 266|#line 2054 "src/parser.c" 2054| 266| break; 2055| | 2056| 0| case YYSYMBOL_ImportWhat: /* ImportWhat */ ------------------ | Branch (2056:5): [True: 0, False: 2.05M] ------------------ 2057| 0|#line 38 "src/parser.y" 2058| 0| { block_free(((*yyvaluep).blk)); } 2059| 0|#line 2060 "src/parser.c" 2060| 0| break; 2061| | 2062| 1| case YYSYMBOL_ImportFrom: /* ImportFrom */ ------------------ | Branch (2062:5): [True: 1, False: 2.05M] ------------------ 2063| 1|#line 38 "src/parser.y" 2064| 1| { block_free(((*yyvaluep).blk)); } 2065| 1|#line 2066 "src/parser.c" 2066| 1| break; 2067| | 2068| 0| case YYSYMBOL_FuncDef: /* FuncDef */ ------------------ | Branch (2068:5): [True: 0, False: 2.05M] ------------------ 2069| 0|#line 38 "src/parser.y" 2070| 0| { block_free(((*yyvaluep).blk)); } 2071| 0|#line 2072 "src/parser.c" 2072| 0| break; 2073| | 2074| 0| case YYSYMBOL_Params: /* Params */ ------------------ | Branch (2074:5): [True: 0, False: 2.05M] ------------------ 2075| 0|#line 38 "src/parser.y" 2076| 0| { block_free(((*yyvaluep).blk)); } 2077| 0|#line 2078 "src/parser.c" 2078| 0| break; 2079| | 2080| 0| case YYSYMBOL_Param: /* Param */ ------------------ | Branch (2080:5): [True: 0, False: 2.05M] ------------------ 2081| 0|#line 38 "src/parser.y" 2082| 0| { block_free(((*yyvaluep).blk)); } 2083| 0|#line 2084 "src/parser.c" 2084| 0| break; 2085| | 2086| 216| case YYSYMBOL_StringStart: /* StringStart */ ------------------ | Branch (2086:5): [True: 216, False: 2.05M] ------------------ 2087| 216|#line 37 "src/parser.y" 2088| 216| { jv_free(((*yyvaluep).literal)); } 2089| 216|#line 2090 "src/parser.c" 2090| 216| break; 2091| | 2092| 612| case YYSYMBOL_String: /* String */ ------------------ | Branch (2092:5): [True: 612, False: 2.05M] ------------------ 2093| 612|#line 38 "src/parser.y" 2094| 612| { block_free(((*yyvaluep).blk)); } 2095| 612|#line 2096 "src/parser.c" 2096| 612| break; 2097| | 2098| 216| case YYSYMBOL_QQString: /* QQString */ ------------------ | Branch (2098:5): [True: 216, False: 2.05M] ------------------ 2099| 216|#line 38 "src/parser.y" 2100| 216| { block_free(((*yyvaluep).blk)); } 2101| 216|#line 2102 "src/parser.c" 2102| 216| break; 2103| | 2104| 0| case YYSYMBOL_ElseBody: /* ElseBody */ ------------------ | Branch (2104:5): [True: 0, False: 2.05M] ------------------ 2105| 0|#line 38 "src/parser.y" 2106| 0| { block_free(((*yyvaluep).blk)); } 2107| 0|#line 2108 "src/parser.c" 2108| 0| break; 2109| | 2110| 2.62k| case YYSYMBOL_Term: /* Term */ ------------------ | Branch (2110:5): [True: 2.62k, False: 2.05M] ------------------ 2111| 2.62k|#line 38 "src/parser.y" 2112| 2.62k| { block_free(((*yyvaluep).blk)); } 2113| 2.62k|#line 2114 "src/parser.c" 2114| 2.62k| break; 2115| | 2116| 201| case YYSYMBOL_Args: /* Args */ ------------------ | Branch (2116:5): [True: 201, False: 2.05M] ------------------ 2117| 201|#line 38 "src/parser.y" 2118| 201| { block_free(((*yyvaluep).blk)); } 2119| 201|#line 2120 "src/parser.c" 2120| 201| break; 2121| | 2122| 0| case YYSYMBOL_Arg: /* Arg */ ------------------ | Branch (2122:5): [True: 0, False: 2.05M] ------------------ 2123| 0|#line 38 "src/parser.y" 2124| 0| { block_free(((*yyvaluep).blk)); } 2125| 0|#line 2126 "src/parser.c" 2126| 0| break; 2127| | 2128| 345| case YYSYMBOL_RepPatterns: /* RepPatterns */ ------------------ | Branch (2128:5): [True: 345, False: 2.05M] ------------------ 2129| 345|#line 38 "src/parser.y" 2130| 345| { block_free(((*yyvaluep).blk)); } 2131| 345|#line 2132 "src/parser.c" 2132| 345| break; 2133| | 2134| 147| case YYSYMBOL_Patterns: /* Patterns */ ------------------ | Branch (2134:5): [True: 147, False: 2.05M] ------------------ 2135| 147|#line 38 "src/parser.y" 2136| 147| { block_free(((*yyvaluep).blk)); } 2137| 147|#line 2138 "src/parser.c" 2138| 147| break; 2139| | 2140| 0| case YYSYMBOL_Pattern: /* Pattern */ ------------------ | Branch (2140:5): [True: 0, False: 2.05M] ------------------ 2141| 0|#line 38 "src/parser.y" 2142| 0| { block_free(((*yyvaluep).blk)); } 2143| 0|#line 2144 "src/parser.c" 2144| 0| break; 2145| | 2146| 33| case YYSYMBOL_ArrayPats: /* ArrayPats */ ------------------ | Branch (2146:5): [True: 33, False: 2.05M] ------------------ 2147| 33|#line 38 "src/parser.y" 2148| 33| { block_free(((*yyvaluep).blk)); } 2149| 33|#line 2150 "src/parser.c" 2150| 33| break; 2151| | 2152| 494| case YYSYMBOL_ObjPats: /* ObjPats */ ------------------ | Branch (2152:5): [True: 494, False: 2.05M] ------------------ 2153| 494|#line 38 "src/parser.y" 2154| 494| { block_free(((*yyvaluep).blk)); } 2155| 494|#line 2156 "src/parser.c" 2156| 494| break; 2157| | 2158| 0| case YYSYMBOL_ObjPat: /* ObjPat */ ------------------ | Branch (2158:5): [True: 0, False: 2.05M] ------------------ 2159| 0|#line 38 "src/parser.y" 2160| 0| { block_free(((*yyvaluep).blk)); } 2161| 0|#line 2162 "src/parser.c" 2162| 0| break; 2163| | 2164| 278| case YYSYMBOL_Keyword: /* Keyword */ ------------------ | Branch (2164:5): [True: 278, False: 2.05M] ------------------ 2165| 278|#line 37 "src/parser.y" 2166| 278| { jv_free(((*yyvaluep).literal)); } 2167| 278|#line 2168 "src/parser.c" 2168| 278| break; 2169| | 2170| 46.0k| case YYSYMBOL_DictPairs: /* DictPairs */ ------------------ | Branch (2170:5): [True: 46.0k, False: 2.01M] ------------------ 2171| 46.0k|#line 38 "src/parser.y" 2172| 46.0k| { block_free(((*yyvaluep).blk)); } 2173| 46.0k|#line 2174 "src/parser.c" 2174| 46.0k| break; 2175| | 2176| 2.22k| case YYSYMBOL_DictPair: /* DictPair */ ------------------ | Branch (2176:5): [True: 2.22k, False: 2.05M] ------------------ 2177| 2.22k|#line 38 "src/parser.y" 2178| 2.22k| { block_free(((*yyvaluep).blk)); } 2179| 2.22k|#line 2180 "src/parser.c" 2180| 2.22k| break; 2181| | 2182| 3.35k| case YYSYMBOL_DictExpr: /* DictExpr */ ------------------ | Branch (2182:5): [True: 3.35k, False: 2.05M] ------------------ 2183| 3.35k|#line 38 "src/parser.y" 2184| 3.35k| { block_free(((*yyvaluep).blk)); } 2185| 3.35k|#line 2186 "src/parser.c" 2186| 3.35k| break; 2187| | 2188| 1.63M| default: ------------------ | Branch (2188:7): [True: 1.63M, False: 427k] ------------------ 2189| 1.63M| break; 2190| 2.05M| } 2191| 2.05M| YY_IGNORE_MAYBE_UNINITIALIZED_END 2192| 2.05M|} expand_path: 83| 189|jv expand_path(jv path) { 84| 189| assert(jv_get_kind(path) == JV_KIND_STRING); ------------------ | Branch (84:3): [True: 0, False: 189] | Branch (84:3): [True: 189, False: 0] ------------------ 85| 189| const char *pstr = jv_string_value(path); 86| 189| jv ret = path; 87| 189| if (jv_string_length_bytes(jv_copy(path)) > 1 && pstr[0] == '~' && pstr[1] == '/') { ------------------ | Branch (87:7): [True: 181, False: 8] | Branch (87:52): [True: 0, False: 181] | 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| 189| return ret; 100| 189|} get_home: 102| 197|jv get_home(void) { 103| 197| jv ret; 104| 197| char *home = getenv("HOME"); 105| 197| if (!home) { ------------------ | Branch (105:7): [True: 0, False: 197] ------------------ 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| 197| } else { 124| 197| ret = jv_string(home); 125| 197| } 126| 197| return ret; 127| 197|} jq_realpath: 130| 551|jv jq_realpath(jv path) { 131| 551| int path_max; 132| 551| char *buf = NULL; 133| 551|#ifdef _PC_PATH_MAX 134| 551| path_max = pathconf(jv_string_value(path),_PC_PATH_MAX); 135| |#else 136| | path_max = PATH_MAX; 137| |#endif 138| 551| if (path_max > 0) { ------------------ | Branch (138:7): [True: 551, False: 0] ------------------ 139| 551| buf = jv_mem_alloc(path_max); 140| 551| } 141| |#ifdef WIN32 142| | char *tmp = _fullpath(buf, jv_string_value(path), path_max); 143| |#else 144| 551| char *tmp = realpath(jv_string_value(path), buf); 145| 551|#endif 146| 551| if (tmp == NULL) { ------------------ | Branch (146:7): [True: 551, False: 0] ------------------ 147| 551| free(buf); 148| 551| return path; 149| 551| } 150| 0| jv_free(path); 151| 0| path = jv_string(tmp); 152| 0| free(tmp); 153| 0| return path; 154| 551|} _jq_memmem: 157| 804k| const void *needle, size_t needlelen) { 158| 804k|#ifdef HAVE_MEMMEM 159| 804k| 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| 804k|} jv_print.c:priv_fwrite: 38| 208k|static void priv_fwrite(const char *s, size_t len, FILE *fout, int is_tty) { 39| |#ifdef WIN32 40| | if (is_tty && len > 0 && len <= INT_MAX / sizeof(wchar_t)) { 41| | HANDLE h = (HANDLE)_get_osfhandle(fileno(fout)); 42| | DWORD mode; 43| | if (GetConsoleMode(h, &mode)) { 44| | int wlen = MultiByteToWideChar(CP_UTF8, 0, s, (int)len, NULL, 0); 45| | wchar_t *ws = wlen > 0 ? malloc(wlen * sizeof(*ws)) : NULL; 46| | if (ws != NULL) { 47| | wlen = MultiByteToWideChar(CP_UTF8, 0, s, (int)len, ws, wlen); 48| | fflush(fout); /* keep our order with stdio writes to this stream */ 49| | for (int done = 0; done < wlen;) { 50| | DWORD written; 51| | /* WriteConsoleW() may write fewer characters than asked for. */ 52| | if (!WriteConsoleW(h, ws + done, wlen - done, &written, NULL) || 53| | written == 0) 54| | break; 55| | done += written; 56| | } 57| | free(ws); 58| | return; 59| | } 60| | } 61| | } 62| |#endif 63| 208k| fwrite(s, 1, len, fout); 64| 208k|} LLVMFuzzerTestOneInput: 7| 596|int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) { 8| | // Creat null-terminated string 9| 596| char *null_terminated = (char *)malloc(size + 1); 10| 596| memcpy(null_terminated, (char *)data, size); 11| 596| null_terminated[size] = '\0'; 12| | 13| | // Fuzzer entrypoint 14| 596| jq_state *jq = NULL; 15| 596| jq = jq_init(); 16| 596| if (jq != NULL) { ------------------ | Branch (16:7): [True: 596, False: 0] ------------------ 17| 596| if (jq_compile(jq, null_terminated)) { ------------------ | Branch (17:9): [True: 147, False: 449] ------------------ 18| 147| jq_dump_disassembly(jq, 2); 19| 147| } 20| 596| } 21| 596| jq_teardown(&jq); 22| | 23| | // Free the null-terminated string 24| 596| free(null_terminated); 25| | 26| 596| return 0; 27| 596|} decContextClearStatus: 54| 307k|decContext *decContextClearStatus(decContext *context, uInt mask) { 55| 307k| context->status&=~mask; 56| 307k| return context; 57| 307k| } // decContextClearStatus decContextDefault: 72| 69.5k|decContext * decContextDefault(decContext *context, Int kind) { 73| | // set defaults... 74| 69.5k| context->digits=9; // 9 digits 75| 69.5k| context->emax=DEC_MAX_EMAX; // 9-digit exponents ------------------ | | 90| 69.5k| #define DEC_MAX_EMAX 999999999 ------------------ 76| 69.5k| context->emin=DEC_MIN_EMIN; // .. balanced ------------------ | | 93| 69.5k| #define DEC_MIN_EMIN -999999999 ------------------ 77| 69.5k| context->round=DEC_ROUND_HALF_UP; // 0.5 rises 78| 69.5k| context->traps=DEC_Errors; // all but informational ------------------ | | 183| 69.5k| #define DEC_Errors (DEC_IEEE_754_Division_by_zero | \ | | ------------------ | | | | 167| 69.5k| #define DEC_IEEE_754_Division_by_zero (DEC_Division_by_zero) | | | | ------------------ | | | | | | 129| 69.5k| #define DEC_Division_by_zero 0x00000002 | | | | ------------------ | | ------------------ | | 184| 69.5k| DEC_IEEE_754_Invalid_operation | \ | | ------------------ | | | | 173| 69.5k| #define DEC_IEEE_754_Invalid_operation (DEC_Conversion_syntax | \ | | | | ------------------ | | | | | | 128| 69.5k| #define DEC_Conversion_syntax 0x00000001 | | | | ------------------ | | | | 174| 69.5k| DEC_Division_impossible | \ | | | | ------------------ | | | | | | 130| 69.5k| #define DEC_Division_impossible 0x00000004 | | | | ------------------ | | | | 175| 69.5k| DEC_Division_undefined | \ | | | | ------------------ | | | | | | 131| 69.5k| #define DEC_Division_undefined 0x00000008 | | | | ------------------ | | | | 176| 69.5k| DEC_Insufficient_storage | \ | | | | ------------------ | | | | | | 132| 69.5k| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ | | | | ------------------ | | | | 177| 69.5k| DEC_Invalid_context | \ | | | | ------------------ | | | | | | 134| 69.5k| #define DEC_Invalid_context 0x00000040 | | | | ------------------ | | | | 178| 69.5k| DEC_Invalid_operation) | | | | ------------------ | | | | | | 135| 69.5k| #define DEC_Invalid_operation 0x00000080 | | | | ------------------ | | ------------------ | | 185| 69.5k| DEC_IEEE_754_Overflow | DEC_IEEE_754_Underflow) | | ------------------ | | | | 179| 69.5k| #define DEC_IEEE_754_Overflow (DEC_Overflow) | | | | ------------------ | | | | | | 139| 69.5k| #define DEC_Overflow 0x00000200 | | | | ------------------ | | ------------------ | | DEC_IEEE_754_Overflow | DEC_IEEE_754_Underflow) | | ------------------ | | | | 180| 69.5k| #define DEC_IEEE_754_Underflow (DEC_Underflow) | | | | ------------------ | | | | | | 143| 69.5k| #define DEC_Underflow 0x00002000 | | | | ------------------ | | ------------------ ------------------ 79| 69.5k| context->status=0; // cleared 80| 69.5k| context->clamp=0; // no clamping 81| | #if DECSUBSET 82| | context->extended=0; // cleared 83| | #endif 84| 69.5k| switch (kind) { 85| 1| case DEC_INIT_BASE: ------------------ | | 227| 1| #define DEC_INIT_BASE 0 ------------------ | Branch (85:5): [True: 1, False: 69.5k] ------------------ 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: 69.5k] ------------------ 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| 69.5k| case DEC_INIT_DECIMAL64: ------------------ | | 229| 69.5k| #define DEC_INIT_DECIMAL64 64 ------------------ | Branch (99:5): [True: 69.5k, False: 1] ------------------ 100| 69.5k| context->digits=16; // digits 101| 69.5k| context->emax=384; // Emax 102| 69.5k| context->emin=-383; // Emin 103| 69.5k| context->round=DEC_ROUND_HALF_EVEN; // 0.5 to nearest even 104| 69.5k| context->traps=0; // no traps set 105| 69.5k| context->clamp=1; // clamp exponents 106| | #if DECSUBSET 107| | context->extended=1; // set 108| | #endif 109| 69.5k| break; 110| 0| case DEC_INIT_DECIMAL128: ------------------ | | 230| 0| #define DEC_INIT_DECIMAL128 128 ------------------ | Branch (110:5): [True: 0, False: 69.5k] ------------------ 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: 69.5k] ------------------ 123| | // use defaults, and .. 124| 0| decContextSetStatus(context, DEC_Invalid_operation); // trap ------------------ | | 135| 0| #define DEC_Invalid_operation 0x00000080 ------------------ 125| 69.5k| } 126| | 127| 69.5k| return context;} // decContextDefault decContextSetStatus: 211| 11.0k|decContext * decContextSetStatus(decContext *context, uInt status) { 212| 11.0k| context->status|=status; 213| 11.0k| if (status & context->traps) raise(SIGFPE); ------------------ | Branch (213:7): [True: 0, False: 11.0k] ------------------ 214| 11.0k| return context;} // decContextSetStatus decNumberToString: 448| 100k|char * decNumberToString(const decNumber *dn, char *string){ 449| 100k| decToString(dn, string, 0); 450| 100k| return string; 451| 100k| } // DecNumberToString decNumberFromString: 479| 307k| decContext *set) { 480| 307k| Int exponent=0; // working exponent [assume 0] ------------------ | | 92| 307k| #define Int int32_t ------------------ 481| 307k| uByte bits=0; // working flags [assume +ve] ------------------ | | 89| 307k| #define uByte uint8_t ------------------ 482| 307k| Unit *res; // where result will be built ------------------ | | 94| 307k| #define Unit decNumberUnit | | ------------------ | | | | 59| 307k| #define decNumberUnit uint16_t | | ------------------ ------------------ 483| 307k| Unit resbuff[SD2U(DECBUFFER+9)];// local buffer in case need temporary ------------------ | | 94| 307k| #define Unit decNumberUnit | | ------------------ | | | | 59| 307k| #define decNumberUnit uint16_t | | ------------------ ------------------ 484| | // [+9 allows for ln() constants] 485| 307k| Unit *allocres=NULL; // -> allocated result, iff allocated ------------------ | | 94| 307k| #define Unit decNumberUnit | | ------------------ | | | | 59| 307k| #define decNumberUnit uint16_t | | ------------------ ------------------ 486| 307k| Int d=0; // count of digits found in decimal part ------------------ | | 92| 307k| #define Int int32_t ------------------ 487| 307k| const char *dotchar=NULL; // where dot was found 488| 307k| const char *cfirst=chars; // -> first character of decimal part 489| 307k| const char *last=NULL; // -> last digit of decimal part 490| 307k| const char *c; // work 491| 307k| Unit *up; // .. ------------------ | | 94| 307k| #define Unit decNumberUnit | | ------------------ | | | | 59| 307k| #define decNumberUnit uint16_t | | ------------------ ------------------ 492| 307k| #if DECDPUN>1 493| 307k| Int cut, out; // .. ------------------ | | 92| 307k| #define Int int32_t ------------------ 494| 307k| #endif 495| 307k| Int residue; // rounding residue ------------------ | | 92| 307k| #define Int int32_t ------------------ 496| 307k| uInt status=0; // error code ------------------ | | 93| 307k| #define uInt uint32_t ------------------ 497| | 498| | #if DECCHECK 499| | if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set)) 500| | return decNumberZero(dn); 501| | #endif 502| | 503| 307k| do { // status & malloc protection 504| 16.8M| for (c=chars;; c++) { // -> input character 505| 16.8M| if (*c>='0' && *c<='9') { // test for Arabic digit ------------------ | Branch (505:11): [True: 16.5M, False: 299k] | Branch (505:22): [True: 16.5M, False: 17.6k] ------------------ 506| 16.5M| last=c; 507| 16.5M| d++; // count of real digits 508| 16.5M| continue; // still in decimal part 509| 16.5M| } 510| 317k| if (*c=='.' && dotchar==NULL) { // first '.' ------------------ | Branch (510:11): [True: 9.80k, False: 307k] | Branch (510:22): [True: 9.80k, False: 0] ------------------ 511| 9.80k| dotchar=c; // record offset into decimal part 512| 9.80k| if (c==cfirst) cfirst++; // first digit must follow ------------------ | Branch (512:13): [True: 2.51k, False: 7.29k] ------------------ 513| 9.80k| continue;} 514| 307k| if (c==chars) { // first in string... ------------------ | Branch (514:11): [True: 0, False: 307k] ------------------ 515| 0| if (*c=='-') { // valid - sign ------------------ | Branch (515:13): [True: 0, False: 0] ------------------ 516| 0| cfirst++; 517| 0| bits=DECNEG; ------------------ | | 31| 0| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 518| 0| continue;} 519| 0| if (*c=='+') { // valid + sign ------------------ | Branch (519:13): [True: 0, False: 0] ------------------ 520| 0| cfirst++; 521| 0| continue;} 522| 0| } 523| | // *c is not a digit, or a valid +, -, or '.' 524| 307k| break; 525| 307k| } // c 526| | 527| 307k| if (last==NULL) { // no digits yet ------------------ | Branch (527:9): [True: 0, False: 307k] ------------------ 528| 0| status=DEC_Conversion_syntax;// assume the worst ------------------ | | 128| 0| #define DEC_Conversion_syntax 0x00000001 ------------------ 529| 0| if (*c=='\0') break; // and no more to come... ------------------ | Branch (529:11): [True: 0, False: 0] ------------------ 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| 0| if (dotchar!=NULL) break; // .. unless had a dot ------------------ | Branch (535:11): [True: 0, False: 0] ------------------ 536| 0| decNumberZero(dn); // be optimistic 537| 0| if (decBiStr(c, "infinity", "INFINITY") ------------------ | Branch (537:11): [True: 0, False: 0] ------------------ 538| 0| || decBiStr(c, "inf", "INF")) { ------------------ | Branch (538:11): [True: 0, False: 0] ------------------ 539| 0| dn->bits=bits | DECINF; ------------------ | | 32| 0| #define DECINF 0x40 /* 1=Infinity */ ------------------ 540| 0| status=0; // is OK 541| 0| break; // all done 542| 0| } 543| | // a NaN expected 544| | // 2003.09.10 NaNs are now permitted to have a sign 545| 0| dn->bits=bits | DECNAN; // assume simple NaN ------------------ | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ ------------------ 546| 0| if (*c=='s' || *c=='S') { // looks like an sNaN ------------------ | Branch (546:11): [True: 0, False: 0] | Branch (546:22): [True: 0, False: 0] ------------------ 547| 0| c++; 548| 0| dn->bits=bits | DECSNAN; ------------------ | | 34| 0| #define DECSNAN 0x10 /* 1=sNaN */ ------------------ 549| 0| } 550| 0| if (*c!='n' && *c!='N') break; // check caseless "NaN" ------------------ | Branch (550:11): [True: 0, False: 0] | Branch (550:22): [True: 0, False: 0] ------------------ 551| 0| c++; 552| 0| if (*c!='a' && *c!='A') break; // .. ------------------ | Branch (552:11): [True: 0, False: 0] | Branch (552:22): [True: 0, False: 0] ------------------ 553| 0| c++; 554| 0| if (*c!='n' && *c!='N') break; // .. ------------------ | Branch (554:11): [True: 0, False: 0] | Branch (554:22): [True: 0, False: 0] ------------------ 555| 0| c++; 556| | // now either nothing, or nnnn payload, expected 557| | // -> start of integer and skip leading 0s [including plain 0] 558| 0| for (cfirst=c; *cfirst=='0';) cfirst++; ------------------ | Branch (558:22): [True: 0, False: 0] ------------------ 559| 0| if (*cfirst=='\0') { // "NaN" or "sNaN", maybe with all 0s ------------------ | Branch (559:11): [True: 0, False: 0] ------------------ 560| 0| status=0; // it's good 561| 0| break; // .. 562| 0| } 563| | // something other than 0s; setup last and d as usual [no dots] 564| 0| for (c=cfirst;; c++, d++) { 565| 0| if (*c<'0' || *c>'9') break; // test for Arabic digit ------------------ | Branch (565:13): [True: 0, False: 0] | Branch (565:23): [True: 0, False: 0] ------------------ 566| 0| last=c; 567| 0| } 568| 0| if (*c!='\0') break; // not all digits ------------------ | Branch (568:11): [True: 0, False: 0] ------------------ 569| 0| if (d>set->digits-1) { ------------------ | Branch (569:11): [True: 0, False: 0] ------------------ 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| 0| status=0; // syntax is OK 577| 0| bits=dn->bits; // for copy-back 578| 0| } // last==NULL 579| | 580| 307k| else if (*c!='\0') { // more to process... ------------------ | Branch (580:15): [True: 17.6k, False: 289k] ------------------ 581| | // had some digits; exponent is only valid sequence now 582| 17.6k| Flag nege; // 1=negative exponent ------------------ | | 87| 17.6k| #define Flag uint8_t ------------------ 583| 17.6k| const char *firstexp; // -> first significant exponent digit 584| 17.6k| status=DEC_Conversion_syntax;// assume the worst ------------------ | | 128| 17.6k| #define DEC_Conversion_syntax 0x00000001 ------------------ 585| 17.6k| uInt expa=0; // accumulator for exponent ------------------ | | 93| 17.6k| #define uInt uint32_t ------------------ 586| 17.6k| if (*c!='e' && *c!='E') break; ------------------ | Branch (586:11): [True: 13.6k, False: 4.04k] | Branch (586:22): [True: 0, False: 13.6k] ------------------ 587| | /* Found 'e' or 'E' -- now process explicit exponent */ 588| | // 1998.07.11: sign no longer required 589| 17.6k| nege=0; 590| 17.6k| c++; // to (possible) sign 591| 17.6k| if (*c=='-') {nege=1; c++;} ------------------ | Branch (591:11): [True: 9.32k, False: 8.36k] ------------------ 592| 8.36k| else if (*c=='+') c++; ------------------ | Branch (592:17): [True: 0, False: 8.36k] ------------------ 593| 17.6k| if (*c=='\0') break; ------------------ | Branch (593:11): [True: 0, False: 17.6k] ------------------ 594| | 595| 24.8k| for (; *c=='0' && *(c+1)!='\0';) c++; // strip insignificant zeros ------------------ | Branch (595:14): [True: 7.26k, False: 17.5k] | Branch (595:25): [True: 7.12k, False: 140] ------------------ 596| 17.6k| firstexp=c; // save exponent digit place 597| 3.00M| for (; ;c++) { 598| 3.00M| if (*c<'0' || *c>'9') break; // not a digit ------------------ | Branch (598:13): [True: 17.6k, False: 2.98M] | Branch (598:23): [True: 0, False: 2.98M] ------------------ 599| 2.98M| expa=X10(expa)+(Int)*c-(Int)'0'; ------------------ | | 163| 2.98M| #define X10(i) (((i)<<1)+((i)<<3)) ------------------ 600| 2.98M| } // c 601| | // if not now on a '\0', *c must not be a digit 602| 17.6k| if (*c!='\0') break; ------------------ | Branch (602:11): [True: 0, False: 17.6k] ------------------ 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| 17.6k| if (c>=firstexp+9+1) { ------------------ | Branch (607:11): [True: 2.65k, False: 15.0k] ------------------ 608| 2.65k| if (c>firstexp+9+1 || *firstexp>'1') expa=DECNUMMAXE*2; ------------------ | | 183| 1.41k| #define DECNUMMAXE 999999999 /* maximum adjusted exponent ditto */ ------------------ | Branch (608:13): [True: 874, False: 1.77k] | Branch (608:31): [True: 544, False: 1.23k] ------------------ 609| | // [up to 1999999999 is OK, for example 1E-1000000998] 610| 2.65k| } 611| 17.6k| exponent=(Int)expa; // save exponent 612| 17.6k| if (nege) exponent=-exponent; // was negative ------------------ | Branch (612:11): [True: 9.32k, False: 8.36k] ------------------ 613| 17.6k| status=0; // is OK 614| 17.6k| } // 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| 307k| if (*cfirst=='0') { // [cfirst has stepped over .] ------------------ | Branch (620:9): [True: 154k, False: 153k] ------------------ 621| 2.99M| for (c=cfirst; cextended) { 629| | decNumberZero(dn); // clean result 630| | break; // [could be return] 631| | } 632| | #endif 633| 154k| } // at least one leading 0 634| | 635| | // Handle decimal point... 636| 307k| if (dotchar!=NULL && dotchardigits) res=dn->lsu; // fits into supplied decNumber ------------------ | Branch (642:9): [True: 307k, 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| 307k| #if DECDPUN>1 657| 307k| out=0; // accumulator 658| 307k| up=res+D2U(d)-1; // -> msu ------------------ | | 264| 307k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 307k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 1.41k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 1.41k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 305k, False: 1.41k] | | ------------------ ------------------ 659| 307k| cut=d-(up-res)*DECDPUN; // digits in top unit ------------------ | | 43| 307k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 660| 13.7M| for (c=cfirst;; c++) { // along the digits 661| 13.7M| if (*c=='.') continue; // ignore '.' [don't decrement cut] ------------------ | Branch (661:11): [True: 3.35k, False: 13.7M] ------------------ 662| 13.7M| out=X10(out)+(Int)*c-(Int)'0'; ------------------ | | 163| 13.7M| #define X10(i) (((i)<<1)+((i)<<3)) ------------------ 663| 13.7M| if (c==last) break; // done [never get to trailing '.'] ------------------ | Branch (663:11): [True: 307k, False: 13.4M] ------------------ 664| 13.4M| cut--; 665| 13.4M| if (cut>0) continue; // more for this unit ------------------ | Branch (665:11): [True: 8.95M, False: 4.44M] ------------------ 666| 4.44M| *up=(Unit)out; // write unit 667| 4.44M| up--; // prepare for unit below.. 668| 4.44M| cut=DECDPUN; // .. ------------------ | | 43| 4.44M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 669| 4.44M| out=0; // .. 670| 4.44M| } // c 671| 307k| *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| 307k| dn->bits=bits; 684| 307k| dn->exponent=exponent; 685| 307k| dn->digits=d; 686| | 687| | // if not in number (too long) shorten into the number 688| 307k| if (d>set->digits) { ------------------ | Branch (688:9): [True: 0, False: 307k] ------------------ 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| 307k| else { // no rounding, but may still have overflow or subnormal 695| | // [these tests are just for performance; finalize repeats them] 696| 307k| if ((dn->exponent-1emin-dn->digits) ------------------ | Branch (696:11): [True: 1.56k, False: 305k] ------------------ 697| 305k| || (dn->exponent-1>set->emax-set->digits)) { ------------------ | Branch (697:11): [True: 1.22k, False: 304k] ------------------ 698| 2.78k| residue=0; 699| 2.78k| decFinalize(dn, set, &residue, &status); 700| 2.78k| } 701| 307k| } 702| | // decNumberShow(dn); 703| 307k| } while(0); // [for break] ------------------ | Branch (703:13): [Folded, False: 307k] ------------------ 704| | 705| 307k| if (allocres!=NULL) free(allocres); // drop any storage used ------------------ | Branch (705:7): [True: 0, False: 307k] ------------------ 706| 307k| if (status!=0) decStatus(dn, status, set); ------------------ | Branch (706:7): [True: 2.65k, False: 304k] ------------------ 707| 307k| return dn; 708| 307k| } /* decNumberFromString */ decNumberCompare: 856| 32.4k| const decNumber *rhs, decContext *set) { 857| 32.4k| uInt status=0; // accumulator ------------------ | | 93| 32.4k| #define uInt uint32_t ------------------ 858| 32.4k| decCompareOp(res, lhs, rhs, set, COMPARE, &status); ------------------ | | 184| 32.4k|#define COMPARE 0x01 // Compare operators ------------------ 859| 32.4k| if (status!=0) decStatus(res, status, set); ------------------ | Branch (859:7): [True: 0, False: 32.4k] ------------------ 860| 32.4k| return res; 861| 32.4k| } // decNumberCompare decNumberReduce: 2310| 69.5k| decContext *set) { 2311| | #if DECSUBSET 2312| | decNumber *allocrhs=NULL; // non-NULL if rounded rhs allocated 2313| | #endif 2314| 69.5k| uInt status=0; // as usual ------------------ | | 93| 69.5k| #define uInt uint32_t ------------------ 2315| 69.5k| Int residue=0; // as usual ------------------ | | 92| 69.5k| #define Int int32_t ------------------ 2316| 69.5k| Int dropped; // work ------------------ | | 92| 69.5k| #define Int int32_t ------------------ 2317| | 2318| | #if DECCHECK 2319| | if (decCheckOperands(res, DECUNUSED, rhs, set)) return res; 2320| | #endif 2321| | 2322| 69.5k| 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| 69.5k| if (decNumberIsNaN(rhs)) { ------------------ | | 172| 69.5k| #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 33| 69.5k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) | | ------------------ | | | | 34| 69.5k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ | | | Branch (172:36): [True: 0, False: 69.5k] | | ------------------ ------------------ 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| 69.5k| decCopyFit(res, rhs, set, &residue, &status); // copy & round 2343| 69.5k| decFinish(res, set, &residue, &status); // cleanup/set flags ------------------ | | 267| 69.5k|#define decFinish(a,b,c,d) decFinalize(a,b,c,d) ------------------ 2344| 69.5k| decTrim(res, set, 1, 0, &dropped); // normalize in place 2345| | // [may clamp] 2346| 69.5k| } while(0); // end protected ------------------ | Branch (2346:13): [Folded, False: 69.5k] ------------------ 2347| | 2348| | #if DECSUBSET 2349| | if (allocrhs !=NULL) free(allocrhs); // .. 2350| | #endif 2351| 69.5k| if (status!=0) decStatus(res, status, set);// then report status ------------------ | Branch (2351:7): [True: 8.40k, False: 61.1k] ------------------ 2352| 69.5k| return res; 2353| 69.5k| } // decNumberReduce decNumberZero: 3588| 35.3k|decNumber * decNumberZero(decNumber *dn) { 3589| | 3590| | #if DECCHECK 3591| | if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 3592| | #endif 3593| | 3594| 35.3k| dn->bits=0; 3595| 35.3k| dn->exponent=0; 3596| 35.3k| dn->digits=1; 3597| 35.3k| dn->lsu[0]=0; 3598| 35.3k| return dn; 3599| 35.3k| } // decNumberZero decNumber.c:decToString: 3621| 100k|static void decToString(const decNumber *dn, char *string, Flag eng) { 3622| 100k| Int exp=dn->exponent; // local copy ------------------ | | 92| 100k| #define Int int32_t ------------------ 3623| 100k| Int e; // E-part value ------------------ | | 92| 100k| #define Int int32_t ------------------ 3624| 100k| Int pre; // digits before the '.' ------------------ | | 92| 100k| #define Int int32_t ------------------ 3625| 100k| Int cut; // for counting digits in a Unit ------------------ | | 92| 100k| #define Int int32_t ------------------ 3626| 100k| char *c=string; // work [output pointer] 3627| 100k| const Unit *up=dn->lsu+D2U(dn->digits)-1; // -> msu [input pointer] ------------------ | | 264| 100k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 100k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 238| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 238| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 100k, False: 238] | | ------------------ ------------------ 3628| 100k| uInt u, pow; // work ------------------ | | 93| 100k| #define uInt uint32_t ------------------ 3629| | 3630| | #if DECCHECK 3631| | if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) { 3632| | strcpy(string, "?"); 3633| | return;} 3634| | #endif 3635| | 3636| 100k| if (decNumberIsNegative(dn)) { // Negatives get a minus ------------------ | | 173| 100k| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 100k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 0, False: 100k] | | ------------------ ------------------ 3637| 0| *c='-'; 3638| 0| c++; 3639| 0| } 3640| 100k| if (dn->bits&DECSPECIAL) { // Is a special value ------------------ | | 36| 100k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 32| 100k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 33| 100k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 34| 100k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ | Branch (3640:7): [True: 2.63k, False: 97.9k] ------------------ 3641| 2.63k| if (decNumberIsInfinite(dn)) { ------------------ | | 171| 2.63k| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 2.63k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 2.63k, False: 0] | | ------------------ ------------------ 3642| 2.63k| strcpy(c, "Inf"); 3643| 2.63k| strcpy(c+3, "inity"); 3644| 2.63k| 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| 97.9k| cut=MSUDIGITS(dn->digits); // [faster than remainder] ------------------ | | 271| 97.9k| #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 264| 97.9k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 249| 97.9k| #define DECMAXD2U 49 | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 238| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 43| 238| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | | | ------------------ | | | | | Branch (264:21): [True: 97.7k, False: 238] | | | | ------------------ | | ------------------ | | #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 43| 97.9k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ ------------------ 3660| 97.9k| cut--; // power of ten for digit 3661| | 3662| 97.9k| if (exp==0) { // simple integer [common fastpath] ------------------ | Branch (3662:7): [True: 81.2k, False: 16.7k] ------------------ 3663| 687k| for (;up>=dn->lsu; up--) { // each Unit from msu ------------------ | Branch (3663:11): [True: 606k, False: 81.2k] ------------------ 3664| 606k| u=*up; // contains DECDPUN digits to lay out 3665| 2.27M| for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow); ------------------ | | 288| 1.66M| #define TODIGIT(u, cut, c, pow) { \ | | 289| 1.66M| *(c)='0'; \ | | 290| 1.66M| pow=DECPOWERS[cut]*2; \ | | 291| 1.66M| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 265k, False: 1.40M] | | ------------------ | | 292| 265k| pow*=4; \ | | 293| 265k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 205k, False: 59.3k] | | ------------------ | | 294| 265k| pow/=2; \ | | 295| 265k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 45.7k, False: 219k] | | ------------------ | | 296| 265k| pow/=2; \ | | 297| 265k| } \ | | 298| 1.66M| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 47.2k, False: 1.62M] | | ------------------ | | 299| 1.66M| pow/=2; \ | | 300| 1.66M| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 241k, False: 1.42M] | | ------------------ | | 301| 1.66M| } ------------------ | Branch (3665:14): [True: 1.66M, False: 606k] ------------------ 3666| 606k| cut=DECDPUN-1; // next Unit has all digits ------------------ | | 43| 606k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3667| 606k| } 3668| 81.2k| *c='\0'; // terminate the string 3669| 81.2k| return;} 3670| | 3671| | /* non-0 exponent -- assume plain form */ 3672| 16.7k| pre=dn->digits+exp; // digits before '.' 3673| 16.7k| e=0; // no E 3674| 16.7k| if ((exp>0) || (pre<-5)) { // need exponential form ------------------ | Branch (3674:7): [True: 7.86k, False: 8.84k] | Branch (3674:18): [True: 6.32k, False: 2.52k] ------------------ 3675| 14.1k| e=exp+dn->digits-1; // calculate E value 3676| 14.1k| pre=1; // assume one digit before '.' 3677| 14.1k| if (eng && (e!=0)) { // engineering: may need to adjust ------------------ | Branch (3677:9): [True: 0, False: 14.1k] | 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| 14.1k| } // need exponent 3701| | 3702| | /* lay out the digits of the coefficient, adding 0s and . as needed */ 3703| 16.7k| u=*up; 3704| 16.7k| if (pre>0) { // xxx.xxx or xx00 (engineering) form ------------------ | Branch (3704:7): [True: 15.0k, False: 1.65k] ------------------ 3705| 15.0k| Int n=pre; ------------------ | | 92| 15.0k| #define Int int32_t ------------------ 3706| 1.41M| for (; pre>0; pre--, c++, cut--) { ------------------ | Branch (3706:12): [True: 1.40M, False: 15.0k] ------------------ 3707| 1.40M| if (cut<0) { // need new Unit ------------------ | Branch (3707:11): [True: 462k, False: 940k] ------------------ 3708| 462k| if (up==dn->lsu) break; // out of input digits (pre>digits) ------------------ | Branch (3708:13): [True: 0, False: 462k] ------------------ 3709| 462k| up--; 3710| 462k| cut=DECDPUN-1; ------------------ | | 43| 462k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3711| 462k| u=*up; 3712| 462k| } 3713| 1.40M| TODIGIT(u, cut, c, pow); ------------------ | | 288| 1.40M| #define TODIGIT(u, cut, c, pow) { \ | | 289| 1.40M| *(c)='0'; \ | | 290| 1.40M| pow=DECPOWERS[cut]*2; \ | | 291| 1.40M| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 262k, False: 1.14M] | | ------------------ | | 292| 262k| pow*=4; \ | | 293| 262k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 256k, False: 6.36k] | | ------------------ | | 294| 262k| pow/=2; \ | | 295| 262k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 3.25k, False: 259k] | | ------------------ | | 296| 262k| pow/=2; \ | | 297| 262k| } \ | | 298| 1.40M| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 5.26k, False: 1.39M] | | ------------------ | | 299| 1.40M| pow/=2; \ | | 300| 1.40M| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 263k, False: 1.13M] | | ------------------ | | 301| 1.40M| } ------------------ 3714| 1.40M| } 3715| 15.0k| if (ndigits) { // more to come, after '.' ------------------ | Branch (3715:9): [True: 9.13k, False: 5.92k] ------------------ 3716| 9.13k| *c='.'; c++; 3717| 3.39M| for (;; c++, cut--) { 3718| 3.39M| if (cut<0) { // need new Unit ------------------ | Branch (3718:13): [True: 1.13M, False: 2.25M] ------------------ 3719| 1.13M| if (up==dn->lsu) break; // out of input digits ------------------ | Branch (3719:15): [True: 9.13k, False: 1.12M] ------------------ 3720| 1.12M| up--; 3721| 1.12M| cut=DECDPUN-1; ------------------ | | 43| 1.12M| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3722| 1.12M| u=*up; 3723| 1.12M| } 3724| 3.38M| TODIGIT(u, cut, c, pow); ------------------ | | 288| 3.38M| #define TODIGIT(u, cut, c, pow) { \ | | 289| 3.38M| *(c)='0'; \ | | 290| 3.38M| pow=DECPOWERS[cut]*2; \ | | 291| 3.38M| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 1.68M, False: 1.70M] | | ------------------ | | 292| 1.68M| pow*=4; \ | | 293| 1.68M| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 1.66M, False: 17.2k] | | ------------------ | | 294| 1.68M| pow/=2; \ | | 295| 1.68M| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 12.3k, False: 1.66M] | | ------------------ | | 296| 1.68M| pow/=2; \ | | 297| 1.68M| } \ | | 298| 3.38M| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 11.2k, False: 3.37M] | | ------------------ | | 299| 3.38M| pow/=2; \ | | 300| 3.38M| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 1.67M, False: 1.70M] | | ------------------ | | 301| 3.38M| } ------------------ 3725| 3.38M| } 3726| 9.13k| } 3727| 5.92k| else for (; pre>0; pre--, c++) *c='0'; // 0 padding (for engineering) needed ------------------ | Branch (3727:18): [True: 0, False: 5.92k] ------------------ 3728| 15.0k| } 3729| 1.65k| else { // 0.xxx or 0.000xxx form 3730| 1.65k| *c='0'; c++; 3731| 1.65k| *c='.'; c++; 3732| 2.97k| for (; pre<0; pre++, c++) *c='0'; // add any 0's after '.' ------------------ | Branch (3732:12): [True: 1.32k, False: 1.65k] ------------------ 3733| 66.2k| for (; ; c++, cut--) { 3734| 66.2k| if (cut<0) { // need new Unit ------------------ | Branch (3734:11): [True: 22.1k, False: 44.1k] ------------------ 3735| 22.1k| if (up==dn->lsu) break; // out of input digits ------------------ | Branch (3735:13): [True: 1.65k, False: 20.4k] ------------------ 3736| 20.4k| up--; 3737| 20.4k| cut=DECDPUN-1; ------------------ | | 43| 20.4k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 3738| 20.4k| u=*up; 3739| 20.4k| } 3740| 64.5k| TODIGIT(u, cut, c, pow); ------------------ | | 288| 64.5k| #define TODIGIT(u, cut, c, pow) { \ | | 289| 64.5k| *(c)='0'; \ | | 290| 64.5k| pow=DECPOWERS[cut]*2; \ | | 291| 64.5k| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 19.2k, False: 45.3k] | | ------------------ | | 292| 19.2k| pow*=4; \ | | 293| 19.2k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 17.7k, False: 1.42k] | | ------------------ | | 294| 19.2k| pow/=2; \ | | 295| 19.2k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 667, False: 18.5k] | | ------------------ | | 296| 19.2k| pow/=2; \ | | 297| 19.2k| } \ | | 298| 64.5k| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 1.69k, False: 62.8k] | | ------------------ | | 299| 64.5k| pow/=2; \ | | 300| 64.5k| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 17.7k, False: 46.8k] | | ------------------ | | 301| 64.5k| } ------------------ 3741| 64.5k| } 3742| 1.65k| } 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| 16.7k| if (e!=0) { ------------------ | Branch (3747:7): [True: 14.1k, False: 2.52k] ------------------ 3748| 14.1k| Flag had=0; // 1=had non-zero ------------------ | | 87| 14.1k| #define Flag uint8_t ------------------ 3749| 14.1k| *c='E'; c++; 3750| 14.1k| *c='+'; c++; // assume positive 3751| 14.1k| u=e; // .. 3752| 14.1k| if (e<0) { ------------------ | Branch (3752:9): [True: 6.32k, False: 7.86k] ------------------ 3753| 6.32k| *(c-1)='-'; // oops, need - 3754| 6.32k| u=-e; // uInt, please 3755| 6.32k| } 3756| | // lay out the exponent [_itoa or equivalent is not ANSI C] 3757| 156k| for (cut=9; cut>=0; cut--) { ------------------ | Branch (3757:17): [True: 141k, False: 14.1k] ------------------ 3758| 141k| TODIGIT(u, cut, c, pow); ------------------ | | 288| 141k| #define TODIGIT(u, cut, c, pow) { \ | | 289| 141k| *(c)='0'; \ | | 290| 141k| pow=DECPOWERS[cut]*2; \ | | 291| 141k| if ((u)>pow) { \ | | ------------------ | | | Branch (291:9): [True: 28.0k, False: 113k] | | ------------------ | | 292| 28.0k| pow*=4; \ | | 293| 28.0k| if ((u)>=pow) {(u)-=pow; *(c)+=8;} \ | | ------------------ | | | Branch (293:11): [True: 8.29k, False: 19.7k] | | ------------------ | | 294| 28.0k| pow/=2; \ | | 295| 28.0k| if ((u)>=pow) {(u)-=pow; *(c)+=4;} \ | | ------------------ | | | Branch (295:11): [True: 8.53k, False: 19.4k] | | ------------------ | | 296| 28.0k| pow/=2; \ | | 297| 28.0k| } \ | | 298| 141k| if ((u)>=pow) {(u)-=pow; *(c)+=2;} \ | | ------------------ | | | Branch (298:9): [True: 18.2k, False: 123k] | | ------------------ | | 299| 141k| pow/=2; \ | | 300| 141k| if ((u)>=pow) {(u)-=pow; *(c)+=1;} \ | | ------------------ | | | Branch (300:9): [True: 23.9k, False: 117k] | | ------------------ | | 301| 141k| } ------------------ 3759| 141k| if (*c=='0' && !had) continue; // skip leading zeros ------------------ | Branch (3759:11): [True: 106k, False: 35.4k] | Branch (3759:22): [True: 104k, False: 1.76k] ------------------ 3760| 37.1k| had=1; // had non-0 3761| 37.1k| c++; // step for next 3762| 37.1k| } // cut 3763| 14.1k| } 3764| 16.7k| *c='\0'; // terminate the string (all paths) 3765| 16.7k| return; 3766| 97.9k| } // decToString decNumber.c:decUnitAddSub: 6339| 3.24k| Unit *c, Int m) { 6340| 3.24k| const Unit *alsu=a; // A lsu [need to remember it] 6341| 3.24k| Unit *clsu=c; // C ditto ------------------ | | 94| 3.24k| #define Unit decNumberUnit | | ------------------ | | | | 59| 3.24k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6342| 3.24k| Unit *minC; // low water mark for C ------------------ | | 94| 3.24k| #define Unit decNumberUnit | | ------------------ | | | | 59| 3.24k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6343| 3.24k| Unit *maxC; // high water mark for C ------------------ | | 94| 3.24k| #define Unit decNumberUnit | | ------------------ | | | | 59| 3.24k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6344| 3.24k| eInt carry=0; // carry integer (could be Long) ------------------ | | 203| 3.24k| #define eInt Int // extended integer | | ------------------ | | | | 92| 3.24k| #define Int int32_t | | ------------------ ------------------ 6345| 3.24k| Int add; // work ------------------ | | 92| 3.24k| #define Int int32_t ------------------ 6346| 3.24k| #if DECDPUN<=4 // myriadal, millenary, etc. 6347| 3.24k| Int est; // estimated quotient ------------------ | | 92| 3.24k| #define Int int32_t ------------------ 6348| 3.24k| #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| 3.24k| maxC=c+alength; // A is usually the longer 6356| 3.24k| minC=c+blength; // .. and B the shorter 6357| 3.24k| if (bshift!=0) { // B is shifted; low As copy across ------------------ | Branch (6357:7): [True: 452, False: 2.78k] ------------------ 6358| 452| minC+=bshift; 6359| | // if in place [common], skip copy unless there's a gap [rare] 6360| 452| if (a==c && bshift<=alength) { ------------------ | Branch (6360:9): [True: 0, False: 452] | Branch (6360:17): [True: 0, False: 0] ------------------ 6361| 0| c+=bshift; 6362| 0| a+=bshift; 6363| 0| } 6364| 4.63M| else for (; cmaxC) { // swap ------------------ | Branch (6369:7): [True: 155, False: 3.08k] ------------------ 6370| 155| Unit *hold=minC; ------------------ | | 94| 155| #define Unit decNumberUnit | | ------------------ | | | | 59| 155| #define decNumberUnit uint16_t | | ------------------ ------------------ 6371| 155| minC=maxC; 6372| 155| maxC=hold; 6373| 155| } 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| 6.38k| 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: 622, False: 677] ------------------ 6410| 622| est=(((ueInt)carry>>3)*16777)>>21; 6411| 622| *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder ------------------ | | 209| 622| #define DECDPUNMAX 999 ------------------ 6412| 622| carry=est; // likely quotient [99%] 6413| 622| if (*c>3)*16777)>>21; 6421| 677| *c=(Unit)(carry-est*(DECDPUNMAX+1)); ------------------ | | 209| 677| #define DECDPUNMAX 999 ------------------ 6422| 677| carry=est-(DECDPUNMAX+1); // correctly negative ------------------ | | 209| 677| #define DECDPUNMAX 999 ------------------ 6423| 677| 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| 40| } // c 6457| | 6458| | // now may have one or other to complete 6459| | // [pretest to avoid loop setup/shutdown] 6460| 467k| 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: 30.7k, False: 193] ------------------ 6497| 30.7k| est=(((ueInt)carry>>3)*16777)>>21; 6498| 30.7k| *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder ------------------ | | 209| 30.7k| #define DECDPUNMAX 999 ------------------ 6499| 30.7k| carry=est; // likely quotient [99%] 6500| 30.7k| if (*c>3)*16777)>>21; 6508| 193| *c=(Unit)(carry-est*(DECDPUNMAX+1)); ------------------ | | 209| 193| #define DECDPUNMAX 999 ------------------ 6509| 193| carry=est-(DECDPUNMAX+1); // correctly negative ------------------ | | 209| 193| #define DECDPUNMAX 999 ------------------ 6510| 193| 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| 3| } // 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| 3.24k| if (carry==0) return c-clsu; // no carry, so no more to do ------------------ | Branch (6546:7): [True: 2.53k, False: 710] ------------------ 6547| 710| if (carry>0) { // positive carry ------------------ | Branch (6547:7): [True: 0, False: 710] ------------------ 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| 710| add=1; // temporary carry... 6554| 1.60M| for (c=clsu; c allocated acc buffer, iff allocated ------------------ | | 94| 9.14k| #define Unit decNumberUnit | | ------------------ | | | | 59| 9.14k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6238| 9.14k| Int accunits, need; // units in use or needed for acc ------------------ | | 92| 9.14k| #define Int int32_t ------------------ 6239| 9.14k| const Unit *l, *r, *u; // work 6240| 9.14k| Int expunits, exprem, result; // .. ------------------ | | 92| 9.14k| #define Int int32_t ------------------ 6241| | 6242| 9.14k| if (exp==0) { // aligned; fastpath ------------------ | Branch (6242:7): [True: 7.35k, False: 1.79k] ------------------ 6243| 7.35k| if (alength>blength) return 1; ------------------ | Branch (6243:9): [True: 1.39k, False: 5.95k] ------------------ 6244| 5.95k| if (alength=a; l--, r--) { ------------------ | Branch (6248:11): [True: 4.29k, False: 584] ------------------ 6249| 4.29k| if (*l>*r) return 1; ------------------ | Branch (6249:11): [True: 1.93k, False: 2.35k] ------------------ 6250| 2.35k| if (*l<*r) return -1; ------------------ | Branch (6250:11): [True: 1.61k, False: 741] ------------------ 6251| 2.35k| } 6252| 584| return 0; // all units match 6253| 4.13k| } // aligned 6254| | 6255| | // Unaligned. If one is >1 unit longer than the other, padded 6256| | // approximately, then can return easily 6257| 1.79k| if (alength>blength+(Int)D2U(exp)) return 1; ------------------ | | 264| 1.79k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.79k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 693| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 693| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.09k, False: 693] | | ------------------ ------------------ | Branch (6257:7): [True: 36, False: 1.75k] ------------------ 6258| 1.75k| if (alength+10 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 673| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.08k, False: 673] | | ------------------ ------------------ | Branch (6258:7): [True: 702, False: 1.05k] ------------------ 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| 1.05k| need=blength+D2U(exp); // maximum real length of B ------------------ | | 264| 1.05k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.05k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 126| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 126| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 928, False: 126] | | ------------------ ------------------ 6264| 1.05k| if (needsizeof(accbuff)) { ------------------ | Branch (6267:7): [True: 126, False: 928] ------------------ 6268| 126| allocacc=(Unit *)malloc(need*sizeof(Unit)); 6269| 126| if (allocacc==NULL) return BADINT; // hopeless -- abandon ------------------ | | 194| 0|#define BADINT (Int)0x80000000 // most-negative Int; error indicator ------------------ | Branch (6269:9): [True: 0, False: 126] ------------------ 6270| 126| acc=allocacc; 6271| 126| } 6272| | // Calculate units and remainder from exponent. 6273| 1.05k| expunits=exp/DECDPUN; ------------------ | | 43| 1.05k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6274| 1.05k| exprem=exp%DECDPUN; ------------------ | | 43| 1.05k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6275| | // subtract [A+B*(-m)] 6276| 1.05k| accunits=decUnitAddSub(a, alength, b, blength, expunits, acc, 6277| 1.05k| -(Int)powers[exprem]); ------------------ | | 177| 1.05k|#define powers DECPOWERS // old internal name ------------------ 6278| | // [UnitAddSub result may have leading zeros, even on zero] 6279| 1.05k| if (accunits<0) result=-1; // negative result ------------------ | Branch (6279:7): [True: 710, False: 344] ------------------ 6280| 344| else { // non-negative result 6281| | // check units of the result before freeing any storage 6282| 8.25k| for (u=acc; uround) { 7081| 0| case DEC_ROUND_05UP: { // round zero or five up (for reround) ------------------ | Branch (7081:5): [True: 0, False: 6.43k] ------------------ 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: 6.43k] ------------------ 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: 6.43k] ------------------ 7099| 0| if (residue>5) bump=1; ------------------ | Branch (7099:11): [True: 0, False: 0] ------------------ 7100| 0| break;} // r-h-d 7101| | 7102| 4.91k| case DEC_ROUND_HALF_EVEN: { ------------------ | Branch (7102:5): [True: 4.91k, False: 1.52k] ------------------ 7103| 4.91k| if (residue>5) bump=1; // >0.5 goes up ------------------ | Branch (7103:11): [True: 2.04k, False: 2.87k] ------------------ 7104| 2.87k| else if (residue==5) { // exactly 0.5000... ------------------ | Branch (7104:17): [True: 827, False: 2.04k] ------------------ 7105| | // 0.5 goes up iff [new] lsd is odd 7106| 827| if (*dn->lsu & 0x01) bump=1; ------------------ | Branch (7106:13): [True: 565, False: 262] ------------------ 7107| 827| } 7108| 4.91k| break;} // r-h-e 7109| | 7110| 1.52k| case DEC_ROUND_HALF_UP: { ------------------ | Branch (7110:5): [True: 1.52k, False: 4.91k] ------------------ 7111| 1.52k| if (residue>=5) bump=1; ------------------ | Branch (7111:11): [True: 815, False: 709] ------------------ 7112| 1.52k| break;} // r-h-u 7113| | 7114| 0| case DEC_ROUND_UP: { ------------------ | Branch (7114:5): [True: 0, False: 6.43k] ------------------ 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: 6.43k] ------------------ 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: 6.43k] ------------------ 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: 6.43k] ------------------ 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| 6.43k| } // switch 7147| | 7148| | // now bump the number, up or down, if need be 7149| 6.43k| if (bump==0) return; // no action required ------------------ | Branch (7149:7): [True: 3.01k, False: 3.42k] ------------------ 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| 3.42k| if (bump>0) { ------------------ | Branch (7156:7): [True: 3.42k, False: 0] ------------------ 7157| 3.42k| Unit *up; // work ------------------ | | 94| 3.42k| #define Unit decNumberUnit | | ------------------ | | | | 59| 3.42k| #define decNumberUnit uint16_t | | ------------------ ------------------ 7158| 3.42k| uInt count=dn->digits; // digits to be checked ------------------ | | 93| 3.42k| #define uInt uint32_t ------------------ 7159| 91.9k| for (up=dn->lsu; ; up++) { 7160| 91.9k| if (count<=DECDPUN) { ------------------ | | 43| 91.9k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (7160:11): [True: 2.04k, False: 89.9k] ------------------ 7161| | // this is the last Unit (the msu) 7162| 2.04k| if (*up!=powers[count]-1) break; // not still 9s ------------------ | | 177| 2.04k|#define powers DECPOWERS // old internal name ------------------ | Branch (7162:13): [True: 807, False: 1.23k] ------------------ 7163| | // here if it, too, is all nines 7164| 1.23k| *up=(Unit)powers[count-1]; // here 999 -> 100 etc. ------------------ | | 177| 1.23k|#define powers DECPOWERS // old internal name ------------------ 7165| 58.4k| for (up=up-1; up>=dn->lsu; up--) *up=0; // others all to 0 ------------------ | Branch (7165:23): [True: 57.1k, False: 1.23k] ------------------ 7166| 1.23k| dn->exponent++; // and bump exponent 7167| | // [which, very rarely, could cause Overflow...] 7168| 1.23k| if ((dn->exponent+dn->digits)>set->emax+1) { ------------------ | Branch (7168:13): [True: 361, False: 873] ------------------ 7169| 361| decSetOverflow(dn, set, status); 7170| 361| } 7171| 1.23k| return; // done 7172| 2.04k| } 7173| | // a full unit to check, with more to come 7174| 89.9k| if (*up!=DECDPUNMAX) break; // not still 9s ------------------ | | 209| 89.9k| #define DECDPUNMAX 999 ------------------ | Branch (7174:11): [True: 1.37k, False: 88.5k] ------------------ 7175| 88.5k| count-=DECDPUN; ------------------ | | 43| 88.5k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 7176| 88.5k| } // up 7177| 3.42k| } // 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| 2.18k| decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump); ------------------ | | 264| 2.18k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 2.18k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 277| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 277| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.90k, False: 277] | | ------------------ ------------------ 7220| 2.18k| } // decApplyRound decNumber.c:decSetOverflow: 7348| 3.20k|static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) { 7349| 3.20k| Flag needmax=0; // result is maximum finite value ------------------ | | 87| 3.20k| #define Flag uint8_t ------------------ 7350| 3.20k| uByte sign=dn->bits&DECNEG; // clean and save sign bit ------------------ | | 89| 3.20k| #define uByte uint8_t ------------------ uByte sign=dn->bits&DECNEG; // clean and save sign bit ------------------ | | 31| 3.20k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ 7351| | 7352| 3.20k| if (ISZERO(dn)) { // zero does not overflow magnitude ------------------ | | 255| 3.20k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 3.20k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 914, False: 2.29k] | | | | ------------------ | | | | 178| 3.20k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 394, False: 520] | | | | ------------------ | | | | 179| 3.20k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 394| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 394| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 394| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 394| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 394, False: 0] | | | | ------------------ | | ------------------ ------------------ 7353| 394| Int emax=set->emax; // limit value ------------------ | | 92| 394| #define Int int32_t ------------------ 7354| 394| if (set->clamp) emax-=set->digits-1; // lower if clamping ------------------ | Branch (7354:9): [True: 166, False: 228] ------------------ 7355| 394| if (dn->exponent>emax) { // clamp required ------------------ | Branch (7355:9): [True: 394, False: 0] ------------------ 7356| 394| dn->exponent=emax; 7357| 394| *status|=DEC_Clamped; ------------------ | | 140| 394| #define DEC_Clamped 0x00000400 ------------------ 7358| 394| } 7359| 394| return; 7360| 394| } 7361| | 7362| 2.81k| decNumberZero(dn); 7363| 2.81k| switch (set->round) { 7364| 0| case DEC_ROUND_DOWN: { ------------------ | Branch (7364:5): [True: 0, False: 2.81k] ------------------ 7365| 0| needmax=1; // never Infinity 7366| 0| break;} // r-d 7367| 0| case DEC_ROUND_05UP: { ------------------ | Branch (7367:5): [True: 0, False: 2.81k] ------------------ 7368| 0| needmax=1; // never Infinity 7369| 0| break;} // r-05 7370| 0| case DEC_ROUND_CEILING: { ------------------ | Branch (7370:5): [True: 0, False: 2.81k] ------------------ 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: 2.81k] ------------------ 7374| 0| if (!sign) needmax=1; // Infinity if negative ------------------ | Branch (7374:11): [True: 0, False: 0] ------------------ 7375| 0| break;} // r-f 7376| 2.81k| default: break; // Infinity in all other cases ------------------ | Branch (7376:5): [True: 2.81k, False: 0] ------------------ 7377| 2.81k| } 7378| 2.81k| if (needmax) { ------------------ | Branch (7378:7): [True: 0, False: 2.81k] ------------------ 7379| 0| decSetMaxValue(dn, set); 7380| 0| dn->bits=sign; // set sign 7381| 0| } 7382| 2.81k| else dn->bits=sign|DECINF; // Value is +/-Infinity ------------------ | | 32| 2.81k| #define DECINF 0x40 /* 1=Infinity */ ------------------ 7383| 2.81k| *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; ------------------ | | 139| 2.81k| #define DEC_Overflow 0x00000200 ------------------ *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; ------------------ | | 133| 2.81k| #define DEC_Inexact 0x00000020 ------------------ *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded; ------------------ | | 141| 2.81k| #define DEC_Rounded 0x00000800 ------------------ 7384| 2.81k| } // decSetOverflow decNumber.c:decCompareOp: 6006| 32.4k| 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| 32.4k| Int result=0; // default result value ------------------ | | 92| 32.4k| #define Int int32_t ------------------ 6012| 32.4k| uByte merged; // work ------------------ | | 89| 32.4k| #define uByte uint8_t ------------------ 6013| | 6014| | #if DECCHECK 6015| | if (decCheckOperands(res, lhs, rhs, set)) return res; 6016| | #endif 6017| | 6018| 32.4k| 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| 32.4k| if (op==COMPTOTAL) { // total ordering ------------------ | | 187| 32.4k|#define COMPTOTAL 0x04 // .. ------------------ | Branch (6037:9): [True: 0, False: 32.4k] ------------------ 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| 32.4k| merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN); ------------------ | | 34| 32.4k| #define DECSNAN 0x10 /* 1=sNaN */ ------------------ merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN); ------------------ | | 33| 32.4k| #define DECNAN 0x20 /* 1=NaN */ ------------------ 6051| 32.4k| if (merged) { // a NaN bit set ------------------ | Branch (6051:9): [True: 0, False: 32.4k] ------------------ 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| 32.4k| if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1); ------------------ | | 190| 64.9k|#define COMPMAXMAG 0x07 // .. ------------------ if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1); ------------------ | | 191| 32.4k|#define COMPMINMAG 0x08 // .. ------------------ | Branch (6089:9): [True: 0, False: 32.4k] | Branch (6089:27): [True: 0, False: 32.4k] ------------------ 6090| 32.4k| else result=decCompare(lhs, rhs, 0); // sign matters 6091| 32.4k| } while(0); // end protected ------------------ | Branch (6091:13): [Folded, False: 32.4k] ------------------ 6092| | 6093| 32.4k| if (result==BADINT) *status|=DEC_Insufficient_storage; // rare ------------------ | | 194| 32.4k|#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: 32.4k] ------------------ 6094| 32.4k| else { 6095| 32.4k| if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { // returning signum ------------------ | | 184| 64.9k|#define COMPARE 0x01 // Compare operators ------------------ if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { // returning signum ------------------ | | 189| 32.4k|#define COMPSIG 0x06 // .. [signaling COMPARE] ------------------ if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { // returning signum ------------------ | | 187| 0|#define COMPTOTAL 0x04 // .. ------------------ | Branch (6095:9): [True: 32.4k, False: 0] | Branch (6095:24): [True: 0, False: 0] | Branch (6095:38): [True: 0, False: 0] ------------------ 6096| 32.4k| if (op==COMPTOTAL && result==0) { ------------------ | | 187| 64.9k|#define COMPTOTAL 0x04 // .. ------------------ | Branch (6096:11): [True: 0, False: 32.4k] | 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| 32.4k| decNumberZero(res); // [always a valid result] 6106| 32.4k| if (result!=0) { // must be -1 or +1 ------------------ | Branch (6106:11): [True: 27.3k, False: 5.05k] ------------------ 6107| 27.3k| *res->lsu=1; 6108| 27.3k| if (result<0) res->bits=DECNEG; ------------------ | | 31| 20.9k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ ------------------ | Branch (6108:13): [True: 20.9k, False: 6.44k] ------------------ 6109| 27.3k| } 6110| 32.4k| } 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| 32.4k| } 6150| | #if DECSUBSET 6151| | if (allocrhs!=NULL) free(allocrhs); // free any storage used 6152| | if (alloclhs!=NULL) free(alloclhs); // .. 6153| | #endif 6154| 32.4k| return res; 6155| 32.4k| } // decCompareOp decNumber.c:decCompare: 6170| 32.5k| Flag abs) { 6171| 32.5k| Int result; // result value ------------------ | | 92| 32.5k| #define Int int32_t ------------------ 6172| 32.5k| Int sigr; // rhs signum ------------------ | | 92| 32.5k| #define Int int32_t ------------------ 6173| 32.5k| Int compare; // work ------------------ | | 92| 32.5k| #define Int int32_t ------------------ 6174| | 6175| 32.5k| result=1; // assume signum(lhs) 6176| 32.5k| if (ISZERO(lhs)) result=0; ------------------ | | 255| 32.5k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 32.5k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 22.4k, False: 10.0k] | | | | ------------------ | | | | 178| 32.5k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 22.3k, False: 134] | | | | ------------------ | | | | 179| 32.5k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 22.3k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 22.3k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 22.3k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 22.3k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 21.1k, False: 1.16k] | | | | ------------------ | | ------------------ ------------------ 6177| 32.5k| if (abs) { ------------------ | Branch (6177:7): [True: 112, False: 32.4k] ------------------ 6178| 112| if (ISZERO(rhs)) return result; // LHS wins or both 0 ------------------ | | 255| 112| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 112| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 0, False: 112] | | | | ------------------ | | | | 178| 112| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 0, False: 0] | | | | ------------------ | | | | 179| 112| && (((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| 112| if (result==0) return -1; // LHS is 0; RHS wins ------------------ | Branch (6180:9): [True: 0, False: 112] ------------------ 6181| | // [here, both non-zero, result=1] 6182| 112| } 6183| 32.4k| else { // signs matter 6184| 32.4k| if (result && decNumberIsNegative(lhs)) result=-1; ------------------ | | 173| 11.2k| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 11.2k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 0, False: 11.2k] | | ------------------ ------------------ | Branch (6184:9): [True: 11.2k, False: 21.1k] ------------------ 6185| 32.4k| sigr=1; // compute signum(rhs) 6186| 32.4k| if (ISZERO(rhs)) sigr=0; ------------------ | | 255| 32.4k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 32.4k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 5.78k, False: 26.6k] | | | | ------------------ | | | | 178| 32.4k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 5.62k, False: 161] | | | | ------------------ | | | | 179| 32.4k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 5.62k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 5.62k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 5.62k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 5.62k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 5.05k, False: 571] | | | | ------------------ | | ------------------ ------------------ 6187| 27.3k| else if (decNumberIsNegative(rhs)) sigr=-1; ------------------ | | 173| 27.3k| #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) | | ------------------ | | | | 31| 27.3k| #define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ | | ------------------ | | | Branch (173:36): [True: 0, False: 27.3k] | | ------------------ ------------------ 6188| 32.4k| if (result > sigr) return +1; // L > R, return 1 ------------------ | Branch (6188:9): [True: 716, False: 31.7k] ------------------ 6189| 31.7k| if (result < sigr) return -1; // L < R, return -1 ------------------ | Branch (6189:9): [True: 16.8k, False: 14.9k] ------------------ 6190| 14.9k| if (result==0) return 0; // both 0 ------------------ | Branch (6190:9): [True: 4.33k, False: 10.5k] ------------------ 6191| 14.9k| } 6192| | 6193| | // signums are the same; both are non-zero 6194| 10.6k| if ((lhs->bits | rhs->bits) & DECINF) { // one or more infinities ------------------ | | 32| 10.6k| #define DECINF 0x40 /* 1=Infinity */ ------------------ | Branch (6194:7): [True: 1.53k, False: 9.14k] ------------------ 6195| 1.53k| if (decNumberIsInfinite(rhs)) { ------------------ | | 171| 1.53k| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 1.53k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 498, False: 1.03k] | | ------------------ ------------------ 6196| 498| if (decNumberIsInfinite(lhs)) result=0;// both infinite ------------------ | | 171| 498| #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) | | ------------------ | | | | 32| 498| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | | Branch (171:36): [True: 132, False: 366] | | ------------------ ------------------ 6197| 366| else result=-result; // only rhs infinite 6198| 498| } 6199| 1.53k| return result; 6200| 1.53k| } 6201| | // must compare the coefficients, allowing for exponents 6202| 9.14k| if (lhs->exponent>rhs->exponent) { // LHS exponent larger ------------------ | Branch (6202:7): [True: 1.51k, False: 7.62k] ------------------ 6203| | // swap sides, and sign 6204| 1.51k| const decNumber *temp=lhs; 6205| 1.51k| lhs=rhs; 6206| 1.51k| rhs=temp; 6207| 1.51k| result=-result; 6208| 1.51k| } 6209| 9.14k| compare=decUnitCompare(lhs->lsu, D2U(lhs->digits), ------------------ | | 264| 9.14k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 9.14k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 243| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 243| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 8.90k, False: 243] | | ------------------ ------------------ 6210| 9.14k| rhs->lsu, D2U(rhs->digits), ------------------ | | 264| 9.14k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 9.14k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 79| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 79| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 9.06k, False: 79] | | ------------------ ------------------ 6211| 9.14k| rhs->exponent-lhs->exponent); 6212| 9.14k| if (compare!=BADINT) compare*=result; // comparison succeeded ------------------ | | 194| 9.14k|#define BADINT (Int)0x80000000 // most-negative Int; error indicator ------------------ | Branch (6212:7): [True: 9.14k, False: 0] ------------------ 6213| 9.14k| return compare; 6214| 10.6k| } // decCompare decNumber.c:decTrim: 6592| 69.5k| Flag noclamp, Int *dropped) { 6593| 69.5k| Int d, exp; // work ------------------ | | 92| 69.5k| #define Int int32_t ------------------ 6594| 69.5k| uInt cut; // .. ------------------ | | 93| 69.5k| #define uInt uint32_t ------------------ 6595| 69.5k| Unit *up; // -> current Unit ------------------ | | 94| 69.5k| #define Unit decNumberUnit | | ------------------ | | | | 59| 69.5k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6596| | 6597| | #if DECCHECK 6598| | if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn; 6599| | #endif 6600| | 6601| 69.5k| *dropped=0; // assume no zeros dropped 6602| 69.5k| if ((dn->bits & DECSPECIAL) // fast exit if special .. ------------------ | | 36| 69.5k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 32| 69.5k| #define DECINF 0x40 /* 1=Infinity */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 33| 69.5k| #define DECNAN 0x20 /* 1=NaN */ | | ------------------ | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | ------------------ | | | | 34| 69.5k| #define DECSNAN 0x10 /* 1=sNaN */ | | ------------------ ------------------ | Branch (6602:7): [True: 2.63k, False: 66.8k] ------------------ 6603| 66.8k| || (*dn->lsu & 0x01)) return dn; // .. or odd ------------------ | Branch (6603:8): [True: 27.1k, False: 39.6k] ------------------ 6604| 39.6k| if (ISZERO(dn)) { // .. or 0 ------------------ | | 255| 39.6k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 39.6k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 16.9k, False: 22.7k] | | | | ------------------ | | | | 178| 39.6k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 13.9k, False: 2.99k] | | | | ------------------ | | | | 179| 39.6k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 13.9k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 13.9k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 13.9k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 13.9k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 13.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 6605| 13.9k| dn->exponent=0; // (sign is preserved) 6606| 13.9k| return dn; 6607| 13.9k| } 6608| | 6609| | // have a finite number which is even 6610| 25.7k| exp=dn->exponent; 6611| 25.7k| cut=1; // digit (1-DECDPUN) in Unit 6612| 25.7k| up=dn->lsu; // -> current Unit 6613| 49.5k| for (d=0; ddigits-1; d++) { // [don't strip the final digit] ------------------ | Branch (6613:13): [True: 32.7k, False: 16.8k] ------------------ 6614| | // slice by powers 6615| 32.7k| #if DECDPUN<=4 6616| 32.7k| uInt quot=QUOT10(*up, cut); ------------------ | | 93| 32.7k| #define uInt uint32_t ------------------ uInt quot=QUOT10(*up, cut); ------------------ | | 210| 32.7k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6617| 32.7k| if ((*up-quot*powers[cut])!=0) break; // found non-0 digit ------------------ | | 177| 32.7k|#define powers DECPOWERS // old internal name ------------------ | Branch (6617:11): [True: 8.95k, False: 23.8k] ------------------ 6618| | #else 6619| | if (*up%powers[cut]!=0) break; // found non-0 digit 6620| | #endif 6621| | // have a trailing 0 6622| 23.8k| if (!all) { // trimming ------------------ | Branch (6622:9): [True: 0, False: 23.8k] ------------------ 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| 23.8k| cut++; // next power 6630| 23.8k| if (cut>DECDPUN) { // need new Unit ------------------ | | 43| 23.8k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6630:9): [True: 5.64k, False: 18.1k] ------------------ 6631| 5.64k| up++; 6632| 5.64k| cut=1; 6633| 5.64k| } 6634| 23.8k| } // d 6635| 25.7k| if (d==0) return dn; // none to drop ------------------ | Branch (6635:7): [True: 19.7k, False: 6.03k] ------------------ 6636| | 6637| | // may need to limit drop if clamping 6638| 6.03k| if (set->clamp && !noclamp) { ------------------ | Branch (6638:7): [True: 6.03k, False: 0] | Branch (6638:21): [True: 6.03k, False: 0] ------------------ 6639| 6.03k| Int maxd=set->emax-set->digits+1-dn->exponent; ------------------ | | 92| 6.03k| #define Int int32_t ------------------ 6640| 6.03k| if (maxd<=0) return dn; // nothing possible ------------------ | Branch (6640:9): [True: 725, False: 5.30k] ------------------ 6641| 5.30k| if (d>maxd) d=maxd; ------------------ | Branch (6641:9): [True: 131, False: 5.17k] ------------------ 6642| 5.30k| } 6643| | 6644| | // effect the drop 6645| 5.30k| decShiftToLeast(dn->lsu, D2U(dn->digits), d); ------------------ | | 264| 5.30k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 5.30k| #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: 5.30k, False: 0] | | ------------------ ------------------ 6646| 5.30k| dn->exponent+=d; // maintain numerical value 6647| 5.30k| dn->digits-=d; // new length 6648| 5.30k| *dropped=d; // report the count 6649| 5.30k| return dn; 6650| 6.03k| } // decTrim decNumber.c:decShiftToMost: 6685| 1.54k|static Int decShiftToMost(Unit *uar, Int digits, Int shift) { 6686| 1.54k| Unit *target, *source, *first; // work ------------------ | | 94| 1.54k| #define Unit decNumberUnit | | ------------------ | | | | 59| 1.54k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6687| 1.54k| Int cut; // odd 0's to add ------------------ | | 92| 1.54k| #define Int int32_t ------------------ 6688| 1.54k| uInt next; // work ------------------ | | 93| 1.54k| #define uInt uint32_t ------------------ 6689| | 6690| 1.54k| if (shift==0) return digits; // [fastpath] nothing to do ------------------ | Branch (6690:7): [True: 0, False: 1.54k] ------------------ 6691| 1.54k| if ((digits+shift)<=DECDPUN) { // [fastpath] single-unit case ------------------ | | 43| 1.54k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6691:7): [True: 235, False: 1.31k] ------------------ 6692| 235| *uar=(Unit)(*uar*powers[shift]); ------------------ | | 177| 235|#define powers DECPOWERS // old internal name ------------------ 6693| 235| return digits+shift; 6694| 235| } 6695| | 6696| 1.31k| next=0; // all paths 6697| 1.31k| source=uar+D2U(digits)-1; // where msu comes from ------------------ | | 264| 1.31k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.31k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 193| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 193| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 1.12k, False: 193] | | ------------------ ------------------ 6698| 1.31k| target=source+D2U(shift); // where upper part of first cut goes ------------------ | | 264| 1.31k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.31k| #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.31k, False: 0] | | ------------------ ------------------ 6699| 1.31k| cut=DECDPUN-MSUDIGITS(shift); // where to slice ------------------ | | 43| 1.31k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ cut=DECDPUN-MSUDIGITS(shift); // where to slice ------------------ | | 271| 1.31k| #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 264| 1.31k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 249| 1.31k| #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.31k, False: 0] | | | | ------------------ | | ------------------ | | #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 43| 1.31k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ ------------------ 6700| 1.31k| if (cut==0) { // unit-boundary case ------------------ | Branch (6700:7): [True: 252, False: 1.06k] ------------------ 6701| 622| for (; source>=uar; source--, target--) *target=*source; ------------------ | Branch (6701:12): [True: 370, False: 252] ------------------ 6702| 252| } 6703| 1.06k| else { 6704| 1.06k| first=uar+D2U(digits+shift)-1; // where msu of source will end up ------------------ | | 264| 1.06k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 1.06k| #define DECMAXD2U 49 | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 194| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 43| 194| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ | | | Branch (264:21): [True: 868, False: 194] | | ------------------ ------------------ 6705| 57.4k| for (; source>=uar; source--, target--) { ------------------ | Branch (6705:12): [True: 56.3k, False: 1.06k] ------------------ 6706| | // split the source Unit and accumulate remainder for next 6707| 56.3k| #if DECDPUN<=4 6708| 56.3k| uInt quot=QUOT10(*source, cut); ------------------ | | 93| 56.3k| #define uInt uint32_t ------------------ uInt quot=QUOT10(*source, cut); ------------------ | | 210| 56.3k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6709| 56.3k| uInt rem=*source-quot*powers[cut]; ------------------ | | 93| 56.3k| #define uInt uint32_t ------------------ uInt rem=*source-quot*powers[cut]; ------------------ | | 177| 56.3k|#define powers DECPOWERS // old internal name ------------------ 6710| 56.3k| next+=quot; 6711| | #else 6712| | uInt rem=*source%powers[cut]; 6713| | next+=*source/powers[cut]; 6714| | #endif 6715| 56.3k| if (target<=first) *target=(Unit)next; // write to target iff valid ------------------ | Branch (6715:11): [True: 55.7k, False: 608] ------------------ 6716| 56.3k| next=rem*powers[DECDPUN-cut]; // save remainder for next Unit ------------------ | | 177| 56.3k|#define powers DECPOWERS // old internal name ------------------ next=rem*powers[DECDPUN-cut]; // save remainder for next Unit ------------------ | | 43| 56.3k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6717| 56.3k| } 6718| 1.06k| } // shift-move 6719| | 6720| | // propagate any partial unit to one below and clear the rest 6721| 3.89k| for (; target>=uar; target--) { ------------------ | Branch (6721:10): [True: 2.57k, False: 1.31k] ------------------ 6722| 2.57k| *target=(Unit)next; 6723| 2.57k| next=0; 6724| 2.57k| } 6725| 1.31k| return digits+shift; 6726| 1.54k| } // decShiftToMost decNumber.c:decShiftToLeast: 6741| 5.30k|static Int decShiftToLeast(Unit *uar, Int units, Int shift) { 6742| 5.30k| Unit *target, *up; // work ------------------ | | 94| 5.30k| #define Unit decNumberUnit | | ------------------ | | | | 59| 5.30k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6743| 5.30k| Int cut, count; // work ------------------ | | 92| 5.30k| #define Int int32_t ------------------ 6744| 5.30k| Int quot, rem; // for division ------------------ | | 92| 5.30k| #define Int int32_t ------------------ 6745| | 6746| 5.30k| if (shift==0) return units; // [fastpath] nothing to do ------------------ | Branch (6746:7): [True: 0, False: 5.30k] ------------------ 6747| 5.30k| if (shift==units*DECDPUN) { // [fastpath] little to do ------------------ | | 43| 5.30k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6747:7): [True: 0, False: 5.30k] ------------------ 6748| 0| *uar=0; // all digits cleared gives zero 6749| 0| return 1; // leaves just the one 6750| 0| } 6751| | 6752| 5.30k| target=uar; // both paths 6753| 5.30k| cut=MSUDIGITS(shift); ------------------ | | 271| 5.30k| #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 264| 5.30k| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | | | ------------------ | | | | | | 249| 5.30k| #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: 5.30k, False: 0] | | | | ------------------ | | ------------------ | | #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN) | | ------------------ | | | | 43| 5.30k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ | | ------------------ ------------------ 6754| 5.30k| if (cut==DECDPUN) { // unit-boundary case; easy ------------------ | | 43| 5.30k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6754:7): [True: 772, False: 4.53k] ------------------ 6755| 772| up=uar+D2U(shift); ------------------ | | 264| 772| #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN) | | ------------------ | | | | 249| 772| #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: 772, False: 0] | | ------------------ ------------------ 6756| 1.78k| 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: 4.53k, False: 0] | | ------------------ ------------------ 6762| 4.53k| count=units*DECDPUN-shift; // the maximum new length ------------------ | | 43| 4.53k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6763| 4.53k| #if DECDPUN<=4 6764| 4.53k| quot=QUOT10(*up, cut); ------------------ | | 210| 4.53k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6765| | #else 6766| | quot=*up/powers[cut]; 6767| | #endif 6768| 12.7k| for (; ; target++) { 6769| 12.7k| *target=(Unit)quot; 6770| 12.7k| count-=(DECDPUN-cut); ------------------ | | 43| 12.7k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6771| 12.7k| if (count<=0) break; ------------------ | Branch (6771:9): [True: 4.53k, False: 8.22k] ------------------ 6772| 8.22k| up++; 6773| 8.22k| quot=*up; 6774| 8.22k| #if DECDPUN<=4 6775| 8.22k| quot=QUOT10(quot, cut); ------------------ | | 210| 8.22k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6776| 8.22k| rem=*up-quot*powers[cut]; ------------------ | | 177| 8.22k|#define powers DECPOWERS // old internal name ------------------ 6777| | #else 6778| | rem=quot%powers[cut]; 6779| | quot=quot/powers[cut]; 6780| | #endif 6781| 8.22k| *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 177| 8.22k|#define powers DECPOWERS // old internal name ------------------ *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 43| 8.22k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6782| 8.22k| count-=cut; 6783| 8.22k| if (count<=0) break; ------------------ | Branch (6783:9): [True: 0, False: 8.22k] ------------------ 6784| 8.22k| } 6785| 4.53k| return target-uar+1; 6786| 5.30k| } // decShiftToLeast decNumber.c:decCopyFit: 6844| 69.5k| decContext *set, Int *residue, uInt *status) { 6845| 69.5k| dest->bits=src->bits; 6846| 69.5k| dest->exponent=src->exponent; 6847| 69.5k| decSetCoeff(dest, set, src->lsu, src->digits, residue, status); 6848| 69.5k| } // decCopyFit decNumber.c:decSetCoeff: 6890| 73.4k| Int len, Int *residue, uInt *status) { 6891| 73.4k| Int discard; // number of digits to discard ------------------ | | 92| 73.4k| #define Int int32_t ------------------ 6892| 73.4k| uInt cut; // cut point in Unit ------------------ | | 93| 73.4k| #define uInt uint32_t ------------------ 6893| 73.4k| const Unit *up; // work 6894| 73.4k| Unit *target; // .. ------------------ | | 94| 73.4k| #define Unit decNumberUnit | | ------------------ | | | | 59| 73.4k| #define decNumberUnit uint16_t | | ------------------ ------------------ 6895| 73.4k| Int count; // .. ------------------ | | 92| 73.4k| #define Int int32_t ------------------ 6896| 73.4k| #if DECDPUN<=4 6897| 73.4k| uInt temp; // .. ------------------ | | 93| 73.4k| #define uInt uint32_t ------------------ 6898| 73.4k| #endif 6899| | 6900| 73.4k| discard=len-set->digits; // digits to discard 6901| 73.4k| if (discard<=0) { // no digits are being discarded ------------------ | Branch (6901:7): [True: 66.1k, False: 7.30k] ------------------ 6902| 66.1k| if (dn->lsu!=lsu) { // copy needed ------------------ | Branch (6902:9): [True: 66.1k, False: 0] ------------------ 6903| | // copy the coefficient array to the result number; no shift needed 6904| 66.1k| count=len; // avoids D2U 6905| 66.1k| up=lsu; 6906| 162k| for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) ------------------ | | 43| 96.6k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6906:28): [True: 96.6k, False: 66.1k] ------------------ 6907| 96.6k| *target=*up; 6908| 66.1k| dn->digits=len; // set the new length 6909| 66.1k| } 6910| | // dn->exponent and residue are unchanged, record any inexactitude 6911| 66.1k| 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: 66.1k] ------------------ 6912| 66.1k| return; 6913| 66.1k| } 6914| | 6915| | // some digits must be discarded ... 6916| 7.30k| dn->exponent+=discard; // maintain numerical value 6917| 7.30k| *status|=DEC_Rounded; // accumulate Rounded status ------------------ | | 141| 7.30k| #define DEC_Rounded 0x00000800 ------------------ 6918| 7.30k| if (*residue>1) *residue=1; // previous residue now to right, so reduce ------------------ | Branch (6918:7): [True: 186, False: 7.12k] ------------------ 6919| | 6920| 7.30k| if (discard>len) { // everything, +1, is being discarded ------------------ | Branch (6920:7): [True: 1.08k, False: 6.22k] ------------------ 6921| | // guard digit is 0 6922| | // residue is all the number [NB could be all 0s] 6923| 1.08k| if (*residue<=0) { // not already positive ------------------ | Branch (6923:9): [True: 925, False: 164] ------------------ 6924| 925| count=len; // avoids D2U 6925| 1.24k| for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { // found non-0 ------------------ | | 43| 321| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6925:20): [True: 1.24k, False: 0] | Branch (6925:55): [True: 925, False: 321] ------------------ 6926| 925| *residue=1; 6927| 925| break; // no need to check any others 6928| 925| } 6929| 925| } 6930| 1.08k| if (*residue!=0) *status|=DEC_Inexact; // record inexactitude ------------------ | | 133| 1.08k| #define DEC_Inexact 0x00000020 ------------------ | Branch (6930:9): [True: 1.08k, False: 0] ------------------ 6931| 1.08k| *dn->lsu=0; // coefficient will now be 0 6932| 1.08k| dn->digits=1; // .. 6933| 1.08k| return; 6934| 1.08k| } // 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| 6.22k| count=0; 6943| 518k| for (up=lsu;; up++) { 6944| 518k| count+=DECDPUN; ------------------ | | 43| 518k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6945| 518k| if (count>=discard) break; // full ones all checked ------------------ | Branch (6945:9): [True: 6.22k, False: 512k] ------------------ 6946| 512k| if (*up!=0) *residue=1; ------------------ | Branch (6946:9): [True: 181k, False: 331k] ------------------ 6947| 512k| } // up 6948| | 6949| | // here up -> Unit with first discarded digit 6950| 6.22k| cut=discard-(count-DECDPUN)-1; ------------------ | | 43| 6.22k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6951| 6.22k| if (cut==DECDPUN-1) { // unit-boundary case (fast) ------------------ | | 43| 6.22k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6951:7): [True: 2.45k, False: 3.76k] ------------------ 6952| 2.45k| Unit half=(Unit)powers[DECDPUN]>>1; ------------------ | | 94| 2.45k| #define Unit decNumberUnit | | ------------------ | | | | 59| 2.45k| #define decNumberUnit uint16_t | | ------------------ ------------------ Unit half=(Unit)powers[DECDPUN]>>1; ------------------ | | 177| 2.45k|#define powers DECPOWERS // old internal name ------------------ Unit half=(Unit)powers[DECDPUN]>>1; ------------------ | | 43| 2.45k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 6953| | // set residue directly 6954| 2.45k| if (*up>=half) { ------------------ | Branch (6954:9): [True: 1.17k, False: 1.28k] ------------------ 6955| 1.17k| if (*up>half) *residue=7; ------------------ | Branch (6955:11): [True: 1.04k, False: 128] ------------------ 6956| 128| else *residue+=5; // add sticky bit 6957| 1.17k| } 6958| 1.28k| else { // digits<=0) { // special for Quantize/Subnormal :-( ------------------ | Branch (6961:9): [True: 411, False: 2.04k] ------------------ 6962| 411| *dn->lsu=0; // .. result is 0 6963| 411| dn->digits=1; // .. 6964| 411| } 6965| 2.04k| else { // shift to least 6966| 2.04k| count=set->digits; // now digits to end up with 6967| 2.04k| dn->digits=count; // set the new length 6968| 2.04k| up++; // move to next 6969| | // on unit boundary, so shift-down copy loop is simple 6970| 29.5k| for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN) ------------------ | | 43| 27.4k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ | Branch (6970:28): [True: 27.4k, False: 2.04k] ------------------ 6971| 27.4k| *target=*up; 6972| 2.04k| } 6973| 2.45k| } // unit-boundary case 6974| | 6975| 3.76k| else { // discard digit is in low digit(s), and not top digit 6976| 3.76k| uInt discard1; // first discarded digit ------------------ | | 93| 3.76k| #define uInt uint32_t ------------------ 6977| 3.76k| uInt quot, rem; // for divisions ------------------ | | 93| 3.76k| #define uInt uint32_t ------------------ 6978| 3.76k| if (cut==0) quot=*up; // is at bottom of unit ------------------ | Branch (6978:9): [True: 1.85k, False: 1.90k] ------------------ 6979| 1.90k| else /* cut>0 */ { // it's not at bottom of unit 6980| 1.90k| #if DECDPUN<=4 6981| 1.90k| quot=QUOT10(*up, cut); ------------------ | | 210| 1.90k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 6982| 1.90k| rem=*up-quot*powers[cut]; ------------------ | | 177| 1.90k|#define powers DECPOWERS // old internal name ------------------ 6983| | #else 6984| | rem=*up%powers[cut]; 6985| | quot=*up/powers[cut]; 6986| | #endif 6987| 1.90k| if (rem!=0) *residue=1; ------------------ | Branch (6987:11): [True: 1.40k, False: 508] ------------------ 6988| 1.90k| } 6989| | // discard digit is now at bottom of quot 6990| 3.76k| #if DECDPUN<=4 6991| 3.76k| temp=(quot*6554)>>16; // fast /10 6992| | // Vowels algorithm here not a win (9 instructions) 6993| 3.76k| discard1=quot-X10(temp); ------------------ | | 163| 3.76k| #define X10(i) (((i)<<1)+((i)<<3)) ------------------ 6994| 3.76k| 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| 3.76k| *residue+=resmap[discard1]; 7002| 3.76k| 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| 3.76k| if (set->digits<=0) { // special for Quantize/Subnormal :-( ------------------ | Branch (7006:9): [True: 344, False: 3.42k] ------------------ 7007| 344| *dn->lsu=0; // .. result is 0 7008| 344| dn->digits=1; // .. 7009| 344| } 7010| 3.42k| else { // shift to least needed 7011| 3.42k| count=set->digits; // now digits to end up with 7012| 3.42k| dn->digits=count; // set the new length 7013| | // shift-copy the coefficient array to the result number 7014| 963k| for (target=dn->lsu; ; target++) { 7015| 963k| *target=(Unit)quot; 7016| 963k| count-=(DECDPUN-cut); ------------------ | | 43| 963k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 7017| 963k| if (count<=0) break; ------------------ | Branch (7017:13): [True: 1.97k, False: 961k] ------------------ 7018| 961k| up++; 7019| 961k| quot=*up; 7020| 961k| #if DECDPUN<=4 7021| 961k| quot=QUOT10(quot, cut); ------------------ | | 210| 961k| #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17) ------------------ 7022| 961k| rem=*up-quot*powers[cut]; ------------------ | | 177| 961k|#define powers DECPOWERS // old internal name ------------------ 7023| | #else 7024| | rem=quot%powers[cut]; 7025| | quot=quot/powers[cut]; 7026| | #endif 7027| 961k| *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 177| 961k|#define powers DECPOWERS // old internal name ------------------ *target=(Unit)(*target+rem*powers[DECDPUN-cut]); ------------------ | | 43| 961k| #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */ ------------------ 7028| 961k| count-=cut; 7029| 961k| if (count<=0) break; ------------------ | Branch (7029:13): [True: 1.44k, False: 959k] ------------------ 7030| 961k| } // shift-copy loop 7031| 3.42k| } // shift to least 7032| 3.76k| } // not unit boundary 7033| | 7034| 6.22k| if (*residue!=0) *status|=DEC_Inexact; // record inexactitude ------------------ | | 133| 5.53k| #define DEC_Inexact 0x00000020 ------------------ | Branch (7034:7): [True: 5.53k, False: 687] ------------------ 7035| 6.22k| return; 7036| 7.30k| } // decSetCoeff decNumber.c:decFinalize: 7275| 72.3k| uInt *status) { 7276| 72.3k| Int shift; // shift needed if clamping ------------------ | | 92| 72.3k| #define Int int32_t ------------------ 7277| 72.3k| Int tinyexp=set->emin-dn->digits+1; // precalculate subnormal boundary ------------------ | | 92| 72.3k| #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| 72.3k| if (dn->exponent<=tinyexp) { // prefilter ------------------ | Branch (7285:7): [True: 4.41k, False: 67.8k] ------------------ 7286| 4.41k| Int comp; ------------------ | | 92| 4.41k| #define Int int32_t ------------------ 7287| 4.41k| decNumber nmin; 7288| | // A very nasty case here is dn == Nmin and residue<0 7289| 4.41k| if (dn->exponentemin; 7298| 112| comp=decCompare(dn, &nmin, 1); // (signless compare) 7299| 112| if (comp==BADINT) { // oops ------------------ | | 194| 112|#define BADINT (Int)0x80000000 // most-negative Int; error indicator ------------------ | Branch (7299:9): [True: 0, False: 112] ------------------ 7300| 0| *status|=DEC_Insufficient_storage; // abandon... ------------------ | | 132| 0| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ ------------------ 7301| 0| return; 7302| 0| } 7303| 112| if (*residue<0 && comp==0) { // neg residue and dn==Nmin ------------------ | Branch (7303:9): [True: 0, False: 112] | 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| 112| } 7309| | 7310| | // now apply any pending round (this could raise overflow). 7311| 68.0k| if (*residue!=0) decApplyRound(dn, set, *residue, status); ------------------ | Branch (7311:7): [True: 2.57k, False: 65.4k] ------------------ 7312| | 7313| | // Check for overflow [redundant in the 'rare' case] or clamp 7314| 68.0k| if (dn->exponent<=set->emax-set->digits+1) return; // neither needed ------------------ | Branch (7314:7): [True: 64.1k, False: 3.85k] ------------------ 7315| | 7316| | 7317| | // here when might have an overflow or clamp to do 7318| 3.85k| if (dn->exponent>set->emax-dn->digits+1) { // too big ------------------ | Branch (7318:7): [True: 2.84k, False: 1.01k] ------------------ 7319| 2.84k| decSetOverflow(dn, set, status); 7320| 2.84k| return; 7321| 2.84k| } 7322| | // here when the result is normal but in clamp range 7323| 1.01k| if (!set->clamp) return; ------------------ | Branch (7323:7): [True: 135, False: 876] ------------------ 7324| | 7325| | // here when need to apply the IEEE exponent clamp (fold-down) 7326| 876| shift=dn->exponent-(set->emax-set->digits+1); 7327| | 7328| | // shift coefficient (if non-zero) 7329| 876| if (!ISZERO(dn)) { ------------------ | | 255| 876| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 876| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 438, False: 438] | | | | ------------------ | | | | 178| 876| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 151, False: 287] | | | | ------------------ | | | | 179| 876| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 151| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 151| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 151| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 151| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 151, False: 0] | | | | ------------------ | | ------------------ ------------------ 7330| 725| dn->digits=decShiftToMost(dn->lsu, dn->digits, shift); 7331| 725| } 7332| 876| dn->exponent-=shift; // adjust the exponent to match 7333| 876| *status|=DEC_Clamped; // and record the dirty deed ------------------ | | 140| 876| #define DEC_Clamped 0x00000400 ------------------ 7334| 876| return; 7335| 1.01k| } // decFinalize decNumber.c:decSetSubnormal: 7429| 4.30k| uInt *status) { 7430| 4.30k| decContext workset; // work 7431| 4.30k| Int etiny, adjust; // .. ------------------ | | 92| 4.30k| #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| 4.30k| etiny=set->emin-(set->digits-1); // smallest allowed exponent 7446| | 7447| 4.30k| if ISZERO(dn) { // value is zero ------------------ | | 255| 4.30k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 4.30k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 602, False: 3.70k] | | | | ------------------ | | | | 178| 4.30k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 356, False: 246] | | | | ------------------ | | | | 179| 4.30k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 356| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 356| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 356| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 356| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 356, 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| 356| if (dn->exponentexponent=etiny; 7457| 225| *status|=DEC_Clamped; ------------------ | | 140| 225| #define DEC_Clamped 0x00000400 ------------------ 7458| 225| } 7459| 356| return; 7460| 356| } 7461| | 7462| 3.94k| *status|=DEC_Subnormal; // have a non-zero subnormal ------------------ | | 142| 3.94k| #define DEC_Subnormal 0x00001000 ------------------ 7463| 3.94k| adjust=etiny-dn->exponent; // calculate digits to remove 7464| 3.94k| if (adjust<=0) { // not out of range; unrounded ------------------ | Branch (7464:7): [True: 30, False: 3.91k] ------------------ 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| 30| if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 133| 30| #define DEC_Inexact 0x00000020 ------------------ if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 143| 0| #define DEC_Underflow 0x00002000 ------------------ | Branch (7468:9): [True: 0, False: 30] ------------------ 7469| 30| return; 7470| 30| } 7471| | 7472| | // adjust>0, so need to rescale the result so exponent becomes Etiny 7473| | // [this code is similar to that in rescale] 7474| 3.91k| workset=*set; // clone rounding, etc. 7475| 3.91k| workset.digits=dn->digits-adjust; // set requested length 7476| 3.91k| workset.emin-=adjust; // and adjust emin to match 7477| | // [note that the latter can be <1, here, similar to Rescale case] 7478| 3.91k| decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status); 7479| 3.91k| decApplyRound(dn, &workset, *residue, status); 7480| | 7481| | // Use 754 default rule: Underflow is set iff Inexact 7482| | // [independent of whether trapped] 7483| 3.91k| if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 133| 3.91k| #define DEC_Inexact 0x00000020 ------------------ if (*status&DEC_Inexact) *status|=DEC_Underflow; ------------------ | | 143| 3.86k| #define DEC_Underflow 0x00002000 ------------------ | Branch (7483:7): [True: 3.86k, False: 52] ------------------ 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| 3.91k| if (dn->exponent>etiny) { ------------------ | Branch (7487:7): [True: 824, False: 3.09k] ------------------ 7488| 824| dn->digits=decShiftToMost(dn->lsu, dn->digits, 1); 7489| 824| dn->exponent--; // (re)adjust the exponent. 7490| 824| } 7491| | 7492| | // if rounded to zero, it is by definition clamped... 7493| 3.91k| if (ISZERO(dn)) *status|=DEC_Clamped; ------------------ | | 255| 3.91k| #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ | | ------------------ | | | | 177| 3.91k| #define decNumberIsZero(dn) (*(dn)->lsu==0 \ | | | | ------------------ | | | | | Branch (177:37): [True: 2.39k, False: 1.52k] | | | | ------------------ | | | | 178| 3.91k| && (dn)->digits==1 \ | | | | ------------------ | | | | | Branch (178:40): [True: 1.44k, False: 957] | | | | ------------------ | | | | 179| 3.91k| && (((dn)->bits&DECSPECIAL)==0)) | | | | ------------------ | | | | | | 36| 1.44k| #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 32| 1.44k| #define DECINF 0x40 /* 1=Infinity */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 33| 1.44k| #define DECNAN 0x20 /* 1=NaN */ | | | | | | ------------------ | | | | | | #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */ | | | | | | ------------------ | | | | | | | | 34| 1.44k| #define DECSNAN 0x10 /* 1=sNaN */ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (179:40): [True: 1.44k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (ISZERO(dn)) *status|=DEC_Clamped; ------------------ | | 140| 1.44k| #define DEC_Clamped 0x00000400 ------------------ 7494| 3.91k| } // decSetSubnormal decNumber.c:decStatus: 7741| 11.0k|static void decStatus(decNumber *dn, uInt status, decContext *set) { 7742| 11.0k| if (status & DEC_NaNs) { // error status -> NaN ------------------ | | 187| 11.0k| #define DEC_NaNs DEC_IEEE_754_Invalid_operation | | ------------------ | | | | 173| 11.0k| #define DEC_IEEE_754_Invalid_operation (DEC_Conversion_syntax | \ | | | | ------------------ | | | | | | 128| 11.0k| #define DEC_Conversion_syntax 0x00000001 | | | | ------------------ | | | | 174| 11.0k| DEC_Division_impossible | \ | | | | ------------------ | | | | | | 130| 11.0k| #define DEC_Division_impossible 0x00000004 | | | | ------------------ | | | | 175| 11.0k| DEC_Division_undefined | \ | | | | ------------------ | | | | | | 131| 11.0k| #define DEC_Division_undefined 0x00000008 | | | | ------------------ | | | | 176| 11.0k| DEC_Insufficient_storage | \ | | | | ------------------ | | | | | | 132| 11.0k| #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */ | | | | ------------------ | | | | 177| 11.0k| DEC_Invalid_context | \ | | | | ------------------ | | | | | | 134| 11.0k| #define DEC_Invalid_context 0x00000040 | | | | ------------------ | | | | 178| 11.0k| DEC_Invalid_operation) | | | | ------------------ | | | | | | 135| 11.0k| #define DEC_Invalid_operation 0x00000080 | | | | ------------------ | | ------------------ ------------------ | Branch (7742:7): [True: 0, False: 11.0k] ------------------ 7743| | // if cause was an sNaN, clear and propagate [NaN is already set up] 7744| 0| if (status & DEC_sNaN) status&=~DEC_sNaN; ------------------ | | 193| 0|#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: 0] ------------------ 7745| 0| else { 7746| 0| decNumberZero(dn); // other error: clean throughout 7747| 0| dn->bits=DECNAN; // and make a quiet NaN ------------------ | | 33| 0| #define DECNAN 0x20 /* 1=NaN */ ------------------ 7748| 0| } 7749| 0| } 7750| 11.0k| decContextSetStatus(set, status); // [may not return] 7751| 11.0k| return; 7752| 11.0k| } // decStatus