| line |
true |
false |
branch |
|
286
|
6 |
1 |
for (i = 0; i < sizeof(forced_byte_expl); ++i) |
|
292
|
8 |
1 |
for (i = 0; i < 8; ++i) |
|
312
|
274 |
11 |
for (i = 0; i < expl_size; ++i) |
|
325
|
76 |
0 |
*unf = TOLOWER(c); |
|
|
0 |
76 |
*unf = TOLOWER(c); |
|
326
|
76 |
0 |
unf[1] = ((*unf >= 'a') && (*unf <= 'z')) ? *unf - 'a' + 'A' : *unf; |
|
|
76 |
0 |
unf[1] = ((*unf >= 'a') && (*unf <= 'z')) ? *unf - 'a' + 'A' : *unf; |
|
337
|
8432 |
5135 |
while (mask != prev_mask) |
|
340
|
16864 |
8432 |
for (i = 0; i < 2; ++i) |
|
342
|
185504 |
16864 |
for (j = 0; j < SIZEOF_ARRAY(regclass_superset); ++j) |
|
346
|
92752 |
92752 |
if (i) |
|
355
|
21807 |
163697 |
if (mask & b) |
|
376
|
0 |
0 |
if (p == desc) |
|
382
|
0 |
0 |
while (p) |
|
385
|
0 |
0 |
for (i = 0; i < SIZEOF_ARRAY(regclass_names); ++i) |
|
387
|
0 |
0 |
if (!strncmp(p + 6, regclass_names[i], strlen(regclass_names[i]))) |
|
389
|
0 |
0 |
if (sign == '+') |
|
391
|
0 |
0 |
if (mask & (regclass_blocks[i] << MIRROR_SHIFT)) |
|
393
|
0 |
0 |
*map = invert ? 0 : EVERY_BLOCK; |
|
399
|
0 |
0 |
else if (sign == '!') |
|
401
|
0 |
0 |
if (mask & regclass_blocks[i]) |
|
403
|
0 |
0 |
*map = invert ? 0 : EVERY_BLOCK; |
|
422
|
0 |
0 |
if ((mask & ALPHA_BLOCK) && (mask & NUMBER_BLOCK)) |
|
|
0 |
0 |
if ((mask & ALPHA_BLOCK) && (mask & NUMBER_BLOCK)) |
|
427
|
0 |
0 |
if (invert) |
|
432
|
0 |
0 |
if ((mask & ALPHA_BLOCK) && (mask & NUMBER_BLOCK)) |
|
|
0 |
0 |
if ((mask & ALPHA_BLOCK) && (mask & NUMBER_BLOCK)) |
|
451
|
189 |
0 |
: (SvCUR(invlist) / sizeof(UV)) - *get_invlist_offset_addr(invlist); |
|
518
|
83 |
0 |
ila = ill ? invlist_array(invlist) : 0; |
|
523
|
0 |
0 |
if (!memcmp(ila, perl_space_invlist, sizeof(perl_space_invlist))) |
|
534
|
0 |
0 |
if (!memcmp(ila, perl_space_invlist + 1, |
|
546
|
83 |
0 |
if (!memcmp(ila, perl_space_short_invlist, sizeof(perl_space_short_invlist))) |
|
557
|
0 |
0 |
if (!memcmp(ila, horizontal_space_invlist, sizeof(horizontal_space_invlist))) |
|
568
|
0 |
0 |
if (!memcmp(ila, horizontal_space_invlist + 1, |
|
580
|
0 |
0 |
if (!memcmp(ila, vertical_space_invlist, sizeof(vertical_space_invlist))) |
|
591
|
0 |
0 |
if (!memcmp(ila, vertical_space_invlist + 1, |
|
603
|
0 |
0 |
if (!memcmp(ila, xposix_digit_invlist, sizeof(xposix_digit_invlist))) |
|
614
|
0 |
0 |
if (!memcmp(ila, xposix_digit_invlist + 1, |
|
626
|
0 |
0 |
if (!memcmp(ila, xposix_alnum_invlist, sizeof(xposix_alnum_invlist))) |
|
637
|
0 |
0 |
if (!memcmp(ila, xposix_alnum_invlist + 1, |
|
649
|
0 |
0 |
if (!memcmp(ila, xposix_alpha_invlist, sizeof(xposix_alpha_invlist))) |
|
660
|
0 |
0 |
if (!memcmp(ila, xposix_alpha_invlist + 1, |
|
672
|
0 |
0 |
if (!memcmp(ila, xposix_word_invlist, sizeof(xposix_word_invlist))) |
|
683
|
0 |
0 |
if (!memcmp(ila, xposix_word_invlist + 1, |
|
695
|
0 |
0 |
if (!memcmp(ila, xposix_xdigit_invlist, sizeof(xposix_xdigit_invlist))) |
|
706
|
0 |
0 |
if (!memcmp(ila, xposix_xdigit_invlist + 1, |
|
718
|
83 |
0 |
if (mask) |
|
720
|
83 |
0 |
if (invert) |
|
758
|
0 |
85 |
if (!pr) /* this should have been tested by find_internal during |
|
767
|
85 |
0 |
if ((n < rdata->count) && |
|
768
|
85 |
0 |
(rdata->what[n] == 's')) { |
|
776
|
83 |
2 |
if (si) /* not so unconditional in Perl 5.32 */ |
|
801
|
108 |
0 |
if (data && data->count) |
|
|
108 |
0 |
if (data && data->count) |
|
805
|
108 |
0 |
if (data->what[n] == 's') |
|
827
|
85 |
4 |
if (ANYOF_FLAGS(a->rn) & (ANYOF_HAS_EXTRA_RUNTIME_MATCHES | ANYOF_INVERT)) |
|
846
|
0 |
5245 |
if (FLAGS(a->rn) >= SIZEOF_ARRAY(posix_regclass_blocks)) |
|
853
|
0 |
5245 |
if (!mask) |
|
873
|
410 |
0 |
if ((start != FLAGS(n)) || ((start + delta) >= 256)) /* UTF-8 not supported */ |
|
|
0 |
410 |
if ((start != FLAGS(n)) || ((start + delta) >= 256)) /* UTF-8 not supported */ |
|
880
|
2217 |
410 |
for (i = 0; i <= delta; i++) |
|
902
|
21908 |
0 |
for (i = lowest; i <= 0xFF; i++) |
|
904
|
2130 |
19778 |
if ((i & FLAGS(n)) == ARG_LOC(n)) |
|
909
|
1187 |
943 |
if (++count >= needed) |
|
922
|
0 |
4102 |
if (!convert_class_narrow(a, map)) |
|
935
|
0 |
950 |
if (!convert_class_narrow(a, &mask)) |
|
949
|
0 |
658 |
if (offs <= 2) |
|
963
|
0 |
6 |
if (arg < 0) |
|
974
|
0 |
6 |
if (NEXT_OFF(p) < 2) |
|
987
|
1577 |
1484 |
if (((OP(p) == EXACT) || (OP(p) == EXACTF) || (OP(p) == EXACTFU)) && |
|
|
1577 |
0 |
if (((OP(p) == EXACT) || (OP(p) == EXACTF) || (OP(p) == EXACTFU)) && |
|
|
0 |
1577 |
if (((OP(p) == EXACT) || (OP(p) == EXACTF) || (OP(p) == EXACTFU)) && |
|
988
|
1484 |
0 |
(FLAGS(p) == 1)) |
|
992
|
536 |
1041 |
else if (trivial_nodes[OP(p)] || |
|
993
|
473 |
63 |
(OP(p) == REG_ANY) || (OP(p) == SANY) || |
|
|
442 |
31 |
(OP(p) == REG_ANY) || (OP(p) == SANY) || |
|
994
|
384 |
58 |
(OP(p) == POSIXD) || (OP(p) == NPOSIXD) || |
|
|
352 |
32 |
(OP(p) == POSIXD) || (OP(p) == NPOSIXD) || |
|
995
|
280 |
72 |
(OP(p) == POSIXU) || (OP(p) == NPOSIXU) || |
|
|
277 |
3 |
(OP(p) == POSIXU) || (OP(p) == NPOSIXU) || |
|
996
|
198 |
79 |
(OP(p) == POSIXA) || (OP(p) == NPOSIXA) || |
|
|
189 |
9 |
(OP(p) == POSIXA) || (OP(p) == NPOSIXA) || |
|
997
|
4 |
185 |
(OP(p) == LNBREAK)) |
|
1001
|
161 |
24 |
else if ((OP(p) == ANYOF) || (OP(p) == ANYOFD)) |
|
|
91 |
70 |
else if ((OP(p) == ANYOF) || (OP(p) == ANYOFD)) |
|
1007
|
0 |
115 |
if (unknown) |
|
1018
|
10 |
60 |
else if (OP(p) == ANYOFR) |
|
1022
|
35 |
25 |
else if (OP(p) == ANYOFM) |
|
1026
|
19 |
6 |
else if (OP(p) == NANYOFM) |
|
1030
|
2 |
4 |
else if ((OP(p) == IFMATCH) || (OP(p) == UNLESSM) || |
|
|
0 |
2 |
else if ((OP(p) == IFMATCH) || (OP(p) == UNLESSM) || |
|
1031
|
0 |
0 |
(OP(p) == SUSPEND)) |
|
1046
|
4158 |
2930 |
while (OP(e) != END) |
|
1048
|
4050 |
108 |
offs = GET_OFFSET(e); |
|
1049
|
0 |
4158 |
if (offs <= 0) |
|
1076
|
18322 |
0 |
if (pt->engine && (pt->engine != &PL_core_reg_engine)) |
|
|
0 |
18322 |
if (pt->engine && (pt->engine != &PL_core_reg_engine)) |
|
1084
|
0 |
18322 |
if (!pr) |
|
1091
|
0 |
18322 |
if (!p) |
|
1097
|
18322 |
0 |
if (!((FLAGS(p) == REG_MAGIC) && |
|
1098
|
0 |
18322 |
(NEXT_OFF(p) == 0))) |
|
1130
|
216 |
0 |
if (('0' <= d) && (d <= '9')) |
|
|
149 |
67 |
if (('0' <= d) && (d <= '9')) |
|
1161
|
117725 |
18336 |
for (i = 0; i < prelen; ++i) |
|
1165
|
1252 |
116473 |
if (c == '.') |
|
1173
|
105671 |
12054 |
if (!quoted) |
|
1177
|
12054 |
93617 |
if (c == '\\') |
|
1186
|
441 |
11613 |
if (c == 'N') |
|
1189
|
24 |
417 |
if ((i + 8 < prelen) && |
|
1190
|
11 |
13 |
!memcmp(precomp + i + 1, "{U+00", 5) && |
|
1191
|
11 |
0 |
isxdigit(precomp[i + 6]) && isxdigit(precomp[i + 7]) && |
|
|
11 |
0 |
isxdigit(precomp[i + 6]) && isxdigit(precomp[i + 7]) && |
|
1192
|
11 |
0 |
(precomp[i + 8] == '}')) |
|
1195
|
5 |
6 |
if ((x != '\r') && (x != '\n')) |
|
|
0 |
5 |
if ((x != '\r') && (x != '\n')) |
|
1202
|
220 |
210 |
else if ((i + 1 < prelen) && |
|
1203
|
13 |
207 |
(precomp[i + 1] == '{')) |
|
1213
|
117 |
11496 |
else if (c == 'x') |
|
1215
|
117 |
0 |
if ((i + 2 < prelen) && |
|
1216
|
97 |
20 |
isxdigit(precomp[i + 1]) && isxdigit(precomp[i + 2])) |
|
|
97 |
0 |
isxdigit(precomp[i + 1]) && isxdigit(precomp[i + 2])) |
|
1219
|
88 |
9 |
if ((x != '\r') && (x != '\n')) |
|
|
85 |
3 |
if ((x != '\r') && (x != '\n')) |
|
1232
|
11516 |
538 |
if (!matched) |
|
1235
|
340 |
11176 |
if (forced_byte[bf.offs] & bf.mask) |
|
1253
|
0 |
921 |
if (!alt) |
|
1273
|
0 |
384 |
if (!alt) |
|
1280
|
384 |
0 |
if ((last >= REGNODE_MAX) || !trivial_nodes[last]) |
|
|
0 |
384 |
if ((last >= REGNODE_MAX) || !trivial_nodes[last]) |
|
1297
|
14077 |
1479 |
offs = GET_OFFSET(a->rn); |
|
1298
|
0 |
15556 |
if (offs <= 0) |
|
1303
|
12 |
15544 |
if (OP(a->rn) == EXACT_REQ8) |
|
1305
|
18 |
12 |
while (*(((unsigned char *)((a)->rn + 1)) + (a)->spent) & 0x80) |
|
1311
|
10225 |
5331 |
if (++(a->spent) >= FLAGS(a->rn)) |
|
1329
|
17620 |
1464 |
offs = GET_OFFSET(a->rn); |
|
1330
|
0 |
19084 |
if (offs <= 0) |
|
1341
|
74 |
32740 |
if (OP(a->rn) == END) |
|
1345
|
18025 |
14715 |
else if ((OP(a->rn) == EXACT) || (OP(a->rn) == EXACTF) || |
|
|
17774 |
251 |
else if ((OP(a->rn) == EXACT) || (OP(a->rn) == EXACTF) || |
|
1346
|
17196 |
578 |
(OP(a->rn) == EXACTFU) || (OP(a->rn) == EXACT_REQ8)) |
|
|
12 |
17184 |
(OP(a->rn) == EXACTFU) || (OP(a->rn) == EXACT_REQ8)) |
|
1363
|
92 |
0 |
offs = GET_OFFSET(p); |
|
1364
|
0 |
92 |
if (offs <= 0) |
|
1370
|
32 |
92 |
while (trivial_nodes[OP(q)]) |
|
1372
|
22 |
10 |
offs = GET_OFFSET(q); |
|
1373
|
0 |
32 |
if (offs <= 0) |
|
1388
|
0 |
18343 |
if (!rs) |
|
1394
|
0 |
18338 |
if (!rx) |
|
1404
|
18338 |
0 |
if (rx) |
|
1416
|
679 |
5664 |
if (anchored) |
|
1423
|
74 |
5590 |
if (rv <= 0) |
|
1440
|
0 |
13072 |
if (rv <= 0) |
|
1447
|
0 |
13072 |
if (rv <= 0) |
|
1453
|
0 |
13072 |
if (rv < 0) |
|
1458
|
265 |
12807 |
if (!rv) |
|
1478
|
0 |
826 |
if (rv <= 0) |
|
1494
|
0 |
268 |
if (offs < 0) |
|
1522
|
0 |
83 |
if (sz1 < 0) |
|
1528
|
0 |
83 |
if (sz2 < 0) |
|
1534
|
0 |
83 |
if (!alt1) |
|
1540
|
0 |
83 |
if (!alt2) |
|
1557
|
1 |
82 |
if (rv <= 0) |
|
1582
|
0 |
77 |
if (sz1 < 0) |
|
1588
|
0 |
77 |
if (sz2 < 0) |
|
1594
|
0 |
77 |
if (!alt1) |
|
1600
|
0 |
77 |
if (!alt2) |
|
1617
|
2 |
75 |
if (rv <= 0) |
|
1641
|
0 |
3 |
if (b1 < 0) |
|
1647
|
0 |
3 |
if (b2 < 0) |
|
1652
|
0 |
3 |
if (b1 != b2) |
|
1658
|
0 |
3 |
if (sz1 < 0) |
|
1664
|
0 |
3 |
if (sz2 < 0) |
|
1669
|
3 |
0 |
if ((sz1 == 2) && (sz2 == 2)) |
|
|
3 |
0 |
if ((sz1 == 2) && (sz2 == 2)) |
|
1691
|
0 |
32 |
if (sz1 < 0) |
|
1697
|
0 |
32 |
if (sz2 < 0) |
|
1703
|
0 |
32 |
if (!alt1) |
|
1709
|
0 |
32 |
if (!alt2) |
|
1726
|
1 |
31 |
if (rv <= 0) |
|
1745
|
8 |
629 |
if (anchored) |
|
1750
|
0 |
629 |
if (bump_regular(a1) <= 0) |
|
1756
|
62 |
567 |
if (!rv) |
|
1772
|
5136 |
5734 |
if ((i >= 16) && (OP(p) == ANYOFD) && |
|
|
4224 |
912 |
if ((i >= 16) && (OP(p) == ANYOFD) && |
|
1773
|
1120 |
3104 |
(FLAGS(p) & ANYOFD_NON_UTF8_MATCHES_ALL_NON_ASCII__shared)) |
|
1782
|
5768 |
5102 |
if (FLAGS(p) & ANYOF_INVERT) |
|
1802
|
26542 |
813 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
1804
|
23152 |
3390 |
loc1 = b1 ? b1[i] : get_bitmap_byte(a1->rn, i); |
|
1805
|
19575 |
6967 |
loc2 = b2 ? b2[i] : get_bitmap_byte(a2->rn, i); |
|
1806
|
118 |
26424 |
if (loc1 & ~loc2) |
|
1824
|
2453 |
68 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
1828
|
77 |
2376 |
if (~loc1 & loc2) |
|
1850
|
4 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
1852
|
1 |
3 |
req = (i != bf.offs) ? 0 : bf.mask; |
|
1853
|
3 |
1 |
if (get_bitmap_byte(a1->rn, i) != req) |
|
1860
|
0 |
0 |
if (bump_regular(&tail1) <= 0) |
|
1866
|
0 |
0 |
if (bump_regular(&tail2) <= 0) |
|
1885
|
0 |
2 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
1891
|
4 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
1893
|
2 |
2 |
req = (i != bf.offs) ? 0 : bf.mask; |
|
1894
|
2 |
2 |
if (left[i] != req) |
|
1901
|
0 |
0 |
if (bump_regular(&tail1) <= 0) |
|
1907
|
0 |
0 |
if (bump_regular(&tail2) <= 0) |
|
1926
|
0 |
3 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
1932
|
6 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
1934
|
3 |
3 |
req = (i != bf.offs) ? 0 : bf.mask; |
|
1935
|
3 |
3 |
if (left[i] != req) |
|
1942
|
0 |
0 |
if (bump_regular(&tail1) <= 0) |
|
1948
|
0 |
0 |
if (bump_regular(&tail2) <= 0) |
|
1967
|
0 |
2 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
1972
|
64 |
2 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
1978
|
2 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
1980
|
0 |
2 |
req = (i != bf.offs) ? 0 : bf.mask; |
|
1981
|
2 |
0 |
if (left[i] != req) |
|
1988
|
0 |
0 |
if (bump_regular(&tail1) <= 0) |
|
1994
|
0 |
0 |
if (bump_regular(&tail2) <= 0) |
|
2013
|
54 |
27 |
if (extra_left) |
|
2023
|
54 |
0 |
if ((FLAGS(a1->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES) && |
|
2024
|
54 |
0 |
(FLAGS(a2->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES)) |
|
2028
|
53 |
1 |
if (invlist1 && invlist2) |
|
|
53 |
0 |
if (invlist1 && invlist2) |
|
2032
|
53 |
0 |
if (ill1 && (ill1 == ill2)) |
|
|
53 |
0 |
if (ill1 && (ill1 == ill2)) |
|
2036
|
53 |
0 |
if (!memcmp(ila1, ila2, ill1 * sizeof(UV))) |
|
2045
|
0 |
1 |
if (cr1 == -1) |
|
2051
|
0 |
1 |
if (cr2 == -1) |
|
2058
|
0 |
1 |
if (m2 & NOT_ALNUM_BLOCK) |
|
2064
|
0 |
1 |
if (!cr1 || !cr2 || (m1 & ~m2)) |
|
|
0 |
0 |
if (!cr1 || !cr2 || (m1 & ~m2)) |
|
|
0 |
0 |
if (!cr1 || !cr2 || (m1 & ~m2)) |
|
2084
|
0 |
3 |
if (ANYOF_FLAGS(a1->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES) |
|
2089
|
0 |
3 |
if (!convert_anyofr_to_bitmap(a2, right)) |
|
2105
|
0 |
2 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
2110
|
0 |
2 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2126
|
0 |
77 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
2131
|
0 |
77 |
if (!convert_anyofr_to_bitmap(a2, right)) |
|
2147
|
0 |
4 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
2152
|
0 |
4 |
if (!convert_anyofr_to_bitmap(a2, right)) |
|
2169
|
0 |
6 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
2186
|
0 |
0 |
if (ANYOF_FLAGS(a1->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES) |
|
2191
|
0 |
0 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2208
|
0 |
18 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
2224
|
0 |
150 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
2229
|
0 |
150 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2249
|
3 |
0 |
if ((FLAGS(a1->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES) || |
|
2250
|
1 |
2 |
((FLAGS(a1->rn) & ANYOFD_NON_UTF8_MATCHES_ALL_NON_ASCII__shared) && |
|
2251
|
0 |
1 |
!(FLAGS(a1->rn) & ANYOF_INVERT))) |
|
2256
|
0 |
3 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2261
|
96 |
3 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
2278
|
0 |
1 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
2283
|
0 |
1 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2288
|
32 |
1 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
2305
|
0 |
3 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
2310
|
0 |
3 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2315
|
96 |
3 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
2331
|
0 |
41 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
2336
|
0 |
41 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2353
|
0 |
0 |
for (i = 0; i < left->expl_size; ++i) |
|
2356
|
0 |
0 |
if (!(get_bitmap_byte(a2->rn, bf.offs) & bf.mask)) |
|
2369
|
0 |
0 |
for (i = 0; i < 16; ++i) |
|
2371
|
0 |
0 |
if (!(get_bitmap_byte(a2->rn, i) & 0xff)) |
|
2389
|
1413 |
0 |
if (!cr1 || !cr2 || (m1 & ~m2)) |
|
|
1413 |
0 |
if (!cr1 || !cr2 || (m1 & ~m2)) |
|
|
262 |
1151 |
if (!cr1 || !cr2 || (m1 & ~m2)) |
|
2406
|
638 |
0 |
if (!cr1 || !cr2) |
|
|
0 |
638 |
if (!cr1 || !cr2) |
|
2413
|
73 |
565 |
if ((m1 & VERTICAL_SPACE_BLOCK) && !(m2 & VERTICAL_SPACE_BLOCK)) |
|
|
69 |
4 |
if ((m1 & VERTICAL_SPACE_BLOCK) && !(m2 & VERTICAL_SPACE_BLOCK)) |
|
2418
|
169 |
469 |
if (m1 & m2) |
|
2440
|
475 |
0 |
if (!cr2 || !cr2 || (m1 & ~m2)) |
|
|
475 |
0 |
if (!cr2 || !cr2 || (m1 & ~m2)) |
|
|
118 |
357 |
if (!cr2 || !cr2 || (m1 & ~m2)) |
|
2459
|
69 |
921 |
if (!generic_isCC_A_(*seq, FLAGS(a2->rn))) |
|
2479
|
2 |
1 |
for (i = 0; i < 2; ++i) |
|
2481
|
0 |
2 |
if (!generic_isCC_A_(unf[i], FLAGS(a2->rn))) |
|
2500
|
16 |
646 |
if (generic_isCC_A_(*seq, FLAGS(a2->rn))) |
|
2521
|
8 |
4 |
for (i = 0; i < 2; ++i) |
|
2523
|
0 |
8 |
if (generic_isCC_A_(unf[i], FLAGS(a2->rn))) |
|
2551
|
0 |
138 |
if (!convert_class_narrow(a1, &left_block)) |
|
2558
|
66 |
72 |
if (!(FLAGS(a2->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES)) |
|
2563
|
0 |
66 |
if (cr == -1) |
|
2568
|
66 |
0 |
if (!cr || !(right_map & left_block)) |
|
|
16 |
50 |
if (!cr || !(right_map & left_block)) |
|
2576
|
0 |
122 |
if (FLAGS(a1->rn) >= SIZEOF_ARRAY(posix_regclass_bitmaps)) |
|
2582
|
0 |
122 |
if (!b) |
|
2601
|
0 |
55 |
if (!convert_class_narrow(a1, &left_block)) |
|
2612
|
21 |
34 |
if (!(FLAGS(a2->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES)) |
|
2617
|
0 |
21 |
if (cr == -1) |
|
2622
|
18 |
3 |
if (FLAGS(a2->rn) & ANYOF_INVERT) |
|
2629
|
21 |
0 |
if (!cr || !(right_map & left_block)) |
|
|
3 |
18 |
if (!cr || !(right_map & left_block)) |
|
2635
|
0 |
52 |
if (FLAGS(a1->rn) >= SIZEOF_ARRAY(posix_regclass_bitmaps)) |
|
2641
|
0 |
52 |
if (!b) |
|
2662
|
9 |
317 |
if (!(get_bitmap_byte(a2->rn, bf.offs) & bf.mask)) |
|
2685
|
10 |
0 |
for (i = 0; i < 2; ++i) |
|
2688
|
6 |
4 |
if (!(get_bitmap_byte(a2->rn, bf.offs) & bf.mask)) |
|
2711
|
0 |
152 |
if (!convert_anyofr_to_bitmap(a2, right)) |
|
2716
|
143 |
9 |
if (right[bf.offs] & bf.mask) |
|
2740
|
0 |
18 |
if (!convert_anyofr_to_bitmap(a2, right)) |
|
2745
|
30 |
0 |
for (i = 0; i < 2; ++i) |
|
2748
|
18 |
12 |
if (!(right[bf.offs] & bf.mask)) |
|
2771
|
0 |
155 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2776
|
136 |
19 |
if (right[bf.offs] & bf.mask) |
|
2800
|
0 |
8 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2805
|
15 |
7 |
for (i = 0; i < 2; ++i) |
|
2808
|
1 |
14 |
if (!(right[bf.offs] & bf.mask)) |
|
2829
|
0 |
119 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2834
|
0 |
119 |
if (right[bf.offs] & bf.mask) |
|
2856
|
0 |
5 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2861
|
160 |
5 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
2866
|
10 |
5 |
for (i = 0; i < 2; ++i) |
|
2869
|
0 |
10 |
if (!(right[bf.offs] & bf.mask)) |
|
2888
|
0 |
94 |
if (FLAGS(a1->rn) >= SIZEOF_ARRAY(posix_regclass_bitmaps)) |
|
2894
|
0 |
94 |
if (!b) |
|
2899
|
0 |
94 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2904
|
3008 |
94 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
2922
|
0 |
49 |
if (FLAGS(a1->rn) >= SIZEOF_ARRAY(posix_regclass_bitmaps)) |
|
2929
|
0 |
49 |
if (!b) |
|
2934
|
0 |
49 |
if (!convert_anyofm_to_bitmap(a2, right)) |
|
2954
|
4 |
5 |
if ((*cur == '\r') && ((a1->spent + 1) < FLAGS(a1->rn))) |
|
|
2 |
2 |
if ((*cur == '\r') && ((a1->spent + 1) < FLAGS(a1->rn))) |
|
2959
|
2 |
0 |
if (*next == '\n') |
|
2967
|
3 |
4 |
if (!generic_isCC_A_(*cur, CC_VERTSPACE_)) |
|
2985
|
31 |
552 |
if (!lookup[(unsigned char)(*seq)]) |
|
3031
|
0 |
8 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
3046
|
0 |
66 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
3061
|
0 |
12 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
3096
|
0 |
6 |
if (FLAGS(a2->rn) >= SIZEOF_ARRAY(posix_regclass_bitmaps)) |
|
3103
|
0 |
6 |
if (!b) |
|
3123
|
0 |
20 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
3129
|
0 |
20 |
if (!b) |
|
3148
|
0 |
101 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
3154
|
0 |
101 |
if (!b) |
|
3171
|
0 |
30 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
3177
|
0 |
30 |
if (!b) |
|
3194
|
0 |
0 |
if (ANYOF_FLAGS(a1->rn) & ANYOF_HAS_EXTRA_RUNTIME_MATCHES) |
|
3199
|
0 |
0 |
if (FLAGS(a2->rn) >= SIZEOF_ARRAY(posix_regclass_bitmaps)) |
|
3206
|
0 |
0 |
if (!b) |
|
3225
|
0 |
11 |
if (FLAGS(a2->rn) >= SIZEOF_ARRAY(posix_regclass_nbitmaps)) |
|
3232
|
0 |
11 |
if (!b) |
|
3252
|
0 |
11 |
if (!convert_anyofr_to_bitmap(a1, anyof_bitmap)) |
|
3257
|
0 |
11 |
if (FLAGS(a2->rn) >= SIZEOF_ARRAY(posix_regclass_nbitmaps)) |
|
3264
|
0 |
11 |
if (!posix_bitmap) |
|
3284
|
0 |
73 |
if (!convert_anyofm_to_bitmap(a1, anyof_bitmap)) |
|
3289
|
0 |
73 |
if (FLAGS(a2->rn) >= SIZEOF_ARRAY(posix_regclass_nbitmaps)) |
|
3296
|
0 |
73 |
if (!posix_bitmap) |
|
3314
|
0 |
13 |
if (!convert_anyofm_to_bitmap(a1, anyof_bitmap)) |
|
3319
|
0 |
13 |
if (FLAGS(a2->rn) >= SIZEOF_ARRAY(posix_regclass_bitmaps)) |
|
3325
|
0 |
13 |
if (!posix_bitmap) |
|
3340
|
0 |
280 |
if (flags >= SIZEOF_ARRAY(newline_posix_regclasses)) |
|
3347
|
54 |
226 |
if (newline_posix_regclasses[flags]) |
|
3362
|
0 |
121 |
if (flags >= SIZEOF_ARRAY(newline_posix_regclasses)) |
|
3368
|
82 |
39 |
if (!newline_posix_regclasses[flags]) |
|
3382
|
8 |
18 |
if (FLAGS(a1->rn) != CC_VERTSPACE_) |
|
3403
|
0 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
3405
|
0 |
0 |
req = (i != bf.offs) ? 0 : bf.mask; |
|
3406
|
0 |
0 |
if (get_bitmap_byte(a1->rn, i) != req) |
|
3426
|
0 |
11 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
3434
|
117 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
3436
|
11 |
106 |
req = (i != bf.offs) ? 0 : bf.mask; |
|
3437
|
11 |
106 |
if (left[i] != req) |
|
3457
|
0 |
17 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
3465
|
151 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
3467
|
1 |
150 |
req = (i != bf.offs) ? 0 : bf.mask; |
|
3468
|
17 |
134 |
if (left[i] != req) |
|
3491
|
0 |
0 |
for (i = 0; i < 2; ++i) |
|
3496
|
0 |
0 |
if (bf[0].offs == bf[1].offs) |
|
3502
|
0 |
0 |
for (i = 0; i < 2; ++i) |
|
3524
|
0 |
1 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
3533
|
2 |
1 |
for (i = 0; i < 2; ++i) |
|
3556
|
0 |
1 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
3565
|
2 |
1 |
for (i = 0; i < 2; ++i) |
|
3584
|
2577 |
4284 |
if (*q1 != *q2) |
|
3604
|
6 |
12 |
if ((*q1 != unf[0]) && (*q1 != unf[1])) |
|
|
5 |
1 |
if ((*q1 != unf[0]) && (*q1 != unf[1])) |
|
3624
|
3 |
11 |
if ((unf[0] != *q2) || (unf[1] != *q2)) |
|
|
3 |
0 |
if ((unf[0] != *q2) || (unf[1] != *q2)) |
|
3643
|
429 |
0 |
l1 = TOLOWER(*q1); |
|
|
0 |
429 |
l1 = TOLOWER(*q1); |
|
3644
|
429 |
0 |
l2 = TOLOWER(*q2); |
|
|
0 |
429 |
l2 = TOLOWER(*q2); |
|
3646
|
54 |
375 |
if (l1 != l2) |
|
3668
|
1257 |
580 |
while (OP(p1) == BRANCH) |
|
3670
|
0 |
1257 |
if (NEXT_OFF(p1) == 0) |
|
3685
|
0 |
1257 |
if (rv < 0) |
|
3690
|
37 |
1220 |
if (!rv) |
|
3703
|
0 |
580 |
if (tsz <= 0) |
|
3721
|
38 |
0 |
offs = GET_OFFSET(a1->rn); |
|
3722
|
0 |
38 |
if (offs <= 0) |
|
3729
|
0 |
38 |
if (sz < 0) |
|
3735
|
0 |
38 |
if (!alt) |
|
3750
|
1197 |
37 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
3752
|
1069 |
128 |
loc = b1 ? b1[i] : get_bitmap_byte(a1->rn, i); |
|
3753
|
592 |
605 |
if ((i >= 16) && loc) |
|
|
0 |
592 |
if ((i >= 16) && loc) |
|
3760
|
9572 |
1196 |
for (j = 0; j < 8; ++j) |
|
3762
|
256 |
9316 |
if (loc & power) |
|
3772
|
0 |
256 |
if (rv < 0) |
|
3778
|
1 |
255 |
if (!rv) |
|
3791
|
0 |
37 |
if (!right.rn) |
|
3822
|
0 |
14 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
3837
|
0 |
20 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
3860
|
3273 |
579 |
while ((OP(p2) == BRANCH) && !rv) |
|
|
2379 |
894 |
while ((OP(p2) == BRANCH) && !rv) |
|
3867
|
0 |
2379 |
if (NEXT_OFF(p2) == 0) |
|
3882
|
0 |
1473 |
if (rv < 0) |
|
3887
|
134 |
1339 |
if (!rv) |
|
3913
|
0 |
414 |
if (sz < 0) |
|
3922
|
414 |
0 |
offs = GET_OFFSET(p2); |
|
3923
|
0 |
414 |
if (offs <= 0) |
|
3933
|
0 |
414 |
if (rv < 0) |
|
3938
|
9 |
405 |
if (rv == 0) |
|
3944
|
0 |
9 |
if (rv < 0) |
|
3949
|
4 |
5 |
if (!rv) |
|
3957
|
0 |
5 |
if (!anchored) |
|
3963
|
0 |
410 |
if (rv <= 0) |
|
3995
|
126 |
13 |
if (rv) |
|
4000
|
13 |
0 |
offs = GET_OFFSET(p1); |
|
4002
|
0 |
13 |
if (offs <= 0) |
|
4036
|
140 |
16 |
if (rv) |
|
4041
|
16 |
0 |
offs = GET_OFFSET(p2); |
|
4043
|
0 |
16 |
if (offs <= 0) |
|
4064
|
0 |
310 |
if (sz < 0) |
|
4073
|
310 |
0 |
offs = GET_OFFSET(p2); |
|
4074
|
0 |
310 |
if (offs <= 0) |
|
4084
|
0 |
310 |
if (rv < 0) |
|
4089
|
4 |
306 |
if (rv == 0) |
|
4092
|
0 |
4 |
if (!alt) |
|
4101
|
0 |
4 |
if (rv < 0) |
|
4107
|
2 |
2 |
if (!rv) |
|
4114
|
2 |
0 |
if (cnt[1] < INFINITE_COUNT) |
|
4119
|
1 |
1 |
if ((cnt[1] > 0) && !anchored) |
|
|
0 |
1 |
if ((cnt[1] > 0) && !anchored) |
|
4134
|
0 |
308 |
if (rv <= 0) |
|
4157
|
0 |
505 |
if (sz < 0) |
|
4162
|
0 |
505 |
if (sz < 2) |
|
4169
|
0 |
505 |
if (!alt) |
|
4174
|
14 |
491 |
if (anchored) |
|
4177
|
0 |
14 |
if (offs <= 0) |
|
4183
|
6 |
8 |
if (OP(q) != END) |
|
4204
|
4 |
2 |
if (rv <= 0) |
|
4234
|
0 |
275 |
if (sz < 0) |
|
4239
|
0 |
275 |
if (sz < 2) |
|
4253
|
0 |
275 |
if (rv < 0) |
|
4258
|
24 |
251 |
if (!rv) |
|
4272
|
0 |
1271 |
if (bump_regular(a2) <= 0) |
|
4294
|
0 |
21 |
if (!cnt[0]) |
|
4307
|
9 |
12 |
if (cnt[0] > 1) |
|
4336
|
11 |
19 |
if (!rv) |
|
4359
|
2 |
39 |
if (cnt[0] > 1) /* FIXME: fails '(?:aa)+' => 'a{2,}' */ |
|
4368
|
35 |
4 |
if (cnt[1] != INFINITE_COUNT) |
|
4371
|
0 |
35 |
if (offs <= 0) |
|
4377
|
0 |
35 |
if (OP(e2) != END) |
|
4388
|
0 |
39 |
return (!rv && !cnt[0]) ? compare_next(anchored, a1, a2) : rv; |
|
|
0 |
0 |
return (!rv && !cnt[0]) ? compare_next(anchored, a1, a2) : rv; |
|
4404
|
159 |
220 |
if (altcnt[1] < INFINITE_COUNT) |
|
4425
|
8 |
642 |
if (!cnt[0]) |
|
4432
|
0 |
642 |
if (sz < 0) |
|
4437
|
0 |
642 |
if (sz <= RC_CURLY_REGNODE_SIZE) |
|
4443
|
342 |
300 |
if (cnt[0] > 1) |
|
4447
|
342 |
0 |
offs = GET_OFFSET(p1); |
|
4448
|
0 |
342 |
if (offs < 0) |
|
4453
|
0 |
342 |
if (offs <= RC_CURLY_REGNODE_SIZE) |
|
4460
|
0 |
342 |
if (!alt) |
|
4479
|
48 |
252 |
if (anchored && !((cnt[0] == 1) && (cnt[1] == 1))) |
|
|
48 |
0 |
if (anchored && !((cnt[0] == 1) && (cnt[1] == 1))) |
|
|
7 |
41 |
if (anchored && !((cnt[0] == 1) && (cnt[1] == 1))) |
|
4484
|
0 |
7 |
if (!alt) |
|
4490
|
0 |
7 |
if (offs <= 0) |
|
4496
|
0 |
7 |
if (OP(q) != END) |
|
4517
|
0 |
0 |
if (rv <= 0) |
|
4547
|
166 |
310 |
if (cnt[0] > 0) |
|
4551
|
0 |
166 |
if (sz < 0) |
|
4556
|
0 |
166 |
if (sz <= RC_CURLY_REGNODE_SIZE) |
|
4568
|
0 |
166 |
if (rv < 0) |
|
4573
|
24 |
142 |
if (!rv) |
|
4577
|
0 |
24 |
if (rv) |
|
4584
|
16 |
8 |
if (cnt[0] > 1) |
|
4586
|
16 |
0 |
offs = GET_OFFSET(p2); |
|
4587
|
0 |
16 |
if (offs < 0) |
|
4592
|
0 |
16 |
if (offs < 3) |
|
4599
|
0 |
16 |
if (!alt) |
|
4622
|
81 |
61 |
if (cnt[0] == 1) |
|
4627
|
40 |
21 |
if (OP(a1->rn) == END) |
|
4640
|
0 |
21 |
if (!alt) |
|
4647
|
21 |
0 |
if (altcnt[1] > 0) |
|
4662
|
2 |
19 |
if (rv <= 0) |
|
4696
|
5 |
342 |
if (cnt2[0] > cnt1[0]) /* FIXME: fails '(?:aa){1,}' => 'a{2,}' */ |
|
4706
|
36 |
306 |
if (cnt1[1] > cnt2[1]) |
|
4710
|
0 |
36 |
if (offs <= 0) |
|
4717
|
3 |
33 |
if (OP(e2) != END) |
|
4731
|
8 |
331 |
return (!rv && !cnt2[0]) ? compare_next(anchored, a1, a2) : rv; |
|
|
3 |
5 |
return (!rv && !cnt2[0]) ? compare_next(anchored, a1, a2) : rv; |
|
4748
|
0 |
120 |
if (bump_with_check(&left) <= 0) |
|
4754
|
0 |
120 |
if (t >= REGNODE_MAX) |
|
4759
|
0 |
120 |
else if (t == ANYOF) |
|
4763
|
0 |
0 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
4765
|
0 |
0 |
if (get_bitmap_byte(left.rn, i) & ~bitmap[i]) |
|
4771
|
1 |
119 |
else if (t == ANYOFR) |
|
4775
|
0 |
1 |
if (!convert_anyofr_to_bitmap(&left, left_bitmap)) |
|
4780
|
32 |
1 |
for (i = 0; i < ANYOF_BITMAP_SIZE; ++i) |
|
4782
|
0 |
32 |
if (left_bitmap[i] & ~bitmap[i]) |
|
4788
|
33 |
86 |
else if ((t == EXACT) || (t == EXACTF) || (t == EXACTFU)) |
|
|
33 |
0 |
else if ((t == EXACT) || (t == EXACTF) || (t == EXACTFU)) |
|
|
1 |
32 |
else if ((t == EXACT) || (t == EXACTF) || (t == EXACTFU)) |
|
4791
|
43 |
44 |
if (!lookup[(unsigned char)(*seq)]) |
|
4796
|
30 |
2 |
else if ((t == POSIXD) || (t == NPOSIXD) || (t == POSIXU) || (t == NPOSIXU)) |
|
|
30 |
0 |
else if ((t == POSIXD) || (t == NPOSIXD) || (t == POSIXU) || (t == NPOSIXU)) |
|
|
23 |
7 |
else if ((t == POSIXD) || (t == NPOSIXD) || (t == POSIXU) || (t == NPOSIXU)) |
|
|
0 |
23 |
else if ((t == POSIXD) || (t == NPOSIXD) || (t == POSIXU) || (t == NPOSIXU)) |
|
4799
|
9 |
0 |
if ((flags >= regclasses_size) || !regclasses[flags]) |
|
|
0 |
9 |
if ((flags >= regclasses_size) || !regclasses[flags]) |
|
4804
|
17 |
6 |
else if (!oktypes[t]) |
|
4810
|
0 |
60 |
if (bump_with_check(&right) <= 0) |
|
4815
|
9 |
51 |
return move_left ? compare(1, &left, &right) : |
|
4856
|
206 |
6 |
for (i = 0; (i < ANYOF_BITMAP_SIZE) && (cmp[0] || cmp[1]); ++i) |
|
|
140 |
66 |
for (i = 0; (i < ANYOF_BITMAP_SIZE) && (cmp[0] || cmp[1]); ++i) |
|
|
65 |
1 |
for (i = 0; (i < ANYOF_BITMAP_SIZE) && (cmp[0] || cmp[1]); ++i) |
|
4858
|
160 |
45 |
loc = bitmap1 ? bitmap1[i] : get_bitmap_byte(a1->rn, i); |
|
4860
|
6 |
199 |
if (loc & ~bitmap2[i]) |
|
4865
|
4 |
201 |
if (loc & bitmap2[i]) |
|
4871
|
3 |
4 |
if (cmp[0] && cmp[1]) |
|
|
0 |
3 |
if (cmp[0] && cmp[1]) |
|
4877
|
11 |
1 |
for (i = 0; i < SIZEOF_ARRAY(cmp); ++i) |
|
4879
|
6 |
5 |
if (cmp[i]) |
|
4914
|
0 |
1 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
4929
|
0 |
1 |
if (!convert_anyofr_to_bitmap(a1, left)) |
|
4944
|
0 |
2 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
4959
|
0 |
1 |
if (!convert_anyofm_to_bitmap(a1, left)) |
|
4979
|
62 |
1 |
compare_next_nword : compare_next_word; |
|
4995
|
15 |
2 |
compare_next_word : compare_next_nword; |
|
5006
|
11 |
0 |
if ((flags >= SIZEOF_ARRAY(word_posix_regclasses)) || |
|
|
11 |
0 |
if ((flags >= SIZEOF_ARRAY(word_posix_regclasses)) || |
|
5008
|
5 |
6 |
(!word_posix_regclasses[flags] && !non_word_posix_regclasses[flags])) |
|
|
0 |
5 |
(!word_posix_regclasses[flags] && !non_word_posix_regclasses[flags])) |
|
5016
|
6 |
5 |
compare_next_nword : compare_next_word; |
|
5027
|
9 |
0 |
if ((flags >= SIZEOF_ARRAY(word_posix_regclasses)) || |
|
|
9 |
0 |
if ((flags >= SIZEOF_ARRAY(word_posix_regclasses)) || |
|
5029
|
4 |
5 |
(!word_posix_regclasses[flags] && !non_word_posix_regclasses[flags])) |
|
|
0 |
4 |
(!word_posix_regclasses[flags] && !non_word_posix_regclasses[flags])) |
|
5037
|
5 |
4 |
compare_next_word : compare_next_nword; |
|
5049
|
3 |
2 |
if (FLAGS(a1->rn) != CC_WORDCHAR_) |
|
5065
|
7 |
2 |
if (FLAGS(a1->rn) != CC_WORDCHAR_) |
|
5107
|
7 |
9161 |
if ((get_forced_semantics(pt1) | get_forced_semantics(pt2)) == FORCED_MISMATCH) |
|
5113
|
0 |
9161 |
if (!p1) |
|
5119
|
0 |
9161 |
if (!p2) |
|
5165
|
38001 |
0 |
if ((OP(a1->rn) >= REGNODE_MAX) || (OP(a2->rn) >= REGNODE_MAX)) |
|
|
0 |
38001 |
if ((OP(a1->rn) >= REGNODE_MAX) || (OP(a2->rn) >= REGNODE_MAX)) |
|
5172
|
963 |
37038 |
if (!cmp) |
|
5198
|
10 |
1 |
for (i = 0; i < SIZEOF_ARRAY(digit_expl); ++i) |
|
5208
|
6 |
1 |
for (i = 0; i < 6; ++i) |
|
5214
|
6 |
1 |
for (i = 0; i < 6; ++i) |
|
5229
|
26 |
1 |
for (i = 0; i < LETTER_COUNT; ++i) |
|
5235
|
26 |
1 |
for (i = 0; i < LETTER_COUNT; ++i) |
|
5245
|
26 |
1 |
for (i = 0; i < LETTER_COUNT; ++i) |
|
5251
|
26 |
1 |
for (i = 0; i < LETTER_COUNT; ++i) |
|
5303
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
5308
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6061
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6203
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6218
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6233
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6260
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6282
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6305
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6328
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6351
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6366
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6373
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6510
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6562
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |
|
6576
|
111 |
1 |
for (i = 0; i < REGNODE_MAX; ++i) |