_pcre2_auto_possessify_8: 1133| 47.1k|{ 1134| 47.1k|PCRE2_UCHAR c; ------------------ | | 813| 47.1k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 47.1k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 47.1k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 47.1k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1135| 47.1k|PCRE2_SPTR end; ------------------ | | 814| 47.1k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 47.1k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 47.1k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 47.1k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1136| 47.1k|PCRE2_UCHAR *repeat_opcode; ------------------ | | 813| 47.1k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 47.1k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 47.1k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 47.1k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1137| 47.1k|uint32_t list[8]; 1138| 47.1k|int rec_limit = 1000; /* Was 10,000 but clang+ASAN uses a lot of stack. */ 1139| 47.1k|BOOL utf = (cb->external_options & PCRE2_UTF) != 0; ------------------ | | 138| 47.1k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 1140| 47.1k|BOOL ucp = (cb->external_options & PCRE2_UCP) != 0; ------------------ | | 136| 47.1k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ 1141| | 1142| 47.1k|for (;;) 1143| 5.04M| { 1144| 5.04M| c = *code; 1145| | 1146| 5.04M| if (c >= OP_TABLE_LENGTH) return -1; /* Something gone wrong */ ------------------ | Branch (1146:7): [True: 0, False: 5.04M] ------------------ 1147| | 1148| 5.04M| if (c >= OP_STAR && c <= OP_TYPEPOSUPTO) ------------------ | Branch (1148:7): [True: 3.93M, False: 1.11M] | Branch (1148:23): [True: 502k, False: 3.42M] ------------------ 1149| 502k| { 1150| 502k| c -= get_repeat_base(c) - OP_STAR; 1151| 502k| end = (c <= OP_MINUPTO) ? ------------------ | Branch (1151:11): [True: 457k, False: 44.6k] ------------------ 1152| 457k| get_chr_property_list(code, utf, ucp, cb->fcc, list) : NULL; 1153| 502k| list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO; ------------------ | Branch (1153:15): [True: 114k, False: 388k] | Branch (1153:31): [True: 114k, False: 274k] | Branch (1153:47): [True: 98.0k, False: 176k] | Branch (1153:64): [True: 18.9k, False: 157k] ------------------ 1154| | 1155| 502k| if (end != NULL && compare_opcodes(end, utf, ucp, cb, list, end, ------------------ | Branch (1155:9): [True: 457k, False: 44.6k] | Branch (1155:24): [True: 111k, False: 345k] ------------------ 1156| 457k| &rec_limit)) 1157| 111k| { 1158| 111k| switch(c) ------------------ | Branch (1158:14): [True: 0, False: 111k] ------------------ 1159| 111k| { 1160| 23.6k| case OP_STAR: ------------------ | Branch (1160:9): [True: 23.6k, False: 88.3k] ------------------ 1161| 23.6k| *code += OP_POSSTAR - OP_STAR; 1162| 23.6k| break; 1163| | 1164| 11.4k| case OP_MINSTAR: ------------------ | Branch (1164:9): [True: 11.4k, False: 100k] ------------------ 1165| 11.4k| *code += OP_POSSTAR - OP_MINSTAR; 1166| 11.4k| break; 1167| | 1168| 24.2k| case OP_PLUS: ------------------ | Branch (1168:9): [True: 24.2k, False: 87.7k] ------------------ 1169| 24.2k| *code += OP_POSPLUS - OP_PLUS; 1170| 24.2k| break; 1171| | 1172| 6.20k| case OP_MINPLUS: ------------------ | Branch (1172:9): [True: 6.20k, False: 105k] ------------------ 1173| 6.20k| *code += OP_POSPLUS - OP_MINPLUS; 1174| 6.20k| break; 1175| | 1176| 22.3k| case OP_QUERY: ------------------ | Branch (1176:9): [True: 22.3k, False: 89.6k] ------------------ 1177| 22.3k| *code += OP_POSQUERY - OP_QUERY; 1178| 22.3k| break; 1179| | 1180| 16.6k| case OP_MINQUERY: ------------------ | Branch (1180:9): [True: 16.6k, False: 95.3k] ------------------ 1181| 16.6k| *code += OP_POSQUERY - OP_MINQUERY; 1182| 16.6k| break; 1183| | 1184| 5.95k| case OP_UPTO: ------------------ | Branch (1184:9): [True: 5.95k, False: 106k] ------------------ 1185| 5.95k| *code += OP_POSUPTO - OP_UPTO; 1186| 5.95k| break; 1187| | 1188| 1.56k| case OP_MINUPTO: ------------------ | Branch (1188:9): [True: 1.56k, False: 110k] ------------------ 1189| 1.56k| *code += OP_POSUPTO - OP_MINUPTO; 1190| 1.56k| break; 1191| 111k| } 1192| 111k| } 1193| 502k| c = *code; 1194| 502k| } 1195| 4.54M| else if (c == OP_CLASS || c == OP_NCLASS || c == OP_XCLASS) ------------------ | Branch (1195:12): [True: 33.5k, False: 4.51M] | Branch (1195:29): [True: 8.98k, False: 4.50M] | Branch (1195:47): [True: 7.69k, False: 4.49M] ------------------ 1196| 50.2k| { 1197| 50.2k|#ifdef SUPPORT_WIDE_CHARS 1198| 50.2k| if (c == OP_XCLASS) ------------------ | Branch (1198:9): [True: 7.69k, False: 42.5k] ------------------ 1199| 7.69k| repeat_opcode = code + GET(code, 1); ------------------ | | 109| 7.69k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1200| 42.5k| else 1201| 42.5k|#endif 1202| 42.5k| repeat_opcode = code + 1 + (32 / sizeof(PCRE2_UCHAR)); 1203| | 1204| 50.2k| c = *repeat_opcode; 1205| 50.2k| if (c >= OP_CRSTAR && c <= OP_CRMINRANGE) ------------------ | Branch (1205:9): [True: 44.4k, False: 5.81k] | Branch (1205:27): [True: 24.5k, False: 19.8k] ------------------ 1206| 24.5k| { 1207| | /* The return from get_chr_property_list() will never be NULL when 1208| | *code (aka c) is one of the three class opcodes. However, gcc with 1209| | -fanalyzer notes that a NULL return is possible, and grumbles. Hence we 1210| | put in a check. */ 1211| | 1212| 24.5k| end = get_chr_property_list(code, utf, ucp, cb->fcc, list); 1213| 24.5k| list[1] = (c & 1) == 0; 1214| | 1215| 24.5k| if (end != NULL && ------------------ | Branch (1215:11): [True: 24.5k, False: 0] ------------------ 1216| 24.5k| compare_opcodes(end, utf, ucp, cb, list, end, &rec_limit)) ------------------ | Branch (1216:11): [True: 10.4k, False: 14.0k] ------------------ 1217| 10.4k| { 1218| 10.4k| switch (c) ------------------ | Branch (1218:17): [True: 0, False: 10.4k] ------------------ 1219| 10.4k| { 1220| 3.01k| case OP_CRSTAR: ------------------ | Branch (1220:11): [True: 3.01k, False: 7.45k] ------------------ 1221| 3.72k| case OP_CRMINSTAR: ------------------ | Branch (1221:11): [True: 714, False: 9.75k] ------------------ 1222| 3.72k| *repeat_opcode = OP_CRPOSSTAR; 1223| 3.72k| break; 1224| | 1225| 1.83k| case OP_CRPLUS: ------------------ | Branch (1225:11): [True: 1.83k, False: 8.62k] ------------------ 1226| 2.06k| case OP_CRMINPLUS: ------------------ | Branch (1226:11): [True: 225, False: 10.2k] ------------------ 1227| 2.06k| *repeat_opcode = OP_CRPOSPLUS; 1228| 2.06k| break; 1229| | 1230| 2.67k| case OP_CRQUERY: ------------------ | Branch (1230:11): [True: 2.67k, False: 7.79k] ------------------ 1231| 4.26k| case OP_CRMINQUERY: ------------------ | Branch (1231:11): [True: 1.59k, False: 8.87k] ------------------ 1232| 4.26k| *repeat_opcode = OP_CRPOSQUERY; 1233| 4.26k| break; 1234| | 1235| 367| case OP_CRRANGE: ------------------ | Branch (1235:11): [True: 367, False: 10.0k] ------------------ 1236| 413| case OP_CRMINRANGE: ------------------ | Branch (1236:11): [True: 46, False: 10.4k] ------------------ 1237| 413| *repeat_opcode = OP_CRPOSRANGE; 1238| 413| break; 1239| 10.4k| } 1240| 10.4k| } 1241| 24.5k| } 1242| 50.2k| c = *code; 1243| 50.2k| } 1244| | 1245| 5.04M| switch(c) ------------------ | Branch (1245:10): [True: 4.73M, False: 310k] ------------------ 1246| 5.04M| { 1247| 47.1k| case OP_END: ------------------ | Branch (1247:5): [True: 47.1k, False: 5.00M] ------------------ 1248| 47.1k| return 0; 1249| | 1250| 53.0k| case OP_TYPESTAR: ------------------ | Branch (1250:5): [True: 53.0k, False: 4.99M] ------------------ 1251| 62.2k| case OP_TYPEMINSTAR: ------------------ | Branch (1251:5): [True: 9.22k, False: 5.04M] ------------------ 1252| 106k| case OP_TYPEPLUS: ------------------ | Branch (1252:5): [True: 44.3k, False: 5.00M] ------------------ 1253| 121k| case OP_TYPEMINPLUS: ------------------ | Branch (1253:5): [True: 14.4k, False: 5.03M] ------------------ 1254| 157k| case OP_TYPEQUERY: ------------------ | Branch (1254:5): [True: 36.4k, False: 5.01M] ------------------ 1255| 164k| case OP_TYPEMINQUERY: ------------------ | Branch (1255:5): [True: 6.65k, False: 5.04M] ------------------ 1256| 184k| case OP_TYPEPOSSTAR: ------------------ | Branch (1256:5): [True: 20.4k, False: 5.02M] ------------------ 1257| 207k| case OP_TYPEPOSPLUS: ------------------ | Branch (1257:5): [True: 22.4k, False: 5.02M] ------------------ 1258| 219k| case OP_TYPEPOSQUERY: ------------------ | Branch (1258:5): [True: 12.0k, False: 5.03M] ------------------ 1259| 219k| if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2; ------------------ | Branch (1259:9): [True: 24.0k, False: 195k] | Branch (1259:31): [True: 30.0k, False: 165k] ------------------ 1260| 219k| break; 1261| | 1262| 4.22k| case OP_TYPEUPTO: ------------------ | Branch (1262:5): [True: 4.22k, False: 5.04M] ------------------ 1263| 6.26k| case OP_TYPEMINUPTO: ------------------ | Branch (1263:5): [True: 2.04k, False: 5.04M] ------------------ 1264| 16.9k| case OP_TYPEEXACT: ------------------ | Branch (1264:5): [True: 10.6k, False: 5.03M] ------------------ 1265| 20.4k| case OP_TYPEPOSUPTO: ------------------ | Branch (1265:5): [True: 3.56k, False: 5.04M] ------------------ 1266| 20.4k| if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP) ------------------ | | 193| 20.4k|#define IMM2_SIZE 2 ------------------ if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP) ------------------ | | 193| 18.1k|#define IMM2_SIZE 2 ------------------ | Branch (1266:9): [True: 2.33k, False: 18.1k] | Branch (1266:43): [True: 2.08k, False: 16.0k] ------------------ 1267| 4.42k| code += 2; 1268| 20.4k| break; 1269| | 1270| 3.63k| case OP_CALLOUT_STR: ------------------ | Branch (1270:5): [True: 3.63k, False: 5.04M] ------------------ 1271| 3.63k| code += GET(code, 1 + 2*LINK_SIZE); ------------------ | | 109| 3.63k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1272| 3.63k| break; 1273| | 1274| 0|#ifdef SUPPORT_WIDE_CHARS 1275| 7.69k| case OP_XCLASS: ------------------ | Branch (1275:5): [True: 7.69k, False: 5.04M] ------------------ 1276| 7.69k| code += GET(code, 1); ------------------ | | 109| 7.69k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1277| 7.69k| break; 1278| 0|#endif 1279| | 1280| 1.93k| case OP_MARK: ------------------ | Branch (1280:5): [True: 1.93k, False: 5.04M] ------------------ 1281| 4.02k| case OP_COMMIT_ARG: ------------------ | Branch (1281:5): [True: 2.09k, False: 5.04M] ------------------ 1282| 7.25k| case OP_PRUNE_ARG: ------------------ | Branch (1282:5): [True: 3.22k, False: 5.04M] ------------------ 1283| 10.8k| case OP_SKIP_ARG: ------------------ | Branch (1283:5): [True: 3.58k, False: 5.04M] ------------------ 1284| 12.0k| case OP_THEN_ARG: ------------------ | Branch (1284:5): [True: 1.24k, False: 5.04M] ------------------ 1285| 12.0k| code += code[1]; 1286| 12.0k| break; 1287| 5.04M| } 1288| | 1289| | /* Add in the fixed length from the table */ 1290| | 1291| 5.00M| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 5.00M|#define PRIV(name) _pcre2_##name ------------------ 1292| | 1293| | /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may be 1294| | followed by a multi-byte character. The length in the table is a minimum, so 1295| | we have to arrange to skip the extra code units. */ 1296| | 1297| 5.00M|#ifdef MAYBE_UTF_MULTI 1298| 5.00M| if (utf) switch(c) ------------------ | Branch (1298:7): [True: 792k, False: 4.20M] | Branch (1298:19): [True: 661k, False: 131k] ------------------ 1299| 792k| { 1300| 37.2k| case OP_CHAR: ------------------ | Branch (1300:5): [True: 37.2k, False: 755k] ------------------ 1301| 75.5k| case OP_CHARI: ------------------ | Branch (1301:5): [True: 38.2k, False: 754k] ------------------ 1302| 76.1k| case OP_NOT: ------------------ | Branch (1302:5): [True: 593, False: 792k] ------------------ 1303| 76.3k| case OP_NOTI: ------------------ | Branch (1303:5): [True: 192, False: 792k] ------------------ 1304| 76.6k| case OP_STAR: ------------------ | Branch (1304:5): [True: 330, False: 792k] ------------------ 1305| 77.1k| case OP_MINSTAR: ------------------ | Branch (1305:5): [True: 474, False: 792k] ------------------ 1306| 77.1k| case OP_PLUS: ------------------ | Branch (1306:5): [True: 52, False: 792k] ------------------ 1307| 78.3k| case OP_MINPLUS: ------------------ | Branch (1307:5): [True: 1.20k, False: 791k] ------------------ 1308| 78.5k| case OP_QUERY: ------------------ | Branch (1308:5): [True: 214, False: 792k] ------------------ 1309| 79.0k| case OP_MINQUERY: ------------------ | Branch (1309:5): [True: 436, False: 792k] ------------------ 1310| 79.0k| case OP_UPTO: ------------------ | Branch (1310:5): [True: 0, False: 792k] ------------------ 1311| 79.0k| case OP_MINUPTO: ------------------ | Branch (1311:5): [True: 24, False: 792k] ------------------ 1312| 79.1k| case OP_EXACT: ------------------ | Branch (1312:5): [True: 117, False: 792k] ------------------ 1313| 79.7k| case OP_POSSTAR: ------------------ | Branch (1313:5): [True: 624, False: 792k] ------------------ 1314| 80.3k| case OP_POSPLUS: ------------------ | Branch (1314:5): [True: 566, False: 792k] ------------------ 1315| 80.6k| case OP_POSQUERY: ------------------ | Branch (1315:5): [True: 299, False: 792k] ------------------ 1316| 80.9k| case OP_POSUPTO: ------------------ | Branch (1316:5): [True: 261, False: 792k] ------------------ 1317| 82.1k| case OP_STARI: ------------------ | Branch (1317:5): [True: 1.19k, False: 791k] ------------------ 1318| 87.5k| case OP_MINSTARI: ------------------ | Branch (1318:5): [True: 5.41k, False: 787k] ------------------ 1319| 88.4k| case OP_PLUSI: ------------------ | Branch (1319:5): [True: 922, False: 792k] ------------------ 1320| 100k| case OP_MINPLUSI: ------------------ | Branch (1320:5): [True: 12.4k, False: 780k] ------------------ 1321| 101k| case OP_QUERYI: ------------------ | Branch (1321:5): [True: 962, False: 792k] ------------------ 1322| 110k| case OP_MINQUERYI: ------------------ | Branch (1322:5): [True: 8.53k, False: 784k] ------------------ 1323| 110k| case OP_UPTOI: ------------------ | Branch (1323:5): [True: 11, False: 792k] ------------------ 1324| 110k| case OP_MINUPTOI: ------------------ | Branch (1324:5): [True: 15, False: 792k] ------------------ 1325| 111k| case OP_EXACTI: ------------------ | Branch (1325:5): [True: 1.27k, False: 791k] ------------------ 1326| 114k| case OP_POSSTARI: ------------------ | Branch (1326:5): [True: 3.01k, False: 789k] ------------------ 1327| 115k| case OP_POSPLUSI: ------------------ | Branch (1327:5): [True: 927, False: 792k] ------------------ 1328| 127k| case OP_POSQUERYI: ------------------ | Branch (1328:5): [True: 12.1k, False: 780k] ------------------ 1329| 127k| case OP_POSUPTOI: ------------------ | Branch (1329:5): [True: 7, False: 792k] ------------------ 1330| 127k| case OP_NOTSTAR: ------------------ | Branch (1330:5): [True: 5, False: 792k] ------------------ 1331| 128k| case OP_NOTMINSTAR: ------------------ | Branch (1331:5): [True: 278, False: 792k] ------------------ 1332| 128k| case OP_NOTPLUS: ------------------ | Branch (1332:5): [True: 34, False: 792k] ------------------ 1333| 128k| case OP_NOTMINPLUS: ------------------ | Branch (1333:5): [True: 354, False: 792k] ------------------ 1334| 128k| case OP_NOTQUERY: ------------------ | Branch (1334:5): [True: 2, False: 792k] ------------------ 1335| 128k| case OP_NOTMINQUERY: ------------------ | Branch (1335:5): [True: 34, False: 792k] ------------------ 1336| 128k| case OP_NOTUPTO: ------------------ | Branch (1336:5): [True: 2, False: 792k] ------------------ 1337| 128k| case OP_NOTMINUPTO: ------------------ | Branch (1337:5): [True: 15, False: 792k] ------------------ 1338| 128k| case OP_NOTEXACT: ------------------ | Branch (1338:5): [True: 68, False: 792k] ------------------ 1339| 128k| case OP_NOTPOSSTAR: ------------------ | Branch (1339:5): [True: 223, False: 792k] ------------------ 1340| 129k| case OP_NOTPOSPLUS: ------------------ | Branch (1340:5): [True: 315, False: 792k] ------------------ 1341| 129k| case OP_NOTPOSQUERY: ------------------ | Branch (1341:5): [True: 10, False: 792k] ------------------ 1342| 129k| case OP_NOTPOSUPTO: ------------------ | Branch (1342:5): [True: 61, False: 792k] ------------------ 1343| 129k| case OP_NOTSTARI: ------------------ | Branch (1343:5): [True: 26, False: 792k] ------------------ 1344| 129k| case OP_NOTMINSTARI: ------------------ | Branch (1344:5): [True: 432, False: 792k] ------------------ 1345| 129k| case OP_NOTPLUSI: ------------------ | Branch (1345:5): [True: 3, False: 792k] ------------------ 1346| 129k| case OP_NOTMINPLUSI: ------------------ | Branch (1346:5): [True: 38, False: 792k] ------------------ 1347| 129k| case OP_NOTQUERYI: ------------------ | Branch (1347:5): [True: 3, False: 792k] ------------------ 1348| 130k| case OP_NOTMINQUERYI: ------------------ | Branch (1348:5): [True: 232, False: 792k] ------------------ 1349| 130k| case OP_NOTUPTOI: ------------------ | Branch (1349:5): [True: 0, False: 792k] ------------------ 1350| 130k| case OP_NOTMINUPTOI: ------------------ | Branch (1350:5): [True: 2, False: 792k] ------------------ 1351| 130k| case OP_NOTEXACTI: ------------------ | Branch (1351:5): [True: 9, False: 792k] ------------------ 1352| 130k| case OP_NOTPOSSTARI: ------------------ | Branch (1352:5): [True: 307, False: 792k] ------------------ 1353| 130k| case OP_NOTPOSPLUSI: ------------------ | Branch (1353:5): [True: 321, False: 792k] ------------------ 1354| 131k| case OP_NOTPOSQUERYI: ------------------ | Branch (1354:5): [True: 871, False: 792k] ------------------ 1355| 131k| case OP_NOTPOSUPTOI: ------------------ | Branch (1355:5): [True: 34, False: 792k] ------------------ 1356| 131k| if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]); ------------------ | | 286| 131k|#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c) | | ------------------ | | | | 254| 131k|#define HASUTF8EXTRALEN(c) ((c) >= 0xc0) | | | | ------------------ | | | | | Branch (254:28): [True: 46.6k, False: 84.8k] | | | | ------------------ | | ------------------ ------------------ if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]); ------------------ | | 291| 46.6k|#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu]) | | ------------------ | | | | 177| 46.6k|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ 1357| 131k| break; 1358| 792k| } 1359| |#else 1360| | (void)(utf); /* Keep compiler happy by referencing function argument */ 1361| |#endif /* SUPPORT_WIDE_CHARS */ 1362| 5.00M| } 1363| 47.1k|} pcre2_auto_possess.c:get_repeat_base: 292| 1.07M|{ 293| 1.07M|return (c > OP_TYPEPOSUPTO)? c : ------------------ | Branch (293:8): [True: 0, False: 1.07M] ------------------ 294| 1.07M| (c >= OP_TYPESTAR)? OP_TYPESTAR : ------------------ | Branch (294:8): [True: 531k, False: 540k] ------------------ 295| 1.07M| (c >= OP_NOTSTARI)? OP_NOTSTARI : ------------------ | Branch (295:8): [True: 9.30k, False: 531k] ------------------ 296| 540k| (c >= OP_NOTSTAR)? OP_NOTSTAR : ------------------ | Branch (296:8): [True: 55.6k, False: 475k] ------------------ 297| 531k| (c >= OP_STARI)? OP_STARI : ------------------ | Branch (297:8): [True: 123k, False: 351k] ------------------ 298| 475k| OP_STAR; 299| 1.07M|} pcre2_auto_possess.c:get_chr_property_list: 327| 845k|{ 328| 845k|PCRE2_UCHAR c = *code; ------------------ | | 813| 845k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 845k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 845k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 845k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 329| 845k|PCRE2_UCHAR base; ------------------ | | 813| 845k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 845k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 845k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 845k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 330| 845k|PCRE2_SPTR end; ------------------ | | 814| 845k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 845k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 845k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 845k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 331| 845k|uint32_t chr; 332| | 333| 845k|#ifdef SUPPORT_UNICODE 334| 845k|uint32_t *clist_dest; 335| 845k|const uint32_t *clist_src; 336| |#else 337| |(void)utf; /* Suppress "unused parameter" compiler warnings */ 338| |(void)ucp; 339| |#endif 340| | 341| 845k|list[0] = c; 342| 845k|list[1] = FALSE; ------------------ | | 69| 845k|#define FALSE 0 ------------------ 343| 845k|code++; 344| | 345| 845k|if (c >= OP_STAR && c <= OP_TYPEPOSUPTO) ------------------ | Branch (345:5): [True: 616k, False: 229k] | Branch (345:21): [True: 569k, False: 47.1k] ------------------ 346| 569k| { 347| 569k| base = get_repeat_base(c); 348| 569k| c -= (base - OP_STAR); 349| | 350| 569k| if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO) ------------------ | Branch (350:7): [True: 22.9k, False: 546k] | Branch (350:23): [True: 5.79k, False: 540k] | Branch (350:42): [True: 3.47k, False: 537k] | Branch (350:59): [True: 325, False: 536k] ------------------ 351| 32.5k| code += IMM2_SIZE; ------------------ | | 193| 32.5k|#define IMM2_SIZE 2 ------------------ 352| | 353| 569k| list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && ------------------ | Branch (353:14): [True: 434k, False: 134k] | Branch (353:30): [True: 392k, False: 42.1k] | Branch (353:49): [True: 389k, False: 3.47k] ------------------ 354| 569k| c != OP_POSPLUS); ------------------ | Branch (354:14): [True: 389k, False: 195] ------------------ 355| | 356| 569k| switch(base) ------------------ | Branch (356:10): [True: 0, False: 569k] ------------------ 357| 569k| { 358| 185k| case OP_STAR: ------------------ | Branch (358:5): [True: 185k, False: 383k] ------------------ 359| 185k| list[0] = OP_CHAR; 360| 185k| break; 361| | 362| 61.4k| case OP_STARI: ------------------ | Branch (362:5): [True: 61.4k, False: 508k] ------------------ 363| 61.4k| list[0] = OP_CHARI; 364| 61.4k| break; 365| | 366| 26.6k| case OP_NOTSTAR: ------------------ | Branch (366:5): [True: 26.6k, False: 542k] ------------------ 367| 26.6k| list[0] = OP_NOT; 368| 26.6k| break; 369| | 370| 3.86k| case OP_NOTSTARI: ------------------ | Branch (370:5): [True: 3.86k, False: 565k] ------------------ 371| 3.86k| list[0] = OP_NOTI; 372| 3.86k| break; 373| | 374| 291k| case OP_TYPESTAR: ------------------ | Branch (374:5): [True: 291k, False: 277k] ------------------ 375| 291k| list[0] = *code; 376| 291k| code++; 377| 291k| break; 378| 569k| } 379| 569k| c = list[0]; 380| 569k| } 381| | 382| 845k|switch(c) ------------------ | Branch (382:8): [True: 9.25k, False: 836k] ------------------ 383| 845k| { 384| 12.4k| case OP_NOT_DIGIT: ------------------ | Branch (384:3): [True: 12.4k, False: 833k] ------------------ 385| 34.8k| case OP_DIGIT: ------------------ | Branch (385:3): [True: 22.3k, False: 823k] ------------------ 386| 68.3k| case OP_NOT_WHITESPACE: ------------------ | Branch (386:3): [True: 33.5k, False: 812k] ------------------ 387| 92.7k| case OP_WHITESPACE: ------------------ | Branch (387:3): [True: 24.3k, False: 821k] ------------------ 388| 115k| case OP_NOT_WORDCHAR: ------------------ | Branch (388:3): [True: 22.3k, False: 823k] ------------------ 389| 133k| case OP_WORDCHAR: ------------------ | Branch (389:3): [True: 18.2k, False: 827k] ------------------ 390| 192k| case OP_ANY: ------------------ | Branch (390:3): [True: 59.3k, False: 786k] ------------------ 391| 203k| case OP_ALLANY: ------------------ | Branch (391:3): [True: 10.7k, False: 834k] ------------------ 392| 215k| case OP_ANYNL: ------------------ | Branch (392:3): [True: 12.3k, False: 833k] ------------------ 393| 238k| case OP_NOT_HSPACE: ------------------ | Branch (393:3): [True: 22.8k, False: 822k] ------------------ 394| 264k| case OP_HSPACE: ------------------ | Branch (394:3): [True: 25.7k, False: 819k] ------------------ 395| 278k| case OP_NOT_VSPACE: ------------------ | Branch (395:3): [True: 13.7k, False: 831k] ------------------ 396| 288k| case OP_VSPACE: ------------------ | Branch (396:3): [True: 9.83k, False: 835k] ------------------ 397| 290k| case OP_EXTUNI: ------------------ | Branch (397:3): [True: 2.84k, False: 842k] ------------------ 398| 291k| case OP_EODN: ------------------ | Branch (398:3): [True: 633, False: 845k] ------------------ 399| 292k| case OP_EOD: ------------------ | Branch (399:3): [True: 978, False: 844k] ------------------ 400| 304k| case OP_DOLL: ------------------ | Branch (400:3): [True: 11.6k, False: 834k] ------------------ 401| 306k| case OP_DOLLM: ------------------ | Branch (401:3): [True: 2.13k, False: 843k] ------------------ 402| 306k| return code; 403| | 404| 291k| case OP_CHAR: ------------------ | Branch (404:3): [True: 291k, False: 554k] ------------------ 405| 319k| case OP_NOT: ------------------ | Branch (405:3): [True: 28.4k, False: 817k] ------------------ 406| 319k| GETCHARINCTEST(chr, code); ------------------ | | 323| 319k| c = *eptr++; \ | | 324| 319k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 10.5k| { \ | | | | 289| 10.5k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 1.77k, False: 8.76k] | | | | ------------------ | | | | 290| 10.5k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 10.5k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 8.18k, False: 579] | | | | ------------------ | | | | 292| 8.76k| { \ | | | | 293| 8.18k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 8.18k| eptr += 2; \ | | | | 295| 8.18k| } \ | | | | 296| 8.76k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 579, False: 0] | | | | ------------------ | | | | 297| 579| { \ | | | | 298| 579| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 579| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 579| eptr += 3; \ | | | | 301| 579| } \ | | | | 302| 579| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 10.5k| } | | ------------------ | | | Branch (324:7): [True: 21.0k, False: 298k] | | | Branch (324:14): [True: 10.5k, False: 10.4k] | | ------------------ ------------------ 407| 319k| list[2] = chr; 408| 319k| list[3] = NOTACHAR; ------------------ | | 205| 319k|#define NOTACHAR 0xffffffff ------------------ 409| 319k| return code; 410| | 411| 79.3k| case OP_CHARI: ------------------ | Branch (411:3): [True: 79.3k, False: 766k] ------------------ 412| 83.2k| case OP_NOTI: ------------------ | Branch (412:3): [True: 3.92k, False: 841k] ------------------ 413| 83.2k| list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT; ------------------ | Branch (413:13): [True: 79.3k, False: 3.92k] ------------------ 414| 83.2k| GETCHARINCTEST(chr, code); ------------------ | | 323| 83.2k| c = *eptr++; \ | | 324| 83.2k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 33.0k| { \ | | | | 289| 33.0k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 1.70k, False: 31.3k] | | | | ------------------ | | | | 290| 33.0k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 33.0k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 30.7k, False: 588] | | | | ------------------ | | | | 292| 31.3k| { \ | | | | 293| 30.7k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 30.7k| eptr += 2; \ | | | | 295| 30.7k| } \ | | | | 296| 31.3k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 588, False: 0] | | | | ------------------ | | | | 297| 588| { \ | | | | 298| 588| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 588| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 588| eptr += 3; \ | | | | 301| 588| } \ | | | | 302| 588| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 33.0k| } | | ------------------ | | | Branch (324:7): [True: 60.6k, False: 22.6k] | | | Branch (324:14): [True: 33.0k, False: 27.5k] | | ------------------ ------------------ 415| 83.2k| list[2] = chr; 416| | 417| 83.2k|#ifdef SUPPORT_UNICODE 418| 83.2k| if (chr < 128 || (chr < 256 && !utf && !ucp)) ------------------ | Branch (418:7): [True: 41.5k, False: 41.7k] | Branch (418:21): [True: 9.00k, False: 32.7k] | Branch (418:34): [True: 8.65k, False: 344] | Branch (418:42): [True: 6.75k, False: 1.90k] ------------------ 419| 48.2k| list[3] = fcc[chr]; 420| 34.9k| else 421| 34.9k| list[3] = UCD_OTHERCASE(chr); ------------------ | | 1862| 34.9k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 34.9k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 34.9k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 34.9k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 34.9k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 34.9k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 34.9k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 34.9k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 34.9k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 34.9k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 34.9k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 422| |#elif defined SUPPORT_WIDE_CHARS 423| | list[3] = (chr < 256) ? fcc[chr] : chr; 424| |#else 425| | list[3] = fcc[chr]; 426| |#endif 427| | 428| | /* The othercase might be the same value. */ 429| | 430| 83.2k| if (chr == list[3]) ------------------ | Branch (430:7): [True: 63.0k, False: 20.2k] ------------------ 431| 63.0k| list[3] = NOTACHAR; ------------------ | | 205| 63.0k|#define NOTACHAR 0xffffffff ------------------ 432| 20.2k| else 433| 20.2k| list[4] = NOTACHAR; ------------------ | | 205| 20.2k|#define NOTACHAR 0xffffffff ------------------ 434| 83.2k| return code; 435| | 436| 0|#ifdef SUPPORT_UNICODE 437| 41.1k| case OP_PROP: ------------------ | Branch (437:3): [True: 41.1k, False: 804k] ------------------ 438| 86.4k| case OP_NOTPROP: ------------------ | Branch (438:3): [True: 45.2k, False: 800k] ------------------ 439| 86.4k| if (code[0] != PT_CLIST) ------------------ | | 1285| 86.4k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (439:7): [True: 80.8k, False: 5.50k] ------------------ 440| 80.8k| { 441| 80.8k| list[2] = code[0]; 442| 80.8k| list[3] = code[1]; 443| 80.8k| return code + 2; 444| 80.8k| } 445| | 446| | /* Convert only if we have enough space. */ 447| | 448| 5.50k| clist_src = PRIV(ucd_caseless_sets) + code[1]; ------------------ | | 177| 5.50k|#define PRIV(name) _pcre2_##name ------------------ 449| 5.50k| clist_dest = list + 2; 450| 5.50k| code += 2; 451| | 452| 22.0k| do { 453| 22.0k| if (clist_dest >= list + 8) ------------------ | Branch (453:10): [True: 0, False: 22.0k] ------------------ 454| 0| { 455| | /* Early return if there is not enough space. This should never 456| | happen, since all clists are shorter than 5 character now. */ 457| 0| list[2] = code[0]; 458| 0| list[3] = code[1]; 459| 0| return code; 460| 0| } 461| 22.0k| *clist_dest++ = *clist_src; 462| 22.0k| } 463| 22.0k| while(*clist_src++ != NOTACHAR); ------------------ | | 205| 22.0k|#define NOTACHAR 0xffffffff ------------------ | Branch (463:9): [True: 16.5k, False: 5.50k] ------------------ 464| | 465| | /* All characters are stored. The terminating NOTACHAR is copied from the 466| | clist itself. */ 467| | 468| 5.50k| list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT; ------------------ | Branch (468:13): [True: 5.48k, False: 20] ------------------ 469| 5.50k| return code; 470| 0|#endif 471| | 472| 5.53k| case OP_NCLASS: ------------------ | Branch (472:3): [True: 5.53k, False: 840k] ------------------ 473| 36.1k| case OP_CLASS: ------------------ | Branch (473:3): [True: 30.5k, False: 815k] ------------------ 474| 36.1k|#ifdef SUPPORT_WIDE_CHARS 475| 40.6k| case OP_XCLASS: ------------------ | Branch (475:3): [True: 4.58k, False: 841k] ------------------ 476| 40.6k| if (c == OP_XCLASS) ------------------ | Branch (476:7): [True: 4.58k, False: 36.1k] ------------------ 477| 4.58k| end = code + GET(code, 0) - 1; ------------------ | | 109| 4.58k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 478| 36.1k| else 479| 36.1k|#endif 480| 36.1k| end = code + 32 / sizeof(PCRE2_UCHAR); 481| | 482| 40.6k| switch(*end) ------------------ | Branch (482:10): [True: 7.29k, False: 33.3k] ------------------ 483| 40.6k| { 484| 6.89k| case OP_CRSTAR: ------------------ | Branch (484:5): [True: 6.89k, False: 33.7k] ------------------ 485| 9.10k| case OP_CRMINSTAR: ------------------ | Branch (485:5): [True: 2.21k, False: 38.4k] ------------------ 486| 18.1k| case OP_CRQUERY: ------------------ | Branch (486:5): [True: 9.03k, False: 31.6k] ------------------ 487| 21.5k| case OP_CRMINQUERY: ------------------ | Branch (487:5): [True: 3.38k, False: 37.3k] ------------------ 488| 21.7k| case OP_CRPOSSTAR: ------------------ | Branch (488:5): [True: 223, False: 40.4k] ------------------ 489| 22.5k| case OP_CRPOSQUERY: ------------------ | Branch (489:5): [True: 848, False: 39.8k] ------------------ 490| 22.5k| list[1] = TRUE; ------------------ | | 70| 22.5k|#define TRUE 1 ------------------ 491| 22.5k| end++; 492| 22.5k| break; 493| | 494| 4.59k| case OP_CRPLUS: ------------------ | Branch (494:5): [True: 4.59k, False: 36.0k] ------------------ 495| 6.03k| case OP_CRMINPLUS: ------------------ | Branch (495:5): [True: 1.44k, False: 39.2k] ------------------ 496| 6.32k| case OP_CRPOSPLUS: ------------------ | Branch (496:5): [True: 285, False: 40.4k] ------------------ 497| 6.32k| end++; 498| 6.32k| break; 499| | 500| 3.02k| case OP_CRRANGE: ------------------ | Branch (500:5): [True: 3.02k, False: 37.6k] ------------------ 501| 3.87k| case OP_CRMINRANGE: ------------------ | Branch (501:5): [True: 850, False: 39.8k] ------------------ 502| 4.47k| case OP_CRPOSRANGE: ------------------ | Branch (502:5): [True: 600, False: 40.0k] ------------------ 503| 4.47k| list[1] = (GET2(end, 1) == 0); ------------------ | | 194| 4.47k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 504| 4.47k| end += 1 + 2 * IMM2_SIZE; ------------------ | | 193| 4.47k|#define IMM2_SIZE 2 ------------------ 505| 4.47k| break; 506| 40.6k| } 507| 40.6k| list[2] = (uint32_t)(end - code); 508| 40.6k| return end; 509| 845k| } 510| | 511| 9.25k|return NULL; /* Opcode not accepted */ 512| 845k|} pcre2_auto_possess.c:compare_opcodes: 538| 535k|{ 539| 535k|PCRE2_UCHAR c; ------------------ | | 813| 535k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 535k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 535k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 535k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 540| 535k|uint32_t list[8]; 541| 535k|const uint32_t *chr_ptr; 542| 535k|const uint32_t *ochr_ptr; 543| 535k|const uint32_t *list_ptr; 544| 535k|PCRE2_SPTR next_code; ------------------ | | 814| 535k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 535k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 535k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 535k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 545| 535k|#ifdef SUPPORT_WIDE_CHARS 546| 535k|PCRE2_SPTR xclass_flags; ------------------ | | 814| 535k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 535k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 535k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 535k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 547| 535k|#endif 548| 535k|const uint8_t *class_bitset; 549| 535k|const uint8_t *set1, *set2, *set_end; 550| 535k|uint32_t chr; 551| 535k|BOOL accepted, invert_bits; 552| 535k|BOOL entered_a_group = FALSE; ------------------ | | 69| 535k|#define FALSE 0 ------------------ 553| | 554| 535k|if (--(*rec_limit) <= 0) return FALSE; /* Recursion has gone too deep */ ------------------ | | 69| 87.8k|#define FALSE 0 ------------------ | Branch (554:5): [True: 87.8k, False: 447k] ------------------ 555| | 556| |/* Note: the base_list[1] contains whether the current opcode has a greedy 557| |(represented by a non-zero value) quantifier. This is a different from 558| |other character type lists, which store here that the character iterator 559| |matches to an empty string (also represented by a non-zero value). */ 560| | 561| 447k|for(;;) 562| 1.02M| { 563| | /* All operations move the code pointer forward. 564| | Therefore infinite recursions are not possible. */ 565| | 566| 1.02M| c = *code; 567| | 568| | /* Skip over callouts */ 569| | 570| 1.02M| if (c == OP_CALLOUT) ------------------ | Branch (570:7): [True: 132k, False: 894k] ------------------ 571| 132k| { 572| 132k| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 132k|#define PRIV(name) _pcre2_##name ------------------ 573| 132k| continue; 574| 132k| } 575| | 576| 894k| if (c == OP_CALLOUT_STR) ------------------ | Branch (576:7): [True: 538, False: 894k] ------------------ 577| 538| { 578| 538| code += GET(code, 1 + 2*LINK_SIZE); ------------------ | | 109| 538| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 579| 538| continue; 580| 538| } 581| | 582| | /* At the end of a branch, skip to the end of the group. */ 583| | 584| 894k| if (c == OP_ALT) ------------------ | Branch (584:7): [True: 53.4k, False: 840k] ------------------ 585| 53.4k| { 586| 147k| do code += GET(code, 1); while (*code == OP_ALT); ------------------ | | 109| 147k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (586:37): [True: 93.7k, False: 53.4k] ------------------ 587| 53.4k| c = *code; 588| 53.4k| } 589| | 590| | /* Inspect the next opcode. */ 591| | 592| 894k| switch(c) 593| 894k| { 594| | /* We can always possessify a greedy iterator at the end of the pattern, 595| | which is reached after skipping over the final OP_KET. A non-greedy 596| | iterator must never be possessified. */ 597| | 598| 15.0k| case OP_END: ------------------ | Branch (598:5): [True: 15.0k, False: 879k] ------------------ 599| 15.0k| return base_list[1] != 0; 600| | 601| | /* When an iterator is at the end of certain kinds of group we can inspect 602| | what follows the group by skipping over the closing ket. Note that this 603| | does not apply to OP_KETRMAX or OP_KETRMIN because what follows any given 604| | iteration is variable (could be another iteration or could be the next 605| | item). As these two opcodes are not listed in the next switch, they will 606| | end up as the next code to inspect, and return FALSE by virtue of being 607| | unsupported. */ 608| | 609| 347k| case OP_KET: ------------------ | Branch (609:5): [True: 347k, False: 547k] ------------------ 610| 349k| case OP_KETRPOS: ------------------ | Branch (610:5): [True: 2.72k, False: 891k] ------------------ 611| | /* The non-greedy case cannot be converted to a possessive form. */ 612| | 613| 349k| if (base_list[1] == 0) return FALSE; ------------------ | | 69| 26.7k|#define FALSE 0 ------------------ | Branch (613:9): [True: 26.7k, False: 323k] ------------------ 614| | 615| | /* If the bracket is capturing it might be referenced by an OP_RECURSE 616| | so its last iterator can never be possessified if the pattern contains 617| | recursions. (This could be improved by keeping a list of group numbers that 618| | are called by recursion.) */ 619| | 620| 323k| switch(*(code - GET(code, 1))) ------------------ | | 109| 323k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (620:12): [True: 152k, False: 170k] ------------------ 621| 323k| { 622| 161k| case OP_CBRA: ------------------ | Branch (622:7): [True: 161k, False: 162k] ------------------ 623| 161k| case OP_SCBRA: ------------------ | Branch (623:7): [True: 0, False: 323k] ------------------ 624| 161k| case OP_CBRAPOS: ------------------ | Branch (624:7): [True: 796, False: 322k] ------------------ 625| 162k| case OP_SCBRAPOS: ------------------ | Branch (625:7): [True: 650, False: 322k] ------------------ 626| 162k| if (cb->had_recurse) return FALSE; ------------------ | | 69| 1.68k|#define FALSE 0 ------------------ | Branch (626:11): [True: 1.68k, False: 160k] ------------------ 627| 160k| break; 628| | 629| | /* A script run might have to backtrack if the iterated item can match 630| | characters from more than one script. So give up unless repeating an 631| | explicit character. */ 632| | 633| 160k| case OP_SCRIPT_RUN: ------------------ | Branch (633:7): [True: 1.92k, False: 321k] ------------------ 634| 1.92k| if (base_list[0] != OP_CHAR && base_list[0] != OP_CHARI) ------------------ | Branch (634:11): [True: 1.30k, False: 619] | Branch (634:38): [True: 1.30k, False: 0] ------------------ 635| 1.30k| return FALSE; ------------------ | | 69| 1.30k|#define FALSE 0 ------------------ 636| 619| break; 637| | 638| | /* Atomic sub-patterns and assertions can always auto-possessify their 639| | last iterator. However, if the group was entered as a result of checking 640| | a previous iterator, this is not possible. */ 641| | 642| 2.31k| case OP_ASSERT: ------------------ | Branch (642:7): [True: 2.31k, False: 320k] ------------------ 643| 2.94k| case OP_ASSERT_NOT: ------------------ | Branch (643:7): [True: 635, False: 322k] ------------------ 644| 3.15k| case OP_ASSERTBACK: ------------------ | Branch (644:7): [True: 204, False: 322k] ------------------ 645| 3.48k| case OP_ASSERTBACK_NOT: ------------------ | Branch (645:7): [True: 330, False: 322k] ------------------ 646| 5.35k| case OP_ONCE: ------------------ | Branch (646:7): [True: 1.87k, False: 321k] ------------------ 647| 5.35k| return !entered_a_group; 648| | 649| | /* Non-atomic assertions - don't possessify last iterator. This needs 650| | more thought. */ 651| | 652| 945| case OP_ASSERT_NA: ------------------ | Branch (652:7): [True: 945, False: 322k] ------------------ 653| 1.16k| case OP_ASSERTBACK_NA: ------------------ | Branch (653:7): [True: 218, False: 322k] ------------------ 654| 1.16k| return FALSE; ------------------ | | 69| 1.16k|#define FALSE 0 ------------------ 655| 323k| } 656| | 657| | /* Skip over the bracket and inspect what comes next. */ 658| | 659| 313k| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 313k|#define PRIV(name) _pcre2_##name ------------------ 660| 313k| continue; 661| | 662| | /* Handle cases where the next item is a group. */ 663| | 664| 410| case OP_ONCE: ------------------ | Branch (664:5): [True: 410, False: 893k] ------------------ 665| 8.63k| case OP_BRA: ------------------ | Branch (665:5): [True: 8.22k, False: 886k] ------------------ 666| 160k| case OP_CBRA: ------------------ | Branch (666:5): [True: 151k, False: 742k] ------------------ 667| 160k| next_code = code + GET(code, 1); ------------------ | | 109| 160k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 668| 160k| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 160k|#define PRIV(name) _pcre2_##name ------------------ 669| | 670| | /* Check each branch. We have to recurse a level for all but the last 671| | branch. */ 672| | 673| 170k| while (*next_code == OP_ALT) ------------------ | Branch (673:12): [True: 48.1k, False: 122k] ------------------ 674| 48.1k| { 675| 48.1k| if (!compare_opcodes(code, utf, ucp, cb, base_list, base_end, rec_limit)) ------------------ | Branch (675:11): [True: 38.2k, False: 9.85k] ------------------ 676| 38.2k| return FALSE; ------------------ | | 69| 38.2k|#define FALSE 0 ------------------ 677| 9.85k| code = next_code + 1 + LINK_SIZE; ------------------ | | 165| 9.85k|#define LINK_SIZE 2 ------------------ 678| 9.85k| next_code += GET(next_code, 1); ------------------ | | 109| 9.85k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 679| 9.85k| } 680| | 681| 122k| entered_a_group = TRUE; ------------------ | | 70| 122k|#define TRUE 1 ------------------ 682| 122k| continue; 683| | 684| 5.06k| case OP_BRAZERO: ------------------ | Branch (684:5): [True: 5.06k, False: 889k] ------------------ 685| 5.36k| case OP_BRAMINZERO: ------------------ | Branch (685:5): [True: 298, False: 894k] ------------------ 686| | 687| 5.36k| next_code = code + 1; 688| 5.36k| if (*next_code != OP_BRA && *next_code != OP_CBRA && ------------------ | Branch (688:9): [True: 3.27k, False: 2.09k] | Branch (688:33): [True: 1.23k, False: 2.03k] ------------------ 689| 5.36k| *next_code != OP_ONCE) return FALSE; ------------------ | | 69| 871|#define FALSE 0 ------------------ | Branch (689:9): [True: 871, False: 364] ------------------ 690| | 691| 5.04k| do next_code += GET(next_code, 1); while (*next_code == OP_ALT); ------------------ | | 109| 5.04k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (691:47): [True: 554, False: 4.49k] ------------------ 692| | 693| | /* The bracket content will be checked by the OP_BRA/OP_CBRA case above. */ 694| | 695| 4.49k| next_code += 1 + LINK_SIZE; ------------------ | | 165| 4.49k|#define LINK_SIZE 2 ------------------ 696| 4.49k| if (!compare_opcodes(next_code, utf, ucp, cb, base_list, base_end, ------------------ | Branch (696:9): [True: 1.59k, False: 2.89k] ------------------ 697| 4.49k| rec_limit)) 698| 1.59k| return FALSE; ------------------ | | 69| 1.59k|#define FALSE 0 ------------------ 699| | 700| 2.89k| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 2.89k|#define PRIV(name) _pcre2_##name ------------------ 701| 2.89k| continue; 702| | 703| | /* The next opcode does not need special handling; fall through and use it 704| | to see if the base can be possessified. */ 705| | 706| 363k| default: ------------------ | Branch (706:5): [True: 363k, False: 530k] ------------------ 707| 363k| break; 708| 894k| } 709| | 710| | /* We now have the next appropriate opcode to compare with the base. Check 711| | for a supported opcode, and load its properties. */ 712| | 713| 363k| code = get_chr_property_list(code, utf, ucp, cb->fcc, list); 714| 363k| if (code == NULL) return FALSE; /* Unsupported */ ------------------ | | 69| 9.25k|#define FALSE 0 ------------------ | Branch (714:7): [True: 9.25k, False: 354k] ------------------ 715| | 716| | /* If either opcode is a small character list, set pointers for comparing 717| | characters from that list with another list, or with a property. */ 718| | 719| 354k| if (base_list[0] == OP_CHAR) ------------------ | Branch (719:7): [True: 131k, False: 222k] ------------------ 720| 131k| { 721| 131k| chr_ptr = base_list + 2; 722| 131k| list_ptr = list; 723| 131k| } 724| 222k| else if (list[0] == OP_CHAR) ------------------ | Branch (724:12): [True: 106k, False: 115k] ------------------ 725| 106k| { 726| 106k| chr_ptr = list + 2; 727| 106k| list_ptr = base_list; 728| 106k| } 729| | 730| | /* Character bitsets can also be compared to certain opcodes. */ 731| | 732| 115k| else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS ------------------ | Branch (732:12): [True: 8.75k, False: 106k] | Branch (732:40): [True: 3.52k, False: 103k] ------------------ 733| 115k|#if PCRE2_CODE_UNIT_WIDTH == 8 734| | /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */ 735| 115k| || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS)) ------------------ | Branch (735:11): [True: 92.4k, False: 10.7k] | Branch (735:20): [True: 1.11k, False: 91.3k] | Branch (735:49): [True: 457, False: 90.9k] ------------------ 736| 115k|#endif 737| 115k| ) 738| 13.8k| { 739| 13.8k|#if PCRE2_CODE_UNIT_WIDTH == 8 740| 13.8k| if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS)) ------------------ | Branch (740:9): [True: 8.75k, False: 5.09k] | Branch (740:38): [True: 3.51k, False: 1.57k] | Branch (740:46): [True: 1.42k, False: 2.08k] ------------------ 741| |#else 742| | if (base_list[0] == OP_CLASS) 743| |#endif 744| 10.1k| { 745| 10.1k| set1 = (uint8_t *)(base_end - base_list[2]); 746| 10.1k| list_ptr = list; 747| 10.1k| } 748| 3.66k| else 749| 3.66k| { 750| 3.66k| set1 = (uint8_t *)(code - list[2]); 751| 3.66k| list_ptr = base_list; 752| 3.66k| } 753| | 754| 13.8k| invert_bits = FALSE; ------------------ | | 69| 13.8k|#define FALSE 0 ------------------ 755| 13.8k| switch(list_ptr[0]) 756| 13.8k| { 757| 6.75k| case OP_CLASS: ------------------ | Branch (757:7): [True: 6.75k, False: 7.09k] ------------------ 758| 8.05k| case OP_NCLASS: ------------------ | Branch (758:7): [True: 1.29k, False: 12.5k] ------------------ 759| 8.05k| set2 = (uint8_t *) 760| 8.05k| ((list_ptr == list ? code : base_end) - list_ptr[2]); ------------------ | Branch (760:11): [True: 7.82k, False: 227] ------------------ 761| 8.05k| break; 762| | 763| 0|#ifdef SUPPORT_WIDE_CHARS 764| 1.99k| case OP_XCLASS: ------------------ | Branch (764:7): [True: 1.99k, False: 11.8k] ------------------ 765| 1.99k| xclass_flags = (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE; ------------------ | | 165| 1.99k|#define LINK_SIZE 2 ------------------ | Branch (765:23): [True: 1.03k, False: 965] ------------------ 766| 1.99k| if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE; ------------------ | | 1311| 1.99k|#define XCL_HASPROP 0x04 /* Flag: property checks are present. */ ------------------ if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE; ------------------ | | 69| 241|#define FALSE 0 ------------------ | Branch (766:11): [True: 241, False: 1.75k] ------------------ 767| 1.75k| if ((*xclass_flags & XCL_MAP) == 0) ------------------ | | 1310| 1.75k|#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */ ------------------ | Branch (767:11): [True: 699, False: 1.05k] ------------------ 768| 699| { 769| | /* No bits are set for characters < 256. */ 770| 699| if (list[1] == 0) return (*xclass_flags & XCL_NOT) == 0; ------------------ | | 1309| 353|#define XCL_NOT 0x01 /* Flag: this is a negative class */ ------------------ | Branch (770:13): [True: 353, False: 346] ------------------ 771| | /* Might be an empty repeat. */ 772| 346| continue; 773| 699| } 774| 1.05k| set2 = (uint8_t *)(xclass_flags + 1); 775| 1.05k| break; 776| 0|#endif 777| | 778| 290| case OP_NOT_DIGIT: ------------------ | Branch (778:7): [True: 290, False: 13.5k] ------------------ 779| 290| invert_bits = TRUE; ------------------ | | 70| 290|#define TRUE 1 ------------------ 780| | /* Fall through */ 781| 626| case OP_DIGIT: ------------------ | Branch (781:7): [True: 336, False: 13.5k] ------------------ 782| 626| set2 = (uint8_t *)(cb->cbits + cbit_digit); ------------------ | | 565| 626|#define cbit_digit 64 /* [:digit:] or \d */ ------------------ 783| 626| break; 784| | 785| 263| case OP_NOT_WHITESPACE: ------------------ | Branch (785:7): [True: 263, False: 13.5k] ------------------ 786| 263| invert_bits = TRUE; ------------------ | | 70| 263|#define TRUE 1 ------------------ 787| | /* Fall through */ 788| 507| case OP_WHITESPACE: ------------------ | Branch (788:7): [True: 244, False: 13.6k] ------------------ 789| 507| set2 = (uint8_t *)(cb->cbits + cbit_space); ------------------ | | 563| 507|#define cbit_space 0 /* [:space:] or \s */ ------------------ 790| 507| break; 791| | 792| 519| case OP_NOT_WORDCHAR: ------------------ | Branch (792:7): [True: 519, False: 13.3k] ------------------ 793| 519| invert_bits = TRUE; ------------------ | | 70| 519|#define TRUE 1 ------------------ 794| | /* Fall through */ 795| 1.03k| case OP_WORDCHAR: ------------------ | Branch (795:7): [True: 520, False: 13.3k] ------------------ 796| 1.03k| set2 = (uint8_t *)(cb->cbits + cbit_word); ------------------ | | 568| 1.03k|#define cbit_word 160 /* [:word:] or \w */ ------------------ 797| 1.03k| break; 798| | 799| 1.62k| default: ------------------ | Branch (799:7): [True: 1.62k, False: 12.2k] ------------------ 800| 1.62k| return FALSE; ------------------ | | 69| 1.62k|#define FALSE 0 ------------------ 801| 13.8k| } 802| | 803| | /* Because the bit sets are unaligned bytes, we need to perform byte 804| | comparison here. */ 805| | 806| 11.2k| set_end = set1 + 32; 807| 11.2k| if (invert_bits) ------------------ | Branch (807:9): [True: 1.07k, False: 10.2k] ------------------ 808| 1.07k| { 809| 1.07k| do 810| 18.8k| { 811| 18.8k| if ((*set1++ & ~(*set2++)) != 0) return FALSE; ------------------ | | 69| 559|#define FALSE 0 ------------------ | Branch (811:13): [True: 559, False: 18.2k] ------------------ 812| 18.8k| } 813| 18.2k| while (set1 < set_end); ------------------ | Branch (813:14): [True: 17.7k, False: 513] ------------------ 814| 1.07k| } 815| 10.2k| else 816| 10.2k| { 817| 10.2k| do 818| 183k| { 819| 183k| if ((*set1++ & *set2++) != 0) return FALSE; ------------------ | | 69| 5.80k|#define FALSE 0 ------------------ | Branch (819:13): [True: 5.80k, False: 177k] ------------------ 820| 183k| } 821| 177k| while (set1 < set_end); ------------------ | Branch (821:14): [True: 173k, False: 4.40k] ------------------ 822| 10.2k| } 823| | 824| 4.91k| if (list[1] == 0) return TRUE; ------------------ | | 70| 4.16k|#define TRUE 1 ------------------ | Branch (824:9): [True: 4.16k, False: 752] ------------------ 825| | /* Might be an empty repeat. */ 826| 752| continue; 827| 4.91k| } 828| | 829| | /* Some property combinations also acceptable. Unicode property opcodes are 830| | processed specially; the rest can be handled with a lookup table. */ 831| | 832| 101k| else 833| 101k| { 834| 101k| uint32_t leftop, rightop; 835| | 836| 101k| leftop = base_list[0]; 837| 101k| rightop = list[0]; 838| | 839| 101k|#ifdef SUPPORT_UNICODE 840| 101k| accepted = FALSE; /* Always set in non-unicode case. */ ------------------ | | 69| 101k|#define FALSE 0 ------------------ 841| 101k| if (leftop == OP_PROP || leftop == OP_NOTPROP) ------------------ | Branch (841:9): [True: 14.0k, False: 87.5k] | Branch (841:30): [True: 8.76k, False: 78.8k] ------------------ 842| 22.8k| { 843| 22.8k| if (rightop == OP_EOD) ------------------ | Branch (843:11): [True: 256, False: 22.5k] ------------------ 844| 256| accepted = TRUE; ------------------ | | 70| 256|#define TRUE 1 ------------------ 845| 22.5k| else if (rightop == OP_PROP || rightop == OP_NOTPROP) ------------------ | Branch (845:16): [True: 8.03k, False: 14.5k] | Branch (845:38): [True: 8.83k, False: 5.68k] ------------------ 846| 16.8k| { 847| 16.8k| int n; 848| 16.8k| const uint8_t *p; 849| 16.8k| BOOL same = leftop == rightop; 850| 16.8k| BOOL lisprop = leftop == OP_PROP; 851| 16.8k| BOOL risprop = rightop == OP_PROP; 852| 16.8k| BOOL bothprop = lisprop && risprop; ------------------ | Branch (852:25): [True: 9.57k, False: 7.29k] | Branch (852:36): [True: 6.13k, False: 3.44k] ------------------ 853| | 854| | /* There's a table that specifies how each combination is to be 855| | processed: 856| | 0 Always return FALSE (never auto-possessify) 857| | 1 Character groups are distinct (possessify if both are OP_PROP) 858| | 2 Check character categories in the same group (general or particular) 859| | 3 Return TRUE if the two opcodes are not the same 860| | ... see comments below 861| | */ 862| | 863| 16.8k| n = propposstab[base_list[2]][list[2]]; 864| 16.8k| switch(n) ------------------ | Branch (864:16): [True: 0, False: 16.8k] ------------------ 865| 16.8k| { 866| 629| case 0: break; ------------------ | Branch (866:11): [True: 629, False: 16.2k] ------------------ 867| 293| case 1: accepted = bothprop; break; ------------------ | Branch (867:11): [True: 293, False: 16.5k] ------------------ 868| 2.89k| case 2: accepted = (base_list[3] == list[3]) != same; break; ------------------ | Branch (868:11): [True: 2.89k, False: 13.9k] ------------------ 869| 2.14k| case 3: accepted = !same; break; ------------------ | Branch (869:11): [True: 2.14k, False: 14.7k] ------------------ 870| | 871| 1.84k| case 4: /* Left general category, right particular category */ ------------------ | Branch (871:11): [True: 1.84k, False: 15.0k] ------------------ 872| 1.84k| accepted = risprop && catposstab[base_list[3]][list[3]] == same; ------------------ | Branch (872:22): [True: 1.00k, False: 834] | Branch (872:33): [True: 1.00k, False: 1] ------------------ 873| 1.84k| break; 874| | 875| 569| case 5: /* Right general category, left particular category */ ------------------ | Branch (875:11): [True: 569, False: 16.2k] ------------------ 876| 569| accepted = lisprop && catposstab[list[3]][base_list[3]] == same; ------------------ | Branch (876:22): [True: 343, False: 226] | Branch (876:33): [True: 324, False: 19] ------------------ 877| 569| break; 878| | 879| | /* This code is logically tricky. Think hard before fiddling with it. 880| | The posspropstab table has four entries per row. Each row relates to 881| | one of PCRE's special properties such as ALNUM or SPACE or WORD. 882| | Only WORD actually needs all four entries, but using repeats for the 883| | others means they can all use the same code below. 884| | 885| | The first two entries in each row are Unicode general categories, and 886| | apply always, because all the characters they include are part of the 887| | PCRE character set. The third and fourth entries are a general and a 888| | particular category, respectively, that include one or more relevant 889| | characters. One or the other is used, depending on whether the check 890| | is for a general or a particular category. However, in both cases the 891| | category contains more characters than the specials that are defined 892| | for the property being tested against. Therefore, it cannot be used 893| | in a NOTPROP case. 894| | 895| | Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po. 896| | Underscore is covered by ucp_P or ucp_Po. */ 897| | 898| 292| case 6: /* Left alphanum vs right general category */ ------------------ | Branch (898:11): [True: 292, False: 16.5k] ------------------ 899| 1.12k| case 7: /* Left space vs right general category */ ------------------ | Branch (899:11): [True: 828, False: 16.0k] ------------------ 900| 2.36k| case 8: /* Left word vs right general category */ ------------------ | Branch (900:11): [True: 1.24k, False: 15.6k] ------------------ 901| 2.36k| p = posspropstab[n-6]; 902| 2.36k| accepted = risprop && lisprop == ------------------ | Branch (902:22): [True: 1.84k, False: 521] | Branch (902:33): [True: 612, False: 1.23k] ------------------ 903| 1.84k| (list[3] != p[0] && ------------------ | Branch (903:14): [True: 1.57k, False: 275] ------------------ 904| 1.84k| list[3] != p[1] && ------------------ | Branch (904:14): [True: 994, False: 578] ------------------ 905| 1.84k| (list[3] != p[2] || !lisprop)); ------------------ | Branch (905:14): [True: 731, False: 263] | Branch (905:33): [True: 33, False: 230] ------------------ 906| 2.36k| break; 907| | 908| 213| case 9: /* Right alphanum vs left general category */ ------------------ | Branch (908:11): [True: 213, False: 16.6k] ------------------ 909| 527| case 10: /* Right space vs left general category */ ------------------ | Branch (909:11): [True: 314, False: 16.5k] ------------------ 910| 2.65k| case 11: /* Right word vs left general category */ ------------------ | Branch (910:11): [True: 2.12k, False: 14.7k] ------------------ 911| 2.65k| p = posspropstab[n-9]; 912| 2.65k| accepted = lisprop && risprop == ------------------ | Branch (912:22): [True: 2.31k, False: 335] | Branch (912:33): [True: 1.35k, False: 964] ------------------ 913| 2.31k| (base_list[3] != p[0] && ------------------ | Branch (913:14): [True: 1.88k, False: 428] ------------------ 914| 2.31k| base_list[3] != p[1] && ------------------ | Branch (914:14): [True: 1.04k, False: 846] ------------------ 915| 2.31k| (base_list[3] != p[2] || !risprop)); ------------------ | Branch (915:14): [True: 561, False: 480] | Branch (915:38): [True: 460, False: 20] ------------------ 916| 2.65k| break; 917| | 918| 271| case 12: /* Left alphanum vs right particular category */ ------------------ | Branch (918:11): [True: 271, False: 16.5k] ------------------ 919| 1.10k| case 13: /* Left space vs right particular category */ ------------------ | Branch (919:11): [True: 838, False: 16.0k] ------------------ 920| 1.69k| case 14: /* Left word vs right particular category */ ------------------ | Branch (920:11): [True: 583, False: 16.2k] ------------------ 921| 1.69k| p = posspropstab[n-12]; 922| 1.69k| accepted = risprop && lisprop == ------------------ | Branch (922:22): [True: 1.34k, False: 344] | Branch (922:33): [True: 474, False: 874] ------------------ 923| 1.34k| (catposstab[p[0]][list[3]] && ------------------ | Branch (923:14): [True: 1.07k, False: 269] ------------------ 924| 1.34k| catposstab[p[1]][list[3]] && ------------------ | Branch (924:14): [True: 797, False: 282] ------------------ 925| 1.34k| (list[3] != p[3] || !lisprop)); ------------------ | Branch (925:14): [True: 211, False: 586] | Branch (925:33): [True: 567, False: 19] ------------------ 926| 1.69k| break; 927| | 928| 429| case 15: /* Right alphanum vs left particular category */ ------------------ | Branch (928:11): [True: 429, False: 16.4k] ------------------ 929| 1.28k| case 16: /* Right space vs left particular category */ ------------------ | Branch (929:11): [True: 857, False: 16.0k] ------------------ 930| 1.78k| case 17: /* Right word vs left particular category */ ------------------ | Branch (930:11): [True: 496, False: 16.3k] ------------------ 931| 1.78k| p = posspropstab[n-15]; 932| 1.78k| accepted = lisprop && risprop == ------------------ | Branch (932:22): [True: 1.56k, False: 218] | Branch (932:33): [True: 416, False: 1.14k] ------------------ 933| 1.56k| (catposstab[p[0]][base_list[3]] && ------------------ | Branch (933:14): [True: 1.24k, False: 322] ------------------ 934| 1.56k| catposstab[p[1]][base_list[3]] && ------------------ | Branch (934:14): [True: 857, False: 385] ------------------ 935| 1.56k| (base_list[3] != p[3] || !risprop)); ------------------ | Branch (935:14): [True: 234, False: 623] | Branch (935:38): [True: 623, False: 0] ------------------ 936| 1.78k| break; 937| 16.8k| } 938| 16.8k| } 939| 22.8k| } 940| | 941| 78.8k| else 942| 78.8k|#endif /* SUPPORT_UNICODE */ 943| | 944| 78.8k| accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP && ------------------ | | 1363| 157k|#define FIRST_AUTOTAB_OP OP_NOT_DIGIT ------------------ accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP && ------------------ | | 1364| 157k|#define LAST_AUTOTAB_LEFT_OP OP_EXTUNI ------------------ | Branch (944:16): [True: 78.8k, False: 0] | Branch (944:46): [True: 75.0k, False: 3.70k] ------------------ 945| 78.8k| rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP && ------------------ | | 1363| 153k|#define FIRST_AUTOTAB_OP OP_NOT_DIGIT ------------------ rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP && ------------------ | | 1365| 153k|#define LAST_AUTOTAB_RIGHT_OP OP_DOLLM ------------------ | Branch (945:12): [True: 75.0k, False: 0] | Branch (945:43): [True: 73.9k, False: 1.17k] ------------------ 946| 78.8k| autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP]; ------------------ | | 1363| 73.9k|#define FIRST_AUTOTAB_OP OP_NOT_DIGIT ------------------ autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP]; ------------------ | | 1363| 73.9k|#define FIRST_AUTOTAB_OP OP_NOT_DIGIT ------------------ | Branch (946:12): [True: 3.38k, False: 70.5k] ------------------ 947| | 948| 101k| if (!accepted) return FALSE; ------------------ | | 69| 93.7k|#define FALSE 0 ------------------ | Branch (948:9): [True: 93.7k, False: 7.85k] ------------------ 949| | 950| 7.85k| if (list[1] == 0) return TRUE; ------------------ | | 70| 7.32k|#define TRUE 1 ------------------ | Branch (950:9): [True: 7.32k, False: 530] ------------------ 951| | /* Might be an empty repeat. */ 952| 530| continue; 953| 7.85k| } 954| | 955| | /* Control reaches here only if one of the items is a small character list. 956| | All characters are checked against the other side. */ 957| | 958| 238k| do 959| 246k| { 960| 246k| chr = *chr_ptr; 961| | 962| 246k| switch(list_ptr[0]) 963| 246k| { 964| 59.7k| case OP_CHAR: ------------------ | Branch (964:7): [True: 59.7k, False: 186k] ------------------ 965| 59.7k| ochr_ptr = list_ptr + 2; 966| 59.7k| do 967| 65.1k| { 968| 65.1k| if (chr == *ochr_ptr) return FALSE; ------------------ | | 69| 29.4k|#define FALSE 0 ------------------ | Branch (968:13): [True: 29.4k, False: 35.6k] ------------------ 969| 35.6k| ochr_ptr++; 970| 35.6k| } 971| 59.7k| while(*ochr_ptr != NOTACHAR); ------------------ | | 205| 35.6k|#define NOTACHAR 0xffffffff ------------------ | Branch (971:13): [True: 5.45k, False: 30.2k] ------------------ 972| 30.2k| break; 973| | 974| 30.2k| case OP_NOT: ------------------ | Branch (974:7): [True: 19.5k, False: 226k] ------------------ 975| 19.5k| ochr_ptr = list_ptr + 2; 976| 19.5k| do 977| 21.1k| { 978| 21.1k| if (chr == *ochr_ptr) ------------------ | Branch (978:13): [True: 4.06k, False: 17.0k] ------------------ 979| 4.06k| break; 980| 17.0k| ochr_ptr++; 981| 17.0k| } 982| 19.5k| while(*ochr_ptr != NOTACHAR); ------------------ | | 205| 17.0k|#define NOTACHAR 0xffffffff ------------------ | Branch (982:13): [True: 1.55k, False: 15.5k] ------------------ 983| 19.5k| if (*ochr_ptr == NOTACHAR) return FALSE; /* Not found */ ------------------ | | 205| 19.5k|#define NOTACHAR 0xffffffff ------------------ if (*ochr_ptr == NOTACHAR) return FALSE; /* Not found */ ------------------ | | 69| 15.5k|#define FALSE 0 ------------------ | Branch (983:11): [True: 15.5k, False: 4.06k] ------------------ 984| 4.06k| break; 985| | 986| | /* Note that OP_DIGIT etc. are generated only when PCRE2_UCP is *not* 987| | set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */ 988| | 989| 5.94k| case OP_DIGIT: ------------------ | Branch (989:7): [True: 5.94k, False: 240k] ------------------ 990| 5.94k| if (chr < 256 && (cb->ctypes[chr] & ctype_digit) != 0) return FALSE; ------------------ | | 582| 5.33k|#define ctype_digit 0x08 ------------------ if (chr < 256 && (cb->ctypes[chr] & ctype_digit) != 0) return FALSE; ------------------ | | 69| 432|#define FALSE 0 ------------------ | Branch (990:11): [True: 5.33k, False: 608] | Branch (990:24): [True: 432, False: 4.90k] ------------------ 991| 5.51k| break; 992| | 993| 5.51k| case OP_NOT_DIGIT: ------------------ | Branch (993:7): [True: 2.50k, False: 243k] ------------------ 994| 2.50k| if (chr > 255 || (cb->ctypes[chr] & ctype_digit) == 0) return FALSE; ------------------ | | 582| 2.19k|#define ctype_digit 0x08 ------------------ if (chr > 255 || (cb->ctypes[chr] & ctype_digit) == 0) return FALSE; ------------------ | | 69| 2.02k|#define FALSE 0 ------------------ | Branch (994:11): [True: 309, False: 2.19k] | Branch (994:24): [True: 1.71k, False: 485] ------------------ 995| 485| break; 996| | 997| 8.06k| case OP_WHITESPACE: ------------------ | Branch (997:7): [True: 8.06k, False: 238k] ------------------ 998| 8.06k| if (chr < 256 && (cb->ctypes[chr] & ctype_space) != 0) return FALSE; ------------------ | | 579| 7.70k|#define ctype_space 0x01 ------------------ if (chr < 256 && (cb->ctypes[chr] & ctype_space) != 0) return FALSE; ------------------ | | 69| 999|#define FALSE 0 ------------------ | Branch (998:11): [True: 7.70k, False: 355] | Branch (998:24): [True: 999, False: 6.70k] ------------------ 999| 7.06k| break; 1000| | 1001| 17.5k| case OP_NOT_WHITESPACE: ------------------ | Branch (1001:7): [True: 17.5k, False: 228k] ------------------ 1002| 17.5k| if (chr > 255 || (cb->ctypes[chr] & ctype_space) == 0) return FALSE; ------------------ | | 579| 17.1k|#define ctype_space 0x01 ------------------ if (chr > 255 || (cb->ctypes[chr] & ctype_space) == 0) return FALSE; ------------------ | | 69| 15.3k|#define FALSE 0 ------------------ | Branch (1002:11): [True: 360, False: 17.1k] | Branch (1002:24): [True: 14.9k, False: 2.24k] ------------------ 1003| 2.24k| break; 1004| | 1005| 2.64k| case OP_WORDCHAR: ------------------ | Branch (1005:7): [True: 2.64k, False: 243k] ------------------ 1006| 2.64k| if (chr < 255 && (cb->ctypes[chr] & ctype_word) != 0) return FALSE; ------------------ | | 583| 2.44k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ if (chr < 255 && (cb->ctypes[chr] & ctype_word) != 0) return FALSE; ------------------ | | 69| 538|#define FALSE 0 ------------------ | Branch (1006:11): [True: 2.44k, False: 200] | Branch (1006:24): [True: 538, False: 1.91k] ------------------ 1007| 2.11k| break; 1008| | 1009| 5.06k| case OP_NOT_WORDCHAR: ------------------ | Branch (1009:7): [True: 5.06k, False: 241k] ------------------ 1010| 5.06k| if (chr > 255 || (cb->ctypes[chr] & ctype_word) == 0) return FALSE; ------------------ | | 583| 4.03k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ if (chr > 255 || (cb->ctypes[chr] & ctype_word) == 0) return FALSE; ------------------ | | 69| 3.75k|#define FALSE 0 ------------------ | Branch (1010:11): [True: 1.03k, False: 4.03k] | Branch (1010:24): [True: 2.72k, False: 1.30k] ------------------ 1011| 1.30k| break; 1012| | 1013| 17.9k| case OP_HSPACE: ------------------ | Branch (1013:7): [True: 17.9k, False: 228k] ------------------ 1014| 17.9k| switch(chr) 1015| 17.9k| { 1016| 8.67k| HSPACE_CASES: return FALSE; ------------------ | | 412| 1.53k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 326| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 326|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 326, False: 17.6k] | | | | ------------------ | | | | 408| 1.17k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.17k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 845, False: 17.0k] | | | | ------------------ | | | | 409| 1.53k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 2.35k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 2.35k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 819, False: 17.1k] | | | | ------------------ | | | | 390| 3.11k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 753, False: 17.1k] | | | | ------------------ | | | | 391| 3.40k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 297, False: 17.6k] | | | | ------------------ | | | | 392| 4.01k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 603, False: 17.3k] | | | | ------------------ | | | | 393| 4.52k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 515, False: 17.4k] | | | | ------------------ | | | | 394| 4.73k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 205, False: 17.7k] | | | | ------------------ | | | | 395| 5.06k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 339, False: 17.5k] | | | | ------------------ | | | | 396| 5.33k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 262, False: 17.6k] | | | | ------------------ | | | | 397| 5.83k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 504, False: 17.4k] | | | | ------------------ | | | | 398| 6.08k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 246, False: 17.6k] | | | | ------------------ | | | | 399| 6.38k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 305, False: 17.6k] | | | | ------------------ | | | | 400| 6.69k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 313, False: 17.6k] | | | | ------------------ | | | | 401| 7.31k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 611, False: 17.3k] | | | | ------------------ | | | | 402| 8.12k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 812, False: 17.1k] | | | | ------------------ | | | | 403| 8.44k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 320, False: 17.6k] | | | | ------------------ | | | | 404| 8.67k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ HSPACE_CASES: return FALSE; ------------------ | | 69| 8.67k|#define FALSE 0 ------------------ 1017| 9.26k| default: break; ------------------ | Branch (1017:9): [True: 9.26k, False: 8.67k] ------------------ 1018| 17.9k| } 1019| 9.26k| break; 1020| | 1021| 19.7k| case OP_NOT_HSPACE: ------------------ | Branch (1021:7): [True: 19.7k, False: 226k] ------------------ 1022| 19.7k| switch(chr) 1023| 19.7k| { 1024| 9.44k| HSPACE_CASES: break; ------------------ | | 412| 1.43k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 340| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 340|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 340, False: 19.4k] | | | | ------------------ | | | | 408| 1.18k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.18k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 846, False: 18.9k] | | | | ------------------ | | | | 409| 1.43k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.70k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.70k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 274, False: 19.4k] | | | | ------------------ | | | | 390| 2.50k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 798, False: 18.9k] | | | | ------------------ | | | | 391| 2.81k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 314, False: 19.4k] | | | | ------------------ | | | | 392| 3.14k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 329, False: 19.4k] | | | | ------------------ | | | | 393| 3.71k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 564, False: 19.2k] | | | | ------------------ | | | | 394| 4.75k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 1.04k, False: 18.7k] | | | | ------------------ | | | | 395| 5.10k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 352, False: 19.4k] | | | | ------------------ | | | | 396| 5.60k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 501, False: 19.2k] | | | | ------------------ | | | | 397| 5.84k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 237, False: 19.5k] | | | | ------------------ | | | | 398| 6.13k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 293, False: 19.4k] | | | | ------------------ | | | | 399| 6.63k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 499, False: 19.2k] | | | | ------------------ | | | | 400| 7.22k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 583, False: 19.1k] | | | | ------------------ | | | | 401| 8.29k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 1.07k, False: 18.6k] | | | | ------------------ | | | | 402| 8.80k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 511, False: 19.2k] | | | | ------------------ | | | | 403| 9.13k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 326, False: 19.4k] | | | | ------------------ | | | | 404| 9.44k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 1025| 10.3k| default: return FALSE; ------------------ | | 69| 10.3k|#define FALSE 0 ------------------ | Branch (1025:9): [True: 10.3k, False: 9.44k] ------------------ 1026| 19.7k| } 1027| 9.44k| break; 1028| | 1029| 9.44k| case OP_ANYNL: ------------------ | Branch (1029:7): [True: 5.72k, False: 240k] ------------------ 1030| 9.24k| case OP_VSPACE: ------------------ | Branch (1030:7): [True: 3.51k, False: 242k] ------------------ 1031| 9.24k| switch(chr) 1032| 9.24k| { 1033| 3.89k| VSPACE_CASES: return FALSE; ------------------ | | 430| 1.57k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 310| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 310|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 310, False: 8.93k] | | | | ------------------ | | | | 424| 757| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 757|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 447, False: 8.79k] | | | | ------------------ | | | | 425| 1.02k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.02k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 271, False: 8.97k] | | | | ------------------ | | | | 426| 1.35k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.35k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 325, False: 8.92k] | | | | ------------------ | | | | 427| 1.57k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 2.90k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 2.90k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 1.33k, False: 7.91k] | | | | ------------------ | | | | 420| 3.89k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ VSPACE_CASES: return FALSE; ------------------ | | 69| 3.89k|#define FALSE 0 ------------------ 1034| 5.34k| default: break; ------------------ | Branch (1034:9): [True: 5.34k, False: 3.89k] ------------------ 1035| 9.24k| } 1036| 5.34k| break; 1037| | 1038| 10.1k| case OP_NOT_VSPACE: ------------------ | Branch (1038:7): [True: 10.1k, False: 236k] ------------------ 1039| 10.1k| switch(chr) 1040| 10.1k| { 1041| 4.77k| VSPACE_CASES: break; ------------------ | | 430| 2.26k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 307| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 307|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 307, False: 9.79k] | | | | ------------------ | | | | 424| 1.57k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 1.57k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 1.27k, False: 8.83k] | | | | ------------------ | | | | 425| 1.82k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.82k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 248, False: 9.85k] | | | | ------------------ | | | | 426| 2.05k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 2.05k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 232, False: 9.87k] | | | | ------------------ | | | | 427| 2.26k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 3.59k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 3.59k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 1.33k, False: 8.76k] | | | | ------------------ | | | | 420| 4.77k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 1042| 5.32k| default: return FALSE; ------------------ | | 69| 5.32k|#define FALSE 0 ------------------ | Branch (1042:9): [True: 5.32k, False: 4.77k] ------------------ 1043| 10.1k| } 1044| 4.77k| break; 1045| | 1046| 7.01k| case OP_DOLL: ------------------ | Branch (1046:7): [True: 7.01k, False: 239k] ------------------ 1047| 7.34k| case OP_EODN: ------------------ | Branch (1047:7): [True: 325, False: 245k] ------------------ 1048| 7.34k| switch (chr) ------------------ | Branch (1048:15): [True: 3.00k, False: 4.33k] ------------------ 1049| 7.34k| { 1050| 294| case CHAR_CR: ------------------ | | 972| 294|#define CHAR_CR '\015' ------------------ | Branch (1050:9): [True: 294, False: 7.05k] ------------------ 1051| 1.02k| case CHAR_LF: ------------------ | | 973| 1.02k|#define CHAR_LF '\012' ------------------ | Branch (1051:9): [True: 734, False: 6.61k] ------------------ 1052| 1.25k| case CHAR_VT: ------------------ | | 970| 1.25k|#define CHAR_VT '\013' ------------------ | Branch (1052:9): [True: 230, False: 7.11k] ------------------ 1053| 1.62k| case CHAR_FF: ------------------ | | 971| 1.62k|#define CHAR_FF '\014' ------------------ | Branch (1053:9): [True: 363, False: 6.98k] ------------------ 1054| 2.94k| case CHAR_NEL: ------------------ | | 975| 2.94k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (1054:9): [True: 1.32k, False: 6.01k] ------------------ 1055| 2.94k|#ifndef EBCDIC 1056| 4.08k| case 0x2028: ------------------ | Branch (1056:9): [True: 1.13k, False: 6.20k] ------------------ 1057| 4.33k| case 0x2029: ------------------ | Branch (1057:9): [True: 257, False: 7.08k] ------------------ 1058| 4.33k|#endif /* Not EBCDIC */ 1059| 4.33k| return FALSE; ------------------ | | 69| 4.33k|#define FALSE 0 ------------------ 1060| 7.34k| } 1061| 3.00k| break; 1062| | 1063| 3.00k| case OP_EOD: /* Can always possessify before \z */ ------------------ | Branch (1063:7): [True: 366, False: 245k] ------------------ 1064| 366| break; 1065| | 1066| 0|#ifdef SUPPORT_UNICODE 1067| 10.0k| case OP_PROP: ------------------ | Branch (1067:7): [True: 10.0k, False: 236k] ------------------ 1068| 35.0k| case OP_NOTPROP: ------------------ | Branch (1068:7): [True: 25.0k, False: 221k] ------------------ 1069| 35.0k| if (!check_char_prop(chr, list_ptr[2], list_ptr[3], ------------------ | Branch (1069:11): [True: 11.8k, False: 23.1k] ------------------ 1070| 35.0k| list_ptr[0] == OP_NOTPROP)) 1071| 11.8k| return FALSE; ------------------ | | 69| 11.8k|#define FALSE 0 ------------------ 1072| 23.1k| break; 1073| 23.1k|#endif 1074| | 1075| 23.1k| case OP_NCLASS: ------------------ | Branch (1075:7): [True: 1.88k, False: 244k] ------------------ 1076| 1.88k| if (chr > 255) return FALSE; ------------------ | | 69| 295|#define FALSE 0 ------------------ | Branch (1076:11): [True: 295, False: 1.58k] ------------------ 1077| | /* Fall through */ 1078| | 1079| 11.7k| case OP_CLASS: ------------------ | Branch (1079:7): [True: 10.1k, False: 236k] ------------------ 1080| 11.7k| if (chr > 255) break; ------------------ | Branch (1080:11): [True: 255, False: 11.5k] ------------------ 1081| 11.5k| class_bitset = (uint8_t *) 1082| 11.5k| ((list_ptr == list ? code : base_end) - list_ptr[2]); ------------------ | Branch (1082:11): [True: 2.83k, False: 8.68k] ------------------ 1083| 11.5k| if ((class_bitset[chr >> 3] & (1u << (chr & 7))) != 0) return FALSE; ------------------ | | 69| 3.55k|#define FALSE 0 ------------------ | Branch (1083:11): [True: 3.55k, False: 7.96k] ------------------ 1084| 7.96k| break; 1085| | 1086| 7.96k|#ifdef SUPPORT_WIDE_CHARS 1087| 7.96k| case OP_XCLASS: ------------------ | Branch (1087:7): [True: 1.71k, False: 244k] ------------------ 1088| 1.71k| if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) - ------------------ | | 177| 1.71k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1088:11): [True: 1.00k, False: 705] | Branch (1088:30): [True: 410, False: 1.30k] ------------------ 1089| 1.71k| list_ptr[2] + LINK_SIZE, utf)) return FALSE; ------------------ | | 165| 1.71k|#define LINK_SIZE 2 ------------------ list_ptr[2] + LINK_SIZE, utf)) return FALSE; ------------------ | | 69| 1.00k|#define FALSE 0 ------------------ 1090| 705| break; 1091| 705|#endif 1092| | 1093| 11.5k| default: ------------------ | Branch (1093:7): [True: 11.5k, False: 234k] ------------------ 1094| 11.5k| return FALSE; ------------------ | | 69| 11.5k|#define FALSE 0 ------------------ 1095| 246k| } 1096| | 1097| 117k| chr_ptr++; 1098| 117k| } 1099| 238k| while(*chr_ptr != NOTACHAR); ------------------ | | 205| 117k|#define NOTACHAR 0xffffffff ------------------ | Branch (1099:9): [True: 7.55k, False: 109k] ------------------ 1100| | 1101| | /* At least one character must be matched from this opcode. */ 1102| | 1103| 109k| if (list[1] == 0) return TRUE; ------------------ | | 70| 103k|#define TRUE 1 ------------------ | Branch (1103:7): [True: 103k, False: 6.69k] ------------------ 1104| 109k| } 1105| | 1106| |/* Control never reaches here. There used to be a fail-save return FALSE; here, 1107| |but some compilers complain about an unreachable statement. */ 1108| 447k|} pcre2_auto_possess.c:check_char_prop: 201| 35.0k|{ 202| 35.0k|BOOL ok; 203| 35.0k|const uint32_t *p; 204| 35.0k|const ucd_record *prop = GET_UCD(c); ------------------ | | 1846| 35.0k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 35.0k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 35.0k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 35.0k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 35.0k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 35.0k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 35.0k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 35.0k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 35.0k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 35.0k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 205| | 206| 35.0k|switch(ptype) ------------------ | Branch (206:8): [True: 796, False: 34.2k] ------------------ 207| 35.0k| { 208| 3.37k| case PT_LAMP: ------------------ | | 1276| 3.37k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (208:3): [True: 3.37k, False: 31.7k] ------------------ 209| 3.37k| return (prop->chartype == ucp_Lu || ------------------ | Branch (209:11): [True: 2.39k, False: 974] ------------------ 210| 3.37k| prop->chartype == ucp_Ll || ------------------ | Branch (210:11): [True: 518, False: 456] ------------------ 211| 3.37k| prop->chartype == ucp_Lt) == negated; ------------------ | Branch (211:11): [True: 0, False: 456] ------------------ 212| | 213| 948| case PT_GC: ------------------ | | 1277| 948|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (213:3): [True: 948, False: 34.1k] ------------------ 214| 948| return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated; ------------------ | | 177| 948|#define PRIV(name) _pcre2_##name ------------------ 215| | 216| 1.25k| case PT_PC: ------------------ | | 1278| 1.25k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (216:3): [True: 1.25k, False: 33.8k] ------------------ 217| 1.25k| return (pdata == prop->chartype) == negated; 218| | 219| 1.14k| case PT_SC: ------------------ | | 1279| 1.14k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (219:3): [True: 1.14k, False: 33.9k] ------------------ 220| 1.14k| return (pdata == prop->script) == negated; 221| | 222| 2.15k| case PT_SCX: ------------------ | | 1280| 2.15k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (222:3): [True: 2.15k, False: 32.9k] ------------------ 223| 2.15k| ok = (pdata == prop->script ------------------ | Branch (223:9): [True: 253, False: 1.90k] ------------------ 224| 2.15k| || MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), pdata) != 0); ------------------ | | 1871| 1.90k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (224:12): [True: 0, False: 1.90k] ------------------ 225| 2.15k| return ok == negated; 226| | 227| | /* These are specials */ 228| | 229| 2.22k| case PT_ALNUM: ------------------ | | 1281| 2.22k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (229:3): [True: 2.22k, False: 32.8k] ------------------ 230| 2.22k| return (PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 2.22k|#define PRIV(name) _pcre2_##name ------------------ | Branch (230:11): [True: 484, False: 1.73k] ------------------ 231| 2.22k| PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated; ------------------ | | 177| 1.73k|#define PRIV(name) _pcre2_##name ------------------ | Branch (231:11): [True: 21, False: 1.71k] ------------------ 232| | 233| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, which 234| | means that Perl space and POSIX space are now identical. PCRE was changed 235| | at release 8.34. */ 236| | 237| 19.7k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 19.7k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (237:3): [True: 19.7k, False: 15.2k] ------------------ 238| 20.4k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 20.4k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (238:3): [True: 641, False: 34.4k] ------------------ 239| 20.4k| switch(c) 240| 20.4k| { 241| 152k| HSPACE_CASES: ------------------ | | 412| 2.08k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 255| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 255|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 255, False: 20.1k] | | | | ------------------ | | | | 408| 1.03k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.03k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 784, False: 19.6k] | | | | ------------------ | | | | 409| 2.08k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 3.16k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 3.16k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 1.07k, False: 19.3k] | | | | ------------------ | | | | 390| 3.70k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 541, False: 19.8k] | | | | ------------------ | | | | 391| 4.52k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 821, False: 19.6k] | | | | ------------------ | | | | 392| 4.77k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 250, False: 20.1k] | | | | ------------------ | | | | 393| 5.54k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 768, False: 19.6k] | | | | ------------------ | | | | 394| 7.38k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 1.84k, False: 18.5k] | | | | ------------------ | | | | 395| 7.69k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 309, False: 20.1k] | | | | ------------------ | | | | 396| 9.03k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 1.33k, False: 19.0k] | | | | ------------------ | | | | 397| 9.77k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 745, False: 19.6k] | | | | ------------------ | | | | 398| 11.1k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 1.36k, False: 19.0k] | | | | ------------------ | | | | 399| 11.9k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 841, False: 19.5k] | | | | ------------------ | | | | 400| 13.0k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 1.08k, False: 19.3k] | | | | ------------------ | | | | 401| 13.6k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 560, False: 19.8k] | | | | ------------------ | | | | 402| 14.1k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 543, False: 19.8k] | | | | ------------------ | | | | 403| 14.4k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 315, False: 20.1k] | | | | ------------------ | | | | 404| 14.8k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 242| 152k| VSPACE_CASES: ------------------ | | 430| 16.4k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 15.1k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 15.1k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 255, False: 20.1k] | | | | ------------------ | | | | 424| 15.4k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 15.4k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 295, False: 20.1k] | | | | ------------------ | | | | 425| 15.6k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 15.6k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 218, False: 20.2k] | | | | ------------------ | | | | 426| 16.2k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 16.2k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 609, False: 19.8k] | | | | ------------------ | | | | 427| 16.4k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 14.8k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 17.3k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 17.3k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 834, False: 19.5k] | | | | ------------------ | | | | 420| 18.3k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 243| 18.3k| return negated; 244| | 245| 2.09k| default: ------------------ | Branch (245:5): [True: 2.09k, False: 18.3k] ------------------ 246| 2.09k| return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated; ------------------ | | 177| 2.09k|#define PRIV(name) _pcre2_##name ------------------ 247| 20.4k| } 248| 0| break; /* Control never reaches here */ 249| | 250| 1.35k| case PT_WORD: ------------------ | | 1284| 1.35k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (250:3): [True: 1.35k, False: 33.7k] ------------------ 251| 1.35k| return (PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 1.35k|#define PRIV(name) _pcre2_##name ------------------ | Branch (251:11): [True: 600, False: 758] ------------------ 252| 1.35k| PRIV(ucp_gentype)[prop->chartype] == ucp_N || ------------------ | | 177| 758|#define PRIV(name) _pcre2_##name ------------------ | Branch (252:11): [True: 262, False: 496] ------------------ 253| 1.35k| c == CHAR_UNDERSCORE) == negated; ------------------ | | 1045| 496|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (253:11): [True: 1, False: 495] ------------------ 254| | 255| 0| case PT_CLIST: ------------------ | | 1285| 0|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (255:3): [True: 0, False: 35.0k] ------------------ 256| 0| p = PRIV(ucd_caseless_sets) + prop->caseset; ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 257| 0| for (;;) 258| 0| { 259| 0| if (c < *p) return !negated; ------------------ | Branch (259:9): [True: 0, False: 0] ------------------ 260| 0| if (c == *p++) return negated; ------------------ | Branch (260:9): [True: 0, False: 0] ------------------ 261| 0| } 262| 0| break; /* Control never reaches here */ 263| | 264| | /* Haven't yet thought these through. */ 265| | 266| 161| case PT_BIDICL: ------------------ | | 1287| 161|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (266:3): [True: 161, False: 34.9k] ------------------ 267| 161| return FALSE; ------------------ | | 69| 161|#define FALSE 0 ------------------ 268| | 269| 1.24k| case PT_BOOL: ------------------ | | 1288| 1.24k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (269:3): [True: 1.24k, False: 33.8k] ------------------ 270| 1.24k| return FALSE; ------------------ | | 69| 1.24k|#define FALSE 0 ------------------ 271| 35.0k| } 272| | 273| 796|return FALSE; ------------------ | | 69| 796|#define FALSE 0 ------------------ 274| 35.0k|} _pcre2_ckd_smul: 67| 13.1k|{ 68| 13.1k|#ifdef HAVE_BUILTIN_MUL_OVERFLOW 69| 13.1k|PCRE2_SIZE m; ------------------ | | 477| 13.1k|#define PCRE2_SIZE size_t ------------------ 70| | 71| 13.1k|if (__builtin_mul_overflow(a, b, &m)) return TRUE; ------------------ | | 70| 0|#define TRUE 1 ------------------ | Branch (71:5): [True: 0, False: 13.1k] ------------------ 72| | 73| 13.1k|*r = m; 74| |#else 75| |INT64_OR_DOUBLE m; 76| | 77| |#ifdef PCRE2_DEBUG 78| |if (a < 0 || b < 0) abort(); 79| |#endif 80| | 81| |m = (INT64_OR_DOUBLE)a * (INT64_OR_DOUBLE)b; 82| | 83| |#if defined INT64_MAX || defined int64_t 84| |if (sizeof(m) > sizeof(*r) && m > (INT64_OR_DOUBLE)PCRE2_SIZE_MAX) return TRUE; 85| |*r = (PCRE2_SIZE)m; 86| |#else 87| |if (m > PCRE2_SIZE_MAX) return TRUE; 88| |*r = m; 89| |#endif 90| | 91| |#endif 92| | 93| 13.1k|return FALSE; ------------------ | | 69| 13.1k|#define FALSE 0 ------------------ 94| 13.1k|} pcre2_code_free_8: 1269| 76.0k|{ 1270| 76.0k|PCRE2_SIZE* ref_count; ------------------ | | 477| 76.0k|#define PCRE2_SIZE size_t ------------------ 1271| | 1272| 76.0k|if (code != NULL) ------------------ | Branch (1272:5): [True: 65.2k, False: 10.7k] ------------------ 1273| 65.2k| { 1274| |#ifdef SUPPORT_JIT 1275| | if (code->executable_jit != NULL) 1276| | PRIV(jit_free)(code->executable_jit, &code->memctl); 1277| |#endif 1278| | 1279| 65.2k| if ((code->flags & PCRE2_DEREF_TABLES) != 0) ------------------ | | 525| 65.2k|#define PCRE2_DEREF_TABLES 0x00040000 /* release character tables */ ------------------ | Branch (1279:7): [True: 0, False: 65.2k] ------------------ 1280| 0| { 1281| | /* Decoded tables belong to the codes after deserialization, and they must 1282| | be freed when there are no more references to them. The *ref_count should 1283| | always be > 0. */ 1284| | 1285| 0| ref_count = (PCRE2_SIZE *)(code->tables + TABLES_LENGTH); ------------------ | | 592| 0|#define TABLES_LENGTH (ctypes_offset + 256) | | ------------------ | | | | 591| 0|#define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | | | ------------------ | | | | | | 590| 0|#define cbits_offset 512 /* Character classes */ | | | | ------------------ | | | | #define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | | | ------------------ | | | | | | 573| 0|#define cbit_length 320 /* Length of the cbits table */ | | | | ------------------ | | ------------------ ------------------ 1286| 0| if (*ref_count > 0) ------------------ | Branch (1286:9): [True: 0, False: 0] ------------------ 1287| 0| { 1288| 0| (*ref_count)--; 1289| 0| if (*ref_count == 0) ------------------ | Branch (1289:11): [True: 0, False: 0] ------------------ 1290| 0| code->memctl.free((void *)code->tables, code->memctl.memory_data); 1291| 0| } 1292| 0| } 1293| | 1294| 65.2k| code->memctl.free(code, code->memctl.memory_data); 1295| 65.2k| } 1296| 76.0k|} _pcre2_check_escape_8: 1513| 145k|{ 1514| 145k|BOOL utf = (options & PCRE2_UTF) != 0; ------------------ | | 138| 145k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 1515| 145k|BOOL alt_bsux = 1516| 145k| ((options & PCRE2_ALT_BSUX) | (xoptions & PCRE2_EXTRA_ALT_BSUX)) != 0; ------------------ | | 120| 145k|#define PCRE2_ALT_BSUX 0x00000002u /* C */ ------------------ ((options & PCRE2_ALT_BSUX) | (xoptions & PCRE2_EXTRA_ALT_BSUX)) != 0; ------------------ | | 154| 145k|#define PCRE2_EXTRA_ALT_BSUX 0x00000020u /* C */ ------------------ 1517| 145k|PCRE2_SPTR ptr = *ptrptr; ------------------ | | 814| 145k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 145k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 145k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 145k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1518| 145k|uint32_t c, cc; 1519| 145k|int escape = 0; 1520| 145k|int i; 1521| | 1522| |/* If backslash is at the end of the string, it's an error. */ 1523| | 1524| 145k|if (ptr >= ptrend) ------------------ | Branch (1524:5): [True: 114, False: 145k] ------------------ 1525| 114| { 1526| 114| *errorcodeptr = ERR1; 1527| 114| return 0; 1528| 114| } 1529| | 1530| 145k|GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */ ------------------ | | 323| 145k| c = *eptr++; \ | | 324| 145k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.22k| { \ | | | | 289| 1.22k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 347, False: 879] | | | | ------------------ | | | | 290| 1.22k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.22k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 602, False: 277] | | | | ------------------ | | | | 292| 879| { \ | | | | 293| 602| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 602| eptr += 2; \ | | | | 295| 602| } \ | | | | 296| 879| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 277, False: 0] | | | | ------------------ | | | | 297| 277| { \ | | | | 298| 277| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 277| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 277| eptr += 3; \ | | | | 301| 277| } \ | | | | 302| 277| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.22k| } | | ------------------ | | | Branch (324:7): [True: 36.2k, False: 109k] | | | Branch (324:14): [True: 1.22k, False: 34.9k] | | ------------------ ------------------ 1531| 145k|*errorcodeptr = 0; /* Be optimistic */ 1532| | 1533| |/* Non-alphanumerics are literals, so we just leave the value in c. An initial 1534| |value test saves a memory lookup for code points outside the alphanumeric 1535| |range. */ 1536| | 1537| 145k|if (c < ESCAPES_FIRST || c > ESCAPES_LAST) {} /* Definitely literal */ ------------------ | | 507| 145k|#define ESCAPES_FIRST CHAR_0 | | ------------------ | | | | 998| 290k|#define CHAR_0 '\060' | | ------------------ ------------------ if (c < ESCAPES_FIRST || c > ESCAPES_LAST) {} /* Definitely literal */ ------------------ | | 508| 135k|#define ESCAPES_LAST CHAR_z | | ------------------ | | | | 1072| 135k|#define CHAR_z '\172' | | ------------------ ------------------ | Branch (1537:5): [True: 9.43k, False: 135k] | Branch (1537:26): [True: 4.36k, False: 131k] ------------------ 1538| | 1539| |/* Otherwise, do a table lookup. Non-zero values need little processing here. A 1540| |positive value is a literal value for something like \n. A negative value is 1541| |the negation of one of the ESC_ macros that is passed back for handling by the 1542| |calling function. Some extra checking is needed for \N because only \N{U+dddd} 1543| |is supported. If the value is zero, further processing is handled below. */ 1544| | 1545| 131k|else if ((i = escapes[c - ESCAPES_FIRST]) != 0) ------------------ | | 507| 131k|#define ESCAPES_FIRST CHAR_0 | | ------------------ | | | | 998| 131k|#define CHAR_0 '\060' | | ------------------ ------------------ | Branch (1545:10): [True: 106k, False: 24.6k] ------------------ 1546| 106k| { 1547| 106k| if (i > 0) ------------------ | Branch (1547:7): [True: 4.65k, False: 102k] ------------------ 1548| 4.65k| { 1549| 4.65k| c = (uint32_t)i; 1550| 4.65k| if (c == CHAR_CR && (xoptions & PCRE2_EXTRA_ESCAPED_CR_IS_LF) != 0) ------------------ | | 972| 9.30k|#define CHAR_CR '\015' ------------------ if (c == CHAR_CR && (xoptions & PCRE2_EXTRA_ESCAPED_CR_IS_LF) != 0) ------------------ | | 153| 353|#define PCRE2_EXTRA_ESCAPED_CR_IS_LF 0x00000010u /* C */ ------------------ | Branch (1550:9): [True: 353, False: 4.29k] | Branch (1550:25): [True: 0, False: 353] ------------------ 1551| 0| c = CHAR_LF; ------------------ | | 973| 0|#define CHAR_LF '\012' ------------------ 1552| 4.65k| } 1553| 102k| else /* Negative table entry */ 1554| 102k| { 1555| 102k| escape = -i; /* Else return a special escape */ 1556| 102k| if (cb != NULL && (escape == ESC_P || escape == ESC_p || escape == ESC_X)) ------------------ | Branch (1556:9): [True: 102k, False: 0] | Branch (1556:24): [True: 6.19k, False: 96.1k] | Branch (1556:43): [True: 4.57k, False: 91.5k] | Branch (1556:62): [True: 2.16k, False: 89.3k] ------------------ 1557| 12.9k| cb->external_flags |= PCRE2_HASBKPORX; /* Note \P, \p, or \X */ ------------------ | | 527| 12.9k|#define PCRE2_HASBKPORX 0x00100000 /* contains \P, \p, or \X */ ------------------ 1558| | 1559| | /* Perl supports \N{name} for character names and \N{U+dddd} for numerical 1560| | Unicode code points, as well as plain \N for "not newline". PCRE does not 1561| | support \N{name}. However, it does support quantification such as \N{2,3}, 1562| | so if \N{ is not followed by U+dddd we check for a quantifier. */ 1563| | 1564| 102k| if (escape == ESC_N && ptr < ptrend && *ptr == CHAR_LEFT_CURLY_BRACKET) ------------------ | | 1073| 2.86k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (1564:9): [True: 2.90k, False: 99.4k] | Branch (1564:28): [True: 2.86k, False: 35] | Branch (1564:44): [True: 900, False: 1.96k] ------------------ 1565| 900| { 1566| 900| PCRE2_SPTR p = ptr + 1; ------------------ | | 814| 900|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 900|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 900|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 900|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1567| | 1568| | /* \N{U+ can be handled by the \x{ code. However, this construction is 1569| | not valid in EBCDIC environments because it specifies a Unicode 1570| | character, not a codepoint in the local code. For example \N{U+0041} 1571| | must be "A" in all environments. Also, in Perl, \N{U+ forces Unicode 1572| | casing semantics for the entire pattern, so allow it only in UTF (i.e. 1573| | Unicode) mode. */ 1574| | 1575| 900| if (ptrend - p > 1 && *p == CHAR_U && p[1] == CHAR_PLUS) ------------------ | | 1035| 1.78k|#define CHAR_U '\125' ------------------ if (ptrend - p > 1 && *p == CHAR_U && p[1] == CHAR_PLUS) ------------------ | | 993| 445|#define CHAR_PLUS '\053' ------------------ | Branch (1575:11): [True: 887, False: 13] | Branch (1575:29): [True: 445, False: 442] | Branch (1575:45): [True: 442, False: 3] ------------------ 1576| 442| { 1577| |#ifdef EBCDIC 1578| | *errorcodeptr = ERR93; 1579| |#else 1580| 442| if (utf) ------------------ | Branch (1580:13): [True: 436, False: 6] ------------------ 1581| 436| { 1582| 436| ptr = p + 1; 1583| 436| escape = 0; /* Not a fancy escape after all */ 1584| 436| goto COME_FROM_NU; 1585| 436| } 1586| 6| else *errorcodeptr = ERR93; 1587| 442|#endif 1588| 442| } 1589| | 1590| | /* Give an error if what follows is not a quantifier, but don't override 1591| | an error set by the quantifier reader (e.g. number overflow). */ 1592| | 1593| 458| else 1594| 458| { 1595| 458| if (!read_repeat_counts(&p, ptrend, NULL, NULL, errorcodeptr) && ------------------ | Branch (1595:13): [True: 31, False: 427] ------------------ 1596| 458| *errorcodeptr == 0) ------------------ | Branch (1596:14): [True: 24, False: 7] ------------------ 1597| 24| *errorcodeptr = ERR37; 1598| 458| } 1599| 900| } 1600| 102k| } 1601| 106k| } 1602| | 1603| |/* Escapes that need further processing, including those that are unknown, have 1604| |a zero entry in the lookup table. When called from pcre2_substitute(), only \c, 1605| |\o, and \x are recognized (\u and \U can never appear as they are used for case 1606| |forcing). */ 1607| | 1608| 24.6k|else 1609| 24.6k| { 1610| 24.6k| int s; 1611| 24.6k| PCRE2_SPTR oldptr; ------------------ | | 814| 24.6k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 24.6k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 24.6k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 24.6k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1612| 24.6k| BOOL overflow; 1613| | 1614| | /* Filter calls from pcre2_substitute(). */ 1615| | 1616| 24.6k| if (cb == NULL) ------------------ | Branch (1616:7): [True: 0, False: 24.6k] ------------------ 1617| 0| { 1618| 0| if (c != CHAR_c && c != CHAR_o && c != CHAR_x) ------------------ | | 1049| 0|#define CHAR_c '\143' ------------------ if (c != CHAR_c && c != CHAR_o && c != CHAR_x) ------------------ | | 1061| 0|#define CHAR_o '\157' ------------------ if (c != CHAR_c && c != CHAR_o && c != CHAR_x) ------------------ | | 1070| 0|#define CHAR_x '\170' ------------------ | Branch (1618:9): [True: 0, False: 0] | Branch (1618:24): [True: 0, False: 0] | Branch (1618:39): [True: 0, False: 0] ------------------ 1619| 0| { 1620| 0| *errorcodeptr = ERR3; 1621| 0| return 0; 1622| 0| } 1623| 0| alt_bsux = FALSE; /* Do not modify \x handling */ ------------------ | | 69| 0|#define FALSE 0 ------------------ 1624| 0| } 1625| | 1626| 24.6k| switch (c) 1627| 24.6k| { 1628| | /* A number of Perl escapes are not handled by PCRE. We give an explicit 1629| | error. */ 1630| | 1631| 4| case CHAR_F: ------------------ | | 1020| 4|#define CHAR_F '\106' ------------------ | Branch (1631:5): [True: 4, False: 24.6k] ------------------ 1632| 7| case CHAR_l: ------------------ | | 1058| 7|#define CHAR_l '\154' ------------------ | Branch (1632:5): [True: 3, False: 24.6k] ------------------ 1633| 10| case CHAR_L: ------------------ | | 1026| 10|#define CHAR_L '\114' ------------------ | Branch (1633:5): [True: 3, False: 24.6k] ------------------ 1634| 10| *errorcodeptr = ERR37; 1635| 10| break; 1636| | 1637| | /* \u is unrecognized when neither PCRE2_ALT_BSUX nor PCRE2_EXTRA_ALT_BSUX 1638| | is set. Otherwise, \u must be followed by exactly four hex digits or, if 1639| | PCRE2_EXTRA_ALT_BSUX is set, by any number of hex digits in braces. 1640| | Otherwise it is a lowercase u letter. This gives some compatibility with 1641| | ECMAScript (aka JavaScript). */ 1642| | 1643| 2.12k| case CHAR_u: ------------------ | | 1067| 2.12k|#define CHAR_u '\165' ------------------ | Branch (1643:5): [True: 2.12k, False: 22.5k] ------------------ 1644| 2.12k| if (!alt_bsux) *errorcodeptr = ERR37; else ------------------ | Branch (1644:9): [True: 116, False: 2.00k] ------------------ 1645| 2.00k| { 1646| 2.00k| uint32_t xc; 1647| | 1648| 2.00k| if (ptr >= ptrend) break; ------------------ | Branch (1648:11): [True: 17, False: 1.99k] ------------------ 1649| 1.99k| if (*ptr == CHAR_LEFT_CURLY_BRACKET && ------------------ | | 1073| 3.98k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (1649:11): [True: 196, False: 1.79k] ------------------ 1650| 1.99k| (xoptions & PCRE2_EXTRA_ALT_BSUX) != 0) ------------------ | | 154| 196|#define PCRE2_EXTRA_ALT_BSUX 0x00000020u /* C */ ------------------ | Branch (1650:11): [True: 0, False: 196] ------------------ 1651| 0| { 1652| 0| PCRE2_SPTR hptr = ptr + 1; ------------------ | | 814| 0|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 0|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 0|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 0|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1653| 0| cc = 0; 1654| | 1655| 0| while (hptr < ptrend && (xc = XDIGIT(*hptr)) != 0xff) ------------------ | | 74| 0|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1655:16): [True: 0, False: 0] | Branch (1655:33): [True: 0, False: 0] ------------------ 1656| 0| { 1657| 0| if ((cc & 0xf0000000) != 0) /* Test for 32-bit overflow */ ------------------ | Branch (1657:15): [True: 0, False: 0] ------------------ 1658| 0| { 1659| 0| *errorcodeptr = ERR77; 1660| 0| ptr = hptr; /* Show where */ 1661| 0| break; /* *hptr != } will cause another break below */ 1662| 0| } 1663| 0| cc = (cc << 4) | xc; 1664| 0| hptr++; 1665| 0| } 1666| | 1667| 0| if (hptr == ptr + 1 || /* No hex digits */ ------------------ | Branch (1667:13): [True: 0, False: 0] ------------------ 1668| 0| hptr >= ptrend || /* Hit end of input */ ------------------ | Branch (1668:13): [True: 0, False: 0] ------------------ 1669| 0| *hptr != CHAR_RIGHT_CURLY_BRACKET) /* No } terminator */ ------------------ | | 1075| 0|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1669:13): [True: 0, False: 0] ------------------ 1670| 0| break; /* Hex escape not recognized */ 1671| | 1672| 0| c = cc; /* Accept the code point */ 1673| 0| ptr = hptr + 1; 1674| 0| } 1675| | 1676| 1.99k| else /* Must be exactly 4 hex digits */ 1677| 1.99k| { 1678| 1.99k| if (ptrend - ptr < 4) break; /* Less than 4 chars */ ------------------ | Branch (1678:13): [True: 34, False: 1.95k] ------------------ 1679| 1.95k| if ((cc = XDIGIT(ptr[0])) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 1.95k|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1679:13): [True: 430, False: 1.52k] ------------------ 1680| 1.52k| if ((xc = XDIGIT(ptr[1])) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 1.52k|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1680:13): [True: 221, False: 1.30k] ------------------ 1681| 1.30k| cc = (cc << 4) | xc; 1682| 1.30k| if ((xc = XDIGIT(ptr[2])) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 1.30k|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1682:13): [True: 493, False: 812] ------------------ 1683| 812| cc = (cc << 4) | xc; 1684| 812| if ((xc = XDIGIT(ptr[3])) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 812|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1684:13): [True: 202, False: 610] ------------------ 1685| 610| c = (cc << 4) | xc; 1686| 610| ptr += 4; 1687| 610| } 1688| | 1689| 610| if (utf) ------------------ | Branch (1689:11): [True: 413, False: 197] ------------------ 1690| 413| { 1691| 413| if (c > 0x10ffffU) *errorcodeptr = ERR77; ------------------ | Branch (1691:13): [True: 0, False: 413] ------------------ 1692| 413| else 1693| 413| if (c >= 0xd800 && c <= 0xdfff && ------------------ | Branch (1693:15): [True: 208, False: 205] | Branch (1693:30): [True: 10, False: 198] ------------------ 1694| 413| (xoptions & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0) ------------------ | | 149| 10|#define PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES 0x00000001u /* C */ ------------------ | Branch (1694:15): [True: 10, False: 0] ------------------ 1695| 10| *errorcodeptr = ERR73; 1696| 413| } 1697| 197| else if (c > MAX_NON_UTF_CHAR) *errorcodeptr = ERR77; ------------------ | | 1900| 197|#define MAX_NON_UTF_CHAR (0xffffffffU >> (32 - PCRE2_CODE_UNIT_WIDTH)) ------------------ | Branch (1697:16): [True: 3, False: 194] ------------------ 1698| 610| } 1699| 726| break; 1700| | 1701| | /* \U is unrecognized unless PCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX is set, 1702| | in which case it is an upper case letter. */ 1703| | 1704| 726| case CHAR_U: ------------------ | | 1035| 234|#define CHAR_U '\125' ------------------ | Branch (1704:5): [True: 234, False: 24.4k] ------------------ 1705| 234| if (!alt_bsux) *errorcodeptr = ERR37; ------------------ | Branch (1705:9): [True: 25, False: 209] ------------------ 1706| 234| break; 1707| | 1708| | /* In a character class, \g is just a literal "g". Outside a character 1709| | class, \g must be followed by one of a number of specific things: 1710| | 1711| | (1) A number, either plain or braced. If positive, it is an absolute 1712| | backreference. If negative, it is a relative backreference. This is a Perl 1713| | 5.10 feature. 1714| | 1715| | (2) Perl 5.10 also supports \g{name} as a reference to a named group. This 1716| | is part of Perl's movement towards a unified syntax for back references. As 1717| | this is synonymous with \k{name}, we fudge it up by pretending it really 1718| | was \k{name}. 1719| | 1720| | (3) For Oniguruma compatibility we also support \g followed by a name or a 1721| | number either in angle brackets or in single quotes. However, these are 1722| | (possibly recursive) subroutine calls, _not_ backreferences. We return 1723| | the ESC_g code. 1724| | 1725| | Summary: Return a negative number for a numerical back reference, ESC_k for 1726| | a named back reference, and ESC_g for a named or numbered subroutine call. 1727| | */ 1728| | 1729| 3.56k| case CHAR_g: ------------------ | | 1053| 3.56k|#define CHAR_g '\147' ------------------ | Branch (1729:5): [True: 3.56k, False: 21.0k] ------------------ 1730| 3.56k| if (isclass) break; ------------------ | Branch (1730:9): [True: 295, False: 3.27k] ------------------ 1731| | 1732| 3.27k| if (ptr >= ptrend) ------------------ | Branch (1732:9): [True: 4, False: 3.27k] ------------------ 1733| 4| { 1734| 4| *errorcodeptr = ERR57; 1735| 4| break; 1736| 4| } 1737| | 1738| 3.27k| if (*ptr == CHAR_LESS_THAN_SIGN || *ptr == CHAR_APOSTROPHE) ------------------ | | 1010| 6.54k|#define CHAR_LESS_THAN_SIGN '\074' ------------------ if (*ptr == CHAR_LESS_THAN_SIGN || *ptr == CHAR_APOSTROPHE) ------------------ | | 989| 2.94k|#define CHAR_APOSTROPHE '\047' ------------------ | Branch (1738:9): [True: 325, False: 2.94k] | Branch (1738:40): [True: 328, False: 2.61k] ------------------ 1739| 653| { 1740| 653| escape = ESC_g; 1741| 653| break; 1742| 653| } 1743| | 1744| | /* If there is a brace delimiter, try to read a numerical reference. If 1745| | there isn't one, assume we have a name and treat it as \k. */ 1746| | 1747| 2.61k| if (*ptr == CHAR_LEFT_CURLY_BRACKET) ------------------ | | 1073| 2.61k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (1747:9): [True: 407, False: 2.21k] ------------------ 1748| 407| { 1749| 407| PCRE2_SPTR p = ptr + 1; ------------------ | | 814| 407|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 407|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 407|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 407|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1750| 407| if (!read_number(&p, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &s, ------------------ | | 147| 407|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (1750:11): [True: 207, False: 200] ------------------ 1751| 407| errorcodeptr)) 1752| 207| { 1753| 207| if (*errorcodeptr == 0) escape = ESC_k; /* No number found */ ------------------ | Branch (1753:13): [True: 204, False: 3] ------------------ 1754| 207| break; 1755| 207| } 1756| 200| if (p >= ptrend || *p != CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 197|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1756:11): [True: 3, False: 197] | Branch (1756:26): [True: 3, False: 194] ------------------ 1757| 6| { 1758| 6| *errorcodeptr = ERR57; 1759| 6| break; 1760| 6| } 1761| 194| ptr = p + 1; 1762| 194| } 1763| | 1764| | /* Read an undelimited number */ 1765| | 1766| 2.21k| else 1767| 2.21k| { 1768| 2.21k| if (!read_number(&ptr, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &s, ------------------ | | 147| 2.21k|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (1768:11): [True: 60, False: 2.15k] ------------------ 1769| 2.21k| errorcodeptr)) 1770| 60| { 1771| 60| if (*errorcodeptr == 0) *errorcodeptr = ERR57; /* No number found */ ------------------ | Branch (1771:13): [True: 49, False: 11] ------------------ 1772| 60| break; 1773| 60| } 1774| 2.21k| } 1775| | 1776| 2.34k| if (s <= 0) ------------------ | Branch (1776:9): [True: 5, False: 2.33k] ------------------ 1777| 5| { 1778| 5| *errorcodeptr = ERR15; 1779| 5| break; 1780| 5| } 1781| | 1782| 2.33k| escape = -s; 1783| 2.33k| break; 1784| | 1785| | /* The handling of escape sequences consisting of a string of digits 1786| | starting with one that is not zero is not straightforward. Perl has changed 1787| | over the years. Nowadays \g{} for backreferences and \o{} for octal are 1788| | recommended to avoid the ambiguities in the old syntax. 1789| | 1790| | Outside a character class, the digits are read as a decimal number. If the 1791| | number is less than 10, or if there are that many previous extracting left 1792| | brackets, it is a back reference. Otherwise, up to three octal digits are 1793| | read to form an escaped character code. Thus \123 is likely to be octal 123 1794| | (cf \0123, which is octal 012 followed by the literal 3). 1795| | 1796| | Inside a character class, \ followed by a digit is always either a literal 1797| | 8 or 9 or an octal number. */ 1798| | 1799| 10.9k| case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5: ------------------ | | 999| 6.06k|#define CHAR_1 '\061' ------------------ case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5: ------------------ | | 1000| 8.66k|#define CHAR_2 '\062' ------------------ case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5: ------------------ | | 1001| 9.71k|#define CHAR_3 '\063' ------------------ case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5: ------------------ | | 1002| 10.1k|#define CHAR_4 '\064' ------------------ case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5: ------------------ | | 1003| 10.9k|#define CHAR_5 '\065' ------------------ | Branch (1799:5): [True: 6.06k, False: 18.5k] | Branch (1799:18): [True: 2.60k, False: 22.0k] | Branch (1799:31): [True: 1.04k, False: 23.6k] | Branch (1799:44): [True: 483, False: 24.1k] | Branch (1799:57): [True: 781, False: 23.8k] ------------------ 1800| 13.2k| case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1004| 11.3k|#define CHAR_6 '\066' ------------------ case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1005| 11.7k|#define CHAR_7 '\067' ------------------ case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1006| 12.4k|#define CHAR_8 '\070' ------------------ case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1007| 13.2k|#define CHAR_9 '\071' ------------------ | Branch (1800:5): [True: 420, False: 24.2k] | Branch (1800:18): [True: 354, False: 24.2k] | Branch (1800:31): [True: 658, False: 23.9k] | Branch (1800:44): [True: 863, False: 23.7k] ------------------ 1801| | 1802| 13.2k| if (!isclass) ------------------ | Branch (1802:9): [True: 12.0k, False: 1.24k] ------------------ 1803| 12.0k| { 1804| 12.0k| oldptr = ptr; 1805| 12.0k| ptr--; /* Back to the digit */ 1806| | 1807| | /* As we know we are at a digit, the only possible error from 1808| | read_number() is a number that is too large to be a group number. In this 1809| | case we fall through handle this as not a group reference. If we have 1810| | read a small enough number, check for a back reference. 1811| | 1812| | \1 to \9 are always back references. \8x and \9x are too; \1x to \7x 1813| | are octal escapes if there are not that many previous captures. */ 1814| | 1815| 12.0k| if (read_number(&ptr, ptrend, -1, INT_MAX/10 - 1, 0, &s, errorcodeptr) && ------------------ | Branch (1815:11): [True: 11.7k, False: 234] ------------------ 1816| 12.0k| (s < 10 || oldptr[-1] >= CHAR_8 || s <= (int)cb->bracount)) ------------------ | | 1006| 14.9k|#define CHAR_8 '\070' ------------------ | Branch (1816:12): [True: 8.69k, False: 3.10k] | Branch (1816:22): [True: 337, False: 2.76k] | Branch (1816:46): [True: 1.76k, False: 1.00k] ------------------ 1817| 10.7k| { 1818| 10.7k| if (s > (int)MAX_GROUP_NUMBER) *errorcodeptr = ERR61; ------------------ | | 147| 10.7k|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (1818:13): [True: 19, False: 10.7k] ------------------ 1819| 10.7k| else escape = -s; /* Indicates a back reference */ 1820| 10.7k| break; 1821| 10.7k| } 1822| | 1823| 1.23k| ptr = oldptr; /* Put the pointer back and fall through */ 1824| 1.23k| } 1825| | 1826| | /* Handle a digit following \ when the number is not a back reference, or 1827| | we are within a character class. If the first digit is 8 or 9, Perl used to 1828| | generate a binary zero and then treat the digit as a following literal. At 1829| | least by Perl 5.18 this changed so as not to insert the binary zero. */ 1830| | 1831| 2.47k| if (c >= CHAR_8) break; ------------------ | | 1006| 2.47k|#define CHAR_8 '\070' ------------------ | Branch (1831:9): [True: 208, False: 2.27k] ------------------ 1832| | 1833| | /* Fall through */ 1834| | 1835| | /* \0 always starts an octal number, but we may drop through to here with a 1836| | larger first octal digit. The original code used just to take the least 1837| | significant 8 bits of octal numbers (I think this is what early Perls used 1838| | to do). Nowadays we allow for larger numbers in UTF-8 mode and 16-bit mode, 1839| | but no more than 3 octal digits. */ 1840| | 1841| 3.58k| case CHAR_0: ------------------ | | 998| 3.58k|#define CHAR_0 '\060' ------------------ | Branch (1841:5): [True: 1.31k, False: 23.3k] ------------------ 1842| 3.58k| c -= CHAR_0; ------------------ | | 998| 3.58k|#define CHAR_0 '\060' ------------------ 1843| 5.64k| while(i++ < 2 && ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ------------------ | | 998| 10.4k|#define CHAR_0 '\060' ------------------ while(i++ < 2 && ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ------------------ | | 1005| 3.84k|#define CHAR_7 '\067' ------------------ | Branch (1843:11): [True: 4.94k, False: 697] | Branch (1843:22): [True: 4.83k, False: 114] | Branch (1843:38): [True: 3.84k, False: 990] | Branch (1843:56): [True: 2.06k, False: 1.78k] ------------------ 1844| 2.06k| c = c * 8 + *ptr++ - CHAR_0; ------------------ | | 998| 5.64k|#define CHAR_0 '\060' ------------------ 1845| 3.58k|#if PCRE2_CODE_UNIT_WIDTH == 8 1846| 3.58k| if (!utf && c > 0xff) *errorcodeptr = ERR51; ------------------ | Branch (1846:9): [True: 2.69k, False: 890] | Branch (1846:17): [True: 35, False: 2.65k] ------------------ 1847| 3.58k|#endif 1848| 3.58k| break; 1849| | 1850| | /* \o is a relatively new Perl feature, supporting a more general way of 1851| | specifying character codes in octal. The only supported form is \o{ddd}. */ 1852| | 1853| 962| case CHAR_o: ------------------ | | 1061| 962|#define CHAR_o '\157' ------------------ | Branch (1853:5): [True: 962, False: 23.6k] ------------------ 1854| 962| if (ptr >= ptrend || *ptr++ != CHAR_LEFT_CURLY_BRACKET) ------------------ | | 1073| 958|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (1854:9): [True: 4, False: 958] | Branch (1854:26): [True: 25, False: 933] ------------------ 1855| 29| { 1856| 29| ptr--; 1857| 29| *errorcodeptr = ERR55; 1858| 29| } 1859| 933| else if (ptr >= ptrend || *ptr == CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 930|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1859:14): [True: 3, False: 930] | Branch (1859:31): [True: 3, False: 927] ------------------ 1860| 6| *errorcodeptr = ERR78; 1861| 927| else 1862| 927| { 1863| 927| c = 0; 1864| 927| overflow = FALSE; ------------------ | | 69| 927|#define FALSE 0 ------------------ 1865| 2.88k| while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ------------------ | | 998| 5.72k|#define CHAR_0 '\060' ------------------ while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ------------------ | | 1005| 2.82k|#define CHAR_7 '\067' ------------------ | Branch (1865:14): [True: 2.83k, False: 46] | Branch (1865:30): [True: 2.82k, False: 11] | Branch (1865:48): [True: 2.02k, False: 803] ------------------ 1866| 2.02k| { 1867| 2.02k| cc = *ptr++; 1868| 2.02k| if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */ ------------------ | | 998| 1.08k|#define CHAR_0 '\060' ------------------ | Branch (1868:13): [True: 1.08k, False: 942] | Branch (1868:23): [True: 234, False: 848] ------------------ 1869| |#if PCRE2_CODE_UNIT_WIDTH == 32 1870| | if (c >= 0x20000000l) { overflow = TRUE; break; } 1871| |#endif 1872| 1.79k| c = (c << 3) + (cc - CHAR_0); ------------------ | | 998| 1.79k|#define CHAR_0 '\060' ------------------ 1873| 1.79k|#if PCRE2_CODE_UNIT_WIDTH == 8 1874| 1.79k| if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; } ------------------ | | 70| 67|#define TRUE 1 ------------------ | Branch (1874:13): [True: 67, False: 1.72k] | Branch (1874:18): [True: 1.15k, False: 639] ------------------ 1875| |#elif PCRE2_CODE_UNIT_WIDTH == 16 1876| | if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; } 1877| |#elif PCRE2_CODE_UNIT_WIDTH == 32 1878| | if (utf && c > 0x10ffffU) { overflow = TRUE; break; } 1879| |#endif 1880| 1.79k| } 1881| 927| if (overflow) ------------------ | Branch (1881:11): [True: 67, False: 860] ------------------ 1882| 67| { 1883| 348| while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++; ------------------ | | 998| 639|#define CHAR_0 '\060' ------------------ while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++; ------------------ | | 1005| 288|#define CHAR_7 '\067' ------------------ | Branch (1883:16): [True: 291, False: 57] | Branch (1883:32): [True: 288, False: 3] | Branch (1883:50): [True: 281, False: 7] ------------------ 1884| 67| *errorcodeptr = ERR34; 1885| 67| } 1886| 860| else if (ptr < ptrend && *ptr++ == CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 814|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1886:16): [True: 814, False: 46] | Branch (1886:32): [True: 782, False: 32] ------------------ 1887| 782| { 1888| 782| if (utf && c >= 0xd800 && c <= 0xdfff && ------------------ | Branch (1888:13): [True: 325, False: 457] | Branch (1888:20): [True: 114, False: 211] | Branch (1888:35): [True: 3, False: 111] ------------------ 1889| 782| (xoptions & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0) ------------------ | | 149| 3|#define PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES 0x00000001u /* C */ ------------------ | Branch (1889:13): [True: 3, False: 0] ------------------ 1890| 3| { 1891| 3| ptr--; 1892| 3| *errorcodeptr = ERR73; 1893| 3| } 1894| 782| } 1895| 78| else 1896| 78| { 1897| 78| ptr--; 1898| 78| *errorcodeptr = ERR64; 1899| 78| } 1900| 927| } 1901| 962| break; 1902| | 1903| | /* When PCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX is set, \x must be followed 1904| | by two hexadecimal digits. Otherwise it is a lowercase x letter. */ 1905| | 1906| 2.52k| case CHAR_x: ------------------ | | 1070| 2.52k|#define CHAR_x '\170' ------------------ | Branch (1906:5): [True: 2.52k, False: 22.1k] ------------------ 1907| 2.52k| if (alt_bsux) ------------------ | Branch (1907:9): [True: 674, False: 1.84k] ------------------ 1908| 674| { 1909| 674| uint32_t xc; 1910| 674| if (ptrend - ptr < 2) break; /* Less than 2 characters */ ------------------ | Branch (1910:11): [True: 19, False: 655] ------------------ 1911| 655| if ((cc = XDIGIT(ptr[0])) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 655|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1911:11): [True: 257, False: 398] ------------------ 1912| 398| if ((xc = XDIGIT(ptr[1])) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 398|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1912:11): [True: 198, False: 200] ------------------ 1913| 200| c = (cc << 4) | xc; 1914| 200| ptr += 2; 1915| 200| } 1916| | 1917| | /* Handle \x in Perl's style. \x{ddd} is a character code which can be 1918| | greater than 0xff in UTF-8 or non-8bit mode, but only if the ddd are hex 1919| | digits. If not, { used to be treated as a data character. However, Perl 1920| | seems to read hex digits up to the first non-such, and ignore the rest, so 1921| | that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE 1922| | now gives an error. */ 1923| | 1924| 1.84k| else 1925| 1.84k| { 1926| 1.84k| if (ptr < ptrend && *ptr == CHAR_LEFT_CURLY_BRACKET) ------------------ | | 1073| 1.83k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (1926:11): [True: 1.83k, False: 16] | Branch (1926:27): [True: 556, False: 1.27k] ------------------ 1927| 556| { 1928| 556|#ifndef EBCDIC 1929| 992| COME_FROM_NU: 1930| 992|#endif 1931| 992| if (++ptr >= ptrend || *ptr == CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 974|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1931:13): [True: 18, False: 974] | Branch (1931:32): [True: 3, False: 971] ------------------ 1932| 21| { 1933| 21| *errorcodeptr = ERR78; 1934| 21| break; 1935| 21| } 1936| 971| c = 0; 1937| 971| overflow = FALSE; ------------------ | | 69| 971|#define FALSE 0 ------------------ 1938| | 1939| 3.82k| while (ptr < ptrend && (cc = XDIGIT(*ptr)) != 0xff) ------------------ | | 74| 3.76k|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1939:16): [True: 3.76k, False: 56] | Branch (1939:32): [True: 2.93k, False: 835] ------------------ 1940| 2.93k| { 1941| 2.93k| ptr++; 1942| 2.93k| if (c == 0 && cc == 0) continue; /* Leading zeroes */ ------------------ | Branch (1942:15): [True: 1.14k, False: 1.78k] | Branch (1942:25): [True: 212, False: 937] ------------------ 1943| |#if PCRE2_CODE_UNIT_WIDTH == 32 1944| | if (c >= 0x10000000l) { overflow = TRUE; break; } 1945| |#endif 1946| 2.71k| c = (c << 4) | cc; 1947| 2.71k| if ((utf && c > 0x10ffffU) || (!utf && c > MAX_NON_UTF_CHAR)) ------------------ | | 1900| 410|#define MAX_NON_UTF_CHAR (0xffffffffU >> (32 - PCRE2_CODE_UNIT_WIDTH)) ------------------ | Branch (1947:16): [True: 2.30k, False: 410] | Branch (1947:23): [True: 21, False: 2.28k] | Branch (1947:42): [True: 410, False: 2.28k] | Branch (1947:50): [True: 59, False: 351] ------------------ 1948| 80| { 1949| 80| overflow = TRUE; ------------------ | | 70| 80|#define TRUE 1 ------------------ 1950| 80| break; 1951| 80| } 1952| 2.71k| } 1953| | 1954| 971| if (overflow) ------------------ | Branch (1954:13): [True: 80, False: 891] ------------------ 1955| 80| { 1956| 370| while (ptr < ptrend && XDIGIT(*ptr) != 0xff) ptr++; ------------------ | | 74| 304|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1956:18): [True: 304, False: 66] | Branch (1956:34): [True: 290, False: 14] ------------------ 1957| 80| *errorcodeptr = ERR34; 1958| 80| } 1959| 891| else if (ptr < ptrend && *ptr++ == CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 835|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1959:18): [True: 835, False: 56] | Branch (1959:34): [True: 817, False: 18] ------------------ 1960| 817| { 1961| 817| if (utf && c >= 0xd800 && c <= 0xdfff && ------------------ | Branch (1961:15): [True: 616, False: 201] | Branch (1961:22): [True: 352, False: 264] | Branch (1961:37): [True: 4, False: 348] ------------------ 1962| 817| (xoptions & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0) ------------------ | | 149| 4|#define PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES 0x00000001u /* C */ ------------------ | Branch (1962:15): [True: 4, False: 0] ------------------ 1963| 4| { 1964| 4| ptr--; 1965| 4| *errorcodeptr = ERR73; 1966| 4| } 1967| 817| } 1968| | 1969| | /* If the sequence of hex digits does not end with '}', give an error. 1970| | We used just to recognize this construct and fall through to the normal 1971| | \x handling, but nowadays Perl gives an error, which seems much more 1972| | sensible, so we do too. */ 1973| | 1974| 74| else 1975| 74| { 1976| 74| ptr--; 1977| 74| *errorcodeptr = ERR67; 1978| 74| } 1979| 971| } /* End of \x{} processing */ 1980| | 1981| | /* Read a up to two hex digits after \x */ 1982| | 1983| 1.29k| else 1984| 1.29k| { 1985| 1.29k| c = 0; 1986| 1.29k| if (ptr >= ptrend || (cc = XDIGIT(*ptr)) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 1.27k|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1986:13): [True: 16, False: 1.27k] | Branch (1986:30): [True: 460, False: 815] ------------------ 1987| 815| ptr++; 1988| 815| c = cc; 1989| 815| if (ptr >= ptrend || (cc = XDIGIT(*ptr)) == 0xff) break; /* Not a hex digit */ ------------------ | | 74| 805|#define XDIGIT(c) xdigitab[c] ------------------ | Branch (1989:13): [True: 10, False: 805] | Branch (1989:30): [True: 405, False: 400] ------------------ 1990| 400| ptr++; 1991| 400| c = (c << 4) | cc; 1992| 400| } /* End of \xdd handling */ 1993| 1.84k| } /* End of Perl-style \x handling */ 1994| 1.57k| break; 1995| | 1996| | /* The handling of \c is different in ASCII and EBCDIC environments. In an 1997| | ASCII (or Unicode) environment, an error is given if the character 1998| | following \c is not a printable ASCII character. Otherwise, the following 1999| | character is upper-cased if it is a letter, and after that the 0x40 bit is 2000| | flipped. The result is the value of the escape. 2001| | 2002| | In an EBCDIC environment the handling of \c is compatible with the 2003| | specification in the perlebcdic document. The following character must be 2004| | a letter or one of small number of special characters. These provide a 2005| | means of defining the character values 0-31. 2006| | 2007| | For testing the EBCDIC handling of \c in an ASCII environment, recognize 2008| | the EBCDIC value of 'c' explicitly. */ 2009| | 2010| |#if defined EBCDIC && 'a' != 0x81 2011| | case 0x83: 2012| |#else 2013| 1.57k| case CHAR_c: ------------------ | | 1049| 641|#define CHAR_c '\143' ------------------ | Branch (2013:5): [True: 641, False: 24.0k] ------------------ 2014| 641|#endif 2015| 641| if (ptr >= ptrend) ------------------ | Branch (2015:9): [True: 6, False: 635] ------------------ 2016| 6| { 2017| 6| *errorcodeptr = ERR2; 2018| 6| break; 2019| 6| } 2020| 635| c = *ptr; 2021| 635| if (c >= CHAR_a && c <= CHAR_z) c = UPPER_CASE(c); ------------------ | | 1047| 1.27k|#define CHAR_a '\141' ------------------ if (c >= CHAR_a && c <= CHAR_z) c = UPPER_CASE(c); ------------------ | | 1072| 428|#define CHAR_z '\172' ------------------ if (c >= CHAR_a && c <= CHAR_z) c = UPPER_CASE(c); ------------------ | | 509| 220|#define UPPER_CASE(c) (c-32) ------------------ | Branch (2021:9): [True: 428, False: 207] | Branch (2021:24): [True: 220, False: 208] ------------------ 2022| | 2023| | /* Handle \c in an ASCII/Unicode environment. */ 2024| | 2025| 635|#ifndef EBCDIC /* ASCII/UTF-8 coding */ 2026| 635| if (c < 32 || c > 126) /* Excludes all non-printable ASCII */ ------------------ | Branch (2026:9): [True: 3, False: 632] | Branch (2026:19): [True: 7, False: 625] ------------------ 2027| 10| { 2028| 10| *errorcodeptr = ERR68; 2029| 10| break; 2030| 10| } 2031| 625| c ^= 0x40; 2032| | 2033| | /* Handle \c in an EBCDIC environment. The special case \c? is converted to 2034| | 255 (0xff) or 95 (0x5f) if other characters suggest we are using the 2035| | POSIX-BC encoding. (This is the way Perl indicates that it handles \c?.) 2036| | The other valid sequences correspond to a list of specific characters. */ 2037| | 2038| |#else 2039| | if (c == CHAR_QUESTION_MARK) 2040| | c = ('\\' == 188 && '`' == 74)? 0x5f : 0xff; 2041| | else 2042| | { 2043| | for (i = 0; i < 32; i++) 2044| | { 2045| | if (c == ebcdic_escape_c[i]) break; 2046| | } 2047| | if (i < 32) c = i; else *errorcodeptr = ERR68; 2048| | } 2049| |#endif /* EBCDIC */ 2050| | 2051| 625| ptr++; 2052| 625| break; 2053| | 2054| | /* Any other alphanumeric following \ is an error. Perl gives an error only 2055| | if in warning mode, but PCRE doesn't have a warning mode. */ 2056| | 2057| 7| default: ------------------ | Branch (2057:5): [True: 7, False: 24.6k] ------------------ 2058| 7| *errorcodeptr = ERR3; 2059| 7| *ptrptr = ptr - 1; /* Point to the character at fault */ 2060| 7| return 0; 2061| 24.6k| } 2062| 24.6k| } 2063| | 2064| |/* Set the pointer to the next character before returning. */ 2065| | 2066| 145k|*ptrptr = ptr; 2067| 145k|*chptr = c; 2068| 145k|return escape; 2069| 145k|} pcre2_compile_8: 9914| 76.0k|{ 9915| 76.0k|BOOL utf; /* Set TRUE for UTF mode */ 9916| 76.0k|BOOL ucp; /* Set TRUE for UCP mode */ 9917| 76.0k|BOOL has_lookbehind = FALSE; /* Set TRUE if a lookbehind is found */ ------------------ | | 69| 76.0k|#define FALSE 0 ------------------ 9918| 76.0k|BOOL zero_terminated; /* Set TRUE for zero-terminated pattern */ 9919| 76.0k|pcre2_real_code *re = NULL; /* What we will return */ ------------------ | | 820| 76.0k|#define pcre2_real_code PCRE2_SUFFIX(pcre2_real_code_) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9920| 76.0k|compile_block cb; /* "Static" compile-time data */ ------------------ | | 1980| 76.0k|#define compile_block PCRE2_SUFFIX(compile_block_) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9921| 76.0k|const uint8_t *tables; /* Char tables base pointer */ 9922| | 9923| 76.0k|PCRE2_UCHAR *code; /* Current pointer in compiled code */ ------------------ | | 813| 76.0k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9924| 76.0k|PCRE2_SPTR codestart; /* Start of compiled code */ ------------------ | | 814| 76.0k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9925| 76.0k|PCRE2_SPTR ptr; /* Current pointer in pattern */ ------------------ | | 814| 76.0k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9926| 76.0k|uint32_t *pptr; /* Current pointer in parsed pattern */ 9927| | 9928| 76.0k|PCRE2_SIZE length = 1; /* Allow for final END opcode */ ------------------ | | 477| 76.0k|#define PCRE2_SIZE size_t ------------------ 9929| 76.0k|PCRE2_SIZE usedlength; /* Actual length used */ ------------------ | | 477| 76.0k|#define PCRE2_SIZE size_t ------------------ 9930| 76.0k|PCRE2_SIZE re_blocksize; /* Size of memory block */ ------------------ | | 477| 76.0k|#define PCRE2_SIZE size_t ------------------ 9931| 76.0k|PCRE2_SIZE big32count = 0; /* 32-bit literals >= 0x80000000 */ ------------------ | | 477| 76.0k|#define PCRE2_SIZE size_t ------------------ 9932| 76.0k|PCRE2_SIZE parsed_size_needed; /* Needed for parsed pattern */ ------------------ | | 477| 76.0k|#define PCRE2_SIZE size_t ------------------ 9933| | 9934| 76.0k|uint32_t firstcuflags, reqcuflags; /* Type of first/req code unit */ 9935| 76.0k|uint32_t firstcu, reqcu; /* Value of first/req code unit */ 9936| 76.0k|uint32_t setflags = 0; /* NL and BSR set flags */ 9937| | 9938| 76.0k|uint32_t skipatstart; /* When checking (*UTF) etc */ 9939| 76.0k|uint32_t limit_heap = UINT32_MAX; 9940| 76.0k|uint32_t limit_match = UINT32_MAX; /* Unset match limits */ 9941| 76.0k|uint32_t limit_depth = UINT32_MAX; 9942| | 9943| 76.0k|int newline = 0; /* Unset; can be set by the pattern */ 9944| 76.0k|int bsr = 0; /* Unset; can be set by the pattern */ 9945| 76.0k|int errorcode = 0; /* Initialize to avoid compiler warn */ 9946| 76.0k|int regexrc; /* Return from compile */ 9947| | 9948| 76.0k|uint32_t i; /* Local loop counter */ 9949| | 9950| |/* Comments at the head of this file explain about these variables. */ 9951| | 9952| 76.0k|uint32_t stack_groupinfo[GROUPINFO_DEFAULT_SIZE]; 9953| 76.0k|uint32_t stack_parsed_pattern[PARSED_PATTERN_DEFAULT_SIZE]; 9954| 76.0k|named_group named_groups[NAMED_GROUP_LIST_SIZE]; ------------------ | | 1983| 76.0k|#define named_group PCRE2_SUFFIX(named_group_) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9955| | 9956| |/* The workspace is used in different ways in the different compiling phases. 9957| |It needs to be 16-bit aligned for the preliminary parsing scan. */ 9958| | 9959| 76.0k|uint32_t c16workspace[C16_WORK_SIZE]; 9960| 76.0k|PCRE2_UCHAR *cworkspace = (PCRE2_UCHAR *)c16workspace; ------------------ | | 813| 76.0k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9961| | 9962| | 9963| |/* -------------- Check arguments and set up the pattern ----------------- */ 9964| | 9965| |/* There must be error code and offset pointers. */ 9966| | 9967| 76.0k|if (errorptr == NULL || erroroffset == NULL) return NULL; ------------------ | Branch (9967:5): [True: 0, False: 76.0k] | Branch (9967:25): [True: 0, False: 76.0k] ------------------ 9968| 76.0k|*errorptr = ERR0; 9969| 76.0k|*erroroffset = 0; 9970| | 9971| |/* There must be a pattern! */ 9972| | 9973| 76.0k|if (pattern == NULL) ------------------ | Branch (9973:5): [True: 0, False: 76.0k] ------------------ 9974| 0| { 9975| 0| *errorptr = ERR16; 9976| 0| return NULL; 9977| 0| } 9978| | 9979| |/* A NULL compile context means "use a default context" */ 9980| | 9981| 76.0k|if (ccontext == NULL) ------------------ | Branch (9981:5): [True: 76.0k, False: 0] ------------------ 9982| 76.0k| ccontext = (pcre2_compile_context *)(&PRIV(default_compile_context)); ------------------ | | 177| 76.0k|#define PRIV(name) _pcre2_##name ------------------ 9983| | 9984| |/* PCRE2_MATCH_INVALID_UTF implies UTF */ 9985| | 9986| 76.0k|if ((options & PCRE2_MATCH_INVALID_UTF) != 0) options |= PCRE2_UTF; ------------------ | | 145| 76.0k|#define PCRE2_MATCH_INVALID_UTF 0x04000000u /* J M D */ ------------------ if ((options & PCRE2_MATCH_INVALID_UTF) != 0) options |= PCRE2_UTF; ------------------ | | 138| 0|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ | Branch (9986:5): [True: 0, False: 76.0k] ------------------ 9987| | 9988| |/* Check that all undefined public option bits are zero. */ 9989| | 9990| 76.0k|if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0 || ------------------ | | 773| 76.0k| (PUBLIC_LITERAL_COMPILE_OPTIONS| \ | | ------------------ | | | | 768| 76.0k| (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | | | ------------------ | | | | | | 105| 76.0k|#define PCRE2_ANCHORED 0x80000000u | | | | ------------------ | | | | (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | | | ------------------ | | | | | | 121| 76.0k|#define PCRE2_AUTO_CALLOUT 0x00000004u /* C */ | | | | ------------------ | | | | (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | | | ------------------ | | | | | | 122| 76.0k|#define PCRE2_CASELESS 0x00000008u /* C */ | | | | ------------------ | | | | (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | | | ------------------ | | | | | | 107| 76.0k|#define PCRE2_ENDANCHORED 0x20000000u | | | | ------------------ | | | | 769| 76.0k| PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \ | | | | ------------------ | | | | | | 127| 76.0k|#define PCRE2_FIRSTLINE 0x00000100u /* J M D */ | | | | ------------------ | | | | PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \ | | | | ------------------ | | | | | | 144| 76.0k|#define PCRE2_LITERAL 0x02000000u /* C */ | | | | ------------------ | | | | PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \ | | | | ------------------ | | | | | | 145| 76.0k|#define PCRE2_MATCH_INVALID_UTF 0x04000000u /* J M D */ | | | | ------------------ | | | | 770| 76.0k| PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | | | ------------------ | | | | | | 135| 76.0k|#define PCRE2_NO_START_OPTIMIZE 0x00010000u /* J M D */ | | | | ------------------ | | | | PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | | | ------------------ | | | | | | 106| 76.0k|#define PCRE2_NO_UTF_CHECK 0x40000000u | | | | ------------------ | | | | PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | | | ------------------ | | | | | | 142| 76.0k|#define PCRE2_USE_OFFSET_LIMIT 0x00800000u /* J M D */ | | | | ------------------ | | | | PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | | | ------------------ | | | | | | 138| 76.0k|#define PCRE2_UTF 0x00080000u /* C J M D */ | | | | ------------------ | | ------------------ | | 774| 76.0k| PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \ | | ------------------ | | | | 119| 76.0k|#define PCRE2_ALLOW_EMPTY_CLASS 0x00000001u /* C */ | | ------------------ | | PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \ | | ------------------ | | | | 120| 76.0k|#define PCRE2_ALT_BSUX 0x00000002u /* C */ | | ------------------ | | PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \ | | ------------------ | | | | 140| 76.0k|#define PCRE2_ALT_CIRCUMFLEX 0x00200000u /* J M D */ | | ------------------ | | 775| 76.0k| PCRE2_ALT_VERBNAMES|PCRE2_DOLLAR_ENDONLY|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 141| 76.0k|#define PCRE2_ALT_VERBNAMES 0x00400000u /* C */ | | ------------------ | | PCRE2_ALT_VERBNAMES|PCRE2_DOLLAR_ENDONLY|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 123| 76.0k|#define PCRE2_DOLLAR_ENDONLY 0x00000010u /* J M D */ | | ------------------ | | PCRE2_ALT_VERBNAMES|PCRE2_DOLLAR_ENDONLY|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 124| 76.0k|#define PCRE2_DOTALL 0x00000020u /* C */ | | ------------------ | | PCRE2_ALT_VERBNAMES|PCRE2_DOLLAR_ENDONLY|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 125| 76.0k|#define PCRE2_DUPNAMES 0x00000040u /* C */ | | ------------------ | | 776| 76.0k| PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MATCH_UNSET_BACKREF| \ | | ------------------ | | | | 126| 76.0k|#define PCRE2_EXTENDED 0x00000080u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MATCH_UNSET_BACKREF| \ | | ------------------ | | | | 143| 76.0k|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MATCH_UNSET_BACKREF| \ | | ------------------ | | | | 128| 76.0k|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ | | ------------------ | | 777| 76.0k| PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C|PCRE2_NEVER_UCP| \ | | ------------------ | | | | 129| 76.0k|#define PCRE2_MULTILINE 0x00000400u /* C */ | | ------------------ | | PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C|PCRE2_NEVER_UCP| \ | | ------------------ | | | | 139| 76.0k|#define PCRE2_NEVER_BACKSLASH_C 0x00100000u /* C */ | | ------------------ | | PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C|PCRE2_NEVER_UCP| \ | | ------------------ | | | | 130| 76.0k|#define PCRE2_NEVER_UCP 0x00000800u /* C */ | | ------------------ | | 778| 76.0k| PCRE2_NEVER_UTF|PCRE2_NO_AUTO_CAPTURE|PCRE2_NO_AUTO_POSSESS| \ | | ------------------ | | | | 131| 76.0k|#define PCRE2_NEVER_UTF 0x00001000u /* C */ | | ------------------ | | PCRE2_NEVER_UTF|PCRE2_NO_AUTO_CAPTURE|PCRE2_NO_AUTO_POSSESS| \ | | ------------------ | | | | 132| 76.0k|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ | | ------------------ | | PCRE2_NEVER_UTF|PCRE2_NO_AUTO_CAPTURE|PCRE2_NO_AUTO_POSSESS| \ | | ------------------ | | | | 133| 76.0k|#define PCRE2_NO_AUTO_POSSESS 0x00004000u /* C */ | | ------------------ | | 779| 76.0k| PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_UCP|PCRE2_UNGREEDY) | | ------------------ | | | | 134| 76.0k|#define PCRE2_NO_DOTSTAR_ANCHOR 0x00008000u /* C */ | | ------------------ | | PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_UCP|PCRE2_UNGREEDY) | | ------------------ | | | | 136| 76.0k|#define PCRE2_UCP 0x00020000u /* C J M D */ | | ------------------ | | PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_UCP|PCRE2_UNGREEDY) | | ------------------ | | | | 137| 76.0k|#define PCRE2_UNGREEDY 0x00040000u /* C */ | | ------------------ ------------------ | Branch (9990:5): [True: 0, False: 76.0k] ------------------ 9991| 76.0k| (ccontext->extra_options & ~PUBLIC_COMPILE_EXTRA_OPTIONS) != 0) ------------------ | | 785| 76.0k| (PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS| \ | | ------------------ | | | | 782| 76.0k| (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_CASELESS_RESTRICT) | | | | ------------------ | | | | | | 152| 76.0k|#define PCRE2_EXTRA_MATCH_LINE 0x00000008u /* C */ | | | | ------------------ | | | | (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_CASELESS_RESTRICT) | | | | ------------------ | | | | | | 151| 76.0k|#define PCRE2_EXTRA_MATCH_WORD 0x00000004u /* C */ | | | | ------------------ | | | | (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_CASELESS_RESTRICT) | | | | ------------------ | | | | | | 156| 76.0k|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ | | | | ------------------ | | ------------------ | | 786| 76.0k| PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES|PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL| \ | | ------------------ | | | | 149| 76.0k|#define PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES 0x00000001u /* C */ | | ------------------ | | PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES|PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL| \ | | ------------------ | | | | 150| 76.0k|#define PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL 0x00000002u /* C */ | | ------------------ | | 787| 76.0k| PCRE2_EXTRA_ESCAPED_CR_IS_LF|PCRE2_EXTRA_ALT_BSUX| \ | | ------------------ | | | | 153| 76.0k|#define PCRE2_EXTRA_ESCAPED_CR_IS_LF 0x00000010u /* C */ | | ------------------ | | PCRE2_EXTRA_ESCAPED_CR_IS_LF|PCRE2_EXTRA_ALT_BSUX| \ | | ------------------ | | | | 154| 76.0k|#define PCRE2_EXTRA_ALT_BSUX 0x00000020u /* C */ | | ------------------ | | 788| 76.0k| PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK|PCRE2_EXTRA_ASCII_BSD| \ | | ------------------ | | | | 155| 76.0k|#define PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK 0x00000040u /* C */ | | ------------------ | | PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK|PCRE2_EXTRA_ASCII_BSD| \ | | ------------------ | | | | 157| 76.0k|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ | | ------------------ | | 789| 76.0k| PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW|PCRE2_EXTRA_ASCII_POSIX| \ | | ------------------ | | | | 158| 76.0k|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW|PCRE2_EXTRA_ASCII_POSIX| \ | | ------------------ | | | | 159| 76.0k|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW|PCRE2_EXTRA_ASCII_POSIX| \ | | ------------------ | | | | 160| 76.0k|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ | | ------------------ | | 790| 76.0k| PCRE2_EXTRA_ASCII_DIGIT) | | ------------------ | | | | 161| 76.0k|#define PCRE2_EXTRA_ASCII_DIGIT 0x00001000u /* C */ | | ------------------ ------------------ | Branch (9991:5): [True: 0, False: 76.0k] ------------------ 9992| 0| { 9993| 0| *errorptr = ERR17; 9994| 0| return NULL; 9995| 0| } 9996| | 9997| 76.0k|if ((options & PCRE2_LITERAL) != 0 && ------------------ | | 144| 76.0k|#define PCRE2_LITERAL 0x02000000u /* C */ ------------------ | Branch (9997:5): [True: 0, False: 76.0k] ------------------ 9998| 76.0k| ((options & ~PUBLIC_LITERAL_COMPILE_OPTIONS) != 0 || ------------------ | | 768| 0| (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | ------------------ | | | | 105| 0|#define PCRE2_ANCHORED 0x80000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | ------------------ | | | | 121| 0|#define PCRE2_AUTO_CALLOUT 0x00000004u /* C */ | | ------------------ | | (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | ------------------ | | | | 122| 0|#define PCRE2_CASELESS 0x00000008u /* C */ | | ------------------ | | (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \ | | ------------------ | | | | 107| 0|#define PCRE2_ENDANCHORED 0x20000000u | | ------------------ | | 769| 0| PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \ | | ------------------ | | | | 127| 0|#define PCRE2_FIRSTLINE 0x00000100u /* J M D */ | | ------------------ | | PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \ | | ------------------ | | | | 144| 0|#define PCRE2_LITERAL 0x02000000u /* C */ | | ------------------ | | PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \ | | ------------------ | | | | 145| 0|#define PCRE2_MATCH_INVALID_UTF 0x04000000u /* J M D */ | | ------------------ | | 770| 0| PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | ------------------ | | | | 135| 0|#define PCRE2_NO_START_OPTIMIZE 0x00010000u /* J M D */ | | ------------------ | | PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | ------------------ | | | | 106| 0|#define PCRE2_NO_UTF_CHECK 0x40000000u | | ------------------ | | PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | ------------------ | | | | 142| 0|#define PCRE2_USE_OFFSET_LIMIT 0x00800000u /* J M D */ | | ------------------ | | PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF) | | ------------------ | | | | 138| 0|#define PCRE2_UTF 0x00080000u /* C J M D */ | | ------------------ ------------------ | Branch (9998:6): [True: 0, False: 0] ------------------ 9999| 0| (ccontext->extra_options & ~PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS) != 0)) ------------------ | | 782| 0| (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_CASELESS_RESTRICT) | | ------------------ | | | | 152| 0|#define PCRE2_EXTRA_MATCH_LINE 0x00000008u /* C */ | | ------------------ | | (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_CASELESS_RESTRICT) | | ------------------ | | | | 151| 0|#define PCRE2_EXTRA_MATCH_WORD 0x00000004u /* C */ | | ------------------ | | (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_CASELESS_RESTRICT) | | ------------------ | | | | 156| 0|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ | | ------------------ ------------------ | Branch (9999:6): [True: 0, False: 0] ------------------ 10000| 0| { 10001| 0| *errorptr = ERR92; 10002| 0| return NULL; 10003| 0| } 10004| | 10005| |/* A zero-terminated pattern is indicated by the special length value 10006| |PCRE2_ZERO_TERMINATED. Check for an overlong pattern. */ 10007| | 10008| 76.0k|if ((zero_terminated = (patlen == PCRE2_ZERO_TERMINATED))) ------------------ | | 479| 76.0k|#define PCRE2_ZERO_TERMINATED (~(PCRE2_SIZE)0) ------------------ | Branch (10008:5): [True: 0, False: 76.0k] ------------------ 10009| 0| patlen = PRIV(strlen)(pattern); ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 10010| | 10011| 76.0k|if (patlen > ccontext->max_pattern_length) ------------------ | Branch (10011:5): [True: 0, False: 76.0k] ------------------ 10012| 0| { 10013| 0| *errorptr = ERR88; 10014| 0| return NULL; 10015| 0| } 10016| | 10017| |/* From here on, all returns from this function should end up going via the 10018| |EXIT label. */ 10019| | 10020| | 10021| |/* ------------ Initialize the "static" compile data -------------- */ 10022| | 10023| 76.0k|tables = (ccontext->tables != NULL)? ccontext->tables : PRIV(default_tables); ------------------ | | 177| 76.0k|#define PRIV(name) _pcre2_##name ------------------ | Branch (10023:10): [True: 76.0k, False: 0] ------------------ 10024| | 10025| 76.0k|cb.lcc = tables + lcc_offset; /* Individual */ ------------------ | | 588| 76.0k|#define lcc_offset 0 /* Lower case */ ------------------ 10026| 76.0k|cb.fcc = tables + fcc_offset; /* character */ ------------------ | | 589| 76.0k|#define fcc_offset 256 /* Flip case */ ------------------ 10027| 76.0k|cb.cbits = tables + cbits_offset; /* tables */ ------------------ | | 590| 76.0k|#define cbits_offset 512 /* Character classes */ ------------------ 10028| 76.0k|cb.ctypes = tables + ctypes_offset; ------------------ | | 591| 76.0k|#define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | ------------------ | | | | 590| 76.0k|#define cbits_offset 512 /* Character classes */ | | ------------------ | | #define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | ------------------ | | | | 573| 76.0k|#define cbit_length 320 /* Length of the cbits table */ | | ------------------ ------------------ 10029| | 10030| 76.0k|cb.assert_depth = 0; 10031| 76.0k|cb.bracount = 0; 10032| 76.0k|cb.cx = ccontext; 10033| 76.0k|cb.dupnames = FALSE; ------------------ | | 69| 76.0k|#define FALSE 0 ------------------ 10034| 76.0k|cb.end_pattern = pattern + patlen; 10035| 76.0k|cb.erroroffset = 0; 10036| 76.0k|cb.external_flags = 0; 10037| 76.0k|cb.external_options = options; 10038| 76.0k|cb.groupinfo = stack_groupinfo; 10039| 76.0k|cb.had_recurse = FALSE; ------------------ | | 69| 76.0k|#define FALSE 0 ------------------ 10040| 76.0k|cb.lastcapture = 0; 10041| 76.0k|cb.max_lookbehind = 0; 10042| 76.0k|cb.name_entry_size = 0; 10043| 76.0k|cb.name_table = NULL; 10044| 76.0k|cb.named_groups = named_groups; 10045| 76.0k|cb.named_group_list_size = NAMED_GROUP_LIST_SIZE; ------------------ | | 187| 76.0k|#define NAMED_GROUP_LIST_SIZE 20 ------------------ 10046| 76.0k|cb.names_found = 0; 10047| 76.0k|cb.parens_depth = 0; 10048| 76.0k|cb.parsed_pattern = stack_parsed_pattern; 10049| 76.0k|cb.req_varyopt = 0; 10050| 76.0k|cb.start_code = cworkspace; 10051| 76.0k|cb.start_pattern = pattern; 10052| 76.0k|cb.start_workspace = cworkspace; 10053| 76.0k|cb.workspace_size = COMPILE_WORK_SIZE; ------------------ | | 166| 76.0k|#define COMPILE_WORK_SIZE (3000*LINK_SIZE) /* Size in code units */ | | ------------------ | | | | 165| 76.0k|#define LINK_SIZE 2 | | ------------------ ------------------ 10054| | 10055| |/* Maximum back reference and backref bitmap. The bitmap records up to 31 back 10056| |references to help in deciding whether (.*) can be treated as anchored or not. 10057| |*/ 10058| | 10059| 76.0k|cb.top_backref = 0; 10060| 76.0k|cb.backref_map = 0; 10061| | 10062| |/* Escape sequences \1 to \9 are always back references, but as they are only 10063| |two characters long, only two elements can be used in the parsed_pattern 10064| |vector. The first contains the reference, and we'd like to use the second to 10065| |record the offset in the pattern, so that forward references to non-existent 10066| |groups can be diagnosed later with an offset. However, on 64-bit systems, 10067| |PCRE2_SIZE won't fit. Instead, we have a vector of offsets for the first 10068| |occurrence of \1 to \9, indexed by the second parsed_pattern value. All other 10069| |references have enough space for the offset to be put into the parsed pattern. 10070| |*/ 10071| | 10072| 836k|for (i = 0; i < 10; i++) cb.small_ref_offset[i] = PCRE2_UNSET; ------------------ | | 480| 836k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (10072:13): [True: 760k, False: 76.0k] ------------------ 10073| | 10074| | 10075| |/* --------------- Start looking at the pattern --------------- */ 10076| | 10077| |/* Unless PCRE2_LITERAL is set, check for global one-time option settings at 10078| |the start of the pattern, and remember the offset to the actual regex. With 10079| |valgrind support, make the terminator of a zero-terminated pattern 10080| |inaccessible. This catches bugs that would otherwise only show up for 10081| |non-zero-terminated patterns. */ 10082| | 10083| |#ifdef SUPPORT_VALGRIND 10084| |if (zero_terminated) VALGRIND_MAKE_MEM_NOACCESS(pattern + patlen, CU2BYTES(1)); 10085| |#endif 10086| | 10087| 76.0k|ptr = pattern; 10088| 76.0k|skipatstart = 0; 10089| | 10090| 76.0k|if ((options & PCRE2_LITERAL) == 0) ------------------ | | 144| 76.0k|#define PCRE2_LITERAL 0x02000000u /* C */ ------------------ | Branch (10090:5): [True: 76.0k, False: 0] ------------------ 10091| 76.0k| { 10092| 80.3k| while (patlen - skipatstart >= 2 && ------------------ | Branch (10092:10): [True: 80.0k, False: 294] ------------------ 10093| 80.3k| ptr[skipatstart] == CHAR_LEFT_PARENTHESIS && ------------------ | | 990| 160k|#define CHAR_LEFT_PARENTHESIS '\050' ------------------ | Branch (10093:10): [True: 28.3k, False: 51.7k] ------------------ 10094| 80.3k| ptr[skipatstart+1] == CHAR_ASTERISK) ------------------ | | 992| 28.3k|#define CHAR_ASTERISK '\052' ------------------ | Branch (10094:10): [True: 6.16k, False: 22.1k] ------------------ 10095| 6.16k| { 10096| 92.4k| for (i = 0; i < sizeof(pso_list)/sizeof(pso); i++) ------------------ | Branch (10096:17): [True: 90.6k, False: 1.84k] ------------------ 10097| 90.6k| { 10098| 90.6k| uint32_t c, pp; 10099| 90.6k| pso *p = pso_list + i; 10100| | 10101| 90.6k| if (patlen - skipatstart - 2 >= p->length && ------------------ | Branch (10101:11): [True: 62.7k, False: 27.8k] ------------------ 10102| 90.6k| PRIV(strncmp_c8)(ptr + skipatstart + 2, (char *)(p->name), ------------------ | | 177| 62.7k|#define PRIV(name) _pcre2_##name ------------------ | Branch (10102:11): [True: 4.31k, False: 58.4k] ------------------ 10103| 62.7k| p->length) == 0) 10104| 4.31k| { 10105| 4.31k| skipatstart += p->length + 2; 10106| 4.31k| switch(p->type) ------------------ | Branch (10106:16): [True: 0, False: 4.31k] ------------------ 10107| 4.31k| { 10108| 1.22k| case PSO_OPT: ------------------ | Branch (10108:11): [True: 1.22k, False: 3.08k] ------------------ 10109| 1.22k| cb.external_options |= p->value; 10110| 1.22k| break; 10111| | 10112| 202| case PSO_FLG: ------------------ | Branch (10112:11): [True: 202, False: 4.11k] ------------------ 10113| 202| setflags |= p->value; 10114| 202| break; 10115| | 10116| 2.88k| case PSO_NL: ------------------ | Branch (10116:11): [True: 2.88k, False: 1.42k] ------------------ 10117| 2.88k| newline = p->value; 10118| 2.88k| setflags |= PCRE2_NL_SET; ------------------ | | 522| 2.88k|#define PCRE2_NL_SET 0x00008000 /* newline was set in the pattern */ ------------------ 10119| 2.88k| break; 10120| | 10121| 0| case PSO_BSR: ------------------ | Branch (10121:11): [True: 0, False: 4.31k] ------------------ 10122| 0| bsr = p->value; 10123| 0| setflags |= PCRE2_BSR_SET; ------------------ | | 521| 0|#define PCRE2_BSR_SET 0x00004000 /* BSR was set in the pattern */ ------------------ 10124| 0| break; 10125| | 10126| 0| case PSO_LIMM: ------------------ | Branch (10126:11): [True: 0, False: 4.31k] ------------------ 10127| 0| case PSO_LIMD: ------------------ | Branch (10127:11): [True: 0, False: 4.31k] ------------------ 10128| 0| case PSO_LIMH: ------------------ | Branch (10128:11): [True: 0, False: 4.31k] ------------------ 10129| 0| c = 0; 10130| 0| pp = skipatstart; 10131| 0| if (!IS_DIGIT(ptr[pp])) ------------------ | | 408| 0|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 0|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 0|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 0, False: 0] | | | Branch (408:39): [True: 0, False: 0] | | ------------------ ------------------ 10132| 0| { 10133| 0| errorcode = ERR60; 10134| 0| ptr += pp; 10135| 0| goto HAD_EARLY_ERROR; 10136| 0| } 10137| 0| while (IS_DIGIT(ptr[pp])) ------------------ | | 408| 0|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 0|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 0|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 0, False: 0] | | | Branch (408:39): [True: 0, False: 0] | | ------------------ ------------------ 10138| 0| { 10139| 0| if (c > UINT32_MAX / 10 - 1) break; /* Integer overflow */ ------------------ | Branch (10139:17): [True: 0, False: 0] ------------------ 10140| 0| c = c*10 + (ptr[pp++] - CHAR_0); ------------------ | | 998| 0|#define CHAR_0 '\060' ------------------ 10141| 0| } 10142| 0| if (ptr[pp++] != CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 0|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (10142:15): [True: 0, False: 0] ------------------ 10143| 0| { 10144| 0| errorcode = ERR60; 10145| 0| ptr += pp; 10146| 0| goto HAD_EARLY_ERROR; 10147| 0| } 10148| 0| if (p->type == PSO_LIMH) limit_heap = c; ------------------ | Branch (10148:15): [True: 0, False: 0] ------------------ 10149| 0| else if (p->type == PSO_LIMM) limit_match = c; ------------------ | Branch (10149:22): [True: 0, False: 0] ------------------ 10150| 0| else limit_depth = c; 10151| 0| skipatstart += pp - skipatstart; 10152| 0| break; 10153| 4.31k| } 10154| 4.31k| break; /* Out of the table scan loop */ 10155| 4.31k| } 10156| 90.6k| } 10157| 6.16k| if (i >= sizeof(pso_list)/sizeof(pso)) break; /* Out of pso loop */ ------------------ | Branch (10157:9): [True: 1.84k, False: 4.31k] ------------------ 10158| 6.16k| } 10159| 76.0k| } 10160| | 10161| |/* End of pattern-start options; advance to start of real regex. */ 10162| | 10163| 76.0k|ptr += skipatstart; 10164| | 10165| |/* Can't support UTF or UCP if PCRE2 was built without Unicode support. */ 10166| | 10167| |#ifndef SUPPORT_UNICODE 10168| |if ((cb.external_options & (PCRE2_UTF|PCRE2_UCP)) != 0) 10169| | { 10170| | errorcode = ERR32; 10171| | goto HAD_EARLY_ERROR; 10172| | } 10173| |#endif 10174| | 10175| |/* Check UTF. We have the original options in 'options', with that value as 10176| |modified by (*UTF) etc in cb->external_options. The extra option 10177| |PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES is not permitted in UTF-16 mode because the 10178| |surrogate code points cannot be represented in UTF-16. */ 10179| | 10180| 76.0k|utf = (cb.external_options & PCRE2_UTF) != 0; ------------------ | | 138| 76.0k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 10181| 76.0k|if (utf) ------------------ | Branch (10181:5): [True: 27.0k, False: 49.0k] ------------------ 10182| 27.0k| { 10183| 27.0k| if ((options & PCRE2_NEVER_UTF) != 0) ------------------ | | 131| 27.0k|#define PCRE2_NEVER_UTF 0x00001000u /* C */ ------------------ | Branch (10183:7): [True: 0, False: 27.0k] ------------------ 10184| 0| { 10185| 0| errorcode = ERR74; 10186| 0| goto HAD_EARLY_ERROR; 10187| 0| } 10188| 27.0k| if ((options & PCRE2_NO_UTF_CHECK) == 0 && ------------------ | | 106| 27.0k|#define PCRE2_NO_UTF_CHECK 0x40000000u ------------------ | Branch (10188:7): [True: 27.0k, False: 0] ------------------ 10189| 27.0k| (errorcode = PRIV(valid_utf)(pattern, patlen, erroroffset)) != 0) ------------------ | | 177| 27.0k|#define PRIV(name) _pcre2_##name ------------------ | Branch (10189:8): [True: 2.34k, False: 24.6k] ------------------ 10190| 2.34k| goto HAD_ERROR; /* Offset was set by valid_utf() */ 10191| | 10192| |#if PCRE2_CODE_UNIT_WIDTH == 16 10193| | if ((ccontext->extra_options & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) != 0) 10194| | { 10195| | errorcode = ERR91; 10196| | goto HAD_EARLY_ERROR; 10197| | } 10198| |#endif 10199| 27.0k| } 10200| | 10201| |/* Check UCP lockout. */ 10202| | 10203| 73.7k|ucp = (cb.external_options & PCRE2_UCP) != 0; ------------------ | | 136| 73.7k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ 10204| 73.7k|if (ucp && (cb.external_options & PCRE2_NEVER_UCP) != 0) ------------------ | | 130| 21.6k|#define PCRE2_NEVER_UCP 0x00000800u /* C */ ------------------ | Branch (10204:5): [True: 21.6k, False: 52.0k] | Branch (10204:12): [True: 0, False: 21.6k] ------------------ 10205| 0| { 10206| 0| errorcode = ERR75; 10207| 0| goto HAD_EARLY_ERROR; 10208| 0| } 10209| | 10210| |/* Process the BSR setting. */ 10211| | 10212| 73.7k|if (bsr == 0) bsr = ccontext->bsr_convention; ------------------ | Branch (10212:5): [True: 73.7k, False: 0] ------------------ 10213| | 10214| |/* Process the newline setting. */ 10215| | 10216| 73.7k|if (newline == 0) newline = ccontext->newline_convention; ------------------ | Branch (10216:5): [True: 71.1k, False: 2.60k] ------------------ 10217| 73.7k|cb.nltype = NLTYPE_FIXED; ------------------ | | 472| 73.7k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ 10218| 73.7k|switch(newline) 10219| 73.7k| { 10220| 92| case PCRE2_NEWLINE_CR: ------------------ | | 209| 92|#define PCRE2_NEWLINE_CR 1 ------------------ | Branch (10220:3): [True: 92, False: 73.6k] ------------------ 10221| 92| cb.nllen = 1; 10222| 92| cb.nl[0] = CHAR_CR; ------------------ | | 972| 92|#define CHAR_CR '\015' ------------------ 10223| 92| break; 10224| | 10225| 71.1k| case PCRE2_NEWLINE_LF: ------------------ | | 210| 71.1k|#define PCRE2_NEWLINE_LF 2 ------------------ | Branch (10225:3): [True: 71.1k, False: 2.59k] ------------------ 10226| 71.1k| cb.nllen = 1; 10227| 71.1k| cb.nl[0] = CHAR_NL; ------------------ | | 974| 71.1k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 71.1k|#define CHAR_LF '\012' | | ------------------ ------------------ 10228| 71.1k| break; 10229| | 10230| 5| case PCRE2_NEWLINE_NUL: ------------------ | | 214| 5|#define PCRE2_NEWLINE_NUL 6 ------------------ | Branch (10230:3): [True: 5, False: 73.7k] ------------------ 10231| 5| cb.nllen = 1; 10232| 5| cb.nl[0] = CHAR_NUL; ------------------ | | 981| 5|#define CHAR_NUL '\0' ------------------ 10233| 5| break; 10234| | 10235| 1.18k| case PCRE2_NEWLINE_CRLF: ------------------ | | 211| 1.18k|#define PCRE2_NEWLINE_CRLF 3 ------------------ | Branch (10235:3): [True: 1.18k, False: 72.5k] ------------------ 10236| 1.18k| cb.nllen = 2; 10237| 1.18k| cb.nl[0] = CHAR_CR; ------------------ | | 972| 1.18k|#define CHAR_CR '\015' ------------------ 10238| 1.18k| cb.nl[1] = CHAR_NL; ------------------ | | 974| 1.18k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 1.18k|#define CHAR_LF '\012' | | ------------------ ------------------ 10239| 1.18k| break; 10240| | 10241| 1.19k| case PCRE2_NEWLINE_ANY: ------------------ | | 212| 1.19k|#define PCRE2_NEWLINE_ANY 4 ------------------ | Branch (10241:3): [True: 1.19k, False: 72.5k] ------------------ 10242| 1.19k| cb.nltype = NLTYPE_ANY; ------------------ | | 473| 1.19k|#define NLTYPE_ANY 1 /* Newline is any Unicode line ending */ ------------------ 10243| 1.19k| break; 10244| | 10245| 130| case PCRE2_NEWLINE_ANYCRLF: ------------------ | | 213| 130|#define PCRE2_NEWLINE_ANYCRLF 5 ------------------ | Branch (10245:3): [True: 130, False: 73.5k] ------------------ 10246| 130| cb.nltype = NLTYPE_ANYCRLF; ------------------ | | 474| 130|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ 10247| 130| break; 10248| | 10249| 0| default: ------------------ | Branch (10249:3): [True: 0, False: 73.7k] ------------------ 10250| 0| errorcode = ERR56; 10251| 0| goto HAD_EARLY_ERROR; 10252| 73.7k| } 10253| | 10254| |/* Pre-scan the pattern to do two things: (1) Discover the named groups and 10255| |their numerical equivalents, so that this information is always available for 10256| |the remaining processing. (2) At the same time, parse the pattern and put a 10257| |processed version into the parsed_pattern vector. This has escapes interpreted 10258| |and comments removed (amongst other things). 10259| | 10260| |In all but one case, when PCRE2_AUTO_CALLOUT is not set, the number of unsigned 10261| |32-bit ints in the parsed pattern is bounded by the length of the pattern plus 10262| |one (for the terminator) plus four if PCRE2_EXTRA_WORD or PCRE2_EXTRA_LINE is 10263| |set. The exceptional case is when running in 32-bit, non-UTF mode, when literal 10264| |characters greater than META_END (0x80000000) have to be coded as two units. In 10265| |this case, therefore, we scan the pattern to check for such values. */ 10266| | 10267| |#if PCRE2_CODE_UNIT_WIDTH == 32 10268| |if (!utf) 10269| | { 10270| | PCRE2_SPTR p; 10271| | for (p = ptr; p < cb.end_pattern; p++) if (*p >= META_END) big32count++; 10272| | } 10273| |#endif 10274| | 10275| |/* Ensure that the parsed pattern buffer is big enough. When PCRE2_AUTO_CALLOUT 10276| |is set we have to assume a numerical callout (4 elements) for each character 10277| |plus one at the end. This is overkill, but memory is plentiful these days. For 10278| |many smaller patterns the vector on the stack (which was set up above) can be 10279| |used. */ 10280| | 10281| 73.7k|parsed_size_needed = patlen - skipatstart + big32count; 10282| | 10283| 73.7k|if ((ccontext->extra_options & ------------------ | Branch (10283:5): [True: 0, False: 73.7k] ------------------ 10284| 73.7k| (PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_MATCH_LINE)) != 0) ------------------ | | 151| 73.7k|#define PCRE2_EXTRA_MATCH_WORD 0x00000004u /* C */ ------------------ (PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_MATCH_LINE)) != 0) ------------------ | | 152| 73.7k|#define PCRE2_EXTRA_MATCH_LINE 0x00000008u /* C */ ------------------ 10285| 0| parsed_size_needed += 4; 10286| | 10287| 73.7k|if ((options & PCRE2_AUTO_CALLOUT) != 0) ------------------ | | 121| 73.7k|#define PCRE2_AUTO_CALLOUT 0x00000004u /* C */ ------------------ | Branch (10287:5): [True: 15.0k, False: 58.6k] ------------------ 10288| 15.0k| parsed_size_needed = (parsed_size_needed + 1) * 5; 10289| | 10290| 73.7k|if (parsed_size_needed >= PARSED_PATTERN_DEFAULT_SIZE) ------------------ | | 193| 73.7k|#define PARSED_PATTERN_DEFAULT_SIZE 1024 ------------------ | Branch (10290:5): [True: 673, False: 73.0k] ------------------ 10291| 673| { 10292| 673| uint32_t *heap_parsed_pattern = ccontext->memctl.malloc( 10293| 673| (parsed_size_needed + 1) * sizeof(uint32_t), ccontext->memctl.memory_data); 10294| 673| if (heap_parsed_pattern == NULL) ------------------ | Branch (10294:7): [True: 0, False: 673] ------------------ 10295| 0| { 10296| 0| *errorptr = ERR21; 10297| 0| goto EXIT; 10298| 0| } 10299| 673| cb.parsed_pattern = heap_parsed_pattern; 10300| 673| } 10301| 73.7k|cb.parsed_pattern_end = cb.parsed_pattern + parsed_size_needed + 1; 10302| | 10303| |/* Do the parsing scan. */ 10304| | 10305| 73.7k|errorcode = parse_regex(ptr, cb.external_options, &has_lookbehind, &cb); 10306| 73.7k|if (errorcode != 0) goto HAD_CB_ERROR; ------------------ | Branch (10306:5): [True: 6.09k, False: 67.6k] ------------------ 10307| | 10308| |/* Workspace is needed to remember information about numbered groups: whether a 10309| |group can match an empty string and what its fixed length is. This is done to 10310| |avoid the possibility of recursive references causing very long compile times 10311| |when checking these features. Unnumbered groups do not have this exposure since 10312| |they cannot be referenced. We use an indexed vector for this purpose. If there 10313| |are sufficiently few groups, the default vector on the stack, as set up above, 10314| |can be used. Otherwise we have to get/free a special vector. The vector must be 10315| |initialized to zero. */ 10316| | 10317| 67.6k|if (cb.bracount >= GROUPINFO_DEFAULT_SIZE) ------------------ | | 175| 67.6k|#define GROUPINFO_DEFAULT_SIZE 256 ------------------ | Branch (10317:5): [True: 138, False: 67.4k] ------------------ 10318| 138| { 10319| 138| cb.groupinfo = ccontext->memctl.malloc( 10320| 138| (cb.bracount + 1)*sizeof(uint32_t), ccontext->memctl.memory_data); 10321| 138| if (cb.groupinfo == NULL) ------------------ | Branch (10321:7): [True: 0, False: 138] ------------------ 10322| 0| { 10323| 0| errorcode = ERR21; 10324| 0| cb.erroroffset = 0; 10325| 0| goto HAD_CB_ERROR; 10326| 0| } 10327| 138| } 10328| 67.6k|memset(cb.groupinfo, 0, (cb.bracount + 1) * sizeof(uint32_t)); 10329| | 10330| |/* If there were any lookbehinds, scan the parsed pattern to figure out their 10331| |lengths. */ 10332| | 10333| 67.6k|if (has_lookbehind) ------------------ | Branch (10333:5): [True: 3.37k, False: 64.2k] ------------------ 10334| 3.37k| { 10335| 3.37k| int loopcount = 0; 10336| 3.37k| errorcode = check_lookbehinds(cb.parsed_pattern, NULL, NULL, &cb, &loopcount); 10337| 3.37k| if (errorcode != 0) goto HAD_CB_ERROR; ------------------ | Branch (10337:7): [True: 509, False: 2.86k] ------------------ 10338| 3.37k| } 10339| | 10340| |/* For debugging, there is a function that shows the parsed data vector. */ 10341| | 10342| |#ifdef DEBUG_SHOW_PARSED 10343| |fprintf(stderr, "+++ Pre-scan complete:\n"); 10344| |show_parsed(&cb); 10345| |#endif 10346| | 10347| |/* For debugging capturing information this code can be enabled. */ 10348| | 10349| |#ifdef DEBUG_SHOW_CAPTURES 10350| | { 10351| | named_group *ng = cb.named_groups; 10352| | fprintf(stderr, "+++Captures: %d\n", cb.bracount); 10353| | for (i = 0; i < cb.names_found; i++, ng++) 10354| | { 10355| | fprintf(stderr, "+++%3d %.*s\n", ng->number, ng->length, ng->name); 10356| | } 10357| | } 10358| |#endif 10359| | 10360| |/* Pretend to compile the pattern while actually just accumulating the amount 10361| |of memory required in the 'length' variable. This behaviour is triggered by 10362| |passing a non-NULL final argument to compile_regex(). We pass a block of 10363| |workspace (cworkspace) for it to compile parts of the pattern into; the 10364| |compiled code is discarded when it is no longer needed, so hopefully this 10365| |workspace will never overflow, though there is a test for its doing so. 10366| | 10367| |On error, errorcode will be set non-zero, so we don't need to look at the 10368| |result of the function. The initial options have been put into the cb block, 10369| |but we still have to pass a separate options variable (the first argument) 10370| |because the options may change as the pattern is processed. */ 10371| | 10372| 67.1k|cb.erroroffset = patlen; /* For any subsequent errors that do not set it */ 10373| 67.1k|pptr = cb.parsed_pattern; 10374| 67.1k|code = cworkspace; 10375| 67.1k|*code = OP_BRA; 10376| | 10377| 67.1k|(void)compile_regex(cb.external_options, ccontext->extra_options, &code, &pptr, 10378| 67.1k| &errorcode, 0, &firstcu, &firstcuflags, &reqcu, &reqcuflags, NULL, NULL, 10379| 67.1k| &cb, &length); 10380| | 10381| 67.1k|if (errorcode != 0) goto HAD_CB_ERROR; /* Offset is in cb.erroroffset */ ------------------ | Branch (10381:5): [True: 1.83k, False: 65.2k] ------------------ 10382| | 10383| |/* This should be caught in compile_regex(), but just in case... */ 10384| | 10385| 65.2k|if (length > MAX_PATTERN_SIZE) ------------------ | | 110| 65.2k|#define MAX_PATTERN_SIZE (1 << 16) ------------------ | Branch (10385:5): [True: 3, False: 65.2k] ------------------ 10386| 3| { 10387| 3| errorcode = ERR20; 10388| 3| goto HAD_CB_ERROR; 10389| 3| } 10390| | 10391| |/* Compute the size of, and then get and initialize, the data block for storing 10392| |the compiled pattern and names table. Integer overflow should no longer be 10393| |possible because nowadays we limit the maximum value of cb.names_found and 10394| |cb.name_entry_size. */ 10395| | 10396| 65.2k|re_blocksize = sizeof(pcre2_real_code) + 10397| 65.2k| CU2BYTES(length + ------------------ | | 545| 65.2k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 10398| 65.2k| (PCRE2_SIZE)cb.names_found * (PCRE2_SIZE)cb.name_entry_size); 10399| 65.2k|re = (pcre2_real_code *) 10400| 65.2k| ccontext->memctl.malloc(re_blocksize, ccontext->memctl.memory_data); 10401| 65.2k|if (re == NULL) ------------------ | Branch (10401:5): [True: 0, False: 65.2k] ------------------ 10402| 0| { 10403| 0| errorcode = ERR21; 10404| 0| goto HAD_CB_ERROR; 10405| 0| } 10406| | 10407| |/* The compiler may put padding at the end of the pcre2_real_code structure in 10408| |order to round it up to a multiple of 4 or 8 bytes. This means that when a 10409| |compiled pattern is copied (for example, when serialized) undefined bytes are 10410| |read, and this annoys debuggers such as valgrind. To avoid this, we explicitly 10411| |write to the last 8 bytes of the structure before setting the fields. */ 10412| | 10413| 65.2k|memset((char *)re + sizeof(pcre2_real_code) - 8, 0, 8); 10414| 65.2k|re->memctl = ccontext->memctl; 10415| 65.2k|re->tables = tables; 10416| 65.2k|re->executable_jit = NULL; 10417| 65.2k|memset(re->start_bitmap, 0, 32 * sizeof(uint8_t)); 10418| 65.2k|re->blocksize = re_blocksize; 10419| 65.2k|re->magic_number = MAGIC_NUMBER; ------------------ | | 546| 65.2k|#define MAGIC_NUMBER 0x50435245UL /* 'PCRE' */ ------------------ 10420| 65.2k|re->compile_options = options; 10421| 65.2k|re->overall_options = cb.external_options; 10422| 65.2k|re->extra_options = ccontext->extra_options; 10423| 65.2k|re->flags = PCRE2_CODE_UNIT_WIDTH/8 | cb.external_flags | setflags; 10424| 65.2k|re->limit_heap = limit_heap; 10425| 65.2k|re->limit_match = limit_match; 10426| 65.2k|re->limit_depth = limit_depth; 10427| 65.2k|re->first_codeunit = 0; 10428| 65.2k|re->last_codeunit = 0; 10429| 65.2k|re->bsr_convention = bsr; 10430| 65.2k|re->newline_convention = newline; 10431| 65.2k|re->max_lookbehind = 0; 10432| 65.2k|re->minlength = 0; 10433| 65.2k|re->top_bracket = 0; 10434| 65.2k|re->top_backref = 0; 10435| 65.2k|re->name_entry_size = cb.name_entry_size; 10436| 65.2k|re->name_count = cb.names_found; 10437| | 10438| |/* The basic block is immediately followed by the name table, and the compiled 10439| |code follows after that. */ 10440| | 10441| 65.2k|codestart = (PCRE2_SPTR)((uint8_t *)re + sizeof(pcre2_real_code)) + 10442| 65.2k| re->name_entry_size * re->name_count; 10443| | 10444| |/* Update the compile data block for the actual compile. The starting points of 10445| |the name/number translation table and of the code are passed around in the 10446| |compile data block. The start/end pattern and initial options are already set 10447| |from the pre-compile phase, as is the name_entry_size field. */ 10448| | 10449| 65.2k|cb.parens_depth = 0; 10450| 65.2k|cb.assert_depth = 0; 10451| 65.2k|cb.lastcapture = 0; 10452| 65.2k|cb.name_table = (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code)); 10453| 65.2k|cb.start_code = codestart; 10454| 65.2k|cb.req_varyopt = 0; 10455| 65.2k|cb.had_accept = FALSE; ------------------ | | 69| 65.2k|#define FALSE 0 ------------------ 10456| 65.2k|cb.had_pruneorskip = FALSE; ------------------ | | 69| 65.2k|#define FALSE 0 ------------------ 10457| | 10458| |/* If any named groups were found, create the name/number table from the list 10459| |created in the pre-pass. */ 10460| | 10461| 65.2k|if (cb.names_found > 0) ------------------ | Branch (10461:5): [True: 907, False: 64.3k] ------------------ 10462| 907| { 10463| 907| named_group *ng = cb.named_groups; ------------------ | | 1983| 907|#define named_group PCRE2_SUFFIX(named_group_) | | ------------------ | | | | 986| 907|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 907|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 907|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 10464| 7.27k| for (i = 0; i < cb.names_found; i++, ng++) ------------------ | Branch (10464:15): [True: 6.37k, False: 907] ------------------ 10465| 6.37k| add_name_to_table(&cb, ng->name, ng->length, ng->number, i); 10466| 907| } 10467| | 10468| |/* Set up a starting, non-extracting bracket, then compile the expression. On 10469| |error, errorcode will be set non-zero, so we don't need to look at the result 10470| |of the function here. */ 10471| | 10472| 65.2k|pptr = cb.parsed_pattern; 10473| 65.2k|code = (PCRE2_UCHAR *)codestart; 10474| 65.2k|*code = OP_BRA; 10475| 65.2k|regexrc = compile_regex(re->overall_options, ccontext->extra_options, &code, 10476| 65.2k| &pptr, &errorcode, 0, &firstcu, &firstcuflags, &reqcu, &reqcuflags, NULL, 10477| 65.2k| NULL, &cb, NULL); 10478| 65.2k|if (regexrc < 0) re->flags |= PCRE2_MATCH_EMPTY; ------------------ | | 520| 17.7k|#define PCRE2_MATCH_EMPTY 0x00002000 /* pattern can match empty string */ ------------------ | Branch (10478:5): [True: 17.7k, False: 47.5k] ------------------ 10479| 65.2k|re->top_bracket = cb.bracount; 10480| 65.2k|re->top_backref = cb.top_backref; 10481| 65.2k|re->max_lookbehind = cb.max_lookbehind; 10482| | 10483| 65.2k|if (cb.had_accept) ------------------ | Branch (10483:5): [True: 374, False: 64.9k] ------------------ 10484| 374| { 10485| 374| reqcu = 0; /* Must disable after (*ACCEPT) */ 10486| 374| reqcuflags = REQ_NONE; ------------------ | | 394| 374|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 10487| 374| re->flags |= PCRE2_HASACCEPT; /* Disables minimum length */ ------------------ | | 530| 374|#define PCRE2_HASACCEPT 0x00800000 /* contains (*ACCEPT) */ ------------------ 10488| 374| } 10489| | 10490| |/* Fill in the final opcode and check for disastrous overflow. If no overflow, 10491| |but the estimated length exceeds the really used length, adjust the value of 10492| |re->blocksize, and if valgrind support is configured, mark the extra allocated 10493| |memory as unaddressable, so that any out-of-bound reads can be detected. */ 10494| | 10495| 65.2k|*code++ = OP_END; 10496| 65.2k|usedlength = code - codestart; 10497| 65.2k|if (usedlength > length) errorcode = ERR23; else ------------------ | Branch (10497:5): [True: 0, False: 65.2k] ------------------ 10498| 65.2k| { 10499| 65.2k| re->blocksize -= CU2BYTES(length - usedlength); ------------------ | | 545| 65.2k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 10500| |#ifdef SUPPORT_VALGRIND 10501| | VALGRIND_MAKE_MEM_NOACCESS(code, CU2BYTES(length - usedlength)); 10502| |#endif 10503| 65.2k| } 10504| | 10505| |/* Scan the pattern for recursion/subroutine calls and convert the group 10506| |numbers into offsets. Maintain a small cache so that repeated groups containing 10507| |recursions are efficiently handled. */ 10508| | 10509| 65.2k|#define RSCAN_CACHE_SIZE 8 10510| | 10511| 65.2k|if (errorcode == 0 && cb.had_recurse) ------------------ | Branch (10511:5): [True: 65.2k, False: 19] | Branch (10511:23): [True: 3.24k, False: 62.0k] ------------------ 10512| 3.24k| { 10513| 3.24k| PCRE2_UCHAR *rcode; ------------------ | | 813| 3.24k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 3.24k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 3.24k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 3.24k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 10514| 3.24k| PCRE2_SPTR rgroup; ------------------ | | 814| 3.24k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 3.24k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 3.24k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 3.24k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 10515| 3.24k| unsigned int ccount = 0; 10516| 3.24k| int start = RSCAN_CACHE_SIZE; ------------------ | |10509| 3.24k|#define RSCAN_CACHE_SIZE 8 ------------------ 10517| 3.24k| recurse_cache rc[RSCAN_CACHE_SIZE]; 10518| | 10519| 3.24k| for (rcode = (PCRE2_UCHAR *)find_recurse(codestart, utf); 10520| 186k| rcode != NULL; ------------------ | Branch (10520:8): [True: 182k, False: 3.24k] ------------------ 10521| 182k| rcode = (PCRE2_UCHAR *)find_recurse(rcode + 1 + LINK_SIZE, utf)) ------------------ | | 165| 182k|#define LINK_SIZE 2 ------------------ 10522| 182k| { 10523| 182k| int p, groupnumber; 10524| | 10525| 182k| groupnumber = (int)GET(rcode, 1); ------------------ | | 109| 182k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 10526| 182k| if (groupnumber == 0) rgroup = codestart; else ------------------ | Branch (10526:9): [True: 168k, False: 14.1k] ------------------ 10527| 14.1k| { 10528| 14.1k| PCRE2_SPTR search_from = codestart; ------------------ | | 814| 14.1k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 14.1k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 14.1k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 14.1k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 10529| 14.1k| rgroup = NULL; 10530| 43.0k| for (i = 0, p = start; i < ccount; i++, p = (p + 1) & 7) ------------------ | Branch (10530:30): [True: 36.4k, False: 6.60k] ------------------ 10531| 36.4k| { 10532| 36.4k| if (groupnumber == rc[p].groupnumber) ------------------ | Branch (10532:13): [True: 7.54k, False: 28.8k] ------------------ 10533| 7.54k| { 10534| 7.54k| rgroup = rc[p].group; 10535| 7.54k| break; 10536| 7.54k| } 10537| | 10538| | /* Group n+1 must always start to the right of group n, so we can save 10539| | search time below when the new group number is greater than any of the 10540| | previously found groups. */ 10541| | 10542| 28.8k| if (groupnumber > rc[p].groupnumber) search_from = rc[p].group; ------------------ | Branch (10542:13): [True: 17.2k, False: 11.6k] ------------------ 10543| 28.8k| } 10544| | 10545| 14.1k| if (rgroup == NULL) ------------------ | Branch (10545:11): [True: 6.60k, False: 7.54k] ------------------ 10546| 6.60k| { 10547| 6.60k| rgroup = PRIV(find_bracket)(search_from, utf, groupnumber); ------------------ | | 177| 6.60k|#define PRIV(name) _pcre2_##name ------------------ 10548| 6.60k| if (rgroup == NULL) ------------------ | Branch (10548:13): [True: 0, False: 6.60k] ------------------ 10549| 0| { 10550| 0| errorcode = ERR53; 10551| 0| break; 10552| 0| } 10553| 6.60k| if (--start < 0) start = RSCAN_CACHE_SIZE - 1; ------------------ | |10509| 337|#define RSCAN_CACHE_SIZE 8 ------------------ | Branch (10553:13): [True: 337, False: 6.27k] ------------------ 10554| 6.60k| rc[start].groupnumber = groupnumber; 10555| 6.60k| rc[start].group = rgroup; 10556| 6.60k| if (ccount < RSCAN_CACHE_SIZE) ccount++; ------------------ | |10509| 6.60k|#define RSCAN_CACHE_SIZE 8 ------------------ | Branch (10556:13): [True: 4.04k, False: 2.56k] ------------------ 10557| 6.60k| } 10558| 14.1k| } 10559| | 10560| 182k| PUT(rcode, 1, rgroup - codestart); ------------------ | | 106| 182k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 182k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 10561| 182k| } 10562| 3.24k| } 10563| | 10564| |/* In rare debugging situations we sometimes need to look at the compiled code 10565| |at this stage. */ 10566| | 10567| |#ifdef DEBUG_CALL_PRINTINT 10568| |pcre2_printint(re, stderr, TRUE); 10569| |fprintf(stderr, "Length=%lu Used=%lu\n", length, usedlength); 10570| |#endif 10571| | 10572| |/* Unless disabled, check whether any single character iterators can be 10573| |auto-possessified. The function overwrites the appropriate opcode values, so 10574| |the type of the pointer must be cast. NOTE: the intermediate variable "temp" is 10575| |used in this code because at least one compiler gives a warning about loss of 10576| |"const" attribute if the cast (PCRE2_UCHAR *)codestart is used directly in the 10577| |function call. */ 10578| | 10579| 65.2k|if (errorcode == 0 && (re->overall_options & PCRE2_NO_AUTO_POSSESS) == 0) ------------------ | | 133| 65.2k|#define PCRE2_NO_AUTO_POSSESS 0x00004000u /* C */ ------------------ | Branch (10579:5): [True: 65.2k, False: 19] | Branch (10579:23): [True: 47.1k, False: 18.1k] ------------------ 10580| 47.1k| { 10581| 47.1k| PCRE2_UCHAR *temp = (PCRE2_UCHAR *)codestart; ------------------ | | 813| 47.1k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 47.1k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 47.1k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 47.1k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 10582| 47.1k| if (PRIV(auto_possessify)(temp, &cb) != 0) errorcode = ERR80; ------------------ | | 177| 47.1k|#define PRIV(name) _pcre2_##name ------------------ | Branch (10582:7): [True: 0, False: 47.1k] ------------------ 10583| 47.1k| } 10584| | 10585| |/* Failed to compile, or error while post-processing. */ 10586| | 10587| 65.2k|if (errorcode != 0) goto HAD_CB_ERROR; ------------------ | Branch (10587:5): [True: 19, False: 65.2k] ------------------ 10588| | 10589| |/* Successful compile. If the anchored option was not passed, set it if 10590| |we can determine that the pattern is anchored by virtue of ^ characters or \A 10591| |or anything else, such as starting with non-atomic .* when DOTALL is set and 10592| |there are no occurrences of *PRUNE or *SKIP (though there is an option to 10593| |disable this case). */ 10594| | 10595| 65.2k|if ((re->overall_options & PCRE2_ANCHORED) == 0 && ------------------ | | 105| 65.2k|#define PCRE2_ANCHORED 0x80000000u ------------------ | Branch (10595:5): [True: 56.3k, False: 8.89k] ------------------ 10596| 65.2k| is_anchored(codestart, 0, &cb, 0, FALSE)) ------------------ | | 69| 56.3k|#define FALSE 0 ------------------ | Branch (10596:6): [True: 730, False: 55.6k] ------------------ 10597| 730| re->overall_options |= PCRE2_ANCHORED; ------------------ | | 105| 730|#define PCRE2_ANCHORED 0x80000000u ------------------ 10598| | 10599| |/* Set up the first code unit or startline flag, the required code unit, and 10600| |then study the pattern. This code need not be obeyed if PCRE2_NO_START_OPTIMIZE 10601| |is set, as the data it would create will not be used. Note that a first code 10602| |unit (but not the startline flag) is useful for anchored patterns because it 10603| |can still give a quick "no match" and also avoid searching for a last code 10604| |unit. */ 10605| | 10606| 65.2k|if ((re->overall_options & PCRE2_NO_START_OPTIMIZE) == 0) ------------------ | | 135| 65.2k|#define PCRE2_NO_START_OPTIMIZE 0x00010000u /* J M D */ ------------------ | Branch (10606:5): [True: 50.3k, False: 14.9k] ------------------ 10607| 50.3k| { 10608| 50.3k| int minminlength = 0; /* For minimal minlength from first/required CU */ 10609| | 10610| | /* If we do not have a first code unit, see if there is one that is asserted 10611| | (these are not saved during the compile because they can cause conflicts with 10612| | actual literals that follow). */ 10613| | 10614| 50.3k| if (firstcuflags >= REQ_NONE) ------------------ | | 394| 50.3k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (10614:7): [True: 42.0k, False: 8.27k] ------------------ 10615| 42.0k| firstcu = find_firstassertedcu(codestart, &firstcuflags, 0); 10616| | 10617| | /* Save the data for a first code unit. The existence of one means the 10618| | minimum length must be at least 1. */ 10619| | 10620| 50.3k| if (firstcuflags < REQ_NONE) ------------------ | | 394| 50.3k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (10620:7): [True: 8.45k, False: 41.9k] ------------------ 10621| 8.45k| { 10622| 8.45k| re->first_codeunit = firstcu; 10623| 8.45k| re->flags |= PCRE2_FIRSTSET; ------------------ | | 511| 8.45k|#define PCRE2_FIRSTSET 0x00000010 /* first_code unit is set */ ------------------ 10624| 8.45k| minminlength++; 10625| | 10626| | /* Handle caseless first code units. */ 10627| | 10628| 8.45k| if ((firstcuflags & REQ_CASELESS) != 0) ------------------ | | 395| 8.45k|#define REQ_CASELESS 0x00000001u /* Code unit in xxcu is caseless */ ------------------ | Branch (10628:9): [True: 1.29k, False: 7.16k] ------------------ 10629| 1.29k| { 10630| 1.29k| if (firstcu < 128 || (!utf && !ucp && firstcu < 255)) ------------------ | Branch (10630:11): [True: 1.11k, False: 181] | Branch (10630:29): [True: 181, False: 0] | Branch (10630:37): [True: 94, False: 87] | Branch (10630:45): [True: 83, False: 11] ------------------ 10631| 1.19k| { 10632| 1.19k| if (cb.fcc[firstcu] != firstcu) re->flags |= PCRE2_FIRSTCASELESS; ------------------ | | 512| 309|#define PCRE2_FIRSTCASELESS 0x00000020 /* caseless first code unit */ ------------------ | Branch (10632:13): [True: 309, False: 885] ------------------ 10633| 1.19k| } 10634| | 10635| | /* The first code unit is > 128 in UTF or UCP mode, or > 255 otherwise. 10636| | In 8-bit UTF mode, codepoints in the range 128-255 are introductory code 10637| | points and cannot have another case, but if UCP is set they may do. */ 10638| | 10639| 98|#ifdef SUPPORT_UNICODE 10640| 98|#if PCRE2_CODE_UNIT_WIDTH == 8 10641| 98| else if (ucp && !utf && UCD_OTHERCASE(firstcu) != firstcu) ------------------ | | 1862| 87|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 87|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 87|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 87|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 87| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 87|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 87|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 87|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 87| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 87|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 87|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (10641:16): [True: 87, False: 11] | Branch (10641:23): [True: 87, False: 0] | Branch (10641:31): [True: 57, False: 30] ------------------ 10642| 57| re->flags |= PCRE2_FIRSTCASELESS; ------------------ | | 512| 57|#define PCRE2_FIRSTCASELESS 0x00000020 /* caseless first code unit */ ------------------ 10643| |#else 10644| | else if ((utf || ucp) && firstcu <= MAX_UTF_CODE_POINT && 10645| | UCD_OTHERCASE(firstcu) != firstcu) 10646| | re->flags |= PCRE2_FIRSTCASELESS; 10647| |#endif 10648| 1.29k|#endif /* SUPPORT_UNICODE */ 10649| 1.29k| } 10650| 8.45k| } 10651| | 10652| | /* When there is no first code unit, for non-anchored patterns, see if we can 10653| | set the PCRE2_STARTLINE flag. This is helpful for multiline matches when all 10654| | branches start with ^ and also when all branches start with non-atomic .* for 10655| | non-DOTALL matches when *PRUNE and SKIP are not present. (There is an option 10656| | that disables this case.) */ 10657| | 10658| 41.9k| else if ((re->overall_options & PCRE2_ANCHORED) == 0 && ------------------ | | 105| 41.9k|#define PCRE2_ANCHORED 0x80000000u ------------------ | Branch (10658:12): [True: 37.5k, False: 4.34k] ------------------ 10659| 41.9k| is_startline(codestart, 0, &cb, 0, FALSE)) ------------------ | | 69| 37.5k|#define FALSE 0 ------------------ | Branch (10659:12): [True: 1.73k, False: 35.8k] ------------------ 10660| 1.73k| re->flags |= PCRE2_STARTLINE; ------------------ | | 516| 1.73k|#define PCRE2_STARTLINE 0x00000200 /* start after \n for multiline */ ------------------ 10661| | 10662| | /* Handle the "required code unit", if one is set. In the UTF case we can 10663| | increment the minimum minimum length only if we are sure this really is a 10664| | different character and not a non-starting code unit of the first character, 10665| | because the minimum length count is in characters, not code units. */ 10666| | 10667| 50.3k| if (reqcuflags < REQ_NONE) ------------------ | | 394| 50.3k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (10667:7): [True: 23.6k, False: 26.7k] ------------------ 10668| 23.6k| { 10669| |#if PCRE2_CODE_UNIT_WIDTH == 16 10670| | if ((re->overall_options & PCRE2_UTF) == 0 || /* Not UTF */ 10671| | firstcuflags >= REQ_NONE || /* First not set */ 10672| | (firstcu & 0xf800) != 0xd800 || /* First not surrogate */ 10673| | (reqcu & 0xfc00) != 0xdc00) /* Req not low surrogate */ 10674| |#elif PCRE2_CODE_UNIT_WIDTH == 8 10675| 23.6k| if ((re->overall_options & PCRE2_UTF) == 0 || /* Not UTF */ ------------------ | | 138| 23.6k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ | Branch (10675:9): [True: 18.9k, False: 4.69k] ------------------ 10676| 23.6k| firstcuflags >= REQ_NONE || /* First not set */ ------------------ | | 394| 28.3k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (10676:9): [True: 3.87k, False: 814] ------------------ 10677| 23.6k| (firstcu & 0x80) == 0 || /* First is ASCII */ ------------------ | Branch (10677:9): [True: 583, False: 231] ------------------ 10678| 23.6k| (reqcu & 0x80) == 0) /* Req is ASCII */ ------------------ | Branch (10678:9): [True: 29, False: 202] ------------------ 10679| 23.4k|#endif 10680| 23.4k| { 10681| 23.4k| minminlength++; 10682| 23.4k| } 10683| | 10684| | /* In the case of an anchored pattern, set up the value only if it follows 10685| | a variable length item in the pattern. */ 10686| | 10687| 23.6k| if ((re->overall_options & PCRE2_ANCHORED) == 0 || ------------------ | | 105| 23.6k|#define PCRE2_ANCHORED 0x80000000u ------------------ | Branch (10687:9): [True: 21.6k, False: 1.93k] ------------------ 10688| 23.6k| (reqcuflags & REQ_VARY) != 0) ------------------ | | 396| 1.93k|#define REQ_VARY 0x00000002u /* Code unit is followed by non-literal */ ------------------ | Branch (10688:9): [True: 1.17k, False: 766] ------------------ 10689| 22.8k| { 10690| 22.8k| re->last_codeunit = reqcu; 10691| 22.8k| re->flags |= PCRE2_LASTSET; ------------------ | | 514| 22.8k|#define PCRE2_LASTSET 0x00000080 /* last code unit is set */ ------------------ 10692| | 10693| | /* Handle caseless required code units as for first code units (above). */ 10694| | 10695| 22.8k| if ((reqcuflags & REQ_CASELESS) != 0) ------------------ | | 395| 22.8k|#define REQ_CASELESS 0x00000001u /* Code unit in xxcu is caseless */ ------------------ | Branch (10695:11): [True: 3.36k, False: 19.4k] ------------------ 10696| 3.36k| { 10697| 3.36k| if (reqcu < 128 || (!utf && !ucp && reqcu < 255)) ------------------ | Branch (10697:13): [True: 3.00k, False: 365] | Branch (10697:29): [True: 365, False: 0] | Branch (10697:37): [True: 155, False: 210] | Branch (10697:45): [True: 145, False: 10] ------------------ 10698| 3.14k| { 10699| 3.14k| if (cb.fcc[reqcu] != reqcu) re->flags |= PCRE2_LASTCASELESS; ------------------ | | 515| 724|#define PCRE2_LASTCASELESS 0x00000100 /* caseless last code unit */ ------------------ | Branch (10699:15): [True: 724, False: 2.42k] ------------------ 10700| 3.14k| } 10701| 220|#ifdef SUPPORT_UNICODE 10702| 220|#if PCRE2_CODE_UNIT_WIDTH == 8 10703| 220| else if (ucp && !utf && UCD_OTHERCASE(reqcu) != reqcu) ------------------ | | 1862| 210|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 210|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 210|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 210|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 210| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 210|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 210|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 210|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 210| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 210|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 210|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (10703:16): [True: 210, False: 10] | Branch (10703:23): [True: 210, False: 0] | Branch (10703:31): [True: 131, False: 79] ------------------ 10704| 131| re->flags |= PCRE2_LASTCASELESS; ------------------ | | 515| 131|#define PCRE2_LASTCASELESS 0x00000100 /* caseless last code unit */ ------------------ 10705| |#else 10706| | else if ((utf || ucp) && reqcu <= MAX_UTF_CODE_POINT && 10707| | UCD_OTHERCASE(reqcu) != reqcu) 10708| | re->flags |= PCRE2_LASTCASELESS; 10709| |#endif 10710| 3.36k|#endif /* SUPPORT_UNICODE */ 10711| 3.36k| } 10712| 22.8k| } 10713| 23.6k| } 10714| | 10715| | /* Study the compiled pattern to set up information such as a bitmap of 10716| | starting code units and a minimum matching length. */ 10717| | 10718| 50.3k| if (PRIV(study)(re) != 0) ------------------ | | 177| 50.3k|#define PRIV(name) _pcre2_##name ------------------ | Branch (10718:7): [True: 0, False: 50.3k] ------------------ 10719| 0| { 10720| 0| errorcode = ERR31; 10721| 0| goto HAD_CB_ERROR; 10722| 0| } 10723| | 10724| | /* If study() set a bitmap of starting code units, it implies a minimum 10725| | length of at least one. */ 10726| | 10727| 50.3k| if ((re->flags & PCRE2_FIRSTMAPSET) != 0 && minminlength == 0) ------------------ | | 513| 50.3k|#define PCRE2_FIRSTMAPSET 0x00000040 /* bitmap of first code units is set */ ------------------ | Branch (10727:7): [True: 9.44k, False: 40.9k] | Branch (10727:47): [True: 3.62k, False: 5.81k] ------------------ 10728| 3.62k| minminlength = 1; 10729| | 10730| | /* If the minimum length set (or not set) by study() is less than the minimum 10731| | implied by required code units, override it. */ 10732| | 10733| 50.3k| if (re->minlength < minminlength) re->minlength = minminlength; ------------------ | Branch (10733:7): [True: 413, False: 49.9k] ------------------ 10734| 50.3k| } /* End of start-of-match optimizations. */ 10735| | 10736| |/* Control ends up here in all cases. When running under valgrind, make a 10737| |pattern's terminating zero defined again. If memory was obtained for the parsed 10738| |version of the pattern, free it before returning. Also free the list of named 10739| |groups if a larger one had to be obtained, and likewise the group information 10740| |vector. */ 10741| | 10742| 76.0k|EXIT: 10743| |#ifdef SUPPORT_VALGRIND 10744| |if (zero_terminated) VALGRIND_MAKE_MEM_DEFINED(pattern + patlen, CU2BYTES(1)); 10745| |#endif 10746| 76.0k|if (cb.parsed_pattern != stack_parsed_pattern) ------------------ | Branch (10746:5): [True: 673, False: 75.3k] ------------------ 10747| 673| ccontext->memctl.free(cb.parsed_pattern, ccontext->memctl.memory_data); 10748| 76.0k|if (cb.named_group_list_size > NAMED_GROUP_LIST_SIZE) ------------------ | | 187| 76.0k|#define NAMED_GROUP_LIST_SIZE 20 ------------------ | Branch (10748:5): [True: 69, False: 75.9k] ------------------ 10749| 69| ccontext->memctl.free((void *)cb.named_groups, ccontext->memctl.memory_data); 10750| 76.0k|if (cb.groupinfo != stack_groupinfo) ------------------ | Branch (10750:5): [True: 138, False: 75.9k] ------------------ 10751| 138| ccontext->memctl.free((void *)cb.groupinfo, ccontext->memctl.memory_data); 10752| 76.0k|return re; /* Will be NULL after an error */ 10753| | 10754| |/* Errors discovered in parse_regex() set the offset value in the compile 10755| |block. Errors discovered before it is called must compute it from the ptr 10756| |value. After parse_regex() is called, the offset in the compile block is set to 10757| |the end of the pattern, but certain errors in compile_regex() may reset it if 10758| |an offset is available in the parsed pattern. */ 10759| | 10760| 8.45k|HAD_CB_ERROR: 10761| 8.45k|ptr = pattern + cb.erroroffset; 10762| | 10763| 8.45k|HAD_EARLY_ERROR: 10764| 8.45k|*erroroffset = ptr - pattern; 10765| | 10766| 10.8k|HAD_ERROR: 10767| 10.8k|*errorptr = errorcode; 10768| 10.8k|pcre2_code_free(re); ------------------ | | 846| 10.8k|#define pcre2_code_free PCRE2_SUFFIX(pcre2_code_free_) | | ------------------ | | | | 986| 10.8k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 10.8k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 10.8k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 10769| 10.8k|re = NULL; 10770| 10.8k|goto EXIT; 10771| 8.45k|} pcre2_compile.c:read_repeat_counts: 1412| 108k|{ 1413| 108k|PCRE2_SPTR p; ------------------ | | 814| 108k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 108k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 108k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 108k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1414| 108k|BOOL yield = FALSE; ------------------ | | 69| 108k|#define FALSE 0 ------------------ 1415| 108k|BOOL had_comma = FALSE; ------------------ | | 69| 108k|#define FALSE 0 ------------------ 1416| 108k|int32_t min = 0; 1417| 108k|int32_t max = REPEAT_UNLIMITED; /* This value is larger than MAX_REPEAT_COUNT */ ------------------ | | 149| 108k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 108k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ 1418| | 1419| |/* Check the syntax */ 1420| | 1421| 108k|*errorcodeptr = 0; 1422| 206k|for (p = *ptrptr;; p++) 1423| 314k| { 1424| 314k| uint32_t c; 1425| 314k| if (p >= ptrend) return FALSE; ------------------ | | 69| 665|#define FALSE 0 ------------------ | Branch (1425:7): [True: 665, False: 313k] ------------------ 1426| 313k| c = *p; 1427| 313k| if (IS_DIGIT(c)) continue; ------------------ | | 408| 313k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 627k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 253k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 253k, False: 59.8k] | | | Branch (408:39): [True: 159k, False: 94.1k] | | ------------------ ------------------ 1428| 153k| if (c == CHAR_RIGHT_CURLY_BRACKET) break; ------------------ | | 1075| 153k|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1428:7): [True: 85.2k, False: 68.7k] ------------------ 1429| 68.7k| if (c == CHAR_COMMA) ------------------ | | 994| 68.7k|#define CHAR_COMMA '\054' ------------------ | Branch (1429:7): [True: 46.5k, False: 22.1k] ------------------ 1430| 46.5k| { 1431| 46.5k| if (had_comma) return FALSE; ------------------ | | 69| 268|#define FALSE 0 ------------------ | Branch (1431:9): [True: 268, False: 46.3k] ------------------ 1432| 46.3k| had_comma = TRUE; ------------------ | | 70| 46.3k|#define TRUE 1 ------------------ 1433| 46.3k| } 1434| 22.1k| else return FALSE; ------------------ | | 69| 22.1k|#define FALSE 0 ------------------ 1435| 68.7k| } 1436| | 1437| |/* The only error from read_number() is for a number that is too big. */ 1438| | 1439| 85.2k|p = *ptrptr; 1440| 85.2k|if (!read_number(&p, ptrend, -1, MAX_REPEAT_COUNT, ERR5, &min, errorcodeptr)) ------------------ | | 148| 85.2k|#define MAX_REPEAT_COUNT 65535u ------------------ | Branch (1440:5): [True: 607, False: 84.6k] ------------------ 1441| 607| goto EXIT; 1442| | 1443| 84.6k|if (*p == CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 84.6k|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1443:5): [True: 41.4k, False: 43.2k] ------------------ 1444| 41.4k| { 1445| 41.4k| p++; 1446| 41.4k| max = min; 1447| 41.4k| } 1448| 43.2k|else 1449| 43.2k| { 1450| 43.2k| if (*(++p) != CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 43.2k|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (1450:7): [True: 40.5k, False: 2.63k] ------------------ 1451| 40.5k| { 1452| 40.5k| if (!read_number(&p, ptrend, -1, MAX_REPEAT_COUNT, ERR5, &max, ------------------ | | 148| 40.5k|#define MAX_REPEAT_COUNT 65535u ------------------ | Branch (1452:9): [True: 10, False: 40.5k] ------------------ 1453| 40.5k| errorcodeptr)) 1454| 10| goto EXIT; 1455| 40.5k| if (max < min) ------------------ | Branch (1455:9): [True: 35, False: 40.5k] ------------------ 1456| 35| { 1457| 35| *errorcodeptr = ERR4; 1458| 35| goto EXIT; 1459| 35| } 1460| 40.5k| } 1461| 43.1k| p++; 1462| 43.1k| } 1463| | 1464| 84.6k|yield = TRUE; ------------------ | | 70| 84.6k|#define TRUE 1 ------------------ 1465| 84.6k|if (minp != NULL) *minp = (uint32_t)min; ------------------ | Branch (1465:5): [True: 42.1k, False: 42.5k] ------------------ 1466| 84.6k|if (maxp != NULL) *maxp = (uint32_t)max; ------------------ | Branch (1466:5): [True: 42.1k, False: 42.5k] ------------------ 1467| | 1468| |/* Update the pattern pointer */ 1469| | 1470| 85.2k|EXIT: 1471| 85.2k|*ptrptr = p; 1472| 85.2k|return yield; 1473| 84.6k|} pcre2_compile.c:read_number: 1326| 172k|{ 1327| 172k|int sign = 0; 1328| 172k|uint32_t n = 0; 1329| 172k|PCRE2_SPTR ptr = *ptrptr; ------------------ | | 814| 172k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 172k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 172k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 172k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1330| 172k|BOOL yield = FALSE; ------------------ | | 69| 172k|#define FALSE 0 ------------------ 1331| | 1332| 172k|*errorcodeptr = 0; 1333| | 1334| 172k|if (allow_sign >= 0 && ptr < ptrend) ------------------ | Branch (1334:5): [True: 25.5k, False: 147k] | Branch (1334:24): [True: 25.5k, False: 29] ------------------ 1335| 25.5k| { 1336| 25.5k| if (*ptr == CHAR_PLUS) ------------------ | | 993| 25.5k|#define CHAR_PLUS '\053' ------------------ | Branch (1336:7): [True: 14.0k, False: 11.4k] ------------------ 1337| 14.0k| { 1338| 14.0k| sign = +1; 1339| 14.0k| max_value -= allow_sign; 1340| 14.0k| ptr++; 1341| 14.0k| } 1342| 11.4k| else if (*ptr == CHAR_MINUS) ------------------ | | 995| 11.4k|#define CHAR_MINUS '\055' ------------------ | Branch (1342:12): [True: 555, False: 10.9k] ------------------ 1343| 555| { 1344| 555| sign = -1; 1345| 555| ptr++; 1346| 555| } 1347| 25.5k| } 1348| | 1349| 172k|if (ptr >= ptrend || !IS_DIGIT(*ptr)) return FALSE; ------------------ | | 408| 172k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 345k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 172k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 172k, False: 470] | | | Branch (408:39): [True: 162k, False: 9.93k] | | ------------------ ------------------ if (ptr >= ptrend || !IS_DIGIT(*ptr)) return FALSE; ------------------ | | 69| 10.4k|#define FALSE 0 ------------------ | Branch (1349:5): [True: 40, False: 172k] ------------------ 1350| 360k|while (ptr < ptrend && IS_DIGIT(*ptr)) ------------------ | | 408| 358k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 716k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 287k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 287k, False: 71.0k] | | | Branch (408:39): [True: 198k, False: 88.9k] | | ------------------ ------------------ | Branch (1350:8): [True: 358k, False: 1.83k] ------------------ 1351| 198k| { 1352| 198k| n = n * 10 + *ptr++ - CHAR_0; ------------------ | | 998| 198k|#define CHAR_0 '\060' ------------------ 1353| 198k| if (n > max_value) ------------------ | Branch (1353:7): [True: 263, False: 197k] ------------------ 1354| 263| { 1355| 263| *errorcodeptr = max_error; 1356| 263| goto EXIT; 1357| 263| } 1358| 198k| } 1359| | 1360| 161k|if (allow_sign >= 0 && sign != 0) ------------------ | Branch (1360:5): [True: 15.6k, False: 146k] | Branch (1360:24): [True: 14.5k, False: 1.13k] ------------------ 1361| 14.5k| { 1362| 14.5k| if (n == 0) ------------------ | Branch (1362:7): [True: 7, False: 14.5k] ------------------ 1363| 7| { 1364| 7| *errorcodeptr = ERR26; /* +0 and -0 are not allowed */ 1365| 7| goto EXIT; 1366| 7| } 1367| | 1368| 14.5k| if (sign > 0) n += allow_sign; ------------------ | Branch (1368:7): [True: 14.0k, False: 547] ------------------ 1369| 547| else if ((int)n > allow_sign) ------------------ | Branch (1369:12): [True: 36, False: 511] ------------------ 1370| 36| { 1371| 36| *errorcodeptr = ERR15; /* Non-existent subpattern */ 1372| 36| goto EXIT; 1373| 36| } 1374| 511| else n = allow_sign + 1 - n; 1375| 14.5k| } 1376| | 1377| 161k|yield = TRUE; ------------------ | | 70| 161k|#define TRUE 1 ------------------ 1378| | 1379| 162k|EXIT: 1380| 162k|*intptr = n; 1381| 162k|*ptrptr = ptr; 1382| 162k|return yield; 1383| 161k|} pcre2_compile.c:parse_regex: 2692| 73.7k|{ 2693| 73.7k|uint32_t c; 2694| 73.7k|uint32_t delimiter; 2695| 73.7k|uint32_t namelen; 2696| 73.7k|uint32_t class_range_state; 2697| 73.7k|uint32_t *verblengthptr = NULL; /* Value avoids compiler warning */ 2698| 73.7k|uint32_t *verbstartptr = NULL; 2699| 73.7k|uint32_t *previous_callout = NULL; 2700| 73.7k|uint32_t *parsed_pattern = cb->parsed_pattern; 2701| 73.7k|uint32_t *parsed_pattern_end = cb->parsed_pattern_end; 2702| 73.7k|uint32_t meta_quantifier = 0; 2703| 73.7k|uint32_t add_after_mark = 0; 2704| 73.7k|uint32_t xoptions = cb->cx->extra_options; 2705| 73.7k|uint16_t nest_depth = 0; 2706| 73.7k|int after_manual_callout = 0; 2707| 73.7k|int expect_cond_assert = 0; 2708| 73.7k|int errorcode = 0; 2709| 73.7k|int escape; 2710| 73.7k|int i; 2711| 73.7k|BOOL inescq = FALSE; ------------------ | | 69| 73.7k|#define FALSE 0 ------------------ 2712| 73.7k|BOOL inverbname = FALSE; ------------------ | | 69| 73.7k|#define FALSE 0 ------------------ 2713| 73.7k|BOOL utf = (options & PCRE2_UTF) != 0; ------------------ | | 138| 73.7k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 2714| 73.7k|BOOL auto_callout = (options & PCRE2_AUTO_CALLOUT) != 0; ------------------ | | 121| 73.7k|#define PCRE2_AUTO_CALLOUT 0x00000004u /* C */ ------------------ 2715| 73.7k|BOOL isdupname; 2716| 73.7k|BOOL negate_class; 2717| 73.7k|BOOL okquantifier = FALSE; ------------------ | | 69| 73.7k|#define FALSE 0 ------------------ 2718| 73.7k|PCRE2_SPTR thisptr; ------------------ | | 814| 73.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 73.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 73.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 73.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2719| 73.7k|PCRE2_SPTR name; ------------------ | | 814| 73.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 73.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 73.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 73.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2720| 73.7k|PCRE2_SPTR ptrend = cb->end_pattern; ------------------ | | 814| 73.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 73.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 73.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 73.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2721| 73.7k|PCRE2_SPTR verbnamestart = NULL; /* Value avoids compiler warning */ ------------------ | | 814| 73.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 73.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 73.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 73.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2722| 73.7k|named_group *ng; ------------------ | | 1983| 73.7k|#define named_group PCRE2_SUFFIX(named_group_) | | ------------------ | | | | 986| 73.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 73.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 73.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2723| 73.7k|nest_save *top_nest, *end_nests; 2724| | 2725| |/* Insert leading items for word and line matching (features provided for the 2726| |benefit of pcre2grep). */ 2727| | 2728| 73.7k|if ((xoptions & PCRE2_EXTRA_MATCH_LINE) != 0) ------------------ | | 152| 73.7k|#define PCRE2_EXTRA_MATCH_LINE 0x00000008u /* C */ ------------------ | Branch (2728:5): [True: 0, False: 73.7k] ------------------ 2729| 0| { 2730| 0| *parsed_pattern++ = META_CIRCUMFLEX; ------------------ | | 221| 0|#define META_CIRCUMFLEX 0x80090000u /* ^ metacharacter */ ------------------ 2731| 0| *parsed_pattern++ = META_NOCAPTURE; ------------------ | | 238| 0|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ 2732| 0| } 2733| 73.7k|else if ((xoptions & PCRE2_EXTRA_MATCH_WORD) != 0) ------------------ | | 151| 73.7k|#define PCRE2_EXTRA_MATCH_WORD 0x00000004u /* C */ ------------------ | Branch (2733:10): [True: 0, False: 73.7k] ------------------ 2734| 0| { 2735| 0| *parsed_pattern++ = META_ESCAPE + ESC_b; ------------------ | | 236| 0|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 2736| 0| *parsed_pattern++ = META_NOCAPTURE; ------------------ | | 238| 0|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ 2737| 0| } 2738| | 2739| |/* If the pattern is actually a literal string, process it separately to avoid 2740| |cluttering up the main loop. */ 2741| | 2742| 73.7k|if ((options & PCRE2_LITERAL) != 0) ------------------ | | 144| 73.7k|#define PCRE2_LITERAL 0x02000000u /* C */ ------------------ | Branch (2742:5): [True: 0, False: 73.7k] ------------------ 2743| 0| { 2744| 0| while (ptr < ptrend) ------------------ | Branch (2744:10): [True: 0, False: 0] ------------------ 2745| 0| { 2746| 0| if (parsed_pattern >= parsed_pattern_end) ------------------ | Branch (2746:9): [True: 0, False: 0] ------------------ 2747| 0| { 2748| 0| errorcode = ERR63; /* Internal error (parsed pattern overflow) */ 2749| 0| goto FAILED; 2750| 0| } 2751| 0| thisptr = ptr; 2752| 0| GETCHARINCTEST(c, ptr); ------------------ | | 323| 0| c = *eptr++; \ | | 324| 0| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 0| { \ | | | | 289| 0| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 0, False: 0] | | | | ------------------ | | | | 290| 0| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 0| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 0, False: 0] | | | | ------------------ | | | | 292| 0| { \ | | | | 293| 0| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 0| eptr += 2; \ | | | | 295| 0| } \ | | | | 296| 0| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 0, False: 0] | | | | ------------------ | | | | 297| 0| { \ | | | | 298| 0| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 0| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 0| eptr += 3; \ | | | | 301| 0| } \ | | | | 302| 0| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 0| } | | ------------------ | | | Branch (324:7): [True: 0, False: 0] | | | Branch (324:14): [True: 0, False: 0] | | ------------------ ------------------ 2753| 0| if (auto_callout) ------------------ | Branch (2753:9): [True: 0, False: 0] ------------------ 2754| 0| parsed_pattern = manage_callouts(thisptr, &previous_callout, 2755| 0| auto_callout, parsed_pattern, cb); 2756| 0| PARSED_LITERAL(c, parsed_pattern); ------------------ | | 2685| 0|#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE; | | ------------------ | | | | 70| 0|#define TRUE 1 | | ------------------ ------------------ 2757| 0| } 2758| 0| goto PARSED_END; 2759| 0| } 2760| | 2761| |/* Process a real regex which may contain meta-characters. */ 2762| | 2763| 73.7k|top_nest = NULL; 2764| 73.7k|end_nests = (nest_save *)(cb->start_workspace + cb->workspace_size); 2765| | 2766| |/* The size of the nest_save structure might not be a factor of the size of the 2767| |workspace. Therefore we must round down end_nests so as to correctly avoid 2768| |creating a nest_save that spans the end of the workspace. */ 2769| | 2770| 73.7k|end_nests = (nest_save *)((char *)end_nests - 2771| 73.7k| ((cb->workspace_size * sizeof(PCRE2_UCHAR)) % sizeof(nest_save))); 2772| | 2773| |/* PCRE2_EXTENDED_MORE implies PCRE2_EXTENDED */ 2774| | 2775| 73.7k|if ((options & PCRE2_EXTENDED_MORE) != 0) options |= PCRE2_EXTENDED; ------------------ | | 143| 73.7k|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ ------------------ if ((options & PCRE2_EXTENDED_MORE) != 0) options |= PCRE2_EXTENDED; ------------------ | | 126| 0|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ | Branch (2775:5): [True: 0, False: 73.7k] ------------------ 2776| | 2777| |/* Now scan the pattern */ 2778| | 2779| 20.1M|while (ptr < ptrend) ------------------ | Branch (2779:8): [True: 20.1M, False: 68.9k] ------------------ 2780| 20.1M| { 2781| 20.1M| int prev_expect_cond_assert; 2782| 20.1M| uint32_t min_repeat = 0, max_repeat = 0; 2783| 20.1M| uint32_t set, unset, *optset; 2784| 20.1M| uint32_t xset, xunset, *xoptset; 2785| 20.1M| uint32_t terminator; 2786| 20.1M| uint32_t prev_meta_quantifier; 2787| 20.1M| BOOL prev_okquantifier; 2788| 20.1M| PCRE2_SPTR tempptr; ------------------ | | 814| 20.1M|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 20.1M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 20.1M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 20.1M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2789| 20.1M| PCRE2_SIZE offset; ------------------ | | 477| 20.1M|#define PCRE2_SIZE size_t ------------------ 2790| | 2791| 20.1M| if (parsed_pattern >= parsed_pattern_end) ------------------ | Branch (2791:7): [True: 0, False: 20.1M] ------------------ 2792| 0| { 2793| 0| errorcode = ERR63; /* Internal error (parsed pattern overflow) */ 2794| 0| goto FAILED; 2795| 0| } 2796| | 2797| 20.1M| if (nest_depth > cb->cx->parens_nest_limit) ------------------ | Branch (2797:7): [True: 4, False: 20.1M] ------------------ 2798| 4| { 2799| 4| errorcode = ERR19; 2800| 4| goto FAILED; /* Parentheses too deeply nested */ 2801| 4| } 2802| | 2803| | /* Get next input character, save its position for callout handling. */ 2804| | 2805| 20.1M| thisptr = ptr; 2806| 20.1M| GETCHARINCTEST(c, ptr); ------------------ | | 323| 20.1M| c = *eptr++; \ | | 324| 20.1M| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 11.2k| { \ | | | | 289| 11.2k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 3.76k, False: 7.45k] | | | | ------------------ | | | | 290| 11.2k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 11.2k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 5.54k, False: 1.91k] | | | | ------------------ | | | | 292| 7.45k| { \ | | | | 293| 5.54k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 5.54k| eptr += 2; \ | | | | 295| 5.54k| } \ | | | | 296| 7.45k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 1.91k, False: 0] | | | | ------------------ | | | | 297| 1.91k| { \ | | | | 298| 1.91k| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 1.91k| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 1.91k| eptr += 3; \ | | | | 301| 1.91k| } \ | | | | 302| 1.91k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 11.2k| } | | ------------------ | | | Branch (324:7): [True: 228k, False: 19.8M] | | | Branch (324:14): [True: 11.2k, False: 217k] | | ------------------ ------------------ 2807| | 2808| | /* Copy quoted literals until \E, allowing for the possibility of automatic 2809| | callouts, except when processing a (*VERB) "name". */ 2810| | 2811| 20.1M| if (inescq) ------------------ | Branch (2811:7): [True: 5.26M, False: 14.8M] ------------------ 2812| 5.26M| { 2813| 5.26M| if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E) ------------------ | | 1042| 10.5M|#define CHAR_BACKSLASH '\134' ------------------ if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E) ------------------ | | 1019| 277k|#define CHAR_E '\105' ------------------ | Branch (2813:9): [True: 277k, False: 4.98M] | Branch (2813:32): [True: 277k, False: 9] | Branch (2813:48): [True: 207k, False: 70.3k] ------------------ 2814| 207k| { 2815| 207k| inescq = FALSE; ------------------ | | 69| 207k|#define FALSE 0 ------------------ 2816| 207k| ptr++; /* Skip E */ 2817| 207k| } 2818| 5.05M| else 2819| 5.05M| { 2820| 5.05M| if (expect_cond_assert > 0) /* A literal is not allowed if we are */ ------------------ | Branch (2820:11): [True: 3, False: 5.05M] ------------------ 2821| 3| { /* expecting a conditional assertion, */ 2822| 3| ptr--; /* but an empty \Q\E sequence is OK. */ 2823| 3| errorcode = ERR28; 2824| 3| goto FAILED; 2825| 3| } 2826| 5.05M| if (inverbname) ------------------ | Branch (2826:11): [True: 331, False: 5.05M] ------------------ 2827| 331| { /* Don't use PARSED_LITERAL() because it */ 2828| |#if PCRE2_CODE_UNIT_WIDTH == 32 /* sets okquantifier. */ 2829| | if (c >= META_END) *parsed_pattern++ = META_BIGVALUE; 2830| |#endif 2831| 331| *parsed_pattern++ = c; 2832| 331| } 2833| 5.05M| else 2834| 5.05M| { 2835| 5.05M| if (after_manual_callout-- <= 0) ------------------ | Branch (2835:13): [True: 4.84M, False: 206k] ------------------ 2836| 4.84M| parsed_pattern = manage_callouts(thisptr, &previous_callout, 2837| 4.84M| auto_callout, parsed_pattern, cb); 2838| 5.05M| PARSED_LITERAL(c, parsed_pattern); ------------------ | | 2685| 5.05M|#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE; | | ------------------ | | | | 70| 5.05M|#define TRUE 1 | | ------------------ ------------------ 2839| 5.05M| } 2840| 5.05M| meta_quantifier = 0; 2841| 5.05M| } 2842| 5.26M| continue; /* Next character */ 2843| 5.26M| } 2844| | 2845| | /* If we are processing the "name" part of a (*VERB:NAME) item, all 2846| | characters up to the closing parenthesis are literals except when 2847| | PCRE2_ALT_VERBNAMES is set. That causes backslash interpretation, but only \Q 2848| | and \E and escaped characters are allowed (no character types such as \d). If 2849| | PCRE2_EXTENDED is also set, we must ignore white space and # comments. Do 2850| | this by not entering the special (*VERB:NAME) processing - they are then 2851| | picked up below. Note that c is a character, not a code unit, so we must not 2852| | use MAX_255 to test its size because MAX_255 tests code units and is assumed 2853| | TRUE in 8-bit mode. */ 2854| | 2855| 14.8M| if (inverbname && ------------------ | Branch (2855:7): [True: 29.5k, False: 14.8M] ------------------ 2856| 14.8M| ( 2857| | /* EITHER: not both options set */ 2858| 29.5k| ((options & (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) != ------------------ | | 126| 29.5k|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ ((options & (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) != ------------------ | | 141| 29.5k|#define PCRE2_ALT_VERBNAMES 0x00400000u /* C */ ------------------ | Branch (2858:9): [True: 24.1k, False: 5.34k] ------------------ 2859| 29.5k| (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) || ------------------ | | 126| 29.5k|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) || ------------------ | | 141| 29.5k|#define PCRE2_ALT_VERBNAMES 0x00400000u /* C */ ------------------ 2860| 29.5k|#ifdef SUPPORT_UNICODE 2861| | /* OR: character > 255 AND not Unicode Pattern White Space */ 2862| 29.5k| (c > 255 && (c|1) != 0x200f && (c|1) != 0x2029) || ------------------ | Branch (2862:10): [True: 494, False: 4.84k] | Branch (2862:21): [True: 428, False: 66] | Branch (2862:40): [True: 229, False: 199] ------------------ 2863| 29.5k|#endif 2864| | /* OR: not a # comment or isspace() white space */ 2865| 29.5k| (c < 256 && c != CHAR_NUMBER_SIGN && (cb->ctypes[c] & ctype_space) == 0 ------------------ | | 985| 9.96k|#define CHAR_NUMBER_SIGN '\043' ------------------ (c < 256 && c != CHAR_NUMBER_SIGN && (cb->ctypes[c] & ctype_space) == 0 ------------------ | | 579| 4.65k|#define ctype_space 0x01 ------------------ | Branch (2865:10): [True: 4.84k, False: 265] | Branch (2865:21): [True: 4.65k, False: 199] | Branch (2865:46): [True: 4.25k, False: 400] ------------------ 2866| 5.11k|#ifdef SUPPORT_UNICODE 2867| | /* and not CHAR_NEL when Unicode is supported */ 2868| 5.11k| && c != CHAR_NEL ------------------ | | 975| 4.25k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (2868:14): [True: 4.05k, False: 194] ------------------ 2869| 5.11k|#endif 2870| 5.11k| ))) 2871| 28.4k| { 2872| 28.4k| PCRE2_SIZE verbnamelength; ------------------ | | 477| 28.4k|#define PCRE2_SIZE size_t ------------------ 2873| | 2874| 28.4k| switch(c) 2875| 28.4k| { 2876| 21.5k| default: /* Don't use PARSED_LITERAL() because it */ ------------------ | Branch (2876:7): [True: 21.5k, False: 6.91k] ------------------ 2877| |#if PCRE2_CODE_UNIT_WIDTH == 32 /* sets okquantifier. */ 2878| | if (c >= META_END) *parsed_pattern++ = META_BIGVALUE; 2879| |#endif 2880| 21.5k| *parsed_pattern++ = c; 2881| 21.5k| break; 2882| | 2883| 4.96k| case CHAR_RIGHT_PARENTHESIS: ------------------ | | 991| 4.96k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (2883:7): [True: 4.96k, False: 23.4k] ------------------ 2884| 4.96k| inverbname = FALSE; ------------------ | | 69| 4.96k|#define FALSE 0 ------------------ 2885| | /* This is the length in characters */ 2886| 4.96k| verbnamelength = (PCRE2_SIZE)(parsed_pattern - verblengthptr - 1); 2887| | /* But the limit on the length is in code units */ 2888| 4.96k| if (ptr - verbnamestart - 1 > (int)MAX_MARK) ------------------ | | 213| 4.96k|#define MAX_MARK ((1u << 8) - 1) ------------------ | Branch (2888:11): [True: 5, False: 4.95k] ------------------ 2889| 5| { 2890| 5| ptr--; 2891| 5| errorcode = ERR76; 2892| 5| goto FAILED; 2893| 5| } 2894| 4.95k| *verblengthptr = (uint32_t)verbnamelength; 2895| | 2896| | /* If this name was on a verb such as (*ACCEPT) which does not continue, 2897| | a (*MARK) was generated for the name. We now add the original verb as the 2898| | next item. */ 2899| | 2900| 4.95k| if (add_after_mark != 0) ------------------ | Branch (2900:11): [True: 233, False: 4.72k] ------------------ 2901| 233| { 2902| 233| *parsed_pattern++ = add_after_mark; 2903| 233| add_after_mark = 0; 2904| 233| } 2905| 4.95k| break; 2906| | 2907| 1.94k| case CHAR_BACKSLASH: ------------------ | | 1042| 1.94k|#define CHAR_BACKSLASH '\134' ------------------ | Branch (2907:7): [True: 1.94k, False: 26.4k] ------------------ 2908| 1.94k| if ((options & PCRE2_ALT_VERBNAMES) != 0) ------------------ | | 141| 1.94k|#define PCRE2_ALT_VERBNAMES 0x00400000u /* C */ ------------------ | Branch (2908:11): [True: 627, False: 1.32k] ------------------ 2909| 627| { 2910| 627| escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options, ------------------ | | 177| 627|#define PRIV(name) _pcre2_##name ------------------ 2911| 627| xoptions, FALSE, cb); ------------------ | | 69| 627|#define FALSE 0 ------------------ 2912| 627| if (errorcode != 0) goto FAILED; ------------------ | Branch (2912:13): [True: 6, False: 621] ------------------ 2913| 627| } 2914| 1.32k| else escape = 0; /* Treat all as literal */ 2915| | 2916| 1.94k| switch(escape) 2917| 1.94k| { 2918| 1.53k| case 0: /* Don't use PARSED_LITERAL() because it */ ------------------ | Branch (2918:9): [True: 1.53k, False: 412] ------------------ 2919| |#if PCRE2_CODE_UNIT_WIDTH == 32 /* sets okquantifier. */ 2920| | if (c >= META_END) *parsed_pattern++ = META_BIGVALUE; 2921| |#endif 2922| 1.53k| *parsed_pattern++ = c; 2923| 1.53k| break; 2924| | 2925| 202| case ESC_Q: ------------------ | Branch (2925:9): [True: 202, False: 1.74k] ------------------ 2926| 202| inescq = TRUE; ------------------ | | 70| 202|#define TRUE 1 ------------------ 2927| 202| break; 2928| | 2929| 203| case ESC_E: /* Ignore */ ------------------ | Branch (2929:9): [True: 203, False: 1.74k] ------------------ 2930| 203| break; 2931| | 2932| 7| default: ------------------ | Branch (2932:9): [True: 7, False: 1.93k] ------------------ 2933| 7| errorcode = ERR40; /* Invalid in verb name */ 2934| 7| goto FAILED; 2935| 1.94k| } 2936| 28.4k| } 2937| 28.4k| continue; /* Next character in pattern */ 2938| 28.4k| } 2939| | 2940| | /* Not a verb name character. At this point we must process everything that 2941| | must not change the quantification state. This is mainly comments, but we 2942| | handle \Q and \E here as well, so that an item such as A\Q\E+ is treated as 2943| | A+, as in Perl. An isolated \E is ignored. */ 2944| | 2945| 14.8M| if (c == CHAR_BACKSLASH && ptr < ptrend) ------------------ | | 1042| 29.6M|#define CHAR_BACKSLASH '\134' ------------------ | Branch (2945:7): [True: 335k, False: 14.4M] | Branch (2945:30): [True: 335k, False: 68] ------------------ 2946| 335k| { 2947| 335k| if (*ptr == CHAR_Q || *ptr == CHAR_E) ------------------ | | 1031| 670k|#define CHAR_Q '\121' ------------------ if (*ptr == CHAR_Q || *ptr == CHAR_E) ------------------ | | 1019| 127k|#define CHAR_E '\105' ------------------ | Branch (2947:9): [True: 207k, False: 127k] | Branch (2947:27): [True: 4.77k, False: 122k] ------------------ 2948| 212k| { 2949| 212k| inescq = *ptr == CHAR_Q; ------------------ | | 1031| 212k|#define CHAR_Q '\121' ------------------ 2950| 212k| ptr++; 2951| 212k| continue; 2952| 212k| } 2953| 335k| } 2954| | 2955| | /* Skip over whitespace and # comments in extended mode. Note that c is a 2956| | character, not a code unit, so we must not use MAX_255 to test its size 2957| | because MAX_255 tests code units and is assumed TRUE in 8-bit mode. The 2958| | whitespace characters are those designated as "Pattern White Space" by 2959| | Unicode, which are the isspace() characters plus CHAR_NEL (newline), which is 2960| | U+0085 in Unicode, plus U+200E, U+200F, U+2028, and U+2029. These are a 2961| | subset of space characters that match \h and \v. */ 2962| | 2963| 14.6M| if ((options & PCRE2_EXTENDED) != 0) ------------------ | | 126| 14.6M|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ | Branch (2963:7): [True: 1.98M, False: 12.6M] ------------------ 2964| 1.98M| { 2965| 1.98M| if (c < 256 && (cb->ctypes[c] & ctype_space) != 0) continue; ------------------ | | 579| 1.97M|#define ctype_space 0x01 ------------------ | Branch (2965:9): [True: 1.97M, False: 4.62k] | Branch (2965:20): [True: 6.89k, False: 1.97M] ------------------ 2966| 1.97M|#ifdef SUPPORT_UNICODE 2967| 1.97M| if (c == CHAR_NEL || (c|1) == 0x200f || (c|1) == 0x2029) continue; ------------------ | | 975| 3.95M|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (2967:9): [True: 629, False: 1.97M] | Branch (2967:26): [True: 261, False: 1.97M] | Branch (2967:45): [True: 438, False: 1.97M] ------------------ 2968| 1.97M|#endif 2969| 1.97M| if (c == CHAR_NUMBER_SIGN) ------------------ | | 985| 1.97M|#define CHAR_NUMBER_SIGN '\043' ------------------ | Branch (2969:9): [True: 1.87k, False: 1.97M] ------------------ 2970| 1.87k| { 2971| 857k| while (ptr < ptrend) ------------------ | Branch (2971:14): [True: 857k, False: 703] ------------------ 2972| 857k| { 2973| 857k| if (IS_NEWLINE(ptr)) /* For non-fixed-length newline cases, */ ------------------ | | 479| 857k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 46| 857k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 857k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 1.16k, False: 856k] | | | Branch (479:4): [True: 109k, False: 747k] | | ------------------ | | 480| 857k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 46| 109k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 48| 218k|#define PSEND end_pattern /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 109k, False: 0] | | ------------------ | | 481| 109k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 109k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 46| 109k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 46| 109k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 48| 109k|#define PSEND end_pattern /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 372, False: 109k] | | ------------------ | | 482| 109k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 46| 109k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | 483| 857k| : \ | | 484| 857k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 46| 747k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 48| 747k|#define PSEND end_pattern /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 46| 747k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 747k, False: 20] | | ------------------ | | 485| 747k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 747k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 46| 747k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.18k, False: 746k] | | ------------------ | | 486| 747k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 46| 1.18k|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 597|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 46| 597|#define NLBLOCK cb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 583, False: 597] | | | Branch (486:30): [True: 213, False: 384] | | ------------------ | | 487| 747k| ) \ | | 488| 857k| ) ------------------ 2974| 1.16k| { /* IS_NEWLINE sets cb->nllen. */ 2975| 1.16k| ptr += cb->nllen; 2976| 1.16k| break; 2977| 1.16k| } 2978| 856k| ptr++; 2979| 856k|#ifdef SUPPORT_UNICODE 2980| 856k| if (utf) FORWARDCHARTEST(ptr, ptrend); ------------------ | | 349| 2.82k|#define FORWARDCHARTEST(eptr,end) while(eptr < end && (*eptr & 0xc0u) == 0x80u) eptr++ | | ------------------ | | | Branch (349:41): [True: 2.37k, False: 458] | | | Branch (349:55): [True: 482, False: 1.88k] | | ------------------ ------------------ | Branch (2980:13): [True: 2.34k, False: 853k] ------------------ 2981| 856k|#endif 2982| 856k| } 2983| 1.87k| continue; /* Next character in pattern */ 2984| 1.87k| } 2985| 1.97M| } 2986| | 2987| | /* Skip over bracketed comments */ 2988| | 2989| 14.5M| if (c == CHAR_LEFT_PARENTHESIS && ptrend - ptr >= 2 && ------------------ | | 990| 29.1M|#define CHAR_LEFT_PARENTHESIS '\050' ------------------ | Branch (2989:7): [True: 2.55M, False: 12.0M] | Branch (2989:37): [True: 2.55M, False: 552] ------------------ 2990| 14.5M| ptr[0] == CHAR_QUESTION_MARK && ptr[1] == CHAR_NUMBER_SIGN) ------------------ | | 1013| 17.1M|#define CHAR_QUESTION_MARK '\077' ------------------ ptr[0] == CHAR_QUESTION_MARK && ptr[1] == CHAR_NUMBER_SIGN) ------------------ | | 985| 401k|#define CHAR_NUMBER_SIGN '\043' ------------------ | Branch (2990:7): [True: 401k, False: 2.15M] | Branch (2990:39): [True: 230, False: 401k] ------------------ 2991| 230| { 2992| 672| while (++ptr < ptrend && *ptr != CHAR_RIGHT_PARENTHESIS); ------------------ | | 991| 648|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (2992:12): [True: 648, False: 24] | Branch (2992:30): [True: 442, False: 206] ------------------ 2993| 230| if (ptr >= ptrend) ------------------ | Branch (2993:9): [True: 24, False: 206] ------------------ 2994| 24| { 2995| 24| errorcode = ERR18; /* A special error for missing ) in a comment */ 2996| 24| goto FAILED; /* to make it easier to debug. */ 2997| 24| } 2998| 206| ptr++; 2999| 206| continue; /* Next character in pattern */ 3000| 230| } 3001| | 3002| | /* If the next item is not a quantifier, fill in length of any previous 3003| | callout and create an auto callout if required. */ 3004| | 3005| 14.5M| if (c != CHAR_ASTERISK && c != CHAR_PLUS && c != CHAR_QUESTION_MARK && ------------------ | | 992| 29.1M|#define CHAR_ASTERISK '\052' ------------------ if (c != CHAR_ASTERISK && c != CHAR_PLUS && c != CHAR_QUESTION_MARK && ------------------ | | 993| 29.1M|#define CHAR_PLUS '\053' ------------------ if (c != CHAR_ASTERISK && c != CHAR_PLUS && c != CHAR_QUESTION_MARK && ------------------ | | 1013| 29.0M|#define CHAR_QUESTION_MARK '\077' ------------------ | Branch (3005:7): [True: 14.5M, False: 30.9k] | Branch (3005:29): [True: 14.4M, False: 63.8k] | Branch (3005:47): [True: 14.3M, False: 152k] ------------------ 3006| 14.5M| (c != CHAR_LEFT_CURLY_BRACKET || ------------------ | | 1073| 28.6M|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (3006:9): [True: 14.2M, False: 53.9k] ------------------ 3007| 14.3M| (tempptr = ptr, ------------------ | Branch (3007:10): [True: 11.8k, False: 42.1k] ------------------ 3008| 53.9k| !read_repeat_counts(&tempptr, ptrend, NULL, NULL, &errorcode)))) 3009| 14.3M| { 3010| 14.3M| if (after_manual_callout-- <= 0) ------------------ | Branch (3010:9): [True: 14.2M, False: 30.2k] ------------------ 3011| 14.2M| parsed_pattern = manage_callouts(thisptr, &previous_callout, auto_callout, 3012| 14.2M| parsed_pattern, cb); 3013| 14.3M| } 3014| | 3015| | /* If expect_cond_assert is 2, we have just passed (?( and are expecting an 3016| | assertion, possibly preceded by a callout. If the value is 1, we have just 3017| | had the callout and expect an assertion. There must be at least 3 more 3018| | characters in all cases. When expect_cond_assert is 2, we know that the 3019| | current character is an opening parenthesis, as otherwise we wouldn't be 3020| | here. However, when it is 1, we need to check, and it's easiest just to check 3021| | always. Note that expect_cond_assert may be negative, since all callouts just 3022| | decrement it. */ 3023| | 3024| 14.5M| if (expect_cond_assert > 0) ------------------ | Branch (3024:7): [True: 3.48k, False: 14.5M] ------------------ 3025| 3.48k| { 3026| 3.48k| BOOL ok = c == CHAR_LEFT_PARENTHESIS && ptrend - ptr >= 3 && ------------------ | | 990| 6.96k|#define CHAR_LEFT_PARENTHESIS '\050' ------------------ | Branch (3026:15): [True: 3.47k, False: 6] | Branch (3026:45): [True: 3.44k, False: 26] ------------------ 3027| 3.48k| (ptr[0] == CHAR_QUESTION_MARK || ptr[0] == CHAR_ASTERISK); ------------------ | | 1013| 6.89k|#define CHAR_QUESTION_MARK '\077' ------------------ (ptr[0] == CHAR_QUESTION_MARK || ptr[0] == CHAR_ASTERISK); ------------------ | | 992| 221|#define CHAR_ASTERISK '\052' ------------------ | Branch (3027:16): [True: 3.22k, False: 221] | Branch (3027:48): [True: 220, False: 1] ------------------ 3028| 3.48k| if (ok) ------------------ | Branch (3028:9): [True: 3.44k, False: 33] ------------------ 3029| 3.44k| { 3030| 3.44k| if (ptr[0] == CHAR_ASTERISK) /* New alpha assertion format, possibly */ ------------------ | | 992| 3.44k|#define CHAR_ASTERISK '\052' ------------------ | Branch (3030:11): [True: 220, False: 3.22k] ------------------ 3031| 220| { 3032| 220| ok = MAX_255(ptr[1]) && (cb->ctypes[ptr[1]] & ctype_lcletter) != 0; ------------------ | | 212| 220|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 440|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ ok = MAX_255(ptr[1]) && (cb->ctypes[ptr[1]] & ctype_lcletter) != 0; ------------------ | | 581| 220|#define ctype_lcletter 0x04 ------------------ | Branch (3032:33): [True: 215, False: 5] ------------------ 3033| 220| } 3034| 3.22k| else switch(ptr[1]) /* Traditional symbolic format */ 3035| 3.22k| { 3036| 349| case CHAR_C: ------------------ | | 1017| 349|#define CHAR_C '\103' ------------------ | Branch (3036:9): [True: 349, False: 2.87k] ------------------ 3037| 349| ok = expect_cond_assert == 2; 3038| 349| break; 3039| | 3040| 1.55k| case CHAR_EQUALS_SIGN: ------------------ | | 1011| 1.55k|#define CHAR_EQUALS_SIGN '\075' ------------------ | Branch (3040:9): [True: 1.55k, False: 1.67k] ------------------ 3041| 2.20k| case CHAR_EXCLAMATION_MARK: ------------------ | | 983| 2.20k|#define CHAR_EXCLAMATION_MARK '\041' ------------------ | Branch (3041:9): [True: 645, False: 2.58k] ------------------ 3042| 2.20k| break; 3043| | 3044| 671| case CHAR_LESS_THAN_SIGN: ------------------ | | 1010| 671|#define CHAR_LESS_THAN_SIGN '\074' ------------------ | Branch (3044:9): [True: 671, False: 2.55k] ------------------ 3045| 671| ok = ptr[2] == CHAR_EQUALS_SIGN || ptr[2] == CHAR_EXCLAMATION_MARK; ------------------ | | 1011| 1.34k|#define CHAR_EQUALS_SIGN '\075' ------------------ ok = ptr[2] == CHAR_EQUALS_SIGN || ptr[2] == CHAR_EXCLAMATION_MARK; ------------------ | | 983| 893|#define CHAR_EXCLAMATION_MARK '\041' ------------------ | Branch (3045:14): [True: 449, False: 222] | Branch (3045:44): [True: 212, False: 10] ------------------ 3046| 671| break; 3047| | 3048| 5| default: ------------------ | Branch (3048:9): [True: 5, False: 3.22k] ------------------ 3049| 5| ok = FALSE; ------------------ | | 69| 5|#define FALSE 0 ------------------ 3050| 3.22k| } 3051| 3.44k| } 3052| | 3053| 3.48k| if (!ok) ------------------ | Branch (3053:9): [True: 64, False: 3.41k] ------------------ 3054| 64| { 3055| 64| ptr--; /* Adjust error offset */ 3056| 64| errorcode = ERR28; 3057| 64| goto FAILED; 3058| 64| } 3059| 3.48k| } 3060| | 3061| | /* Remember whether we are expecting a conditional assertion, and set the 3062| | default for this item. */ 3063| | 3064| 14.5M| prev_expect_cond_assert = expect_cond_assert; 3065| 14.5M| expect_cond_assert = 0; 3066| | 3067| | /* Remember quantification status for the previous significant item, then set 3068| | default for this item. */ 3069| | 3070| 14.5M| prev_okquantifier = okquantifier; 3071| 14.5M| prev_meta_quantifier = meta_quantifier; 3072| 14.5M| okquantifier = FALSE; ------------------ | | 69| 14.5M|#define FALSE 0 ------------------ 3073| 14.5M| meta_quantifier = 0; 3074| | 3075| | /* If the previous significant item was a quantifier, adjust the parsed code 3076| | if there is a following modifier. The base meta value is always followed by 3077| | the PLUS and QUERY values, in that order. We do this here rather than after 3078| | reading a quantifier so that intervening comments and /x whitespace can be 3079| | ignored without having to replicate code. */ 3080| | 3081| 14.5M| if (prev_meta_quantifier != 0 && (c == CHAR_QUESTION_MARK || c == CHAR_PLUS)) ------------------ | | 1013| 508k|#define CHAR_QUESTION_MARK '\077' ------------------ if (prev_meta_quantifier != 0 && (c == CHAR_QUESTION_MARK || c == CHAR_PLUS)) ------------------ | | 993| 249k|#define CHAR_PLUS '\053' ------------------ | Branch (3081:7): [True: 254k, False: 14.3M] | Branch (3081:37): [True: 4.68k, False: 249k] | Branch (3081:64): [True: 13.4k, False: 236k] ------------------ 3082| 18.1k| { 3083| 18.1k| parsed_pattern[(prev_meta_quantifier == META_MINMAX)? -3 : -1] = ------------------ | | 288| 18.1k|#define META_MINMAX 0x803d0000u /* {n,m} repeat */ ------------------ | Branch (3083:20): [True: 8.23k, False: 9.88k] ------------------ 3084| 18.1k| prev_meta_quantifier + ((c == CHAR_QUESTION_MARK)? ------------------ | | 1013| 18.1k|#define CHAR_QUESTION_MARK '\077' ------------------ | Branch (3084:31): [True: 4.68k, False: 13.4k] ------------------ 3085| 13.4k| 0x00020000u : 0x00010000u); 3086| 18.1k| continue; /* Next character in pattern */ 3087| 18.1k| } 3088| | 3089| | 3090| | /* Process the next item in the main part of a pattern. */ 3091| | 3092| 14.5M| switch(c) 3093| 14.5M| { 3094| 8.97M| default: /* Non-special character */ ------------------ | Branch (3094:5): [True: 8.97M, False: 5.59M] ------------------ 3095| 8.97M| PARSED_LITERAL(c, parsed_pattern); ------------------ | | 2685| 8.97M|#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE; | | ------------------ | | | | 70| 8.97M|#define TRUE 1 | | ------------------ ------------------ 3096| 8.97M| break; 3097| | 3098| | 3099| | /* ---- Escape sequence ---- */ 3100| | 3101| 122k| case CHAR_BACKSLASH: ------------------ | | 1042| 122k|#define CHAR_BACKSLASH '\134' ------------------ | Branch (3101:5): [True: 122k, False: 14.4M] ------------------ 3102| 122k| tempptr = ptr; 3103| 122k| escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options, ------------------ | | 177| 122k|#define PRIV(name) _pcre2_##name ------------------ 3104| 122k| xoptions, FALSE, cb); ------------------ | | 69| 122k|#define FALSE 0 ------------------ 3105| 122k| if (errorcode != 0) ------------------ | Branch (3105:9): [True: 755, False: 122k] ------------------ 3106| 755| { 3107| 1.12k| ESCAPE_FAILED: 3108| 1.12k| if ((xoptions & PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL) == 0) ------------------ | | 150| 1.12k|#define PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL 0x00000002u /* C */ ------------------ | Branch (3108:11): [True: 1.12k, False: 0] ------------------ 3109| 1.12k| goto FAILED; 3110| 0| ptr = tempptr; 3111| 0| if (ptr >= ptrend) c = CHAR_BACKSLASH; else ------------------ | | 1042| 0|#define CHAR_BACKSLASH '\134' ------------------ | Branch (3111:11): [True: 0, False: 0] ------------------ 3112| 0| { 3113| 0| GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */ ------------------ | | 323| 0| c = *eptr++; \ | | 324| 0| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 0| { \ | | | | 289| 0| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 0, False: 0] | | | | ------------------ | | | | 290| 0| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 0| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 0, False: 0] | | | | ------------------ | | | | 292| 0| { \ | | | | 293| 0| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 0| eptr += 2; \ | | | | 295| 0| } \ | | | | 296| 0| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 0, False: 0] | | | | ------------------ | | | | 297| 0| { \ | | | | 298| 0| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 0| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 0| eptr += 3; \ | | | | 301| 0| } \ | | | | 302| 0| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 0| } | | ------------------ | | | Branch (324:7): [True: 0, False: 0] | | | Branch (324:14): [True: 0, False: 0] | | ------------------ ------------------ 3114| 0| } 3115| 0| escape = 0; /* Treat as literal character */ 3116| 0| } 3117| | 3118| | /* The escape was a data escape or literal character. */ 3119| | 3120| 122k| if (escape == 0) ------------------ | Branch (3120:9): [True: 23.8k, False: 98.3k] ------------------ 3121| 23.8k| { 3122| 23.8k| PARSED_LITERAL(c, parsed_pattern); ------------------ | | 2685| 23.8k|#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE; | | ------------------ | | | | 70| 23.8k|#define TRUE 1 | | ------------------ ------------------ 3123| 23.8k| } 3124| | 3125| | /* The escape was a back (or forward) reference. We keep the offset in 3126| | order to give a more useful diagnostic for a bad forward reference. For 3127| | references to groups numbered less than 10 we can't use more than two items 3128| | in parsed_pattern because they may be just two characters in the input (and 3129| | in a 64-bit world an offset may need two elements). So for them, the offset 3130| | of the first occurrent is held in a special vector. */ 3131| | 3132| 98.3k| else if (escape < 0) ------------------ | Branch (3132:14): [True: 13.1k, False: 85.1k] ------------------ 3133| 13.1k| { 3134| 13.1k| offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 1); 3135| 13.1k| escape = -escape; 3136| 13.1k| *parsed_pattern++ = META_BACKREF | (uint32_t)escape; ------------------ | | 215| 13.1k|#define META_BACKREF 0x80030000u /* Back ref */ ------------------ 3137| 13.1k| if (escape < 10) ------------------ | Branch (3137:11): [True: 9.71k, False: 3.39k] ------------------ 3138| 9.71k| { 3139| 9.71k| if (cb->small_ref_offset[escape] == PCRE2_UNSET) ------------------ | | 480| 9.71k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (3139:13): [True: 4.93k, False: 4.77k] ------------------ 3140| 4.93k| cb->small_ref_offset[escape] = offset; 3141| 9.71k| } 3142| 3.39k| else 3143| 3.39k| { 3144| 3.39k| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 3.39k| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 3145| 3.39k| } 3146| 13.1k| okquantifier = TRUE; ------------------ | | 70| 13.1k|#define TRUE 1 ------------------ 3147| 13.1k| } 3148| | 3149| | /* The escape was a character class such as \d etc. or other special 3150| | escape indicator such as \A or \X. Most of them generate just a single 3151| | parsed item, but \P and \p are followed by a 16-bit type and a 16-bit 3152| | value. They are supported only when Unicode is available. The type and 3153| | value are packed into a single 32-bit value so that the whole sequences 3154| | uses only two elements in the parsed_vector. This is because the same 3155| | coding is used if \d (for example) is turned into \p{Nd} when PCRE2_UCP is 3156| | set. 3157| | 3158| | There are also some cases where the escape sequence is followed by a name: 3159| | \k{name}, \k, and \k'name' are backreferences by name, and \g 3160| | and \g'name' are subroutine calls by name; \g{name} is a synonym for 3161| | \k{name}. Note that \g and \g'number' are handled by check_escape() 3162| | and returned as a negative value (handled above). A name is coded as an 3163| | offset into the pattern and a length. */ 3164| | 3165| 85.1k| else switch (escape) 3166| 85.1k| { 3167| 5| case ESC_C: ------------------ | Branch (3167:7): [True: 5, False: 85.1k] ------------------ 3168| 5|#ifdef NEVER_BACKSLASH_C 3169| 5| errorcode = ERR85; 3170| 5| goto ESCAPE_FAILED; 3171| |#else 3172| | if ((options & PCRE2_NEVER_BACKSLASH_C) != 0) 3173| | { 3174| | errorcode = ERR83; 3175| | goto ESCAPE_FAILED; 3176| | } 3177| |#endif 3178| 0| okquantifier = TRUE; ------------------ | | 70| 0|#define TRUE 1 ------------------ 3179| 0| *parsed_pattern++ = META_ESCAPE + escape; ------------------ | | 236| 0|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3180| 0| break; 3181| | 3182| 2.15k| case ESC_X: ------------------ | Branch (3182:7): [True: 2.15k, False: 83.0k] ------------------ 3183| |#ifndef SUPPORT_UNICODE 3184| | errorcode = ERR45; /* Supported only with Unicode support */ 3185| | goto ESCAPE_FAILED; 3186| |#endif 3187| 16.7k| case ESC_H: ------------------ | Branch (3187:7): [True: 14.5k, False: 70.6k] ------------------ 3188| 23.7k| case ESC_h: ------------------ | Branch (3188:7): [True: 6.98k, False: 78.1k] ------------------ 3189| 26.1k| case ESC_N: ------------------ | Branch (3189:7): [True: 2.41k, False: 82.7k] ------------------ 3190| 29.1k| case ESC_R: ------------------ | Branch (3190:7): [True: 2.99k, False: 82.1k] ------------------ 3191| 31.9k| case ESC_V: ------------------ | Branch (3191:7): [True: 2.77k, False: 82.4k] ------------------ 3192| 33.8k| case ESC_v: ------------------ | Branch (3192:7): [True: 1.88k, False: 83.3k] ------------------ 3193| 33.8k| okquantifier = TRUE; ------------------ | | 70| 33.8k|#define TRUE 1 ------------------ 3194| 33.8k| *parsed_pattern++ = META_ESCAPE + escape; ------------------ | | 236| 33.8k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3195| 33.8k| break; 3196| | 3197| 9.45k| default: /* \A, \B, \b, \G, \K, \Z, \z cannot be quantified. */ ------------------ | Branch (3197:7): [True: 9.45k, False: 75.7k] ------------------ 3198| 9.45k| *parsed_pattern++ = META_ESCAPE + escape; ------------------ | | 236| 9.45k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3199| 9.45k| break; 3200| | 3201| | /* Escapes that may change in UCP mode. */ 3202| | 3203| 2.59k| case ESC_d: ------------------ | Branch (3203:7): [True: 2.59k, False: 82.5k] ------------------ 3204| 5.63k| case ESC_D: ------------------ | Branch (3204:7): [True: 3.03k, False: 82.1k] ------------------ 3205| 12.8k| case ESC_s: ------------------ | Branch (3205:7): [True: 7.19k, False: 77.9k] ------------------ 3206| 18.6k| case ESC_S: ------------------ | Branch (3206:7): [True: 5.79k, False: 79.3k] ------------------ 3207| 23.4k| case ESC_w: ------------------ | Branch (3207:7): [True: 4.85k, False: 80.3k] ------------------ 3208| 26.4k| case ESC_W: ------------------ | Branch (3208:7): [True: 2.94k, False: 82.2k] ------------------ 3209| 26.4k| okquantifier = TRUE; ------------------ | | 70| 26.4k|#define TRUE 1 ------------------ 3210| 26.4k| parsed_pattern = handle_escdsw(escape, parsed_pattern, options, 3211| 26.4k| xoptions); 3212| 26.4k| break; 3213| | 3214| | /* Unicode property matching */ 3215| | 3216| 5.12k| case ESC_P: ------------------ | Branch (3216:7): [True: 5.12k, False: 80.0k] ------------------ 3217| 8.41k| case ESC_p: ------------------ | Branch (3217:7): [True: 3.28k, False: 81.9k] ------------------ 3218| 8.41k|#ifdef SUPPORT_UNICODE 3219| 8.41k| { 3220| 8.41k| BOOL negated; 3221| 8.41k| uint16_t ptype = 0, pdata = 0; 3222| 8.41k| if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcode, cb)) ------------------ | Branch (3222:13): [True: 257, False: 8.15k] ------------------ 3223| 257| goto ESCAPE_FAILED; 3224| 8.15k| if (negated) escape = (escape == ESC_P)? ESC_p : ESC_P; ------------------ | Branch (3224:13): [True: 201, False: 7.95k] | Branch (3224:31): [True: 13, False: 188] ------------------ 3225| 8.15k| *parsed_pattern++ = META_ESCAPE + escape; ------------------ | | 236| 8.15k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3226| 8.15k| *parsed_pattern++ = (ptype << 16) | pdata; 3227| 8.15k| okquantifier = TRUE; ------------------ | | 70| 8.15k|#define TRUE 1 ------------------ 3228| 8.15k| } 3229| |#else 3230| | errorcode = ERR45; 3231| | goto ESCAPE_FAILED; 3232| |#endif 3233| 0| break; /* End \P and \p */ 3234| | 3235| | /* When \g is used with quotes or angle brackets as delimiters, it is a 3236| | numerical or named subroutine call, and control comes here. When used 3237| | with brace delimiters it is a numberical back reference and does not come 3238| | here because check_escape() returns it directly as a reference. \k is 3239| | always a named back reference. */ 3240| | 3241| 653| case ESC_g: ------------------ | Branch (3241:7): [True: 653, False: 84.5k] ------------------ 3242| 7.09k| case ESC_k: ------------------ | Branch (3242:7): [True: 6.44k, False: 78.7k] ------------------ 3243| 7.09k| if (ptr >= ptrend || (*ptr != CHAR_LEFT_CURLY_BRACKET && ------------------ | | 1073| 14.1k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (3243:11): [True: 12, False: 7.08k] | Branch (3243:29): [True: 6.87k, False: 209] ------------------ 3244| 7.08k| *ptr != CHAR_LESS_THAN_SIGN && *ptr != CHAR_APOSTROPHE)) ------------------ | | 1010| 13.9k|#define CHAR_LESS_THAN_SIGN '\074' ------------------ *ptr != CHAR_LESS_THAN_SIGN && *ptr != CHAR_APOSTROPHE)) ------------------ | | 989| 6.54k|#define CHAR_APOSTROPHE '\047' ------------------ | Branch (3244:11): [True: 6.54k, False: 330] | Branch (3244:42): [True: 29, False: 6.51k] ------------------ 3245| 41| { 3246| 41| errorcode = (escape == ESC_g)? ERR57 : ERR69; ------------------ | Branch (3246:21): [True: 0, False: 41] ------------------ 3247| 41| goto ESCAPE_FAILED; 3248| 41| } 3249| 7.05k| terminator = (*ptr == CHAR_LESS_THAN_SIGN)? ------------------ | | 1010| 7.05k|#define CHAR_LESS_THAN_SIGN '\074' ------------------ | Branch (3249:20): [True: 330, False: 6.72k] ------------------ 3250| 6.72k| CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)? ------------------ | | 1012| 330|#define CHAR_GREATER_THAN_SIGN '\076' ------------------ CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)? ------------------ | | 989| 6.72k|#define CHAR_APOSTROPHE '\047' ------------------ | Branch (3250:34): [True: 6.51k, False: 209] ------------------ 3251| 6.51k| CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET; ------------------ | | 989| 6.51k|#define CHAR_APOSTROPHE '\047' ------------------ CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET; ------------------ | | 1075| 7.26k|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ 3252| | 3253| | /* For a non-braced \g, check for a numerical recursion. */ 3254| | 3255| 7.05k| if (escape == ESC_g && terminator != CHAR_RIGHT_CURLY_BRACKET) ------------------ | | 1075| 653|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (3255:11): [True: 653, False: 6.39k] | Branch (3255:30): [True: 653, False: 0] ------------------ 3256| 653| { 3257| 653| PCRE2_SPTR p = ptr + 1; ------------------ | | 814| 653|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 653|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 653|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 653|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3258| | 3259| 653| if (read_number(&p, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &i, ------------------ | | 147| 653|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (3259:13): [True: 254, False: 399] ------------------ 3260| 653| &errorcode)) 3261| 254| { 3262| 254| if (p >= ptrend || *p != terminator) ------------------ | Branch (3262:15): [True: 3, False: 251] | Branch (3262:30): [True: 3, False: 248] ------------------ 3263| 6| { 3264| 6| errorcode = ERR57; 3265| 6| goto ESCAPE_FAILED; 3266| 6| } 3267| 248| ptr = p; 3268| 248| goto SET_RECURSION; 3269| 254| } 3270| 399| if (errorcode != 0) goto ESCAPE_FAILED; ------------------ | Branch (3270:13): [True: 3, False: 396] ------------------ 3271| 399| } 3272| | 3273| | /* Not a numerical recursion */ 3274| | 3275| 6.79k| if (!read_name(&ptr, ptrend, utf, terminator, &offset, &name, &namelen, ------------------ | Branch (3275:11): [True: 54, False: 6.74k] ------------------ 3276| 6.79k| &errorcode, cb)) goto ESCAPE_FAILED; 3277| | 3278| | /* \k and \g when used with braces are back references, whereas \g used 3279| | with quotes or angle brackets is a recursion */ 3280| | 3281| 6.74k| *parsed_pattern++ = 3282| 6.74k| (escape == ESC_k || terminator == CHAR_RIGHT_CURLY_BRACKET)? ------------------ | | 1075| 374|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (3282:10): [True: 6.36k, False: 374] | Branch (3282:29): [True: 0, False: 374] ------------------ 3283| 6.36k| META_BACKREF_BYNAME : META_RECURSE_BYNAME; ------------------ | | 216| 6.36k|#define META_BACKREF_BYNAME 0x80040000u /* \k'name' */ ------------------ META_BACKREF_BYNAME : META_RECURSE_BYNAME; ------------------ | | 245| 7.11k|#define META_RECURSE_BYNAME 0x80210000u /* (?&name) */ ------------------ 3284| 6.74k| *parsed_pattern++ = namelen; 3285| | 3286| 6.74k| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 6.74k| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 3287| 6.74k| okquantifier = TRUE; ------------------ | | 70| 6.74k|#define TRUE 1 ------------------ 3288| 6.74k| break; /* End special escape processing */ 3289| 85.1k| } 3290| 121k| break; /* End escape sequence processing */ 3291| | 3292| | 3293| | /* ---- Single-character special items ---- */ 3294| | 3295| 121k| case CHAR_CIRCUMFLEX_ACCENT: ------------------ | | 1044| 14.9k|#define CHAR_CIRCUMFLEX_ACCENT '\136' ------------------ | Branch (3295:5): [True: 14.9k, False: 14.5M] ------------------ 3296| 14.9k| *parsed_pattern++ = META_CIRCUMFLEX; ------------------ | | 221| 14.9k|#define META_CIRCUMFLEX 0x80090000u /* ^ metacharacter */ ------------------ 3297| 14.9k| break; 3298| | 3299| 10.4k| case CHAR_DOLLAR_SIGN: ------------------ | | 986| 10.4k|#define CHAR_DOLLAR_SIGN '\044' ------------------ | Branch (3299:5): [True: 10.4k, False: 14.5M] ------------------ 3300| 10.4k| *parsed_pattern++ = META_DOLLAR; ------------------ | | 234| 10.4k|#define META_DOLLAR 0x80160000u /* $ metacharacter */ ------------------ 3301| 10.4k| break; 3302| | 3303| 30.3k| case CHAR_DOT: ------------------ | | 996| 30.3k|#define CHAR_DOT '\056' ------------------ | Branch (3303:5): [True: 30.3k, False: 14.5M] ------------------ 3304| 30.3k| *parsed_pattern++ = META_DOT; ------------------ | | 235| 30.3k|#define META_DOT 0x80170000u /* . metacharacter */ ------------------ 3305| 30.3k| okquantifier = TRUE; ------------------ | | 70| 30.3k|#define TRUE 1 ------------------ 3306| 30.3k| break; 3307| | 3308| | 3309| | /* ---- Single-character quantifiers ---- */ 3310| | 3311| 30.9k| case CHAR_ASTERISK: ------------------ | | 992| 30.9k|#define CHAR_ASTERISK '\052' ------------------ | Branch (3311:5): [True: 30.9k, False: 14.5M] ------------------ 3312| 30.9k| meta_quantifier = META_ASTERISK; ------------------ | | 279| 30.9k|#define META_ASTERISK 0x80340000u /* * */ ------------------ 3313| 30.9k| goto CHECK_QUANTIFIER; 3314| | 3315| 50.4k| case CHAR_PLUS: ------------------ | | 993| 50.4k|#define CHAR_PLUS '\053' ------------------ | Branch (3315:5): [True: 50.4k, False: 14.5M] ------------------ 3316| 50.4k| meta_quantifier = META_PLUS; ------------------ | | 282| 50.4k|#define META_PLUS 0x80370000u /* + */ ------------------ 3317| 50.4k| goto CHECK_QUANTIFIER; 3318| | 3319| 148k| case CHAR_QUESTION_MARK: ------------------ | | 1013| 148k|#define CHAR_QUESTION_MARK '\077' ------------------ | Branch (3319:5): [True: 148k, False: 14.4M] ------------------ 3320| 148k| meta_quantifier = META_QUERY; ------------------ | | 285| 148k|#define META_QUERY 0x803a0000u /* ? */ ------------------ 3321| 148k| goto CHECK_QUANTIFIER; 3322| | 3323| | 3324| | /* ---- Potential {n,m} quantifier ---- */ 3325| | 3326| 53.9k| case CHAR_LEFT_CURLY_BRACKET: ------------------ | | 1073| 53.9k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (3326:5): [True: 53.9k, False: 14.5M] ------------------ 3327| 53.9k| if (!read_repeat_counts(&ptr, ptrend, &min_repeat, &max_repeat, ------------------ | Branch (3327:9): [True: 11.8k, False: 42.1k] ------------------ 3328| 53.9k| &errorcode)) 3329| 11.8k| { 3330| 11.8k| if (errorcode != 0) goto FAILED; /* Error in quantifier. */ ------------------ | Branch (3330:11): [True: 23, False: 11.8k] ------------------ 3331| 11.8k| PARSED_LITERAL(c, parsed_pattern); /* Not a quantifier */ ------------------ | | 2685| 11.8k|#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE; | | ------------------ | | | | 70| 11.8k|#define TRUE 1 | | ------------------ ------------------ 3332| 11.8k| break; /* No more quantifier processing */ 3333| 11.8k| } 3334| 42.1k| meta_quantifier = META_MINMAX; ------------------ | | 288| 42.1k|#define META_MINMAX 0x803d0000u /* {n,m} repeat */ ------------------ 3335| | /* Fall through */ 3336| | 3337| | 3338| | /* ---- Quantifier post-processing ---- */ 3339| | 3340| | /* Check that a quantifier is allowed after the previous item. */ 3341| | 3342| 271k| CHECK_QUANTIFIER: 3343| 271k| if (!prev_okquantifier) ------------------ | Branch (3343:9): [True: 204, False: 271k] ------------------ 3344| 204| { 3345| 204| errorcode = ERR9; 3346| 204| goto FAILED_BACK; 3347| 204| } 3348| | 3349| | /* Most (*VERB)s are not allowed to be quantified, but an ungreedy 3350| | quantifier can be useful for (*ACCEPT) - meaning "succeed on backtrack", a 3351| | sort of negated (*COMMIT). We therefore allow (*ACCEPT) to be quantified by 3352| | wrapping it in non-capturing brackets, but we have to allow for a preceding 3353| | (*MARK) for when (*ACCEPT) has an argument. */ 3354| | 3355| 271k| if (parsed_pattern[-1] == META_ACCEPT) ------------------ | | 266| 271k|#define META_ACCEPT 0x802a0000u /* (*ACCEPT) */ ------------------ | Branch (3355:9): [True: 327, False: 271k] ------------------ 3356| 327| { 3357| 327| uint32_t *p; 3358| 1.10k| for (p = parsed_pattern - 1; p >= verbstartptr; p--) p[1] = p[0]; ------------------ | Branch (3358:36): [True: 779, False: 327] ------------------ 3359| 327| *verbstartptr = META_NOCAPTURE; ------------------ | | 238| 327|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ 3360| 327| parsed_pattern[1] = META_KET; ------------------ | | 237| 327|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ 3361| 327| parsed_pattern += 2; 3362| 327| } 3363| | 3364| | /* Now we can put the quantifier into the parsed pattern vector. At this 3365| | stage, we have only the basic quantifier. The check for a following + or ? 3366| | modifier happens at the top of the loop, after any intervening comments 3367| | have been removed. */ 3368| | 3369| 271k| *parsed_pattern++ = meta_quantifier; 3370| 271k| if (c == CHAR_LEFT_CURLY_BRACKET) ------------------ | | 1073| 271k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (3370:9): [True: 42.0k, False: 229k] ------------------ 3371| 42.0k| { 3372| 42.0k| *parsed_pattern++ = min_repeat; 3373| 42.0k| *parsed_pattern++ = max_repeat; 3374| 42.0k| } 3375| 271k| break; 3376| | 3377| | 3378| | /* ---- Character class ---- */ 3379| | 3380| 197k| case CHAR_LEFT_SQUARE_BRACKET: ------------------ | | 1041| 197k|#define CHAR_LEFT_SQUARE_BRACKET '\133' ------------------ | Branch (3380:5): [True: 197k, False: 14.3M] ------------------ 3381| 197k| okquantifier = TRUE; ------------------ | | 70| 197k|#define TRUE 1 ------------------ 3382| | 3383| | /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is 3384| | used for "start of word" and "end of word". As these are otherwise illegal 3385| | sequences, we don't break anything by recognizing them. They are replaced 3386| | by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are 3387| | erroneous and are handled by the normal code below. */ 3388| | 3389| 197k| if (ptrend - ptr >= 6 && ------------------ | Branch (3389:9): [True: 193k, False: 4.33k] ------------------ 3390| 197k| (PRIV(strncmp_c8)(ptr, STRING_WEIRD_STARTWORD, 6) == 0 || ------------------ | | 177| 193k|#define PRIV(name) _pcre2_##name ------------------ (PRIV(strncmp_c8)(ptr, STRING_WEIRD_STARTWORD, 6) == 0 || ------------------ | | 1229| 193k|#define STRING_WEIRD_STARTWORD STR_LEFT_SQUARE_BRACKET STR_COLON STR_LESS_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET | | ------------------ | | | | 1148| 193k|#define STR_LEFT_SQUARE_BRACKET "\133" | | ------------------ | | #define STRING_WEIRD_STARTWORD STR_LEFT_SQUARE_BRACKET STR_COLON STR_LESS_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET | | ------------------ | | | | 1150| 193k|#define STR_RIGHT_SQUARE_BRACKET "\135" | | ------------------ ------------------ | Branch (3390:11): [True: 418, False: 192k] ------------------ 3391| 193k| PRIV(strncmp_c8)(ptr, STRING_WEIRD_ENDWORD, 6) == 0)) ------------------ | | 177| 192k|#define PRIV(name) _pcre2_##name ------------------ PRIV(strncmp_c8)(ptr, STRING_WEIRD_ENDWORD, 6) == 0)) ------------------ | | 1230| 192k|#define STRING_WEIRD_ENDWORD STR_LEFT_SQUARE_BRACKET STR_COLON STR_GREATER_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET | | ------------------ | | | | 1148| 192k|#define STR_LEFT_SQUARE_BRACKET "\133" | | ------------------ | | #define STRING_WEIRD_ENDWORD STR_LEFT_SQUARE_BRACKET STR_COLON STR_GREATER_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET | | ------------------ | | | | 1150| 192k|#define STR_RIGHT_SQUARE_BRACKET "\135" | | ------------------ ------------------ | Branch (3391:11): [True: 204, False: 192k] ------------------ 3392| 622| { 3393| 622| *parsed_pattern++ = META_ESCAPE + ESC_b; ------------------ | | 236| 622|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3394| | 3395| 622| if (ptr[2] == CHAR_LESS_THAN_SIGN) ------------------ | | 1010| 622|#define CHAR_LESS_THAN_SIGN '\074' ------------------ | Branch (3395:11): [True: 418, False: 204] ------------------ 3396| 418| { 3397| 418| *parsed_pattern++ = META_LOOKAHEAD; ------------------ | | 251| 418|#define META_LOOKAHEAD 0x80230000u /* (?= */ ------------------ 3398| 418| } 3399| 204| else 3400| 204| { 3401| 204| *parsed_pattern++ = META_LOOKBEHIND; ------------------ | | 253| 204|#define META_LOOKBEHIND 0x80250000u /* (?<= */ ------------------ 3402| 204| *has_lookbehind = TRUE; ------------------ | | 70| 204|#define TRUE 1 ------------------ 3403| | 3404| | /* The offset is used only for the "non-fixed length" error; this won't 3405| | occur here, so just store zero. */ 3406| | 3407| 204| PUTOFFSET((PCRE2_SIZE)0, parsed_pattern); ------------------ | | 100| 204| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 3408| 204| } 3409| | 3410| 622| if ((options & PCRE2_UCP) == 0) ------------------ | | 136| 622|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (3410:11): [True: 309, False: 313] ------------------ 3411| 309| *parsed_pattern++ = META_ESCAPE + ESC_w; ------------------ | | 236| 309|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3412| 313| else 3413| 313| { 3414| 313| *parsed_pattern++ = META_ESCAPE + ESC_p; ------------------ | | 236| 313|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3415| 313| *parsed_pattern++ = PT_WORD << 16; ------------------ | | 1284| 313|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ 3416| 313| } 3417| 622| *parsed_pattern++ = META_KET; ------------------ | | 237| 622|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ 3418| 622| ptr += 6; 3419| 622| break; 3420| 622| } 3421| | 3422| | /* PCRE supports POSIX class stuff inside a class. Perl gives an error if 3423| | they are encountered at the top level, so we'll do that too. */ 3424| | 3425| 196k| if (ptr < ptrend && (*ptr == CHAR_COLON || *ptr == CHAR_DOT || ------------------ | | 1008| 393k|#define CHAR_COLON '\072' ------------------ if (ptr < ptrend && (*ptr == CHAR_COLON || *ptr == CHAR_DOT || ------------------ | | 996| 390k|#define CHAR_DOT '\056' ------------------ | Branch (3425:9): [True: 196k, False: 25] | Branch (3425:26): [True: 3.29k, False: 193k] | Branch (3425:48): [True: 16.1k, False: 177k] ------------------ 3426| 196k| *ptr == CHAR_EQUALS_SIGN) && ------------------ | | 1011| 177k|#define CHAR_EQUALS_SIGN '\075' ------------------ | Branch (3426:10): [True: 260, False: 177k] ------------------ 3427| 196k| check_posix_syntax(ptr, ptrend, &tempptr)) ------------------ | Branch (3427:9): [True: 21, False: 19.6k] ------------------ 3428| 21| { 3429| 21| errorcode = (*ptr-- == CHAR_COLON)? ERR12 : ERR13; ------------------ | | 1008| 21|#define CHAR_COLON '\072' ------------------ | Branch (3429:19): [True: 18, False: 3] ------------------ 3430| 21| goto FAILED; 3431| 21| } 3432| | 3433| | /* Process a regular character class. If the first character is '^', set 3434| | the negation flag. If the first few characters (either before or after ^) 3435| | are \Q\E or \E or space or tab in extended-more mode, we skip them too. 3436| | This makes for compatibility with Perl. */ 3437| | 3438| 196k| negate_class = FALSE; ------------------ | | 69| 196k|#define FALSE 0 ------------------ 3439| 358k| while (ptr < ptrend) ------------------ | Branch (3439:12): [True: 358k, False: 79] ------------------ 3440| 358k| { 3441| 358k| GETCHARINCTEST(c, ptr); ------------------ | | 323| 358k| c = *eptr++; \ | | 324| 358k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.71k| { \ | | | | 289| 1.71k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 779, False: 933] | | | | ------------------ | | | | 290| 1.71k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.71k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 575, False: 358] | | | | ------------------ | | | | 292| 933| { \ | | | | 293| 575| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 575| eptr += 2; \ | | | | 295| 575| } \ | | | | 296| 933| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 358, False: 0] | | | | ------------------ | | | | 297| 358| { \ | | | | 298| 358| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 358| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 358| eptr += 3; \ | | | | 301| 358| } \ | | | | 302| 358| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.71k| } | | ------------------ | | | Branch (324:7): [True: 10.6k, False: 347k] | | | Branch (324:14): [True: 1.71k, False: 8.94k] | | ------------------ ------------------ 3442| 358k| if (c == CHAR_BACKSLASH) ------------------ | | 1042| 358k|#define CHAR_BACKSLASH '\134' ------------------ | Branch (3442:11): [True: 5.79k, False: 352k] ------------------ 3443| 5.79k| { 3444| 5.79k| if (ptr < ptrend && *ptr == CHAR_E) ptr++; ------------------ | | 1019| 5.78k|#define CHAR_E '\105' ------------------ | Branch (3444:13): [True: 5.78k, False: 9] | Branch (3444:29): [True: 611, False: 5.17k] ------------------ 3445| 5.18k| else if (ptrend - ptr >= 3 && ------------------ | Branch (3445:18): [True: 4.98k, False: 199] ------------------ 3446| 5.18k| PRIV(strncmp_c8)(ptr, STR_Q STR_BACKSLASH STR_E, 3) == 0) ------------------ | | 177| 4.98k|#define PRIV(name) _pcre2_##name ------------------ PRIV(strncmp_c8)(ptr, STR_Q STR_BACKSLASH STR_E, 3) == 0) ------------------ | | 1138| 4.98k|#define STR_Q "\121" ------------------ PRIV(strncmp_c8)(ptr, STR_Q STR_BACKSLASH STR_E, 3) == 0) ------------------ | | 1126| 4.98k|#define STR_E "\105" ------------------ | Branch (3446:14): [True: 194, False: 4.78k] ------------------ 3447| 194| ptr += 3; 3448| 4.98k| else 3449| 4.98k| break; 3450| 5.79k| } 3451| 352k| else if ((options & PCRE2_EXTENDED_MORE) != 0 && ------------------ | | 143| 352k|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ ------------------ | Branch (3451:16): [True: 1.06k, False: 351k] ------------------ 3452| 352k| (c == CHAR_SPACE || c == CHAR_HT)) /* Note: just these two */ ------------------ | | 982| 2.12k|#define CHAR_SPACE '\040' ------------------ (c == CHAR_SPACE || c == CHAR_HT)) /* Note: just these two */ ------------------ | | 969| 498|#define CHAR_HT '\011' ------------------ | Branch (3452:17): [True: 565, False: 498] | Branch (3452:36): [True: 208, False: 290] ------------------ 3453| 773| continue; 3454| 351k| else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT) ------------------ | | 1044| 192k|#define CHAR_CIRCUMFLEX_ACCENT '\136' ------------------ | Branch (3454:16): [True: 192k, False: 159k] | Branch (3454:33): [True: 159k, False: 32.5k] ------------------ 3455| 159k| negate_class = TRUE; ------------------ | | 70| 159k|#define TRUE 1 ------------------ 3456| 191k| else break; 3457| 358k| } 3458| | 3459| | /* Now the real contents of the class; c has the first "real" character. 3460| | Empty classes are permitted only if the option is set. */ 3461| | 3462| 196k| if (c == CHAR_RIGHT_SQUARE_BRACKET && ------------------ | | 1043| 393k|#define CHAR_RIGHT_SQUARE_BRACKET '\135' ------------------ | Branch (3462:9): [True: 28.9k, False: 167k] ------------------ 3463| 196k| (cb->external_options & PCRE2_ALLOW_EMPTY_CLASS) != 0) ------------------ | | 119| 28.9k|#define PCRE2_ALLOW_EMPTY_CLASS 0x00000001u /* C */ ------------------ | Branch (3463:9): [True: 1.23k, False: 27.7k] ------------------ 3464| 1.23k| { 3465| 1.23k| *parsed_pattern++ = negate_class? META_CLASS_EMPTY_NOT : META_CLASS_EMPTY; ------------------ | | 224| 297|#define META_CLASS_EMPTY_NOT 0x800c0000u /* negative empty class */ ------------------ *parsed_pattern++ = negate_class? META_CLASS_EMPTY_NOT : META_CLASS_EMPTY; ------------------ | | 223| 2.17k|#define META_CLASS_EMPTY 0x800b0000u /* empty class */ ------------------ | Branch (3465:27): [True: 297, False: 938] ------------------ 3466| 1.23k| break; /* End of class processing */ 3467| 1.23k| } 3468| | 3469| | /* Process a non-empty class. */ 3470| | 3471| 195k| *parsed_pattern++ = negate_class? META_CLASS_NOT : META_CLASS; ------------------ | | 226| 159k|#define META_CLASS_NOT 0x800e0000u /* start non-empty negative class */ ------------------ *parsed_pattern++ = negate_class? META_CLASS_NOT : META_CLASS; ------------------ | | 222| 231k|#define META_CLASS 0x800a0000u /* start non-empty class */ ------------------ | Branch (3471:25): [True: 159k, False: 36.0k] ------------------ 3472| 195k| class_range_state = RANGE_NO; 3473| | 3474| | /* In an EBCDIC environment, Perl treats alphabetic ranges specially 3475| | because there are holes in the encoding, and simply using the range A-Z 3476| | (for example) would include the characters in the holes. This applies only 3477| | to ranges where both values are literal; [\xC1-\xE9] is different to [A-Z] 3478| | in this respect. In order to accommodate this, we keep track of whether 3479| | character values are literal or not, and a state variable for handling 3480| | ranges. */ 3481| | 3482| | /* Loop for the contents of the class */ 3483| | 3484| 195k| for (;;) 3485| 5.22M| { 3486| 5.22M| BOOL char_is_literal = TRUE; ------------------ | | 70| 5.22M|#define TRUE 1 ------------------ 3487| | 3488| | /* Inside \Q...\E everything is literal except \E */ 3489| | 3490| 5.22M| if (inescq) ------------------ | Branch (3490:11): [True: 709, False: 5.22M] ------------------ 3491| 709| { 3492| 709| if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E) ------------------ | | 1042| 1.41k|#define CHAR_BACKSLASH '\134' ------------------ if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E) ------------------ | | 1019| 408|#define CHAR_E '\105' ------------------ | Branch (3492:13): [True: 411, False: 298] | Branch (3492:36): [True: 408, False: 3] | Branch (3492:52): [True: 213, False: 195] ------------------ 3493| 213| { 3494| 213| inescq = FALSE; /* Reset literal state */ ------------------ | | 69| 213|#define FALSE 0 ------------------ 3495| 213| ptr++; /* Skip the 'E' */ 3496| 213| goto CLASS_CONTINUE; 3497| 213| } 3498| 496| goto CLASS_LITERAL; 3499| 709| } 3500| | 3501| | /* Skip over space and tab (only) in extended-more mode. */ 3502| | 3503| 5.22M| if ((options & PCRE2_EXTENDED_MORE) != 0 && ------------------ | | 143| 5.22M|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ ------------------ | Branch (3503:11): [True: 168k, False: 5.05M] ------------------ 3504| 5.22M| (c == CHAR_SPACE || c == CHAR_HT)) ------------------ | | 982| 336k|#define CHAR_SPACE '\040' ------------------ (c == CHAR_SPACE || c == CHAR_HT)) ------------------ | | 969| 168k|#define CHAR_HT '\011' ------------------ | Branch (3504:12): [True: 209, False: 168k] | Branch (3504:31): [True: 206, False: 167k] ------------------ 3505| 415| goto CLASS_CONTINUE; 3506| | 3507| | /* Handle POSIX class names. Perl allows a negation extension of the 3508| | form [:^name:]. A square bracket that doesn't match the syntax is 3509| | treated as a literal. We also recognize the POSIX constructions 3510| | [.ch.] and [=ch=] ("collating elements") and fault them, as Perl 3511| | 5.6 and 5.8 do. */ 3512| | 3513| 5.22M| if (c == CHAR_LEFT_SQUARE_BRACKET && ------------------ | | 1041| 10.4M|#define CHAR_LEFT_SQUARE_BRACKET '\133' ------------------ | Branch (3513:11): [True: 39.2k, False: 5.18M] ------------------ 3514| 5.22M| ptrend - ptr >= 3 && ------------------ | Branch (3514:11): [True: 38.9k, False: 278] ------------------ 3515| 5.22M| (*ptr == CHAR_COLON || *ptr == CHAR_DOT || ------------------ | | 1008| 77.9k|#define CHAR_COLON '\072' ------------------ (*ptr == CHAR_COLON || *ptr == CHAR_DOT || ------------------ | | 996| 71.8k|#define CHAR_DOT '\056' ------------------ | Branch (3515:12): [True: 6.09k, False: 32.8k] | Branch (3515:34): [True: 479, False: 32.4k] ------------------ 3516| 38.9k| *ptr == CHAR_EQUALS_SIGN) && ------------------ | | 1011| 32.4k|#define CHAR_EQUALS_SIGN '\075' ------------------ | Branch (3516:12): [True: 289, False: 32.1k] ------------------ 3517| 5.22M| check_posix_syntax(ptr, ptrend, &tempptr)) ------------------ | Branch (3517:11): [True: 5.18k, False: 1.67k] ------------------ 3518| 5.18k| { 3519| 5.18k| BOOL posix_negate = FALSE; ------------------ | | 69| 5.18k|#define FALSE 0 ------------------ 3520| 5.18k| int posix_class; 3521| | 3522| | /* Perl treats a hyphen before a POSIX class as a literal, not the 3523| | start of a range. However, it gives a warning in its warning mode. PCRE 3524| | does not have a warning mode, so we give an error, because this is 3525| | likely an error on the user's part. */ 3526| | 3527| 5.18k| if (class_range_state == RANGE_STARTED) ------------------ | Branch (3527:13): [True: 3, False: 5.18k] ------------------ 3528| 3| { 3529| 3| errorcode = ERR50; 3530| 3| goto FAILED; 3531| 3| } 3532| | 3533| 5.18k| if (*ptr != CHAR_COLON) ------------------ | | 1008| 5.18k|#define CHAR_COLON '\072' ------------------ | Branch (3533:13): [True: 5, False: 5.18k] ------------------ 3534| 5| { 3535| 5| errorcode = ERR13; 3536| 5| goto FAILED_BACK; 3537| 5| } 3538| | 3539| 5.18k| if (*(++ptr) == CHAR_CIRCUMFLEX_ACCENT) ------------------ | | 1044| 5.18k|#define CHAR_CIRCUMFLEX_ACCENT '\136' ------------------ | Branch (3539:13): [True: 1.00k, False: 4.18k] ------------------ 3540| 1.00k| { 3541| 1.00k| posix_negate = TRUE; ------------------ | | 70| 1.00k|#define TRUE 1 ------------------ 3542| 1.00k| ptr++; 3543| 1.00k| } 3544| | 3545| 5.18k| posix_class = check_posix_name(ptr, (int)(tempptr - ptr)); 3546| 5.18k| if (posix_class < 0) ------------------ | Branch (3546:13): [True: 36, False: 5.14k] ------------------ 3547| 36| { 3548| 36| errorcode = ERR30; 3549| 36| goto FAILED; 3550| 36| } 3551| 5.14k| ptr = tempptr + 2; 3552| | 3553| | /* Perl treats a hyphen after a POSIX class as a literal, not the 3554| | start of a range. However, it gives a warning in its warning mode 3555| | unless the hyphen is the last character in the class. PCRE does not 3556| | have a warning mode, so we give an error, because this is likely an 3557| | error on the user's part. */ 3558| | 3559| 5.14k| if (ptr < ptrend - 1 && *ptr == CHAR_MINUS && ------------------ | | 995| 10.0k|#define CHAR_MINUS '\055' ------------------ | Branch (3559:13): [True: 4.90k, False: 244] | Branch (3559:33): [True: 197, False: 4.70k] ------------------ 3560| 5.14k| ptr[1] != CHAR_RIGHT_SQUARE_BRACKET) ------------------ | | 1043| 197|#define CHAR_RIGHT_SQUARE_BRACKET '\135' ------------------ | Branch (3560:13): [True: 3, False: 194] ------------------ 3561| 3| { 3562| 3| errorcode = ERR50; 3563| 3| goto FAILED; 3564| 3| } 3565| | 3566| | /* Set "a hyphen is not the start of a range" for the -] case, and also 3567| | in case the POSIX class is followed by \E or \Q\E (possibly repeated - 3568| | fuzzers do that kind of thing) and *then* a hyphen. This causes that 3569| | hyphen to be treated as a literal. I don't think it's worth setting up 3570| | special apparatus to do otherwise. */ 3571| | 3572| 5.14k| class_range_state = RANGE_NO; 3573| | 3574| | /* When PCRE2_UCP is set, unless PCRE2_EXTRA_ASCII_POSIX is set, some 3575| | of the POSIX classes are converted to use Unicode properties \p or \P 3576| | or, in one case, \h or \H. The substitutes table has two values per 3577| | class, containing the type and value of a \p or \P item. The special 3578| | cases are specified with a negative type: a non-zero value causes \h or 3579| | \H to be used, and a zero value falls through to behave like a non-UCP 3580| | POSIX class. There are now also some extra options that force ASCII for 3581| | some classes. */ 3582| | 3583| 5.14k|#ifdef SUPPORT_UNICODE 3584| 5.14k| if ((options & PCRE2_UCP) != 0 && ------------------ | | 136| 5.14k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (3584:13): [True: 2.14k, False: 3.00k] ------------------ 3585| 5.14k| (xoptions & PCRE2_EXTRA_ASCII_POSIX) == 0 && ------------------ | | 160| 2.14k|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ ------------------ | Branch (3585:13): [True: 1.71k, False: 427] ------------------ 3586| 5.14k| !(posix_class == 7 && (xoptions & PCRE2_EXTRA_ASCII_DIGIT) != 0)) ------------------ | | 161| 222|#define PCRE2_EXTRA_ASCII_DIGIT 0x00001000u /* C */ ------------------ | Branch (3586:15): [True: 222, False: 1.49k] | Branch (3586:35): [True: 0, False: 222] ------------------ 3587| 1.71k| { 3588| 1.71k| int ptype = posix_substitutes[2*posix_class]; 3589| 1.71k| int pvalue = posix_substitutes[2*posix_class + 1]; 3590| | 3591| 1.71k| if (ptype >= 0) ------------------ | Branch (3591:15): [True: 771, False: 943] ------------------ 3592| 771| { 3593| 771| *parsed_pattern++ = META_ESCAPE + (posix_negate? ESC_P : ESC_p); ------------------ | | 236| 771|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (3593:48): [True: 68, False: 703] ------------------ 3594| 771| *parsed_pattern++ = (ptype << 16) | pvalue; 3595| 771| goto CLASS_CONTINUE; 3596| 771| } 3597| | 3598| 943| if (pvalue != 0) ------------------ | Branch (3598:15): [True: 199, False: 744] ------------------ 3599| 199| { 3600| 199| *parsed_pattern++ = META_ESCAPE + (posix_negate? ESC_H : ESC_h); ------------------ | | 236| 199|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (3600:48): [True: 1, False: 198] ------------------ 3601| 199| goto CLASS_CONTINUE; 3602| 199| } 3603| | 3604| | /* Fall through */ 3605| 943| } 3606| 4.17k|#endif /* SUPPORT_UNICODE */ 3607| | 3608| | /* Non-UCP POSIX class */ 3609| | 3610| 4.17k| *parsed_pattern++ = posix_negate? META_POSIX_NEG : META_POSIX; ------------------ | | 241| 918|#define META_POSIX_NEG 0x801d0000u /* negative POSIX class item */ ------------------ *parsed_pattern++ = posix_negate? META_POSIX_NEG : META_POSIX; ------------------ | | 240| 7.42k|#define META_POSIX 0x801c0000u /* POSIX class item */ ------------------ | Branch (3610:29): [True: 918, False: 3.25k] ------------------ 3611| 4.17k| *parsed_pattern++ = posix_class; 3612| 4.17k| } 3613| | 3614| | /* Handle potential start of range */ 3615| | 3616| 5.21M| else if (c == CHAR_MINUS && class_range_state >= RANGE_OK_ESCAPED) ------------------ | | 995| 10.4M|#define CHAR_MINUS '\055' ------------------ | Branch (3616:16): [True: 22.1k, False: 5.19M] | Branch (3616:35): [True: 20.8k, False: 1.33k] ------------------ 3617| 20.8k| { 3618| 20.8k| *parsed_pattern++ = (class_range_state == RANGE_OK_LITERAL)? ------------------ | Branch (3618:29): [True: 20.5k, False: 222] ------------------ 3619| 20.5k| META_RANGE_LITERAL : META_RANGE_ESCAPED; ------------------ | | 243| 20.5k|#define META_RANGE_LITERAL 0x801f0000u /* range defined literally */ ------------------ META_RANGE_LITERAL : META_RANGE_ESCAPED; ------------------ | | 242| 21.0k|#define META_RANGE_ESCAPED 0x801e0000u /* range with at least one escape */ ------------------ 3620| 20.8k| class_range_state = RANGE_STARTED; 3621| 20.8k| } 3622| | 3623| | /* Handle a literal character */ 3624| | 3625| 5.19M| else if (c != CHAR_BACKSLASH) ------------------ | | 1042| 5.19M|#define CHAR_BACKSLASH '\134' ------------------ | Branch (3625:16): [True: 5.17M, False: 22.0k] ------------------ 3626| 5.17M| { 3627| 5.17M| CLASS_LITERAL: 3628| 5.17M| if (class_range_state == RANGE_STARTED) ------------------ | Branch (3628:13): [True: 20.3k, False: 5.15M] ------------------ 3629| 20.3k| { 3630| 20.3k| if (c == parsed_pattern[-2]) /* Optimize one-char range */ ------------------ | Branch (3630:15): [True: 348, False: 20.0k] ------------------ 3631| 348| parsed_pattern--; 3632| 20.0k| else if (parsed_pattern[-2] > c) /* Check range is in order */ ------------------ | Branch (3632:20): [True: 44, False: 20.0k] ------------------ 3633| 44| { 3634| 44| errorcode = ERR8; 3635| 44| goto FAILED_BACK; 3636| 44| } 3637| 20.0k| else 3638| 20.0k| { 3639| 20.0k| if (!char_is_literal && parsed_pattern[-1] == META_RANGE_LITERAL) ------------------ | | 243| 511|#define META_RANGE_LITERAL 0x801f0000u /* range defined literally */ ------------------ | Branch (3639:17): [True: 511, False: 19.4k] | Branch (3639:37): [True: 317, False: 194] ------------------ 3640| 317| parsed_pattern[-1] = META_RANGE_ESCAPED; ------------------ | | 242| 317|#define META_RANGE_ESCAPED 0x801e0000u /* range with at least one escape */ ------------------ 3641| 20.0k| PARSED_LITERAL(c, parsed_pattern); ------------------ | | 2685| 20.0k|#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE; | | ------------------ | | | | 70| 20.0k|#define TRUE 1 | | ------------------ ------------------ 3642| 20.0k| } 3643| 20.3k| class_range_state = RANGE_NO; 3644| 20.3k| } 3645| 5.15M| else /* Potential start of range */ 3646| 5.15M| { 3647| 5.15M| class_range_state = char_is_literal? ------------------ | Branch (3647:31): [True: 5.15M, False: 5.57k] ------------------ 3648| 5.15M| RANGE_OK_LITERAL : RANGE_OK_ESCAPED; 3649| 5.15M| PARSED_LITERAL(c, parsed_pattern); ------------------ | | 2685| 5.15M|#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE; | | ------------------ | | | | 70| 5.15M|#define TRUE 1 | | ------------------ ------------------ 3650| 5.15M| } 3651| 5.17M| } 3652| | 3653| | /* Handle escapes in a class */ 3654| | 3655| 22.0k| else 3656| 22.0k| { 3657| 22.0k| tempptr = ptr; 3658| 22.0k| escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options, ------------------ | | 177| 22.0k|#define PRIV(name) _pcre2_##name ------------------ 3659| 22.0k| xoptions, TRUE, cb); ------------------ | | 70| 22.0k|#define TRUE 1 ------------------ 3660| | 3661| 22.0k| if (errorcode != 0) ------------------ | Branch (3661:13): [True: 71, False: 21.9k] ------------------ 3662| 71| { 3663| 71| if ((xoptions & PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL) == 0) ------------------ | | 150| 71|#define PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL 0x00000002u /* C */ ------------------ | Branch (3663:15): [True: 71, False: 0] ------------------ 3664| 71| goto FAILED; 3665| 0| ptr = tempptr; 3666| 0| if (ptr >= ptrend) c = CHAR_BACKSLASH; else ------------------ | | 1042| 0|#define CHAR_BACKSLASH '\134' ------------------ | Branch (3666:15): [True: 0, False: 0] ------------------ 3667| 0| { 3668| 0| GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */ ------------------ | | 323| 0| c = *eptr++; \ | | 324| 0| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 0| { \ | | | | 289| 0| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 0, False: 0] | | | | ------------------ | | | | 290| 0| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 0| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 0, False: 0] | | | | ------------------ | | | | 292| 0| { \ | | | | 293| 0| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 0| eptr += 2; \ | | | | 295| 0| } \ | | | | 296| 0| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 0, False: 0] | | | | ------------------ | | | | 297| 0| { \ | | | | 298| 0| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 0| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 0| eptr += 3; \ | | | | 301| 0| } \ | | | | 302| 0| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 0| } | | ------------------ | | | Branch (324:7): [True: 0, False: 0] | | | Branch (324:14): [True: 0, False: 0] | | ------------------ ------------------ 3669| 0| } 3670| 0| escape = 0; /* Treat as literal character */ 3671| 0| } 3672| | 3673| 21.9k| switch(escape) ------------------ | Branch (3673:16): [True: 15.3k, False: 6.60k] ------------------ 3674| 21.9k| { 3675| 4.82k| case 0: /* Escaped character code point is in c */ ------------------ | Branch (3675:11): [True: 4.82k, False: 17.1k] ------------------ 3676| 4.82k| char_is_literal = FALSE; ------------------ | | 69| 4.82k|#define FALSE 0 ------------------ 3677| 4.82k| goto CLASS_LITERAL; 3678| | 3679| 1.26k| case ESC_b: ------------------ | Branch (3679:11): [True: 1.26k, False: 20.6k] ------------------ 3680| 1.26k| c = CHAR_BS; /* \b is backspace in a class */ ------------------ | | 976| 1.26k|#define CHAR_BS '\010' ------------------ 3681| 1.26k| char_is_literal = FALSE; ------------------ | | 69| 1.26k|#define FALSE 0 ------------------ 3682| 1.26k| goto CLASS_LITERAL; 3683| | 3684| 279| case ESC_Q: ------------------ | Branch (3684:11): [True: 279, False: 21.6k] ------------------ 3685| 279| inescq = TRUE; /* Enter literal mode */ ------------------ | | 70| 279|#define TRUE 1 ------------------ 3686| 279| goto CLASS_CONTINUE; 3687| | 3688| 219| case ESC_E: /* Ignore orphan \E */ ------------------ | Branch (3688:11): [True: 219, False: 21.7k] ------------------ 3689| 219| goto CLASS_CONTINUE; 3690| | 3691| 6| case ESC_B: /* Always an error in a class */ ------------------ | Branch (3691:11): [True: 6, False: 21.9k] ------------------ 3692| 11| case ESC_R: ------------------ | Branch (3692:11): [True: 5, False: 21.9k] ------------------ 3693| 16| case ESC_X: ------------------ | Branch (3693:11): [True: 5, False: 21.9k] ------------------ 3694| 16| errorcode = ERR7; 3695| 16| ptr--; 3696| 16| goto FAILED; 3697| 21.9k| } 3698| | 3699| | /* The second part of a range can be a single-character escape 3700| | sequence (detected above), but not any of the other escapes. Perl 3701| | treats a hyphen as a literal in such circumstances. However, in Perl's 3702| | warning mode, a warning is given, so PCRE now faults it, as it is 3703| | almost certainly a mistake on the user's part. */ 3704| | 3705| 15.3k| if (class_range_state == RANGE_STARTED) ------------------ | Branch (3705:13): [True: 3, False: 15.3k] ------------------ 3706| 3| { 3707| 3| errorcode = ERR50; 3708| 3| goto FAILED; /* Not CLASS_ESCAPE_FAILED; always an error */ 3709| 3| } 3710| | 3711| | /* Of the remaining escapes, only those that define characters are 3712| | allowed in a class. None may start a range. */ 3713| | 3714| 15.3k| class_range_state = RANGE_NO; 3715| 15.3k| switch(escape) 3716| 15.3k| { 3717| 10| case ESC_N: ------------------ | Branch (3717:11): [True: 10, False: 15.3k] ------------------ 3718| 10| errorcode = ERR71; 3719| 10| goto FAILED; 3720| | 3721| 732| case ESC_H: ------------------ | Branch (3721:11): [True: 732, False: 14.6k] ------------------ 3722| 1.37k| case ESC_h: ------------------ | Branch (3722:11): [True: 643, False: 14.6k] ------------------ 3723| 1.78k| case ESC_V: ------------------ | Branch (3723:11): [True: 409, False: 14.9k] ------------------ 3724| 2.31k| case ESC_v: ------------------ | Branch (3724:11): [True: 528, False: 14.8k] ------------------ 3725| 2.31k| *parsed_pattern++ = META_ESCAPE + escape; ------------------ | | 236| 2.31k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3726| 2.31k| break; 3727| | 3728| | /* These escapes may be converted to Unicode property tests when 3729| | PCRE2_UCP is set. */ 3730| | 3731| 1.25k| case ESC_d: ------------------ | Branch (3731:11): [True: 1.25k, False: 14.0k] ------------------ 3732| 2.86k| case ESC_D: ------------------ | Branch (3732:11): [True: 1.61k, False: 13.7k] ------------------ 3733| 5.39k| case ESC_s: ------------------ | Branch (3733:11): [True: 2.52k, False: 12.8k] ------------------ 3734| 7.17k| case ESC_S: ------------------ | Branch (3734:11): [True: 1.78k, False: 13.5k] ------------------ 3735| 9.23k| case ESC_w: ------------------ | Branch (3735:11): [True: 2.06k, False: 13.2k] ------------------ 3736| 10.6k| case ESC_W: ------------------ | Branch (3736:11): [True: 1.40k, False: 13.9k] ------------------ 3737| 10.6k| parsed_pattern = handle_escdsw(escape, parsed_pattern, options, 3738| 10.6k| xoptions); 3739| 10.6k| break; 3740| | 3741| | /* Explicit Unicode property matching */ 3742| | 3743| 1.06k| case ESC_P: ------------------ | Branch (3743:11): [True: 1.06k, False: 14.2k] ------------------ 3744| 2.36k| case ESC_p: ------------------ | Branch (3744:11): [True: 1.29k, False: 14.0k] ------------------ 3745| 2.36k|#ifdef SUPPORT_UNICODE 3746| 2.36k| { 3747| 2.36k| BOOL negated; 3748| 2.36k| uint16_t ptype = 0, pdata = 0; 3749| 2.36k| if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcode, cb)) ------------------ | Branch (3749:17): [True: 28, False: 2.33k] ------------------ 3750| 28| goto FAILED; 3751| 2.33k| if (negated) escape = (escape == ESC_P)? ESC_p : ESC_P; ------------------ | Branch (3751:17): [True: 195, False: 2.13k] | Branch (3751:35): [True: 0, False: 195] ------------------ 3752| 2.33k| *parsed_pattern++ = META_ESCAPE + escape; ------------------ | | 236| 2.33k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 3753| 2.33k| *parsed_pattern++ = (ptype << 16) | pdata; 3754| 2.33k| } 3755| |#else 3756| | errorcode = ERR45; 3757| | goto FAILED; 3758| |#endif 3759| 0| break; /* End \P and \p */ 3760| | 3761| 10| default: /* All others are not allowed in a class */ ------------------ | Branch (3761:11): [True: 10, False: 15.3k] ------------------ 3762| 10| errorcode = ERR7; 3763| 10| ptr--; 3764| 10| goto FAILED; 3765| 15.3k| } 3766| | 3767| | /* Perl gives a warning unless a following hyphen is the last character 3768| | in the class. PCRE throws an error. */ 3769| | 3770| 15.2k| if (ptr < ptrend - 1 && *ptr == CHAR_MINUS && ------------------ | | 995| 29.8k|#define CHAR_MINUS '\055' ------------------ | Branch (3770:13): [True: 14.6k, False: 679] | Branch (3770:33): [True: 214, False: 14.3k] ------------------ 3771| 15.2k| ptr[1] != CHAR_RIGHT_SQUARE_BRACKET) ------------------ | | 1043| 214|#define CHAR_RIGHT_SQUARE_BRACKET '\135' ------------------ | Branch (3771:13): [True: 10, False: 204] ------------------ 3772| 10| { 3773| 10| errorcode = ERR50; 3774| 10| goto FAILED; 3775| 10| } 3776| 15.2k| } 3777| | 3778| | /* Proceed to next thing in the class. */ 3779| | 3780| 5.22M| CLASS_CONTINUE: 3781| 5.22M| if (ptr >= ptrend) ------------------ | Branch (3781:11): [True: 1.31k, False: 5.21M] ------------------ 3782| 1.31k| { 3783| 1.31k| errorcode = ERR6; /* Missing terminating ']' */ 3784| 1.31k| goto FAILED; 3785| 1.31k| } 3786| 5.21M| GETCHARINCTEST(c, ptr); ------------------ | | 323| 5.21M| c = *eptr++; \ | | 324| 5.21M| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.52k| { \ | | | | 289| 1.52k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 757, False: 770] | | | | ------------------ | | | | 290| 1.52k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.52k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 444, False: 326] | | | | ------------------ | | | | 292| 770| { \ | | | | 293| 444| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 444| eptr += 2; \ | | | | 295| 444| } \ | | | | 296| 770| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 326, False: 0] | | | | ------------------ | | | | 297| 326| { \ | | | | 298| 326| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 326| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 326| eptr += 3; \ | | | | 301| 326| } \ | | | | 302| 326| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.52k| } | | ------------------ | | | Branch (324:7): [True: 26.9k, False: 5.19M] | | | Branch (324:14): [True: 1.52k, False: 25.3k] | | ------------------ ------------------ 3787| 5.21M| if (c == CHAR_RIGHT_SQUARE_BRACKET && !inescq) break; ------------------ | | 1043| 10.4M|#define CHAR_RIGHT_SQUARE_BRACKET '\135' ------------------ | Branch (3787:11): [True: 194k, False: 5.02M] | Branch (3787:45): [True: 194k, False: 202] ------------------ 3788| 5.21M| } /* End of class-processing loop */ 3789| | 3790| | /* -] at the end of a class is a literal '-' */ 3791| | 3792| 194k| if (class_range_state == RANGE_STARTED) ------------------ | Branch (3792:9): [True: 394, False: 193k] ------------------ 3793| 394| { 3794| 394| parsed_pattern[-1] = CHAR_MINUS; ------------------ | | 995| 394|#define CHAR_MINUS '\055' ------------------ 3795| 394| class_range_state = RANGE_NO; 3796| 394| } 3797| | 3798| 194k| *parsed_pattern++ = META_CLASS_END; ------------------ | | 225| 194k|#define META_CLASS_END 0x800d0000u /* end of non-empty class */ ------------------ 3799| 194k| break; /* End of character class */ 3800| | 3801| | 3802| | /* ---- Opening parenthesis ---- */ 3803| | 3804| 2.55M| case CHAR_LEFT_PARENTHESIS: ------------------ | | 990| 2.55M|#define CHAR_LEFT_PARENTHESIS '\050' ------------------ | Branch (3804:5): [True: 2.55M, False: 12.0M] ------------------ 3805| 2.55M| if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS; ------------------ | Branch (3805:9): [True: 67, False: 2.55M] ------------------ 3806| | 3807| | /* If ( is not followed by ? it is either a capture or a special verb or an 3808| | alpha assertion or a positive non-atomic lookahead. */ 3809| | 3810| 2.55M| if (*ptr != CHAR_QUESTION_MARK) ------------------ | | 1013| 2.55M|#define CHAR_QUESTION_MARK '\077' ------------------ | Branch (3810:9): [True: 2.15M, False: 401k] ------------------ 3811| 2.15M| { 3812| 2.15M| const char *vn; 3813| | 3814| | /* Handle capturing brackets (or non-capturing if auto-capture is turned 3815| | off). */ 3816| | 3817| 2.15M| if (*ptr != CHAR_ASTERISK) ------------------ | | 992| 2.15M|#define CHAR_ASTERISK '\052' ------------------ | Branch (3817:11): [True: 2.13M, False: 17.4k] ------------------ 3818| 2.13M| { 3819| 2.13M| nest_depth++; 3820| 2.13M| if ((options & PCRE2_NO_AUTO_CAPTURE) == 0) ------------------ | | 132| 2.13M|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ ------------------ | Branch (3820:13): [True: 2.11M, False: 17.8k] ------------------ 3821| 2.11M| { 3822| 2.11M| if (cb->bracount >= MAX_GROUP_NUMBER) ------------------ | | 147| 2.11M|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (3822:15): [True: 3, False: 2.11M] ------------------ 3823| 3| { 3824| 3| errorcode = ERR97; 3825| 3| goto FAILED; 3826| 3| } 3827| 2.11M| cb->bracount++; 3828| 2.11M| *parsed_pattern++ = META_CAPTURE | cb->bracount; ------------------ | | 220| 2.11M|#define META_CAPTURE 0x80080000u /* Capturing parenthesis */ ------------------ 3829| 2.11M| } 3830| 17.8k| else *parsed_pattern++ = META_NOCAPTURE; ------------------ | | 238| 17.8k|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ 3831| 2.13M| } 3832| | 3833| | /* Do nothing for (* followed by end of pattern or ) so it gives a "bad 3834| | quantifier" error rather than "(*MARK) must have an argument". */ 3835| | 3836| 17.4k| else if (ptrend - ptr <= 1 || (c = ptr[1]) == CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 17.4k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (3836:16): [True: 11, False: 17.4k] | Branch (3836:37): [True: 5, False: 17.4k] ------------------ 3837| 16| break; 3838| | 3839| | /* Handle "alpha assertions" such as (*pla:...). Most of these are 3840| | synonyms for the historical symbolic assertions, but the script run and 3841| | non-atomic lookaround ones are new. They are distinguished by starting 3842| | with a lower case letter. Checking both ends of the alphabet makes this 3843| | work in all character codes. */ 3844| | 3845| 17.4k| else if (CHMAX_255(c) && (cb->ctypes[c] & ctype_lcletter) != 0) ------------------ | | 217| 34.8k|#define CHMAX_255(c) ((c) <= 255u) | | ------------------ | | | Branch (217:22): [True: 17.4k, False: 0] | | ------------------ ------------------ else if (CHMAX_255(c) && (cb->ctypes[c] & ctype_lcletter) != 0) ------------------ | | 581| 17.4k|#define ctype_lcletter 0x04 ------------------ | Branch (3845:32): [True: 3.63k, False: 13.7k] ------------------ 3846| 3.63k| { 3847| 3.63k| uint32_t meta; 3848| | 3849| 3.63k| vn = alasnames; 3850| 3.63k| if (!read_name(&ptr, ptrend, utf, 0, &offset, &name, &namelen, ------------------ | Branch (3850:13): [True: 3, False: 3.63k] ------------------ 3851| 3.63k| &errorcode, cb)) goto FAILED; 3852| 3.63k| if (ptr >= ptrend || *ptr != CHAR_COLON) ------------------ | | 1008| 3.61k|#define CHAR_COLON '\072' ------------------ | Branch (3852:13): [True: 13, False: 3.61k] | Branch (3852:30): [True: 9, False: 3.60k] ------------------ 3853| 22| { 3854| 22| errorcode = ERR95; /* Malformed */ 3855| 22| goto FAILED; 3856| 22| } 3857| | 3858| | /* Scan the table of alpha assertion names */ 3859| | 3860| 34.7k| for (i = 0; i < alascount; i++) ------------------ | Branch (3860:21): [True: 34.7k, False: 14] ------------------ 3861| 34.7k| { 3862| 34.7k| if (namelen == alasmeta[i].len && ------------------ | Branch (3862:15): [True: 8.00k, False: 26.7k] ------------------ 3863| 34.7k| PRIV(strncmp_c8)(name, vn, namelen) == 0) ------------------ | | 177| 8.00k|#define PRIV(name) _pcre2_##name ------------------ | Branch (3863:15): [True: 3.59k, False: 4.40k] ------------------ 3864| 3.59k| break; 3865| 31.1k| vn += alasmeta[i].len + 1; 3866| 31.1k| } 3867| | 3868| 3.60k| if (i >= alascount) ------------------ | Branch (3868:13): [True: 14, False: 3.59k] ------------------ 3869| 14| { 3870| 14| errorcode = ERR95; /* Alpha assertion not recognized */ 3871| 14| goto FAILED; 3872| 14| } 3873| | 3874| | /* Check for expecting an assertion condition. If so, only atomic 3875| | lookaround assertions are valid. */ 3876| | 3877| 3.59k| meta = alasmeta[i].meta; 3878| 3.59k| if (prev_expect_cond_assert > 0 && ------------------ | Branch (3878:13): [True: 213, False: 3.38k] ------------------ 3879| 3.59k| (meta < META_LOOKAHEAD || meta > META_LOOKBEHINDNOT)) ------------------ | | 251| 426|#define META_LOOKAHEAD 0x80230000u /* (?= */ ------------------ (meta < META_LOOKAHEAD || meta > META_LOOKBEHINDNOT)) ------------------ | | 254| 210|#define META_LOOKBEHINDNOT 0x80260000u /* (?start_workspace); ------------------ | Branch (3928:17): [True: 256, False: 385] ------------------ 3929| 385| else if (++top_nest >= end_nests) ------------------ | Branch (3929:22): [True: 0, False: 385] ------------------ 3930| 0| { 3931| 0| errorcode = ERR84; 3932| 0| goto FAILED; 3933| 0| } 3934| 641| top_nest->nest_depth = nest_depth; 3935| 641| top_nest->flags = NSF_ATOMICSR; ------------------ | | 2653| 641|#define NSF_ATOMICSR 0x0004u ------------------ 3936| 641| top_nest->options = options & PARSE_TRACKED_OPTIONS; ------------------ | | 2660| 641|#define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 122| 641|#define PCRE2_CASELESS 0x00000008u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 124| 641|#define PCRE2_DOTALL 0x00000020u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 125| 641|#define PCRE2_DUPNAMES 0x00000040u /* C */ | | ------------------ | | 2661| 641| PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 126| 641|#define PCRE2_EXTENDED 0x00000080u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 143| 641|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 129| 641|#define PCRE2_MULTILINE 0x00000400u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 132| 641|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ | | ------------------ | | 2662| 641| PCRE2_UNGREEDY) | | ------------------ | | | | 137| 641|#define PCRE2_UNGREEDY 0x00040000u /* C */ | | ------------------ ------------------ 3937| 641| top_nest->xoptions = xoptions & PARSE_TRACKED_EXTRA_OPTIONS; ------------------ | | 2664| 641|#define PARSE_TRACKED_EXTRA_OPTIONS (PCRE2_EXTRA_CASELESS_RESTRICT| \ | | ------------------ | | | | 156| 641|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ | | ------------------ | | 2665| 641| PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 157| 641|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 158| 641|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 159| 641|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ | | ------------------ | | 2666| 641| PCRE2_EXTRA_ASCII_POSIX) | | ------------------ | | | | 160| 641|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ | | ------------------ ------------------ 3938| 641| } 3939| 2.03k| break; 3940| |#else /* SUPPORT_UNICODE */ 3941| | errorcode = ERR96; 3942| | goto FAILED; 3943| |#endif 3944| 3.58k| } 3945| 3.58k| } 3946| | 3947| | 3948| | /* ---- Handle (*VERB) and (*VERB:NAME) ---- */ 3949| | 3950| 13.7k| else 3951| 13.7k| { 3952| 13.7k| vn = verbnames; 3953| 13.7k| if (!read_name(&ptr, ptrend, utf, 0, &offset, &name, &namelen, ------------------ | Branch (3953:13): [True: 5, False: 13.7k] ------------------ 3954| 13.7k| &errorcode, cb)) goto FAILED; 3955| 13.7k| if (ptr >= ptrend || (*ptr != CHAR_COLON && ------------------ | | 1008| 27.5k|#define CHAR_COLON '\072' ------------------ | Branch (3955:13): [True: 17, False: 13.7k] | Branch (3955:31): [True: 8.27k, False: 5.48k] ------------------ 3956| 13.7k| *ptr != CHAR_RIGHT_PARENTHESIS)) ------------------ | | 991| 8.27k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (3956:31): [True: 42, False: 8.23k] ------------------ 3957| 59| { 3958| 59| errorcode = ERR60; /* Malformed */ 3959| 59| goto FAILED; 3960| 59| } 3961| | 3962| | /* Scan the table of verb names */ 3963| | 3964| 89.9k| for (i = 0; i < verbcount; i++) ------------------ | Branch (3964:21): [True: 89.8k, False: 38] ------------------ 3965| 89.8k| { 3966| 89.8k| if (namelen == verbs[i].len && ------------------ | Branch (3966:15): [True: 26.6k, False: 63.1k] ------------------ 3967| 89.8k| PRIV(strncmp_c8)(name, vn, namelen) == 0) ------------------ | | 177| 26.6k|#define PRIV(name) _pcre2_##name ------------------ | Branch (3967:15): [True: 13.6k, False: 13.0k] ------------------ 3968| 13.6k| break; 3969| 76.2k| vn += verbs[i].len + 1; 3970| 76.2k| } 3971| | 3972| 13.7k| if (i >= verbcount) ------------------ | Branch (3972:13): [True: 38, False: 13.6k] ------------------ 3973| 38| { 3974| 38| errorcode = ERR60; /* Verb not recognized */ 3975| 38| goto FAILED; 3976| 38| } 3977| | 3978| | /* An empty argument is treated as no argument. */ 3979| | 3980| 13.6k| if (*ptr == CHAR_COLON && ptr + 1 < ptrend && ------------------ | | 1008| 27.3k|#define CHAR_COLON '\072' ------------------ | Branch (3980:13): [True: 5.48k, False: 8.19k] | Branch (3980:35): [True: 5.46k, False: 19] ------------------ 3981| 13.6k| ptr[1] == CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 5.46k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (3981:14): [True: 198, False: 5.27k] ------------------ 3982| 198| ptr++; /* Advance to the closing parens */ 3983| | 3984| | /* Check for mandatory non-empty argument; this is (*MARK) */ 3985| | 3986| 13.6k| if (verbs[i].has_arg > 0 && *ptr != CHAR_COLON) ------------------ | | 1008| 1.11k|#define CHAR_COLON '\072' ------------------ | Branch (3986:13): [True: 1.11k, False: 12.5k] | Branch (3986:37): [True: 11, False: 1.10k] ------------------ 3987| 11| { 3988| 11| errorcode = ERR66; 3989| 11| goto FAILED; 3990| 11| } 3991| | 3992| | /* Remember where this verb, possibly with a preceding (*MARK), starts, 3993| | for handling quantified (*ACCEPT). */ 3994| | 3995| 13.6k| verbstartptr = parsed_pattern; 3996| 13.6k| okquantifier = (verbs[i].meta == META_ACCEPT); ------------------ | | 266| 13.6k|#define META_ACCEPT 0x802a0000u /* (*ACCEPT) */ ------------------ 3997| | 3998| | /* It appears that Perl allows any characters whatsoever, other than a 3999| | closing parenthesis, to appear in arguments ("names"), so we no longer 4000| | insist on letters, digits, and underscores. Perl does not, however, do 4001| | any interpretation within arguments, and has no means of including a 4002| | closing parenthesis. PCRE supports escape processing but only when it 4003| | is requested by an option. We set inverbname TRUE here, and let the 4004| | main loop take care of this so that escape and \x processing is done by 4005| | the main code above. */ 4006| | 4007| 13.6k| if (*ptr++ == CHAR_COLON) /* Skip past : or ) */ ------------------ | | 1008| 13.6k|#define CHAR_COLON '\072' ------------------ | Branch (4007:13): [True: 5.28k, False: 8.38k] ------------------ 4008| 5.28k| { 4009| | /* Some optional arguments can be treated as a preceding (*MARK) */ 4010| | 4011| 5.28k| if (verbs[i].has_arg < 0) ------------------ | Branch (4011:15): [True: 244, False: 5.04k] ------------------ 4012| 244| { 4013| 244| add_after_mark = verbs[i].meta; 4014| 244| *parsed_pattern++ = META_MARK; ------------------ | | 265| 244|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ 4015| 244| } 4016| | 4017| | /* The remaining verbs with arguments (except *MARK) need a different 4018| | opcode. */ 4019| | 4020| 5.04k| else 4021| 5.04k| { 4022| 5.04k| *parsed_pattern++ = verbs[i].meta + 4023| 5.04k| ((verbs[i].meta != META_MARK)? 0x00010000u:0); ------------------ | | 265| 5.04k|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ | Branch (4023:16): [True: 3.93k, False: 1.10k] ------------------ 4024| 5.04k| } 4025| | 4026| | /* Set up for reading the name in the main loop. */ 4027| | 4028| 5.28k| verblengthptr = parsed_pattern++; 4029| 5.28k| verbnamestart = ptr; 4030| 5.28k| inverbname = TRUE; ------------------ | | 70| 5.28k|#define TRUE 1 ------------------ 4031| 5.28k| } 4032| 8.38k| else /* No verb "name" argument */ 4033| 8.38k| { 4034| 8.38k| *parsed_pattern++ = verbs[i].meta; 4035| 8.38k| } 4036| 13.6k| } /* End of (*VERB) handling */ 4037| 2.15M| break; /* Done with this parenthesis */ 4038| 2.15M| } /* End of groups that don't start with (? */ 4039| | 4040| | 4041| | /* ---- Items starting (? ---- */ 4042| | 4043| | /* The type of item is determined by what follows (?. Handle (?| and option 4044| | changes under "default" because both need a new block on the nest stack. 4045| | Comments starting with (?# are handled above. Note that there is some 4046| | ambiguity about the sequence (?- because if a digit follows it's a relative 4047| | recursion or subroutine call whereas otherwise it's an option unsetting. */ 4048| | 4049| 401k| if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS; ------------------ | Branch (4049:9): [True: 18, False: 401k] ------------------ 4050| | 4051| 401k| switch(*ptr) 4052| 401k| { 4053| 17.3k| default: ------------------ | Branch (4053:7): [True: 17.3k, False: 384k] ------------------ 4054| 17.3k| if (*ptr == CHAR_MINUS && ptrend - ptr > 1 && IS_DIGIT(ptr[1])) ------------------ | | 995| 34.6k|#define CHAR_MINUS '\055' ------------------ if (*ptr == CHAR_MINUS && ptrend - ptr > 1 && IS_DIGIT(ptr[1])) ------------------ | | 408| 796|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 1.59k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 594|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 594, False: 202] | | | Branch (408:39): [True: 227, False: 367] | | ------------------ ------------------ | Branch (4054:11): [True: 801, False: 16.5k] | Branch (4054:33): [True: 796, False: 5] ------------------ 4055| 227| goto RECURSION_BYNUMBER; /* The + case is handled by CHAR_PLUS */ 4056| | 4057| | /* We now have either (?| or a (possibly empty) option setting, 4058| | optionally followed by a non-capturing group. */ 4059| | 4060| 17.1k| nest_depth++; 4061| 17.1k| if (top_nest == NULL) top_nest = (nest_save *)(cb->start_workspace); ------------------ | Branch (4061:11): [True: 6.67k, False: 10.4k] ------------------ 4062| 10.4k| else if (++top_nest >= end_nests) ------------------ | Branch (4062:16): [True: 0, False: 10.4k] ------------------ 4063| 0| { 4064| 0| errorcode = ERR84; 4065| 0| goto FAILED; 4066| 0| } 4067| 17.1k| top_nest->nest_depth = nest_depth; 4068| 17.1k| top_nest->flags = 0; 4069| 17.1k| top_nest->options = options & PARSE_TRACKED_OPTIONS; ------------------ | | 2660| 17.1k|#define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 122| 17.1k|#define PCRE2_CASELESS 0x00000008u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 124| 17.1k|#define PCRE2_DOTALL 0x00000020u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 125| 17.1k|#define PCRE2_DUPNAMES 0x00000040u /* C */ | | ------------------ | | 2661| 17.1k| PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 126| 17.1k|#define PCRE2_EXTENDED 0x00000080u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 143| 17.1k|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 129| 17.1k|#define PCRE2_MULTILINE 0x00000400u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 132| 17.1k|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ | | ------------------ | | 2662| 17.1k| PCRE2_UNGREEDY) | | ------------------ | | | | 137| 17.1k|#define PCRE2_UNGREEDY 0x00040000u /* C */ | | ------------------ ------------------ 4070| 17.1k| top_nest->xoptions = xoptions & PARSE_TRACKED_EXTRA_OPTIONS; ------------------ | | 2664| 17.1k|#define PARSE_TRACKED_EXTRA_OPTIONS (PCRE2_EXTRA_CASELESS_RESTRICT| \ | | ------------------ | | | | 156| 17.1k|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ | | ------------------ | | 2665| 17.1k| PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 157| 17.1k|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 158| 17.1k|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 159| 17.1k|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ | | ------------------ | | 2666| 17.1k| PCRE2_EXTRA_ASCII_POSIX) | | ------------------ | | | | 160| 17.1k|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ | | ------------------ ------------------ 4071| | 4072| | /* Start of non-capturing group that resets the capture count for each 4073| | branch. */ 4074| | 4075| 17.1k| if (*ptr == CHAR_VERTICAL_LINE) ------------------ | | 1074| 17.1k|#define CHAR_VERTICAL_LINE '\174' ------------------ | Branch (4075:11): [True: 5.54k, False: 11.5k] ------------------ 4076| 5.54k| { 4077| 5.54k| top_nest->reset_group = (uint16_t)cb->bracount; 4078| 5.54k| top_nest->max_group = (uint16_t)cb->bracount; 4079| 5.54k| top_nest->flags |= NSF_RESET; ------------------ | | 2651| 5.54k|#define NSF_RESET 0x0001u ------------------ 4080| 5.54k| cb->external_flags |= PCRE2_DUPCAPUSED; ------------------ | | 528| 5.54k|#define PCRE2_DUPCAPUSED 0x00200000 /* contains (?| */ ------------------ 4081| 5.54k| *parsed_pattern++ = META_NOCAPTURE; ------------------ | | 238| 5.54k|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ 4082| 5.54k| ptr++; 4083| 5.54k| } 4084| | 4085| | /* Scan for options imnrsxJU to be set or unset. */ 4086| | 4087| 11.5k| else 4088| 11.5k| { 4089| 11.5k| BOOL hyphenok = TRUE; ------------------ | | 70| 11.5k|#define TRUE 1 ------------------ 4090| 11.5k| uint32_t oldoptions = options; 4091| 11.5k| uint32_t oldxoptions = xoptions; 4092| | 4093| 11.5k| top_nest->reset_group = 0; 4094| 11.5k| top_nest->max_group = 0; 4095| 11.5k| set = unset = 0; 4096| 11.5k| optset = &set; 4097| 11.5k| xset = xunset = 0; 4098| 11.5k| xoptset = &xset; 4099| | 4100| | /* ^ at the start unsets irmnsx and disables the subsequent use of - */ 4101| | 4102| 11.5k| if (ptr < ptrend && *ptr == CHAR_CIRCUMFLEX_ACCENT) ------------------ | | 1044| 11.5k|#define CHAR_CIRCUMFLEX_ACCENT '\136' ------------------ | Branch (4102:13): [True: 11.5k, False: 0] | Branch (4102:29): [True: 204, False: 11.3k] ------------------ 4103| 204| { 4104| 204| options &= ~(PCRE2_CASELESS|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| ------------------ | | 122| 204|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ options &= ~(PCRE2_CASELESS|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| ------------------ | | 129| 204|#define PCRE2_MULTILINE 0x00000400u /* C */ ------------------ options &= ~(PCRE2_CASELESS|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| ------------------ | | 132| 204|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ ------------------ 4105| 204| PCRE2_DOTALL|PCRE2_EXTENDED|PCRE2_EXTENDED_MORE); ------------------ | | 124| 204|#define PCRE2_DOTALL 0x00000020u /* C */ ------------------ PCRE2_DOTALL|PCRE2_EXTENDED|PCRE2_EXTENDED_MORE); ------------------ | | 126| 204|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ PCRE2_DOTALL|PCRE2_EXTENDED|PCRE2_EXTENDED_MORE); ------------------ | | 143| 204|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ ------------------ 4106| 204| xoptions &= ~(PCRE2_EXTRA_CASELESS_RESTRICT); ------------------ | | 156| 204|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ ------------------ 4107| 204| hyphenok = FALSE; ------------------ | | 69| 204|#define FALSE 0 ------------------ 4108| 204| ptr++; 4109| 204| } 4110| | 4111| 22.0k| while (ptr < ptrend && *ptr != CHAR_RIGHT_PARENTHESIS && ------------------ | | 991| 43.9k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4111:16): [True: 21.8k, False: 219] | Branch (4111:32): [True: 12.1k, False: 9.72k] ------------------ 4112| 22.0k| *ptr != CHAR_COLON) ------------------ | | 1008| 12.1k|#define CHAR_COLON '\072' ------------------ | Branch (4112:32): [True: 10.6k, False: 1.52k] ------------------ 4113| 10.6k| { 4114| 10.6k| switch (*ptr++) 4115| 10.6k| { 4116| 615| case CHAR_MINUS: ------------------ | | 995| 615|#define CHAR_MINUS '\055' ------------------ | Branch (4116:13): [True: 615, False: 10.0k] ------------------ 4117| 615| if (!hyphenok) ------------------ | Branch (4117:17): [True: 7, False: 608] ------------------ 4118| 7| { 4119| 7| errorcode = ERR94; 4120| 7| ptr--; /* Correct the offset */ 4121| 7| goto FAILED; 4122| 7| } 4123| 608| optset = &unset; 4124| 608| xoptset = &xunset; 4125| 608| hyphenok = FALSE; ------------------ | | 69| 608|#define FALSE 0 ------------------ 4126| 608| break; 4127| | 4128| | /* There are some two-character sequences that start with 'a'. */ 4129| | 4130| 990| case CHAR_a: ------------------ | | 1047| 990|#define CHAR_a '\141' ------------------ | Branch (4130:13): [True: 990, False: 9.62k] ------------------ 4131| 990| if (ptr < ptrend) ------------------ | Branch (4131:17): [True: 983, False: 7] ------------------ 4132| 983| { 4133| 983| if (*ptr == CHAR_D) ------------------ | | 1018| 983|#define CHAR_D '\104' ------------------ | Branch (4133:19): [True: 194, False: 789] ------------------ 4134| 194| { 4135| 194| *xoptset |= PCRE2_EXTRA_ASCII_BSD; ------------------ | | 157| 194|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ ------------------ 4136| 194| ptr++; 4137| 194| break; 4138| 194| } 4139| 789| if (*ptr == CHAR_P) ------------------ | | 1030| 789|#define CHAR_P '\120' ------------------ | Branch (4139:19): [True: 66, False: 723] ------------------ 4140| 66| { 4141| 66| *xoptset |= PCRE2_EXTRA_ASCII_POSIX; ------------------ | | 160| 66|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ ------------------ 4142| 66| ptr++; 4143| 66| break; 4144| 66| } 4145| 723| if (*ptr == CHAR_S) ------------------ | | 1033| 723|#define CHAR_S '\123' ------------------ | Branch (4145:19): [True: 196, False: 527] ------------------ 4146| 196| { 4147| 196| *xoptset |= PCRE2_EXTRA_ASCII_BSS; ------------------ | | 158| 196|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ ------------------ 4148| 196| ptr++; 4149| 196| break; 4150| 196| } 4151| 527| if (*ptr == CHAR_W) ------------------ | | 1037| 527|#define CHAR_W '\127' ------------------ | Branch (4151:19): [True: 196, False: 331] ------------------ 4152| 196| { 4153| 196| *xoptset |= PCRE2_EXTRA_ASCII_BSW; ------------------ | | 159| 196|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ ------------------ 4154| 196| ptr++; 4155| 196| break; 4156| 196| } 4157| 527| } 4158| 338| *xoptset |= PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS| ------------------ | | 157| 338|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ ------------------ *xoptset |= PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS| ------------------ | | 158| 338|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ ------------------ 4159| 338| PCRE2_EXTRA_ASCII_BSW|PCRE2_EXTRA_ASCII_POSIX; ------------------ | | 159| 338|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ ------------------ PCRE2_EXTRA_ASCII_BSW|PCRE2_EXTRA_ASCII_POSIX; ------------------ | | 160| 338|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ ------------------ 4160| 338| break; 4161| | 4162| 5.17k| case CHAR_J: /* Record that it changed in the external options */ ------------------ | | 1024| 5.17k|#define CHAR_J '\112' ------------------ | Branch (4162:13): [True: 5.17k, False: 5.44k] ------------------ 4163| 5.17k| *optset |= PCRE2_DUPNAMES; ------------------ | | 125| 5.17k|#define PCRE2_DUPNAMES 0x00000040u /* C */ ------------------ 4164| 5.17k| cb->external_flags |= PCRE2_JCHANGED; ------------------ | | 517| 5.17k|#define PCRE2_JCHANGED 0x00000400 /* j option used in pattern */ ------------------ 4165| 5.17k| break; 4166| | 4167| 714| case CHAR_i: *optset |= PCRE2_CASELESS; break; ------------------ | | 1055| 714|#define CHAR_i '\151' ------------------ case CHAR_i: *optset |= PCRE2_CASELESS; break; ------------------ | | 122| 714|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (4167:13): [True: 714, False: 9.90k] ------------------ 4168| 226| case CHAR_m: *optset |= PCRE2_MULTILINE; break; ------------------ | | 1059| 226|#define CHAR_m '\155' ------------------ case CHAR_m: *optset |= PCRE2_MULTILINE; break; ------------------ | | 129| 226|#define PCRE2_MULTILINE 0x00000400u /* C */ ------------------ | Branch (4168:13): [True: 226, False: 10.3k] ------------------ 4169| 264| case CHAR_n: *optset |= PCRE2_NO_AUTO_CAPTURE; break; ------------------ | | 1060| 264|#define CHAR_n '\156' ------------------ case CHAR_n: *optset |= PCRE2_NO_AUTO_CAPTURE; break; ------------------ | | 132| 264|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ ------------------ | Branch (4169:13): [True: 264, False: 10.3k] ------------------ 4170| 569| case CHAR_r: *xoptset|= PCRE2_EXTRA_CASELESS_RESTRICT; break; ------------------ | | 1064| 569|#define CHAR_r '\162' ------------------ case CHAR_r: *xoptset|= PCRE2_EXTRA_CASELESS_RESTRICT; break; ------------------ | | 156| 569|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ ------------------ | Branch (4170:13): [True: 569, False: 10.0k] ------------------ 4171| 399| case CHAR_s: *optset |= PCRE2_DOTALL; break; ------------------ | | 1065| 399|#define CHAR_s '\163' ------------------ case CHAR_s: *optset |= PCRE2_DOTALL; break; ------------------ | | 124| 399|#define PCRE2_DOTALL 0x00000020u /* C */ ------------------ | Branch (4171:13): [True: 399, False: 10.2k] ------------------ 4172| 202| case CHAR_U: *optset |= PCRE2_UNGREEDY; break; ------------------ | | 1035| 202|#define CHAR_U '\125' ------------------ case CHAR_U: *optset |= PCRE2_UNGREEDY; break; ------------------ | | 137| 202|#define PCRE2_UNGREEDY 0x00040000u /* C */ ------------------ | Branch (4172:13): [True: 202, False: 10.4k] ------------------ 4173| | 4174| | /* If x appears twice it sets the extended extended option. */ 4175| | 4176| 1.38k| case CHAR_x: ------------------ | | 1070| 1.38k|#define CHAR_x '\170' ------------------ | Branch (4176:13): [True: 1.38k, False: 9.23k] ------------------ 4177| 1.38k| *optset |= PCRE2_EXTENDED; ------------------ | | 126| 1.38k|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ 4178| 1.38k| if (ptr < ptrend && *ptr == CHAR_x) ------------------ | | 1070| 1.35k|#define CHAR_x '\170' ------------------ | Branch (4178:17): [True: 1.35k, False: 25] | Branch (4178:33): [True: 480, False: 876] ------------------ 4179| 480| { 4180| 480| *optset |= PCRE2_EXTENDED_MORE; ------------------ | | 143| 480|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ ------------------ 4181| 480| ptr++; 4182| 480| } 4183| 1.38k| break; 4184| | 4185| 89| default: ------------------ | Branch (4185:13): [True: 89, False: 10.5k] ------------------ 4186| 89| errorcode = ERR11; 4187| 89| ptr--; /* Correct the offset */ 4188| 89| goto FAILED; 4189| 10.6k| } 4190| 10.6k| } 4191| | 4192| | /* If we are setting extended without extended-more, ensure that any 4193| | existing extended-more gets unset. Also, unsetting extended must also 4194| | unset extended-more. */ 4195| | 4196| 11.4k| if ((set & (PCRE2_EXTENDED|PCRE2_EXTENDED_MORE)) == PCRE2_EXTENDED || ------------------ | | 126| 11.4k|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ if ((set & (PCRE2_EXTENDED|PCRE2_EXTENDED_MORE)) == PCRE2_EXTENDED || ------------------ | | 143| 11.4k|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ ------------------ if ((set & (PCRE2_EXTENDED|PCRE2_EXTENDED_MORE)) == PCRE2_EXTENDED || ------------------ | | 126| 22.9k|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ | Branch (4196:13): [True: 551, False: 10.9k] ------------------ 4197| 11.4k| (unset & PCRE2_EXTENDED) != 0) ------------------ | | 126| 10.9k|#define PCRE2_EXTENDED 0x00000080u /* C */ ------------------ | Branch (4197:13): [True: 319, False: 10.5k] ------------------ 4198| 870| unset |= PCRE2_EXTENDED_MORE; ------------------ | | 143| 870|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ ------------------ 4199| | 4200| 11.4k| options = (options | set) & (~unset); 4201| 11.4k| xoptions = (xoptions | xset) & (~xunset); 4202| | 4203| | /* If the options ended with ')' this is not the start of a nested 4204| | group with option changes, so the options change at this level. 4205| | In this case, if the previous level set up a nest block, discard the 4206| | one we have just created. Otherwise adjust it for the previous level. 4207| | If the options ended with ':' we are starting a non-capturing group, 4208| | possibly with an options setting. */ 4209| | 4210| 11.4k| if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS; ------------------ | Branch (4210:13): [True: 219, False: 11.2k] ------------------ 4211| 11.2k| if (*ptr++ == CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 11.2k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4211:13): [True: 9.72k, False: 1.52k] ------------------ 4212| 9.72k| { 4213| 9.72k| nest_depth--; /* This is not a nested group after all. */ 4214| 9.72k| if (top_nest > (nest_save *)(cb->start_workspace) && ------------------ | Branch (4214:15): [True: 7.77k, False: 1.95k] ------------------ 4215| 9.72k| (top_nest-1)->nest_depth == nest_depth) top_nest--; ------------------ | Branch (4215:15): [True: 6.26k, False: 1.50k] ------------------ 4216| 3.46k| else top_nest->nest_depth = nest_depth; 4217| 9.72k| } 4218| 1.52k| else *parsed_pattern++ = META_NOCAPTURE; ------------------ | | 238| 1.52k|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ 4219| | 4220| | /* If nothing changed, no need to record. */ 4221| | 4222| 11.2k| if (options != oldoptions || xoptions != oldxoptions) ------------------ | Branch (4222:13): [True: 1.66k, False: 9.58k] | Branch (4222:38): [True: 427, False: 9.15k] ------------------ 4223| 2.09k| { 4224| 2.09k| *parsed_pattern++ = META_OPTIONS; ------------------ | | 239| 2.09k|#define META_OPTIONS 0x801b0000u /* (?i) and friends */ ------------------ 4225| 2.09k| *parsed_pattern++ = options; 4226| 2.09k| *parsed_pattern++ = xoptions; 4227| 2.09k| } 4228| 11.2k| } /* End options processing */ 4229| 16.7k| break; /* End default case after (? */ 4230| | 4231| | 4232| | /* ---- Python syntax support ---- */ 4233| | 4234| 16.7k| case CHAR_P: ------------------ | | 1030| 483|#define CHAR_P '\120' ------------------ | Branch (4234:7): [True: 483, False: 401k] ------------------ 4235| 483| if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS; ------------------ | Branch (4235:11): [True: 3, False: 480] ------------------ 4236| | 4237| | /* (?P is the same as (?, which defines a named group. */ 4238| | 4239| 480| if (*ptr == CHAR_LESS_THAN_SIGN) ------------------ | | 1010| 480|#define CHAR_LESS_THAN_SIGN '\074' ------------------ | Branch (4239:11): [True: 194, False: 286] ------------------ 4240| 194| { 4241| 194| terminator = CHAR_GREATER_THAN_SIGN; ------------------ | | 1012| 194|#define CHAR_GREATER_THAN_SIGN '\076' ------------------ 4242| 194| goto DEFINE_NAME; 4243| 194| } 4244| | 4245| | /* (?P>name) is the same as (?&name), which is a recursion or subroutine 4246| | call. */ 4247| | 4248| 286| if (*ptr == CHAR_GREATER_THAN_SIGN) goto RECURSE_BY_NAME; ------------------ | | 1012| 286|#define CHAR_GREATER_THAN_SIGN '\076' ------------------ | Branch (4248:11): [True: 66, False: 220] ------------------ 4249| | 4250| | /* (?P=name) is the same as \k, a back reference by name. Anything 4251| | else after (?P is an error. */ 4252| | 4253| 220| if (*ptr != CHAR_EQUALS_SIGN) ------------------ | | 1011| 220|#define CHAR_EQUALS_SIGN '\075' ------------------ | Branch (4253:11): [True: 23, False: 197] ------------------ 4254| 23| { 4255| 23| errorcode = ERR41; 4256| 23| goto FAILED; 4257| 23| } 4258| 197| if (!read_name(&ptr, ptrend, utf, CHAR_RIGHT_PARENTHESIS, &offset, &name, ------------------ | | 991| 197|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4258:11): [True: 3, False: 194] ------------------ 4259| 197| &namelen, &errorcode, cb)) goto FAILED; 4260| 194| *parsed_pattern++ = META_BACKREF_BYNAME; ------------------ | | 216| 194|#define META_BACKREF_BYNAME 0x80040000u /* \k'name' */ ------------------ 4261| 194| *parsed_pattern++ = namelen; 4262| 194| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 194| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 4263| 194| okquantifier = TRUE; ------------------ | | 70| 194|#define TRUE 1 ------------------ 4264| 194| break; /* End of (?P processing */ 4265| | 4266| | 4267| | /* ---- Recursion/subroutine calls by number ---- */ 4268| | 4269| 2.34k| case CHAR_R: ------------------ | | 1032| 2.34k|#define CHAR_R '\122' ------------------ | Branch (4269:7): [True: 2.34k, False: 399k] ------------------ 4270| 2.34k| i = 0; /* (?R) == (?R0) */ 4271| 2.34k| ptr++; 4272| 2.34k| if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 2.33k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4272:11): [True: 3, False: 2.33k] | Branch (4272:28): [True: 3, False: 2.33k] ------------------ 4273| 6| { 4274| 6| errorcode = ERR58; 4275| 6| goto FAILED; 4276| 6| } 4277| 2.33k| goto SET_RECURSION; 4278| | 4279| | /* An item starting (?- followed by a digit comes here via the "default" 4280| | case because (?- followed by a non-digit is an options setting. */ 4281| | 4282| 12.1k| case CHAR_PLUS: ------------------ | | 993| 12.1k|#define CHAR_PLUS '\053' ------------------ | Branch (4282:7): [True: 12.1k, False: 389k] ------------------ 4283| 12.1k| if (ptrend - ptr < 2 || !IS_DIGIT(ptr[1])) ------------------ | | 408| 12.1k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 24.3k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 12.1k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 12.1k, False: 13] | | | Branch (408:39): [True: 12.1k, False: 13] | | ------------------ ------------------ | Branch (4283:11): [True: 3, False: 12.1k] ------------------ 4284| 29| { 4285| 29| errorcode = ERR29; /* Missing number */ 4286| 29| goto FAILED; 4287| 29| } 4288| | /* Fall through */ 4289| | 4290| 18.2k| case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: ------------------ | | 998| 13.4k|#define CHAR_0 '\060' ------------------ case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: ------------------ | | 999| 15.8k|#define CHAR_1 '\061' ------------------ case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: ------------------ | | 1000| 17.1k|#define CHAR_2 '\062' ------------------ case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: ------------------ | | 1001| 17.6k|#define CHAR_3 '\063' ------------------ case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: ------------------ | | 1002| 18.2k|#define CHAR_4 '\064' ------------------ | Branch (4290:7): [True: 1.36k, False: 400k] | Branch (4290:20): [True: 2.31k, False: 399k] | Branch (4290:33): [True: 1.31k, False: 400k] | Branch (4290:46): [True: 507, False: 401k] | Branch (4290:59): [True: 576, False: 400k] ------------------ 4291| 19.2k| case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1003| 18.4k|#define CHAR_5 '\065' ------------------ case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1004| 18.6k|#define CHAR_6 '\066' ------------------ case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1005| 18.8k|#define CHAR_7 '\067' ------------------ case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1006| 19.0k|#define CHAR_8 '\070' ------------------ case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9: ------------------ | | 1007| 19.2k|#define CHAR_9 '\071' ------------------ | Branch (4291:7): [True: 239, False: 401k] | Branch (4291:20): [True: 222, False: 401k] | Branch (4291:33): [True: 207, False: 401k] | Branch (4291:46): [True: 211, False: 401k] | Branch (4291:59): [True: 209, False: 401k] ------------------ 4292| 19.5k| RECURSION_BYNUMBER: 4293| 19.5k| if (!read_number(&ptr, ptrend, ------------------ | Branch (4293:11): [True: 29, False: 19.4k] ------------------ 4294| 19.5k| (IS_DIGIT(*ptr))? -1:(int)(cb->bracount), /* + and - are relative */ ------------------ | | 408| 19.5k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 39.0k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 7.16k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 7.16k, False: 12.3k] | | | Branch (408:39): [True: 7.16k, False: 0] | | ------------------ ------------------ 4295| 19.5k| MAX_GROUP_NUMBER, ERR61, ------------------ | | 147| 19.5k|#define MAX_GROUP_NUMBER 65535u ------------------ 4296| 19.5k| &i, &errorcode)) goto FAILED; 4297| 19.4k| if (i < 0) /* NB (?0) is permitted */ ------------------ | Branch (4297:11): [True: 0, False: 19.4k] ------------------ 4298| 0| { 4299| 0| errorcode = ERR15; /* Unknown group */ 4300| 0| goto FAILED_BACK; 4301| 0| } 4302| 19.4k| if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 19.3k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4302:11): [True: 170, False: 19.3k] | Branch (4302:28): [True: 12, False: 19.3k] ------------------ 4303| 182| goto UNCLOSED_PARENTHESIS; 4304| | 4305| 21.8k| SET_RECURSION: 4306| 21.8k| *parsed_pattern++ = META_RECURSE | (uint32_t)i; ------------------ | | 244| 21.8k|#define META_RECURSE 0x80200000u /* Recursion */ ------------------ 4307| 21.8k| offset = (PCRE2_SIZE)(ptr - cb->start_pattern); 4308| 21.8k| ptr++; 4309| 21.8k| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 21.8k| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 4310| 21.8k| okquantifier = TRUE; ------------------ | | 70| 21.8k|#define TRUE 1 ------------------ 4311| 21.8k| break; /* End of recursive call by number handling */ 4312| | 4313| | 4314| | /* ---- Recursion/subroutine calls by name ---- */ 4315| | 4316| 337| case CHAR_AMPERSAND: ------------------ | | 988| 337|#define CHAR_AMPERSAND '\046' ------------------ | Branch (4316:7): [True: 337, False: 401k] ------------------ 4317| 403| RECURSE_BY_NAME: 4318| 403| if (!read_name(&ptr, ptrend, utf, CHAR_RIGHT_PARENTHESIS, &offset, &name, ------------------ | | 991| 403|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4318:11): [True: 52, False: 351] ------------------ 4319| 403| &namelen, &errorcode, cb)) goto FAILED; 4320| 351| *parsed_pattern++ = META_RECURSE_BYNAME; ------------------ | | 245| 351|#define META_RECURSE_BYNAME 0x80210000u /* (?&name) */ ------------------ 4321| 351| *parsed_pattern++ = namelen; 4322| 351| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 351| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 4323| 351| okquantifier = TRUE; ------------------ | | 70| 351|#define TRUE 1 ------------------ 4324| 351| break; 4325| | 4326| | /* ---- Callout with numerical or string argument ---- */ 4327| | 4328| 236k| case CHAR_C: ------------------ | | 1017| 236k|#define CHAR_C '\103' ------------------ | Branch (4328:7): [True: 236k, False: 164k] ------------------ 4329| 236k| if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS; ------------------ | Branch (4329:11): [True: 3, False: 236k] ------------------ 4330| | 4331| | /* If the previous item was a condition starting (?(? an assertion, 4332| | optionally preceded by a callout, is expected. This is checked later on, 4333| | during actual compilation. However we need to identify this kind of 4334| | assertion in this pass because it must not be qualified. The value of 4335| | expect_cond_assert is set to 2 after (?(? is processed. We decrement it 4336| | for a callout - still leaving a positive value that identifies the 4337| | assertion. Multiple callouts or any other items will make it zero or 4338| | less, which doesn't matter because they will cause an error later. */ 4339| | 4340| 236k| expect_cond_assert = prev_expect_cond_assert - 1; 4341| | 4342| | /* If previous_callout is not NULL, it means this follows a previous 4343| | callout. If it was a manual callout, do nothing; this means its "length 4344| | of next pattern item" field will remain zero. If it was an automatic 4345| | callout, abolish it. */ 4346| | 4347| 236k| if (previous_callout != NULL && (options & PCRE2_AUTO_CALLOUT) != 0 && ------------------ | | 121| 34.2k|#define PCRE2_AUTO_CALLOUT 0x00000004u /* C */ ------------------ | Branch (4347:11): [True: 34.2k, False: 202k] | Branch (4347:39): [True: 7.17k, False: 27.0k] ------------------ 4348| 236k| previous_callout == parsed_pattern - 4 && ------------------ | Branch (4348:11): [True: 6.93k, False: 235] ------------------ 4349| 236k| parsed_pattern[-1] == 255) ------------------ | Branch (4349:11): [True: 6.10k, False: 838] ------------------ 4350| 6.10k| parsed_pattern = previous_callout; 4351| | 4352| | /* Save for updating next pattern item length, and skip one item before 4353| | completing. */ 4354| | 4355| 236k| previous_callout = parsed_pattern; 4356| 236k| after_manual_callout = 1; 4357| | 4358| | /* Handle a string argument; specific delimiter is required. */ 4359| | 4360| 236k| if (*ptr != CHAR_RIGHT_PARENTHESIS && !IS_DIGIT(*ptr)) ------------------ | | 991| 473k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ if (*ptr != CHAR_RIGHT_PARENTHESIS && !IS_DIGIT(*ptr)) ------------------ | | 408| 3.12k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 6.25k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 2.39k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 2.39k, False: 736] | | | Branch (408:39): [True: 355, False: 2.03k] | | ------------------ ------------------ | Branch (4360:11): [True: 3.12k, False: 233k] ------------------ 4361| 2.77k| { 4362| 2.77k| PCRE2_SIZE calloutlength; ------------------ | | 477| 2.77k|#define PCRE2_SIZE size_t ------------------ 4363| 2.77k| PCRE2_SPTR startptr = ptr; ------------------ | | 814| 2.77k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 2.77k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 2.77k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 2.77k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4364| | 4365| 2.77k| delimiter = 0; 4366| 12.2k| for (i = 0; PRIV(callout_start_delims)[i] != 0; i++) ------------------ | | 177| 12.2k|#define PRIV(name) _pcre2_##name ------------------ | Branch (4366:21): [True: 12.1k, False: 38] ------------------ 4367| 12.1k| { 4368| 12.1k| if (*ptr == PRIV(callout_start_delims)[i]) ------------------ | | 177| 12.1k|#define PRIV(name) _pcre2_##name ------------------ | Branch (4368:15): [True: 2.73k, False: 9.45k] ------------------ 4369| 2.73k| { 4370| 2.73k| delimiter = PRIV(callout_end_delims)[i]; ------------------ | | 177| 2.73k|#define PRIV(name) _pcre2_##name ------------------ 4371| 2.73k| break; 4372| 2.73k| } 4373| 12.1k| } 4374| 2.77k| if (delimiter == 0) ------------------ | Branch (4374:13): [True: 38, False: 2.73k] ------------------ 4375| 38| { 4376| 38| errorcode = ERR82; 4377| 38| goto FAILED; 4378| 38| } 4379| | 4380| 2.73k| *parsed_pattern = META_CALLOUT_STRING; ------------------ | | 219| 2.73k|#define META_CALLOUT_STRING 0x80070000u /* (?C with string argument */ ------------------ 4381| 2.73k| parsed_pattern += 3; /* Skip pattern info */ 4382| | 4383| 2.73k| for (;;) 4384| 73.8k| { 4385| 73.8k| if (++ptr >= ptrend) ------------------ | Branch (4385:15): [True: 70, False: 73.8k] ------------------ 4386| 70| { 4387| 70| errorcode = ERR81; 4388| 70| ptr = startptr; /* To give a more useful message */ 4389| 70| goto FAILED; 4390| 70| } 4391| 73.8k| if (*ptr == delimiter && (++ptr >= ptrend || *ptr != delimiter)) ------------------ | Branch (4391:15): [True: 3.02k, False: 70.7k] | Branch (4391:37): [True: 25, False: 3.00k] | Branch (4391:56): [True: 2.64k, False: 359] ------------------ 4392| 2.66k| break; 4393| 73.8k| } 4394| | 4395| 2.66k| calloutlength = (PCRE2_SIZE)(ptr - startptr); 4396| 2.66k| if (calloutlength > UINT32_MAX) ------------------ | Branch (4396:13): [True: 0, False: 2.66k] ------------------ 4397| 0| { 4398| 0| errorcode = ERR72; 4399| 0| goto FAILED; 4400| 0| } 4401| 2.66k| *parsed_pattern++ = (uint32_t)calloutlength; 4402| 2.66k| offset = (PCRE2_SIZE)(startptr - cb->start_pattern); 4403| 2.66k| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 2.66k| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 4404| 2.66k| } 4405| | 4406| | /* Handle a callout with an optional numerical argument, which must be 4407| | less than or equal to 255. A missing argument gives 0. */ 4408| | 4409| 234k| else 4410| 234k| { 4411| 234k| int n = 0; 4412| 234k| *parsed_pattern = META_CALLOUT_NUMBER; /* Numerical callout */ ------------------ | | 218| 234k|#define META_CALLOUT_NUMBER 0x80060000u /* (?C with numerical argument */ ------------------ 4413| 234k| parsed_pattern += 3; /* Skip pattern info */ 4414| 234k| while (ptr < ptrend && IS_DIGIT(*ptr)) ------------------ | | 408| 234k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 469k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 566|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 566, False: 234k] | | | Branch (408:39): [True: 558, False: 8] | | ------------------ ------------------ | Branch (4414:16): [True: 234k, False: 24] ------------------ 4415| 558| { 4416| 558| n = n * 10 + *ptr++ - CHAR_0; ------------------ | | 998| 558|#define CHAR_0 '\060' ------------------ 4417| 558| if (n > 255) ------------------ | Branch (4417:15): [True: 5, False: 553] ------------------ 4418| 5| { 4419| 5| errorcode = ERR38; 4420| 5| goto FAILED; 4421| 5| } 4422| 558| } 4423| 234k| *parsed_pattern++ = n; 4424| 234k| } 4425| | 4426| | /* Both formats must have a closing parenthesis */ 4427| | 4428| 236k| if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 236k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4428:11): [True: 49, False: 236k] | Branch (4428:28): [True: 21, False: 236k] ------------------ 4429| 70| { 4430| 70| errorcode = ERR39; 4431| 70| goto FAILED; 4432| 70| } 4433| 236k| ptr++; 4434| | 4435| | /* Remember the offset to the next item in the pattern, and set a default 4436| | length. This should get updated after the next item is read. */ 4437| | 4438| 236k| previous_callout[1] = (uint32_t)(ptr - cb->start_pattern); 4439| 236k| previous_callout[2] = 0; 4440| 236k| break; /* End callout */ 4441| | 4442| | 4443| | /* ---- Conditional group ---- */ 4444| | 4445| | /* A condition can be an assertion, a number (referring to a numbered 4446| | group's having been set), a name (referring to a named group), or 'R', 4447| | referring to overall recursion. R and R&name are also permitted 4448| | for recursion state tests. Numbers may be preceded by + or - to specify a 4449| | relative group number. 4450| | 4451| | There are several syntaxes for testing a named group: (?(name)) is used 4452| | by Python; Perl 5.10 onwards uses (?() or (?('name')). 4453| | 4454| | There are two unfortunate ambiguities. 'R' can be the recursive thing or 4455| | the name 'R' (and similarly for 'R' followed by digits). 'DEFINE' can be 4456| | the Perl DEFINE feature or the Python named test. We look for a name 4457| | first; if not found, we try the other case. 4458| | 4459| | For compatibility with auto-callouts, we allow a callout to be specified 4460| | before a condition that is an assertion. */ 4461| | 4462| 13.0k| case CHAR_LEFT_PARENTHESIS: ------------------ | | 990| 13.0k|#define CHAR_LEFT_PARENTHESIS '\050' ------------------ | Branch (4462:7): [True: 13.0k, False: 388k] ------------------ 4463| 13.0k| if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS; ------------------ | Branch (4463:11): [True: 7, False: 13.0k] ------------------ 4464| 13.0k| nest_depth++; 4465| | 4466| | /* If the next character is ? or * there must be an assertion next 4467| | (optionally preceded by a callout). We do not check this here, but 4468| | instead we set expect_cond_assert to 2. If this is still greater than 4469| | zero (callouts decrement it) when the next assertion is read, it will be 4470| | marked as a condition that must not be repeated. A value greater than 4471| | zero also causes checking that an assertion (possibly with callout) 4472| | follows. */ 4473| | 4474| 13.0k| if (*ptr == CHAR_QUESTION_MARK || *ptr == CHAR_ASTERISK) ------------------ | | 1013| 26.1k|#define CHAR_QUESTION_MARK '\077' ------------------ if (*ptr == CHAR_QUESTION_MARK || *ptr == CHAR_ASTERISK) ------------------ | | 992| 10.1k|#define CHAR_ASTERISK '\052' ------------------ | Branch (4474:11): [True: 2.92k, False: 10.1k] | Branch (4474:41): [True: 225, False: 9.91k] ------------------ 4475| 3.15k| { 4476| 3.15k| *parsed_pattern++ = META_COND_ASSERT; ------------------ | | 227| 3.15k|#define META_COND_ASSERT 0x800f0000u /* (?(?assertion)... */ ------------------ 4477| 3.15k| ptr--; /* Pull pointer back to the opening parenthesis. */ 4478| 3.15k| expect_cond_assert = 2; 4479| 3.15k| break; /* End of conditional */ 4480| 3.15k| } 4481| | 4482| | /* Handle (?([+-]number)... */ 4483| | 4484| 9.91k| if (read_number(&ptr, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &i, ------------------ | | 147| 9.91k|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (4484:11): [True: 711, False: 9.19k] ------------------ 4485| 9.91k| &errorcode)) 4486| 711| { 4487| 711| if (i <= 0) ------------------ | Branch (4487:13): [True: 3, False: 708] ------------------ 4488| 3| { 4489| 3| errorcode = ERR15; 4490| 3| goto FAILED; 4491| 3| } 4492| 708| *parsed_pattern++ = META_COND_NUMBER; ------------------ | | 230| 708|#define META_COND_NUMBER 0x80120000u /* (?(digits)... */ ------------------ 4493| 708| offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 2); 4494| 708| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 708| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 4495| 708| *parsed_pattern++ = i; 4496| 708| } 4497| 9.19k| else if (errorcode != 0) goto FAILED; /* Number too big */ ------------------ | Branch (4497:16): [True: 3, False: 9.19k] ------------------ 4498| | 4499| | /* No number found. Handle the special case (?(VERSION[>]=n.m)... */ 4500| | 4501| 9.19k| else if (ptrend - ptr >= 10 && ------------------ | Branch (4501:16): [True: 8.44k, False: 753] ------------------ 4502| 9.19k| PRIV(strncmp_c8)(ptr, STRING_VERSION, 7) == 0 && ------------------ | | 177| 8.44k|#define PRIV(name) _pcre2_##name ------------------ PRIV(strncmp_c8)(ptr, STRING_VERSION, 7) == 0 && ------------------ | | 1228| 8.44k|#define STRING_VERSION STR_V STR_E STR_R STR_S STR_I STR_O STR_N | | ------------------ | | | | 1143| 8.44k|#define STR_V "\126" | | ------------------ | | #define STRING_VERSION STR_V STR_E STR_R STR_S STR_I STR_O STR_N | | ------------------ | | | | 1135| 8.44k|#define STR_N "\116" | | ------------------ ------------------ | Branch (4502:16): [True: 2.18k, False: 6.26k] ------------------ 4503| 9.19k| ptr[7] != CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 2.18k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4503:16): [True: 1.98k, False: 194] ------------------ 4504| 1.98k| { 4505| 1.98k| uint32_t ge = 0; 4506| 1.98k| int major = 0; 4507| 1.98k| int minor = 0; 4508| | 4509| 1.98k| ptr += 7; 4510| 1.98k| if (*ptr == CHAR_GREATER_THAN_SIGN) ------------------ | | 1012| 1.98k|#define CHAR_GREATER_THAN_SIGN '\076' ------------------ | Branch (4510:13): [True: 603, False: 1.38k] ------------------ 4511| 603| { 4512| 603| ge = 1; 4513| 603| ptr++; 4514| 603| } 4515| | 4516| | /* NOTE: cannot write IS_DIGIT(*(++ptr)) here because IS_DIGIT 4517| | references its argument twice. */ 4518| | 4519| 1.98k| if (*ptr != CHAR_EQUALS_SIGN || (ptr++, !IS_DIGIT(*ptr))) ------------------ | | 1011| 3.97k|#define CHAR_EQUALS_SIGN '\075' ------------------ if (*ptr != CHAR_EQUALS_SIGN || (ptr++, !IS_DIGIT(*ptr))) ------------------ | | 408| 1.97k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 3.94k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 1.96k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 1.96k, False: 9] | | | Branch (408:39): [True: 1.95k, False: 8] | | ------------------ ------------------ | Branch (4519:13): [True: 16, False: 1.97k] | Branch (4519:41): [True: 17, False: 1.95k] ------------------ 4520| 33| goto BAD_VERSION_CONDITION; 4521| | 4522| 1.95k| if (!read_number(&ptr, ptrend, -1, 1000, ERR79, &major, &errorcode)) ------------------ | Branch (4522:13): [True: 3, False: 1.95k] ------------------ 4523| 3| goto FAILED; 4524| | 4525| 1.95k| if (ptr >= ptrend) goto BAD_VERSION_CONDITION; ------------------ | Branch (4525:13): [True: 14, False: 1.93k] ------------------ 4526| 1.93k| if (*ptr == CHAR_DOT) ------------------ | | 996| 1.93k|#define CHAR_DOT '\056' ------------------ | Branch (4526:13): [True: 410, False: 1.52k] ------------------ 4527| 410| { 4528| 410| if (++ptr >= ptrend || !IS_DIGIT(*ptr)) goto BAD_VERSION_CONDITION; ------------------ | | 408| 405|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 810|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 400|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 400, False: 5] | | | Branch (408:39): [True: 397, False: 3] | | ------------------ ------------------ | Branch (4528:15): [True: 5, False: 405] ------------------ 4529| 397| minor = (*ptr++ - CHAR_0) * 10; ------------------ | | 998| 397|#define CHAR_0 '\060' ------------------ 4530| 397| if (ptr >= ptrend) goto BAD_VERSION_CONDITION; ------------------ | Branch (4530:15): [True: 5, False: 392] ------------------ 4531| 392| if (IS_DIGIT(*ptr)) minor += *ptr++ - CHAR_0; ------------------ | | 408| 392|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 784|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 197|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 197, False: 195] | | | Branch (408:39): [True: 194, False: 3] | | ------------------ ------------------ if (IS_DIGIT(*ptr)) minor += *ptr++ - CHAR_0; ------------------ | | 998| 194|#define CHAR_0 '\060' ------------------ 4532| 392| if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 386|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4532:15): [True: 6, False: 386] | Branch (4532:32): [True: 4, False: 382] ------------------ 4533| 10| goto BAD_VERSION_CONDITION; 4534| 392| } 4535| | 4536| 1.91k| *parsed_pattern++ = META_COND_VERSION; ------------------ | | 233| 1.91k|#define META_COND_VERSION 0x80150000u /* (?(VERSIONx.y)... */ ------------------ 4537| 1.91k| *parsed_pattern++ = ge; 4538| 1.91k| *parsed_pattern++ = major; 4539| 1.91k| *parsed_pattern++ = minor; 4540| 1.91k| } 4541| | 4542| | /* All the remaining cases now require us to read a name. We cannot at 4543| | this stage distinguish ambiguous cases such as (?(R12) which might be a 4544| | recursion test by number or a name, because the named groups have not yet 4545| | all been identified. Those cases are treated as names, but given a 4546| | different META code. */ 4547| | 4548| 7.20k| else 4549| 7.20k| { 4550| 7.20k| BOOL was_r_ampersand = FALSE; ------------------ | | 69| 7.20k|#define FALSE 0 ------------------ 4551| | 4552| 7.20k| if (*ptr == CHAR_R && ptrend - ptr > 1 && ptr[1] == CHAR_AMPERSAND) ------------------ | | 1032| 14.4k|#define CHAR_R '\122' ------------------ if (*ptr == CHAR_R && ptrend - ptr > 1 && ptr[1] == CHAR_AMPERSAND) ------------------ | | 988| 3.63k|#define CHAR_AMPERSAND '\046' ------------------ | Branch (4552:13): [True: 3.64k, False: 3.56k] | Branch (4552:31): [True: 3.63k, False: 4] | Branch (4552:51): [True: 592, False: 3.04k] ------------------ 4553| 592| { 4554| 592| terminator = CHAR_RIGHT_PARENTHESIS; ------------------ | | 991| 592|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ 4555| 592| was_r_ampersand = TRUE; ------------------ | | 70| 592|#define TRUE 1 ------------------ 4556| 592| ptr++; 4557| 592| } 4558| 6.61k| else if (*ptr == CHAR_LESS_THAN_SIGN) ------------------ | | 1010| 6.61k|#define CHAR_LESS_THAN_SIGN '\074' ------------------ | Branch (4558:18): [True: 195, False: 6.42k] ------------------ 4559| 195| terminator = CHAR_GREATER_THAN_SIGN; ------------------ | | 1012| 195|#define CHAR_GREATER_THAN_SIGN '\076' ------------------ 4560| 6.42k| else if (*ptr == CHAR_APOSTROPHE) ------------------ | | 989| 6.42k|#define CHAR_APOSTROPHE '\047' ------------------ | Branch (4560:18): [True: 216, False: 6.20k] ------------------ 4561| 216| terminator = CHAR_APOSTROPHE; ------------------ | | 989| 216|#define CHAR_APOSTROPHE '\047' ------------------ 4562| 6.20k| else 4563| 6.20k| { 4564| 6.20k| terminator = CHAR_RIGHT_PARENTHESIS; ------------------ | | 991| 6.20k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ 4565| 6.20k| ptr--; /* Point to char before name */ 4566| 6.20k| } 4567| 7.20k| if (!read_name(&ptr, ptrend, utf, terminator, &offset, &name, &namelen, ------------------ | Branch (4567:13): [True: 198, False: 7.01k] ------------------ 4568| 7.20k| &errorcode, cb)) goto FAILED; 4569| | 4570| | /* Handle (?(R&name) */ 4571| | 4572| 7.01k| if (was_r_ampersand) ------------------ | Branch (4572:13): [True: 584, False: 6.42k] ------------------ 4573| 584| { 4574| 584| *parsed_pattern = META_COND_RNAME; ------------------ | | 231| 584|#define META_COND_RNAME 0x80130000u /* (?(R&name)... */ ------------------ 4575| 584| ptr--; /* Back to closing parens */ 4576| 584| } 4577| | 4578| | /* Handle (?(name). If the name is "DEFINE" we identify it with a 4579| | special code. Likewise if the name consists of R followed only by 4580| | digits. Otherwise, handle it like a quoted name. */ 4581| | 4582| 6.42k| else if (terminator == CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 6.42k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4582:18): [True: 6.03k, False: 392] ------------------ 4583| 6.03k| { 4584| 6.03k| if (namelen == 6 && PRIV(strncmp_c8)(name, STRING_DEFINE, 6) == 0) ------------------ | | 177| 220|#define PRIV(name) _pcre2_##name ------------------ if (namelen == 6 && PRIV(strncmp_c8)(name, STRING_DEFINE, 6) == 0) ------------------ | | 1227| 220|#define STRING_DEFINE STR_D STR_E STR_F STR_I STR_N STR_E | | ------------------ | | | | 1125| 220|#define STR_D "\104" | | ------------------ | | #define STRING_DEFINE STR_D STR_E STR_F STR_I STR_N STR_E | | ------------------ | | | | 1126| 220|#define STR_E "\105" | | ------------------ ------------------ | Branch (4584:15): [True: 220, False: 5.81k] | Branch (4584:31): [True: 0, False: 220] ------------------ 4585| 0| *parsed_pattern = META_COND_DEFINE; ------------------ | | 228| 0|#define META_COND_DEFINE 0x80100000u /* (?(DEFINE)... */ ------------------ 4586| 6.03k| else 4587| 6.03k| { 4588| 7.85k| for (i = 1; i < (int)namelen; i++) ------------------ | Branch (4588:25): [True: 2.91k, False: 4.93k] ------------------ 4589| 2.91k| if (!IS_DIGIT(name[i])) break; ------------------ | | 408| 2.91k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 5.83k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 2.91k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 2.91k, False: 0] | | | Branch (408:39): [True: 1.82k, False: 1.09k] | | ------------------ ------------------ 4590| 6.03k| *parsed_pattern = (*name == CHAR_R && i >= (int)namelen)? ------------------ | | 1032| 12.0k|#define CHAR_R '\122' ------------------ | Branch (4590:32): [True: 3.02k, False: 3.00k] | Branch (4590:51): [True: 2.68k, False: 340] ------------------ 4591| 3.34k| META_COND_RNUMBER : META_COND_NAME; ------------------ | | 232| 2.68k|#define META_COND_RNUMBER 0x80140000u /* (?(Rdigits)... */ ------------------ META_COND_RNUMBER : META_COND_NAME; ------------------ | | 229| 9.38k|#define META_COND_NAME 0x80110000u /* (?()... */ ------------------ 4592| 6.03k| } 4593| 6.03k| ptr--; /* Back to closing parens */ 4594| 6.03k| } 4595| | 4596| | /* Handle (?('name') or (?() */ 4597| | 4598| 392| else *parsed_pattern = META_COND_NAME; ------------------ | | 229| 392|#define META_COND_NAME 0x80110000u /* (?()... */ ------------------ 4599| | 4600| | /* All these cases except DEFINE end with the name length and offset; 4601| | DEFINE just has an offset (for the "too many branches" error). */ 4602| | 4603| 7.01k| if (*parsed_pattern++ != META_COND_DEFINE) *parsed_pattern++ = namelen; ------------------ | | 228| 7.01k|#define META_COND_DEFINE 0x80100000u /* (?(DEFINE)... */ ------------------ | Branch (4603:13): [True: 7.01k, False: 0] ------------------ 4604| 7.01k| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 7.01k| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 4605| 7.01k| } /* End cases that read a name */ 4606| | 4607| | /* Check the closing parenthesis of the condition */ 4608| | 4609| 9.62k| if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS) ------------------ | | 991| 9.60k|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4609:11): [True: 23, False: 9.60k] | Branch (4609:28): [True: 27, False: 9.57k] ------------------ 4610| 50| { 4611| 50| errorcode = ERR24; 4612| 50| goto FAILED; 4613| 50| } 4614| 9.57k| ptr++; 4615| 9.57k| break; /* End of condition processing */ 4616| | 4617| | 4618| | /* ---- Atomic group ---- */ 4619| | 4620| 1.71k| case CHAR_GREATER_THAN_SIGN: ------------------ | | 1012| 1.71k|#define CHAR_GREATER_THAN_SIGN '\076' ------------------ | Branch (4620:7): [True: 1.71k, False: 399k] ------------------ 4621| 1.71k| ATOMIC_GROUP: /* Come from (*atomic: */ 4622| 1.71k| *parsed_pattern++ = META_ATOMIC; ------------------ | | 214| 1.71k|#define META_ATOMIC 0x80020000u /* atomic group */ ------------------ 4623| 1.71k| nest_depth++; 4624| 1.71k| ptr++; 4625| 1.71k| break; 4626| | 4627| | 4628| | /* ---- Lookahead assertions ---- */ 4629| | 4630| 6.41k| case CHAR_EQUALS_SIGN: ------------------ | | 1011| 6.41k|#define CHAR_EQUALS_SIGN '\075' ------------------ | Branch (4630:7): [True: 6.41k, False: 395k] ------------------ 4631| 6.76k| POSITIVE_LOOK_AHEAD: /* Come from (*pla: */ 4632| 6.76k| *parsed_pattern++ = META_LOOKAHEAD; ------------------ | | 251| 6.76k|#define META_LOOKAHEAD 0x80230000u /* (?= */ ------------------ 4633| 6.76k| ptr++; 4634| 6.76k| goto POST_ASSERTION; 4635| | 4636| 1.47k| case CHAR_ASTERISK: ------------------ | | 992| 1.47k|#define CHAR_ASTERISK '\052' ------------------ | Branch (4636:7): [True: 1.47k, False: 400k] ------------------ 4637| 1.67k| POSITIVE_NONATOMIC_LOOK_AHEAD: /* Come from (?* */ 4638| 1.67k| *parsed_pattern++ = META_LOOKAHEAD_NA; ------------------ | | 258| 1.67k|#define META_LOOKAHEAD_NA 0x80270000u /* (*napla: */ ------------------ 4639| 1.67k| ptr++; 4640| 1.67k| goto POST_ASSERTION; 4641| | 4642| 4.74k| case CHAR_EXCLAMATION_MARK: ------------------ | | 983| 4.74k|#define CHAR_EXCLAMATION_MARK '\041' ------------------ | Branch (4642:7): [True: 4.74k, False: 396k] ------------------ 4643| 5.12k| NEGATIVE_LOOK_AHEAD: /* Come from (*nla: */ 4644| 5.12k| *parsed_pattern++ = META_LOOKAHEADNOT; ------------------ | | 252| 5.12k|#define META_LOOKAHEADNOT 0x80240000u /* (?! */ ------------------ 4645| 5.12k| ptr++; 4646| 5.12k| goto POST_ASSERTION; 4647| | 4648| | 4649| | /* ---- Lookbehind assertions ---- */ 4650| | 4651| | /* (?< followed by = or ! or * is a lookbehind assertion. Otherwise (?< 4652| | is the start of the name of a capturing group. */ 4653| | 4654| 15.3k| case CHAR_LESS_THAN_SIGN: ------------------ | | 1010| 15.3k|#define CHAR_LESS_THAN_SIGN '\074' ------------------ | Branch (4654:7): [True: 15.3k, False: 386k] ------------------ 4655| 15.3k| if (ptrend - ptr <= 1 || ------------------ | Branch (4655:11): [True: 5, False: 15.3k] ------------------ 4656| 15.3k| (ptr[1] != CHAR_EQUALS_SIGN && ------------------ | | 1011| 30.7k|#define CHAR_EQUALS_SIGN '\075' ------------------ | Branch (4656:11): [True: 8.04k, False: 7.30k] ------------------ 4657| 15.3k| ptr[1] != CHAR_EXCLAMATION_MARK && ------------------ | | 983| 23.3k|#define CHAR_EXCLAMATION_MARK '\041' ------------------ | Branch (4657:11): [True: 2.55k, False: 5.48k] ------------------ 4658| 15.3k| ptr[1] != CHAR_ASTERISK)) ------------------ | | 992| 2.55k|#define CHAR_ASTERISK '\052' ------------------ | Branch (4658:11): [True: 1.67k, False: 878] ------------------ 4659| 1.68k| { 4660| 1.68k| terminator = CHAR_GREATER_THAN_SIGN; ------------------ | | 1012| 1.68k|#define CHAR_GREATER_THAN_SIGN '\076' ------------------ 4661| 1.68k| goto DEFINE_NAME; 4662| 1.68k| } 4663| 13.6k| *parsed_pattern++ = (ptr[1] == CHAR_EQUALS_SIGN)? ------------------ | | 1011| 13.6k|#define CHAR_EQUALS_SIGN '\075' ------------------ | Branch (4663:27): [True: 7.30k, False: 6.36k] ------------------ 4664| 7.30k| META_LOOKBEHIND : (ptr[1] == CHAR_EXCLAMATION_MARK)? ------------------ | | 253| 7.30k|#define META_LOOKBEHIND 0x80250000u /* (?<= */ ------------------ META_LOOKBEHIND : (ptr[1] == CHAR_EXCLAMATION_MARK)? ------------------ | | 983| 6.36k|#define CHAR_EXCLAMATION_MARK '\041' ------------------ | Branch (4664:27): [True: 5.48k, False: 878] ------------------ 4665| 5.48k| META_LOOKBEHINDNOT : META_LOOKBEHIND_NA; ------------------ | | 254| 5.48k|#define META_LOOKBEHINDNOT 0x80260000u /* (?start_pattern - 2); 4670| 14.3k| PUTOFFSET(offset, parsed_pattern); ------------------ | | 100| 14.3k| { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); } ------------------ 4671| 14.3k| ptr += 2; 4672| | /* Fall through */ 4673| | 4674| | /* If the previous item was a condition starting (?(? an assertion, 4675| | optionally preceded by a callout, is expected. This is checked later on, 4676| | during actual compilation. However we need to identify this kind of 4677| | assertion in this pass because it must not be qualified. The value of 4678| | expect_cond_assert is set to 2 after (?(? is processed. We decrement it 4679| | for a callout - still leaving a positive value that identifies the 4680| | assertion. Multiple callouts or any other items will make it zero or 4681| | less, which doesn't matter because they will cause an error later. */ 4682| | 4683| 27.8k| POST_ASSERTION: 4684| 27.8k| nest_depth++; 4685| 27.8k| if (prev_expect_cond_assert > 0) ------------------ | Branch (4685:11): [True: 3.06k, False: 24.7k] ------------------ 4686| 3.06k| { 4687| 3.06k| if (top_nest == NULL) top_nest = (nest_save *)(cb->start_workspace); ------------------ | Branch (4687:13): [True: 1.38k, False: 1.68k] ------------------ 4688| 1.68k| else if (++top_nest >= end_nests) ------------------ | Branch (4688:18): [True: 0, False: 1.68k] ------------------ 4689| 0| { 4690| 0| errorcode = ERR84; 4691| 0| goto FAILED; 4692| 0| } 4693| 3.06k| top_nest->nest_depth = nest_depth; 4694| 3.06k| top_nest->flags = NSF_CONDASSERT; ------------------ | | 2652| 3.06k|#define NSF_CONDASSERT 0x0002u ------------------ 4695| 3.06k| top_nest->options = options & PARSE_TRACKED_OPTIONS; ------------------ | | 2660| 3.06k|#define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 122| 3.06k|#define PCRE2_CASELESS 0x00000008u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 124| 3.06k|#define PCRE2_DOTALL 0x00000020u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 125| 3.06k|#define PCRE2_DUPNAMES 0x00000040u /* C */ | | ------------------ | | 2661| 3.06k| PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 126| 3.06k|#define PCRE2_EXTENDED 0x00000080u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 143| 3.06k|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 129| 3.06k|#define PCRE2_MULTILINE 0x00000400u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 132| 3.06k|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ | | ------------------ | | 2662| 3.06k| PCRE2_UNGREEDY) | | ------------------ | | | | 137| 3.06k|#define PCRE2_UNGREEDY 0x00040000u /* C */ | | ------------------ ------------------ 4696| 3.06k| top_nest->xoptions = xoptions & PARSE_TRACKED_EXTRA_OPTIONS; ------------------ | | 2664| 3.06k|#define PARSE_TRACKED_EXTRA_OPTIONS (PCRE2_EXTRA_CASELESS_RESTRICT| \ | | ------------------ | | | | 156| 3.06k|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ | | ------------------ | | 2665| 3.06k| PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 157| 3.06k|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 158| 3.06k|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 159| 3.06k|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ | | ------------------ | | 2666| 3.06k| PCRE2_EXTRA_ASCII_POSIX) | | ------------------ | | | | 160| 3.06k|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ | | ------------------ ------------------ 4697| 3.06k| } 4698| 27.8k| break; 4699| | 4700| | 4701| | /* ---- Define a named group ---- */ 4702| | 4703| | /* A named group may be defined as (?'name') or (?). In the latter 4704| | case we jump to DEFINE_NAME from the disambiguation of (?< above with the 4705| | terminator set to '>'. */ 4706| | 4707| 82.0k| case CHAR_APOSTROPHE: ------------------ | | 989| 82.0k|#define CHAR_APOSTROPHE '\047' ------------------ | Branch (4707:7): [True: 82.0k, False: 319k] ------------------ 4708| 82.0k| terminator = CHAR_APOSTROPHE; /* Terminator */ ------------------ | | 989| 82.0k|#define CHAR_APOSTROPHE '\047' ------------------ 4709| | 4710| 83.9k| DEFINE_NAME: 4711| 83.9k| if (!read_name(&ptr, ptrend, utf, terminator, &offset, &name, &namelen, ------------------ | Branch (4711:11): [True: 135, False: 83.8k] ------------------ 4712| 83.9k| &errorcode, cb)) goto FAILED; 4713| | 4714| | /* We have a name for this capturing group. It is also assigned a number, 4715| | which is its primary means of identification. */ 4716| | 4717| 83.8k| if (cb->bracount >= MAX_GROUP_NUMBER) ------------------ | | 147| 83.8k|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (4717:11): [True: 4, False: 83.8k] ------------------ 4718| 4| { 4719| 4| errorcode = ERR97; 4720| 4| goto FAILED; 4721| 4| } 4722| 83.8k| cb->bracount++; 4723| 83.8k| *parsed_pattern++ = META_CAPTURE | cb->bracount; ------------------ | | 220| 83.8k|#define META_CAPTURE 0x80080000u /* Capturing parenthesis */ ------------------ 4724| 83.8k| nest_depth++; 4725| | 4726| | /* Check not too many names */ 4727| | 4728| 83.8k| if (cb->names_found >= MAX_NAME_COUNT) ------------------ | | 194| 83.8k|#define MAX_NAME_COUNT 10000 ------------------ | Branch (4728:11): [True: 3, False: 83.8k] ------------------ 4729| 3| { 4730| 3| errorcode = ERR49; 4731| 3| goto FAILED; 4732| 3| } 4733| | 4734| | /* Adjust the entry size to accommodate the longest name found. */ 4735| | 4736| 83.8k| if (namelen + IMM2_SIZE + 1 > cb->name_entry_size) ------------------ | | 193| 83.8k|#define IMM2_SIZE 2 ------------------ | Branch (4736:11): [True: 1.43k, False: 82.3k] ------------------ 4737| 1.43k| cb->name_entry_size = (uint16_t)(namelen + IMM2_SIZE + 1); ------------------ | | 193| 1.43k|#define IMM2_SIZE 2 ------------------ 4738| | 4739| | /* Scan the list to check for duplicates. For duplicate names, if the 4740| | number is the same, break the loop, which causes the name to be 4741| | discarded; otherwise, if DUPNAMES is not set, give an error. 4742| | If it is set, allow the name with a different number, but continue 4743| | scanning in case this is a duplicate with the same number. For 4744| | non-duplicate names, give an error if the number is duplicated. */ 4745| | 4746| 83.8k| isdupname = FALSE; ------------------ | | 69| 83.8k|#define FALSE 0 ------------------ 4747| 83.8k| ng = cb->named_groups; 4748| 254M| for (i = 0; i < cb->names_found; i++, ng++) ------------------ | Branch (4748:19): [True: 254M, False: 83.4k] ------------------ 4749| 254M| { 4750| 254M| if (namelen == ng->length && ------------------ | Branch (4750:13): [True: 254M, False: 55.2k] ------------------ 4751| 254M| PRIV(strncmp)(name, ng->name, (PCRE2_SIZE)namelen) == 0) ------------------ | | 177| 254M|#define PRIV(name) _pcre2_##name ------------------ | Branch (4751:13): [True: 253M, False: 1.05M] ------------------ 4752| 253M| { 4753| 253M| if (ng->number == cb->bracount) break; ------------------ | Branch (4753:15): [True: 194, False: 253M] ------------------ 4754| 253M| if ((options & PCRE2_DUPNAMES) == 0) ------------------ | | 125| 253M|#define PCRE2_DUPNAMES 0x00000040u /* C */ ------------------ | Branch (4754:15): [True: 132, False: 253M] ------------------ 4755| 132| { 4756| 132| errorcode = ERR43; 4757| 132| goto FAILED; 4758| 132| } 4759| 253M| isdupname = ng->isdup = TRUE; /* Mark as a duplicate */ ------------------ | | 70| 253M|#define TRUE 1 ------------------ 4760| 253M| cb->dupnames = TRUE; /* Duplicate names exist */ ------------------ | | 70| 253M|#define TRUE 1 ------------------ 4761| 253M| } 4762| 1.10M| else if (ng->number == cb->bracount) ------------------ | Branch (4762:18): [True: 4, False: 1.10M] ------------------ 4763| 4| { 4764| 4| errorcode = ERR65; 4765| 4| goto FAILED; 4766| 4| } 4767| 254M| } 4768| | 4769| 83.6k| if (i < cb->names_found) break; /* Ignore duplicate with same number */ ------------------ | Branch (4769:11): [True: 194, False: 83.4k] ------------------ 4770| | 4771| | /* Increase the list size if necessary */ 4772| | 4773| 83.4k| if (cb->names_found >= cb->named_group_list_size) ------------------ | Branch (4773:11): [True: 268, False: 83.2k] ------------------ 4774| 268| { 4775| 268| uint32_t newsize = cb->named_group_list_size * 2; 4776| 268| named_group *newspace = ------------------ | | 1983| 268|#define named_group PCRE2_SUFFIX(named_group_) | | ------------------ | | | | 986| 268|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 268|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 268|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4777| 268| cb->cx->memctl.malloc(newsize * sizeof(named_group), 4778| 268| cb->cx->memctl.memory_data); 4779| 268| if (newspace == NULL) ------------------ | Branch (4779:13): [True: 0, False: 268] ------------------ 4780| 0| { 4781| 0| errorcode = ERR21; 4782| 0| goto FAILED; 4783| 0| } 4784| | 4785| 268| memcpy(newspace, cb->named_groups, 4786| 268| cb->named_group_list_size * sizeof(named_group)); 4787| 268| if (cb->named_group_list_size > NAMED_GROUP_LIST_SIZE) ------------------ | | 187| 268|#define NAMED_GROUP_LIST_SIZE 20 ------------------ | Branch (4787:13): [True: 199, False: 69] ------------------ 4788| 199| cb->cx->memctl.free((void *)cb->named_groups, 4789| 199| cb->cx->memctl.memory_data); 4790| 268| cb->named_groups = newspace; 4791| 268| cb->named_group_list_size = newsize; 4792| 268| } 4793| | 4794| | /* Add this name to the list */ 4795| | 4796| 83.4k| cb->named_groups[cb->names_found].name = name; 4797| 83.4k| cb->named_groups[cb->names_found].length = (uint16_t)namelen; 4798| 83.4k| cb->named_groups[cb->names_found].number = cb->bracount; 4799| 83.4k| cb->named_groups[cb->names_found].isdup = (uint16_t)isdupname; 4800| 83.4k| cb->names_found++; 4801| 83.4k| break; 4802| 401k| } /* End of (? switch */ 4803| 401k| break; /* End of ( handling */ 4804| | 4805| | 4806| | /* ---- Branch terminators ---- */ 4807| | 4808| | /* Alternation: reset the capture count if we are in a (?| group. */ 4809| | 4810| 401k| case CHAR_VERTICAL_LINE: ------------------ | | 1074| 130k|#define CHAR_VERTICAL_LINE '\174' ------------------ | Branch (4810:5): [True: 130k, False: 14.4M] ------------------ 4811| 130k| if (top_nest != NULL && top_nest->nest_depth == nest_depth && ------------------ | Branch (4811:9): [True: 5.66k, False: 124k] | Branch (4811:29): [True: 3.32k, False: 2.34k] ------------------ 4812| 130k| (top_nest->flags & NSF_RESET) != 0) ------------------ | | 2651| 3.32k|#define NSF_RESET 0x0001u ------------------ | Branch (4812:9): [True: 590, False: 2.73k] ------------------ 4813| 590| { 4814| 590| if (cb->bracount > top_nest->max_group) ------------------ | Branch (4814:11): [True: 290, False: 300] ------------------ 4815| 290| top_nest->max_group = (uint16_t)cb->bracount; 4816| 590| cb->bracount = top_nest->reset_group; 4817| 590| } 4818| 130k| *parsed_pattern++ = META_ALT; ------------------ | | 213| 130k|#define META_ALT 0x80010000u /* alternation */ ------------------ 4819| 130k| break; 4820| | 4821| | /* End of group; reset the capture count to the maximum if we are in a (?| 4822| | group and/or reset the options that are tracked during parsing. Disallow 4823| | quantifier for a condition that is an assertion. */ 4824| | 4825| 2.25M| case CHAR_RIGHT_PARENTHESIS: ------------------ | | 991| 2.25M|#define CHAR_RIGHT_PARENTHESIS '\051' ------------------ | Branch (4825:5): [True: 2.25M, False: 12.3M] ------------------ 4826| 2.25M| okquantifier = TRUE; ------------------ | | 70| 2.25M|#define TRUE 1 ------------------ 4827| 2.25M| if (top_nest != NULL && top_nest->nest_depth == nest_depth) ------------------ | Branch (4827:9): [True: 2.01M, False: 241k] | Branch (4827:29): [True: 9.69k, False: 2.00M] ------------------ 4828| 9.69k| { 4829| 9.69k| options = (options & ~PARSE_TRACKED_OPTIONS) | top_nest->options; ------------------ | | 2660| 9.69k|#define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 122| 9.69k|#define PCRE2_CASELESS 0x00000008u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 124| 9.69k|#define PCRE2_DOTALL 0x00000020u /* C */ | | ------------------ | | #define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \ | | ------------------ | | | | 125| 9.69k|#define PCRE2_DUPNAMES 0x00000040u /* C */ | | ------------------ | | 2661| 9.69k| PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 126| 9.69k|#define PCRE2_EXTENDED 0x00000080u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 143| 9.69k|#define PCRE2_EXTENDED_MORE 0x01000000u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 129| 9.69k|#define PCRE2_MULTILINE 0x00000400u /* C */ | | ------------------ | | PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 132| 9.69k|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ | | ------------------ | | 2662| 9.69k| PCRE2_UNGREEDY) | | ------------------ | | | | 137| 9.69k|#define PCRE2_UNGREEDY 0x00040000u /* C */ | | ------------------ ------------------ 4830| 9.69k| xoptions = (xoptions & ~PARSE_TRACKED_EXTRA_OPTIONS) | top_nest->xoptions; ------------------ | | 2664| 9.69k|#define PARSE_TRACKED_EXTRA_OPTIONS (PCRE2_EXTRA_CASELESS_RESTRICT| \ | | ------------------ | | | | 156| 9.69k|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ | | ------------------ | | 2665| 9.69k| PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 157| 9.69k|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 158| 9.69k|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ | | ------------------ | | PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \ | | ------------------ | | | | 159| 9.69k|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ | | ------------------ | | 2666| 9.69k| PCRE2_EXTRA_ASCII_POSIX) | | ------------------ | | | | 160| 9.69k|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ | | ------------------ ------------------ 4831| 9.69k| if ((top_nest->flags & NSF_RESET) != 0 && ------------------ | | 2651| 9.69k|#define NSF_RESET 0x0001u ------------------ | Branch (4831:11): [True: 5.24k, False: 4.44k] ------------------ 4832| 9.69k| top_nest->max_group > cb->bracount) ------------------ | Branch (4832:11): [True: 254, False: 4.99k] ------------------ 4833| 254| cb->bracount = top_nest->max_group; 4834| 9.69k| if ((top_nest->flags & NSF_CONDASSERT) != 0) ------------------ | | 2652| 9.69k|#define NSF_CONDASSERT 0x0002u ------------------ | Branch (4834:11): [True: 1.86k, False: 7.82k] ------------------ 4835| 1.86k| okquantifier = FALSE; ------------------ | | 69| 1.86k|#define FALSE 0 ------------------ 4836| | 4837| 9.69k| if ((top_nest->flags & NSF_ATOMICSR) != 0) ------------------ | | 2653| 9.69k|#define NSF_ATOMICSR 0x0004u ------------------ | Branch (4837:11): [True: 415, False: 9.27k] ------------------ 4838| 415| { 4839| 415| *parsed_pattern++ = META_KET; ------------------ | | 237| 415|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ 4840| 415| } 4841| | 4842| 9.69k| if (top_nest == (nest_save *)(cb->start_workspace)) top_nest = NULL; ------------------ | Branch (4842:11): [True: 6.12k, False: 3.57k] ------------------ 4843| 3.57k| else top_nest--; 4844| 9.69k| } 4845| 2.25M| if (nest_depth == 0) /* Unmatched closing parenthesis */ ------------------ | Branch (4845:9): [True: 69, False: 2.25M] ------------------ 4846| 69| { 4847| 69| errorcode = ERR22; 4848| 69| goto FAILED_BACK; 4849| 69| } 4850| 2.25M| nest_depth--; 4851| 2.25M| *parsed_pattern++ = META_KET; ------------------ | | 237| 2.25M|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ 4852| 2.25M| break; 4853| 14.5M| } /* End of switch on pattern character */ 4854| 14.5M| } /* End of main character scan loop */ 4855| | 4856| |/* End of pattern reached. Check for missing ) at the end of a verb name. */ 4857| | 4858| 68.9k|if (inverbname && ptr >= ptrend) ------------------ | Branch (4858:5): [True: 315, False: 68.6k] | Branch (4858:19): [True: 315, False: 0] ------------------ 4859| 315| { 4860| 315| errorcode = ERR60; 4861| 315| goto FAILED; 4862| 315| } 4863| | 4864| |/* Manage callout for the final item */ 4865| | 4866| 68.6k|PARSED_END: 4867| 68.6k|parsed_pattern = manage_callouts(ptr, &previous_callout, auto_callout, 4868| 68.6k| parsed_pattern, cb); 4869| | 4870| |/* Insert trailing items for word and line matching (features provided for the 4871| |benefit of pcre2grep). */ 4872| | 4873| 68.6k|if ((xoptions & PCRE2_EXTRA_MATCH_LINE) != 0) ------------------ | | 152| 68.6k|#define PCRE2_EXTRA_MATCH_LINE 0x00000008u /* C */ ------------------ | Branch (4873:5): [True: 0, False: 68.6k] ------------------ 4874| 0| { 4875| 0| *parsed_pattern++ = META_KET; ------------------ | | 237| 0|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ 4876| 0| *parsed_pattern++ = META_DOLLAR; ------------------ | | 234| 0|#define META_DOLLAR 0x80160000u /* $ metacharacter */ ------------------ 4877| 0| } 4878| 68.6k|else if ((xoptions & PCRE2_EXTRA_MATCH_WORD) != 0) ------------------ | | 151| 68.6k|#define PCRE2_EXTRA_MATCH_WORD 0x00000004u /* C */ ------------------ | Branch (4878:10): [True: 0, False: 68.6k] ------------------ 4879| 0| { 4880| 0| *parsed_pattern++ = META_KET; ------------------ | | 237| 0|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ 4881| 0| *parsed_pattern++ = META_ESCAPE + ESC_b; ------------------ | | 236| 0|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 4882| 0| } 4883| | 4884| |/* Terminate the parsed pattern, then return success if all groups are closed. 4885| |Otherwise we have unclosed parentheses. */ 4886| | 4887| 68.6k|if (parsed_pattern >= parsed_pattern_end) ------------------ | Branch (4887:5): [True: 0, False: 68.6k] ------------------ 4888| 0| { 4889| 0| errorcode = ERR63; /* Internal error (parsed pattern overflow) */ 4890| 0| goto FAILED; 4891| 0| } 4892| | 4893| 68.6k|*parsed_pattern = META_END; ------------------ | | 211| 68.6k|#define META_END 0x80000000u /* End of pattern */ ------------------ 4894| 68.6k|if (nest_depth == 0) return 0; ------------------ | Branch (4894:5): [True: 67.6k, False: 974] ------------------ 4895| | 4896| 1.47k|UNCLOSED_PARENTHESIS: 4897| 1.47k|errorcode = ERR14; 4898| | 4899| |/* Come here for all failures. */ 4900| | 4901| 6.09k|FAILED: 4902| 6.09k|cb->erroroffset = (PCRE2_SIZE)(ptr - cb->start_pattern); 4903| 6.09k|return errorcode; 4904| | 4905| |/* Some errors need to indicate the previous character. */ 4906| | 4907| 322|FAILED_BACK: 4908| 322|ptr--; 4909| 322|goto FAILED; 4910| | 4911| |/* This failure happens several times. */ 4912| | 4913| 75|BAD_VERSION_CONDITION: 4914| 75|errorcode = ERR79; 4915| 75|goto FAILED; 4916| 1.47k|} pcre2_compile.c:manage_callouts: 2514| 19.1M|{ 2515| 19.1M|uint32_t *previous_callout = *pcalloutptr; 2516| | 2517| 19.1M|if (previous_callout != NULL) previous_callout[2] = (uint32_t)(ptr - ------------------ | Branch (2517:5): [True: 3.24M, False: 15.9M] ------------------ 2518| 3.24M| cb->start_pattern - (PCRE2_SIZE)previous_callout[1]); 2519| | 2520| 19.1M|if (!auto_callout) previous_callout = NULL; else ------------------ | Branch (2520:5): [True: 16.1M, False: 3.05M] ------------------ 2521| 3.05M| { 2522| 3.05M| if (previous_callout == NULL || ------------------ | Branch (2522:7): [True: 15.0k, False: 3.03M] ------------------ 2523| 3.05M| previous_callout != parsed_pattern - 4 || ------------------ | Branch (2523:7): [True: 3.03M, False: 2.19k] ------------------ 2524| 3.05M| previous_callout[3] != 255) ------------------ | Branch (2524:7): [True: 399, False: 1.79k] ------------------ 2525| 3.05M| { 2526| 3.05M| previous_callout = parsed_pattern; /* Set up new automatic callout */ 2527| 3.05M| parsed_pattern += 4; 2528| 3.05M| previous_callout[0] = META_CALLOUT_NUMBER; ------------------ | | 218| 3.05M|#define META_CALLOUT_NUMBER 0x80060000u /* (?C with numerical argument */ ------------------ 2529| 3.05M| previous_callout[2] = 0; 2530| 3.05M| previous_callout[3] = 255; 2531| 3.05M| } 2532| 3.05M| previous_callout[1] = (uint32_t)(ptr - cb->start_pattern); 2533| 3.05M| } 2534| | 2535| 19.1M|*pcalloutptr = previous_callout; 2536| 19.1M|return parsed_pattern; 2537| 19.1M|} pcre2_compile.c:handle_escdsw: 2561| 37.0k|{ 2562| 37.0k|uint32_t ascii_option = 0; 2563| 37.0k|uint32_t prop = ESC_p; 2564| | 2565| 37.0k|switch(escape) ------------------ | Branch (2565:8): [True: 0, False: 37.0k] ------------------ 2566| 37.0k| { 2567| 4.64k| case ESC_D: ------------------ | Branch (2567:3): [True: 4.64k, False: 32.4k] ------------------ 2568| 4.64k| prop = ESC_P; 2569| | /* Fall through */ 2570| 8.49k| case ESC_d: ------------------ | Branch (2570:3): [True: 3.85k, False: 33.2k] ------------------ 2571| 8.49k| ascii_option = PCRE2_EXTRA_ASCII_BSD; ------------------ | | 157| 8.49k|#define PCRE2_EXTRA_ASCII_BSD 0x00000100u /* C */ ------------------ 2572| 8.49k| break; 2573| | 2574| 7.57k| case ESC_S: ------------------ | Branch (2574:3): [True: 7.57k, False: 29.4k] ------------------ 2575| 7.57k| prop = ESC_P; 2576| | /* Fall through */ 2577| 17.2k| case ESC_s: ------------------ | Branch (2577:3): [True: 9.72k, False: 27.3k] ------------------ 2578| 17.2k| ascii_option = PCRE2_EXTRA_ASCII_BSS; ------------------ | | 158| 17.2k|#define PCRE2_EXTRA_ASCII_BSS 0x00000200u /* C */ ------------------ 2579| 17.2k| break; 2580| | 2581| 4.35k| case ESC_W: ------------------ | Branch (2581:3): [True: 4.35k, False: 32.7k] ------------------ 2582| 4.35k| prop = ESC_P; 2583| | /* Fall through */ 2584| 11.2k| case ESC_w: ------------------ | Branch (2584:3): [True: 6.91k, False: 30.1k] ------------------ 2585| 11.2k| ascii_option = PCRE2_EXTRA_ASCII_BSW; ------------------ | | 159| 11.2k|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ ------------------ 2586| 11.2k| break; 2587| 37.0k| } 2588| | 2589| 37.0k|if ((options & PCRE2_UCP) == 0 || (xoptions & ascii_option) != 0) ------------------ | | 136| 37.0k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (2589:5): [True: 27.4k, False: 9.63k] | Branch (2589:35): [True: 293, False: 9.34k] ------------------ 2590| 27.7k| { 2591| 27.7k| *parsed_pattern++ = META_ESCAPE + escape; ------------------ | | 236| 27.7k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 2592| 27.7k| } 2593| 9.34k|else 2594| 9.34k| { 2595| 9.34k| *parsed_pattern++ = META_ESCAPE + prop; ------------------ | | 236| 9.34k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ 2596| 9.34k| switch(escape) ------------------ | Branch (2596:10): [True: 0, False: 9.34k] ------------------ 2597| 9.34k| { 2598| 852| case ESC_d: ------------------ | Branch (2598:5): [True: 852, False: 8.49k] ------------------ 2599| 1.92k| case ESC_D: ------------------ | Branch (2599:5): [True: 1.07k, False: 8.27k] ------------------ 2600| 1.92k| *parsed_pattern++ = (PT_PC << 16) | ucp_Nd; ------------------ | | 1278| 1.92k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ 2601| 1.92k| break; 2602| | 2603| 2.60k| case ESC_s: ------------------ | Branch (2603:5): [True: 2.60k, False: 6.73k] ------------------ 2604| 4.94k| case ESC_S: ------------------ | Branch (2604:5): [True: 2.34k, False: 7.00k] ------------------ 2605| 4.94k| *parsed_pattern++ = PT_SPACE << 16; ------------------ | | 1282| 4.94k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ 2606| 4.94k| break; 2607| | 2608| 1.06k| case ESC_w: ------------------ | Branch (2608:5): [True: 1.06k, False: 8.28k] ------------------ 2609| 2.46k| case ESC_W: ------------------ | Branch (2609:5): [True: 1.40k, False: 7.93k] ------------------ 2610| 2.46k| *parsed_pattern++ = PT_WORD << 16; ------------------ | | 1284| 2.46k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ 2611| 2.46k| break; 2612| 9.34k| } 2613| 9.34k| } 2614| | 2615| 37.0k|return parsed_pattern; 2616| 37.0k|} pcre2_compile.c:get_ucp: 2097| 10.7k|{ 2098| 10.7k|PCRE2_UCHAR c; ------------------ | | 813| 10.7k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 10.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 10.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 10.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2099| 10.7k|PCRE2_SIZE i, bot, top; ------------------ | | 477| 10.7k|#define PCRE2_SIZE size_t ------------------ 2100| 10.7k|PCRE2_SPTR ptr = *ptrptr; ------------------ | | 814| 10.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 10.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 10.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 10.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2101| 10.7k|PCRE2_UCHAR name[50]; ------------------ | | 813| 10.7k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 10.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 10.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 10.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2102| 10.7k|PCRE2_UCHAR *vptr = NULL; ------------------ | | 813| 10.7k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 10.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 10.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 10.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2103| 10.7k|uint16_t ptscript = PT_NOTSCRIPT; ------------------ | | 1304| 10.7k|#define PT_NOTSCRIPT 255 ------------------ 2104| | 2105| 10.7k|if (ptr >= cb->end_pattern) goto ERROR_RETURN; ------------------ | Branch (2105:5): [True: 49, False: 10.7k] ------------------ 2106| 10.7k|c = *ptr++; 2107| 10.7k|*negptr = FALSE; ------------------ | | 69| 10.7k|#define FALSE 0 ------------------ 2108| | 2109| |/* \P or \p can be followed by a name in {}, optionally preceded by ^ for 2110| |negation. */ 2111| | 2112| 10.7k|if (c == CHAR_LEFT_CURLY_BRACKET) ------------------ | | 1073| 10.7k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (2112:5): [True: 7.06k, False: 3.65k] ------------------ 2113| 7.06k| { 2114| 7.06k| if (ptr >= cb->end_pattern) goto ERROR_RETURN; ------------------ | Branch (2114:7): [True: 3, False: 7.06k] ------------------ 2115| | 2116| 7.06k| if (*ptr == CHAR_CIRCUMFLEX_ACCENT) ------------------ | | 1044| 7.06k|#define CHAR_CIRCUMFLEX_ACCENT '\136' ------------------ | Branch (2116:7): [True: 402, False: 6.66k] ------------------ 2117| 402| { 2118| 402| *negptr = TRUE; ------------------ | | 70| 402|#define TRUE 1 ------------------ 2119| 402| ptr++; 2120| 402| } 2121| | 2122| 30.4k| for (i = 0; i < (int)(sizeof(name) / sizeof(PCRE2_UCHAR)) - 1; i++) ------------------ | Branch (2122:15): [True: 30.4k, False: 10] ------------------ 2123| 30.4k| { 2124| 30.4k| if (ptr >= cb->end_pattern) goto ERROR_RETURN; ------------------ | Branch (2124:9): [True: 102, False: 30.3k] ------------------ 2125| 30.3k| c = *ptr++; 2126| 31.2k| while (c == '_' || c == '-' || isspace(c)) ------------------ | Branch (2126:12): [True: 405, False: 30.8k] | Branch (2126:24): [True: 264, False: 30.5k] ------------------ 2127| 939| { 2128| 939| if (ptr >= cb->end_pattern) goto ERROR_RETURN; ------------------ | Branch (2128:11): [True: 37, False: 902] ------------------ 2129| 902| c = *ptr++; 2130| 902| } 2131| 30.2k| if (c == CHAR_NUL) goto ERROR_RETURN; ------------------ | | 981| 30.2k|#define CHAR_NUL '\0' ------------------ | Branch (2131:9): [True: 7, False: 30.2k] ------------------ 2132| 30.2k| if (c == CHAR_RIGHT_CURLY_BRACKET) break; ------------------ | | 1075| 30.2k|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (2132:9): [True: 6.91k, False: 23.3k] ------------------ 2133| 23.3k| name[i] = tolower(c); 2134| 23.3k| if ((c == ':' || c == '=') && vptr == NULL) vptr = name + i; ------------------ | Branch (2134:10): [True: 1.66k, False: 21.7k] | Branch (2134:22): [True: 111, False: 21.5k] | Branch (2134:35): [True: 1.59k, False: 188] ------------------ 2135| 23.3k| } 2136| | 2137| 6.92k| if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN; ------------------ | | 1075| 6.92k|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ | Branch (2137:7): [True: 10, False: 6.91k] ------------------ 2138| 6.91k| name[i] = 0; 2139| 6.91k| } 2140| | 2141| |/* If { doesn't follow \p or \P there is just one following character, which 2142| |must be an ASCII letter. */ 2143| | 2144| 3.65k|else if (MAX_255(c) && (cb->ctypes[c] & ctype_letter) != 0) ------------------ | | 212| 3.65k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 7.30k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ else if (MAX_255(c) && (cb->ctypes[c] & ctype_letter) != 0) ------------------ | | 580| 3.65k|#define ctype_letter 0x02 ------------------ | Branch (2144:24): [True: 3.64k, False: 7] ------------------ 2145| 3.64k| { 2146| 3.64k| name[0] = tolower(c); 2147| 3.64k| name[1] = 0; 2148| 3.64k| } 2149| 7|else goto ERROR_RETURN; 2150| | 2151| 10.5k|*ptrptr = ptr; 2152| | 2153| |/* If the property contains ':' or '=' we have class name and value separately 2154| |specified. The following are supported: 2155| | 2156| | . Bidi_Class (synonym bc), for which the property names are "bidi". 2157| | . Script (synonym sc) for which the property name is the script name 2158| | . Script_Extensions (synonym scx), ditto 2159| | 2160| |As this is a small number, we currently just check the names directly. If this 2161| |grows, a sorted table and a switch will be neater. 2162| | 2163| |For both the script properties, set a PT_xxx value so that (1) they can be 2164| |distinguished and (2) invalid script names that happen to be the name of 2165| |another property can be diagnosed. */ 2166| | 2167| 10.5k|if (vptr != NULL) ------------------ | Branch (2167:5): [True: 1.54k, False: 9.01k] ------------------ 2168| 1.54k| { 2169| 1.54k| int offset = 0; 2170| 1.54k| PCRE2_UCHAR sname[8]; ------------------ | | 813| 1.54k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 1.54k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.54k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.54k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2171| | 2172| 1.54k| *vptr = 0; /* Terminate property name */ 2173| 1.54k| if (PRIV(strcmp_c8)(name, STRING_bidiclass) == 0 || ------------------ | | 177| 1.54k|#define PRIV(name) _pcre2_##name ------------------ if (PRIV(strcmp_c8)(name, STRING_bidiclass) == 0 || ------------------ | | 1258| 1.54k|#define STRING_bidiclass STR_b STR_i STR_d STR_i STR_c STR_l STR_a STR_s STR_s | | ------------------ | | | | 1155| 1.54k|#define STR_b "\142" | | ------------------ | | #define STRING_bidiclass STR_b STR_i STR_d STR_i STR_c STR_l STR_a STR_s STR_s | | ------------------ | | | | 1172| 1.54k|#define STR_s "\163" | | ------------------ ------------------ | Branch (2173:7): [True: 0, False: 1.54k] ------------------ 2174| 1.54k| PRIV(strcmp_c8)(name, STRING_bc) == 0) ------------------ | | 177| 1.54k|#define PRIV(name) _pcre2_##name ------------------ PRIV(strcmp_c8)(name, STRING_bc) == 0) ------------------ | | 1257| 1.54k|#define STRING_bc STR_b STR_c | | ------------------ | | | | 1155| 1.54k|#define STR_b "\142" | | ------------------ | | #define STRING_bc STR_b STR_c | | ------------------ | | | | 1156| 1.54k|#define STR_c "\143" | | ------------------ ------------------ | Branch (2174:7): [True: 763, False: 779] ------------------ 2175| 763| { 2176| 763| offset = 4; 2177| 763| sname[0] = CHAR_b; ------------------ | | 1048| 763|#define CHAR_b '\142' ------------------ 2178| 763| sname[1] = CHAR_i; /* There is no strcpy_c8 function */ ------------------ | | 1055| 763|#define CHAR_i '\151' ------------------ 2179| 763| sname[2] = CHAR_d; ------------------ | | 1050| 763|#define CHAR_d '\144' ------------------ 2180| 763| sname[3] = CHAR_i; ------------------ | | 1055| 763|#define CHAR_i '\151' ------------------ 2181| 763| } 2182| | 2183| 779| else if (PRIV(strcmp_c8)(name, STRING_script) == 0 || ------------------ | | 177| 779|#define PRIV(name) _pcre2_##name ------------------ else if (PRIV(strcmp_c8)(name, STRING_script) == 0 || ------------------ | | 1260| 779|#define STRING_script STR_s STR_c STR_r STR_i STR_p STR_t | | ------------------ | | | | 1172| 779|#define STR_s "\163" | | ------------------ | | #define STRING_script STR_s STR_c STR_r STR_i STR_p STR_t | | ------------------ | | | | 1173| 779|#define STR_t "\164" | | ------------------ ------------------ | Branch (2183:12): [True: 194, False: 585] ------------------ 2184| 779| PRIV(strcmp_c8)(name, STRING_sc) == 0) ------------------ | | 177| 585|#define PRIV(name) _pcre2_##name ------------------ PRIV(strcmp_c8)(name, STRING_sc) == 0) ------------------ | | 1259| 585|#define STRING_sc STR_s STR_c | | ------------------ | | | | 1172| 585|#define STR_s "\163" | | ------------------ | | #define STRING_sc STR_s STR_c | | ------------------ | | | | 1156| 585|#define STR_c "\143" | | ------------------ ------------------ | Branch (2184:12): [True: 377, False: 208] ------------------ 2185| 571| ptscript = PT_SC; ------------------ | | 1279| 571|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ 2186| | 2187| 208| else if (PRIV(strcmp_c8)(name, STRING_scriptextensions) == 0 || ------------------ | | 177| 208|#define PRIV(name) _pcre2_##name ------------------ else if (PRIV(strcmp_c8)(name, STRING_scriptextensions) == 0 || ------------------ | | 1261| 208|#define STRING_scriptextensions STR_s STR_c STR_r STR_i STR_p STR_t STR_e STR_x STR_t STR_e STR_n STR_s STR_i STR_o STR_n STR_s | | ------------------ | | | | 1172| 208|#define STR_s "\163" | | ------------------ | | #define STRING_scriptextensions STR_s STR_c STR_r STR_i STR_p STR_t STR_e STR_x STR_t STR_e STR_n STR_s STR_i STR_o STR_n STR_s | | ------------------ | | | | 1172| 208|#define STR_s "\163" | | ------------------ ------------------ | Branch (2187:12): [True: 3, False: 205] ------------------ 2188| 208| PRIV(strcmp_c8)(name, STRING_scx) == 0) ------------------ | | 177| 205|#define PRIV(name) _pcre2_##name ------------------ PRIV(strcmp_c8)(name, STRING_scx) == 0) ------------------ | | 1262| 205|#define STRING_scx STR_s STR_c STR_x | | ------------------ | | | | 1172| 205|#define STR_s "\163" | | ------------------ | | #define STRING_scx STR_s STR_c STR_x | | ------------------ | | | | 1177| 205|#define STR_x "\170" | | ------------------ ------------------ | Branch (2188:12): [True: 202, False: 3] ------------------ 2189| 205| ptscript = PT_SCX; ------------------ | | 1280| 205|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ 2190| | 2191| 3| else 2192| 3| { 2193| 3| *errorcodeptr = ERR47; 2194| 3| return FALSE; ------------------ | | 69| 3|#define FALSE 0 ------------------ 2195| 3| } 2196| | 2197| | /* Adjust the string in name[] as needed */ 2198| | 2199| 1.53k| memmove(name + offset, vptr + 1, (name + i - vptr)*sizeof(PCRE2_UCHAR)); 2200| 1.53k| if (offset != 0) memmove(name, sname, offset*sizeof(PCRE2_UCHAR)); ------------------ | Branch (2200:7): [True: 763, False: 776] ------------------ 2201| 1.53k| } 2202| | 2203| |/* Search for a recognized property using binary chop. */ 2204| | 2205| 10.5k|bot = 0; 2206| 10.5k|top = PRIV(utt_size); ------------------ | | 177| 10.5k|#define PRIV(name) _pcre2_##name ------------------ 2207| | 2208| 78.6k|while (bot < top) ------------------ | Branch (2208:8): [True: 78.5k, False: 63] ------------------ 2209| 78.5k| { 2210| 78.5k| int r; 2211| 78.5k| i = (bot + top) >> 1; 2212| 78.5k| r = PRIV(strcmp_c8)(name, PRIV(utt_names) + PRIV(utt)[i].name_offset); ------------------ | | 177| 78.5k|#define PRIV(name) _pcre2_##name ------------------ r = PRIV(strcmp_c8)(name, PRIV(utt_names) + PRIV(utt)[i].name_offset); ------------------ | | 177| 78.5k|#define PRIV(name) _pcre2_##name ------------------ r = PRIV(strcmp_c8)(name, PRIV(utt_names) + PRIV(utt)[i].name_offset); ------------------ | | 177| 78.5k|#define PRIV(name) _pcre2_##name ------------------ 2213| | 2214| | /* When a matching property is found, some extra checking is needed when the 2215| | \p{xx:yy} syntax is used and xx is either sc or scx. */ 2216| | 2217| 78.5k| if (r == 0) ------------------ | Branch (2217:7): [True: 10.4k, False: 68.0k] ------------------ 2218| 10.4k| { 2219| 10.4k| *pdataptr = PRIV(utt)[i].value; ------------------ | | 177| 10.4k|#define PRIV(name) _pcre2_##name ------------------ 2220| 10.4k| if (vptr == NULL || ptscript == PT_NOTSCRIPT) ------------------ | | 1304| 1.50k|#define PT_NOTSCRIPT 255 ------------------ | Branch (2220:9): [True: 8.98k, False: 1.50k] | Branch (2220:25): [True: 760, False: 745] ------------------ 2221| 9.74k| { 2222| 9.74k| *ptypeptr = PRIV(utt)[i].type; ------------------ | | 177| 9.74k|#define PRIV(name) _pcre2_##name ------------------ 2223| 9.74k| return TRUE; ------------------ | | 70| 9.74k|#define TRUE 1 ------------------ 2224| 9.74k| } 2225| | 2226| 745| switch (PRIV(utt)[i].type) ------------------ | | 177| 745|#define PRIV(name) _pcre2_##name ------------------ | Branch (2226:13): [True: 4, False: 741] ------------------ 2227| 745| { 2228| 196| case PT_SC: ------------------ | | 1279| 196|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (2228:7): [True: 196, False: 549] ------------------ 2229| 196| *ptypeptr = PT_SC; ------------------ | | 1279| 196|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ 2230| 196| return TRUE; ------------------ | | 70| 196|#define TRUE 1 ------------------ 2231| | 2232| 545| case PT_SCX: ------------------ | | 1280| 545|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (2232:7): [True: 545, False: 200] ------------------ 2233| 545| *ptypeptr = ptscript; 2234| 545| return TRUE; ------------------ | | 70| 545|#define TRUE 1 ------------------ 2235| 745| } 2236| | 2237| 4| break; /* Non-script found */ 2238| 745| } 2239| | 2240| 68.0k| if (r > 0) bot = i + 1; else top = i; ------------------ | Branch (2240:7): [True: 37.9k, False: 30.0k] ------------------ 2241| 68.0k| } 2242| | 2243| 67|*errorcodeptr = ERR47; /* Unrecognized property */ 2244| 67|return FALSE; ------------------ | | 69| 67|#define FALSE 0 ------------------ 2245| | 2246| 215|ERROR_RETURN: /* Malformed \P or \p */ 2247| 215|*errorcodeptr = ERR46; 2248| 215|*ptrptr = ptr; 2249| 215|return FALSE; ------------------ | | 69| 215|#define FALSE 0 ------------------ 2250| 10.5k|} pcre2_compile.c:read_name: 2390| 115k|{ 2391| 115k|PCRE2_SPTR ptr = *ptrptr; ------------------ | | 814| 115k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 115k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 115k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 115k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2392| 115k|BOOL is_group = (*ptr != CHAR_ASTERISK); ------------------ | | 992| 115k|#define CHAR_ASTERISK '\052' ------------------ 2393| | 2394| 115k|if (++ptr >= ptrend) /* No characters in name */ ------------------ | Branch (2394:5): [True: 101, False: 115k] ------------------ 2395| 101| { 2396| 101| *errorcodeptr = is_group? ERR62: /* Subpattern name expected */ ------------------ | Branch (2396:19): [True: 101, False: 0] ------------------ 2397| 101| ERR60; /* Verb not recognized or malformed */ 2398| 101| goto FAILED; 2399| 101| } 2400| | 2401| 115k|*nameptr = ptr; 2402| 115k|*offsetptr = (PCRE2_SIZE)(ptr - cb->start_pattern); 2403| | 2404| |/* In UTF mode, a group name may contain letters and decimal digits as defined 2405| |by Unicode properties, and underscores, but must not start with a digit. */ 2406| | 2407| 115k|#ifdef SUPPORT_UNICODE 2408| 115k|if (utf && is_group) ------------------ | Branch (2408:5): [True: 8.29k, False: 107k] | Branch (2408:12): [True: 5.51k, False: 2.78k] ------------------ 2409| 5.51k| { 2410| 5.51k| uint32_t c, type; 2411| | 2412| 5.51k| GETCHAR(c, ptr); ------------------ | | 302| 5.51k| c = *eptr; \ | | 303| 5.51k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 404| { \ | | | | 267| 404| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 221, False: 183] | | | | ------------------ | | | | 268| 404| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 404| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 110, False: 73] | | | | ------------------ | | | | 270| 183| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 183| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 73, False: 0] | | | | ------------------ | | | | 272| 73| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 73| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 73| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 404| } | | ------------------ | | | Branch (303:7): [True: 404, False: 5.11k] | | ------------------ ------------------ 2413| 5.51k| type = UCD_CHARTYPE(c); ------------------ | | 1857| 5.51k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 5.51k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 5.51k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 5.51k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 5.51k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 5.51k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 5.51k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 5.51k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 5.51k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 5.51k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 5.51k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2414| | 2415| 5.51k| if (type == ucp_Nd) ------------------ | Branch (2415:7): [True: 7, False: 5.50k] ------------------ 2416| 7| { 2417| 7| *errorcodeptr = ERR44; 2418| 7| goto FAILED; 2419| 7| } 2420| | 2421| 5.50k| for(;;) 2422| 12.8k| { 2423| 12.8k| if (type != ucp_Nd && PRIV(ucp_gentype)[type] != ucp_L && ------------------ | | 177| 12.2k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2423:9): [True: 12.2k, False: 615] | Branch (2423:27): [True: 5.41k, False: 6.80k] ------------------ 2424| 12.8k| c != CHAR_UNDERSCORE) break; ------------------ | | 1045| 5.41k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (2424:9): [True: 5.40k, False: 3] ------------------ 2425| 7.42k| ptr++; 2426| 7.42k| FORWARDCHARTEST(ptr, ptrend); ------------------ | | 349| 9.26k|#define FORWARDCHARTEST(eptr,end) while(eptr < end && (*eptr & 0xc0u) == 0x80u) eptr++ | | ------------------ | | | Branch (349:41): [True: 9.16k, False: 98] | | | Branch (349:55): [True: 1.84k, False: 7.32k] | | ------------------ ------------------ 2427| 7.42k| if (ptr >= ptrend) break; ------------------ | Branch (2427:9): [True: 98, False: 7.32k] ------------------ 2428| 7.32k| GETCHAR(c, ptr); ------------------ | | 302| 7.32k| c = *eptr; \ | | 303| 7.32k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 519| { \ | | | | 267| 519| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 71, False: 448] | | | | ------------------ | | | | 268| 519| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 519| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 198, False: 250] | | | | ------------------ | | | | 270| 448| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 448| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 250, False: 0] | | | | ------------------ | | | | 272| 250| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 250| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 250| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 519| } | | ------------------ | | | Branch (303:7): [True: 519, False: 6.80k] | | ------------------ ------------------ 2429| 7.32k| type = UCD_CHARTYPE(c); ------------------ | | 1857| 7.32k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 7.32k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 7.32k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 7.32k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 7.32k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 7.32k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 7.32k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 7.32k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 7.32k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 7.32k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 7.32k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2430| 7.32k| } 2431| 5.50k| } 2432| 110k|else 2433| |#else 2434| |(void)utf; /* Avoid compiler warning */ 2435| |#endif /* SUPPORT_UNICODE */ 2436| | 2437| |/* Handle non-group names and group names in non-UTF modes. A group name must 2438| |not start with a digit. If either of the others start with a digit it just 2439| |won't be recognized. */ 2440| | 2441| 110k| { 2442| 110k| if (is_group && IS_DIGIT(*ptr)) ------------------ | | 408| 92.9k|#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 998| 185k|#define CHAR_0 '\060' | | ------------------ | | #define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9) | | ------------------ | | | | 1007| 92.9k|#define CHAR_9 '\071' | | ------------------ | | | Branch (408:22): [True: 92.9k, False: 29] | | | Branch (408:39): [True: 7, False: 92.9k] | | ------------------ ------------------ | Branch (2442:7): [True: 92.9k, False: 17.4k] ------------------ 2443| 7| { 2444| 7| *errorcodeptr = ERR44; 2445| 7| goto FAILED; 2446| 7| } 2447| | 2448| 273k| while (ptr < ptrend && MAX_255(*ptr) && (cb->ctypes[*ptr] & ctype_word) != 0) ------------------ | | 212| 273k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 546k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ while (ptr < ptrend && MAX_255(*ptr) && (cb->ctypes[*ptr] & ctype_word) != 0) ------------------ | | 583| 273k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (2448:10): [True: 273k, False: 58] | Branch (2448:43): [True: 162k, False: 110k] ------------------ 2449| 162k| { 2450| 162k| ptr++; 2451| 162k| } 2452| 110k| } 2453| | 2454| |/* Check name length */ 2455| | 2456| 115k|if (ptr > *nameptr + MAX_NAME_SIZE) ------------------ | | 199| 115k|#define MAX_NAME_SIZE 32 ------------------ | Branch (2456:5): [True: 21, False: 115k] ------------------ 2457| 21| { 2458| 21| *errorcodeptr = ERR48; 2459| 21| goto FAILED; 2460| 21| } 2461| 115k|*namelenptr = (uint32_t)(ptr - *nameptr); 2462| | 2463| |/* Subpattern names must not be empty, and their terminator is checked here. 2464| |(What follows a verb or alpha assertion name is checked separately.) */ 2465| | 2466| 115k|if (is_group) ------------------ | Branch (2466:5): [True: 98.4k, False: 17.4k] ------------------ 2467| 98.4k| { 2468| 98.4k| if (ptr == *nameptr) ------------------ | Branch (2468:7): [True: 151, False: 98.2k] ------------------ 2469| 151| { 2470| 151| *errorcodeptr = ERR62; /* Subpattern name expected */ 2471| 151| goto FAILED; 2472| 151| } 2473| 98.2k| if (ptr >= ptrend || *ptr != (PCRE2_UCHAR)terminator) ------------------ | Branch (2473:7): [True: 108, False: 98.1k] | Branch (2473:24): [True: 55, False: 98.1k] ------------------ 2474| 163| { 2475| 163| *errorcodeptr = ERR42; 2476| 163| goto FAILED; 2477| 163| } 2478| 98.1k| ptr++; 2479| 98.1k| } 2480| | 2481| 115k|*ptrptr = ptr; 2482| 115k|return TRUE; ------------------ | | 70| 115k|#define TRUE 1 ------------------ 2483| | 2484| 450|FAILED: 2485| 450|*ptrptr = ptr; 2486| 450|return FALSE; ------------------ | | 69| 450|#define FALSE 0 ------------------ 2487| 115k|} pcre2_compile.c:check_posix_syntax: 2302| 26.5k|{ 2303| 26.5k|PCRE2_UCHAR terminator; /* Don't combine these lines; the Solaris cc */ ------------------ | | 813| 26.5k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 26.5k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 26.5k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 26.5k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2304| 26.5k|terminator = *ptr++; /* compiler warns about "non-constant" initializer. */ 2305| | 2306| 361k|for (; ptrend - ptr >= 2; ptr++) ------------------ | Branch (2306:8): [True: 360k, False: 377] ------------------ 2307| 360k| { 2308| 360k| if (*ptr == CHAR_BACKSLASH && ------------------ | | 1042| 721k|#define CHAR_BACKSLASH '\134' ------------------ | Branch (2308:7): [True: 1.64k, False: 359k] ------------------ 2309| 360k| (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET || ptr[1] == CHAR_BACKSLASH)) ------------------ | | 1043| 3.28k|#define CHAR_RIGHT_SQUARE_BRACKET '\135' ------------------ (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET || ptr[1] == CHAR_BACKSLASH)) ------------------ | | 1042| 1.43k|#define CHAR_BACKSLASH '\134' ------------------ | Branch (2309:8): [True: 206, False: 1.43k] | Branch (2309:47): [True: 225, False: 1.21k] ------------------ 2310| 431| ptr++; 2311| | 2312| 360k| else if ((*ptr == CHAR_LEFT_SQUARE_BRACKET && ptr[1] == terminator) || ------------------ | | 1041| 720k|#define CHAR_LEFT_SQUARE_BRACKET '\133' ------------------ | Branch (2312:13): [True: 2.34k, False: 358k] | Branch (2312:49): [True: 1.02k, False: 1.31k] ------------------ 2313| 360k| *ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE; ------------------ | | 1043| 359k|#define CHAR_RIGHT_SQUARE_BRACKET '\135' ------------------ *ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE; ------------------ | | 69| 20.9k|#define FALSE 0 ------------------ | Branch (2313:13): [True: 19.9k, False: 339k] ------------------ 2314| | 2315| 339k| else if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET) ------------------ | | 1043| 5.93k|#define CHAR_RIGHT_SQUARE_BRACKET '\135' ------------------ | Branch (2315:12): [True: 5.93k, False: 333k] | Branch (2315:34): [True: 5.21k, False: 729] ------------------ 2316| 5.21k| { 2317| 5.21k| *endptr = ptr; 2318| 5.21k| return TRUE; ------------------ | | 70| 5.21k|#define TRUE 1 ------------------ 2319| 5.21k| } 2320| 360k| } 2321| | 2322| 377|return FALSE; ------------------ | | 69| 377|#define FALSE 0 ------------------ 2323| 26.5k|} pcre2_compile.c:check_posix_name: 2343| 5.18k|{ 2344| 5.18k|const char *pn = posix_names; 2345| 5.18k|int yield = 0; 2346| 34.1k|while (posix_name_lengths[yield] != 0) ------------------ | Branch (2346:8): [True: 34.1k, False: 36] ------------------ 2347| 34.1k| { 2348| 34.1k| if (len == posix_name_lengths[yield] && ------------------ | Branch (2348:7): [True: 22.2k, False: 11.9k] ------------------ 2349| 34.1k| PRIV(strncmp_c8)(ptr, pn, (unsigned int)len) == 0) return yield; ------------------ | | 177| 22.2k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2349:5): [True: 5.14k, False: 17.0k] ------------------ 2350| 28.9k| pn += posix_name_lengths[yield] + 1; 2351| 28.9k| yield++; 2352| 28.9k| } 2353| 36|return -1; 2354| 5.18k|} pcre2_compile.c:check_lookbehinds: 9754| 21.4k|{ 9755| 21.4k|int errorcode = 0; 9756| 21.4k|int nestlevel = 0; 9757| | 9758| 21.4k|cb->erroroffset = PCRE2_UNSET; ------------------ | | 480| 21.4k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ 9759| | 9760| 5.15M|for (; *pptr != META_END; pptr++) ------------------ | | 211| 5.15M|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (9760:8): [True: 5.14M, False: 2.85k] ------------------ 9761| 5.14M| { 9762| 5.14M| if (*pptr < META_END) continue; /* Literal */ ------------------ | | 211| 5.14M|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (9762:7): [True: 740k, False: 4.40M] ------------------ 9763| | 9764| 4.40M| switch (META_CODE(*pptr)) ------------------ | | 113| 4.40M|#define META_CODE(x) (x & 0xffff0000u) ------------------ 9765| 4.40M| { 9766| 0| default: ------------------ | Branch (9766:5): [True: 0, False: 4.40M] ------------------ 9767| 0| return ERR70; /* Unrecognized meta code */ 9768| | 9769| 16.2k| case META_ESCAPE: ------------------ | | 236| 16.2k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (9769:5): [True: 16.2k, False: 4.39M] ------------------ 9770| 16.2k| if (*pptr - META_ESCAPE == ESC_P || *pptr - META_ESCAPE == ESC_p) ------------------ | | 236| 16.2k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ if (*pptr - META_ESCAPE == ESC_P || *pptr - META_ESCAPE == ESC_p) ------------------ | | 236| 15.8k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (9770:9): [True: 333, False: 15.8k] | Branch (9770:41): [True: 541, False: 15.3k] ------------------ 9771| 874| pptr += 1; 9772| 16.2k| break; 9773| | 9774| 2.11M| case META_KET: ------------------ | | 237| 2.11M|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ | Branch (9774:5): [True: 2.11M, False: 2.29M] ------------------ 9775| 2.11M| if (--nestlevel < 0) ------------------ | Branch (9775:9): [True: 17.9k, False: 2.09M] ------------------ 9776| 17.9k| { 9777| 17.9k| if (retptr != NULL) *retptr = pptr; ------------------ | Branch (9777:11): [True: 17.9k, False: 5] ------------------ 9778| 17.9k| return 0; 9779| 17.9k| } 9780| 2.09M| break; 9781| | 9782| 2.09M| case META_ATOMIC: ------------------ | | 214| 442|#define META_ATOMIC 0x80020000u /* atomic group */ ------------------ | Branch (9782:5): [True: 442, False: 4.40M] ------------------ 9783| 2.08M| case META_CAPTURE: ------------------ | | 220| 2.08M|#define META_CAPTURE 0x80080000u /* Capturing parenthesis */ ------------------ | Branch (9783:5): [True: 2.08M, False: 2.32M] ------------------ 9784| 2.08M| case META_COND_ASSERT: ------------------ | | 227| 2.08M|#define META_COND_ASSERT 0x800f0000u /* (?(?assertion)... */ ------------------ | Branch (9784:5): [True: 243, False: 4.40M] ------------------ 9785| 2.08M| case META_LOOKAHEAD: ------------------ | | 251| 2.08M|#define META_LOOKAHEAD 0x80230000u /* (?= */ ------------------ | Branch (9785:5): [True: 535, False: 4.40M] ------------------ 9786| 2.08M| case META_LOOKAHEADNOT: ------------------ | | 252| 2.08M|#define META_LOOKAHEADNOT 0x80240000u /* (?! */ ------------------ | Branch (9786:5): [True: 419, False: 4.40M] ------------------ 9787| 2.08M| case META_LOOKAHEAD_NA: ------------------ | | 258| 2.08M|#define META_LOOKAHEAD_NA 0x80270000u /* (*napla: */ ------------------ | Branch (9787:5): [True: 324, False: 4.40M] ------------------ 9788| 2.09M| case META_NOCAPTURE: ------------------ | | 238| 2.09M|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ | Branch (9788:5): [True: 8.96k, False: 4.39M] ------------------ 9789| 2.09M| case META_SCRIPT_RUN: ------------------ | | 246| 2.09M|#define META_SCRIPT_RUN 0x80220000u /* (*script_run:...) */ ------------------ | Branch (9789:5): [True: 289, False: 4.40M] ------------------ 9790| 2.09M| nestlevel++; 9791| 2.09M| break; 9792| | 9793| 233| case META_ACCEPT: ------------------ | | 266| 233|#define META_ACCEPT 0x802a0000u /* (*ACCEPT) */ ------------------ | Branch (9793:5): [True: 233, False: 4.40M] ------------------ 9794| 4.33k| case META_ALT: ------------------ | | 213| 4.33k|#define META_ALT 0x80010000u /* alternation */ ------------------ | Branch (9794:5): [True: 4.10k, False: 4.40M] ------------------ 9795| 7.01k| case META_ASTERISK: ------------------ | | 279| 7.01k|#define META_ASTERISK 0x80340000u /* * */ ------------------ | Branch (9795:5): [True: 2.68k, False: 4.40M] ------------------ 9796| 7.43k| case META_ASTERISK_PLUS: ------------------ | | 280| 7.43k|#define META_ASTERISK_PLUS 0x80350000u /* *+ */ ------------------ | Branch (9796:5): [True: 420, False: 4.40M] ------------------ 9797| 7.64k| case META_ASTERISK_QUERY: ------------------ | | 281| 7.64k|#define META_ASTERISK_QUERY 0x80360000u /* *? */ ------------------ | Branch (9797:5): [True: 201, False: 4.40M] ------------------ 9798| 8.54k| case META_BACKREF: ------------------ | | 215| 8.54k|#define META_BACKREF 0x80030000u /* Back ref */ ------------------ | Branch (9798:5): [True: 902, False: 4.40M] ------------------ 9799| 9.58k| case META_CIRCUMFLEX: ------------------ | | 221| 9.58k|#define META_CIRCUMFLEX 0x80090000u /* ^ metacharacter */ ------------------ | Branch (9799:5): [True: 1.03k, False: 4.40M] ------------------ 9800| 14.3k| case META_CLASS: ------------------ | | 222| 14.3k|#define META_CLASS 0x800a0000u /* start non-empty class */ ------------------ | Branch (9800:5): [True: 4.79k, False: 4.40M] ------------------ 9801| 14.5k| case META_CLASS_EMPTY: ------------------ | | 223| 14.5k|#define META_CLASS_EMPTY 0x800b0000u /* empty class */ ------------------ | Branch (9801:5): [True: 199, False: 4.40M] ------------------ 9802| 14.7k| case META_CLASS_EMPTY_NOT: ------------------ | | 224| 14.7k|#define META_CLASS_EMPTY_NOT 0x800c0000u /* negative empty class */ ------------------ | Branch (9802:5): [True: 195, False: 4.40M] ------------------ 9803| 30.3k| case META_CLASS_END: ------------------ | | 225| 30.3k|#define META_CLASS_END 0x800d0000u /* end of non-empty class */ ------------------ | Branch (9803:5): [True: 15.6k, False: 4.39M] ------------------ 9804| 41.1k| case META_CLASS_NOT: ------------------ | | 226| 41.1k|#define META_CLASS_NOT 0x800e0000u /* start non-empty negative class */ ------------------ | Branch (9804:5): [True: 10.8k, False: 4.39M] ------------------ 9805| 41.4k| case META_COMMIT: ------------------ | | 268| 41.4k|#define META_COMMIT 0x802c0000u /* These */ ------------------ | Branch (9805:5): [True: 214, False: 4.40M] ------------------ 9806| 42.3k| case META_DOLLAR: ------------------ | | 234| 42.3k|#define META_DOLLAR 0x80160000u /* $ metacharacter */ ------------------ | Branch (9806:5): [True: 980, False: 4.40M] ------------------ 9807| 47.3k| case META_DOT: ------------------ | | 235| 47.3k|#define META_DOT 0x80170000u /* . metacharacter */ ------------------ | Branch (9807:5): [True: 4.99k, False: 4.40M] ------------------ 9808| 47.6k| case META_FAIL: ------------------ | | 267| 47.6k|#define META_FAIL 0x802b0000u /* (*FAIL) */ ------------------ | Branch (9808:5): [True: 285, False: 4.40M] ------------------ 9809| 52.0k| case META_PLUS: ------------------ | | 282| 52.0k|#define META_PLUS 0x80370000u /* + */ ------------------ | Branch (9809:5): [True: 4.37k, False: 4.40M] ------------------ 9810| 52.2k| case META_PLUS_PLUS: ------------------ | | 283| 52.2k|#define META_PLUS_PLUS 0x80380000u /* ++ */ ------------------ | Branch (9810:5): [True: 222, False: 4.40M] ------------------ 9811| 52.5k| case META_PLUS_QUERY: ------------------ | | 284| 52.5k|#define META_PLUS_QUERY 0x80390000u /* +? */ ------------------ | Branch (9811:5): [True: 285, False: 4.40M] ------------------ 9812| 52.8k| case META_PRUNE: ------------------ | | 270| 52.8k|#define META_PRUNE 0x802e0000u /* must */ ------------------ | Branch (9812:5): [True: 322, False: 4.40M] ------------------ 9813| 66.1k| case META_QUERY: ------------------ | | 285| 66.1k|#define META_QUERY 0x803a0000u /* ? */ ------------------ | Branch (9813:5): [True: 13.3k, False: 4.39M] ------------------ 9814| 66.4k| case META_QUERY_PLUS: ------------------ | | 286| 66.4k|#define META_QUERY_PLUS 0x803b0000u /* ?+ */ ------------------ | Branch (9814:5): [True: 246, False: 4.40M] ------------------ 9815| 66.7k| case META_QUERY_QUERY: ------------------ | | 287| 66.7k|#define META_QUERY_QUERY 0x803c0000u /* ?? */ ------------------ | Branch (9815:5): [True: 314, False: 4.40M] ------------------ 9816| 66.9k| case META_RANGE_ESCAPED: ------------------ | | 242| 66.9k|#define META_RANGE_ESCAPED 0x801e0000u /* range with at least one escape */ ------------------ | Branch (9816:5): [True: 194, False: 4.40M] ------------------ 9817| 67.1k| case META_RANGE_LITERAL: ------------------ | | 243| 67.1k|#define META_RANGE_LITERAL 0x801f0000u /* range defined literally */ ------------------ | Branch (9817:5): [True: 210, False: 4.40M] ------------------ 9818| 67.3k| case META_SKIP: ------------------ | | 272| 67.3k|#define META_SKIP 0x80300000u /* kept */ ------------------ | Branch (9818:5): [True: 198, False: 4.40M] ------------------ 9819| 67.5k| case META_THEN: ------------------ | | 274| 67.5k|#define META_THEN 0x80320000u /* this */ ------------------ | Branch (9819:5): [True: 207, False: 4.40M] ------------------ 9820| 67.5k| break; 9821| | 9822| 1.26k| case META_RECURSE: ------------------ | | 244| 1.26k|#define META_RECURSE 0x80200000u /* Recursion */ ------------------ | Branch (9822:5): [True: 1.26k, False: 4.40M] ------------------ 9823| 1.26k| pptr += SIZEOFFSET; ------------------ | | 108| 1.26k|#define SIZEOFFSET 2 ------------------ 9824| 1.26k| break; 9825| | 9826| 223| case META_BACKREF_BYNAME: ------------------ | | 216| 223|#define META_BACKREF_BYNAME 0x80040000u /* \k'name' */ ------------------ | Branch (9826:5): [True: 223, False: 4.40M] ------------------ 9827| 417| case META_RECURSE_BYNAME: ------------------ | | 245| 417|#define META_RECURSE_BYNAME 0x80210000u /* (?&name) */ ------------------ | Branch (9827:5): [True: 194, False: 4.40M] ------------------ 9828| 417| pptr += 1 + SIZEOFFSET; ------------------ | | 108| 417|#define SIZEOFFSET 2 ------------------ 9829| 417| break; 9830| | 9831| 0| case META_COND_DEFINE: ------------------ | | 228| 0|#define META_COND_DEFINE 0x80100000u /* (?(DEFINE)... */ ------------------ | Branch (9831:5): [True: 0, False: 4.40M] ------------------ 9832| 0| pptr += SIZEOFFSET; ------------------ | | 108| 0|#define SIZEOFFSET 2 ------------------ 9833| 0| nestlevel++; 9834| 0| break; 9835| | 9836| 285| case META_COND_NAME: ------------------ | | 229| 285|#define META_COND_NAME 0x80110000u /* (?()... */ ------------------ | Branch (9836:5): [True: 285, False: 4.40M] ------------------ 9837| 618| case META_COND_NUMBER: ------------------ | | 230| 618|#define META_COND_NUMBER 0x80120000u /* (?(digits)... */ ------------------ | Branch (9837:5): [True: 333, False: 4.40M] ------------------ 9838| 841| case META_COND_RNAME: ------------------ | | 231| 841|#define META_COND_RNAME 0x80130000u /* (?(R&name)... */ ------------------ | Branch (9838:5): [True: 223, False: 4.40M] ------------------ 9839| 1.07k| case META_COND_RNUMBER: ------------------ | | 232| 1.07k|#define META_COND_RNUMBER 0x80140000u /* (?(Rdigits)... */ ------------------ | Branch (9839:5): [True: 235, False: 4.40M] ------------------ 9840| 1.07k| pptr += 1 + SIZEOFFSET; ------------------ | | 108| 1.07k|#define SIZEOFFSET 2 ------------------ 9841| 1.07k| nestlevel++; 9842| 1.07k| break; 9843| | 9844| 279| case META_COND_VERSION: ------------------ | | 233| 279|#define META_COND_VERSION 0x80150000u /* (?(VERSIONx.y)... */ ------------------ | Branch (9844:5): [True: 279, False: 4.40M] ------------------ 9845| 279| pptr += 3; 9846| 279| nestlevel++; 9847| 279| break; 9848| | 9849| 220| case META_CALLOUT_STRING: ------------------ | | 219| 220|#define META_CALLOUT_STRING 0x80070000u /* (?C with string argument */ ------------------ | Branch (9849:5): [True: 220, False: 4.40M] ------------------ 9850| 220| pptr += 3 + SIZEOFFSET; ------------------ | | 108| 220|#define SIZEOFFSET 2 ------------------ 9851| 220| break; 9852| | 9853| 0| case META_BIGVALUE: ------------------ | | 217| 0|#define META_BIGVALUE 0x80050000u /* Next is a literal > META_END */ ------------------ | Branch (9853:5): [True: 0, False: 4.40M] ------------------ 9854| 516| case META_POSIX: ------------------ | | 240| 516|#define META_POSIX 0x801c0000u /* POSIX class item */ ------------------ | Branch (9854:5): [True: 516, False: 4.40M] ------------------ 9855| 710| case META_POSIX_NEG: ------------------ | | 241| 710|#define META_POSIX_NEG 0x801d0000u /* negative POSIX class item */ ------------------ | Branch (9855:5): [True: 194, False: 4.40M] ------------------ 9856| 710| pptr += 1; 9857| 710| break; 9858| | 9859| 13.3k| case META_MINMAX: ------------------ | | 288| 13.3k|#define META_MINMAX 0x803d0000u /* {n,m} repeat */ ------------------ | Branch (9859:5): [True: 13.3k, False: 4.39M] ------------------ 9860| 13.5k| case META_MINMAX_QUERY: ------------------ | | 290| 13.5k|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (9860:5): [True: 268, False: 4.40M] ------------------ 9861| 14.4k| case META_MINMAX_PLUS: ------------------ | | 289| 14.4k|#define META_MINMAX_PLUS 0x803e0000u /* {n,m}+ repeat */ ------------------ | Branch (9861:5): [True: 866, False: 4.40M] ------------------ 9862| 14.7k| case META_OPTIONS: ------------------ | | 239| 14.7k|#define META_OPTIONS 0x801b0000u /* (?i) and friends */ ------------------ | Branch (9862:5): [True: 264, False: 4.40M] ------------------ 9863| 14.7k| pptr += 2; 9864| 14.7k| break; 9865| | 9866| 84.1k| case META_CALLOUT_NUMBER: ------------------ | | 218| 84.1k|#define META_CALLOUT_NUMBER 0x80060000u /* (?C with numerical argument */ ------------------ | Branch (9866:5): [True: 84.1k, False: 4.32M] ------------------ 9867| 84.1k| pptr += 3; 9868| 84.1k| break; 9869| | 9870| 266| case META_MARK: ------------------ | | 265| 266|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ | Branch (9870:5): [True: 266, False: 4.40M] ------------------ 9871| 476| case META_COMMIT_ARG: ------------------ | | 269| 476|#define META_COMMIT_ARG 0x802d0000u /* pairs */ ------------------ | Branch (9871:5): [True: 210, False: 4.40M] ------------------ 9872| 686| case META_PRUNE_ARG: ------------------ | | 271| 686|#define META_PRUNE_ARG 0x802f0000u /* be */ ------------------ | Branch (9872:5): [True: 210, False: 4.40M] ------------------ 9873| 885| case META_SKIP_ARG: ------------------ | | 273| 885|#define META_SKIP_ARG 0x80310000u /* in */ ------------------ | Branch (9873:5): [True: 199, False: 4.40M] ------------------ 9874| 3.00k| case META_THEN_ARG: ------------------ | | 275| 3.00k|#define META_THEN_ARG 0x80330000u /* order */ ------------------ | Branch (9874:5): [True: 2.11k, False: 4.40M] ------------------ 9875| 3.00k| pptr += 1 + pptr[1]; 9876| 3.00k| break; 9877| | 9878| 1.76k| case META_LOOKBEHIND: ------------------ | | 253| 1.76k|#define META_LOOKBEHIND 0x80250000u /* (?<= */ ------------------ | Branch (9878:5): [True: 1.76k, False: 4.40M] ------------------ 9879| 4.37k| case META_LOOKBEHINDNOT: ------------------ | | 254| 4.37k|#define META_LOOKBEHINDNOT 0x80260000u /* (?erroroffset == PCRE2_UNSET) cb->erroroffset = offset; ------------------ | | 480| 781|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (9713:9): [True: 365, False: 416] ------------------ 9714| 781| return FALSE; ------------------ | | 69| 781|#define FALSE 0 ------------------ 9715| 781| } 9716| 9.98k| if (branchlength > cb->max_lookbehind) cb->max_lookbehind = branchlength; ------------------ | Branch (9716:7): [True: 1.22k, False: 8.76k] ------------------ 9717| 9.98k| *bptr |= branchlength; /* branchlength never more than 65535 */ 9718| 9.98k| bptr = *pptrptr; 9719| 9.98k| } 9720| 9.98k|while (*bptr == META_ALT); ------------------ | | 213| 9.98k|#define META_ALT 0x80010000u /* alternation */ ------------------ | Branch (9720:8): [True: 1.78k, False: 8.20k] ------------------ 9721| | 9722| 8.20k|return TRUE; ------------------ | | 70| 8.20k|#define TRUE 1 ------------------ 9723| 8.98k|} pcre2_compile.c:get_branchlength: 9286| 107k|{ 9287| 107k|int branchlength = 0; 9288| 107k|int grouplength; 9289| 107k|uint32_t lastitemlength = 0; 9290| 107k|uint32_t *pptr = *pptrptr; 9291| 107k|PCRE2_SIZE offset; ------------------ | | 477| 107k|#define PCRE2_SIZE size_t ------------------ 9292| 107k|parsed_recurse_check this_recurse; 9293| | 9294| |/* A large and/or complex regex can take too long to process. This can happen 9295| |more often when (?| groups are present in the pattern because their length 9296| |cannot be cached. */ 9297| | 9298| 107k|if ((*lcptr)++ > 2000) ------------------ | Branch (9298:5): [True: 11, False: 107k] ------------------ 9299| 11| { 9300| 11| *errcodeptr = ERR35; /* Lookbehind is too complicated */ 9301| 11| return -1; 9302| 11| } 9303| | 9304| |/* Scan the branch, accumulating the length. */ 9305| | 9306| 491k|for (;; pptr++) 9307| 599k| { 9308| 599k| parsed_recurse_check *r; 9309| 599k| uint32_t *gptr, *gptrend; 9310| 599k| uint32_t escape; 9311| 599k| uint32_t group = 0; 9312| 599k| uint32_t itemlength = 0; 9313| | 9314| 599k| if (*pptr < META_END) ------------------ | | 211| 599k|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (9314:7): [True: 303k, False: 295k] ------------------ 9315| 303k| { 9316| 303k| itemlength = 1; 9317| 303k| } 9318| | 9319| 295k| else switch (META_CODE(*pptr)) ------------------ | | 113| 295k|#define META_CODE(x) (x & 0xffff0000u) ------------------ 9320| 295k| { 9321| 92.5k| case META_KET: ------------------ | | 237| 92.5k|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ | Branch (9321:5): [True: 92.5k, False: 203k] ------------------ 9322| 95.3k| case META_ALT: ------------------ | | 213| 95.3k|#define META_ALT 0x80010000u /* alternation */ ------------------ | Branch (9322:5): [True: 2.81k, False: 293k] ------------------ 9323| 95.3k| goto EXIT; 9324| | 9325| | /* (*ACCEPT) and (*FAIL) terminate the branch, but we must skip to the 9326| | actual termination. */ 9327| | 9328| 330| case META_ACCEPT: ------------------ | | 266| 330|#define META_ACCEPT 0x802a0000u /* (*ACCEPT) */ ------------------ | Branch (9328:5): [True: 330, False: 295k] ------------------ 9329| 804| case META_FAIL: ------------------ | | 267| 804|#define META_FAIL 0x802b0000u /* (*FAIL) */ ------------------ | Branch (9329:5): [True: 474, False: 295k] ------------------ 9330| 804| pptr = parsed_skip(pptr, PSKIP_ALT); 9331| 804| if (pptr == NULL) goto PARSED_SKIP_FAILED; ------------------ | Branch (9331:9): [True: 0, False: 804] ------------------ 9332| 804| goto EXIT; 9333| | 9334| 804| case META_MARK: ------------------ | | 265| 229|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ | Branch (9334:5): [True: 229, False: 295k] ------------------ 9335| 458| case META_COMMIT_ARG: ------------------ | | 269| 458|#define META_COMMIT_ARG 0x802d0000u /* pairs */ ------------------ | Branch (9335:5): [True: 229, False: 295k] ------------------ 9336| 726| case META_PRUNE_ARG: ------------------ | | 271| 726|#define META_PRUNE_ARG 0x802f0000u /* be */ ------------------ | Branch (9336:5): [True: 268, False: 295k] ------------------ 9337| 1.19k| case META_SKIP_ARG: ------------------ | | 273| 1.19k|#define META_SKIP_ARG 0x80310000u /* in */ ------------------ | Branch (9337:5): [True: 470, False: 295k] ------------------ 9338| 1.47k| case META_THEN_ARG: ------------------ | | 275| 1.47k|#define META_THEN_ARG 0x80330000u /* order */ ------------------ | Branch (9338:5): [True: 277, False: 295k] ------------------ 9339| 1.47k| pptr += pptr[1] + 1; 9340| 1.47k| break; 9341| | 9342| 215| case META_CIRCUMFLEX: ------------------ | | 221| 215|#define META_CIRCUMFLEX 0x80090000u /* ^ metacharacter */ ------------------ | Branch (9342:5): [True: 215, False: 295k] ------------------ 9343| 411| case META_COMMIT: ------------------ | | 268| 411|#define META_COMMIT 0x802c0000u /* These */ ------------------ | Branch (9343:5): [True: 196, False: 295k] ------------------ 9344| 3.40k| case META_DOLLAR: ------------------ | | 234| 3.40k|#define META_DOLLAR 0x80160000u /* $ metacharacter */ ------------------ | Branch (9344:5): [True: 2.99k, False: 292k] ------------------ 9345| 3.64k| case META_PRUNE: ------------------ | | 270| 3.64k|#define META_PRUNE 0x802e0000u /* must */ ------------------ | Branch (9345:5): [True: 240, False: 295k] ------------------ 9346| 3.84k| case META_SKIP: ------------------ | | 272| 3.84k|#define META_SKIP 0x80300000u /* kept */ ------------------ | Branch (9346:5): [True: 201, False: 295k] ------------------ 9347| 4.05k| case META_THEN: ------------------ | | 274| 4.05k|#define META_THEN 0x80320000u /* this */ ------------------ | Branch (9347:5): [True: 204, False: 295k] ------------------ 9348| 4.05k| break; 9349| | 9350| 270| case META_OPTIONS: ------------------ | | 239| 270|#define META_OPTIONS 0x801b0000u /* (?i) and friends */ ------------------ | Branch (9350:5): [True: 270, False: 295k] ------------------ 9351| 270| pptr += 2; 9352| 270| break; 9353| | 9354| 0| case META_BIGVALUE: ------------------ | | 217| 0|#define META_BIGVALUE 0x80050000u /* Next is a literal > META_END */ ------------------ | Branch (9354:5): [True: 0, False: 295k] ------------------ 9355| 0| itemlength = 1; 9356| 0| pptr += 1; 9357| 0| break; 9358| | 9359| 931| case META_CLASS: ------------------ | | 222| 931|#define META_CLASS 0x800a0000u /* start non-empty class */ ------------------ | Branch (9359:5): [True: 931, False: 295k] ------------------ 9360| 1.24k| case META_CLASS_NOT: ------------------ | | 226| 1.24k|#define META_CLASS_NOT 0x800e0000u /* start non-empty negative class */ ------------------ | Branch (9360:5): [True: 311, False: 295k] ------------------ 9361| 1.24k| itemlength = 1; 9362| 1.24k| pptr = parsed_skip(pptr, PSKIP_CLASS); 9363| 1.24k| if (pptr == NULL) goto PARSED_SKIP_FAILED; ------------------ | Branch (9363:9): [True: 0, False: 1.24k] ------------------ 9364| 1.24k| break; 9365| | 9366| 1.24k| case META_CLASS_EMPTY_NOT: ------------------ | | 224| 203|#define META_CLASS_EMPTY_NOT 0x800c0000u /* negative empty class */ ------------------ | Branch (9366:5): [True: 203, False: 295k] ------------------ 9367| 846| case META_DOT: ------------------ | | 235| 846|#define META_DOT 0x80170000u /* . metacharacter */ ------------------ | Branch (9367:5): [True: 643, False: 295k] ------------------ 9368| 846| itemlength = 1; 9369| 846| break; 9370| | 9371| 67.8k| case META_CALLOUT_NUMBER: ------------------ | | 218| 67.8k|#define META_CALLOUT_NUMBER 0x80060000u /* (?C with numerical argument */ ------------------ | Branch (9371:5): [True: 67.8k, False: 228k] ------------------ 9372| 67.8k| pptr += 3; 9373| 67.8k| break; 9374| | 9375| 194| case META_CALLOUT_STRING: ------------------ | | 219| 194|#define META_CALLOUT_STRING 0x80070000u /* (?C with string argument */ ------------------ | Branch (9375:5): [True: 194, False: 295k] ------------------ 9376| 194| pptr += 3 + SIZEOFFSET; ------------------ | | 108| 194|#define SIZEOFFSET 2 ------------------ 9377| 194| break; 9378| | 9379| | /* Only some escapes consume a character. Of those, \R and \X are never 9380| | allowed because they might match more than character. \C is allowed only in 9381| | 32-bit and non-UTF 8/16-bit modes. */ 9382| | 9383| 3.57k| case META_ESCAPE: ------------------ | | 236| 3.57k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (9383:5): [True: 3.57k, False: 292k] ------------------ 9384| 3.57k| escape = META_DATA(*pptr); ------------------ | | 114| 3.57k|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 9385| 3.57k| if (escape == ESC_R || escape == ESC_X) return -1; ------------------ | Branch (9385:9): [True: 8, False: 3.56k] | Branch (9385:28): [True: 5, False: 3.55k] ------------------ 9386| 3.55k| if (escape > ESC_b && escape < ESC_Z) ------------------ | Branch (9386:9): [True: 2.90k, False: 649] | Branch (9386:27): [True: 2.40k, False: 500] ------------------ 9387| 2.40k| { 9388| 2.40k|#if PCRE2_CODE_UNIT_WIDTH != 32 9389| 2.40k| if ((cb->external_options & PCRE2_UTF) != 0 && escape == ESC_C) ------------------ | | 138| 2.40k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ | Branch (9389:11): [True: 845, False: 1.56k] | Branch (9389:54): [True: 0, False: 845] ------------------ 9390| 0| { 9391| 0| *errcodeptr = ERR36; 9392| 0| return -1; 9393| 0| } 9394| 2.40k|#endif 9395| 2.40k| itemlength = 1; 9396| 2.40k| if (escape == ESC_p || escape == ESC_P) pptr++; /* Skip prop data */ ------------------ | Branch (9396:11): [True: 749, False: 1.66k] | Branch (9396:30): [True: 343, False: 1.31k] ------------------ 9397| 2.40k| } 9398| 3.55k| break; 9399| | 9400| | /* Lookaheads do not contribute to the length of this branch, but they may 9401| | contain lookbehinds within them whose lengths need to be set. */ 9402| | 9403| 12.1k| case META_LOOKAHEAD: ------------------ | | 251| 12.1k|#define META_LOOKAHEAD 0x80230000u /* (?= */ ------------------ | Branch (9403:5): [True: 12.1k, False: 283k] ------------------ 9404| 16.6k| case META_LOOKAHEADNOT: ------------------ | | 252| 16.6k|#define META_LOOKAHEADNOT 0x80240000u /* (?! */ ------------------ | Branch (9404:5): [True: 4.51k, False: 291k] ------------------ 9405| 18.0k| case META_LOOKAHEAD_NA: ------------------ | | 258| 18.0k|#define META_LOOKAHEAD_NA 0x80270000u /* (*napla: */ ------------------ | Branch (9405:5): [True: 1.46k, False: 294k] ------------------ 9406| 18.0k| *errcodeptr = check_lookbehinds(pptr + 1, &pptr, recurses, cb, lcptr); 9407| 18.0k| if (*errcodeptr != 0) return -1; ------------------ | Branch (9407:9): [True: 98, False: 17.9k] ------------------ 9408| | 9409| | /* Ignore any qualifiers that follow a lookahead assertion. */ 9410| | 9411| 17.9k| switch (pptr[1]) 9412| 17.9k| { 9413| 264| case META_ASTERISK: ------------------ | | 279| 264|#define META_ASTERISK 0x80340000u /* * */ ------------------ | Branch (9413:7): [True: 264, False: 17.7k] ------------------ 9414| 554| case META_ASTERISK_PLUS: ------------------ | | 280| 554|#define META_ASTERISK_PLUS 0x80350000u /* *+ */ ------------------ | Branch (9414:7): [True: 290, False: 17.7k] ------------------ 9415| 2.61k| case META_ASTERISK_QUERY: ------------------ | | 281| 2.61k|#define META_ASTERISK_QUERY 0x80360000u /* *? */ ------------------ | Branch (9415:7): [True: 2.05k, False: 15.9k] ------------------ 9416| 3.15k| case META_PLUS: ------------------ | | 282| 3.15k|#define META_PLUS 0x80370000u /* + */ ------------------ | Branch (9416:7): [True: 546, False: 17.4k] ------------------ 9417| 3.41k| case META_PLUS_PLUS: ------------------ | | 283| 3.41k|#define META_PLUS_PLUS 0x80380000u /* ++ */ ------------------ | Branch (9417:7): [True: 260, False: 17.7k] ------------------ 9418| 3.62k| case META_PLUS_QUERY: ------------------ | | 284| 3.62k|#define META_PLUS_QUERY 0x80390000u /* +? */ ------------------ | Branch (9418:7): [True: 205, False: 17.7k] ------------------ 9419| 4.31k| case META_QUERY: ------------------ | | 285| 4.31k|#define META_QUERY 0x803a0000u /* ? */ ------------------ | Branch (9419:7): [True: 696, False: 17.2k] ------------------ 9420| 4.51k| case META_QUERY_PLUS: ------------------ | | 286| 4.51k|#define META_QUERY_PLUS 0x803b0000u /* ?+ */ ------------------ | Branch (9420:7): [True: 194, False: 17.7k] ------------------ 9421| 4.75k| case META_QUERY_QUERY: ------------------ | | 287| 4.75k|#define META_QUERY_QUERY 0x803c0000u /* ?? */ ------------------ | Branch (9421:7): [True: 242, False: 17.7k] ------------------ 9422| 4.75k| pptr++; 9423| 4.75k| break; 9424| | 9425| 194| case META_MINMAX: ------------------ | | 288| 194|#define META_MINMAX 0x803d0000u /* {n,m} repeat */ ------------------ | Branch (9425:7): [True: 194, False: 17.7k] ------------------ 9426| 388| case META_MINMAX_PLUS: ------------------ | | 289| 388|#define META_MINMAX_PLUS 0x803e0000u /* {n,m}+ repeat */ ------------------ | Branch (9426:7): [True: 194, False: 17.7k] ------------------ 9427| 582| case META_MINMAX_QUERY: ------------------ | | 290| 582|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (9427:7): [True: 194, False: 17.7k] ------------------ 9428| 582| pptr += 3; 9429| 582| break; 9430| | 9431| 12.6k| default: ------------------ | Branch (9431:7): [True: 12.6k, False: 5.33k] ------------------ 9432| 12.6k| break; 9433| 17.9k| } 9434| 17.9k| break; 9435| | 9436| | /* A nested lookbehind does not contribute any length to this lookbehind, 9437| | but must itself be checked and have its lengths set. */ 9438| | 9439| 17.9k| case META_LOOKBEHIND: ------------------ | | 253| 555|#define META_LOOKBEHIND 0x80250000u /* (?<= */ ------------------ | Branch (9439:5): [True: 555, False: 295k] ------------------ 9440| 1.10k| case META_LOOKBEHINDNOT: ------------------ | | 254| 1.10k|#define META_LOOKBEHINDNOT 0x80260000u /* (?external_options & PCRE2_MATCH_UNSET_BACKREF) != 0) ------------------ | | 128| 183|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ ------------------ | Branch (9453:9): [True: 10, False: 173] ------------------ 9454| 10| goto ISNOTFIXED; 9455| | /* Fall through */ 9456| | 9457| 587| case META_RECURSE_BYNAME: ------------------ | | 245| 587|#define META_RECURSE_BYNAME 0x80210000u /* (?&name) */ ------------------ | Branch (9457:5): [True: 414, False: 295k] ------------------ 9458| 587| { 9459| 587| int i; 9460| 587| PCRE2_SPTR name; ------------------ | | 814| 587|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 587|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 587|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 587|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9461| 587| BOOL is_dupname = FALSE; ------------------ | | 69| 587|#define FALSE 0 ------------------ 9462| 587| named_group *ng = cb->named_groups; ------------------ | | 1983| 587|#define named_group PCRE2_SUFFIX(named_group_) | | ------------------ | | | | 986| 587|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 587|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 587|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9463| 587| uint32_t meta_code = META_CODE(*pptr); ------------------ | | 113| 587|#define META_CODE(x) (x & 0xffff0000u) ------------------ 9464| 587| uint32_t length = *(++pptr); 9465| | 9466| 587| GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 587| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 9467| 587| name = cb->start_pattern + offset; 9468| 1.01k| for (i = 0; i < cb->names_found; i++, ng++) ------------------ | Branch (9468:19): [True: 980, False: 30] ------------------ 9469| 980| { 9470| 980| if (length == ng->length && PRIV(strncmp)(name, ng->name, length) == 0) ------------------ | | 177| 768|#define PRIV(name) _pcre2_##name ------------------ | Branch (9470:13): [True: 768, False: 212] | Branch (9470:37): [True: 557, False: 211] ------------------ 9471| 557| { 9472| 557| group = ng->number; 9473| 557| is_dupname = ng->isdup; 9474| 557| break; 9475| 557| } 9476| 980| } 9477| | 9478| 587| if (group == 0) ------------------ | Branch (9478:11): [True: 30, False: 557] ------------------ 9479| 30| { 9480| 30| *errcodeptr = ERR15; /* Non-existent subpattern */ 9481| 30| cb->erroroffset = offset; 9482| 30| return -1; 9483| 30| } 9484| | 9485| | /* A numerical back reference can be fixed length if duplicate capturing 9486| | groups are not being used. A non-duplicate named back reference can also 9487| | be handled. */ 9488| | 9489| 557| if (meta_code == META_RECURSE_BYNAME || ------------------ | | 245| 1.11k|#define META_RECURSE_BYNAME 0x80210000u /* (?&name) */ ------------------ | Branch (9489:11): [True: 404, False: 153] ------------------ 9490| 557| (!is_dupname && (cb->external_flags & PCRE2_DUPCAPUSED) == 0)) ------------------ | | 528| 150|#define PCRE2_DUPCAPUSED 0x00200000 /* contains (?| */ ------------------ | Branch (9490:12): [True: 150, False: 3] | Branch (9490:27): [True: 147, False: 3] ------------------ 9491| 551| goto RECURSE_OR_BACKREF_LENGTH; /* Handle as a numbered version. */ 9492| 557| } 9493| 6| goto ISNOTFIXED; /* Duplicate name or number */ 9494| | 9495| | /* The offset values for back references < 10 are in a separate vector 9496| | because otherwise they would use more than two parsed pattern elements on 9497| | 64-bit systems. */ 9498| | 9499| 1.02k| case META_BACKREF: ------------------ | | 215| 1.02k|#define META_BACKREF 0x80030000u /* Back ref */ ------------------ | Branch (9499:5): [True: 1.02k, False: 294k] ------------------ 9500| 1.02k| if ((cb->external_options & PCRE2_MATCH_UNSET_BACKREF) != 0 || ------------------ | | 128| 1.02k|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ ------------------ | Branch (9500:9): [True: 76, False: 949] ------------------ 9501| 1.02k| (cb->external_flags & PCRE2_DUPCAPUSED) != 0) ------------------ | | 528| 949|#define PCRE2_DUPCAPUSED 0x00200000 /* contains (?| */ ------------------ | Branch (9501:9): [True: 5, False: 944] ------------------ 9502| 81| goto ISNOTFIXED; 9503| 944| group = META_DATA(*pptr); ------------------ | | 114| 944|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 9504| 944| if (group < 10) ------------------ | Branch (9504:9): [True: 562, False: 382] ------------------ 9505| 562| { 9506| 562| offset = cb->small_ref_offset[group]; 9507| 562| goto RECURSE_OR_BACKREF_LENGTH; 9508| 562| } 9509| | 9510| | /* Fall through */ 9511| | /* For groups >= 10 - picking up group twice does no harm. */ 9512| | 9513| | /* A true recursion implies not fixed length, but a subroutine call may 9514| | be OK. Back reference "recursions" are also failed. */ 9515| | 9516| 32.6k| case META_RECURSE: ------------------ | | 244| 32.6k|#define META_RECURSE 0x80200000u /* Recursion */ ------------------ | Branch (9516:5): [True: 32.2k, False: 263k] ------------------ 9517| 32.6k| group = META_DATA(*pptr); ------------------ | | 114| 32.6k|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 9518| 32.6k| GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 32.6k| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 9519| | 9520| 33.7k| RECURSE_OR_BACKREF_LENGTH: 9521| 33.7k| if (group > cb->bracount) ------------------ | Branch (9521:9): [True: 114, False: 33.6k] ------------------ 9522| 114| { 9523| 114| cb->erroroffset = offset; 9524| 114| *errcodeptr = ERR15; /* Non-existent subpattern */ 9525| 114| return -1; 9526| 114| } 9527| 33.6k| if (group == 0) goto ISNOTFIXED; /* Local recursion */ ------------------ | Branch (9527:9): [True: 11, False: 33.6k] ------------------ 9528| 240M| for (gptr = cb->parsed_pattern; *gptr != META_END; gptr++) ------------------ | | 211| 240M|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (9528:37): [True: 240M, False: 0] ------------------ 9529| 240M| { 9530| 240M| if (META_CODE(*gptr) == META_BIGVALUE) gptr++; ------------------ | | 113| 240M|#define META_CODE(x) (x & 0xffff0000u) ------------------ if (META_CODE(*gptr) == META_BIGVALUE) gptr++; ------------------ | | 217| 240M|#define META_BIGVALUE 0x80050000u /* Next is a literal > META_END */ ------------------ | Branch (9530:11): [True: 0, False: 240M] ------------------ 9531| 240M| else if (*gptr == (META_CAPTURE | group)) break; ------------------ | | 220| 240M|#define META_CAPTURE 0x80080000u /* Capturing parenthesis */ ------------------ | Branch (9531:18): [True: 33.6k, False: 240M] ------------------ 9532| 240M| } 9533| | 9534| | /* We must start the search for the end of the group at the first meta code 9535| | inside the group. Otherwise it will be treated as an enclosed group. */ 9536| | 9537| 33.6k| gptrend = parsed_skip(gptr + 1, PSKIP_KET); 9538| 33.6k| if (gptrend == NULL) goto PARSED_SKIP_FAILED; ------------------ | Branch (9538:9): [True: 0, False: 33.6k] ------------------ 9539| 33.6k| if (pptr > gptr && pptr < gptrend) goto ISNOTFIXED; /* Local recursion */ ------------------ | Branch (9539:9): [True: 2.21k, False: 31.4k] | Branch (9539:24): [True: 47, False: 2.17k] ------------------ 9540| 3.44M| for (r = recurses; r != NULL; r = r->prev) if (r->groupptr == gptr) break; ------------------ | Branch (9540:24): [True: 3.41M, False: 33.5k] | Branch (9540:52): [True: 7, False: 3.41M] ------------------ 9541| 33.5k| if (r != NULL) goto ISNOTFIXED; /* Mutual recursion */ ------------------ | Branch (9541:9): [True: 7, False: 33.5k] ------------------ 9542| 33.5k| this_recurse.prev = recurses; 9543| 33.5k| this_recurse.groupptr = gptr; 9544| | 9545| | /* We do not need to know the position of the end of the group, that is, 9546| | gptr is not used after the call to get_grouplength(). Setting the second 9547| | argument FALSE stops it scanning for the end when the length can be found 9548| | in the cache. */ 9549| | 9550| 33.5k| gptr++; 9551| 33.5k| grouplength = get_grouplength(&gptr, FALSE, errcodeptr, lcptr, group, ------------------ | | 69| 33.5k|#define FALSE 0 ------------------ 9552| 33.5k| &this_recurse, cb); 9553| 33.5k| if (grouplength < 0) ------------------ | Branch (9553:9): [True: 6.01k, False: 27.5k] ------------------ 9554| 6.01k| { 9555| 6.01k| if (*errcodeptr == 0) goto ISNOTFIXED; ------------------ | Branch (9555:11): [True: 6, False: 6.00k] ------------------ 9556| 6.00k| return -1; /* Error already set */ 9557| 6.01k| } 9558| 27.5k| itemlength = grouplength; 9559| 27.5k| break; 9560| | 9561| | /* A (DEFINE) group is never obeyed inline and so it does not contribute to 9562| | the length of this branch. Skip from the following item to the next 9563| | unpaired ket. */ 9564| | 9565| 0| case META_COND_DEFINE: ------------------ | | 228| 0|#define META_COND_DEFINE 0x80100000u /* (?(DEFINE)... */ ------------------ | Branch (9565:5): [True: 0, False: 295k] ------------------ 9566| 0| pptr = parsed_skip(pptr + 1, PSKIP_KET); 9567| 0| break; 9568| | 9569| | /* Check other nested groups - advance past the initial data for each type 9570| | and then seek a fixed length with get_grouplength(). */ 9571| | 9572| 232| case META_COND_NAME: ------------------ | | 229| 232|#define META_COND_NAME 0x80110000u /* (?()... */ ------------------ | Branch (9572:5): [True: 232, False: 295k] ------------------ 9573| 574| case META_COND_NUMBER: ------------------ | | 230| 574|#define META_COND_NUMBER 0x80120000u /* (?(digits)... */ ------------------ | Branch (9573:5): [True: 342, False: 295k] ------------------ 9574| 814| case META_COND_RNAME: ------------------ | | 231| 814|#define META_COND_RNAME 0x80130000u /* (?(R&name)... */ ------------------ | Branch (9574:5): [True: 240, False: 295k] ------------------ 9575| 1.07k| case META_COND_RNUMBER: ------------------ | | 232| 1.07k|#define META_COND_RNUMBER 0x80140000u /* (?(Rdigits)... */ ------------------ | Branch (9575:5): [True: 263, False: 295k] ------------------ 9576| 1.07k| pptr += 2 + SIZEOFFSET; ------------------ | | 108| 1.07k|#define SIZEOFFSET 2 ------------------ 9577| 1.07k| goto CHECK_GROUP; 9578| | 9579| 560| case META_COND_ASSERT: ------------------ | | 227| 560|#define META_COND_ASSERT 0x800f0000u /* (?(?assertion)... */ ------------------ | Branch (9579:5): [True: 560, False: 295k] ------------------ 9580| 560| pptr += 1; 9581| 560| goto CHECK_GROUP; 9582| | 9583| 244| case META_COND_VERSION: ------------------ | | 233| 244|#define META_COND_VERSION 0x80150000u /* (?(VERSIONx.y)... */ ------------------ | Branch (9583:5): [True: 244, False: 295k] ------------------ 9584| 244| pptr += 4; 9585| 244| goto CHECK_GROUP; 9586| | 9587| 54.6k| case META_CAPTURE: ------------------ | | 220| 54.6k|#define META_CAPTURE 0x80080000u /* Capturing parenthesis */ ------------------ | Branch (9587:5): [True: 54.6k, False: 241k] ------------------ 9588| 54.6k| group = META_DATA(*pptr); ------------------ | | 114| 54.6k|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 9589| | /* Fall through */ 9590| | 9591| 55.0k| case META_ATOMIC: ------------------ | | 214| 55.0k|#define META_ATOMIC 0x80020000u /* atomic group */ ------------------ | Branch (9591:5): [True: 430, False: 295k] ------------------ 9592| 61.3k| case META_NOCAPTURE: ------------------ | | 238| 61.3k|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ | Branch (9592:5): [True: 6.30k, False: 289k] ------------------ 9593| 61.5k| case META_SCRIPT_RUN: ------------------ | | 246| 61.5k|#define META_SCRIPT_RUN 0x80220000u /* (*script_run:...) */ ------------------ | Branch (9593:5): [True: 201, False: 295k] ------------------ 9594| 61.5k| pptr++; 9595| 63.4k| CHECK_GROUP: 9596| 63.4k| grouplength = get_grouplength(&pptr, TRUE, errcodeptr, lcptr, group, ------------------ | | 70| 63.4k|#define TRUE 1 ------------------ 9597| 63.4k| recurses, cb); 9598| 63.4k| if (grouplength < 0) return -1; ------------------ | Branch (9598:9): [True: 4.77k, False: 58.6k] ------------------ 9599| 58.6k| itemlength = grouplength; 9600| 58.6k| break; 9601| | 9602| | /* Exact repetition is OK; variable repetition is not. A repetition of zero 9603| | must subtract the length that has already been added. */ 9604| | 9605| 1.29k| case META_MINMAX: ------------------ | | 288| 1.29k|#define META_MINMAX 0x803d0000u /* {n,m} repeat */ ------------------ | Branch (9605:5): [True: 1.29k, False: 294k] ------------------ 9606| 1.48k| case META_MINMAX_PLUS: ------------------ | | 289| 1.48k|#define META_MINMAX_PLUS 0x803e0000u /* {n,m}+ repeat */ ------------------ | Branch (9606:5): [True: 194, False: 295k] ------------------ 9607| 1.74k| case META_MINMAX_QUERY: ------------------ | | 290| 1.74k|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (9607:5): [True: 258, False: 295k] ------------------ 9608| 1.74k| if (pptr[1] == pptr[2]) ------------------ | Branch (9608:9): [True: 1.74k, False: 3] ------------------ 9609| 1.74k| { 9610| 1.74k| switch(pptr[1]) 9611| 1.74k| { 9612| 294| case 0: ------------------ | Branch (9612:9): [True: 294, False: 1.44k] ------------------ 9613| 294| branchlength -= lastitemlength; 9614| 294| break; 9615| | 9616| 196| case 1: ------------------ | Branch (9616:9): [True: 196, False: 1.54k] ------------------ 9617| 196| itemlength = 0; 9618| 196| break; 9619| | 9620| 1.25k| default: /* Check for integer overflow */ ------------------ | Branch (9620:9): [True: 1.25k, False: 490] ------------------ 9621| 1.25k| if (lastitemlength != 0 && /* Should not occur, but just in case */ ------------------ | Branch (9621:13): [True: 974, False: 276] ------------------ 9622| 1.25k| INT_MAX/lastitemlength < pptr[1] - 1) ------------------ | Branch (9622:13): [True: 3, False: 971] ------------------ 9623| 3| { 9624| 3| *errcodeptr = ERR87; /* Integer overflow; lookbehind too big */ 9625| 3| return -1; 9626| 3| } 9627| 1.24k| itemlength = (pptr[1] - 1) * lastitemlength; 9628| 1.24k| break; 9629| 1.74k| } 9630| 1.73k| pptr += 2; 9631| 1.73k| break; 9632| 1.74k| } 9633| | /* Fall through */ 9634| | 9635| | /* Any other item means this branch does not have a fixed length. */ 9636| | 9637| 97| default: ------------------ | Branch (9637:5): [True: 94, False: 295k] ------------------ 9638| 265| ISNOTFIXED: 9639| 265| *errcodeptr = ERR25; /* Not fixed length */ 9640| 265| return -1; 9641| 295k| } 9642| | 9643| | /* Add the item length to the branchlength, checking for integer overflow and 9644| | for the branch length exceeding the limit. */ 9645| | 9646| 491k| if (INT_MAX - branchlength < (int)itemlength || ------------------ | Branch (9646:7): [True: 3, False: 491k] ------------------ 9647| 491k| (branchlength += itemlength) > LOOKBEHIND_MAX) ------------------ | | 616| 982k|#define LOOKBEHIND_MAX UINT16_MAX ------------------ | Branch (9647:7): [True: 35, False: 491k] ------------------ 9648| 38| { 9649| 38| *errcodeptr = ERR87; 9650| 38| return -1; 9651| 38| } 9652| | 9653| | /* Save this item length for use if the next item is a quantifier. */ 9654| | 9655| 491k| lastitemlength = itemlength; 9656| 491k| } 9657| | 9658| 96.1k|EXIT: 9659| 96.1k|*pptrptr = pptr; 9660| 96.1k|return branchlength; 9661| | 9662| 0|PARSED_SKIP_FAILED: 9663| 0|*errcodeptr = ERR90; 9664| 0|return -1; 9665| 107k|} pcre2_compile.c:parsed_skip: 9102| 36.1k|{ 9103| 36.1k|uint32_t nestlevel = 0; 9104| | 9105| 3.59M|for (;; pptr++) 9106| 3.62M| { 9107| 3.62M| uint32_t meta = META_CODE(*pptr); ------------------ | | 113| 3.62M|#define META_CODE(x) (x & 0xffff0000u) ------------------ 9108| | 9109| 3.62M| switch(meta) 9110| 3.62M| { 9111| 471k| default: /* Just skip over most items */ ------------------ | Branch (9111:5): [True: 471k, False: 3.15M] ------------------ 9112| 471k| if (meta < META_END) continue; /* Literal */ ------------------ | | 211| 471k|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (9112:9): [True: 347k, False: 124k] ------------------ 9113| 124k| break; 9114| | 9115| | /* This should never occur. */ 9116| | 9117| 124k| case META_END: ------------------ | | 211| 0|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (9117:5): [True: 0, False: 3.62M] ------------------ 9118| 0| return NULL; 9119| | 9120| | /* The data for these items is variable in length. */ 9121| | 9122| 1.35k| case META_BACKREF: /* Offset is present only if group >= 10 */ ------------------ | | 215| 1.35k|#define META_BACKREF 0x80030000u /* Back ref */ ------------------ | Branch (9122:5): [True: 1.35k, False: 3.62M] ------------------ 9123| 1.35k| if (META_DATA(*pptr) >= 10) pptr += SIZEOFFSET; ------------------ | | 114| 1.35k|#define META_DATA(x) (x & 0x0000ffffu) ------------------ if (META_DATA(*pptr) >= 10) pptr += SIZEOFFSET; ------------------ | | 108| 661|#define SIZEOFFSET 2 ------------------ | Branch (9123:9): [True: 661, False: 698] ------------------ 9124| 1.35k| break; 9125| | 9126| 16.1k| case META_ESCAPE: /* A few escapes are followed by data items. */ ------------------ | | 236| 16.1k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (9126:5): [True: 16.1k, False: 3.61M] ------------------ 9127| 16.1k| switch (META_DATA(*pptr)) ------------------ | | 114| 16.1k|#define META_DATA(x) (x & 0x0000ffffu) | | ------------------ | | | Branch (114:24): [True: 14.7k, False: 1.35k] | | ------------------ ------------------ 9128| 16.1k| { 9129| 480| case ESC_P: ------------------ | Branch (9129:7): [True: 480, False: 15.6k] ------------------ 9130| 1.35k| case ESC_p: ------------------ | Branch (9130:7): [True: 872, False: 15.2k] ------------------ 9131| 1.35k| pptr += 1; 9132| 1.35k| break; 9133| | 9134| 0| case ESC_g: ------------------ | Branch (9134:7): [True: 0, False: 16.1k] ------------------ 9135| 0| case ESC_k: ------------------ | Branch (9135:7): [True: 0, False: 16.1k] ------------------ 9136| 0| pptr += 1 + SIZEOFFSET; ------------------ | | 108| 0|#define SIZEOFFSET 2 ------------------ 9137| 0| break; 9138| 16.1k| } 9139| 16.1k| break; 9140| | 9141| 16.1k| case META_MARK: /* Add the length of the name. */ ------------------ | | 265| 444|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ | Branch (9141:5): [True: 444, False: 3.62M] ------------------ 9142| 868| case META_COMMIT_ARG: ------------------ | | 269| 868|#define META_COMMIT_ARG 0x802d0000u /* pairs */ ------------------ | Branch (9142:5): [True: 424, False: 3.62M] ------------------ 9143| 1.31k| case META_PRUNE_ARG: ------------------ | | 271| 1.31k|#define META_PRUNE_ARG 0x802f0000u /* be */ ------------------ | Branch (9143:5): [True: 448, False: 3.62M] ------------------ 9144| 1.94k| case META_SKIP_ARG: ------------------ | | 273| 1.94k|#define META_SKIP_ARG 0x80310000u /* in */ ------------------ | Branch (9144:5): [True: 630, False: 3.62M] ------------------ 9145| 10.9k| case META_THEN_ARG: ------------------ | | 275| 10.9k|#define META_THEN_ARG 0x80330000u /* order */ ------------------ | Branch (9145:5): [True: 8.99k, False: 3.61M] ------------------ 9146| 10.9k| pptr += pptr[1]; 9147| 10.9k| break; 9148| | 9149| | /* These are the "active" items in this loop. */ 9150| | 9151| 7.31k| case META_CLASS_END: ------------------ | | 225| 7.31k|#define META_CLASS_END 0x800d0000u /* end of non-empty class */ ------------------ | Branch (9151:5): [True: 7.31k, False: 3.61M] ------------------ 9152| 7.31k| if (skiptype == PSKIP_CLASS) return pptr; ------------------ | Branch (9152:9): [True: 1.24k, False: 6.07k] ------------------ 9153| 6.07k| break; 9154| | 9155| 6.07k| case META_ATOMIC: ------------------ | | 214| 680|#define META_ATOMIC 0x80020000u /* atomic group */ ------------------ | Branch (9155:5): [True: 680, False: 3.62M] ------------------ 9156| 1.48M| case META_CAPTURE: ------------------ | | 220| 1.48M|#define META_CAPTURE 0x80080000u /* Capturing parenthesis */ ------------------ | Branch (9156:5): [True: 1.48M, False: 2.13M] ------------------ 9157| 1.49M| case META_COND_ASSERT: ------------------ | | 227| 1.49M|#define META_COND_ASSERT 0x800f0000u /* (?(?assertion)... */ ------------------ | Branch (9157:5): [True: 758, False: 3.62M] ------------------ 9158| 1.49M| case META_COND_DEFINE: ------------------ | | 228| 1.49M|#define META_COND_DEFINE 0x80100000u /* (?(DEFINE)... */ ------------------ | Branch (9158:5): [True: 0, False: 3.62M] ------------------ 9159| 1.49M| case META_COND_NAME: ------------------ | | 229| 1.49M|#define META_COND_NAME 0x80110000u /* (?()... */ ------------------ | Branch (9159:5): [True: 423, False: 3.62M] ------------------ 9160| 1.49M| case META_COND_NUMBER: ------------------ | | 230| 1.49M|#define META_COND_NUMBER 0x80120000u /* (?(digits)... */ ------------------ | Branch (9160:5): [True: 634, False: 3.62M] ------------------ 9161| 1.49M| case META_COND_RNAME: ------------------ | | 231| 1.49M|#define META_COND_RNAME 0x80130000u /* (?(R&name)... */ ------------------ | Branch (9161:5): [True: 422, False: 3.62M] ------------------ 9162| 1.49M| case META_COND_RNUMBER: ------------------ | | 232| 1.49M|#define META_COND_RNUMBER 0x80140000u /* (?(Rdigits)... */ ------------------ | Branch (9162:5): [True: 429, False: 3.62M] ------------------ 9163| 1.49M| case META_COND_VERSION: ------------------ | | 233| 1.49M|#define META_COND_VERSION 0x80150000u /* (?(VERSIONx.y)... */ ------------------ | Branch (9163:5): [True: 409, False: 3.62M] ------------------ 9164| 1.50M| case META_LOOKAHEAD: ------------------ | | 251| 1.50M|#define META_LOOKAHEAD 0x80230000u /* (?= */ ------------------ | Branch (9164:5): [True: 13.0k, False: 3.61M] ------------------ 9165| 1.51M| case META_LOOKAHEADNOT: ------------------ | | 252| 1.51M|#define META_LOOKAHEADNOT 0x80240000u /* (?! */ ------------------ | Branch (9165:5): [True: 11.4k, False: 3.61M] ------------------ 9166| 1.51M| case META_LOOKAHEAD_NA: ------------------ | | 258| 1.51M|#define META_LOOKAHEAD_NA 0x80270000u /* (*napla: */ ------------------ | Branch (9166:5): [True: 1.59k, False: 3.62M] ------------------ 9167| 1.51M| case META_LOOKBEHIND: ------------------ | | 253| 1.51M|#define META_LOOKBEHIND 0x80250000u /* (?<= */ ------------------ | Branch (9167:5): [True: 520, False: 3.62M] ------------------ 9168| 1.52M| case META_LOOKBEHINDNOT: ------------------ | | 254| 1.52M|#define META_LOOKBEHINDNOT 0x80260000u /* (?> 16) & 0x7fff; 9188| 3.24M| if (meta >= sizeof(meta_extra_lengths)) return NULL; ------------------ | Branch (9188:7): [True: 0, False: 3.24M] ------------------ 9189| 3.24M| pptr += meta_extra_lengths[meta]; 9190| 3.24M| } 9191| |/* Control never reaches here */ 9192| 0|return pptr; 9193| 36.1k|} pcre2_compile.c:get_grouplength: 9222| 97.0k|{ 9223| 97.0k|int branchlength; 9224| 97.0k|int grouplength = -1; 9225| | 9226| |/* The cache can be used only if there is no possibility of there being two 9227| |groups with the same number. We do not need to set the end pointer for a group 9228| |that is being processed as a back reference or recursion, but we must do so for 9229| |an inline group. */ 9230| | 9231| 97.0k|if (group > 0 && (cb->external_flags & PCRE2_DUPCAPUSED) == 0) ------------------ | | 528| 88.1k|#define PCRE2_DUPCAPUSED 0x00200000 /* contains (?| */ ------------------ | Branch (9231:5): [True: 88.1k, False: 8.81k] | Branch (9231:18): [True: 4.51k, False: 83.6k] ------------------ 9232| 4.51k| { 9233| 4.51k| uint32_t groupinfo = cb->groupinfo[group]; 9234| 4.51k| if ((groupinfo & GI_NOT_FIXED_LENGTH) != 0) return -1; ------------------ | | 401| 4.51k|#define GI_NOT_FIXED_LENGTH 0x40000000u ------------------ | Branch (9234:7): [True: 0, False: 4.51k] ------------------ 9235| 4.51k| if ((groupinfo & GI_SET_FIXED_LENGTH) != 0) ------------------ | | 400| 4.51k|#define GI_SET_FIXED_LENGTH 0x80000000u ------------------ | Branch (9235:7): [True: 1.20k, False: 3.31k] ------------------ 9236| 1.20k| { 9237| 1.20k| if (isinline) *pptrptr = parsed_skip(*pptrptr, PSKIP_KET); ------------------ | Branch (9237:9): [True: 529, False: 678] ------------------ 9238| 1.20k| return groupinfo & GI_FIXED_LENGTH_MASK; ------------------ | | 402| 1.20k|#define GI_FIXED_LENGTH_MASK 0x0000ffffu ------------------ 9239| 1.20k| } 9240| 4.51k| } 9241| | 9242| |/* Scan the group. In this case we find the end pointer of necessity. */ 9243| | 9244| 95.8k|for(;;) 9245| 96.9k| { 9246| 96.9k| branchlength = get_branchlength(pptrptr, errcodeptr, lcptr, recurses, cb); 9247| 96.9k| if (branchlength < 0) goto ISNOTFIXED; ------------------ | Branch (9247:7): [True: 10.7k, False: 86.1k] ------------------ 9248| 86.1k| if (grouplength == -1) grouplength = branchlength; ------------------ | Branch (9248:7): [True: 85.2k, False: 883] ------------------ 9249| 883| else if (grouplength != branchlength) goto ISNOTFIXED; ------------------ | Branch (9249:14): [True: 41, False: 842] ------------------ 9250| 86.1k| if (**pptrptr == META_KET) break; ------------------ | | 237| 86.1k|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ | Branch (9250:7): [True: 85.0k, False: 1.10k] ------------------ 9251| 1.10k| *pptrptr += 1; /* Skip META_ALT */ 9252| 1.10k| } 9253| | 9254| 85.0k|if (group > 0) ------------------ | Branch (9254:5): [True: 78.3k, False: 6.65k] ------------------ 9255| 78.3k| cb->groupinfo[group] |= (uint32_t)(GI_SET_FIXED_LENGTH | grouplength); ------------------ | | 400| 78.3k|#define GI_SET_FIXED_LENGTH 0x80000000u ------------------ 9256| 85.0k|return grouplength; 9257| | 9258| 10.7k|ISNOTFIXED: 9259| 10.7k|if (group > 0) cb->groupinfo[group] |= GI_NOT_FIXED_LENGTH; ------------------ | | 401| 8.62k|#define GI_NOT_FIXED_LENGTH 0x40000000u ------------------ | Branch (9259:5): [True: 8.62k, False: 2.16k] ------------------ 9260| 10.7k|return -1; 9261| 95.8k|} pcre2_compile.c:compile_regex: 8253| 877k|{ 8254| 877k|PCRE2_UCHAR *code = *codeptr; ------------------ | | 813| 877k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 877k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 877k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 877k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8255| 877k|PCRE2_UCHAR *last_branch = code; ------------------ | | 813| 877k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 877k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 877k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 877k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8256| 877k|PCRE2_UCHAR *start_bracket = code; ------------------ | | 813| 877k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 877k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 877k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 877k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8257| 877k|BOOL lookbehind; 8258| 877k|open_capitem capitem; 8259| 877k|int capnumber = 0; 8260| 877k|int okreturn = 1; 8261| 877k|uint32_t *pptr = *pptrptr; 8262| 877k|uint32_t firstcu, reqcu; 8263| 877k|uint32_t lookbehindlength; 8264| 877k|uint32_t firstcuflags, reqcuflags; 8265| 877k|uint32_t branchfirstcu, branchreqcu; 8266| 877k|uint32_t branchfirstcuflags, branchreqcuflags; 8267| 877k|PCRE2_SIZE length; ------------------ | | 477| 877k|#define PCRE2_SIZE size_t ------------------ 8268| 877k|branch_chain bc; ------------------ | | 1979| 877k|#define branch_chain PCRE2_SUFFIX(branch_chain_) | | ------------------ | | | | 986| 877k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 877k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 877k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8269| | 8270| |/* If set, call the external function that checks for stack availability. */ 8271| | 8272| 877k|if (cb->cx->stack_guard != NULL && ------------------ | Branch (8272:5): [True: 0, False: 877k] ------------------ 8273| 877k| cb->cx->stack_guard(cb->parens_depth, cb->cx->stack_guard_data)) ------------------ | Branch (8273:5): [True: 0, False: 0] ------------------ 8274| 0| { 8275| 0| *errorcodeptr= ERR33; 8276| 0| return 0; 8277| 0| } 8278| | 8279| |/* Miscellaneous initialization */ 8280| | 8281| 877k|bc.outer = bcptr; 8282| 877k|bc.current_branch = code; 8283| | 8284| 877k|firstcu = reqcu = 0; 8285| 877k|firstcuflags = reqcuflags = REQ_UNSET; ------------------ | | 393| 877k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ 8286| | 8287| |/* Accumulate the length for use in the pre-compile phase. Start with the 8288| |length of the BRA and KET and any extra code units that are required at the 8289| |beginning. We accumulate in a local variable to save frequent testing of 8290| |lengthptr for NULL. We cannot do this by looking at the value of 'code' at the 8291| |start and end of each alternative, because compiled items are discarded during 8292| |the pre-compile phase so that the workspace is not exceeded. */ 8293| | 8294| 877k|length = 2 + 2*LINK_SIZE + skipunits; ------------------ | | 165| 877k|#define LINK_SIZE 2 ------------------ 8295| | 8296| |/* Remember if this is a lookbehind assertion, and if it is, save its length 8297| |and skip over the pattern offset. */ 8298| | 8299| 877k|lookbehind = *code == OP_ASSERTBACK || ------------------ | Branch (8299:14): [True: 2.81k, False: 874k] ------------------ 8300| 877k| *code == OP_ASSERTBACK_NOT || ------------------ | Branch (8300:14): [True: 4.09k, False: 870k] ------------------ 8301| 877k| *code == OP_ASSERTBACK_NA; ------------------ | Branch (8301:14): [True: 1.44k, False: 868k] ------------------ 8302| | 8303| 877k|if (lookbehind) ------------------ | Branch (8303:5): [True: 8.35k, False: 868k] ------------------ 8304| 8.35k| { 8305| 8.35k| lookbehindlength = META_DATA(pptr[-1]); ------------------ | | 114| 8.35k|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 8306| 8.35k| pptr += SIZEOFFSET; ------------------ | | 108| 8.35k|#define SIZEOFFSET 2 ------------------ 8307| 8.35k| } 8308| 868k|else lookbehindlength = 0; 8309| | 8310| |/* If this is a capturing subpattern, add to the chain of open capturing items 8311| |so that we can detect them if (*ACCEPT) is encountered. Note that only OP_CBRA 8312| |need be tested here; changing this opcode to one of its variants, e.g. 8313| |OP_SCBRAPOS, happens later, after the group has been compiled. */ 8314| | 8315| 877k|if (*code == OP_CBRA) ------------------ | Branch (8315:5): [True: 680k, False: 196k] ------------------ 8316| 680k| { 8317| 680k| capnumber = GET2(code, 1 + LINK_SIZE); ------------------ | | 194| 680k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 8318| 680k| capitem.number = capnumber; 8319| 680k| capitem.next = open_caps; 8320| 680k| capitem.assert_depth = cb->assert_depth; 8321| 680k| open_caps = &capitem; 8322| 680k| } 8323| | 8324| |/* Offset is set zero to mark that this bracket is still open */ 8325| | 8326| 877k|PUT(code, 1, 0); ------------------ | | 106| 877k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 877k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 8327| 877k|code += 1 + LINK_SIZE + skipunits; ------------------ | | 165| 877k|#define LINK_SIZE 2 ------------------ 8328| | 8329| |/* Loop for each alternative branch */ 8330| | 8331| 877k|for (;;) 8332| 935k| { 8333| 935k| int branch_return; 8334| | 8335| | /* Insert OP_REVERSE if this is as lookbehind assertion. */ 8336| | 8337| 935k| if (lookbehind && lookbehindlength > 0) ------------------ | Branch (8337:7): [True: 11.8k, False: 923k] | Branch (8337:21): [True: 3.14k, False: 8.74k] ------------------ 8338| 3.14k| { 8339| 3.14k| *code++ = OP_REVERSE; 8340| 3.14k| PUTINC(code, 0, lookbehindlength); ------------------ | | 547| 3.14k|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 3.14k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 3.14k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 3.14k|#define LINK_SIZE 2 | | ------------------ ------------------ 8341| 3.14k| length += 1 + LINK_SIZE; ------------------ | | 165| 3.14k|#define LINK_SIZE 2 ------------------ 8342| 3.14k| } 8343| | 8344| | /* Now compile the branch; in the pre-compile phase its length gets added 8345| | into the length. */ 8346| | 8347| 935k| if ((branch_return = ------------------ | Branch (8347:7): [True: 2.95k, False: 932k] ------------------ 8348| 935k| compile_branch(&options, &xoptions, &code, &pptr, errorcodeptr, 8349| 935k| &branchfirstcu, &branchfirstcuflags, &branchreqcu, &branchreqcuflags, 8350| 935k| &bc, open_caps, cb, (lengthptr == NULL)? NULL : &length)) == 0) ------------------ | Branch (8350:31): [True: 362k, False: 573k] ------------------ 8351| 2.95k| return 0; 8352| | 8353| | /* If a branch can match an empty string, so can the whole group. */ 8354| | 8355| 932k| if (branch_return < 0) okreturn = -1; ------------------ | Branch (8355:7): [True: 717k, False: 214k] ------------------ 8356| | 8357| | /* In the real compile phase, there is some post-processing to be done. */ 8358| | 8359| 932k| if (lengthptr == NULL) ------------------ | Branch (8359:7): [True: 362k, False: 570k] ------------------ 8360| 362k| { 8361| | /* If this is the first branch, the firstcu and reqcu values for the 8362| | branch become the values for the regex. */ 8363| | 8364| 362k| if (*last_branch != OP_ALT) ------------------ | Branch (8364:9): [True: 333k, False: 28.8k] ------------------ 8365| 333k| { 8366| 333k| firstcu = branchfirstcu; 8367| 333k| firstcuflags = branchfirstcuflags; 8368| 333k| reqcu = branchreqcu; 8369| 333k| reqcuflags = branchreqcuflags; 8370| 333k| } 8371| | 8372| | /* If this is not the first branch, the first char and reqcu have to 8373| | match the values from all the previous branches, except that if the 8374| | previous value for reqcu didn't have REQ_VARY set, it can still match, 8375| | and we set REQ_VARY for the group from this branch's value. */ 8376| | 8377| 28.8k| else 8378| 28.8k| { 8379| | /* If we previously had a firstcu, but it doesn't match the new branch, 8380| | we have to abandon the firstcu for the regex, but if there was 8381| | previously no reqcu, it takes on the value of the old firstcu. */ 8382| | 8383| 28.8k| if (firstcuflags != branchfirstcuflags || firstcu != branchfirstcu) ------------------ | Branch (8383:11): [True: 14.2k, False: 14.6k] | Branch (8383:49): [True: 1.52k, False: 13.0k] ------------------ 8384| 15.7k| { 8385| 15.7k| if (firstcuflags < REQ_NONE) ------------------ | | 394| 15.7k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (8385:13): [True: 3.45k, False: 12.3k] ------------------ 8386| 3.45k| { 8387| 3.45k| if (reqcuflags >= REQ_NONE) ------------------ | | 394| 3.45k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (8387:15): [True: 1.42k, False: 2.02k] ------------------ 8388| 1.42k| { 8389| 1.42k| reqcu = firstcu; 8390| 1.42k| reqcuflags = firstcuflags; 8391| 1.42k| } 8392| 3.45k| } 8393| 15.7k| firstcuflags = REQ_NONE; ------------------ | | 394| 15.7k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 8394| 15.7k| } 8395| | 8396| | /* If we (now or from before) have no firstcu, a firstcu from the 8397| | branch becomes a reqcu if there isn't a branch reqcu. */ 8398| | 8399| 28.8k| if (firstcuflags >= REQ_NONE && branchfirstcuflags < REQ_NONE && ------------------ | | 394| 57.7k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ if (firstcuflags >= REQ_NONE && branchfirstcuflags < REQ_NONE && ------------------ | | 394| 54.2k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (8399:11): [True: 25.3k, False: 3.48k] | Branch (8399:39): [True: 5.74k, False: 19.6k] ------------------ 8400| 28.8k| branchreqcuflags >= REQ_NONE) ------------------ | | 394| 5.74k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (8400:11): [True: 2.94k, False: 2.80k] ------------------ 8401| 2.94k| { 8402| 2.94k| branchreqcu = branchfirstcu; 8403| 2.94k| branchreqcuflags = branchfirstcuflags; 8404| 2.94k| } 8405| | 8406| | /* Now ensure that the reqcus match */ 8407| | 8408| 28.8k| if (((reqcuflags & ~REQ_VARY) != (branchreqcuflags & ~REQ_VARY)) || ------------------ | | 396| 28.8k|#define REQ_VARY 0x00000002u /* Code unit is followed by non-literal */ ------------------ if (((reqcuflags & ~REQ_VARY) != (branchreqcuflags & ~REQ_VARY)) || ------------------ | | 396| 28.8k|#define REQ_VARY 0x00000002u /* Code unit is followed by non-literal */ ------------------ | Branch (8408:11): [True: 16.5k, False: 12.2k] ------------------ 8409| 28.8k| reqcu != branchreqcu) ------------------ | Branch (8409:11): [True: 1.80k, False: 10.4k] ------------------ 8410| 18.3k| reqcuflags = REQ_NONE; ------------------ | | 394| 18.3k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 8411| 10.4k| else 8412| 10.4k| { 8413| 10.4k| reqcu = branchreqcu; 8414| 10.4k| reqcuflags |= branchreqcuflags; /* To "or" REQ_VARY if present */ 8415| 10.4k| } 8416| 28.8k| } 8417| 362k| } 8418| | 8419| | /* Handle reaching the end of the expression, either ')' or end of pattern. 8420| | In the real compile phase, go back through the alternative branches and 8421| | reverse the chain of offsets, with the field in the BRA item now becoming an 8422| | offset to the first alternative. If there are no alternatives, it points to 8423| | the end of the group. The length in the terminating ket is always the length 8424| | of the whole bracketed item. Return leaving the pointer at the terminating 8425| | char. */ 8426| | 8427| 932k| if (META_CODE(*pptr) != META_ALT) ------------------ | | 113| 932k|#define META_CODE(x) (x & 0xffff0000u) ------------------ if (META_CODE(*pptr) != META_ALT) ------------------ | | 213| 932k|#define META_ALT 0x80010000u /* alternation */ ------------------ | Branch (8427:7): [True: 874k, False: 58.1k] ------------------ 8428| 874k| { 8429| 874k| if (lengthptr == NULL) ------------------ | Branch (8429:9): [True: 333k, False: 541k] ------------------ 8430| 333k| { 8431| 333k| PCRE2_SIZE branch_length = code - last_branch; ------------------ | | 477| 333k|#define PCRE2_SIZE size_t ------------------ 8432| 333k| do 8433| 362k| { 8434| 362k| PCRE2_SIZE prev_length = GET(last_branch, 1); ------------------ | | 477| 362k|#define PCRE2_SIZE size_t ------------------ PCRE2_SIZE prev_length = GET(last_branch, 1); ------------------ | | 109| 362k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 8435| 362k| PUT(last_branch, 1, branch_length); ------------------ | | 106| 362k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 362k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 8436| 362k| branch_length = prev_length; 8437| 362k| last_branch -= branch_length; 8438| 362k| } 8439| 362k| while (branch_length > 0); ------------------ | Branch (8439:14): [True: 28.8k, False: 333k] ------------------ 8440| 333k| } 8441| | 8442| | /* Fill in the ket */ 8443| | 8444| 874k| *code = OP_KET; 8445| 874k| PUT(code, 1, (int)(code - start_bracket)); ------------------ | | 106| 874k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 874k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 8446| 874k| code += 1 + LINK_SIZE; ------------------ | | 165| 874k|#define LINK_SIZE 2 ------------------ 8447| | 8448| | /* Set values to pass back */ 8449| | 8450| 874k| *codeptr = code; 8451| 874k| *pptrptr = pptr; 8452| 874k| *firstcuptr = firstcu; 8453| 874k| *firstcuflagsptr = firstcuflags; 8454| 874k| *reqcuptr = reqcu; 8455| 874k| *reqcuflagsptr = reqcuflags; 8456| 874k| if (lengthptr != NULL) ------------------ | Branch (8456:9): [True: 541k, False: 333k] ------------------ 8457| 541k| { 8458| 541k| if (OFLOW_MAX - *lengthptr < length) ------------------ | | 200| 541k|#define OFLOW_MAX (INT_MAX - 20) ------------------ | Branch (8458:11): [True: 0, False: 541k] ------------------ 8459| 0| { 8460| 0| *errorcodeptr = ERR20; 8461| 0| return 0; 8462| 0| } 8463| 541k| *lengthptr += length; 8464| 541k| } 8465| 874k| return okreturn; 8466| 874k| } 8467| | 8468| | /* Another branch follows. In the pre-compile phase, we can move the code 8469| | pointer back to where it was for the start of the first branch. (That is, 8470| | pretend that each branch is the only one.) 8471| | 8472| | In the real compile phase, insert an ALT node. Its length field points back 8473| | to the previous branch while the bracket remains open. At the end the chain 8474| | is reversed. It's done like this so that the start of the bracket has a 8475| | zero offset until it is closed, making it possible to detect recursion. */ 8476| | 8477| 58.1k| if (lengthptr != NULL) ------------------ | Branch (8477:7): [True: 29.2k, False: 28.8k] ------------------ 8478| 29.2k| { 8479| 29.2k| code = *codeptr + 1 + LINK_SIZE + skipunits; ------------------ | | 165| 29.2k|#define LINK_SIZE 2 ------------------ 8480| 29.2k| length += 1 + LINK_SIZE; ------------------ | | 165| 29.2k|#define LINK_SIZE 2 ------------------ 8481| 29.2k| } 8482| 28.8k| else 8483| 28.8k| { 8484| 28.8k| *code = OP_ALT; 8485| 28.8k| PUT(code, 1, (int)(code - last_branch)); ------------------ | | 106| 28.8k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 28.8k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 8486| 28.8k| bc.current_branch = last_branch = code; 8487| 28.8k| code += 1 + LINK_SIZE; ------------------ | | 165| 28.8k|#define LINK_SIZE 2 ------------------ 8488| 28.8k| } 8489| | 8490| | /* Set the lookbehind length (if not in a lookbehind the value will be zero) 8491| | and then advance past the vertical bar. */ 8492| | 8493| 58.1k| lookbehindlength = META_DATA(*pptr); ------------------ | | 114| 58.1k|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 8494| 58.1k| pptr++; 8495| 58.1k| } 8496| |/* Control never reaches here */ 8497| 877k|} pcre2_compile.c:compile_branch: 5512| 935k|{ 5513| 935k|int bravalue = 0; 5514| 935k|int okreturn = -1; 5515| 935k|int group_return = 0; 5516| 935k|uint32_t repeat_min = 0, repeat_max = 0; /* To please picky compilers */ 5517| 935k|uint32_t greedy_default, greedy_non_default; 5518| 935k|uint32_t repeat_type, op_type; 5519| 935k|uint32_t options = *optionsptr; /* May change dynamically */ 5520| 935k|uint32_t xoptions = *xoptionsptr; /* May change dynamically */ 5521| 935k|uint32_t firstcu, reqcu; 5522| 935k|uint32_t zeroreqcu, zerofirstcu; 5523| 935k|uint32_t escape; 5524| 935k|uint32_t *pptr = *pptrptr; 5525| 935k|uint32_t meta, meta_arg; 5526| 935k|uint32_t firstcuflags, reqcuflags; 5527| 935k|uint32_t zeroreqcuflags, zerofirstcuflags; 5528| 935k|uint32_t req_caseopt, reqvary, tempreqvary; 5529| 935k|PCRE2_SIZE offset = 0; ------------------ | | 477| 935k|#define PCRE2_SIZE size_t ------------------ 5530| 935k|PCRE2_SIZE length_prevgroup = 0; ------------------ | | 477| 935k|#define PCRE2_SIZE size_t ------------------ 5531| 935k|PCRE2_UCHAR *code = *codeptr; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5532| 935k|PCRE2_UCHAR *last_code = code; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5533| 935k|PCRE2_UCHAR *orig_code = code; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5534| 935k|PCRE2_UCHAR *tempcode; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5535| 935k|PCRE2_UCHAR *previous = NULL; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5536| 935k|PCRE2_UCHAR op_previous; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5537| 935k|BOOL groupsetfirstcu = FALSE; ------------------ | | 69| 935k|#define FALSE 0 ------------------ 5538| 935k|BOOL had_accept = FALSE; ------------------ | | 69| 935k|#define FALSE 0 ------------------ 5539| 935k|BOOL matched_char = FALSE; ------------------ | | 69| 935k|#define FALSE 0 ------------------ 5540| 935k|BOOL previous_matched_char = FALSE; ------------------ | | 69| 935k|#define FALSE 0 ------------------ 5541| 935k|BOOL reset_caseful = FALSE; ------------------ | | 69| 935k|#define FALSE 0 ------------------ 5542| 935k|const uint8_t *cbits = cb->cbits; 5543| 935k|uint8_t classbits[32]; 5544| | 5545| |/* We can fish out the UTF setting once and for all into a BOOL, but we must 5546| |not do this for other options (e.g. PCRE2_EXTENDED) that may change dynamically 5547| |as we process the pattern. */ 5548| | 5549| 935k|#ifdef SUPPORT_UNICODE 5550| 935k|BOOL utf = (options & PCRE2_UTF) != 0; ------------------ | | 138| 935k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 5551| 935k|BOOL ucp = (options & PCRE2_UCP) != 0; ------------------ | | 136| 935k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ 5552| |#else /* No Unicode support */ 5553| |BOOL utf = FALSE; 5554| |#endif 5555| | 5556| |/* Helper variables for OP_XCLASS opcode (for characters > 255). We define 5557| |class_uchardata always so that it can be passed to add_to_class() always, 5558| |though it will not be used in non-UTF 8-bit cases. This avoids having to supply 5559| |alternative calls for the different cases. */ 5560| | 5561| 935k|PCRE2_UCHAR *class_uchardata; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5562| 935k|#ifdef SUPPORT_WIDE_CHARS 5563| 935k|BOOL xclass; 5564| 935k|PCRE2_UCHAR *class_uchardata_base; ------------------ | | 813| 935k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 935k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 935k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 935k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5565| 935k|#endif 5566| | 5567| |/* Set up the default and non-default settings for greediness */ 5568| | 5569| 935k|greedy_default = ((options & PCRE2_UNGREEDY) != 0); ------------------ | | 137| 935k|#define PCRE2_UNGREEDY 0x00040000u /* C */ ------------------ 5570| 935k|greedy_non_default = greedy_default ^ 1; 5571| | 5572| |/* Initialize no first unit, no required unit. REQ_UNSET means "no char 5573| |matching encountered yet". It gets changed to REQ_NONE if we hit something that 5574| |matches a non-fixed first unit; reqcu just remains unset if we never find one. 5575| | 5576| |When we hit a repeat whose minimum is zero, we may have to adjust these values 5577| |to take the zero repeat into account. This is implemented by setting them to 5578| |zerofirstcu and zeroreqcu when such a repeat is encountered. The individual 5579| |item types that can be repeated set these backoff variables appropriately. */ 5580| | 5581| 935k|firstcu = reqcu = zerofirstcu = zeroreqcu = 0; 5582| 935k|firstcuflags = reqcuflags = zerofirstcuflags = zeroreqcuflags = REQ_UNSET; ------------------ | | 393| 935k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ 5583| | 5584| |/* The variable req_caseopt contains either the REQ_CASELESS bit or zero, 5585| |according to the current setting of the caseless flag. The REQ_CASELESS value 5586| |leaves the lower 28 bit empty. It is added into the firstcu or reqcu variables 5587| |to record the case status of the value. This is used only for ASCII characters. 5588| |*/ 5589| | 5590| 935k|req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS : 0; ------------------ | | 122| 935k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS : 0; ------------------ | | 395| 97.1k|#define REQ_CASELESS 0x00000001u /* Code unit in xxcu is caseless */ ------------------ | Branch (5590:15): [True: 97.1k, False: 838k] ------------------ 5591| | 5592| |/* Switch on next META item until the end of the branch */ 5593| | 5594| 2.74M|for (;; pptr++) 5595| 3.67M| { 5596| 3.67M|#ifdef SUPPORT_WIDE_CHARS 5597| 3.67M| BOOL xclass_has_prop; 5598| 3.67M|#endif 5599| 3.67M| BOOL negate_class; 5600| 3.67M| BOOL should_flip_negation; 5601| 3.67M| BOOL match_all_or_no_wide_chars; 5602| 3.67M| BOOL possessive_quantifier; 5603| 3.67M| BOOL note_group_empty; 5604| 3.67M| int class_has_8bitchar; 5605| 3.67M| uint32_t mclength; 5606| 3.67M| uint32_t skipunits; 5607| 3.67M| uint32_t subreqcu, subfirstcu; 5608| 3.67M| uint32_t groupnumber; 5609| 3.67M| uint32_t verbarglen, verbculen; 5610| 3.67M| uint32_t subreqcuflags, subfirstcuflags; 5611| 3.67M| open_capitem *oc; 5612| 3.67M| PCRE2_UCHAR mcbuffer[8]; ------------------ | | 813| 3.67M|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 3.67M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 3.67M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 3.67M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5613| | 5614| | /* Get next META item in the pattern and its potential argument. */ 5615| | 5616| 3.67M| meta = META_CODE(*pptr); ------------------ | | 113| 3.67M|#define META_CODE(x) (x & 0xffff0000u) ------------------ 5617| 3.67M| meta_arg = META_DATA(*pptr); ------------------ | | 114| 3.67M|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 5618| | 5619| | /* If we are in the pre-compile phase, accumulate the length used for the 5620| | previous cycle of this loop, unless the next item is a quantifier. */ 5621| | 5622| 3.67M| if (lengthptr != NULL) ------------------ | Branch (5622:7): [True: 2.25M, False: 1.42M] ------------------ 5623| 2.25M| { 5624| 2.25M| if (code > cb->start_workspace + cb->workspace_size - ------------------ | Branch (5624:9): [True: 0, False: 2.25M] ------------------ 5625| 2.25M| WORK_SIZE_SAFETY_MARGIN) /* Check for overrun */ ------------------ | | 180| 2.25M|#define WORK_SIZE_SAFETY_MARGIN (100) ------------------ 5626| 0| { 5627| 0| *errorcodeptr = (code >= cb->start_workspace + cb->workspace_size)? ------------------ | Branch (5627:23): [True: 0, False: 0] ------------------ 5628| 0| ERR52 : ERR86; 5629| 0| return 0; 5630| 0| } 5631| | 5632| | /* There is at least one situation where code goes backwards: this is the 5633| | case of a zero quantifier after a class (e.g. [ab]{0}). When the quantifier 5634| | is processed, the whole class is eliminated. However, it is created first, 5635| | so we have to allow memory for it. Therefore, don't ever reduce the length 5636| | at this point. */ 5637| | 5638| 2.25M| if (code < last_code) code = last_code; ------------------ | Branch (5638:9): [True: 683, False: 2.25M] ------------------ 5639| | 5640| | /* If the next thing is not a quantifier, we add the length of the previous 5641| | item into the total, and reset the code pointer to the start of the 5642| | workspace. Otherwise leave the previous item available to be quantified. */ 5643| | 5644| 2.25M| if (meta < META_ASTERISK || meta > META_MINMAX_QUERY) ------------------ | | 279| 4.50M|#define META_ASTERISK 0x80340000u /* * */ ------------------ if (meta < META_ASTERISK || meta > META_MINMAX_QUERY) ------------------ | | 290| 144k|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (5644:9): [True: 2.11M, False: 144k] | Branch (5644:33): [True: 0, False: 144k] ------------------ 5645| 2.11M| { 5646| 2.11M| if (OFLOW_MAX - *lengthptr < (PCRE2_SIZE)(code - orig_code)) ------------------ | | 200| 2.11M|#define OFLOW_MAX (INT_MAX - 20) ------------------ | Branch (5646:11): [True: 3, False: 2.11M] ------------------ 5647| 3| { 5648| 3| *errorcodeptr = ERR20; /* Integer overflow */ 5649| 3| return 0; 5650| 3| } 5651| 2.11M| *lengthptr += (PCRE2_SIZE)(code - orig_code); 5652| 2.11M| if (*lengthptr > MAX_PATTERN_SIZE) ------------------ | | 110| 2.11M|#define MAX_PATTERN_SIZE (1 << 16) ------------------ | Branch (5652:11): [True: 205, False: 2.10M] ------------------ 5653| 205| { 5654| 205| *errorcodeptr = ERR20; /* Pattern is too large */ 5655| 205| return 0; 5656| 205| } 5657| 2.10M| code = orig_code; 5658| 2.10M| } 5659| | 5660| | /* Remember where this code item starts so we can catch the "backwards" 5661| | case above next time round. */ 5662| | 5663| 2.25M| last_code = code; 5664| 2.25M| } 5665| | 5666| | /* Process the next parsed pattern item. If it is not a quantifier, remember 5667| | where it starts so that it can be quantified when a quantifier follows. 5668| | Checking for the legality of quantifiers happens in parse_regex(), except for 5669| | a quantifier after an assertion that is a condition. */ 5670| | 5671| 3.67M| if (meta < META_ASTERISK || meta > META_MINMAX_QUERY) ------------------ | | 279| 7.35M|#define META_ASTERISK 0x80340000u /* * */ ------------------ if (meta < META_ASTERISK || meta > META_MINMAX_QUERY) ------------------ | | 290| 268k|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (5671:7): [True: 3.40M, False: 268k] | Branch (5671:31): [True: 0, False: 268k] ------------------ 5672| 3.40M| { 5673| 3.40M| previous = code; 5674| 3.40M| if (matched_char && !had_accept) okreturn = 1; ------------------ | Branch (5674:9): [True: 1.27M, False: 2.13M] | Branch (5674:25): [True: 1.27M, False: 2.21k] ------------------ 5675| 3.40M| } 5676| | 5677| 3.67M| previous_matched_char = matched_char; 5678| 3.67M| matched_char = FALSE; ------------------ | | 69| 3.67M|#define FALSE 0 ------------------ 5679| 3.67M| note_group_empty = FALSE; ------------------ | | 69| 3.67M|#define FALSE 0 ------------------ 5680| 3.67M| skipunits = 0; /* Default value for most subgroups */ 5681| | 5682| 3.67M| switch(meta) 5683| 3.67M| { 5684| | /* ===================================================================*/ 5685| | /* The branch terminates at pattern end or | or ) */ 5686| | 5687| 130k| case META_END: ------------------ | | 211| 130k|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (5687:5): [True: 130k, False: 3.54M] ------------------ 5688| 188k| case META_ALT: ------------------ | | 213| 188k|#define META_ALT 0x80010000u /* alternation */ ------------------ | Branch (5688:5): [True: 58.1k, False: 3.61M] ------------------ 5689| 932k| case META_KET: ------------------ | | 237| 932k|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ | Branch (5689:5): [True: 743k, False: 2.93M] ------------------ 5690| 932k| *firstcuptr = firstcu; 5691| 932k| *firstcuflagsptr = firstcuflags; 5692| 932k| *reqcuptr = reqcu; 5693| 932k| *reqcuflagsptr = reqcuflags; 5694| 932k| *codeptr = code; 5695| 932k| *pptrptr = pptr; 5696| 932k| return okreturn; 5697| | 5698| | 5699| | /* ===================================================================*/ 5700| | /* Handle single-character metacharacters. In multiline mode, ^ disables 5701| | the setting of any following char as a first character. */ 5702| | 5703| 17.4k| case META_CIRCUMFLEX: ------------------ | | 221| 17.4k|#define META_CIRCUMFLEX 0x80090000u /* ^ metacharacter */ ------------------ | Branch (5703:5): [True: 17.4k, False: 3.65M] ------------------ 5704| 17.4k| if ((options & PCRE2_MULTILINE) != 0) ------------------ | | 129| 17.4k|#define PCRE2_MULTILINE 0x00000400u /* C */ ------------------ | Branch (5704:9): [True: 3.97k, False: 13.4k] ------------------ 5705| 3.97k| { 5706| 3.97k| if (firstcuflags == REQ_UNSET) ------------------ | | 393| 3.97k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ | Branch (5706:11): [True: 1.92k, False: 2.05k] ------------------ 5707| 1.92k| zerofirstcuflags = firstcuflags = REQ_NONE; ------------------ | | 394| 1.92k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 5708| 3.97k| *code++ = OP_CIRCM; 5709| 3.97k| } 5710| 13.4k| else *code++ = OP_CIRC; 5711| 17.4k| break; 5712| | 5713| 17.0k| case META_DOLLAR: ------------------ | | 234| 17.0k|#define META_DOLLAR 0x80160000u /* $ metacharacter */ ------------------ | Branch (5713:5): [True: 17.0k, False: 3.65M] ------------------ 5714| 17.0k| *code++ = ((options & PCRE2_MULTILINE) != 0)? OP_DOLLM : OP_DOLL; ------------------ | | 129| 17.0k|#define PCRE2_MULTILINE 0x00000400u /* C */ ------------------ | Branch (5714:15): [True: 4.95k, False: 12.1k] ------------------ 5715| 17.0k| break; 5716| | 5717| | /* There can never be a first char if '.' is first, whatever happens about 5718| | repeats. The value of reqcu doesn't change either. */ 5719| | 5720| 49.5k| case META_DOT: ------------------ | | 235| 49.5k|#define META_DOT 0x80170000u /* . metacharacter */ ------------------ | Branch (5720:5): [True: 49.5k, False: 3.62M] ------------------ 5721| 49.5k| matched_char = TRUE; ------------------ | | 70| 49.5k|#define TRUE 1 ------------------ 5722| 49.5k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 49.5k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 33.2k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (5722:9): [True: 33.2k, False: 16.3k] ------------------ 5723| 49.5k| zerofirstcu = firstcu; 5724| 49.5k| zerofirstcuflags = firstcuflags; 5725| 49.5k| zeroreqcu = reqcu; 5726| 49.5k| zeroreqcuflags = reqcuflags; 5727| 49.5k| *code++ = ((options & PCRE2_DOTALL) != 0)? OP_ALLANY: OP_ANY; ------------------ | | 124| 49.5k|#define PCRE2_DOTALL 0x00000020u /* C */ ------------------ | Branch (5727:15): [True: 12.6k, False: 36.9k] ------------------ 5728| 49.5k| break; 5729| | 5730| | 5731| | /* ===================================================================*/ 5732| | /* Empty character classes are allowed if PCRE2_ALLOW_EMPTY_CLASS is set. 5733| | Otherwise, an initial ']' is taken as a data character. When empty classes 5734| | are allowed, [] must always fail, so generate OP_FAIL, whereas [^] must 5735| | match any character, so generate OP_ALLANY. */ 5736| | 5737| 1.77k| case META_CLASS_EMPTY: ------------------ | | 223| 1.77k|#define META_CLASS_EMPTY 0x800b0000u /* empty class */ ------------------ | Branch (5737:5): [True: 1.77k, False: 3.67M] ------------------ 5738| 2.36k| case META_CLASS_EMPTY_NOT: ------------------ | | 224| 2.36k|#define META_CLASS_EMPTY_NOT 0x800c0000u /* negative empty class */ ------------------ | Branch (5738:5): [True: 590, False: 3.67M] ------------------ 5739| 2.36k| matched_char = TRUE; ------------------ | | 70| 2.36k|#define TRUE 1 ------------------ 5740| 2.36k| *code++ = (meta == META_CLASS_EMPTY_NOT)? OP_ALLANY : OP_FAIL; ------------------ | | 224| 2.36k|#define META_CLASS_EMPTY_NOT 0x800c0000u /* negative empty class */ ------------------ | Branch (5740:15): [True: 590, False: 1.77k] ------------------ 5741| 2.36k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 2.36k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 525|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (5741:9): [True: 525, False: 1.84k] ------------------ 5742| 2.36k| zerofirstcu = firstcu; 5743| 2.36k| zerofirstcuflags = firstcuflags; 5744| 2.36k| break; 5745| | 5746| | 5747| | /* ===================================================================*/ 5748| | /* Non-empty character class. If the included characters are all < 256, we 5749| | build a 32-byte bitmap of the permitted characters, except in the special 5750| | case where there is only one such character. For negated classes, we build 5751| | the map as usual, then invert it at the end. However, we use a different 5752| | opcode so that data characters > 255 can be handled correctly. 5753| | 5754| | If the class contains characters outside the 0-255 range, a different 5755| | opcode is compiled. It may optionally have a bit map for characters < 256, 5756| | but those above are explicitly listed afterwards. A flag code unit tells 5757| | whether the bitmap is present, and whether this is a negated class or 5758| | not. */ 5759| | 5760| 36.4k| case META_CLASS_NOT: ------------------ | | 226| 36.4k|#define META_CLASS_NOT 0x800e0000u /* start non-empty negative class */ ------------------ | Branch (5760:5): [True: 36.4k, False: 3.64M] ------------------ 5761| 61.6k| case META_CLASS: ------------------ | | 222| 61.6k|#define META_CLASS 0x800a0000u /* start non-empty class */ ------------------ | Branch (5761:5): [True: 25.1k, False: 3.65M] ------------------ 5762| 61.6k| matched_char = TRUE; ------------------ | | 70| 61.6k|#define TRUE 1 ------------------ 5763| 61.6k| negate_class = meta == META_CLASS_NOT; ------------------ | | 226| 61.6k|#define META_CLASS_NOT 0x800e0000u /* start non-empty negative class */ ------------------ 5764| | 5765| | /* We can optimize the case of a single character in a class by generating 5766| | OP_CHAR or OP_CHARI if it's positive, or OP_NOT or OP_NOTI if it's 5767| | negative. In the negative case there can be no first char if this item is 5768| | first, whatever repeat count may follow. In the case of reqcu, save the 5769| | previous value for reinstating. */ 5770| | 5771| | /* NOTE: at present this optimization is not effective if the only 5772| | character in a class in 32-bit, non-UCP mode has its top bit set. */ 5773| | 5774| 61.6k| if (pptr[1] < META_END && pptr[2] == META_CLASS_END) ------------------ | | 211| 123k|#define META_END 0x80000000u /* End of pattern */ ------------------ if (pptr[1] < META_END && pptr[2] == META_CLASS_END) ------------------ | | 225| 53.3k|#define META_CLASS_END 0x800d0000u /* end of non-empty class */ ------------------ | Branch (5774:9): [True: 53.3k, False: 8.29k] | Branch (5774:31): [True: 32.3k, False: 20.9k] ------------------ 5775| 32.3k| { 5776| 32.3k|#ifdef SUPPORT_UNICODE 5777| 32.3k| uint32_t d; 5778| 32.3k|#endif 5779| 32.3k| uint32_t c = pptr[1]; 5780| | 5781| 32.3k| pptr += 2; /* Move on to class end */ 5782| 32.3k| if (meta == META_CLASS) /* A positive one-char class can be */ ------------------ | | 222| 32.3k|#define META_CLASS 0x800a0000u /* start non-empty class */ ------------------ | Branch (5782:11): [True: 1.52k, False: 30.8k] ------------------ 5783| 1.52k| { /* handled as a normal literal character. */ 5784| 1.52k| meta = c; /* Set up the character */ 5785| 1.52k| goto NORMAL_CHAR_SET; 5786| 1.52k| } 5787| | 5788| | /* Handle a negative one-character class */ 5789| | 5790| 30.8k| zeroreqcu = reqcu; 5791| 30.8k| zeroreqcuflags = reqcuflags; 5792| 30.8k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 30.8k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 4.60k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (5792:11): [True: 4.60k, False: 26.2k] ------------------ 5793| 30.8k| zerofirstcu = firstcu; 5794| 30.8k| zerofirstcuflags = firstcuflags; 5795| | 5796| | /* For caseless UTF or UCP mode, check whether this character has more 5797| | than one other case. If so, generate a special OP_NOTPROP item instead of 5798| | OP_NOTI. When restricted by PCRE2_EXTRA_CASELESS_RESTRICT, ignore any 5799| | caseless set that starts with an ASCII character. */ 5800| | 5801| 30.8k|#ifdef SUPPORT_UNICODE 5802| 30.8k| if ((utf||ucp) && (options & PCRE2_CASELESS) != 0 && ------------------ | | 122| 13.8k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (5802:12): [True: 3.75k, False: 27.0k] | Branch (5802:17): [True: 10.0k, False: 17.0k] | Branch (5802:25): [True: 11.2k, False: 2.62k] ------------------ 5803| 30.8k| (d = UCD_CASESET(c)) != 0 && ------------------ | | 1861| 11.2k|#define UCD_CASESET(ch) GET_UCD(ch)->caseset | | ------------------ | | | | 1846| 11.2k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 11.2k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 11.2k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 11.2k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 11.2k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 11.2k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 11.2k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 11.2k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 11.2k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 11.2k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5803:11): [True: 712, False: 10.5k] ------------------ 5804| 30.8k| ((xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) == 0 || ------------------ | | 156| 712|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ ------------------ | Branch (5804:12): [True: 324, False: 388] ------------------ 5805| 712| PRIV(ucd_caseless_sets)[d] > 127)) ------------------ | | 177| 388|#define PRIV(name) _pcre2_##name ------------------ | Branch (5805:11): [True: 194, False: 194] ------------------ 5806| 518| { 5807| 518| *code++ = OP_NOTPROP; 5808| 518| *code++ = PT_CLIST; ------------------ | | 1285| 518|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ 5809| 518| *code++ = d; 5810| 518| break; /* We are finished with this class */ 5811| 518| } 5812| 30.3k|#endif 5813| | /* Char has only one other (usable) case, or UCP not available */ 5814| | 5815| 30.3k| *code++ = ((options & PCRE2_CASELESS) != 0)? OP_NOTI: OP_NOT; ------------------ | | 122| 30.3k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (5815:17): [True: 11.7k, False: 18.5k] ------------------ 5816| 30.3k| code += PUTCHAR(c, code); ------------------ | | 357| 30.3k|#define PUTCHAR(c, p) ((utf && c > MAX_UTF_SINGLE_CU)? \ | | ------------------ | | | | 282| 33.8k|#define MAX_UTF_SINGLE_CU 127 | | ------------------ | | | Branch (357:25): [True: 3.53k, False: 26.8k] | | | Branch (357:32): [True: 1.06k, False: 2.46k] | | ------------------ | | 358| 30.3k| PRIV(ord2utf)(c,p) : (*p = c, 1)) | | ------------------ | | | | 177| 1.06k|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ 5817| 30.3k| break; /* We are finished with this class */ 5818| 30.8k| } /* End of 1-char optimization */ 5819| | 5820| | /* Handle character classes that contain more than just one literal 5821| | character. If there are exactly two characters in a positive class, see if 5822| | they are case partners. This can be optimized to generate a caseless single 5823| | character match (which also sets first/required code units if relevant). 5824| | When casing restrictions apply, ignore a caseless set if both characters 5825| | are ASCII. */ 5826| | 5827| 29.2k| if (meta == META_CLASS && pptr[1] < META_END && pptr[2] < META_END && ------------------ | | 222| 58.5k|#define META_CLASS 0x800a0000u /* start non-empty class */ ------------------ if (meta == META_CLASS && pptr[1] < META_END && pptr[2] < META_END && ------------------ | | 211| 52.9k|#define META_END 0x80000000u /* End of pattern */ ------------------ if (meta == META_CLASS && pptr[1] < META_END && pptr[2] < META_END && ------------------ | | 211| 44.9k|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (5827:9): [True: 23.6k, False: 5.59k] | Branch (5827:31): [True: 15.6k, False: 8.02k] | Branch (5827:53): [True: 13.3k, False: 2.27k] ------------------ 5828| 29.2k| pptr[3] == META_CLASS_END) ------------------ | | 225| 13.3k|#define META_CLASS_END 0x800d0000u /* end of non-empty class */ ------------------ | Branch (5828:9): [True: 8.42k, False: 4.93k] ------------------ 5829| 8.42k| { 5830| 8.42k| uint32_t c = pptr[1]; 5831| | 5832| 8.42k|#ifdef SUPPORT_UNICODE 5833| 8.42k| if (UCD_CASESET(c) == 0 || ------------------ | | 1861| 8.42k|#define UCD_CASESET(ch) GET_UCD(ch)->caseset | | ------------------ | | | | 1846| 8.42k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 8.42k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 8.42k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 8.42k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 8.42k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 8.42k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 8.42k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 8.42k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 8.42k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 8.42k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5833:11): [True: 7.21k, False: 1.21k] ------------------ 5834| 8.42k| ((xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0 && ------------------ | | 156| 1.21k|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ ------------------ | Branch (5834:11): [True: 602, False: 616] ------------------ 5835| 1.21k| c < 128 && pptr[2] < 128)) ------------------ | Branch (5835:10): [True: 398, False: 204] | Branch (5835:21): [True: 204, False: 194] ------------------ 5836| 7.41k|#endif 5837| 7.41k| { 5838| 7.41k| uint32_t d; 5839| | 5840| 7.41k|#ifdef SUPPORT_UNICODE 5841| 7.41k| if ((utf || ucp) && c > 127) d = UCD_OTHERCASE(c); else ------------------ | | 1862| 834|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 834|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 834|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 834|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 834| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 834|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 834|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 834|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 834| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 834|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 834|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5841:14): [True: 2.04k, False: 5.37k] | Branch (5841:21): [True: 1.42k, False: 3.94k] | Branch (5841:29): [True: 834, False: 2.63k] ------------------ 5842| 6.58k|#endif 5843| 6.58k| { 5844| |#if PCRE2_CODE_UNIT_WIDTH != 8 5845| | if (c > 255) d = c; else 5846| |#endif 5847| 6.58k| d = TABLE_GET(c, cb->fcc, c); ------------------ | | 214| 6.58k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 5848| 6.58k| } 5849| | 5850| 7.41k| if (c != d && pptr[2] == d) ------------------ | Branch (5850:13): [True: 2.54k, False: 4.86k] | Branch (5850:23): [True: 579, False: 1.96k] ------------------ 5851| 579| { 5852| 579| pptr += 3; /* Move on to class end */ 5853| 579| meta = c; 5854| 579| if ((options & PCRE2_CASELESS) == 0) ------------------ | | 122| 579|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (5854:15): [True: 334, False: 245] ------------------ 5855| 334| { 5856| 334| reset_caseful = TRUE; ------------------ | | 70| 334|#define TRUE 1 ------------------ 5857| 334| options |= PCRE2_CASELESS; ------------------ | | 122| 334|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ 5858| 334| req_caseopt = REQ_CASELESS; ------------------ | | 395| 334|#define REQ_CASELESS 0x00000001u /* Code unit in xxcu is caseless */ ------------------ 5859| 334| } 5860| 579| goto CLASS_CASELESS_CHAR; 5861| 579| } 5862| 7.41k| } 5863| 8.42k| } 5864| | 5865| | /* If a non-extended class contains a negative special such as \S, we need 5866| | to flip the negation flag at the end, so that support for characters > 255 5867| | works correctly (they are all included in the class). An extended class may 5868| | need to insert specific matching or non-matching code for wide characters. 5869| | */ 5870| | 5871| 28.6k| should_flip_negation = match_all_or_no_wide_chars = FALSE; ------------------ | | 69| 28.6k|#define FALSE 0 ------------------ 5872| | 5873| | /* Extended class (xclass) will be used when characters > 255 5874| | might match. */ 5875| | 5876| 28.6k|#ifdef SUPPORT_WIDE_CHARS 5877| 28.6k| xclass = FALSE; ------------------ | | 69| 28.6k|#define FALSE 0 ------------------ 5878| 28.6k| class_uchardata = code + LINK_SIZE + 2; /* For XCLASS items */ ------------------ | | 165| 28.6k|#define LINK_SIZE 2 ------------------ 5879| 28.6k| class_uchardata_base = class_uchardata; /* Save the start */ 5880| 28.6k|#endif 5881| | 5882| | /* For optimization purposes, we track some properties of the class: 5883| | class_has_8bitchar will be non-zero if the class contains at least one 5884| | character with a code point less than 256; xclass_has_prop will be TRUE if 5885| | Unicode property checks are present in the class. */ 5886| | 5887| 28.6k| class_has_8bitchar = 0; 5888| 28.6k|#ifdef SUPPORT_WIDE_CHARS 5889| 28.6k| xclass_has_prop = FALSE; ------------------ | | 69| 28.6k|#define FALSE 0 ------------------ 5890| 28.6k|#endif 5891| | 5892| | /* Initialize the 256-bit (32-byte) bit map to all zeros. We build the map 5893| | in a temporary bit of memory, in case the class contains fewer than two 5894| | 8-bit characters because in that case the compiled code doesn't use the bit 5895| | map. */ 5896| | 5897| 28.6k| memset(classbits, 0, 32 * sizeof(uint8_t)); 5898| | 5899| | /* Process items until META_CLASS_END is reached. */ 5900| | 5901| 479k| while ((meta = *(++pptr)) != META_CLASS_END) ------------------ | | 225| 479k|#define META_CLASS_END 0x800d0000u /* end of non-empty class */ ------------------ | Branch (5901:12): [True: 450k, False: 28.6k] ------------------ 5902| 450k| { 5903| | /* Handle POSIX classes such as [:alpha:] etc. */ 5904| | 5905| 450k| if (meta == META_POSIX || meta == META_POSIX_NEG) ------------------ | | 240| 901k|#define META_POSIX 0x801c0000u /* POSIX class item */ ------------------ if (meta == META_POSIX || meta == META_POSIX_NEG) ------------------ | | 241| 446k|#define META_POSIX_NEG 0x801d0000u /* negative POSIX class item */ ------------------ | Branch (5905:11): [True: 4.51k, False: 446k] | Branch (5905:33): [True: 1.39k, False: 444k] ------------------ 5906| 5.90k| { 5907| 5.90k| BOOL local_negate = (meta == META_POSIX_NEG); ------------------ | | 241| 5.90k|#define META_POSIX_NEG 0x801d0000u /* negative POSIX class item */ ------------------ 5908| 5.90k| int posix_class = *(++pptr); 5909| 5.90k| int taboffset, tabopt; 5910| 5.90k| uint8_t pbits[32]; 5911| | 5912| 5.90k| should_flip_negation = local_negate; /* Note negative special */ 5913| | 5914| | /* If matching is caseless, upper and lower are converted to alpha. 5915| | This relies on the fact that the class table starts with alpha, 5916| | lower, upper as the first 3 entries. */ 5917| | 5918| 5.90k| if ((options & PCRE2_CASELESS) != 0 && posix_class <= 2) ------------------ | | 122| 5.90k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (5918:13): [True: 1.76k, False: 4.13k] | Branch (5918:48): [True: 463, False: 1.30k] ------------------ 5919| 463| posix_class = 0; 5920| | 5921| | /* When PCRE2_UCP is set, some of the POSIX classes are converted to 5922| | different escape sequences that use Unicode properties \p or \P. 5923| | Others that are not available via \p or \P have to generate 5924| | XCL_PROP/XCL_NOTPROP directly, which is done here. */ 5925| | 5926| 5.90k|#ifdef SUPPORT_UNICODE 5927| 5.90k| if ((options & PCRE2_UCP) != 0 && ------------------ | | 136| 5.90k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (5927:13): [True: 1.89k, False: 4.01k] ------------------ 5928| 5.90k| (xoptions & PCRE2_EXTRA_ASCII_POSIX) == 0) ------------------ | | 160| 1.89k|#define PCRE2_EXTRA_ASCII_POSIX 0x00000800u /* C */ ------------------ | Branch (5928:13): [True: 1.11k, False: 778] ------------------ 5929| 1.11k| { 5930| 1.11k| switch(posix_class) 5931| 1.11k| { 5932| 0| case PC_GRAPH: ------------------ | | 709| 0|#define PC_GRAPH 8 ------------------ | Branch (5932:13): [True: 0, False: 1.11k] ------------------ 5933| 0| case PC_PRINT: ------------------ | | 710| 0|#define PC_PRINT 9 ------------------ | Branch (5933:13): [True: 0, False: 1.11k] ------------------ 5934| 0| case PC_PUNCT: ------------------ | | 711| 0|#define PC_PUNCT 10 ------------------ | Branch (5934:13): [True: 0, False: 1.11k] ------------------ 5935| 0| *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP; ------------------ | | 1317| 0|#define XCL_NOTPROP 4 /* Unicode inverted property (ditto) */ ------------------ *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP; ------------------ | | 1316| 0|#define XCL_PROP 3 /* Unicode property (2-byte property code follows) */ ------------------ | Branch (5935:34): [True: 0, False: 0] ------------------ 5936| 0| *class_uchardata++ = (PCRE2_UCHAR) 5937| 0| ((posix_class == PC_GRAPH)? PT_PXGRAPH : ------------------ | | 709| 0|#define PC_GRAPH 8 ------------------ ((posix_class == PC_GRAPH)? PT_PXGRAPH : ------------------ | | 1297| 0|#define PT_PXGRAPH 14 /* [:graph:] - characters that mark the paper */ ------------------ | Branch (5937:16): [True: 0, False: 0] ------------------ 5938| 0| (posix_class == PC_PRINT)? PT_PXPRINT : PT_PXPUNCT); ------------------ | | 710| 0|#define PC_PRINT 9 ------------------ (posix_class == PC_PRINT)? PT_PXPRINT : PT_PXPUNCT); ------------------ | | 1298| 0|#define PT_PXPRINT 15 /* [:print:] - [:graph:] plus non-control spaces */ ------------------ (posix_class == PC_PRINT)? PT_PXPRINT : PT_PXPUNCT); ------------------ | | 1299| 0|#define PT_PXPUNCT 16 /* [:punct:] - punctuation characters */ ------------------ | Branch (5938:16): [True: 0, False: 0] ------------------ 5939| 0| *class_uchardata++ = 0; 5940| 0| xclass_has_prop = TRUE; ------------------ | | 70| 0|#define TRUE 1 ------------------ 5941| 0| goto CONTINUE_CLASS; 5942| | 5943| | /* For the other POSIX classes (ascii, xdigit) we are going to 5944| | fall through to the non-UCP case and build a bit map for 5945| | characters with code points less than 256. However, if we are in 5946| | a negated POSIX class, characters with code points greater than 5947| | 255 must either all match or all not match, depending on whether 5948| | the whole class is not or is negated. For example, for 5949| | [[:^ascii:]... they must all match, whereas for [^[:^xdigit:]... 5950| | they must not. 5951| | 5952| | In the special case where there are no xclass items, this is 5953| | automatically handled by the use of OP_CLASS or OP_NCLASS, but an 5954| | explicit range is needed for OP_XCLASS. Setting a flag here 5955| | causes the range to be generated later when it is known that 5956| | OP_XCLASS is required. In the 8-bit library this is relevant only in 5957| | utf mode, since no wide characters can exist otherwise. */ 5958| | 5959| 1.11k| default: ------------------ | Branch (5959:13): [True: 1.11k, False: 0] ------------------ 5960| 1.11k|#if PCRE2_CODE_UNIT_WIDTH == 8 5961| 1.11k| if (utf) ------------------ | Branch (5961:17): [True: 596, False: 521] ------------------ 5962| 596|#endif 5963| 596| match_all_or_no_wide_chars |= local_negate; 5964| 1.11k| break; 5965| 1.11k| } 5966| 1.11k| } 5967| 5.90k|#endif /* SUPPORT_UNICODE */ 5968| | 5969| | /* In the non-UCP case, or when UCP makes no difference, we build the 5970| | bit map for the POSIX class in a chunk of local store because we may 5971| | be adding and subtracting from it, and we don't want to subtract bits 5972| | that may be in the main map already. At the end we or the result into 5973| | the bit map that is being built. */ 5974| | 5975| 5.90k| posix_class *= 3; 5976| | 5977| | /* Copy in the first table (always present) */ 5978| | 5979| 5.90k| memcpy(pbits, cbits + posix_class_maps[posix_class], 5980| 5.90k| 32 * sizeof(uint8_t)); 5981| | 5982| | /* If there is a second table, add or remove it as required. */ 5983| | 5984| 5.90k| taboffset = posix_class_maps[posix_class + 1]; 5985| 5.90k| tabopt = posix_class_maps[posix_class + 2]; 5986| | 5987| 5.90k| if (taboffset >= 0) ------------------ | Branch (5987:13): [True: 4.09k, False: 1.81k] ------------------ 5988| 4.09k| { 5989| 4.09k| if (tabopt >= 0) ------------------ | Branch (5989:15): [True: 2.81k, False: 1.27k] ------------------ 5990| 93.0k| for (int i = 0; i < 32; i++) pbits[i] |= cbits[(int)i + taboffset]; ------------------ | Branch (5990:29): [True: 90.2k, False: 2.81k] ------------------ 5991| 1.27k| else 5992| 42.1k| for (int i = 0; i < 32; i++) pbits[i] &= ~cbits[(int)i + taboffset]; ------------------ | Branch (5992:29): [True: 40.8k, False: 1.27k] ------------------ 5993| 4.09k| } 5994| | 5995| | /* Now see if we need to remove any special characters. An option 5996| | value of 1 removes vertical space and 2 removes underscore. */ 5997| | 5998| 5.90k| if (tabopt < 0) tabopt = -tabopt; ------------------ | Branch (5998:13): [True: 1.27k, False: 4.62k] ------------------ 5999| 5.90k| if (tabopt == 1) pbits[1] &= ~0x3c; ------------------ | Branch (5999:13): [True: 215, False: 5.69k] ------------------ 6000| 5.69k| else if (tabopt == 2) pbits[11] &= 0x7f; ------------------ | Branch (6000:20): [True: 1.32k, False: 4.36k] ------------------ 6001| | 6002| | /* Add the POSIX table or its complement into the main table that is 6003| | being built and we are done. */ 6004| | 6005| 5.90k| if (local_negate) ------------------ | Branch (6005:13): [True: 1.39k, False: 4.51k] ------------------ 6006| 45.9k| for (int i = 0; i < 32; i++) classbits[i] |= (uint8_t)(~pbits[i]); ------------------ | Branch (6006:27): [True: 44.5k, False: 1.39k] ------------------ 6007| 4.51k| else 6008| 148k| for (int i = 0; i < 32; i++) classbits[i] |= pbits[i]; ------------------ | Branch (6008:27): [True: 144k, False: 4.51k] ------------------ 6009| | 6010| | /* Every class contains at least one < 256 character. */ 6011| | 6012| 5.90k| class_has_8bitchar = 1; 6013| 5.90k| goto CONTINUE_CLASS; /* End of POSIX handling */ 6014| 5.90k| } 6015| | 6016| | /* Other than POSIX classes, the only items we should encounter are 6017| | \d-type escapes and literal characters (possibly as ranges). */ 6018| | 6019| 444k| if (meta == META_BIGVALUE) ------------------ | | 217| 444k|#define META_BIGVALUE 0x80050000u /* Next is a literal > META_END */ ------------------ | Branch (6019:11): [True: 0, False: 444k] ------------------ 6020| 0| { 6021| 0| meta = *(++pptr); 6022| 0| goto CLASS_LITERAL; 6023| 0| } 6024| | 6025| | /* Any other non-literal must be an escape */ 6026| | 6027| 444k| if (meta >= META_END) ------------------ | | 211| 444k|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (6027:11): [True: 19.5k, False: 425k] ------------------ 6028| 19.5k| { 6029| 19.5k| if (META_CODE(meta) != META_ESCAPE) ------------------ | | 113| 19.5k|#define META_CODE(x) (x & 0xffff0000u) ------------------ if (META_CODE(meta) != META_ESCAPE) ------------------ | | 236| 19.5k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (6029:13): [True: 0, False: 19.5k] ------------------ 6030| 0| { 6031| |#ifdef DEBUG_SHOW_PARSED 6032| | fprintf(stderr, "** Unrecognized parsed pattern item 0x%.8x " 6033| | "in character class\n", meta); 6034| |#endif 6035| 0| *errorcodeptr = ERR89; /* Internal error - unrecognized. */ 6036| 0| return 0; 6037| 0| } 6038| 19.5k| escape = META_DATA(meta); ------------------ | | 114| 19.5k|#define META_DATA(x) (x & 0x0000ffffu) ------------------ 6039| | 6040| | /* Every class contains at least one < 256 character. */ 6041| | 6042| 19.5k| class_has_8bitchar++; 6043| | 6044| 19.5k| switch(escape) ------------------ | Branch (6044:16): [True: 0, False: 19.5k] ------------------ 6045| 19.5k| { 6046| 1.25k| case ESC_d: ------------------ | Branch (6046:11): [True: 1.25k, False: 18.3k] ------------------ 6047| 41.5k| for (int i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_digit]; ------------------ | | 565| 40.2k|#define cbit_digit 64 /* [:digit:] or \d */ ------------------ | Branch (6047:27): [True: 40.2k, False: 1.25k] ------------------ 6048| 1.25k| break; 6049| | 6050| 1.69k| case ESC_D: ------------------ | Branch (6050:11): [True: 1.69k, False: 17.8k] ------------------ 6051| 1.69k| should_flip_negation = TRUE; ------------------ | | 70| 1.69k|#define TRUE 1 ------------------ 6052| 55.9k| for (int i = 0; i < 32; i++) ------------------ | Branch (6052:27): [True: 54.2k, False: 1.69k] ------------------ 6053| 54.2k| classbits[i] |= (uint8_t)(~cbits[i+cbit_digit]); ------------------ | | 565| 54.2k|#define cbit_digit 64 /* [:digit:] or \d */ ------------------ 6054| 1.69k| break; 6055| | 6056| 1.17k| case ESC_w: ------------------ | Branch (6056:11): [True: 1.17k, False: 18.4k] ------------------ 6057| 38.6k| for (int i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_word]; ------------------ | | 568| 37.4k|#define cbit_word 160 /* [:word:] or \w */ ------------------ | Branch (6057:27): [True: 37.4k, False: 1.17k] ------------------ 6058| 1.17k| break; 6059| | 6060| 1.51k| case ESC_W: ------------------ | Branch (6060:11): [True: 1.51k, False: 18.0k] ------------------ 6061| 1.51k| should_flip_negation = TRUE; ------------------ | | 70| 1.51k|#define TRUE 1 ------------------ 6062| 49.8k| for (int i = 0; i < 32; i++) ------------------ | Branch (6062:27): [True: 48.3k, False: 1.51k] ------------------ 6063| 48.3k| classbits[i] |= (uint8_t)(~cbits[i+cbit_word]); ------------------ | | 568| 48.3k|#define cbit_word 160 /* [:word:] or \w */ ------------------ 6064| 1.51k| break; 6065| | 6066| | /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl 6067| | 5.18. Before PCRE 8.34, we had to preserve the VT bit if it was 6068| | previously set by something earlier in the character class. 6069| | Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so 6070| | we could just adjust the appropriate bit. From PCRE 8.34 we no 6071| | longer treat \s and \S specially. */ 6072| | 6073| 2.03k| case ESC_s: ------------------ | Branch (6073:11): [True: 2.03k, False: 17.5k] ------------------ 6074| 67.0k| for (int i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_space]; ------------------ | | 563| 65.0k|#define cbit_space 0 /* [:space:] or \s */ ------------------ | Branch (6074:27): [True: 65.0k, False: 2.03k] ------------------ 6075| 2.03k| break; 6076| | 6077| 2.07k| case ESC_S: ------------------ | Branch (6077:11): [True: 2.07k, False: 17.4k] ------------------ 6078| 2.07k| should_flip_negation = TRUE; ------------------ | | 70| 2.07k|#define TRUE 1 ------------------ 6079| 68.4k| for (int i = 0; i < 32; i++) ------------------ | Branch (6079:27): [True: 66.4k, False: 2.07k] ------------------ 6080| 66.4k| classbits[i] |= (uint8_t)(~cbits[i+cbit_space]); ------------------ | | 563| 66.4k|#define cbit_space 0 /* [:space:] or \s */ ------------------ 6081| 2.07k| break; 6082| | 6083| | /* When adding the horizontal or vertical space lists to a class, or 6084| | their complements, disable PCRE2_CASELESS, because it justs wastes 6085| | time, and in the "not-x" UTF cases can create unwanted duplicates in 6086| | the XCLASS list (provoked by characters that have more than one other 6087| | case and by both cases being in the same "not-x" sublist). */ 6088| | 6089| 682| case ESC_h: ------------------ | Branch (6089:11): [True: 682, False: 18.8k] ------------------ 6090| 682| (void)add_list_to_class(classbits, &class_uchardata, 6091| 682| options & ~PCRE2_CASELESS, xoptions, cb, PRIV(hspace_list), ------------------ | | 122| 682|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ options & ~PCRE2_CASELESS, xoptions, cb, PRIV(hspace_list), ------------------ | | 177| 682|#define PRIV(name) _pcre2_##name ------------------ 6092| 682| NOTACHAR); ------------------ | | 205| 682|#define NOTACHAR 0xffffffff ------------------ 6093| 682| break; 6094| | 6095| 1.16k| case ESC_H: ------------------ | Branch (6095:11): [True: 1.16k, False: 18.4k] ------------------ 6096| 1.16k| (void)add_not_list_to_class(classbits, &class_uchardata, 6097| 1.16k| options & ~PCRE2_CASELESS, xoptions, cb, PRIV(hspace_list)); ------------------ | | 122| 1.16k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ options & ~PCRE2_CASELESS, xoptions, cb, PRIV(hspace_list)); ------------------ | | 177| 1.16k|#define PRIV(name) _pcre2_##name ------------------ 6098| 1.16k| break; 6099| | 6100| 435| case ESC_v: ------------------ | Branch (6100:11): [True: 435, False: 19.1k] ------------------ 6101| 435| (void)add_list_to_class(classbits, &class_uchardata, 6102| 435| options & ~PCRE2_CASELESS, xoptions, cb, PRIV(vspace_list), ------------------ | | 122| 435|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ options & ~PCRE2_CASELESS, xoptions, cb, PRIV(vspace_list), ------------------ | | 177| 435|#define PRIV(name) _pcre2_##name ------------------ 6103| 435| NOTACHAR); ------------------ | | 205| 435|#define NOTACHAR 0xffffffff ------------------ 6104| 435| break; 6105| | 6106| 615| case ESC_V: ------------------ | Branch (6106:11): [True: 615, False: 18.9k] ------------------ 6107| 615| (void)add_not_list_to_class(classbits, &class_uchardata, 6108| 615| options & ~PCRE2_CASELESS, xoptions, cb, PRIV(vspace_list)); ------------------ | | 122| 615|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ options & ~PCRE2_CASELESS, xoptions, cb, PRIV(vspace_list)); ------------------ | | 177| 615|#define PRIV(name) _pcre2_##name ------------------ 6109| 615| break; 6110| | 6111| | /* If Unicode is not supported, \P and \p are not allowed and are 6112| | faulted at parse time, so will never appear here. */ 6113| | 6114| 0|#ifdef SUPPORT_UNICODE 6115| 4.00k| case ESC_p: ------------------ | Branch (6115:11): [True: 4.00k, False: 15.5k] ------------------ 6116| 6.93k| case ESC_P: ------------------ | Branch (6116:11): [True: 2.93k, False: 16.6k] ------------------ 6117| 6.93k| { 6118| 6.93k| uint32_t ptype = *(++pptr) >> 16; 6119| 6.93k| uint32_t pdata = *pptr & 0xffff; 6120| 6.93k| *class_uchardata++ = (escape == ESC_p)? XCL_PROP : XCL_NOTPROP; ------------------ | | 1316| 4.00k|#define XCL_PROP 3 /* Unicode property (2-byte property code follows) */ ------------------ *class_uchardata++ = (escape == ESC_p)? XCL_PROP : XCL_NOTPROP; ------------------ | | 1317| 9.86k|#define XCL_NOTPROP 4 /* Unicode inverted property (ditto) */ ------------------ | Branch (6120:34): [True: 4.00k, False: 2.93k] ------------------ 6121| 6.93k| *class_uchardata++ = ptype; 6122| 6.93k| *class_uchardata++ = pdata; 6123| 6.93k| xclass_has_prop = TRUE; ------------------ | | 70| 6.93k|#define TRUE 1 ------------------ 6124| 6.93k| class_has_8bitchar--; /* Undo! */ 6125| 6.93k| } 6126| 6.93k| break; 6127| 19.5k|#endif 6128| 19.5k| } 6129| | 6130| 19.5k| goto CONTINUE_CLASS; 6131| 19.5k| } /* End handling \d-type escapes */ 6132| | 6133| | /* A literal character may be followed by a range meta. At parse time 6134| | there are checks for out-of-order characters, for ranges where the two 6135| | characters are equal, and for hyphens that cannot indicate a range. At 6136| | this point, therefore, no checking is needed. */ 6137| | 6138| 425k| else 6139| 425k| { 6140| 425k| uint32_t c, d; 6141| | 6142| 425k| CLASS_LITERAL: 6143| 425k| c = d = meta; 6144| | 6145| | /* Remember if \r or \n were explicitly used */ 6146| | 6147| 425k| if (c == CHAR_CR || c == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF; ------------------ | | 972| 850k|#define CHAR_CR '\015' ------------------ if (c == CHAR_CR || c == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF; ------------------ | | 974| 424k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 424k|#define CHAR_LF '\012' | | ------------------ ------------------ if (c == CHAR_CR || c == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF; ------------------ | | 518| 3.72k|#define PCRE2_HASCRORLF 0x00000800 /* explicit \r or \n in pattern */ ------------------ | Branch (6147:13): [True: 1.18k, False: 424k] | Branch (6147:29): [True: 2.53k, False: 421k] ------------------ 6148| | 6149| | /* Process a character range */ 6150| | 6151| 425k| if (pptr[1] == META_RANGE_LITERAL || pptr[1] == META_RANGE_ESCAPED) ------------------ | | 243| 850k|#define META_RANGE_LITERAL 0x801f0000u /* range defined literally */ ------------------ if (pptr[1] == META_RANGE_LITERAL || pptr[1] == META_RANGE_ESCAPED) ------------------ | | 242| 423k|#define META_RANGE_ESCAPED 0x801e0000u /* range with at least one escape */ ------------------ | Branch (6151:13): [True: 1.52k, False: 423k] | Branch (6151:46): [True: 818, False: 422k] ------------------ 6152| 2.34k| { 6153| |#ifdef EBCDIC 6154| | BOOL range_is_literal = (pptr[1] == META_RANGE_LITERAL); 6155| |#endif 6156| 2.34k| pptr += 2; 6157| 2.34k| d = *pptr; 6158| 2.34k| if (d == META_BIGVALUE) d = *(++pptr); ------------------ | | 217| 2.34k|#define META_BIGVALUE 0x80050000u /* Next is a literal > META_END */ ------------------ | Branch (6158:15): [True: 0, False: 2.34k] ------------------ 6159| | 6160| | /* Remember an explicit \r or \n, and add the range to the class. */ 6161| | 6162| 2.34k| if (d == CHAR_CR || d == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF; ------------------ | | 972| 4.68k|#define CHAR_CR '\015' ------------------ if (d == CHAR_CR || d == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF; ------------------ | | 974| 2.14k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 2.14k|#define CHAR_LF '\012' | | ------------------ ------------------ if (d == CHAR_CR || d == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF; ------------------ | | 518| 396|#define PCRE2_HASCRORLF 0x00000800 /* explicit \r or \n in pattern */ ------------------ | Branch (6162:15): [True: 194, False: 2.14k] | Branch (6162:31): [True: 202, False: 1.94k] ------------------ 6163| | 6164| | /* In an EBCDIC environment, Perl treats alphabetic ranges specially 6165| | because there are holes in the encoding, and simply using the range 6166| | A-Z (for example) would include the characters in the holes. This 6167| | applies only to literal ranges; [\xC1-\xE9] is different to [A-Z]. */ 6168| | 6169| |#ifdef EBCDIC 6170| | if (range_is_literal && 6171| | (cb->ctypes[c] & ctype_letter) != 0 && 6172| | (cb->ctypes[d] & ctype_letter) != 0 && 6173| | (c <= CHAR_z) == (d <= CHAR_z)) 6174| | { 6175| | uint32_t uc = (d <= CHAR_z)? 0 : 64; 6176| | uint32_t C = c - uc; 6177| | uint32_t D = d - uc; 6178| | 6179| | if (C <= CHAR_i) 6180| | { 6181| | class_has_8bitchar += 6182| | add_to_class(classbits, &class_uchardata, options, xoptions, 6183| | cb, C + uc, ((D < CHAR_i)? D : CHAR_i) + uc); 6184| | C = CHAR_j; 6185| | } 6186| | 6187| | if (C <= D && C <= CHAR_r) 6188| | { 6189| | class_has_8bitchar += 6190| | add_to_class(classbits, &class_uchardata, options, xoptions, 6191| | cb, C + uc, ((D < CHAR_r)? D : CHAR_r) + uc); 6192| | C = CHAR_s; 6193| | } 6194| | 6195| | if (C <= D) 6196| | { 6197| | class_has_8bitchar += 6198| | add_to_class(classbits, &class_uchardata, options, xoptions, 6199| | cb, C + uc, D + uc); 6200| | } 6201| | } 6202| | else 6203| |#endif 6204| | /* Not an EBCDIC special range */ 6205| | 6206| 2.34k| class_has_8bitchar += add_to_class(classbits, &class_uchardata, 6207| 2.34k| options, xoptions, cb, c, d); 6208| 2.34k| goto CONTINUE_CLASS; /* Go get the next char in the class */ 6209| 2.34k| } /* End of range handling */ 6210| | 6211| | 6212| | /* Handle a single character. */ 6213| | 6214| 422k| class_has_8bitchar += 6215| 422k| add_to_class(classbits, &class_uchardata, options, xoptions, cb, 6216| 422k| meta, meta); 6217| 422k| } 6218| | 6219| | /* Continue to the next item in the class. */ 6220| | 6221| 450k| CONTINUE_CLASS: 6222| | 6223| 450k|#ifdef SUPPORT_WIDE_CHARS 6224| | /* If any wide characters or Unicode properties have been encountered, 6225| | set xclass = TRUE. Then, in the pre-compile phase, accumulate the length 6226| | of the extra data and reset the pointer. This is so that very large 6227| | classes that contain a zillion wide characters or Unicode property tests 6228| | do not overwrite the workspace (which is on the stack). */ 6229| | 6230| 450k| if (class_uchardata > class_uchardata_base) ------------------ | Branch (6230:11): [True: 30.8k, False: 419k] ------------------ 6231| 30.8k| { 6232| 30.8k| xclass = TRUE; ------------------ | | 70| 30.8k|#define TRUE 1 ------------------ 6233| 30.8k| if (lengthptr != NULL) ------------------ | Branch (6233:13): [True: 6.36k, False: 24.4k] ------------------ 6234| 6.36k| { 6235| 6.36k| *lengthptr += class_uchardata - class_uchardata_base; 6236| 6.36k| class_uchardata = class_uchardata_base; 6237| 6.36k| } 6238| 30.8k| } 6239| 450k|#endif 6240| | 6241| 450k| continue; /* Needed to avoid error when not supporting wide chars */ 6242| 444k| } /* End of main class-processing loop */ 6243| | 6244| | /* If this class is the first thing in the branch, there can be no first 6245| | char setting, whatever the repeat count. Any reqcu setting must remain 6246| | unchanged after any kind of repeat. */ 6247| | 6248| 28.6k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 28.6k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 10.2k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6248:9): [True: 10.2k, False: 18.4k] ------------------ 6249| 28.6k| zerofirstcu = firstcu; 6250| 28.6k| zerofirstcuflags = firstcuflags; 6251| 28.6k| zeroreqcu = reqcu; 6252| 28.6k| zeroreqcuflags = reqcuflags; 6253| | 6254| | /* If there are characters with values > 255, or Unicode property settings 6255| | (\p or \P), we have to compile an extended class, with its own opcode, 6256| | unless there were no property settings and there was a negated special such 6257| | as \S in the class, and PCRE2_UCP is not set, because in that case all 6258| | characters > 255 are in or not in the class, so any that were explicitly 6259| | given as well can be ignored. 6260| | 6261| | In the UCP case, if certain negated POSIX classes ([:^ascii:] or 6262| | [^:xdigit:]) were present in a class, we either have to match or not match 6263| | all wide characters (depending on whether the whole class is or is not 6264| | negated). This requirement is indicated by match_all_or_no_wide_chars being 6265| | true. We do this by including an explicit range, which works in both cases. 6266| | This applies only in UTF and 16-bit and 32-bit non-UTF modes, since there 6267| | cannot be any wide characters in 8-bit non-UTF mode. 6268| | 6269| | When there *are* properties in a positive UTF-8 or any 16-bit or 32_bit 6270| | class where \S etc is present without PCRE2_UCP, causing an extended class 6271| | to be compiled, we make sure that all characters > 255 are included by 6272| | forcing match_all_or_no_wide_chars to be true. 6273| | 6274| | If, when generating an xclass, there are no characters < 256, we can omit 6275| | the bitmap in the actual compiled code. */ 6276| | 6277| 28.6k|#ifdef SUPPORT_WIDE_CHARS /* Defined for 16/32 bits, or 8-bit with Unicode */ 6278| 28.6k| if (xclass && ( ------------------ | Branch (6278:9): [True: 8.37k, False: 20.3k] ------------------ 6279| 8.37k|#ifdef SUPPORT_UNICODE 6280| 8.37k| (options & PCRE2_UCP) != 0 || ------------------ | | 136| 8.37k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (6280:9): [True: 4.70k, False: 3.66k] ------------------ 6281| 8.37k|#endif 6282| 8.37k| xclass_has_prop || !should_flip_negation)) ------------------ | Branch (6282:9): [True: 1.97k, False: 1.69k] | Branch (6282:28): [True: 1.43k, False: 256] ------------------ 6283| 8.11k| { 6284| 8.11k| if (match_all_or_no_wide_chars || ( ------------------ | Branch (6284:11): [True: 196, False: 7.91k] ------------------ 6285| 7.91k|#if PCRE2_CODE_UNIT_WIDTH == 8 6286| 7.91k| utf && ------------------ | Branch (6286:12): [True: 4.77k, False: 3.13k] ------------------ 6287| 7.91k|#endif 6288| 7.91k| should_flip_negation && !negate_class && (options & PCRE2_UCP) == 0)) ------------------ | | 136| 388|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (6288:12): [True: 590, False: 4.18k] | Branch (6288:36): [True: 388, False: 202] | Branch (6288:53): [True: 194, False: 194] ------------------ 6289| 390| { 6290| 390| *class_uchardata++ = XCL_RANGE; ------------------ | | 1315| 390|#define XCL_RANGE 2 /* A range (two multibyte chars) follows */ ------------------ 6291| 390| if (utf) /* Will always be utf in the 8-bit library */ ------------------ | Branch (6291:13): [True: 390, False: 0] ------------------ 6292| 390| { 6293| 390| class_uchardata += PRIV(ord2utf)(0x100, class_uchardata); ------------------ | | 177| 390|#define PRIV(name) _pcre2_##name ------------------ 6294| 390| class_uchardata += PRIV(ord2utf)(MAX_UTF_CODE_POINT, class_uchardata); ------------------ | | 177| 390|#define PRIV(name) _pcre2_##name ------------------ class_uchardata += PRIV(ord2utf)(MAX_UTF_CODE_POINT, class_uchardata); ------------------ | | 209| 390|#define MAX_UTF_CODE_POINT 0x10ffff ------------------ 6295| 390| } 6296| 0| else /* Can only happen for the 16-bit & 32-bit libraries */ 6297| 0| { 6298| |#if PCRE2_CODE_UNIT_WIDTH == 16 6299| | *class_uchardata++ = 0x100; 6300| | *class_uchardata++ = 0xffffu; 6301| |#elif PCRE2_CODE_UNIT_WIDTH == 32 6302| | *class_uchardata++ = 0x100; 6303| | *class_uchardata++ = 0xffffffffu; 6304| |#endif 6305| 0| } 6306| 390| } 6307| 8.11k| *class_uchardata++ = XCL_END; /* Marks the end of extra data */ ------------------ | | 1313| 8.11k|#define XCL_END 0 /* Marks end of individual items */ ------------------ 6308| 8.11k| *code++ = OP_XCLASS; 6309| 8.11k| code += LINK_SIZE; ------------------ | | 165| 8.11k|#define LINK_SIZE 2 ------------------ 6310| 8.11k| *code = negate_class? XCL_NOT:0; ------------------ | | 1309| 1.69k|#define XCL_NOT 0x01 /* Flag: this is a negative class */ ------------------ | Branch (6310:15): [True: 1.69k, False: 6.42k] ------------------ 6311| 8.11k| if (xclass_has_prop) *code |= XCL_HASPROP; ------------------ | | 1311| 5.06k|#define XCL_HASPROP 0x04 /* Flag: property checks are present. */ ------------------ | Branch (6311:11): [True: 5.06k, False: 3.05k] ------------------ 6312| | 6313| | /* If the map is required, move up the extra data to make room for it; 6314| | otherwise just move the code pointer to the end of the extra data. */ 6315| | 6316| 8.11k| if (class_has_8bitchar > 0) ------------------ | Branch (6316:11): [True: 5.23k, False: 2.88k] ------------------ 6317| 5.23k| { 6318| 5.23k| *code++ |= XCL_MAP; ------------------ | | 1310| 5.23k|#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */ ------------------ 6319| 5.23k| (void)memmove(code + (32 / sizeof(PCRE2_UCHAR)), code, 6320| 5.23k| CU2BYTES(class_uchardata - code)); ------------------ | | 545| 5.23k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 6321| 5.23k| if (negate_class && !xclass_has_prop) ------------------ | Branch (6321:13): [True: 1.64k, False: 3.59k] | Branch (6321:29): [True: 990, False: 651] ------------------ 6322| 990| { 6323| | /* Using 255 ^ instead of ~ avoids clang sanitize warning. */ 6324| 32.6k| for (int i = 0; i < 32; i++) classbits[i] = 255 ^ classbits[i]; ------------------ | Branch (6324:27): [True: 31.6k, False: 990] ------------------ 6325| 990| } 6326| 5.23k| memcpy(code, classbits, 32); 6327| 5.23k| code = class_uchardata + (32 / sizeof(PCRE2_UCHAR)); 6328| 5.23k| } 6329| 2.88k| else code = class_uchardata; 6330| | 6331| | /* Now fill in the complete length of the item */ 6332| | 6333| 8.11k| PUT(previous, 1, (int)(code - previous)); ------------------ | | 106| 8.11k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 8.11k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 6334| 8.11k| break; /* End of class handling */ 6335| 8.11k| } 6336| 20.5k|#endif /* SUPPORT_WIDE_CHARS */ 6337| | 6338| | /* If there are no characters > 255, or they are all to be included or 6339| | excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the 6340| | whole class was negated and whether there were negative specials such as \S 6341| | (non-UCP) in the class. Then copy the 32-byte map into the code vector, 6342| | negating it if necessary. */ 6343| | 6344| 20.5k| *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS; ------------------ | Branch (6344:15): [True: 13.4k, False: 7.11k] ------------------ 6345| 20.5k| if (lengthptr == NULL) /* Save time in the pre-compile phase */ ------------------ | Branch (6345:9): [True: 9.93k, False: 10.6k] ------------------ 6346| 9.93k| { 6347| 9.93k| if (negate_class) ------------------ | Branch (6347:11): [True: 1.93k, False: 8.00k] ------------------ 6348| 1.93k| { 6349| | /* Using 255 ^ instead of ~ avoids clang sanitize warning. */ 6350| 63.8k| for (int i = 0; i < 32; i++) classbits[i] = 255 ^ classbits[i]; ------------------ | Branch (6350:24): [True: 61.9k, False: 1.93k] ------------------ 6351| 1.93k| } 6352| 9.93k| memcpy(code, classbits, 32); 6353| 9.93k| } 6354| 20.5k| code += 32 / sizeof(PCRE2_UCHAR); 6355| 20.5k| break; /* End of class processing */ 6356| | 6357| | 6358| | /* ===================================================================*/ 6359| | /* Deal with (*VERB)s. */ 6360| | 6361| | /* Check for open captures before ACCEPT and close those that are within 6362| | the same assertion level, also converting ACCEPT to ASSERT_ACCEPT in an 6363| | assertion. In the first pass, just accumulate the length required; 6364| | otherwise hitting (*ACCEPT) inside many nested parentheses can cause 6365| | workspace overflow. Do not set firstcu after *ACCEPT. */ 6366| | 6367| 1.56k| case META_ACCEPT: ------------------ | | 266| 1.56k|#define META_ACCEPT 0x802a0000u /* (*ACCEPT) */ ------------------ | Branch (6367:5): [True: 1.56k, False: 3.67M] ------------------ 6368| 1.56k| cb->had_accept = had_accept = TRUE; ------------------ | | 70| 1.56k|#define TRUE 1 ------------------ 6369| 1.56k| for (oc = open_caps; 6370| 4.31k| oc != NULL && oc->assert_depth >= cb->assert_depth; ------------------ | Branch (6370:10): [True: 2.81k, False: 1.49k] | Branch (6370:24): [True: 2.74k, False: 65] ------------------ 6371| 2.74k| oc = oc->next) 6372| 2.74k| { 6373| 2.74k| if (lengthptr != NULL) ------------------ | Branch (6373:11): [True: 1.48k, False: 1.26k] ------------------ 6374| 1.48k| { 6375| 1.48k| *lengthptr += CU2BYTES(1) + IMM2_SIZE; ------------------ | | 545| 1.48k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ *lengthptr += CU2BYTES(1) + IMM2_SIZE; ------------------ | | 193| 1.48k|#define IMM2_SIZE 2 ------------------ 6376| 1.48k| } 6377| 1.26k| else 6378| 1.26k| { 6379| 1.26k| *code++ = OP_CLOSE; 6380| 1.26k| PUT2INC(code, 0, oc->number); ------------------ | | 548| 1.26k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 1.26k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 1.26k|#define IMM2_SIZE 2 | | ------------------ ------------------ 6381| 1.26k| } 6382| 2.74k| } 6383| 1.56k| *code++ = (cb->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT; ------------------ | Branch (6383:15): [True: 251, False: 1.31k] ------------------ 6384| 1.56k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 1.56k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 1.09k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6384:9): [True: 1.09k, False: 470] ------------------ 6385| 1.56k| break; 6386| | 6387| 609| case META_PRUNE: ------------------ | | 270| 609|#define META_PRUNE 0x802e0000u /* must */ ------------------ | Branch (6387:5): [True: 609, False: 3.67M] ------------------ 6388| 1.39k| case META_SKIP: ------------------ | | 272| 1.39k|#define META_SKIP 0x80300000u /* kept */ ------------------ | Branch (6388:5): [True: 790, False: 3.67M] ------------------ 6389| 1.39k| cb->had_pruneorskip = TRUE; ------------------ | | 70| 1.39k|#define TRUE 1 ------------------ 6390| | /* Fall through */ 6391| 2.00k| case META_COMMIT: ------------------ | | 268| 2.00k|#define META_COMMIT 0x802c0000u /* These */ ------------------ | Branch (6391:5): [True: 602, False: 3.67M] ------------------ 6392| 2.82k| case META_FAIL: ------------------ | | 267| 2.82k|#define META_FAIL 0x802b0000u /* (*FAIL) */ ------------------ | Branch (6392:5): [True: 827, False: 3.67M] ------------------ 6393| 2.82k| *code++ = verbops[(meta - META_MARK) >> 16]; ------------------ | | 265| 2.82k|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ 6394| 2.82k| break; 6395| | 6396| 1.05k| case META_THEN: ------------------ | | 274| 1.05k|#define META_THEN 0x80320000u /* this */ ------------------ | Branch (6396:5): [True: 1.05k, False: 3.67M] ------------------ 6397| 1.05k| cb->external_flags |= PCRE2_HASTHEN; ------------------ | | 519| 1.05k|#define PCRE2_HASTHEN 0x00001000 /* pattern contains (*THEN) */ ------------------ 6398| 1.05k| *code++ = OP_THEN; 6399| 1.05k| break; 6400| | 6401| | /* Handle verbs with arguments. Arguments can be very long, especially in 6402| | 16- and 32-bit modes, and can overflow the workspace in the first pass. 6403| | However, the argument length is constrained to be small enough to fit in 6404| | one code unit. This check happens in parse_regex(). In the first pass, 6405| | instead of putting the argument into memory, we just update the length 6406| | counter and set up an empty argument. */ 6407| | 6408| 566| case META_THEN_ARG: ------------------ | | 275| 566|#define META_THEN_ARG 0x80330000u /* order */ ------------------ | Branch (6408:5): [True: 566, False: 3.67M] ------------------ 6409| 566| cb->external_flags |= PCRE2_HASTHEN; ------------------ | | 519| 566|#define PCRE2_HASTHEN 0x00001000 /* pattern contains (*THEN) */ ------------------ 6410| 566| goto VERB_ARG; 6411| | 6412| 470| case META_PRUNE_ARG: ------------------ | | 271| 470|#define META_PRUNE_ARG 0x802f0000u /* be */ ------------------ | Branch (6412:5): [True: 470, False: 3.67M] ------------------ 6413| 2.05k| case META_SKIP_ARG: ------------------ | | 273| 2.05k|#define META_SKIP_ARG 0x80310000u /* in */ ------------------ | Branch (6413:5): [True: 1.58k, False: 3.67M] ------------------ 6414| 2.05k| cb->had_pruneorskip = TRUE; ------------------ | | 70| 2.05k|#define TRUE 1 ------------------ 6415| | /* Fall through */ 6416| 3.76k| case META_MARK: ------------------ | | 265| 3.76k|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ | Branch (6416:5): [True: 1.71k, False: 3.67M] ------------------ 6417| 4.35k| case META_COMMIT_ARG: ------------------ | | 269| 4.35k|#define META_COMMIT_ARG 0x802d0000u /* pairs */ ------------------ | Branch (6417:5): [True: 586, False: 3.67M] ------------------ 6418| 4.92k| VERB_ARG: 6419| 4.92k| *code++ = verbops[(meta - META_MARK) >> 16]; ------------------ | | 265| 4.92k|#define META_MARK 0x80290000u /* (*MARK) */ ------------------ 6420| | /* The length is in characters. */ 6421| 4.92k| verbarglen = *(++pptr); 6422| 4.92k| verbculen = 0; 6423| 4.92k| tempcode = code++; 6424| 16.2k| for (int i = 0; i < (int)verbarglen; i++) ------------------ | Branch (6424:21): [True: 11.3k, False: 4.92k] ------------------ 6425| 11.3k| { 6426| 11.3k| meta = *(++pptr); 6427| 11.3k|#ifdef SUPPORT_UNICODE 6428| 11.3k| if (utf) mclength = PRIV(ord2utf)(meta, mcbuffer); else ------------------ | | 177| 1.63k|#define PRIV(name) _pcre2_##name ------------------ | Branch (6428:11): [True: 1.63k, False: 9.72k] ------------------ 6429| 9.72k|#endif 6430| 9.72k| { 6431| 9.72k| mclength = 1; 6432| 9.72k| mcbuffer[0] = meta; 6433| 9.72k| } 6434| 11.3k| if (lengthptr != NULL) *lengthptr += mclength; else ------------------ | Branch (6434:11): [True: 5.70k, False: 5.65k] ------------------ 6435| 5.65k| { 6436| 5.65k| memcpy(code, mcbuffer, CU2BYTES(mclength)); ------------------ | | 545| 5.65k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 6437| 5.65k| code += mclength; 6438| 5.65k| verbculen += mclength; 6439| 5.65k| } 6440| 11.3k| } 6441| | 6442| 4.92k| *tempcode = verbculen; /* Fill in the code unit length */ 6443| 4.92k| *code++ = 0; /* Terminating zero */ 6444| 4.92k| break; 6445| | 6446| | 6447| | /* ===================================================================*/ 6448| | /* Handle options change. The new setting must be passed back for use in 6449| | subsequent branches. Reset the greedy defaults and the case value for 6450| | firstcu and reqcu. */ 6451| | 6452| 3.03k| case META_OPTIONS: ------------------ | | 239| 3.03k|#define META_OPTIONS 0x801b0000u /* (?i) and friends */ ------------------ | Branch (6452:5): [True: 3.03k, False: 3.67M] ------------------ 6453| 3.03k| *optionsptr = options = *(++pptr); 6454| 3.03k| *xoptionsptr = xoptions = *(++pptr); 6455| 3.03k| greedy_default = ((options & PCRE2_UNGREEDY) != 0); ------------------ | | 137| 3.03k|#define PCRE2_UNGREEDY 0x00040000u /* C */ ------------------ 6456| 3.03k| greedy_non_default = greedy_default ^ 1; 6457| 3.03k| req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS : 0; ------------------ | | 122| 3.03k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS : 0; ------------------ | | 395| 1.22k|#define REQ_CASELESS 0x00000001u /* Code unit in xxcu is caseless */ ------------------ | Branch (6457:19): [True: 1.22k, False: 1.81k] ------------------ 6458| 3.03k| break; 6459| | 6460| | 6461| | /* ===================================================================*/ 6462| | /* Handle conditional subpatterns. The case of (?(Rdigits) is ambiguous 6463| | because it could be a numerical check on recursion, or a name check on a 6464| | group's being set. The pre-pass sets up META_COND_RNUMBER as a name so that 6465| | we can handle it either way. We first try for a name; if not found, process 6466| | the number. */ 6467| | 6468| 3.07k| case META_COND_RNUMBER: /* (?(Rdigits) */ ------------------ | | 232| 3.07k|#define META_COND_RNUMBER 0x80140000u /* (?(Rdigits)... */ ------------------ | Branch (6468:5): [True: 3.07k, False: 3.67M] ------------------ 6469| 4.47k| case META_COND_NAME: /* (?(name) or (?'name') or ?() */ ------------------ | | 229| 4.47k|#define META_COND_NAME 0x80110000u /* (?()... */ ------------------ | Branch (6469:5): [True: 1.39k, False: 3.67M] ------------------ 6470| 5.06k| case META_COND_RNAME: /* (?(R&name) - test for recursion */ ------------------ | | 231| 5.06k|#define META_COND_RNAME 0x80130000u /* (?(R&name)... */ ------------------ | Branch (6470:5): [True: 596, False: 3.67M] ------------------ 6471| 5.06k| bravalue = OP_COND; 6472| 5.06k| { 6473| 5.06k| int count, index; 6474| 5.06k| unsigned int i; 6475| 5.06k| PCRE2_SPTR name; ------------------ | | 814| 5.06k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 5.06k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 5.06k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 5.06k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6476| 5.06k| named_group *ng = cb->named_groups; ------------------ | | 1983| 5.06k|#define named_group PCRE2_SUFFIX(named_group_) | | ------------------ | | | | 986| 5.06k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 5.06k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 5.06k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6477| 5.06k| uint32_t length = *(++pptr); 6478| | 6479| 5.06k| GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 5.06k| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 6480| 5.06k| name = cb->start_pattern + offset; 6481| | 6482| | /* In the first pass, the names generated in the pre-pass are available, 6483| | but the main name table has not yet been created. Scan the list of names 6484| | generated in the pre-pass in order to get a number and whether or not 6485| | this name is duplicated. If it is not duplicated, we can handle it as a 6486| | numerical group. */ 6487| | 6488| 10.2k| for (i = 0; i < cb->names_found; i++, ng++) ------------------ | Branch (6488:19): [True: 7.22k, False: 3.04k] ------------------ 6489| 7.22k| { 6490| 7.22k| if (length == ng->length && ------------------ | Branch (6490:13): [True: 4.11k, False: 3.11k] ------------------ 6491| 7.22k| PRIV(strncmp)(name, ng->name, length) == 0) ------------------ | | 177| 4.11k|#define PRIV(name) _pcre2_##name ------------------ | Branch (6491:13): [True: 2.02k, False: 2.09k] ------------------ 6492| 2.02k| { 6493| 2.02k| if (!ng->isdup) ------------------ | Branch (6493:15): [True: 876, False: 1.15k] ------------------ 6494| 876| { 6495| 876| code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_RREF : OP_CREF; ------------------ | | 165| 876|#define LINK_SIZE 2 ------------------ code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_RREF : OP_CREF; ------------------ | | 231| 876|#define META_COND_RNAME 0x80130000u /* (?(R&name)... */ ------------------ | Branch (6495:33): [True: 333, False: 543] ------------------ 6496| 876| PUT2(code, 2+LINK_SIZE, ng->number); ------------------ | | 195| 876|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 ------------------ 6497| 876| if (ng->number > cb->top_backref) cb->top_backref = ng->number; ------------------ | Branch (6497:17): [True: 109, False: 767] ------------------ 6498| 876| skipunits = 1+IMM2_SIZE; ------------------ | | 193| 876|#define IMM2_SIZE 2 ------------------ 6499| 876| goto GROUP_PROCESS_NOTE_EMPTY; 6500| 876| } 6501| 1.15k| break; /* Found a duplicated name */ 6502| 2.02k| } 6503| 7.22k| } 6504| | 6505| | /* If the name was not found we have a bad reference, unless we are 6506| | dealing with R, which is treated as a recursion test by number. 6507| | */ 6508| | 6509| 4.19k| if (i >= cb->names_found) ------------------ | Branch (6509:11): [True: 3.04k, False: 1.15k] ------------------ 6510| 3.04k| { 6511| 3.04k| groupnumber = 0; 6512| 3.04k| if (meta == META_COND_RNUMBER) ------------------ | | 232| 3.04k|#define META_COND_RNUMBER 0x80140000u /* (?(Rdigits)... */ ------------------ | Branch (6512:13): [True: 2.95k, False: 87] ------------------ 6513| 2.95k| { 6514| 3.78k| for (i = 1; i < length; i++) ------------------ | Branch (6514:23): [True: 832, False: 2.95k] ------------------ 6515| 832| { 6516| 832| groupnumber = groupnumber * 10 + name[i] - CHAR_0; ------------------ | | 998| 832|#define CHAR_0 '\060' ------------------ 6517| 832| if (groupnumber > MAX_GROUP_NUMBER) ------------------ | | 147| 832|#define MAX_GROUP_NUMBER 65535u ------------------ | Branch (6517:17): [True: 3, False: 829] ------------------ 6518| 3| { 6519| 3| *errorcodeptr = ERR61; 6520| 3| cb->erroroffset = offset + i; 6521| 3| return 0; 6522| 3| } 6523| 832| } 6524| 2.95k| } 6525| | 6526| 3.03k| if (meta != META_COND_RNUMBER || groupnumber > cb->bracount) ------------------ | | 232| 6.07k|#define META_COND_RNUMBER 0x80140000u /* (?(Rdigits)... */ ------------------ | Branch (6526:13): [True: 87, False: 2.95k] | Branch (6526:42): [True: 36, False: 2.91k] ------------------ 6527| 123| { 6528| 123| *errorcodeptr = ERR15; 6529| 123| cb->erroroffset = offset; 6530| 123| return 0; 6531| 123| } 6532| | 6533| | /* (?Rdigits) treated as a recursion reference by number. A value of 6534| | zero (which is the result of both (?R) and (?R0)) means "any", and is 6535| | translated into RREF_ANY (which is 0xffff). */ 6536| | 6537| 2.91k| if (groupnumber == 0) groupnumber = RREF_ANY; ------------------ | | 1789| 2.68k|#define RREF_ANY 0xffff ------------------ | Branch (6537:13): [True: 2.68k, False: 234] ------------------ 6538| 2.91k| code[1+LINK_SIZE] = OP_RREF; ------------------ | | 165| 2.91k|#define LINK_SIZE 2 ------------------ 6539| 2.91k| PUT2(code, 2+LINK_SIZE, groupnumber); ------------------ | | 195| 2.91k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 ------------------ 6540| 2.91k| skipunits = 1+IMM2_SIZE; ------------------ | | 193| 2.91k|#define IMM2_SIZE 2 ------------------ 6541| 2.91k| goto GROUP_PROCESS_NOTE_EMPTY; 6542| 3.03k| } 6543| | 6544| | /* A duplicated name was found. Note that if an R name is found 6545| | (META_COND_RNUMBER), it is a reference test, not a recursion test. */ 6546| | 6547| 1.15k| code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_RREF : OP_CREF; ------------------ | | 165| 1.15k|#define LINK_SIZE 2 ------------------ code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_RREF : OP_CREF; ------------------ | | 231| 1.15k|#define META_COND_RNAME 0x80130000u /* (?(R&name)... */ ------------------ | Branch (6547:27): [True: 227, False: 925] ------------------ 6548| | 6549| | /* We have a duplicated name. In the compile pass we have to search the 6550| | main table in order to get the index and count values. */ 6551| | 6552| 1.15k| count = 0; /* Values for first pass (avoids compiler warning) */ 6553| 1.15k| index = 0; 6554| 1.15k| if (lengthptr == NULL && !find_dupname_details(name, length, &index, ------------------ | Branch (6554:11): [True: 575, False: 577] | Branch (6554:32): [True: 0, False: 575] ------------------ 6555| 575| &count, errorcodeptr, cb)) return 0; 6556| | 6557| | /* Add one to the opcode to change CREF/RREF into DNCREF/DNRREF and 6558| | insert appropriate data values. */ 6559| | 6560| 1.15k| code[1+LINK_SIZE]++; ------------------ | | 165| 1.15k|#define LINK_SIZE 2 ------------------ 6561| 1.15k| skipunits = 1+2*IMM2_SIZE; ------------------ | | 193| 1.15k|#define IMM2_SIZE 2 ------------------ 6562| 1.15k| PUT2(code, 2+LINK_SIZE, index); ------------------ | | 195| 1.15k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 ------------------ 6563| 1.15k| PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count); ------------------ | | 195| 1.15k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 ------------------ 6564| 1.15k| } 6565| 0| goto GROUP_PROCESS_NOTE_EMPTY; 6566| | 6567| | /* The DEFINE condition is always false. Its internal groups may never 6568| | be called, so matched_char must remain false, hence the jump to 6569| | GROUP_PROCESS rather than GROUP_PROCESS_NOTE_EMPTY. */ 6570| | 6571| 0| case META_COND_DEFINE: ------------------ | | 228| 0|#define META_COND_DEFINE 0x80100000u /* (?(DEFINE)... */ ------------------ | Branch (6571:5): [True: 0, False: 3.67M] ------------------ 6572| 0| bravalue = OP_COND; 6573| 0| GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 0| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 6574| 0| code[1+LINK_SIZE] = OP_DEFINE; ------------------ | | 165| 0|#define LINK_SIZE 2 ------------------ 6575| 0| skipunits = 1; 6576| 0| goto GROUP_PROCESS; 6577| | 6578| | /* Conditional test of a group's being set. */ 6579| | 6580| 571| case META_COND_NUMBER: ------------------ | | 230| 571|#define META_COND_NUMBER 0x80120000u /* (?(digits)... */ ------------------ | Branch (6580:5): [True: 571, False: 3.67M] ------------------ 6581| 571| bravalue = OP_COND; 6582| 571| GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 571| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 6583| 571| groupnumber = *(++pptr); 6584| 571| if (groupnumber > cb->bracount) ------------------ | Branch (6584:9): [True: 71, False: 500] ------------------ 6585| 71| { 6586| 71| *errorcodeptr = ERR15; 6587| 71| cb->erroroffset = offset; 6588| 71| return 0; 6589| 71| } 6590| 500| if (groupnumber > cb->top_backref) cb->top_backref = groupnumber; ------------------ | Branch (6590:9): [True: 154, False: 346] ------------------ 6591| 500| offset -= 2; /* Point at initial ( for too many branches error */ 6592| 500| code[1+LINK_SIZE] = OP_CREF; ------------------ | | 165| 500|#define LINK_SIZE 2 ------------------ 6593| 500| skipunits = 1+IMM2_SIZE; ------------------ | | 193| 500|#define IMM2_SIZE 2 ------------------ 6594| 500| PUT2(code, 2+LINK_SIZE, groupnumber); ------------------ | | 195| 500|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 ------------------ 6595| 500| goto GROUP_PROCESS_NOTE_EMPTY; 6596| | 6597| | /* Test for the PCRE2 version. */ 6598| | 6599| 2.41k| case META_COND_VERSION: ------------------ | | 233| 2.41k|#define META_COND_VERSION 0x80150000u /* (?(VERSIONx.y)... */ ------------------ | Branch (6599:5): [True: 2.41k, False: 3.67M] ------------------ 6600| 2.41k| bravalue = OP_COND; 6601| 2.41k| if (pptr[1] > 0) ------------------ | Branch (6601:9): [True: 739, False: 1.67k] ------------------ 6602| 739| code[1+LINK_SIZE] = ((PCRE2_MAJOR > pptr[2]) || ------------------ | | 165| 739|#define LINK_SIZE 2 ------------------ code[1+LINK_SIZE] = ((PCRE2_MAJOR > pptr[2]) || ------------------ | | 44| 739|#define PCRE2_MAJOR 10 ------------------ | Branch (6602:28): [True: 348, False: 391] ------------------ 6603| 739| (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR >= pptr[3]))? ------------------ | | 44| 391|#define PCRE2_MAJOR 10 ------------------ (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR >= pptr[3]))? ------------------ | | 45| 197|#define PCRE2_MINOR 43 ------------------ | Branch (6603:10): [True: 197, False: 194] | Branch (6603:36): [True: 197, False: 0] ------------------ 6604| 545| OP_TRUE : OP_FALSE; 6605| 1.67k| else 6606| 1.67k| code[1+LINK_SIZE] = (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR == pptr[3])? ------------------ | | 165| 1.67k|#define LINK_SIZE 2 ------------------ code[1+LINK_SIZE] = (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR == pptr[3])? ------------------ | | 44| 1.67k|#define PCRE2_MAJOR 10 ------------------ code[1+LINK_SIZE] = (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR == pptr[3])? ------------------ | | 45| 198|#define PCRE2_MINOR 43 ------------------ | Branch (6606:28): [True: 198, False: 1.48k] | Branch (6606:54): [True: 0, False: 198] ------------------ 6607| 1.67k| OP_TRUE : OP_FALSE; 6608| 2.41k| skipunits = 1; 6609| 2.41k| pptr += 3; 6610| 2.41k| goto GROUP_PROCESS_NOTE_EMPTY; 6611| | 6612| | /* The condition is an assertion, possibly preceded by a callout. */ 6613| | 6614| 2.72k| case META_COND_ASSERT: ------------------ | | 227| 2.72k|#define META_COND_ASSERT 0x800f0000u /* (?(?assertion)... */ ------------------ | Branch (6614:5): [True: 2.72k, False: 3.67M] ------------------ 6615| 2.72k| bravalue = OP_COND; 6616| 2.72k| goto GROUP_PROCESS_NOTE_EMPTY; 6617| | 6618| | 6619| | /* ===================================================================*/ 6620| | /* Handle all kinds of nested bracketed groups. The non-capturing, 6621| | non-conditional cases are here; others come to GROUP_PROCESS via goto. */ 6622| | 6623| 7.11k| case META_LOOKAHEAD: ------------------ | | 251| 7.11k|#define META_LOOKAHEAD 0x80230000u /* (?= */ ------------------ | Branch (6623:5): [True: 7.11k, False: 3.66M] ------------------ 6624| 7.11k| bravalue = OP_ASSERT; 6625| 7.11k| cb->assert_depth += 1; 6626| 7.11k| goto GROUP_PROCESS; 6627| | 6628| 2.42k| case META_LOOKAHEAD_NA: ------------------ | | 258| 2.42k|#define META_LOOKAHEAD_NA 0x80270000u /* (*napla: */ ------------------ | Branch (6628:5): [True: 2.42k, False: 3.67M] ------------------ 6629| 2.42k| bravalue = OP_ASSERT_NA; 6630| 2.42k| cb->assert_depth += 1; 6631| 2.42k| goto GROUP_PROCESS; 6632| | 6633| | /* Optimize (?!) to (*FAIL) unless it is quantified - which is a weird 6634| | thing to do, but Perl allows all assertions to be quantified, and when 6635| | they contain capturing parentheses there may be a potential use for 6636| | this feature. Not that that applies to a quantified (?!) but we allow 6637| | it for uniformity. */ 6638| | 6639| 3.54k| case META_LOOKAHEADNOT: ------------------ | | 252| 3.54k|#define META_LOOKAHEADNOT 0x80240000u /* (?! */ ------------------ | Branch (6639:5): [True: 3.54k, False: 3.67M] ------------------ 6640| 3.54k| if (pptr[1] == META_KET && ------------------ | | 237| 7.09k|#define META_KET 0x80190000u /* closing parenthesis */ ------------------ | Branch (6640:9): [True: 1.14k, False: 2.39k] ------------------ 6641| 3.54k| (pptr[2] < META_ASTERISK || pptr[2] > META_MINMAX_QUERY)) ------------------ | | 279| 2.29k|#define META_ASTERISK 0x80340000u /* * */ ------------------ (pptr[2] < META_ASTERISK || pptr[2] > META_MINMAX_QUERY)) ------------------ | | 290| 376|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (6641:11): [True: 773, False: 376] | Branch (6641:38): [True: 0, False: 376] ------------------ 6642| 773| { 6643| 773| *code++ = OP_FAIL; 6644| 773| pptr++; 6645| 773| } 6646| 2.77k| else 6647| 2.77k| { 6648| 2.77k| bravalue = OP_ASSERT_NOT; 6649| 2.77k| cb->assert_depth += 1; 6650| 2.77k| goto GROUP_PROCESS; 6651| 2.77k| } 6652| 773| break; 6653| | 6654| 2.81k| case META_LOOKBEHIND: ------------------ | | 253| 2.81k|#define META_LOOKBEHIND 0x80250000u /* (?<= */ ------------------ | Branch (6654:5): [True: 2.81k, False: 3.67M] ------------------ 6655| 2.81k| bravalue = OP_ASSERTBACK; 6656| 2.81k| cb->assert_depth += 1; 6657| 2.81k| goto GROUP_PROCESS; 6658| | 6659| 4.09k| case META_LOOKBEHINDNOT: ------------------ | | 254| 4.09k|#define META_LOOKBEHINDNOT 0x80260000u /* (?assert_depth += 1; 6662| 4.09k| goto GROUP_PROCESS; 6663| | 6664| 1.44k| case META_LOOKBEHIND_NA: ------------------ | | 259| 1.44k|#define META_LOOKBEHIND_NA 0x80280000u /* (*naplb: */ ------------------ | Branch (6664:5): [True: 1.44k, False: 3.67M] ------------------ 6665| 1.44k| bravalue = OP_ASSERTBACK_NA; 6666| 1.44k| cb->assert_depth += 1; 6667| 1.44k| goto GROUP_PROCESS; 6668| | 6669| 2.32k| case META_ATOMIC: ------------------ | | 214| 2.32k|#define META_ATOMIC 0x80020000u /* atomic group */ ------------------ | Branch (6669:5): [True: 2.32k, False: 3.67M] ------------------ 6670| 2.32k| bravalue = OP_ONCE; 6671| 2.32k| goto GROUP_PROCESS_NOTE_EMPTY; 6672| | 6673| 2.08k| case META_SCRIPT_RUN: ------------------ | | 246| 2.08k|#define META_SCRIPT_RUN 0x80220000u /* (*script_run:...) */ ------------------ | Branch (6673:5): [True: 2.08k, False: 3.67M] ------------------ 6674| 2.08k| bravalue = OP_SCRIPT_RUN; 6675| 2.08k| goto GROUP_PROCESS_NOTE_EMPTY; 6676| | 6677| 28.7k| case META_NOCAPTURE: ------------------ | | 238| 28.7k|#define META_NOCAPTURE 0x801a0000u /* no capture parens */ ------------------ | Branch (6677:5): [True: 28.7k, False: 3.64M] ------------------ 6678| 28.7k| bravalue = OP_BRA; 6679| | /* Fall through */ 6680| | 6681| | /* Process nested bracketed regex. The nesting depth is maintained for the 6682| | benefit of the stackguard function. The test for too deep nesting is now 6683| | done in parse_regex(). Assertion and DEFINE groups come to GROUP_PROCESS; 6684| | others come to GROUP_PROCESS_NOTE_EMPTY, to indicate that we need to take 6685| | note of whether or not they may match an empty string. */ 6686| | 6687| 724k| GROUP_PROCESS_NOTE_EMPTY: 6688| 724k| note_group_empty = TRUE; ------------------ | | 70| 724k|#define TRUE 1 ------------------ 6689| | 6690| 744k| GROUP_PROCESS: 6691| 744k| cb->parens_depth += 1; 6692| 744k| *code = bravalue; 6693| 744k| pptr++; 6694| 744k| tempcode = code; 6695| 744k| tempreqvary = cb->req_varyopt; /* Save value before group */ 6696| 744k| length_prevgroup = 0; /* Initialize for pre-compile phase */ 6697| | 6698| 744k| if ((group_return = ------------------ | Branch (6698:9): [True: 1.10k, False: 743k] ------------------ 6699| 744k| compile_regex( 6700| 744k| options, /* The options state */ 6701| 744k| xoptions, /* The extra options state */ 6702| 744k| &tempcode, /* Where to put code (updated) */ 6703| 744k| &pptr, /* Input pointer (updated) */ 6704| 744k| errorcodeptr, /* Where to put an error message */ 6705| 744k| skipunits, /* Skip over bracket number */ 6706| 744k| &subfirstcu, /* For possible first char */ 6707| 744k| &subfirstcuflags, 6708| 744k| &subreqcu, /* For possible last char */ 6709| 744k| &subreqcuflags, 6710| 744k| bcptr, /* Current branch chain */ 6711| 744k| open_caps, /* Pointer to capture stack */ 6712| 744k| cb, /* Compile data block */ 6713| 744k| (lengthptr == NULL)? NULL : /* Actual compile phase */ ------------------ | Branch (6713:10): [True: 268k, False: 476k] ------------------ 6714| 744k| &length_prevgroup /* Pre-compile phase */ 6715| 744k| )) == 0) 6716| 1.10k| return 0; /* Error */ 6717| | 6718| 743k| cb->parens_depth -= 1; 6719| | 6720| | /* If that was a non-conditional significant group (not an assertion, not a 6721| | DEFINE) that matches at least one character, then the current item matches 6722| | a character. Conditionals are handled below. */ 6723| | 6724| 743k| if (note_group_empty && bravalue != OP_COND && group_return > 0) ------------------ | Branch (6724:9): [True: 723k, False: 20.5k] | Branch (6724:29): [True: 712k, False: 10.5k] | Branch (6724:52): [True: 72.0k, False: 640k] ------------------ 6725| 72.0k| matched_char = TRUE; ------------------ | | 70| 72.0k|#define TRUE 1 ------------------ 6726| | 6727| | /* If we've just compiled an assertion, pop the assert depth. */ 6728| | 6729| 743k| if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NA) ------------------ | Branch (6729:9): [True: 743k, False: 0] | Branch (6729:34): [True: 20.5k, False: 723k] ------------------ 6730| 20.5k| cb->assert_depth -= 1; 6731| | 6732| | /* At the end of compiling, code is still pointing to the start of the 6733| | group, while tempcode has been updated to point past the end of the group. 6734| | The parsed pattern pointer (pptr) is on the closing META_KET. 6735| | 6736| | If this is a conditional bracket, check that there are no more than 6737| | two branches in the group, or just one if it's a DEFINE group. We do this 6738| | in the real compile phase, not in the pre-pass, where the whole group may 6739| | not be available. */ 6740| | 6741| 743k| if (bravalue == OP_COND && lengthptr == NULL) ------------------ | Branch (6741:9): [True: 10.5k, False: 733k] | Branch (6741:32): [True: 5.20k, False: 5.33k] ------------------ 6742| 5.20k| { 6743| 5.20k| PCRE2_UCHAR *tc = code; ------------------ | | 813| 5.20k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 5.20k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 5.20k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 5.20k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6744| 5.20k| int condcount = 0; 6745| | 6746| 7.08k| do { 6747| 7.08k| condcount++; 6748| 7.08k| tc += GET(tc,1); ------------------ | | 109| 7.08k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 6749| 7.08k| } 6750| 7.08k| while (*tc != OP_KET); ------------------ | Branch (6750:14): [True: 1.88k, False: 5.20k] ------------------ 6751| | 6752| | /* A DEFINE group is never obeyed inline (the "condition" is always 6753| | false). It must have only one branch. Having checked this, change the 6754| | opcode to OP_FALSE. */ 6755| | 6756| 5.20k| if (code[LINK_SIZE+1] == OP_DEFINE) ------------------ | | 165| 5.20k|#define LINK_SIZE 2 ------------------ | Branch (6756:11): [True: 0, False: 5.20k] ------------------ 6757| 0| { 6758| 0| if (condcount > 1) ------------------ | Branch (6758:13): [True: 0, False: 0] ------------------ 6759| 0| { 6760| 0| cb->erroroffset = offset; 6761| 0| *errorcodeptr = ERR54; 6762| 0| return 0; 6763| 0| } 6764| 0| code[LINK_SIZE+1] = OP_FALSE; ------------------ | | 165| 0|#define LINK_SIZE 2 ------------------ 6765| 0| bravalue = OP_DEFINE; /* A flag to suppress char handling below */ 6766| 0| } 6767| | 6768| | /* A "normal" conditional group. If there is just one branch, we must not 6769| | make use of its firstcu or reqcu, because this is equivalent to an 6770| | empty second branch. Also, it may match an empty string. If there are two 6771| | branches, this item must match a character if the group must. */ 6772| | 6773| 5.20k| else 6774| 5.20k| { 6775| 5.20k| if (condcount > 2) ------------------ | Branch (6775:13): [True: 19, False: 5.18k] ------------------ 6776| 19| { 6777| 19| cb->erroroffset = offset; 6778| 19| *errorcodeptr = ERR27; 6779| 19| return 0; 6780| 19| } 6781| 5.18k| if (condcount == 1) subfirstcuflags = subreqcuflags = REQ_NONE; ------------------ | | 394| 3.73k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6781:13): [True: 3.73k, False: 1.44k] ------------------ 6782| 1.44k| else if (group_return > 0) matched_char = TRUE; ------------------ | | 70| 342|#define TRUE 1 ------------------ | Branch (6782:20): [True: 342, False: 1.10k] ------------------ 6783| 5.18k| } 6784| 5.20k| } 6785| | 6786| | /* In the pre-compile phase, update the length by the length of the group, 6787| | less the brackets at either end. Then reduce the compiled code to just a 6788| | set of non-capturing brackets so that it doesn't use much memory if it is 6789| | duplicated by a quantifier.*/ 6790| | 6791| 743k| if (lengthptr != NULL) ------------------ | Branch (6791:9): [True: 475k, False: 268k] ------------------ 6792| 475k| { 6793| 475k| if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE) ------------------ | | 200| 475k|#define OFLOW_MAX (INT_MAX - 20) ------------------ if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE) ------------------ | | 165| 475k|#define LINK_SIZE 2 ------------------ | Branch (6793:11): [True: 0, False: 475k] ------------------ 6794| 0| { 6795| 0| *errorcodeptr = ERR20; 6796| 0| return 0; 6797| 0| } 6798| 475k| *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE; ------------------ | | 165| 475k|#define LINK_SIZE 2 ------------------ 6799| 475k| code++; /* This already contains bravalue */ 6800| 475k| PUTINC(code, 0, 1 + LINK_SIZE); ------------------ | | 547| 475k|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 475k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 475k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 475k|#define LINK_SIZE 2 | | ------------------ ------------------ 6801| 475k| *code++ = OP_KET; 6802| 475k| PUTINC(code, 0, 1 + LINK_SIZE); ------------------ | | 547| 475k|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 475k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 475k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 475k|#define LINK_SIZE 2 | | ------------------ ------------------ 6803| 475k| break; /* No need to waste time with special character handling */ 6804| 475k| } 6805| | 6806| | /* Otherwise update the main code pointer to the end of the group. */ 6807| | 6808| 268k| code = tempcode; 6809| | 6810| | /* For a DEFINE group, required and first character settings are not 6811| | relevant. */ 6812| | 6813| 268k| if (bravalue == OP_DEFINE) break; ------------------ | Branch (6813:9): [True: 0, False: 268k] ------------------ 6814| | 6815| | /* Handle updating of the required and first code units for other types of 6816| | group. Update for normal brackets of all kinds, and conditions with two 6817| | branches (see code above). If the bracket is followed by a quantifier with 6818| | zero repeat, we have to back off. Hence the definition of zeroreqcu and 6819| | zerofirstcu outside the main loop so that they can be accessed for the back 6820| | off. */ 6821| | 6822| 268k| zeroreqcu = reqcu; 6823| 268k| zeroreqcuflags = reqcuflags; 6824| 268k| zerofirstcu = firstcu; 6825| 268k| zerofirstcuflags = firstcuflags; 6826| 268k| groupsetfirstcu = FALSE; ------------------ | | 69| 268k|#define FALSE 0 ------------------ 6827| | 6828| 268k| if (bravalue >= OP_ONCE) /* Not an assertion */ ------------------ | Branch (6828:9): [True: 257k, False: 10.2k] ------------------ 6829| 257k| { 6830| | /* If we have not yet set a firstcu in this branch, take it from the 6831| | subpattern, remembering that it was set here so that a repeat of more 6832| | than one can replicate it as reqcu if necessary. If the subpattern has 6833| | no firstcu, set "none" for the whole branch. In both cases, a zero 6834| | repeat forces firstcu to "none". */ 6835| | 6836| 257k| if (firstcuflags == REQ_UNSET && subfirstcuflags != REQ_UNSET) ------------------ | | 393| 515k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET && subfirstcuflags != REQ_UNSET) ------------------ | | 393| 71.9k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ | Branch (6836:11): [True: 71.9k, False: 185k] | Branch (6836:40): [True: 30.2k, False: 41.7k] ------------------ 6837| 30.2k| { 6838| 30.2k| if (subfirstcuflags < REQ_NONE) ------------------ | | 394| 30.2k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6838:13): [True: 9.27k, False: 20.9k] ------------------ 6839| 9.27k| { 6840| 9.27k| firstcu = subfirstcu; 6841| 9.27k| firstcuflags = subfirstcuflags; 6842| 9.27k| groupsetfirstcu = TRUE; ------------------ | | 70| 9.27k|#define TRUE 1 ------------------ 6843| 9.27k| } 6844| 20.9k| else firstcuflags = REQ_NONE; ------------------ | | 394| 20.9k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 6845| 30.2k| zerofirstcuflags = REQ_NONE; ------------------ | | 394| 30.2k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 6846| 30.2k| } 6847| | 6848| | /* If firstcu was previously set, convert the subpattern's firstcu 6849| | into reqcu if there wasn't one, using the vary flag that was in 6850| | existence beforehand. */ 6851| | 6852| 227k| else if (subfirstcuflags < REQ_NONE && subreqcuflags >= REQ_NONE) ------------------ | | 394| 455k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ else if (subfirstcuflags < REQ_NONE && subreqcuflags >= REQ_NONE) ------------------ | | 394| 8.09k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6852:16): [True: 8.09k, False: 219k] | Branch (6852:46): [True: 2.13k, False: 5.95k] ------------------ 6853| 2.13k| { 6854| 2.13k| subreqcu = subfirstcu; 6855| 2.13k| subreqcuflags = subfirstcuflags | tempreqvary; 6856| 2.13k| } 6857| | 6858| | /* If the subpattern set a required code unit (or set a first code unit 6859| | that isn't really the first code unit - see above), set it. */ 6860| | 6861| 257k| if (subreqcuflags < REQ_NONE) ------------------ | | 394| 257k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6861:11): [True: 25.0k, False: 232k] ------------------ 6862| 25.0k| { 6863| 25.0k| reqcu = subreqcu; 6864| 25.0k| reqcuflags = subreqcuflags; 6865| 25.0k| } 6866| 257k| } 6867| | 6868| | /* For a forward assertion, we take the reqcu, if set, provided that the 6869| | group has also set a firstcu. This can be helpful if the pattern that 6870| | follows the assertion doesn't set a different char. For example, it's 6871| | useful for /(?=abcde).+/. We can't set firstcu for an assertion, however 6872| | because it leads to incorrect effect for patterns such as /(?=a)a.+/ when 6873| | the "real" "a" would then become a reqcu instead of a firstcu. This is 6874| | overcome by a scan at the end if there's no firstcu, looking for an 6875| | asserted first char. A similar effect for patterns like /(?=.*X)X$/ means 6876| | we must only take the reqcu when the group also set a firstcu. Otherwise, 6877| | in that example, 'X' ends up set for both. */ 6878| | 6879| 10.2k| else if ((bravalue == OP_ASSERT || bravalue == OP_ASSERT_NA) && ------------------ | Branch (6879:15): [True: 3.54k, False: 6.68k] | Branch (6879:40): [True: 1.20k, False: 5.48k] ------------------ 6880| 10.2k| subreqcuflags < REQ_NONE && subfirstcuflags < REQ_NONE) ------------------ | | 394| 14.9k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ subreqcuflags < REQ_NONE && subfirstcuflags < REQ_NONE) ------------------ | | 394| 985|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6880:14): [True: 985, False: 3.75k] | Branch (6880:42): [True: 595, False: 390] ------------------ 6881| 595| { 6882| 595| reqcu = subreqcu; 6883| 595| reqcuflags = subreqcuflags; 6884| 595| } 6885| | 6886| 268k| break; /* End of nested group handling */ 6887| | 6888| | 6889| | /* ===================================================================*/ 6890| | /* Handle named backreferences and recursions. */ 6891| | 6892| 3.72k| case META_BACKREF_BYNAME: ------------------ | | 216| 3.72k|#define META_BACKREF_BYNAME 0x80040000u /* \k'name' */ ------------------ | Branch (6892:5): [True: 3.72k, False: 3.67M] ------------------ 6893| 4.07k| case META_RECURSE_BYNAME: ------------------ | | 245| 4.07k|#define META_RECURSE_BYNAME 0x80210000u /* (?&name) */ ------------------ | Branch (6893:5): [True: 344, False: 3.67M] ------------------ 6894| 4.07k| { 6895| 4.07k| int count, index; 6896| 4.07k| PCRE2_SPTR name; ------------------ | | 814| 4.07k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 4.07k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 4.07k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 4.07k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6897| 4.07k| BOOL is_dupname = FALSE; ------------------ | | 69| 4.07k|#define FALSE 0 ------------------ 6898| 4.07k| named_group *ng = cb->named_groups; ------------------ | | 1983| 4.07k|#define named_group PCRE2_SUFFIX(named_group_) | | ------------------ | | | | 986| 4.07k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 4.07k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 4.07k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6899| 4.07k| uint32_t length = *(++pptr); 6900| | 6901| 4.07k| GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 4.07k| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 6902| 4.07k| name = cb->start_pattern + offset; 6903| | 6904| | /* In the first pass, the names generated in the pre-pass are available, 6905| | but the main name table has not yet been created. Scan the list of names 6906| | generated in the pre-pass in order to get a number and whether or not 6907| | this name is duplicated. */ 6908| | 6909| 4.07k| groupnumber = 0; 6910| 428k| for (unsigned int i = 0; i < cb->names_found; i++, ng++) ------------------ | Branch (6910:32): [True: 424k, False: 3.78k] ------------------ 6911| 424k| { 6912| 424k| if (length == ng->length && ------------------ | Branch (6912:13): [True: 423k, False: 924] ------------------ 6913| 424k| PRIV(strncmp)(name, ng->name, length) == 0) ------------------ | | 177| 423k|#define PRIV(name) _pcre2_##name ------------------ | Branch (6913:13): [True: 422k, False: 1.44k] ------------------ 6914| 422k| { 6915| 422k| is_dupname = ng->isdup; 6916| 422k| groupnumber = ng->number; 6917| | 6918| | /* For a recursion, that's all that is needed. We can now go to 6919| | the code that handles numerical recursion, applying it to the first 6920| | group with the given name. */ 6921| | 6922| 422k| if (meta == META_RECURSE_BYNAME) ------------------ | | 245| 422k|#define META_RECURSE_BYNAME 0x80210000u /* (?&name) */ ------------------ | Branch (6922:15): [True: 292, False: 421k] ------------------ 6923| 292| { 6924| 292| meta_arg = groupnumber; 6925| 292| goto HANDLE_NUMERICAL_RECURSION; 6926| 292| } 6927| | 6928| | /* For a back reference, update the back reference map and the 6929| | maximum back reference. */ 6930| | 6931| 421k| cb->backref_map |= (groupnumber < 32)? (1u << groupnumber) : 1; ------------------ | Branch (6931:30): [True: 18.1k, False: 403k] ------------------ 6932| 421k| if (groupnumber > cb->top_backref) ------------------ | Branch (6932:15): [True: 4.83k, False: 417k] ------------------ 6933| 4.83k| cb->top_backref = groupnumber; 6934| 421k| } 6935| 424k| } 6936| | 6937| | /* If the name was not found we have a bad reference. */ 6938| | 6939| 3.78k| if (groupnumber == 0) ------------------ | Branch (6939:11): [True: 101, False: 3.67k] ------------------ 6940| 101| { 6941| 101| *errorcodeptr = ERR15; 6942| 101| cb->erroroffset = offset; 6943| 101| return 0; 6944| 101| } 6945| | 6946| | /* If a back reference name is not duplicated, we can handle it as 6947| | a numerical reference. */ 6948| | 6949| 3.67k| if (!is_dupname) ------------------ | Branch (6949:11): [True: 586, False: 3.09k] ------------------ 6950| 586| { 6951| 586| meta_arg = groupnumber; 6952| 586| goto HANDLE_SINGLE_REFERENCE; 6953| 586| } 6954| | 6955| | /* If a back reference name is duplicated, we generate a different 6956| | opcode to a numerical back reference. In the second pass we must 6957| | search for the index and count in the final name table. */ 6958| | 6959| 3.09k| count = 0; /* Values for first pass (avoids compiler warning) */ 6960| 3.09k| index = 0; 6961| 3.09k| if (lengthptr == NULL && !find_dupname_details(name, length, &index, ------------------ | Branch (6961:11): [True: 1.53k, False: 1.55k] | Branch (6961:32): [True: 0, False: 1.53k] ------------------ 6962| 1.53k| &count, errorcodeptr, cb)) return 0; 6963| | 6964| 3.09k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 3.09k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 1.11k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (6964:11): [True: 1.11k, False: 1.98k] ------------------ 6965| 3.09k| *code++ = ((options & PCRE2_CASELESS) != 0)? OP_DNREFI : OP_DNREF; ------------------ | | 122| 3.09k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (6965:17): [True: 740, False: 2.35k] ------------------ 6966| 3.09k| PUT2INC(code, 0, index); ------------------ | | 548| 3.09k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 3.09k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 3.09k|#define IMM2_SIZE 2 | | ------------------ ------------------ 6967| 3.09k| PUT2INC(code, 0, count); ------------------ | | 548| 3.09k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 3.09k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 3.09k|#define IMM2_SIZE 2 | | ------------------ ------------------ 6968| 3.09k| } 6969| 0| break; 6970| | 6971| | 6972| | /* ===================================================================*/ 6973| | /* Handle a numerical callout. */ 6974| | 6975| 280k| case META_CALLOUT_NUMBER: ------------------ | | 218| 280k|#define META_CALLOUT_NUMBER 0x80060000u /* (?C with numerical argument */ ------------------ | Branch (6975:5): [True: 280k, False: 3.39M] ------------------ 6976| 280k| code[0] = OP_CALLOUT; 6977| 280k| PUT(code, 1, pptr[1]); /* Offset to next pattern item */ ------------------ | | 106| 280k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 280k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 6978| 280k| PUT(code, 1 + LINK_SIZE, pptr[2]); /* Length of next pattern item */ ------------------ | | 106| 280k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 280k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 6979| 280k| code[1 + 2*LINK_SIZE] = pptr[3]; ------------------ | | 165| 280k|#define LINK_SIZE 2 ------------------ 6980| 280k| pptr += 3; 6981| 280k| code += PRIV(OP_lengths)[OP_CALLOUT]; ------------------ | | 177| 280k|#define PRIV(name) _pcre2_##name ------------------ 6982| 280k| break; 6983| | 6984| | 6985| | /* ===================================================================*/ 6986| | /* Handle a callout with a string argument. In the pre-pass we just compute 6987| | the length without generating anything. The length in pptr[3] includes both 6988| | delimiters; in the actual compile only the first one is copied, but a 6989| | terminating zero is added. Any doubled delimiters within the string make 6990| | this an overestimate, but it is not worth bothering about. */ 6991| | 6992| 3.89k| case META_CALLOUT_STRING: ------------------ | | 219| 3.89k|#define META_CALLOUT_STRING 0x80070000u /* (?C with string argument */ ------------------ | Branch (6992:5): [True: 3.89k, False: 3.67M] ------------------ 6993| 3.89k| if (lengthptr != NULL) ------------------ | Branch (6993:9): [True: 1.94k, False: 1.94k] ------------------ 6994| 1.94k| { 6995| 1.94k| *lengthptr += pptr[3] + (1 + 4*LINK_SIZE); ------------------ | | 165| 1.94k|#define LINK_SIZE 2 ------------------ 6996| 1.94k| pptr += 3; 6997| 1.94k| SKIPOFFSET(pptr); ------------------ | | 107| 1.94k|#define SKIPOFFSET(p) p += 2 ------------------ 6998| 1.94k| } 6999| | 7000| | /* In the real compile we can copy the string. The starting delimiter is 7001| | included so that the client can discover it if they want. We also pass the 7002| | start offset to help a script language give better error messages. */ 7003| | 7004| 1.94k| else 7005| 1.94k| { 7006| 1.94k| PCRE2_SPTR pp; ------------------ | | 814| 1.94k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.94k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.94k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.94k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7007| 1.94k| uint32_t delimiter; 7008| 1.94k| uint32_t length = pptr[3]; 7009| 1.94k| PCRE2_UCHAR *callout_string = code + (1 + 4*LINK_SIZE); ------------------ | | 813| 1.94k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 1.94k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.94k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.94k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_UCHAR *callout_string = code + (1 + 4*LINK_SIZE); ------------------ | | 165| 1.94k|#define LINK_SIZE 2 ------------------ 7010| | 7011| 1.94k| code[0] = OP_CALLOUT_STR; 7012| 1.94k| PUT(code, 1, pptr[1]); /* Offset to next pattern item */ ------------------ | | 106| 1.94k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 1.94k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7013| 1.94k| PUT(code, 1 + LINK_SIZE, pptr[2]); /* Length of next pattern item */ ------------------ | | 106| 1.94k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 1.94k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7014| | 7015| 1.94k| pptr += 3; 7016| 1.94k| GETPLUSOFFSET(offset, pptr); /* Offset to string in pattern */ ------------------ | | 104| 1.94k| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 7017| 1.94k| pp = cb->start_pattern + offset; 7018| 1.94k| delimiter = *callout_string++ = *pp++; 7019| 1.94k| if (delimiter == CHAR_LEFT_CURLY_BRACKET) ------------------ | | 1073| 1.94k|#define CHAR_LEFT_CURLY_BRACKET '\173' ------------------ | Branch (7019:11): [True: 695, False: 1.25k] ------------------ 7020| 695| delimiter = CHAR_RIGHT_CURLY_BRACKET; ------------------ | | 1075| 695|#define CHAR_RIGHT_CURLY_BRACKET '\175' ------------------ 7021| 1.94k| PUT(code, 1 + 3*LINK_SIZE, (int)(offset + 1)); /* One after delimiter */ ------------------ | | 106| 1.94k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 1.94k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7022| | 7023| | /* The syntax of the pattern was checked in the parsing scan. The length 7024| | includes both delimiters, but we have passed the opening one just above, 7025| | so we reduce length before testing it. The test is for > 1 because we do 7026| | not want to copy the final delimiter. This also ensures that pp[1] is 7027| | accessible. */ 7028| | 7029| 70.4k| while (--length > 1) ------------------ | Branch (7029:14): [True: 68.4k, False: 1.94k] ------------------ 7030| 68.4k| { 7031| 68.4k| if (*pp == delimiter && pp[1] == delimiter) ------------------ | Branch (7031:13): [True: 284, False: 68.1k] | Branch (7031:33): [True: 284, False: 0] ------------------ 7032| 284| { 7033| 284| *callout_string++ = delimiter; 7034| 284| pp += 2; 7035| 284| length--; 7036| 284| } 7037| 68.1k| else *callout_string++ = *pp++; 7038| 68.4k| } 7039| 1.94k| *callout_string++ = CHAR_NUL; ------------------ | | 981| 1.94k|#define CHAR_NUL '\0' ------------------ 7040| | 7041| | /* Set the length of the entire item, the advance to its end. */ 7042| | 7043| 1.94k| PUT(code, 1 + 2*LINK_SIZE, (int)(callout_string - code)); ------------------ | | 106| 1.94k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 1.94k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7044| 1.94k| code = callout_string; 7045| 1.94k| } 7046| 3.89k| break; 7047| | 7048| | 7049| | /* ===================================================================*/ 7050| | /* Handle repetition. The different types are all sorted out in the parsing 7051| | pass. */ 7052| | 7053| 6.38k| case META_MINMAX_PLUS: ------------------ | | 289| 6.38k|#define META_MINMAX_PLUS 0x803e0000u /* {n,m}+ repeat */ ------------------ | Branch (7053:5): [True: 6.38k, False: 3.67M] ------------------ 7054| 7.26k| case META_MINMAX_QUERY: ------------------ | | 290| 7.26k|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (7054:5): [True: 881, False: 3.67M] ------------------ 7055| 69.5k| case META_MINMAX: ------------------ | | 288| 69.5k|#define META_MINMAX 0x803d0000u /* {n,m} repeat */ ------------------ | Branch (7055:5): [True: 62.3k, False: 3.61M] ------------------ 7056| 69.5k| repeat_min = *(++pptr); 7057| 69.5k| repeat_max = *(++pptr); 7058| 69.5k| goto REPEAT; 7059| | 7060| 51.1k| case META_ASTERISK: ------------------ | | 279| 51.1k|#define META_ASTERISK 0x80340000u /* * */ ------------------ | Branch (7060:5): [True: 51.1k, False: 3.62M] ------------------ 7061| 53.7k| case META_ASTERISK_PLUS: ------------------ | | 280| 53.7k|#define META_ASTERISK_PLUS 0x80350000u /* *+ */ ------------------ | Branch (7061:5): [True: 2.64k, False: 3.67M] ------------------ 7062| 55.9k| case META_ASTERISK_QUERY: ------------------ | | 281| 55.9k|#define META_ASTERISK_QUERY 0x80360000u /* *? */ ------------------ | Branch (7062:5): [True: 2.22k, False: 3.67M] ------------------ 7063| 55.9k| repeat_min = 0; 7064| 55.9k| repeat_max = REPEAT_UNLIMITED; ------------------ | | 149| 55.9k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 55.9k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ 7065| 55.9k| goto REPEAT; 7066| | 7067| 61.2k| case META_PLUS: ------------------ | | 282| 61.2k|#define META_PLUS 0x80370000u /* + */ ------------------ | Branch (7067:5): [True: 61.2k, False: 3.61M] ------------------ 7068| 67.7k| case META_PLUS_PLUS: ------------------ | | 283| 67.7k|#define META_PLUS_PLUS 0x80380000u /* ++ */ ------------------ | Branch (7068:5): [True: 6.51k, False: 3.67M] ------------------ 7069| 69.8k| case META_PLUS_QUERY: ------------------ | | 284| 69.8k|#define META_PLUS_QUERY 0x80390000u /* +? */ ------------------ | Branch (7069:5): [True: 2.03k, False: 3.67M] ------------------ 7070| 69.8k| repeat_min = 1; 7071| 69.8k| repeat_max = REPEAT_UNLIMITED; ------------------ | | 149| 69.8k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 69.8k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ 7072| 69.8k| goto REPEAT; 7073| | 7074| 68.3k| case META_QUERY: ------------------ | | 285| 68.3k|#define META_QUERY 0x803a0000u /* ? */ ------------------ | Branch (7074:5): [True: 68.3k, False: 3.60M] ------------------ 7075| 70.4k| case META_QUERY_PLUS: ------------------ | | 286| 70.4k|#define META_QUERY_PLUS 0x803b0000u /* ?+ */ ------------------ | Branch (7075:5): [True: 2.05k, False: 3.67M] ------------------ 7076| 73.3k| case META_QUERY_QUERY: ------------------ | | 287| 73.3k|#define META_QUERY_QUERY 0x803c0000u /* ?? */ ------------------ | Branch (7076:5): [True: 2.89k, False: 3.67M] ------------------ 7077| 73.3k| repeat_min = 0; 7078| 73.3k| repeat_max = 1; 7079| | 7080| 268k| REPEAT: 7081| 268k| if (previous_matched_char && repeat_min > 0) matched_char = TRUE; ------------------ | | 70| 91.3k|#define TRUE 1 ------------------ | Branch (7081:9): [True: 234k, False: 33.8k] | Branch (7081:34): [True: 91.3k, False: 143k] ------------------ 7082| | 7083| | /* Remember whether this is a variable length repeat, and default to 7084| | single-char opcodes. */ 7085| | 7086| 268k| reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY; ------------------ | | 396| 498k|#define REQ_VARY 0x00000002u /* Code unit is followed by non-literal */ ------------------ | Branch (7086:15): [True: 38.9k, False: 229k] ------------------ 7087| 268k| op_type = 0; 7088| | 7089| | /* Adjust first and required code units for a zero repeat. */ 7090| | 7091| 268k| if (repeat_min == 0) ------------------ | Branch (7091:9): [True: 153k, False: 115k] ------------------ 7092| 153k| { 7093| 153k| firstcu = zerofirstcu; 7094| 153k| firstcuflags = zerofirstcuflags; 7095| 153k| reqcu = zeroreqcu; 7096| 153k| reqcuflags = zeroreqcuflags; 7097| 153k| } 7098| | 7099| | /* Note the greediness and possessiveness. */ 7100| | 7101| 268k| switch (meta) 7102| 268k| { 7103| 6.38k| case META_MINMAX_PLUS: ------------------ | | 289| 6.38k|#define META_MINMAX_PLUS 0x803e0000u /* {n,m}+ repeat */ ------------------ | Branch (7103:7): [True: 6.38k, False: 262k] ------------------ 7104| 9.02k| case META_ASTERISK_PLUS: ------------------ | | 280| 9.02k|#define META_ASTERISK_PLUS 0x80350000u /* *+ */ ------------------ | Branch (7104:7): [True: 2.64k, False: 266k] ------------------ 7105| 15.5k| case META_PLUS_PLUS: ------------------ | | 283| 15.5k|#define META_PLUS_PLUS 0x80380000u /* ++ */ ------------------ | Branch (7105:7): [True: 6.51k, False: 262k] ------------------ 7106| 17.6k| case META_QUERY_PLUS: ------------------ | | 286| 17.6k|#define META_QUERY_PLUS 0x803b0000u /* ?+ */ ------------------ | Branch (7106:7): [True: 2.05k, False: 266k] ------------------ 7107| 17.6k| repeat_type = 0; /* Force greedy */ 7108| 17.6k| possessive_quantifier = TRUE; ------------------ | | 70| 17.6k|#define TRUE 1 ------------------ 7109| 17.6k| break; 7110| | 7111| 881| case META_MINMAX_QUERY: ------------------ | | 290| 881|#define META_MINMAX_QUERY 0x803f0000u /* {n,m}? repeat */ ------------------ | Branch (7111:7): [True: 881, False: 267k] ------------------ 7112| 3.10k| case META_ASTERISK_QUERY: ------------------ | | 281| 3.10k|#define META_ASTERISK_QUERY 0x80360000u /* *? */ ------------------ | Branch (7112:7): [True: 2.22k, False: 266k] ------------------ 7113| 5.14k| case META_PLUS_QUERY: ------------------ | | 284| 5.14k|#define META_PLUS_QUERY 0x80390000u /* +? */ ------------------ | Branch (7113:7): [True: 2.03k, False: 266k] ------------------ 7114| 8.03k| case META_QUERY_QUERY: ------------------ | | 287| 8.03k|#define META_QUERY_QUERY 0x803c0000u /* ?? */ ------------------ | Branch (7114:7): [True: 2.89k, False: 265k] ------------------ 7115| 8.03k| repeat_type = greedy_non_default; 7116| 8.03k| possessive_quantifier = FALSE; ------------------ | | 69| 8.03k|#define FALSE 0 ------------------ 7117| 8.03k| break; 7118| | 7119| 243k| default: ------------------ | Branch (7119:7): [True: 243k, False: 25.6k] ------------------ 7120| 243k| repeat_type = greedy_default; 7121| 243k| possessive_quantifier = FALSE; ------------------ | | 69| 243k|#define FALSE 0 ------------------ 7122| 243k| break; 7123| 268k| } 7124| | 7125| | /* Save start of previous item, in case we have to move it up in order to 7126| | insert something before it, and remember what it was. */ 7127| | 7128| 268k| tempcode = previous; 7129| 268k| op_previous = *previous; 7130| | 7131| | /* Now handle repetition for the different types of item. If the repeat 7132| | minimum and the repeat maximum are both 1, we can ignore the quantifier for 7133| | non-parenthesized items, as they have only one alternative. For anything in 7134| | parentheses, we must not ignore if {1} is possessive. */ 7135| | 7136| 268k| switch (op_previous) 7137| 268k| { 7138| | /* If previous was a character or negated character match, abolish the 7139| | item and generate a repeat item instead. If a char item has a minimum of 7140| | more than one, ensure that it is set in reqcu - it might not be if a 7141| | sequence such as x{3} is the first thing in a branch because the x will 7142| | have gone into firstcu instead. */ 7143| | 7144| 65.5k| case OP_CHAR: ------------------ | Branch (7144:7): [True: 65.5k, False: 203k] ------------------ 7145| 85.9k| case OP_CHARI: ------------------ | Branch (7145:7): [True: 20.3k, False: 248k] ------------------ 7146| 101k| case OP_NOT: ------------------ | Branch (7146:7): [True: 15.8k, False: 252k] ------------------ 7147| 112k| case OP_NOTI: ------------------ | Branch (7147:7): [True: 10.4k, False: 258k] ------------------ 7148| 112k| if (repeat_max == 1 && repeat_min == 1) goto END_REPEAT; ------------------ | Branch (7148:11): [True: 51.8k, False: 60.3k] | Branch (7148:30): [True: 309, False: 51.5k] ------------------ 7149| 111k| op_type = chartypeoffset[op_previous - OP_CHAR]; 7150| | 7151| | /* Deal with UTF characters that take up more than one code unit. */ 7152| | 7153| 111k|#ifdef MAYBE_UTF_MULTI 7154| 111k| if (utf && NOT_FIRSTCU(code[-1])) ------------------ | | 296| 13.6k|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 4.27k, False: 9.40k] | | ------------------ ------------------ | Branch (7154:11): [True: 13.6k, False: 98.2k] ------------------ 7155| 4.27k| { 7156| 4.27k| PCRE2_UCHAR *lastchar = code - 1; ------------------ | | 813| 4.27k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 4.27k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 4.27k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 4.27k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7157| 4.27k| BACKCHAR(lastchar); ------------------ | | 345| 11.5k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 7.24k, False: 4.27k] | | ------------------ ------------------ 7158| 4.27k| mclength = (uint32_t)(code - lastchar); /* Length of UTF character */ 7159| 4.27k| memcpy(mcbuffer, lastchar, CU2BYTES(mclength)); /* Save the char */ ------------------ | | 545| 4.27k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7160| 4.27k| } 7161| 107k| else 7162| 107k|#endif /* MAYBE_UTF_MULTI */ 7163| | 7164| | /* Handle the case of a single code unit - either with no UTF support, or 7165| | with UTF disabled, or for a single-code-unit UTF character. In the latter 7166| | case, for a repeated positive match, get the caseless flag for the 7167| | required code unit from the previous character, because a class like [Aa] 7168| | sets a caseless A but by now the req_caseopt flag has been reset. */ 7169| | 7170| 107k| { 7171| 107k| mcbuffer[0] = code[-1]; 7172| 107k| mclength = 1; 7173| 107k| if (op_previous <= OP_CHARI && repeat_min > 1) ------------------ | Branch (7173:13): [True: 81.8k, False: 25.7k] | Branch (7173:40): [True: 4.82k, False: 77.0k] ------------------ 7174| 4.82k| { 7175| 4.82k| reqcu = mcbuffer[0]; 7176| 4.82k| reqcuflags = cb->req_varyopt; 7177| 4.82k| if (op_previous == OP_CHARI) reqcuflags |= REQ_CASELESS; ------------------ | | 395| 1.31k|#define REQ_CASELESS 0x00000001u /* Code unit in xxcu is caseless */ ------------------ | Branch (7177:15): [True: 1.31k, False: 3.51k] ------------------ 7178| 4.82k| } 7179| 107k| } 7180| 111k| goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */ 7181| | 7182| | /* If previous was a character class or a back reference, we put the 7183| | repeat stuff after it, but just skip the item if the repeat was {0,0}. */ 7184| | 7185| 0|#ifdef SUPPORT_WIDE_CHARS 7186| 2.22k| case OP_XCLASS: ------------------ | Branch (7186:7): [True: 2.22k, False: 266k] ------------------ 7187| 2.22k|#endif 7188| 7.28k| case OP_CLASS: ------------------ | Branch (7188:7): [True: 5.05k, False: 263k] ------------------ 7189| 9.89k| case OP_NCLASS: ------------------ | Branch (7189:7): [True: 2.61k, False: 266k] ------------------ 7190| 12.5k| case OP_REF: ------------------ | Branch (7190:7): [True: 2.60k, False: 266k] ------------------ 7191| 12.9k| case OP_REFI: ------------------ | Branch (7191:7): [True: 496, False: 268k] ------------------ 7192| 13.4k| case OP_DNREF: ------------------ | Branch (7192:7): [True: 456, False: 268k] ------------------ 7193| 13.7k| case OP_DNREFI: ------------------ | Branch (7193:7): [True: 276, False: 268k] ------------------ 7194| | 7195| 13.7k| if (repeat_max == 0) ------------------ | Branch (7195:11): [True: 204, False: 13.5k] ------------------ 7196| 204| { 7197| 204| code = previous; 7198| 204| goto END_REPEAT; 7199| 204| } 7200| 13.5k| if (repeat_max == 1 && repeat_min == 1) goto END_REPEAT; ------------------ | Branch (7200:11): [True: 3.76k, False: 9.75k] | Branch (7200:30): [True: 198, False: 3.56k] ------------------ 7201| | 7202| 13.3k| if (repeat_min == 0 && repeat_max == REPEAT_UNLIMITED) ------------------ | | 149| 8.08k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 8.08k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7202:11): [True: 8.08k, False: 5.24k] | Branch (7202:30): [True: 3.92k, False: 4.16k] ------------------ 7203| 3.92k| *code++ = OP_CRSTAR + repeat_type; 7204| 9.40k| else if (repeat_min == 1 && repeat_max == REPEAT_UNLIMITED) ------------------ | | 149| 3.42k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 3.42k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7204:16): [True: 3.42k, False: 5.98k] | Branch (7204:35): [True: 3.19k, False: 228] ------------------ 7205| 3.19k| *code++ = OP_CRPLUS + repeat_type; 7206| 6.20k| else if (repeat_min == 0 && repeat_max == 1) ------------------ | Branch (7206:16): [True: 4.16k, False: 2.04k] | Branch (7206:35): [True: 3.56k, False: 591] ------------------ 7207| 3.56k| *code++ = OP_CRQUERY + repeat_type; 7208| 2.64k| else 7209| 2.64k| { 7210| 2.64k| *code++ = OP_CRRANGE + repeat_type; 7211| 2.64k| PUT2INC(code, 0, repeat_min); ------------------ | | 548| 2.64k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 2.64k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 2.64k|#define IMM2_SIZE 2 | | ------------------ ------------------ 7212| 2.64k| if (repeat_max == REPEAT_UNLIMITED) repeat_max = 0; /* 2-byte encoding for max */ ------------------ | | 149| 2.64k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 2.64k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7212:13): [True: 412, False: 2.22k] ------------------ 7213| 2.64k| PUT2INC(code, 0, repeat_max); ------------------ | | 548| 2.64k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 2.64k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 2.64k|#define IMM2_SIZE 2 | | ------------------ ------------------ 7214| 2.64k| } 7215| 13.3k| break; 7216| | 7217| | /* If previous is OP_FAIL, it was generated by an empty class [] 7218| | (PCRE2_ALLOW_EMPTY_CLASS is set). The other ways in which OP_FAIL can be 7219| | generated, that is by (*FAIL) or (?!), disallow a quantifier at parse 7220| | time. We can just ignore this repeat. */ 7221| | 7222| 258| case OP_FAIL: ------------------ | Branch (7222:7): [True: 258, False: 268k] ------------------ 7223| 258| goto END_REPEAT; 7224| | 7225| | /* Prior to 10.30, repeated recursions were wrapped in OP_ONCE brackets 7226| | because pcre2_match() could not handle backtracking into recursively 7227| | called groups. Now that this backtracking is available, we no longer need 7228| | to do this. However, we still need to replicate recursions as we do for 7229| | groups so as to have independent backtracking points. We can replicate 7230| | for the minimum number of repeats directly. For optional repeats we now 7231| | wrap the recursion in OP_BRA brackets and make use of the bracket 7232| | repetition. */ 7233| | 7234| 3.08k| case OP_RECURSE: ------------------ | Branch (7234:7): [True: 3.08k, False: 265k] ------------------ 7235| 3.08k| if (repeat_max == 1 && repeat_min == 1 && !possessive_quantifier) ------------------ | Branch (7235:11): [True: 1.37k, False: 1.71k] | Branch (7235:30): [True: 802, False: 570] | Branch (7235:49): [True: 282, False: 520] ------------------ 7236| 282| goto END_REPEAT; 7237| | 7238| | /* Generate unwrapped repeats for a non-zero minimum, except when the 7239| | minimum is 1 and the maximum unlimited, because that can be handled with 7240| | OP_BRA terminated by OP_KETRMAX/MIN. When the maximum is equal to the 7241| | minimum, we just need to generate the appropriate additional copies. 7242| | Otherwise we need to generate one more, to simulate the situation when 7243| | the minimum is zero. */ 7244| | 7245| 2.80k| if (repeat_min > 0 && (repeat_min != 1 || repeat_max != REPEAT_UNLIMITED)) ------------------ | | 149| 950|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 950|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7245:11): [True: 1.96k, False: 841] | Branch (7245:30): [True: 1.01k, False: 950] | Branch (7245:49): [True: 690, False: 260] ------------------ 7246| 1.70k| { 7247| 1.70k| int replicate = repeat_min; 7248| 1.70k| if (repeat_min == repeat_max) replicate--; ------------------ | Branch (7248:13): [True: 1.28k, False: 422] ------------------ 7249| | 7250| | /* In the pre-compile phase, we don't actually do the replication. We 7251| | just adjust the length as if we had. Do some paranoid checks for 7252| | potential integer overflow. */ 7253| | 7254| 1.70k| if (lengthptr != NULL) ------------------ | Branch (7254:13): [True: 871, False: 833] ------------------ 7255| 871| { 7256| 871| PCRE2_SIZE delta; ------------------ | | 477| 871|#define PCRE2_SIZE size_t ------------------ 7257| 871| if (PRIV(ckd_smul)(&delta, replicate, 1 + LINK_SIZE) || ------------------ | | 177| 871|#define PRIV(name) _pcre2_##name ------------------ if (PRIV(ckd_smul)(&delta, replicate, 1 + LINK_SIZE) || ------------------ | | 165| 871|#define LINK_SIZE 2 ------------------ | Branch (7257:15): [True: 0, False: 871] ------------------ 7258| 871| OFLOW_MAX - *lengthptr < delta) ------------------ | | 200| 871|#define OFLOW_MAX (INT_MAX - 20) ------------------ | Branch (7258:15): [True: 0, False: 871] ------------------ 7259| 0| { 7260| 0| *errorcodeptr = ERR20; 7261| 0| return 0; 7262| 0| } 7263| 871| *lengthptr += delta; 7264| 871| } 7265| | 7266| 131k| else for (int i = 0; i < replicate; i++) ------------------ | Branch (7266:30): [True: 130k, False: 833] ------------------ 7267| 130k| { 7268| 130k| memcpy(code, previous, CU2BYTES(1 + LINK_SIZE)); ------------------ | | 545| 130k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7269| 130k| previous = code; 7270| 130k| code += 1 + LINK_SIZE; ------------------ | | 165| 130k|#define LINK_SIZE 2 ------------------ 7271| 130k| } 7272| | 7273| | /* If the number of repeats is fixed, we are done. Otherwise, adjust 7274| | the counts and fall through. */ 7275| | 7276| 1.70k| if (repeat_min == repeat_max) break; ------------------ | Branch (7276:13): [True: 1.28k, False: 422] ------------------ 7277| 422| if (repeat_max != REPEAT_UNLIMITED) repeat_max -= repeat_min; ------------------ | | 149| 422|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 422|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7277:13): [True: 226, False: 196] ------------------ 7278| 422| repeat_min = 0; 7279| 422| } 7280| | 7281| | /* Wrap the recursion call in OP_BRA brackets. */ 7282| | 7283| 1.52k| (void)memmove(previous + 1 + LINK_SIZE, previous, CU2BYTES(1 + LINK_SIZE)); ------------------ | | 165| 1.52k|#define LINK_SIZE 2 ------------------ (void)memmove(previous + 1 + LINK_SIZE, previous, CU2BYTES(1 + LINK_SIZE)); ------------------ | | 545| 1.52k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7284| 1.52k| op_previous = *previous = OP_BRA; 7285| 1.52k| PUT(previous, 1, 2 + 2*LINK_SIZE); ------------------ | | 106| 1.52k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 1.52k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7286| 1.52k| previous[2 + 2*LINK_SIZE] = OP_KET; ------------------ | | 165| 1.52k|#define LINK_SIZE 2 ------------------ 7287| 1.52k| PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE); ------------------ | | 106| 1.52k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 1.52k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7288| 1.52k| code += 2 + 2 * LINK_SIZE; ------------------ | | 165| 1.52k|#define LINK_SIZE 2 ------------------ 7289| 1.52k| length_prevgroup = 3 + 3*LINK_SIZE; ------------------ | | 165| 1.52k|#define LINK_SIZE 2 ------------------ 7290| 1.52k| group_return = -1; /* Set "may match empty string" */ 7291| | 7292| | /* Now treat as a repeated OP_BRA. */ 7293| | /* Fall through */ 7294| | 7295| | /* If previous was a bracket group, we may have to replicate it in 7296| | certain cases. Note that at this point we can encounter only the "basic" 7297| | bracket opcodes such as BRA and CBRA, as this is the place where they get 7298| | converted into the more special varieties such as BRAPOS and SBRA. 7299| | Originally, PCRE did not allow repetition of assertions, but now it does, 7300| | for Perl compatibility. */ 7301| | 7302| 2.40k| case OP_ASSERT: ------------------ | Branch (7302:7): [True: 880, False: 267k] ------------------ 7303| 3.39k| case OP_ASSERT_NOT: ------------------ | Branch (7303:7): [True: 994, False: 267k] ------------------ 7304| 3.78k| case OP_ASSERT_NA: ------------------ | Branch (7304:7): [True: 390, False: 268k] ------------------ 7305| 4.20k| case OP_ASSERTBACK: ------------------ | Branch (7305:7): [True: 420, False: 268k] ------------------ 7306| 4.68k| case OP_ASSERTBACK_NOT: ------------------ | Branch (7306:7): [True: 476, False: 268k] ------------------ 7307| 5.23k| case OP_ASSERTBACK_NA: ------------------ | Branch (7307:7): [True: 550, False: 268k] ------------------ 7308| 6.28k| case OP_ONCE: ------------------ | Branch (7308:7): [True: 1.05k, False: 267k] ------------------ 7309| 6.63k| case OP_SCRIPT_RUN: ------------------ | Branch (7309:7): [True: 352, False: 268k] ------------------ 7310| 17.4k| case OP_BRA: ------------------ | Branch (7310:7): [True: 10.8k, False: 257k] ------------------ 7311| 41.6k| case OP_CBRA: ------------------ | Branch (7311:7): [True: 24.1k, False: 244k] ------------------ 7312| 44.0k| case OP_COND: ------------------ | Branch (7312:7): [True: 2.44k, False: 266k] ------------------ 7313| 44.0k| { 7314| 44.0k| int len = (int)(code - previous); 7315| 44.0k| PCRE2_UCHAR *bralink = NULL; ------------------ | | 813| 44.0k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 44.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 44.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 44.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7316| 44.0k| PCRE2_UCHAR *brazeroptr = NULL; ------------------ | | 813| 44.0k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 44.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 44.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 44.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7317| | 7318| 44.0k| if (repeat_max == 1 && repeat_min == 1 && !possessive_quantifier) ------------------ | Branch (7318:13): [True: 3.81k, False: 40.2k] | Branch (7318:32): [True: 528, False: 3.28k] | Branch (7318:51): [True: 226, False: 302] ------------------ 7319| 226| goto END_REPEAT; 7320| | 7321| | /* Repeating a DEFINE group (or any group where the condition is always 7322| | FALSE and there is only one branch) is pointless, but Perl allows the 7323| | syntax, so we just ignore the repeat. */ 7324| | 7325| 43.8k| if (op_previous == OP_COND && previous[LINK_SIZE+1] == OP_FALSE && ------------------ | | 165| 2.44k|#define LINK_SIZE 2 ------------------ | Branch (7325:13): [True: 2.44k, False: 41.4k] | Branch (7325:39): [True: 280, False: 2.16k] ------------------ 7326| 43.8k| previous[GET(previous, 1)] != OP_ALT) ------------------ | | 109| 280| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (7326:13): [True: 66, False: 214] ------------------ 7327| 66| goto END_REPEAT; 7328| | 7329| | /* Perl allows all assertions to be quantified, and when they contain 7330| | capturing parentheses and/or are optional there are potential uses for 7331| | this feature. PCRE2 used to force the maximum quantifier to 1 on the 7332| | invalid grounds that further repetition was never useful. This was 7333| | always a bit pointless, since an assertion could be wrapped with a 7334| | repeated group to achieve the effect. General repetition is now 7335| | permitted, but if the maximum is unlimited it is set to one more than 7336| | the minimum. */ 7337| | 7338| 43.7k| if (op_previous < OP_ONCE) /* Assertion */ ------------------ | Branch (7338:13): [True: 3.69k, False: 40.0k] ------------------ 7339| 3.69k| { 7340| 3.69k| if (repeat_max == REPEAT_UNLIMITED) repeat_max = repeat_min + 1; ------------------ | | 149| 3.69k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 3.69k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7340:15): [True: 1.68k, False: 2.00k] ------------------ 7341| 3.69k| } 7342| | 7343| | /* The case of a zero minimum is special because of the need to stick 7344| | OP_BRAZERO in front of it, and because the group appears once in the 7345| | data, whereas in other cases it appears the minimum number of times. For 7346| | this reason, it is simplest to treat this case separately, as otherwise 7347| | the code gets far too messy. There are several special subcases when the 7348| | minimum is zero. */ 7349| | 7350| 43.7k| if (repeat_min == 0) ------------------ | Branch (7350:13): [True: 9.39k, False: 34.3k] ------------------ 7351| 9.39k| { 7352| | /* If the maximum is also zero, we used to just omit the group from 7353| | the output altogether, like this: 7354| | 7355| | ** if (repeat_max == 0) 7356| | ** { 7357| | ** code = previous; 7358| | ** goto END_REPEAT; 7359| | ** } 7360| | 7361| | However, that fails when a group or a subgroup within it is 7362| | referenced as a subroutine from elsewhere in the pattern, so now we 7363| | stick in OP_SKIPZERO in front of it so that it is skipped on 7364| | execution. As we don't have a list of which groups are referenced, we 7365| | cannot do this selectively. 7366| | 7367| | If the maximum is 1 or unlimited, we just have to stick in the 7368| | BRAZERO and do no more at this point. */ 7369| | 7370| 9.39k| if (repeat_max <= 1 || repeat_max == REPEAT_UNLIMITED) ------------------ | | 149| 4.91k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 4.91k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7370:15): [True: 4.48k, False: 4.91k] | Branch (7370:34): [True: 4.35k, False: 561] ------------------ 7371| 8.83k| { 7372| 8.83k| (void)memmove(previous + 1, previous, CU2BYTES(len)); ------------------ | | 545| 8.83k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7373| 8.83k| code++; 7374| 8.83k| if (repeat_max == 0) ------------------ | Branch (7374:17): [True: 680, False: 8.15k] ------------------ 7375| 680| { 7376| 680| *previous++ = OP_SKIPZERO; 7377| 680| goto END_REPEAT; 7378| 680| } 7379| 8.15k| brazeroptr = previous; /* Save for possessive optimizing */ 7380| 8.15k| *previous++ = OP_BRAZERO + repeat_type; 7381| 8.15k| } 7382| | 7383| | /* If the maximum is greater than 1 and limited, we have to replicate 7384| | in a nested fashion, sticking OP_BRAZERO before each set of brackets. 7385| | The first one has to be handled carefully because it's the original 7386| | copy, which has to be moved up. The remainder can be handled by code 7387| | that is common with the non-zero minimum case below. We have to 7388| | adjust the value or repeat_max, since one less copy is required. */ 7389| | 7390| 561| else 7391| 561| { 7392| 561| int linkoffset; 7393| 561| (void)memmove(previous + 2 + LINK_SIZE, previous, CU2BYTES(len)); ------------------ | | 165| 561|#define LINK_SIZE 2 ------------------ (void)memmove(previous + 2 + LINK_SIZE, previous, CU2BYTES(len)); ------------------ | | 545| 561|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7394| 561| code += 2 + LINK_SIZE; ------------------ | | 165| 561|#define LINK_SIZE 2 ------------------ 7395| 561| *previous++ = OP_BRAZERO + repeat_type; 7396| 561| *previous++ = OP_BRA; 7397| | 7398| | /* We chain together the bracket link offset fields that have to be 7399| | filled in later when the ends of the brackets are reached. */ 7400| | 7401| 561| linkoffset = (bralink == NULL)? 0 : (int)(previous - bralink); ------------------ | Branch (7401:26): [True: 561, False: 0] ------------------ 7402| 561| bralink = previous; 7403| 561| PUTINC(previous, 0, linkoffset); ------------------ | | 547| 561|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 561| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 561| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 561|#define LINK_SIZE 2 | | ------------------ ------------------ 7404| 561| } 7405| | 7406| 8.71k| if (repeat_max != REPEAT_UNLIMITED) repeat_max--; ------------------ | | 149| 8.71k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 8.71k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7406:15): [True: 4.36k, False: 4.35k] ------------------ 7407| 8.71k| } 7408| | 7409| | /* If the minimum is greater than zero, replicate the group as many 7410| | times as necessary, and adjust the maximum to the number of subsequent 7411| | copies that we need. */ 7412| | 7413| 34.3k| else 7414| 34.3k| { 7415| 34.3k| if (repeat_min > 1) ------------------ | Branch (7415:15): [True: 21.5k, False: 12.8k] ------------------ 7416| 21.5k| { 7417| | /* In the pre-compile phase, we don't actually do the replication. 7418| | We just adjust the length as if we had. Do some paranoid checks for 7419| | potential integer overflow. */ 7420| | 7421| 21.5k| if (lengthptr != NULL) ------------------ | Branch (7421:17): [True: 10.9k, False: 10.6k] ------------------ 7422| 10.9k| { 7423| 10.9k| PCRE2_SIZE delta; ------------------ | | 477| 10.9k|#define PCRE2_SIZE size_t ------------------ 7424| 10.9k| if (PRIV(ckd_smul)(&delta, repeat_min - 1, length_prevgroup) || ------------------ | | 177| 10.9k|#define PRIV(name) _pcre2_##name ------------------ | Branch (7424:19): [True: 0, False: 10.9k] ------------------ 7425| 10.9k| OFLOW_MAX - *lengthptr < delta) ------------------ | | 200| 10.9k|#define OFLOW_MAX (INT_MAX - 20) ------------------ | Branch (7425:19): [True: 8, False: 10.9k] ------------------ 7426| 8| { 7427| 8| *errorcodeptr = ERR20; 7428| 8| return 0; 7429| 8| } 7430| 10.9k| *lengthptr += delta; 7431| 10.9k| } 7432| | 7433| | /* This is compiling for real. If there is a set first code unit 7434| | for the group, and we have not yet set a "required code unit", set 7435| | it. */ 7436| | 7437| 10.6k| else 7438| 10.6k| { 7439| 10.6k| if (groupsetfirstcu && reqcuflags >= REQ_NONE) ------------------ | | 394| 1.36k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (7439:19): [True: 1.36k, False: 9.26k] | Branch (7439:38): [True: 626, False: 740] ------------------ 7440| 626| { 7441| 626| reqcu = firstcu; 7442| 626| reqcuflags = firstcuflags; 7443| 626| } 7444| 960k| for (uint32_t i = 1; i < repeat_min; i++) ------------------ | Branch (7444:36): [True: 950k, False: 10.6k] ------------------ 7445| 950k| { 7446| 950k| memcpy(code, previous, CU2BYTES(len)); ------------------ | | 545| 950k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7447| 950k| code += len; 7448| 950k| } 7449| 10.6k| } 7450| 21.5k| } 7451| | 7452| 34.3k| if (repeat_max != REPEAT_UNLIMITED) repeat_max -= repeat_min; ------------------ | | 149| 34.3k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 34.3k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7452:15): [True: 23.0k, False: 11.2k] ------------------ 7453| 34.3k| } 7454| | 7455| | /* This code is common to both the zero and non-zero minimum cases. If 7456| | the maximum is limited, it replicates the group in a nested fashion, 7457| | remembering the bracket starts on a stack. In the case of a zero 7458| | minimum, the first one was set up above. In all cases the repeat_max 7459| | now specifies the number of additional copies needed. Again, we must 7460| | remember to replicate entries on the forward reference list. */ 7461| | 7462| 43.0k| if (repeat_max != REPEAT_UNLIMITED) ------------------ | | 149| 43.0k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 43.0k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7462:13): [True: 27.4k, False: 15.6k] ------------------ 7463| 27.4k| { 7464| | /* In the pre-compile phase, we don't actually do the replication. We 7465| | just adjust the length as if we had. For each repetition we must add 7466| | 1 to the length for BRAZERO and for all but the last repetition we 7467| | must add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some 7468| | paranoid checks to avoid integer overflow. */ 7469| | 7470| 27.4k| if (lengthptr != NULL && repeat_max > 0) ------------------ | Branch (7470:15): [True: 13.9k, False: 13.5k] | Branch (7470:36): [True: 1.33k, False: 12.6k] ------------------ 7471| 1.33k| { 7472| 1.33k| PCRE2_SIZE delta; ------------------ | | 477| 1.33k|#define PCRE2_SIZE size_t ------------------ 7473| 1.33k| if (PRIV(ckd_smul)(&delta, repeat_max, ------------------ | | 177| 1.33k|#define PRIV(name) _pcre2_##name ------------------ | Branch (7473:17): [True: 0, False: 1.33k] ------------------ 7474| 1.33k| length_prevgroup + 1 + 2 + 2*LINK_SIZE) || ------------------ | | 165| 1.33k|#define LINK_SIZE 2 ------------------ 7475| 1.33k| OFLOW_MAX + (2 + 2*LINK_SIZE) - *lengthptr < delta) ------------------ | | 200| 1.33k|#define OFLOW_MAX (INT_MAX - 20) ------------------ OFLOW_MAX + (2 + 2*LINK_SIZE) - *lengthptr < delta) ------------------ | | 165| 1.33k|#define LINK_SIZE 2 ------------------ | Branch (7475:17): [True: 5, False: 1.32k] ------------------ 7476| 5| { 7477| 5| *errorcodeptr = ERR20; 7478| 5| return 0; 7479| 5| } 7480| 1.32k| delta -= (2 + 2*LINK_SIZE); /* Last one doesn't nest */ ------------------ | | 165| 1.32k|#define LINK_SIZE 2 ------------------ 7481| 1.32k| *lengthptr += delta; 7482| 1.32k| } 7483| | 7484| | /* This is compiling for real */ 7485| | 7486| 85.0k| else for (uint32_t i = repeat_max; i >= 1; i--) ------------------ | Branch (7486:46): [True: 58.8k, False: 26.1k] ------------------ 7487| 58.8k| { 7488| 58.8k| *code++ = OP_BRAZERO + repeat_type; 7489| | 7490| | /* All but the final copy start a new nesting, maintaining the 7491| | chain of brackets outstanding. */ 7492| | 7493| 58.8k| if (i != 1) ------------------ | Branch (7493:17): [True: 57.6k, False: 1.24k] ------------------ 7494| 57.6k| { 7495| 57.6k| int linkoffset; 7496| 57.6k| *code++ = OP_BRA; 7497| 57.6k| linkoffset = (bralink == NULL)? 0 : (int)(code - bralink); ------------------ | Branch (7497:28): [True: 405, False: 57.2k] ------------------ 7498| 57.6k| bralink = code; 7499| 57.6k| PUTINC(code, 0, linkoffset); ------------------ | | 547| 57.6k|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 57.6k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 57.6k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 57.6k|#define LINK_SIZE 2 | | ------------------ ------------------ 7500| 57.6k| } 7501| | 7502| 58.8k| memcpy(code, previous, CU2BYTES(len)); ------------------ | | 545| 58.8k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7503| 58.8k| code += len; 7504| 58.8k| } 7505| | 7506| | /* Now chain through the pending brackets, and fill in their length 7507| | fields (which are holding the chain links pro tem). */ 7508| | 7509| 85.6k| while (bralink != NULL) ------------------ | Branch (7509:18): [True: 58.1k, False: 27.4k] ------------------ 7510| 58.1k| { 7511| 58.1k| int oldlinkoffset; 7512| 58.1k| int linkoffset = (int)(code - bralink + 1); 7513| 58.1k| PCRE2_UCHAR *bra = code - linkoffset; ------------------ | | 813| 58.1k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 58.1k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 58.1k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 58.1k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7514| 58.1k| oldlinkoffset = GET(bra, 1); ------------------ | | 109| 58.1k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 7515| 58.1k| bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset; ------------------ | Branch (7515:23): [True: 966, False: 57.2k] ------------------ 7516| 58.1k| *code++ = OP_KET; 7517| 58.1k| PUTINC(code, 0, linkoffset); ------------------ | | 547| 58.1k|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 58.1k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 58.1k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 58.1k|#define LINK_SIZE 2 | | ------------------ ------------------ 7518| 58.1k| PUT(bra, 1, linkoffset); ------------------ | | 106| 58.1k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 58.1k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7519| 58.1k| } 7520| 27.4k| } 7521| | 7522| | /* If the maximum is unlimited, set a repeater in the final copy. For 7523| | SCRIPT_RUN and ONCE brackets, that's all we need to do. However, 7524| | possessively repeated ONCE brackets can be converted into non-capturing 7525| | brackets, as the behaviour of (?:xx)++ is the same as (?>xx)++ and this 7526| | saves having to deal with possessive ONCEs specially. 7527| | 7528| | Otherwise, when we are doing the actual compile phase, check to see 7529| | whether this group is one that could match an empty string. If so, 7530| | convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so 7531| | that runtime checking can be done. [This check is also applied to ONCE 7532| | and SCRIPT_RUN groups at runtime, but in a different way.] 7533| | 7534| | Then, if the quantifier was possessive and the bracket is not a 7535| | conditional, we convert the BRA code to the POS form, and the KET code 7536| | to KETRPOS. (It turns out to be convenient at runtime to detect this 7537| | kind of subpattern at both the start and at the end.) The use of 7538| | special opcodes makes it possible to reduce greatly the stack usage in 7539| | pcre2_match(). If the group is preceded by OP_BRAZERO, convert this to 7540| | OP_BRAPOSZERO. 7541| | 7542| | Then, if the minimum number of matches is 1 or 0, cancel the possessive 7543| | flag so that the default action below, of wrapping everything inside 7544| | atomic brackets, does not happen. When the minimum is greater than 1, 7545| | there will be earlier copies of the group, and so we still have to wrap 7546| | the whole thing. */ 7547| | 7548| 15.6k| else 7549| 15.6k| { 7550| 15.6k| PCRE2_UCHAR *ketcode = code - 1 - LINK_SIZE; ------------------ | | 813| 15.6k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 15.6k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 15.6k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 15.6k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_UCHAR *ketcode = code - 1 - LINK_SIZE; ------------------ | | 165| 15.6k|#define LINK_SIZE 2 ------------------ 7551| 15.6k| PCRE2_UCHAR *bracode = ketcode - GET(ketcode, 1); ------------------ | | 813| 15.6k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 15.6k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 15.6k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 15.6k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_UCHAR *bracode = ketcode - GET(ketcode, 1); ------------------ | | 109| 15.6k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 7552| | 7553| | /* Convert possessive ONCE brackets to non-capturing */ 7554| | 7555| 15.6k| if (*bracode == OP_ONCE && possessive_quantifier) *bracode = OP_BRA; ------------------ | Branch (7555:15): [True: 732, False: 14.9k] | Branch (7555:38): [True: 242, False: 490] ------------------ 7556| | 7557| | /* For non-possessive ONCE and for SCRIPT_RUN brackets, all we need 7558| | to do is to set the KET. */ 7559| | 7560| 15.6k| if (*bracode == OP_ONCE || *bracode == OP_SCRIPT_RUN) ------------------ | Branch (7560:15): [True: 490, False: 15.1k] | Branch (7560:38): [True: 238, False: 14.9k] ------------------ 7561| 728| *ketcode = OP_KETRMAX + repeat_type; 7562| | 7563| | /* Handle non-SCRIPT_RUN and non-ONCE brackets and possessive ONCEs 7564| | (which have been converted to non-capturing above). */ 7565| | 7566| 14.9k| else 7567| 14.9k| { 7568| | /* In the compile phase, adjust the opcode if the group can match 7569| | an empty string. For a conditional group with only one branch, the 7570| | value of group_return will not show "could be empty", so we must 7571| | check that separately. */ 7572| | 7573| 14.9k| if (lengthptr == NULL) ------------------ | Branch (7573:17): [True: 7.35k, False: 7.55k] ------------------ 7574| 7.35k| { 7575| 7.35k| if (group_return < 0) *bracode += OP_SBRA - OP_BRA; ------------------ | Branch (7575:19): [True: 3.95k, False: 3.39k] ------------------ 7576| 7.35k| if (*bracode == OP_COND && bracode[GET(bracode,1)] != OP_ALT) ------------------ | | 109| 416| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (7576:19): [True: 416, False: 6.93k] | Branch (7576:42): [True: 204, False: 212] ------------------ 7577| 204| *bracode = OP_SCOND; 7578| 7.35k| } 7579| | 7580| | /* Handle possessive quantifiers. */ 7581| | 7582| 14.9k| if (possessive_quantifier) ------------------ | Branch (7582:17): [True: 5.79k, False: 9.11k] ------------------ 7583| 5.79k| { 7584| | /* For COND brackets, we wrap the whole thing in a possessively 7585| | repeated non-capturing bracket, because we have not invented POS 7586| | versions of the COND opcodes. */ 7587| | 7588| 5.79k| if (*bracode == OP_COND || *bracode == OP_SCOND) ------------------ | Branch (7588:19): [True: 273, False: 5.51k] | Branch (7588:42): [True: 241, False: 5.27k] ------------------ 7589| 514| { 7590| 514| int nlen = (int)(code - bracode); 7591| 514| (void)memmove(bracode + 1 + LINK_SIZE, bracode, CU2BYTES(nlen)); ------------------ | | 165| 514|#define LINK_SIZE 2 ------------------ (void)memmove(bracode + 1 + LINK_SIZE, bracode, CU2BYTES(nlen)); ------------------ | | 545| 514|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7592| 514| code += 1 + LINK_SIZE; ------------------ | | 165| 514|#define LINK_SIZE 2 ------------------ 7593| 514| nlen += 1 + LINK_SIZE; ------------------ | | 165| 514|#define LINK_SIZE 2 ------------------ 7594| 514| *bracode = (*bracode == OP_COND)? OP_BRAPOS : OP_SBRAPOS; ------------------ | Branch (7594:28): [True: 273, False: 241] ------------------ 7595| 514| *code++ = OP_KETRPOS; 7596| 514| PUTINC(code, 0, nlen); ------------------ | | 547| 514|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 514| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 514| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 514|#define LINK_SIZE 2 | | ------------------ ------------------ 7597| 514| PUT(bracode, 1, nlen); ------------------ | | 106| 514| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 514| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7598| 514| } 7599| | 7600| | /* For non-COND brackets, we modify the BRA code and use KETRPOS. */ 7601| | 7602| 5.27k| else 7603| 5.27k| { 7604| 5.27k| *bracode += 1; /* Switch to xxxPOS opcodes */ 7605| 5.27k| *ketcode = OP_KETRPOS; 7606| 5.27k| } 7607| | 7608| | /* If the minimum is zero, mark it as possessive, then unset the 7609| | possessive flag when the minimum is 0 or 1. */ 7610| | 7611| 5.79k| if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO; ------------------ | Branch (7611:19): [True: 1.23k, False: 4.56k] ------------------ 7612| 5.79k| if (repeat_min < 2) possessive_quantifier = FALSE; ------------------ | | 69| 5.55k|#define FALSE 0 ------------------ | Branch (7612:19): [True: 5.55k, False: 241] ------------------ 7613| 5.79k| } 7614| | 7615| | /* Non-possessive quantifier */ 7616| | 7617| 9.11k| else *ketcode = OP_KETRMAX + repeat_type; 7618| 14.9k| } 7619| 15.6k| } 7620| 43.0k| } 7621| 43.0k| break; 7622| | 7623| | /* If previous was a character type match (\d or similar), abolish it and 7624| | create a suitable repeat item. The code is shared with single-character 7625| | repeats by setting op_type to add a suitable offset into repeat_type. 7626| | Note the the Unicode property types will be present only when 7627| | SUPPORT_UNICODE is defined, but we don't wrap the little bits of code 7628| | here because it just makes it horribly messy. */ 7629| | 7630| 96.9k| default: ------------------ | Branch (7630:7): [True: 96.9k, False: 171k] ------------------ 7631| 96.9k| if (op_previous >= OP_EODN) /* Not a character type - internal error */ ------------------ | Branch (7631:11): [True: 0, False: 96.9k] ------------------ 7632| 0| { 7633| 0| *errorcodeptr = ERR10; 7634| 0| return 0; 7635| 0| } 7636| 96.9k| else 7637| 96.9k| { 7638| 96.9k| int prop_type, prop_value; 7639| 96.9k| PCRE2_UCHAR *oldcode; ------------------ | | 813| 96.9k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 96.9k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 96.9k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 96.9k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7640| | 7641| 96.9k| if (repeat_max == 1 && repeat_min == 1) goto END_REPEAT; ------------------ | Branch (7641:13): [True: 15.2k, False: 81.6k] | Branch (7641:32): [True: 334, False: 14.9k] ------------------ 7642| | 7643| 96.5k| op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */ 7644| 96.5k| mclength = 0; /* Not a character */ 7645| | 7646| 96.5k| if (op_previous == OP_PROP || op_previous == OP_NOTPROP) ------------------ | Branch (7646:13): [True: 7.06k, False: 89.5k] | Branch (7646:39): [True: 11.2k, False: 78.2k] ------------------ 7647| 18.3k| { 7648| 18.3k| prop_type = previous[1]; 7649| 18.3k| prop_value = previous[2]; 7650| 18.3k| } 7651| 78.2k| else 7652| 78.2k| { 7653| | /* Come here from just above with a character in mcbuffer/mclength. */ 7654| 190k| OUTPUT_SINGLE_REPEAT: 7655| 190k| prop_type = prop_value = -1; 7656| 190k| } 7657| | 7658| | /* At this point, if prop_type == prop_value == -1 we either have a 7659| | character in mcbuffer when mclength is greater than zero, or we have 7660| | mclength zero, in which case there is a non-property character type in 7661| | op_previous. If prop_type/value are not negative, we have a property 7662| | character type in op_previous. */ 7663| | 7664| 208k| oldcode = code; /* Save where we were */ 7665| 208k| code = previous; /* Usually overwrite previous item */ 7666| | 7667| | /* If the maximum is zero then the minimum must also be zero; Perl allows 7668| | this case, so we do too - by simply omitting the item altogether. */ 7669| | 7670| 208k| if (repeat_max == 0) goto END_REPEAT; ------------------ | Branch (7670:13): [True: 1.15k, False: 207k] ------------------ 7671| | 7672| | /* Combine the op_type with the repeat_type */ 7673| | 7674| 207k| repeat_type += op_type; 7675| | 7676| | /* A minimum of zero is handled either as the special case * or ?, or as 7677| | an UPTO, with the maximum given. */ 7678| | 7679| 207k| if (repeat_min == 0) ------------------ | Branch (7679:13): [True: 135k, False: 72.3k] ------------------ 7680| 135k| { 7681| 135k| if (repeat_max == REPEAT_UNLIMITED) *code++ = OP_STAR + repeat_type; ------------------ | | 149| 135k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 135k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7681:15): [True: 47.3k, False: 87.6k] ------------------ 7682| 87.6k| else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type; ------------------ | Branch (7682:22): [True: 66.4k, False: 21.1k] ------------------ 7683| 21.1k| else 7684| 21.1k| { 7685| 21.1k| *code++ = OP_UPTO + repeat_type; 7686| 21.1k| PUT2INC(code, 0, repeat_max); ------------------ | | 548| 21.1k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 21.1k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 21.1k|#define IMM2_SIZE 2 | | ------------------ ------------------ 7687| 21.1k| } 7688| 135k| } 7689| | 7690| | /* A repeat minimum of 1 is optimized into some special cases. If the 7691| | maximum is unlimited, we use OP_PLUS. Otherwise, the original item is 7692| | left in place and, if the maximum is greater than 1, we use OP_UPTO with 7693| | one less than the maximum. */ 7694| | 7695| 72.3k| else if (repeat_min == 1) ------------------ | Branch (7695:18): [True: 56.1k, False: 16.1k] ------------------ 7696| 56.1k| { 7697| 56.1k| if (repeat_max == REPEAT_UNLIMITED) ------------------ | | 149| 56.1k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 56.1k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7697:15): [True: 54.3k, False: 1.86k] ------------------ 7698| 54.3k| *code++ = OP_PLUS + repeat_type; 7699| 1.86k| else 7700| 1.86k| { 7701| 1.86k| code = oldcode; /* Leave previous item in place */ 7702| 1.86k| if (repeat_max == 1) goto END_REPEAT; ------------------ | Branch (7702:17): [True: 0, False: 1.86k] ------------------ 7703| 1.86k| *code++ = OP_UPTO + repeat_type; 7704| 1.86k| PUT2INC(code, 0, repeat_max - 1); ------------------ | | 548| 1.86k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 1.86k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 1.86k|#define IMM2_SIZE 2 | | ------------------ ------------------ 7705| 1.86k| } 7706| 56.1k| } 7707| | 7708| | /* The case {n,n} is just an EXACT, while the general case {n,m} is 7709| | handled as an EXACT followed by an UPTO or STAR or QUERY. */ 7710| | 7711| 16.1k| else 7712| 16.1k| { 7713| 16.1k| *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */ 7714| 16.1k| PUT2INC(code, 0, repeat_min); ------------------ | | 548| 16.1k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 16.1k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 16.1k|#define IMM2_SIZE 2 | | ------------------ ------------------ 7715| | 7716| | /* Unless repeat_max equals repeat_min, fill in the data for EXACT, 7717| | and then generate the second opcode. For a repeated Unicode property 7718| | match, there are two extra values that define the required property, 7719| | and mclength is set zero to indicate this. */ 7720| | 7721| 16.1k| if (repeat_max != repeat_min) ------------------ | Branch (7721:15): [True: 4.04k, False: 12.0k] ------------------ 7722| 4.04k| { 7723| 4.04k| if (mclength > 0) ------------------ | Branch (7723:17): [True: 2.37k, False: 1.67k] ------------------ 7724| 2.37k| { 7725| 2.37k| memcpy(code, mcbuffer, CU2BYTES(mclength)); ------------------ | | 545| 2.37k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7726| 2.37k| code += mclength; 7727| 2.37k| } 7728| 1.67k| else 7729| 1.67k| { 7730| 1.67k| *code++ = op_previous; 7731| 1.67k| if (prop_type >= 0) ------------------ | Branch (7731:19): [True: 329, False: 1.34k] ------------------ 7732| 329| { 7733| 329| *code++ = prop_type; 7734| 329| *code++ = prop_value; 7735| 329| } 7736| 1.67k| } 7737| | 7738| | /* Now set up the following opcode */ 7739| | 7740| 4.04k| if (repeat_max == REPEAT_UNLIMITED) ------------------ | | 149| 4.04k|#define REPEAT_UNLIMITED (MAX_REPEAT_COUNT+1) | | ------------------ | | | | 148| 4.04k|#define MAX_REPEAT_COUNT 65535u | | ------------------ ------------------ | Branch (7740:17): [True: 1.09k, False: 2.95k] ------------------ 7741| 1.09k| *code++ = OP_STAR + repeat_type; 7742| 2.95k| else 7743| 2.95k| { 7744| 2.95k| repeat_max -= repeat_min; 7745| 2.95k| if (repeat_max == 1) ------------------ | Branch (7745:19): [True: 246, False: 2.70k] ------------------ 7746| 246| { 7747| 246| *code++ = OP_QUERY + repeat_type; 7748| 246| } 7749| 2.70k| else 7750| 2.70k| { 7751| 2.70k| *code++ = OP_UPTO + repeat_type; 7752| 2.70k| PUT2INC(code, 0, repeat_max); ------------------ | | 548| 2.70k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 2.70k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 2.70k|#define IMM2_SIZE 2 | | ------------------ ------------------ 7753| 2.70k| } 7754| 2.95k| } 7755| 4.04k| } 7756| 16.1k| } 7757| | 7758| | /* Fill in the character or character type for the final opcode. */ 7759| | 7760| 207k| if (mclength > 0) ------------------ | Branch (7760:13): [True: 111k, False: 96.1k] ------------------ 7761| 111k| { 7762| 111k| memcpy(code, mcbuffer, CU2BYTES(mclength)); ------------------ | | 545| 111k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7763| 111k| code += mclength; 7764| 111k| } 7765| 96.1k| else 7766| 96.1k| { 7767| 96.1k| *code++ = op_previous; 7768| 96.1k| if (prop_type >= 0) ------------------ | Branch (7768:15): [True: 18.3k, False: 77.8k] ------------------ 7769| 18.3k| { 7770| 18.3k| *code++ = prop_type; 7771| 18.3k| *code++ = prop_value; 7772| 18.3k| } 7773| 96.1k| } 7774| 207k| } 7775| 207k| break; 7776| 268k| } /* End of switch on different op_previous values */ 7777| | 7778| | 7779| | /* If the character following a repeat is '+', possessive_quantifier is 7780| | TRUE. For some opcodes, there are special alternative opcodes for this 7781| | case. For anything else, we wrap the entire repeated item inside OP_ONCE 7782| | brackets. Logically, the '+' notation is just syntactic sugar, taken from 7783| | Sun's Java package, but the special opcodes can optimize it. 7784| | 7785| | Some (but not all) possessively repeated subpatterns have already been 7786| | completely handled in the code just above. For them, possessive_quantifier 7787| | is always FALSE at this stage. Note that the repeated item starts at 7788| | tempcode, not at previous, which might be the first part of a string whose 7789| | (former) last char we repeated. */ 7790| | 7791| 265k| if (possessive_quantifier) ------------------ | Branch (7791:9): [True: 11.9k, False: 253k] ------------------ 7792| 11.9k| { 7793| 11.9k| int len; 7794| | 7795| | /* Possessifying an EXACT quantifier has no effect, so we can ignore it. 7796| | However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6}, 7797| | {5,}, or {5,10}). We skip over an EXACT item; if the length of what 7798| | remains is greater than zero, there's a further opcode that can be 7799| | handled. If not, do nothing, leaving the EXACT alone. */ 7800| | 7801| 11.9k| switch(*tempcode) ------------------ | Branch (7801:14): [True: 6.54k, False: 5.40k] ------------------ 7802| 11.9k| { 7803| 598| case OP_TYPEEXACT: ------------------ | Branch (7803:9): [True: 598, False: 11.3k] ------------------ 7804| 598| tempcode += PRIV(OP_lengths)[*tempcode] + ------------------ | | 177| 598|#define PRIV(name) _pcre2_##name ------------------ 7805| 598| ((tempcode[1 + IMM2_SIZE] == OP_PROP ------------------ | | 193| 598|#define IMM2_SIZE 2 ------------------ | Branch (7805:13): [True: 208, False: 390] ------------------ 7806| 598| || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0); ------------------ | | 193| 390|#define IMM2_SIZE 2 ------------------ | Branch (7806:14): [True: 18, False: 372] ------------------ 7807| 598| break; 7808| | 7809| | /* CHAR opcodes are used for exacts whose count is 1. */ 7810| | 7811| 212| case OP_CHAR: ------------------ | Branch (7811:9): [True: 212, False: 11.7k] ------------------ 7812| 412| case OP_CHARI: ------------------ | Branch (7812:9): [True: 200, False: 11.7k] ------------------ 7813| 688| case OP_NOT: ------------------ | Branch (7813:9): [True: 276, False: 11.6k] ------------------ 7814| 928| case OP_NOTI: ------------------ | Branch (7814:9): [True: 240, False: 11.7k] ------------------ 7815| 1.70k| case OP_EXACT: ------------------ | Branch (7815:9): [True: 781, False: 11.1k] ------------------ 7816| 2.00k| case OP_EXACTI: ------------------ | Branch (7816:9): [True: 297, False: 11.6k] ------------------ 7817| 2.86k| case OP_NOTEXACT: ------------------ | Branch (7817:9): [True: 860, False: 11.0k] ------------------ 7818| 3.51k| case OP_NOTEXACTI: ------------------ | Branch (7818:9): [True: 650, False: 11.3k] ------------------ 7819| 3.51k| tempcode += PRIV(OP_lengths)[*tempcode]; ------------------ | | 177| 3.51k|#define PRIV(name) _pcre2_##name ------------------ 7820| 3.51k|#ifdef SUPPORT_UNICODE 7821| 3.51k| if (utf && HAS_EXTRALEN(tempcode[-1])) ------------------ | | 286| 701|#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c) | | ------------------ | | | | 254| 701|#define HASUTF8EXTRALEN(c) ((c) >= 0xc0) | | | | ------------------ | | | | | Branch (254:28): [True: 194, False: 507] | | | | ------------------ | | ------------------ ------------------ | Branch (7821:13): [True: 701, False: 2.81k] ------------------ 7822| 194| tempcode += GET_EXTRALEN(tempcode[-1]); ------------------ | | 291| 194|#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu]) | | ------------------ | | | | 177| 194|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ 7823| 3.51k|#endif 7824| 3.51k| break; 7825| | 7826| | /* For the class opcodes, the repeat operator appears at the end; 7827| | adjust tempcode to point to it. */ 7828| | 7829| 634| case OP_CLASS: ------------------ | Branch (7829:9): [True: 634, False: 11.3k] ------------------ 7830| 1.01k| case OP_NCLASS: ------------------ | Branch (7830:9): [True: 379, False: 11.5k] ------------------ 7831| 1.01k| tempcode += 1 + 32/sizeof(PCRE2_UCHAR); 7832| 1.01k| break; 7833| | 7834| 0|#ifdef SUPPORT_WIDE_CHARS 7835| 277| case OP_XCLASS: ------------------ | Branch (7835:9): [True: 277, False: 11.6k] ------------------ 7836| 277| tempcode += GET(tempcode, 1); ------------------ | | 109| 277| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 7837| 277| break; 7838| 11.9k|#endif 7839| 11.9k| } 7840| | 7841| | /* If tempcode is equal to code (which points to the end of the repeated 7842| | item), it means we have skipped an EXACT item but there is no following 7843| | QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In 7844| | all other cases, tempcode will be pointing to the repeat opcode, and will 7845| | be less than code, so the value of len will be greater than 0. */ 7846| | 7847| 11.9k| len = (int)(code - tempcode); 7848| 11.9k| if (len > 0) ------------------ | Branch (7848:11): [True: 10.2k, False: 1.66k] ------------------ 7849| 10.2k| { 7850| 10.2k| unsigned int repcode = *tempcode; 7851| | 7852| | /* There is a table for possessifying opcodes, all of which are less 7853| | than OP_CALLOUT. A zero entry means there is no possessified version. 7854| | */ 7855| | 7856| 10.2k| if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0) ------------------ | Branch (7856:13): [True: 8.56k, False: 1.72k] | Branch (7856:37): [True: 7.70k, False: 861] ------------------ 7857| 7.70k| *tempcode = opcode_possessify[repcode]; 7858| | 7859| | /* For opcode without a special possessified version, wrap the item in 7860| | ONCE brackets. */ 7861| | 7862| 2.58k| else 7863| 2.58k| { 7864| 2.58k| (void)memmove(tempcode + 1 + LINK_SIZE, tempcode, CU2BYTES(len)); ------------------ | | 165| 2.58k|#define LINK_SIZE 2 ------------------ (void)memmove(tempcode + 1 + LINK_SIZE, tempcode, CU2BYTES(len)); ------------------ | | 545| 2.58k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7865| 2.58k| code += 1 + LINK_SIZE; ------------------ | | 165| 2.58k|#define LINK_SIZE 2 ------------------ 7866| 2.58k| len += 1 + LINK_SIZE; ------------------ | | 165| 2.58k|#define LINK_SIZE 2 ------------------ 7867| 2.58k| tempcode[0] = OP_ONCE; 7868| 2.58k| *code++ = OP_KET; 7869| 2.58k| PUTINC(code, 0, len); ------------------ | | 547| 2.58k|#define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 106| 2.58k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | | | 107| 2.58k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) | | ------------------ | | #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE | | ------------------ | | | | 165| 2.58k|#define LINK_SIZE 2 | | ------------------ ------------------ 7870| 2.58k| PUT(tempcode, 1, len); ------------------ | | 106| 2.58k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 2.58k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7871| 2.58k| } 7872| 10.2k| } 7873| 11.9k| } 7874| | 7875| | /* We set the "follows varying string" flag for subsequently encountered 7876| | reqcus if it isn't already set and we have just passed a varying length 7877| | item. */ 7878| | 7879| 268k| END_REPEAT: 7880| 268k| cb->req_varyopt |= reqvary; 7881| 268k| break; 7882| | 7883| | 7884| | /* ===================================================================*/ 7885| | /* Handle a 32-bit data character with a value greater than META_END. */ 7886| | 7887| 0| case META_BIGVALUE: ------------------ | | 217| 0|#define META_BIGVALUE 0x80050000u /* Next is a literal > META_END */ ------------------ | Branch (7887:5): [True: 0, False: 3.67M] ------------------ 7888| 0| pptr++; 7889| 0| goto NORMAL_CHAR; 7890| | 7891| | 7892| | /* ===============================================================*/ 7893| | /* Handle a back reference by number, which is the meta argument. The 7894| | pattern offsets for back references to group numbers less than 10 are held 7895| | in a special vector, to avoid using more than two parsed pattern elements 7896| | in 64-bit environments. We only need the offset to the first occurrence, 7897| | because if that doesn't fail, subsequent ones will also be OK. */ 7898| | 7899| 15.9k| case META_BACKREF: ------------------ | | 215| 15.9k|#define META_BACKREF 0x80030000u /* Back ref */ ------------------ | Branch (7899:5): [True: 15.9k, False: 3.66M] ------------------ 7900| 15.9k| if (meta_arg < 10) offset = cb->small_ref_offset[meta_arg]; ------------------ | Branch (7900:9): [True: 11.0k, False: 4.92k] ------------------ 7901| 4.92k| else GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 4.92k| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 7902| | 7903| 15.9k| if (meta_arg > cb->bracount) ------------------ | Branch (7903:9): [True: 1.16k, False: 14.8k] ------------------ 7904| 1.16k| { 7905| 1.16k| cb->erroroffset = offset; 7906| 1.16k| *errorcodeptr = ERR15; /* Non-existent subpattern */ 7907| 1.16k| return 0; 7908| 1.16k| } 7909| | 7910| | /* Come here from named backref handling when the reference is to a 7911| | single group (that is, not to a duplicated name). The back reference 7912| | data will have already been updated. We must disable firstcu if not 7913| | set, to cope with cases like (?=(\w+))\1: which would otherwise set ':' 7914| | later. */ 7915| | 7916| 15.3k| HANDLE_SINGLE_REFERENCE: 7917| 15.3k| if (firstcuflags == REQ_UNSET) zerofirstcuflags = firstcuflags = REQ_NONE; ------------------ | | 393| 15.3k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) zerofirstcuflags = firstcuflags = REQ_NONE; ------------------ | | 394| 6.52k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (7917:9): [True: 6.52k, False: 8.87k] ------------------ 7918| 15.3k| *code++ = ((options & PCRE2_CASELESS) != 0)? OP_REFI : OP_REF; ------------------ | | 122| 15.3k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (7918:15): [True: 2.53k, False: 12.8k] ------------------ 7919| 15.3k| PUT2INC(code, 0, meta_arg); ------------------ | | 548| 15.3k|#define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 195| 15.3k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 | | ------------------ | | #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE | | ------------------ | | | | 193| 15.3k|#define IMM2_SIZE 2 | | ------------------ ------------------ 7920| | 7921| | /* Update the map of back references, and keep the highest one. We 7922| | could do this in parse_regex() for numerical back references, but not 7923| | for named back references, because we don't know the numbers to which 7924| | named back references refer. So we do it all in this function. */ 7925| | 7926| 15.3k| cb->backref_map |= (meta_arg < 32)? (1u << meta_arg) : 1; ------------------ | Branch (7926:24): [True: 14.0k, False: 1.33k] ------------------ 7927| 15.3k| if (meta_arg > cb->top_backref) cb->top_backref = meta_arg; ------------------ | Branch (7927:9): [True: 3.74k, False: 11.6k] ------------------ 7928| 15.3k| break; 7929| | 7930| | 7931| | /* ===============================================================*/ 7932| | /* Handle recursion by inserting the number of the called group (which is 7933| | the meta argument) after OP_RECURSE. At the end of compiling the pattern is 7934| | scanned and these numbers are replaced by offsets within the pattern. It is 7935| | done like this to avoid problems with forward references and adjusting 7936| | offsets when groups are duplicated and moved (as discovered in previous 7937| | implementations). Note that a recursion does not have a set first 7938| | character. */ 7939| | 7940| 17.0k| case META_RECURSE: ------------------ | | 244| 17.0k|#define META_RECURSE 0x80200000u /* Recursion */ ------------------ | Branch (7940:5): [True: 17.0k, False: 3.65M] ------------------ 7941| 17.0k| GETPLUSOFFSET(offset, pptr); ------------------ | | 104| 17.0k| { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; } ------------------ 7942| 17.0k| if (meta_arg > cb->bracount) ------------------ | Branch (7942:9): [True: 138, False: 16.9k] ------------------ 7943| 138| { 7944| 138| cb->erroroffset = offset; 7945| 138| *errorcodeptr = ERR15; /* Non-existent subpattern */ 7946| 138| return 0; 7947| 138| } 7948| 17.2k| HANDLE_NUMERICAL_RECURSION: 7949| 17.2k| *code = OP_RECURSE; 7950| 17.2k| PUT(code, 1, meta_arg); ------------------ | | 106| 17.2k| (a[n] = (PCRE2_UCHAR)((d) >> 8)), \ | | 107| 17.2k| (a[(n)+1] = (PCRE2_UCHAR)((d) & 255)) ------------------ 7951| 17.2k| code += 1 + LINK_SIZE; ------------------ | | 165| 17.2k|#define LINK_SIZE 2 ------------------ 7952| 17.2k| groupsetfirstcu = FALSE; ------------------ | | 69| 17.2k|#define FALSE 0 ------------------ 7953| 17.2k| cb->had_recurse = TRUE; ------------------ | | 70| 17.2k|#define TRUE 1 ------------------ 7954| 17.2k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 17.2k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 9.33k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (7954:9): [True: 9.33k, False: 7.88k] ------------------ 7955| 17.2k| zerofirstcu = firstcu; 7956| 17.2k| zerofirstcuflags = firstcuflags; 7957| 17.2k| break; 7958| | 7959| | 7960| | /* ===============================================================*/ 7961| | /* Handle capturing parentheses; the number is the meta argument. */ 7962| | 7963| 680k| case META_CAPTURE: ------------------ | | 220| 680k|#define META_CAPTURE 0x80080000u /* Capturing parenthesis */ ------------------ | Branch (7963:5): [True: 680k, False: 2.99M] ------------------ 7964| 680k| bravalue = OP_CBRA; 7965| 680k| skipunits = IMM2_SIZE; ------------------ | | 193| 680k|#define IMM2_SIZE 2 ------------------ 7966| 680k| PUT2(code, 1+LINK_SIZE, meta_arg); ------------------ | | 195| 680k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 ------------------ 7967| 680k| cb->lastcapture = meta_arg; 7968| 680k| goto GROUP_PROCESS_NOTE_EMPTY; 7969| | 7970| | 7971| | /* ===============================================================*/ 7972| | /* Handle escape sequence items. For ones like \d, the ESC_values are 7973| | arranged to be the same as the corresponding OP_values in the default case 7974| | when PCRE2_UCP is not set (which is the only case in which they will appear 7975| | here). 7976| | 7977| | Note: \Q and \E are never seen here, as they were dealt with in 7978| | parse_pattern(). Neither are numerical back references or recursions, which 7979| | were turned into META_BACKREF or META_RECURSE items, respectively. \k and 7980| | \g, when followed by names, are turned into META_BACKREF_BYNAME or 7981| | META_RECURSE_BYNAME. */ 7982| | 7983| 111k| case META_ESCAPE: ------------------ | | 236| 111k|#define META_ESCAPE 0x80180000u /* \d and friends */ ------------------ | Branch (7983:5): [True: 111k, False: 3.56M] ------------------ 7984| | 7985| | /* We can test for escape sequences that consume a character because their 7986| | values lie between ESC_b and ESC_Z; this may have to change if any new ones 7987| | are ever created. For these sequences, we disable the setting of a first 7988| | character if it hasn't already been set. */ 7989| | 7990| 111k| if (meta_arg > ESC_b && meta_arg < ESC_Z) ------------------ | Branch (7990:9): [True: 99.2k, False: 11.8k] | Branch (7990:29): [True: 96.7k, False: 2.44k] ------------------ 7991| 96.7k| { 7992| 96.7k| matched_char = TRUE; ------------------ | | 70| 96.7k|#define TRUE 1 ------------------ 7993| 96.7k| if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 393| 96.7k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE; ------------------ | | 394| 48.7k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (7993:11): [True: 48.7k, False: 48.0k] ------------------ 7994| 96.7k| } 7995| | 7996| | /* Set values to reset to if this is followed by a zero repeat. */ 7997| | 7998| 111k| zerofirstcu = firstcu; 7999| 111k| zerofirstcuflags = firstcuflags; 8000| 111k| zeroreqcu = reqcu; 8001| 111k| zeroreqcuflags = reqcuflags; 8002| | 8003| | /* If Unicode is not supported, \P and \p are not allowed and are 8004| | faulted at parse time, so will never appear here. */ 8005| | 8006| 111k|#ifdef SUPPORT_UNICODE 8007| 111k| if (meta_arg == ESC_P || meta_arg == ESC_p) ------------------ | Branch (8007:9): [True: 16.9k, False: 94.2k] | Branch (8007:30): [True: 11.2k, False: 82.9k] ------------------ 8008| 28.1k| { 8009| 28.1k| uint32_t ptype = *(++pptr) >> 16; 8010| 28.1k| uint32_t pdata = *pptr & 0xffff; 8011| | 8012| | /* The special case of \p{Any} is compiled to OP_ALLANY so as to benefit 8013| | from the auto-anchoring code. */ 8014| | 8015| 28.1k| if (meta_arg == ESC_p && ptype == PT_ANY) ------------------ | | 1275| 11.2k|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (8015:11): [True: 11.2k, False: 16.9k] | Branch (8015:32): [True: 214, False: 11.0k] ------------------ 8016| 214| { 8017| 214| *code++ = OP_ALLANY; 8018| 214| } 8019| 27.9k| else 8020| 27.9k| { 8021| 27.9k| *code++ = (meta_arg == ESC_p)? OP_PROP : OP_NOTPROP; ------------------ | Branch (8021:19): [True: 11.0k, False: 16.9k] ------------------ 8022| 27.9k| *code++ = ptype; 8023| 27.9k| *code++ = pdata; 8024| 27.9k| } 8025| 28.1k| break; /* End META_ESCAPE */ 8026| 28.1k| } 8027| 82.9k|#endif 8028| | 8029| | /* \K is forbidden in lookarounds since 10.38 because that's what Perl has 8030| | done. However, there's an option, in case anyone was relying on it. */ 8031| | 8032| 82.9k| if (cb->assert_depth > 0 && meta_arg == ESC_K && ------------------ | Branch (8032:9): [True: 2.51k, False: 80.4k] | Branch (8032:33): [True: 7, False: 2.51k] ------------------ 8033| 82.9k| (xoptions & PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK) == 0) ------------------ | | 155| 7|#define PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK 0x00000040u /* C */ ------------------ | Branch (8033:9): [True: 7, False: 0] ------------------ 8034| 7| { 8035| 7| *errorcodeptr = ERR99; 8036| 7| return 0; 8037| 7| } 8038| | 8039| | /* For the rest (including \X when Unicode is supported - if not it's 8040| | faulted at parse time), the OP value is the escape value when PCRE2_UCP is 8041| | not set; if it is set, most of them do not show up here because they are 8042| | converted into Unicode property tests in parse_regex(). 8043| | 8044| | In non-UTF mode, and for both 32-bit modes, we turn \C into OP_ALLANY 8045| | instead of OP_ANYBYTE so that it works in DFA mode and in lookbehinds. 8046| | There are special UCP codes for \B and \b which are used in UCP mode unless 8047| | "word" matching is being forced to ASCII. 8048| | 8049| | Note that \b and \B do a one-character lookbehind, and \A also behaves as 8050| | if it does. */ 8051| | 8052| 82.9k| switch(meta_arg) ------------------ | Branch (8052:12): [True: 71.8k, False: 11.1k] ------------------ 8053| 82.9k| { 8054| 0| case ESC_C: ------------------ | Branch (8054:7): [True: 0, False: 82.9k] ------------------ 8055| 0| cb->external_flags |= PCRE2_HASBKC; /* Record */ ------------------ | | 529| 0|#define PCRE2_HASBKC 0x00400000 /* contains \C */ ------------------ 8056| |#if PCRE2_CODE_UNIT_WIDTH == 32 8057| | meta_arg = OP_ALLANY; 8058| |#else 8059| 0| if (!utf) meta_arg = OP_ALLANY; ------------------ | Branch (8059:11): [True: 0, False: 0] ------------------ 8060| 0|#endif 8061| 0| break; 8062| | 8063| 3.72k| case ESC_B: ------------------ | Branch (8063:7): [True: 3.72k, False: 79.2k] ------------------ 8064| 9.24k| case ESC_b: ------------------ | Branch (8064:7): [True: 5.52k, False: 77.4k] ------------------ 8065| 9.24k| if ((options & PCRE2_UCP) != 0 && (xoptions & PCRE2_EXTRA_ASCII_BSW) == 0) ------------------ | | 136| 9.24k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ if ((options & PCRE2_UCP) != 0 && (xoptions & PCRE2_EXTRA_ASCII_BSW) == 0) ------------------ | | 159| 3.24k|#define PCRE2_EXTRA_ASCII_BSW 0x00000400u /* C */ ------------------ | Branch (8065:11): [True: 3.24k, False: 6.00k] | Branch (8065:41): [True: 3.04k, False: 194] ------------------ 8066| 3.04k| meta_arg = (meta_arg == ESC_B)? OP_NOT_UCP_WORD_BOUNDARY : ------------------ | Branch (8066:20): [True: 1.19k, False: 1.85k] ------------------ 8067| 3.04k| OP_UCP_WORD_BOUNDARY; 8068| | /* Fall through */ 8069| | 8070| 11.1k| case ESC_A: ------------------ | Branch (8070:7): [True: 1.87k, False: 81.0k] ------------------ 8071| 11.1k| if (cb->max_lookbehind == 0) cb->max_lookbehind = 1; ------------------ | Branch (8071:11): [True: 1.84k, False: 9.26k] ------------------ 8072| 11.1k| break; 8073| 82.9k| } 8074| | 8075| 82.9k| *code++ = meta_arg; 8076| 82.9k| break; /* End META_ESCAPE */ 8077| | 8078| | 8079| | /* ===================================================================*/ 8080| | /* Handle an unrecognized meta value. A parsed pattern value less than 8081| | META_END is a literal. Otherwise we have a problem. */ 8082| | 8083| 1.13M| default: ------------------ | Branch (8083:5): [True: 1.13M, False: 2.54M] ------------------ 8084| 1.13M| if (meta >= META_END) ------------------ | | 211| 1.13M|#define META_END 0x80000000u /* End of pattern */ ------------------ | Branch (8084:9): [True: 0, False: 1.13M] ------------------ 8085| 0| { 8086| |#ifdef DEBUG_SHOW_PARSED 8087| | fprintf(stderr, "** Unrecognized parsed pattern item 0x%.8x\n", *pptr); 8088| |#endif 8089| 0| *errorcodeptr = ERR89; /* Internal error - unrecognized. */ 8090| 0| return 0; 8091| 0| } 8092| | 8093| | /* Handle a literal character. We come here by goto in the case of a 8094| | 32-bit, non-UTF character whose value is greater than META_END. */ 8095| | 8096| 1.13M| NORMAL_CHAR: 8097| 1.13M| meta = *pptr; /* Get the full 32 bits */ 8098| 1.13M| NORMAL_CHAR_SET: /* Character is already in meta */ 8099| 1.13M| matched_char = TRUE; ------------------ | | 70| 1.13M|#define TRUE 1 ------------------ 8100| | 8101| | /* For caseless UTF or UCP mode, check whether this character has more than 8102| | one other case. If so, generate a special OP_PROP item instead of OP_CHARI. 8103| | When casing restrictions apply, ignore caseless sets that start with an 8104| | ASCII character. */ 8105| | 8106| 1.13M|#ifdef SUPPORT_UNICODE 8107| 1.13M| if ((utf||ucp) && (options & PCRE2_CASELESS) != 0) ------------------ | | 122| 239k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (8107:10): [True: 105k, False: 1.03M] | Branch (8107:15): [True: 133k, False: 898k] | Branch (8107:23): [True: 117k, False: 121k] ------------------ 8108| 117k| { 8109| 117k| uint32_t caseset = UCD_CASESET(meta); ------------------ | | 1861| 117k|#define UCD_CASESET(ch) GET_UCD(ch)->caseset | | ------------------ | | | | 1846| 117k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 117k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 117k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 117k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 117k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 117k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 117k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 117k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 117k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 117k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8110| 117k| if (caseset != 0 && ------------------ | Branch (8110:11): [True: 4.35k, False: 113k] ------------------ 8111| 117k| ((xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) == 0 || ------------------ | | 156| 4.35k|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ ------------------ | Branch (8111:13): [True: 3.95k, False: 400] ------------------ 8112| 4.35k| PRIV(ucd_caseless_sets)[caseset] > 127)) ------------------ | | 177| 400|#define PRIV(name) _pcre2_##name ------------------ | Branch (8112:12): [True: 198, False: 202] ------------------ 8113| 4.15k| { 8114| 4.15k| *code++ = OP_PROP; 8115| 4.15k| *code++ = PT_CLIST; ------------------ | | 1285| 4.15k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ 8116| 4.15k| *code++ = caseset; 8117| 4.15k| if (firstcuflags == REQ_UNSET) ------------------ | | 393| 4.15k|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ | Branch (8117:13): [True: 1.35k, False: 2.80k] ------------------ 8118| 1.35k| firstcuflags = zerofirstcuflags = REQ_NONE; ------------------ | | 394| 1.35k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 8119| 4.15k| break; /* End handling this meta item */ 8120| 4.15k| } 8121| 117k| } 8122| 1.13M|#endif 8123| | 8124| | /* Caseful matches, or caseless and not one of the multicase characters. We 8125| | come here by goto in the case of a positive class that contains only 8126| | case-partners of a character with just two cases; matched_char has already 8127| | been set TRUE and options fudged if necessary. */ 8128| | 8129| 1.13M| CLASS_CASELESS_CHAR: 8130| | 8131| | /* Get the character's code units into mcbuffer, with the length in 8132| | mclength. When not in UTF mode, the length is always 1. */ 8133| | 8134| 1.13M|#ifdef SUPPORT_UNICODE 8135| 1.13M| if (utf) mclength = PRIV(ord2utf)(meta, mcbuffer); else ------------------ | | 177| 103k|#define PRIV(name) _pcre2_##name ------------------ | Branch (8135:9): [True: 103k, False: 1.03M] ------------------ 8136| 1.03M|#endif 8137| 1.03M| { 8138| 1.03M| mclength = 1; 8139| 1.03M| mcbuffer[0] = meta; 8140| 1.03M| } 8141| | 8142| | /* Generate the appropriate code */ 8143| | 8144| 1.13M| *code++ = ((options & PCRE2_CASELESS) != 0)? OP_CHARI : OP_CHAR; ------------------ | | 122| 1.13M|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (8144:15): [True: 138k, False: 995k] ------------------ 8145| 1.13M| memcpy(code, mcbuffer, CU2BYTES(mclength)); ------------------ | | 545| 1.13M|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 8146| 1.13M| code += mclength; 8147| | 8148| | /* Remember if \r or \n were seen */ 8149| | 8150| 1.13M| if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL) ------------------ | | 972| 2.26M|#define CHAR_CR '\015' ------------------ if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL) ------------------ | | 974| 1.12M|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 1.12M|#define CHAR_LF '\012' | | ------------------ ------------------ | Branch (8150:9): [True: 8.64k, False: 1.12M] | Branch (8150:35): [True: 9.33k, False: 1.11M] ------------------ 8151| 17.9k| cb->external_flags |= PCRE2_HASCRORLF; ------------------ | | 518| 17.9k|#define PCRE2_HASCRORLF 0x00000800 /* explicit \r or \n in pattern */ ------------------ 8152| | 8153| | /* Set the first and required code units appropriately. If no previous 8154| | first code unit, set it from this character, but revert to none on a zero 8155| | repeat. Otherwise, leave the firstcu value alone, and don't change it on 8156| | a zero repeat. */ 8157| | 8158| 1.13M| if (firstcuflags == REQ_UNSET) ------------------ | | 393| 1.13M|#define REQ_UNSET 0xffffffffu /* Not yet found anything */ ------------------ | Branch (8158:9): [True: 88.0k, False: 1.04M] ------------------ 8159| 88.0k| { 8160| 88.0k| zerofirstcuflags = REQ_NONE; ------------------ | | 394| 88.0k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 8161| 88.0k| zeroreqcu = reqcu; 8162| 88.0k| zeroreqcuflags = reqcuflags; 8163| | 8164| | /* If the character is more than one code unit long, we can set a single 8165| | firstcu only if it is not to be matched caselessly. Multiple possible 8166| | starting code units may be picked up later in the studying code. */ 8167| | 8168| 88.0k| if (mclength == 1 || req_caseopt == 0) ------------------ | Branch (8168:11): [True: 82.5k, False: 5.57k] | Branch (8168:28): [True: 3.15k, False: 2.42k] ------------------ 8169| 85.6k| { 8170| 85.6k| firstcu = mcbuffer[0]; 8171| 85.6k| firstcuflags = req_caseopt; 8172| 85.6k| if (mclength != 1) ------------------ | Branch (8172:13): [True: 3.15k, False: 82.5k] ------------------ 8173| 3.15k| { 8174| 3.15k| reqcu = code[-1]; 8175| 3.15k| reqcuflags = cb->req_varyopt; 8176| 3.15k| } 8177| 85.6k| } 8178| 2.42k| else firstcuflags = reqcuflags = REQ_NONE; ------------------ | | 394| 2.42k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 8179| 88.0k| } 8180| | 8181| | /* firstcu was previously set; we can set reqcu only if the length is 8182| | 1 or the matching is caseful. */ 8183| | 8184| 1.04M| else 8185| 1.04M| { 8186| 1.04M| zerofirstcu = firstcu; 8187| 1.04M| zerofirstcuflags = firstcuflags; 8188| 1.04M| zeroreqcu = reqcu; 8189| 1.04M| zeroreqcuflags = reqcuflags; 8190| 1.04M| if (mclength == 1 || req_caseopt == 0) ------------------ | Branch (8190:11): [True: 1.02M, False: 18.3k] | Branch (8190:28): [True: 7.44k, False: 10.9k] ------------------ 8191| 1.03M| { 8192| 1.03M| reqcu = code[-1]; 8193| 1.03M| reqcuflags = req_caseopt | cb->req_varyopt; 8194| 1.03M| } 8195| 1.04M| } 8196| | 8197| | /* If caselessness was temporarily instated, reset it. */ 8198| | 8199| 1.13M| if (reset_caseful) ------------------ | Branch (8199:9): [True: 334, False: 1.13M] ------------------ 8200| 334| { 8201| 334| options &= ~PCRE2_CASELESS; ------------------ | | 122| 334|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ 8202| 334| req_caseopt = 0; 8203| 334| reset_caseful = FALSE; ------------------ | | 69| 334|#define FALSE 0 ------------------ 8204| 334| } 8205| | 8206| 1.13M| break; /* End literal character handling */ 8207| 3.67M| } /* End of big switch */ 8208| 3.67M| } /* End of big loop */ 8209| | 8210| |/* Control never reaches here. */ 8211| 935k|} pcre2_compile.c:add_list_to_class: 5346| 1.11k|{ 5347| 1.11k|unsigned int n8 = 0; 5348| 8.56k|while (p[0] < NOTACHAR) ------------------ | | 205| 8.56k|#define NOTACHAR 0xffffffff ------------------ | Branch (5348:8): [True: 7.44k, False: 1.11k] ------------------ 5349| 7.44k| { 5350| 7.44k| unsigned int n = 0; 5351| 7.44k| if (p[0] != except) ------------------ | Branch (5351:7): [True: 7.44k, False: 0] ------------------ 5352| 7.44k| { 5353| 16.0k| while(p[n+1] == p[0] + n + 1) n++; ------------------ | Branch (5353:11): [True: 8.56k, False: 7.44k] ------------------ 5354| 7.44k| cb->class_range_start = p[0]; 5355| 7.44k| cb->class_range_end = p[n]; 5356| 7.44k| n8 += add_to_class_internal(classbits, uchardptr, options, xoptions, cb, 5357| 7.44k| p[0], p[n]); 5358| 7.44k| } 5359| 7.44k| p += n + 1; 5360| 7.44k| } 5361| 1.11k|return n8; 5362| 1.11k|} pcre2_compile.c:add_to_class_internal: 5107| 484k|{ 5108| 484k|uint32_t c; 5109| 484k|uint32_t classbits_end = (end <= 0xff ? end : 0xff); ------------------ | Branch (5109:27): [True: 444k, False: 40.2k] ------------------ 5110| 484k|unsigned int n8 = 0; 5111| | 5112| |/* If caseless matching is required, scan the range and process alternate 5113| |cases. In Unicode, there are 8-bit characters that have alternate cases that 5114| |are greater than 255 and vice-versa (though these may be ignored if caseless 5115| |restriction is in force). Sometimes we can just extend the original range. */ 5116| | 5117| 484k|if ((options & PCRE2_CASELESS) != 0) ------------------ | | 122| 484k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ | Branch (5117:5): [True: 63.3k, False: 421k] ------------------ 5118| 63.3k| { 5119| 63.3k|#ifdef SUPPORT_UNICODE 5120| 63.3k| if ((options & (PCRE2_UTF|PCRE2_UCP)) != 0) ------------------ | | 138| 63.3k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ if ((options & (PCRE2_UTF|PCRE2_UCP)) != 0) ------------------ | | 136| 63.3k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (5120:7): [True: 53.8k, False: 9.48k] ------------------ 5121| 53.8k| { 5122| 53.8k| int rc; 5123| 53.8k| uint32_t oc, od; 5124| | 5125| 53.8k| options &= ~PCRE2_CASELESS; /* Remove for recursive calls */ ------------------ | | 122| 53.8k|#define PCRE2_CASELESS 0x00000008u /* C */ ------------------ 5126| 53.8k| c = start; 5127| | 5128| 172k| while ((rc = get_othercase_range(&c, end, &oc, &od, ------------------ | Branch (5128:12): [True: 119k, False: 53.8k] ------------------ 5129| 172k| (xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0)) >= 0) ------------------ | | 156| 172k|#define PCRE2_EXTRA_CASELESS_RESTRICT 0x00000080u /* C */ ------------------ 5130| 119k| { 5131| | /* Handle a single character that has more than one other case. */ 5132| | 5133| 119k| if (rc > 0) n8 += add_list_to_class_internal(classbits, uchardptr, ------------------ | Branch (5133:11): [True: 10.9k, False: 108k] ------------------ 5134| 10.9k| options, xoptions, cb, PRIV(ucd_caseless_sets) + rc, oc); ------------------ | | 177| 10.9k|#define PRIV(name) _pcre2_##name ------------------ 5135| | 5136| | /* Do nothing if the other case range is within the original range. */ 5137| | 5138| 108k| else if (oc >= cb->class_range_start && od <= cb->class_range_end) ------------------ | Branch (5138:16): [True: 103k, False: 4.57k] | Branch (5138:47): [True: 90.6k, False: 12.8k] ------------------ 5139| 90.6k| continue; 5140| | 5141| | /* Extend the original range if there is overlap, noting that if oc < c, 5142| | we can't have od > end because a subrange is always shorter than the 5143| | basic range. Otherwise, use a recursive call to add the additional range. 5144| | */ 5145| | 5146| 17.4k| else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */ ------------------ | Branch (5146:16): [True: 4.57k, False: 12.8k] | Branch (5146:30): [True: 321, False: 4.25k] ------------------ 5147| 17.1k| else if (od > end && oc <= end + 1) ------------------ | Branch (5147:16): [True: 12.8k, False: 4.25k] | Branch (5147:28): [True: 672, False: 12.2k] ------------------ 5148| 672| { 5149| 672| end = od; /* Extend upwards */ 5150| 672| if (end > classbits_end) classbits_end = (end <= 0xff ? end : 0xff); ------------------ | Branch (5150:13): [True: 672, False: 0] | Branch (5150:51): [True: 289, False: 383] ------------------ 5151| 672| } 5152| 16.4k| else n8 += add_to_class_internal(classbits, uchardptr, options, xoptions, 5153| 16.4k| cb, oc, od); 5154| 119k| } 5155| 53.8k| } 5156| 9.48k| else 5157| 9.48k|#endif /* SUPPORT_UNICODE */ 5158| | 5159| | /* Not UTF mode */ 5160| | 5161| 24.0k| for (c = start; c <= classbits_end; c++) ------------------ | Branch (5161:19): [True: 14.5k, False: 9.48k] ------------------ 5162| 14.5k| { 5163| 14.5k| SETBIT(classbits, cb->fcc[c]); ------------------ | | 386| 14.5k|#define SETBIT(a,b) a[(b)/8] = (uint8_t)(a[(b)/8] | (1u << ((b)&7))) ------------------ 5164| 14.5k| n8++; 5165| 14.5k| } 5166| 63.3k| } 5167| | 5168| |/* Now handle the originally supplied range. Adjust the final value according 5169| |to the bit length - this means that the same lists of (e.g.) horizontal spaces 5170| |can be used in all cases. */ 5171| | 5172| 484k|if ((options & PCRE2_UTF) == 0 && end > MAX_NON_UTF_CHAR) ------------------ | | 138| 484k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ if ((options & PCRE2_UTF) == 0 && end > MAX_NON_UTF_CHAR) ------------------ | | 1900| 428k|#define MAX_NON_UTF_CHAR (0xffffffffU >> (32 - PCRE2_CODE_UNIT_WIDTH)) ------------------ | Branch (5172:5): [True: 428k, False: 56.5k] | Branch (5172:35): [True: 17.2k, False: 410k] ------------------ 5173| 17.2k| end = MAX_NON_UTF_CHAR; ------------------ | | 1900| 17.2k|#define MAX_NON_UTF_CHAR (0xffffffffU >> (32 - PCRE2_CODE_UNIT_WIDTH)) ------------------ 5174| | 5175| 484k|if (start > cb->class_range_start && end < cb->class_range_end) return n8; ------------------ | Branch (5175:5): [True: 31.6k, False: 452k] | Branch (5175:38): [True: 12.8k, False: 18.7k] ------------------ 5176| | 5177| |/* Use the bitmap for characters < 256. Otherwise use extra data.*/ 5178| | 5179| 1.56M|for (c = start; c <= classbits_end; c++) ------------------ | Branch (5179:17): [True: 1.08M, False: 471k] ------------------ 5180| 1.08M| { 5181| | /* Regardless of start, c will always be <= 255. */ 5182| 1.08M| SETBIT(classbits, c); ------------------ | | 386| 1.08M|#define SETBIT(a,b) a[(b)/8] = (uint8_t)(a[(b)/8] | (1u << ((b)&7))) ------------------ 5183| 1.08M| n8++; 5184| 1.08M| } 5185| | 5186| 471k|#ifdef SUPPORT_WIDE_CHARS 5187| 471k|if (start <= 0xff) start = 0xff + 1; ------------------ | Branch (5187:5): [True: 444k, False: 27.4k] ------------------ 5188| | 5189| 471k|if (end >= start) ------------------ | Branch (5189:5): [True: 12.2k, False: 459k] ------------------ 5190| 12.2k| { 5191| 12.2k| PCRE2_UCHAR *uchardata = *uchardptr; ------------------ | | 813| 12.2k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 12.2k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 12.2k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 12.2k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5192| | 5193| 12.2k|#ifdef SUPPORT_UNICODE 5194| 12.2k| if ((options & PCRE2_UTF) != 0) ------------------ | | 138| 12.2k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ | Branch (5194:7): [True: 12.2k, False: 0] ------------------ 5195| 12.2k| { 5196| 12.2k| if (start < end) ------------------ | Branch (5196:9): [True: 5.36k, False: 6.86k] ------------------ 5197| 5.36k| { 5198| 5.36k| *uchardata++ = XCL_RANGE; ------------------ | | 1315| 5.36k|#define XCL_RANGE 2 /* A range (two multibyte chars) follows */ ------------------ 5199| 5.36k| uchardata += PRIV(ord2utf)(start, uchardata); ------------------ | | 177| 5.36k|#define PRIV(name) _pcre2_##name ------------------ 5200| 5.36k| uchardata += PRIV(ord2utf)(end, uchardata); ------------------ | | 177| 5.36k|#define PRIV(name) _pcre2_##name ------------------ 5201| 5.36k| } 5202| 6.86k| else if (start == end) ------------------ | Branch (5202:14): [True: 6.86k, False: 0] ------------------ 5203| 6.86k| { 5204| 6.86k| *uchardata++ = XCL_SINGLE; ------------------ | | 1314| 6.86k|#define XCL_SINGLE 1 /* Single item (one multibyte char) follows */ ------------------ 5205| 6.86k| uchardata += PRIV(ord2utf)(start, uchardata); ------------------ | | 177| 6.86k|#define PRIV(name) _pcre2_##name ------------------ 5206| 6.86k| } 5207| 12.2k| } 5208| 0| else 5209| 0|#endif /* SUPPORT_UNICODE */ 5210| | 5211| | /* Without UTF support, character values are constrained by the bit length, 5212| | and can only be > 256 for 16-bit and 32-bit libraries. */ 5213| | 5214| 0|#if PCRE2_CODE_UNIT_WIDTH == 8 5215| 0| {} 5216| |#else 5217| | if (start < end) 5218| | { 5219| | *uchardata++ = XCL_RANGE; 5220| | *uchardata++ = start; 5221| | *uchardata++ = end; 5222| | } 5223| | else if (start == end) 5224| | { 5225| | *uchardata++ = XCL_SINGLE; 5226| | *uchardata++ = start; 5227| | } 5228| |#endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 5229| 12.2k| *uchardptr = uchardata; /* Updata extra data pointer */ 5230| 12.2k| } 5231| |#else /* SUPPORT_WIDE_CHARS */ 5232| | (void)uchardptr; /* Avoid compiler warning */ 5233| |#endif /* SUPPORT_WIDE_CHARS */ 5234| | 5235| 471k|return n8; /* Number of 8-bit characters */ 5236| 484k|} pcre2_compile.c:get_othercase_range: 5030| 172k|{ 5031| 172k|uint32_t c, othercase, next; 5032| 172k|unsigned int co; 5033| | 5034| |/* Find the first character that has an other case. If it has multiple other 5035| |cases, return its case offset value. When CASELESS_RESTRICT is set, ignore the 5036| |multi-case entries that begin with ASCII values. */ 5037| | 5038| 14.8M|for (c = *cptr; c <= d; c++) ------------------ | Branch (5038:17): [True: 14.8M, False: 53.8k] ------------------ 5039| 14.8M| { 5040| 14.8M| if ((co = UCD_CASESET(c)) != 0 && ------------------ | | 1861| 14.8M|#define UCD_CASESET(ch) GET_UCD(ch)->caseset | | ------------------ | | | | 1846| 14.8M|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 14.8M|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 14.8M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 14.8M| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 14.8M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 14.8M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 14.8M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 14.8M| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 14.8M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 14.8M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5040:7): [True: 11.2k, False: 14.7M] ------------------ 5041| 14.8M| (!restricted || PRIV(ucd_caseless_sets)[co] > 127)) ------------------ | | 177| 696|#define PRIV(name) _pcre2_##name ------------------ | Branch (5041:8): [True: 10.5k, False: 696] | Branch (5041:23): [True: 404, False: 292] ------------------ 5042| 10.9k| { 5043| 10.9k| *ocptr = c++; /* Character that has the set */ 5044| 10.9k| *cptr = c; /* Rest of input range */ 5045| 10.9k| return (int)co; 5046| 10.9k| } 5047| | 5048| | /* This is not a valid multiple-case character. Check that the single other 5049| | case is different to the original. We don't need to check "restricted" here 5050| | because the non-ASCII characters with multiple cases that include an ASCII 5051| | character don't have a different "othercase". */ 5052| | 5053| 14.7M| if ((othercase = UCD_OTHERCASE(c)) != c) break; ------------------ | | 1862| 14.7M|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 14.7M|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 14.7M|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 14.7M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 14.7M| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 14.7M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 14.7M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 14.7M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 14.7M| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 14.7M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 14.7M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5053:7): [True: 108k, False: 14.6M] ------------------ 5054| 14.7M| } 5055| | 5056| 161k|if (c > d) return -1; /* Reached end of range */ ------------------ | Branch (5056:5): [True: 53.8k, False: 108k] ------------------ 5057| | 5058| |/* Found a character that has a single other case. Search for the end of the 5059| |range, which is either the end of the input range, or a character that has zero 5060| |or more than one other cases. */ 5061| | 5062| 108k|*ocptr = othercase; 5063| 108k|next = othercase + 1; 5064| | 5065| 195k|for (++c; c <= d; c++) ------------------ | Branch (5065:11): [True: 179k, False: 15.4k] ------------------ 5066| 179k| { 5067| 179k| if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break; ------------------ | | 1861| 179k|#define UCD_CASESET(ch) GET_UCD(ch)->caseset | | ------------------ | | | | 1846| 179k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 179k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 179k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 179k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 179k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 179k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 179k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 179k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 179k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 179k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break; ------------------ | | 1862| 174k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 174k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 174k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 174k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 174k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 174k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 174k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 174k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 174k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 174k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 174k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5067:7): [True: 4.83k, False: 174k] | Branch (5067:37): [True: 87.8k, False: 87.0k] ------------------ 5068| 87.0k| next++; 5069| 87.0k| } 5070| | 5071| 108k|*odptr = next - 1; /* End of othercase range */ 5072| 108k|*cptr = c; /* Rest of input range */ 5073| 108k|return 0; 5074| 161k|} pcre2_compile.c:add_list_to_class_internal: 5268| 10.9k|{ 5269| 10.9k|unsigned int n8 = 0; 5270| 41.9k|while (p[0] < NOTACHAR) ------------------ | | 205| 41.9k|#define NOTACHAR 0xffffffff ------------------ | Branch (5270:8): [True: 31.0k, False: 10.9k] ------------------ 5271| 31.0k| { 5272| 31.0k| unsigned int n = 0; 5273| 31.0k| if (p[0] != except) ------------------ | Branch (5273:7): [True: 21.2k, False: 9.82k] ------------------ 5274| 21.2k| { 5275| 23.9k| while(p[n+1] == p[0] + n + 1) n++; ------------------ | Branch (5275:11): [True: 2.72k, False: 21.2k] ------------------ 5276| 21.2k| n8 += add_to_class_internal(classbits, uchardptr, options, xoptions, cb, 5277| 21.2k| p[0], p[n]); 5278| 21.2k| } 5279| 31.0k| p += n + 1; 5280| 31.0k| } 5281| 10.9k|return n8; 5282| 10.9k|} pcre2_compile.c:add_not_list_to_class: 5388| 1.78k|{ 5389| 1.78k|BOOL utf = (options & PCRE2_UTF) != 0; ------------------ | | 138| 1.78k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 5390| 1.78k|unsigned int n8 = 0; 5391| 1.78k|if (p[0] > 0) ------------------ | Branch (5391:5): [True: 1.78k, False: 0] ------------------ 5392| 1.78k| n8 += add_to_class(classbits, uchardptr, options, xoptions, cb, 0, p[0] - 1); 5393| 14.1k|while (p[0] < NOTACHAR) ------------------ | | 205| 14.1k|#define NOTACHAR 0xffffffff ------------------ | Branch (5393:8): [True: 12.3k, False: 1.78k] ------------------ 5394| 12.3k| { 5395| 26.5k| while (p[1] == p[0] + 1) p++; ------------------ | Branch (5395:10): [True: 14.1k, False: 12.3k] ------------------ 5396| 12.3k| n8 += add_to_class(classbits, uchardptr, options, xoptions, cb, p[0] + 1, 5397| 12.3k| (p[1] == NOTACHAR) ? (utf ? 0x10ffffu : 0xffffffffu) : p[1] - 1); ------------------ | | 205| 12.3k|#define NOTACHAR 0xffffffff ------------------ | Branch (5397:5): [True: 1.78k, False: 10.5k] | Branch (5397:27): [True: 754, False: 1.03k] ------------------ 5398| 12.3k| p++; 5399| 12.3k| } 5400| 1.78k|return n8; 5401| 1.78k|} pcre2_compile.c:add_to_class: 5310| 439k|{ 5311| 439k|cb->class_range_start = start; 5312| 439k|cb->class_range_end = end; 5313| 439k|return add_to_class_internal(classbits, uchardptr, options, xoptions, cb, 5314| 439k| start, end); 5315| 439k|} pcre2_compile.c:find_dupname_details: 5427| 2.11k|{ 5428| 2.11k|uint32_t i, groupnumber; 5429| 2.11k|int count; 5430| 2.11k|PCRE2_UCHAR *slot = cb->name_table; ------------------ | | 813| 2.11k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 2.11k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 2.11k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 2.11k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5431| | 5432| |/* Find the first entry in the table */ 5433| | 5434| 2.67k|for (i = 0; i < cb->names_found; i++) ------------------ | Branch (5434:13): [True: 2.67k, False: 0] ------------------ 5435| 2.67k| { 5436| 2.67k| if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) == 0 && ------------------ | | 177| 2.67k|#define PRIV(name) _pcre2_##name ------------------ if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) == 0 && ------------------ | | 193| 2.67k|#define IMM2_SIZE 2 ------------------ | Branch (5436:7): [True: 2.11k, False: 562] ------------------ 5437| 2.67k| slot[IMM2_SIZE+length] == 0) break; ------------------ | | 193| 2.11k|#define IMM2_SIZE 2 ------------------ | Branch (5437:7): [True: 2.11k, False: 0] ------------------ 5438| 562| slot += cb->name_entry_size; 5439| 562| } 5440| | 5441| |/* This should not occur, because this function is called only when we know we 5442| |have duplicate names. Give an internal error. */ 5443| | 5444| 2.11k|if (i >= cb->names_found) ------------------ | Branch (5444:5): [True: 0, False: 2.11k] ------------------ 5445| 0| { 5446| 0| *errorcodeptr = ERR53; 5447| 0| cb->erroroffset = name - cb->start_pattern; 5448| 0| return FALSE; ------------------ | | 69| 0|#define FALSE 0 ------------------ 5449| 0| } 5450| | 5451| |/* Record the index and then see how many duplicates there are, updating the 5452| |backref map and maximum back reference as we do. */ 5453| | 5454| 2.11k|*indexptr = i; 5455| 2.11k|count = 0; 5456| | 5457| 2.11k|for (;;) 5458| 213k| { 5459| 213k| count++; 5460| 213k| groupnumber = GET2(slot,0); ------------------ | | 194| 213k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5461| 213k| cb->backref_map |= (groupnumber < 32)? (1u << groupnumber) : 1; ------------------ | Branch (5461:22): [True: 11.4k, False: 202k] ------------------ 5462| 213k| if (groupnumber > cb->top_backref) cb->top_backref = groupnumber; ------------------ | Branch (5462:7): [True: 522, False: 213k] ------------------ 5463| 213k| if (++i >= cb->names_found) break; ------------------ | Branch (5463:7): [True: 1.53k, False: 212k] ------------------ 5464| 212k| slot += cb->name_entry_size; 5465| 212k| if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) != 0 || ------------------ | | 177| 212k|#define PRIV(name) _pcre2_##name ------------------ if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) != 0 || ------------------ | | 193| 212k|#define IMM2_SIZE 2 ------------------ | Branch (5465:7): [True: 230, False: 211k] ------------------ 5466| 212k| (slot+IMM2_SIZE)[length] != 0) break; ------------------ | | 193| 211k|#define IMM2_SIZE 2 ------------------ | Branch (5466:5): [True: 351, False: 211k] ------------------ 5467| 212k| } 5468| | 5469| 2.11k|*countptr = count; 5470| 2.11k|return TRUE; ------------------ | | 70| 2.11k|#define TRUE 1 ------------------ 5471| 2.11k|} pcre2_compile.c:add_name_to_table: 9034| 6.37k|{ 9035| 6.37k|uint32_t i; 9036| 6.37k|PCRE2_UCHAR *slot = cb->name_table; ------------------ | | 813| 6.37k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 6.37k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 6.37k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 6.37k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 9037| | 9038| 2.46M|for (i = 0; i < tablecount; i++) ------------------ | Branch (9038:13): [True: 2.45M, False: 5.56k] ------------------ 9039| 2.45M| { 9040| 2.45M| int crc = memcmp(name, slot+IMM2_SIZE, CU2BYTES(length)); ------------------ | | 193| 2.45M|#define IMM2_SIZE 2 ------------------ int crc = memcmp(name, slot+IMM2_SIZE, CU2BYTES(length)); ------------------ | | 545| 2.45M|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 9041| 2.45M| if (crc == 0 && slot[IMM2_SIZE+length] != 0) ------------------ | | 193| 2.45M|#define IMM2_SIZE 2 ------------------ | Branch (9041:7): [True: 2.45M, False: 4.44k] | Branch (9041:19): [True: 543, False: 2.45M] ------------------ 9042| 543| crc = -1; /* Current name is a substring */ 9043| | 9044| | /* Make space in the table and break the loop for an earlier name. For a 9045| | duplicate or later name, carry on. We do this for duplicates so that in the 9046| | simple case (when ?(| is not used) they are in order of their numbers. In all 9047| | cases they are in the order in which they appear in the pattern. */ 9048| | 9049| 2.45M| if (crc < 0) ------------------ | Branch (9049:7): [True: 808, False: 2.45M] ------------------ 9050| 808| { 9051| 808| (void)memmove(slot + cb->name_entry_size, slot, 9052| 808| CU2BYTES((tablecount - i) * cb->name_entry_size)); ------------------ | | 545| 808|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 9053| 808| break; 9054| 808| } 9055| | 9056| | /* Continue the loop for a later or duplicate name */ 9057| | 9058| 2.45M| slot += cb->name_entry_size; 9059| 2.45M| } 9060| | 9061| 6.37k|PUT2(slot, 0, groupno); ------------------ | | 195| 6.37k|#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255 ------------------ 9062| 6.37k|memcpy(slot + IMM2_SIZE, name, CU2BYTES(length)); ------------------ | | 193| 6.37k|#define IMM2_SIZE 2 ------------------ memcpy(slot + IMM2_SIZE, name, CU2BYTES(length)); ------------------ | | 545| 6.37k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 9063| | 9064| |/* Add a terminating zero and fill the rest of the slot with zeroes so that 9065| |the memory is all initialized. Otherwise valgrind moans about uninitialized 9066| |memory when saving serialized compiled patterns. */ 9067| | 9068| 6.37k|memset(slot + IMM2_SIZE + length, 0, ------------------ | | 193| 6.37k|#define IMM2_SIZE 2 ------------------ 9069| 6.37k| CU2BYTES(cb->name_entry_size - length - IMM2_SIZE)); ------------------ | | 545| 6.37k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 9070| 6.37k|} pcre2_compile.c:find_recurse: 8772| 186k|{ 8773| 186k|for (;;) 8774| 796k| { 8775| 796k| PCRE2_UCHAR c = *code; ------------------ | | 813| 796k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 796k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 796k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 796k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8776| 796k| if (c == OP_END) return NULL; ------------------ | Branch (8776:7): [True: 3.24k, False: 793k] ------------------ 8777| 793k| if (c == OP_RECURSE) return code; ------------------ | Branch (8777:7): [True: 182k, False: 610k] ------------------ 8778| | 8779| | /* XCLASS is used for classes that cannot be represented just by a bit map. 8780| | This includes negated single high-valued characters. CALLOUT_STR is used for 8781| | callouts with string arguments. In both cases the length in the table is 8782| | zero; the actual length is stored in the compiled code. */ 8783| | 8784| 610k| if (c == OP_XCLASS) code += GET(code, 1); ------------------ | | 109| 288| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (8784:7): [True: 288, False: 609k] ------------------ 8785| 609k| else if (c == OP_CALLOUT_STR) code += GET(code, 1 + 2*LINK_SIZE); ------------------ | | 109| 332| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (8785:14): [True: 332, False: 609k] ------------------ 8786| | 8787| | /* Otherwise, we can get the item's length from the table, except that for 8788| | repeated character types, we have to test for \p and \P, which have an extra 8789| | two code units of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, 8790| | we must add in its length. */ 8791| | 8792| 609k| else 8793| 609k| { 8794| 609k| switch(c) ------------------ | Branch (8794:12): [True: 597k, False: 12.5k] ------------------ 8795| 609k| { 8796| 1.24k| case OP_TYPESTAR: ------------------ | Branch (8796:7): [True: 1.24k, False: 608k] ------------------ 8797| 1.66k| case OP_TYPEMINSTAR: ------------------ | Branch (8797:7): [True: 415, False: 609k] ------------------ 8798| 2.83k| case OP_TYPEPLUS: ------------------ | Branch (8798:7): [True: 1.17k, False: 608k] ------------------ 8799| 3.37k| case OP_TYPEMINPLUS: ------------------ | Branch (8799:7): [True: 542, False: 609k] ------------------ 8800| 3.94k| case OP_TYPEQUERY: ------------------ | Branch (8800:7): [True: 573, False: 609k] ------------------ 8801| 4.38k| case OP_TYPEMINQUERY: ------------------ | Branch (8801:7): [True: 438, False: 609k] ------------------ 8802| 4.63k| case OP_TYPEPOSSTAR: ------------------ | Branch (8802:7): [True: 247, False: 609k] ------------------ 8803| 4.88k| case OP_TYPEPOSPLUS: ------------------ | Branch (8803:7): [True: 253, False: 609k] ------------------ 8804| 5.15k| case OP_TYPEPOSQUERY: ------------------ | Branch (8804:7): [True: 266, False: 609k] ------------------ 8805| 5.15k| if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2; ------------------ | Branch (8805:11): [True: 331, False: 4.82k] | Branch (8805:33): [True: 514, False: 4.30k] ------------------ 8806| 5.15k| break; 8807| | 8808| 277| case OP_TYPEPOSUPTO: ------------------ | Branch (8808:7): [True: 277, False: 609k] ------------------ 8809| 1.51k| case OP_TYPEUPTO: ------------------ | Branch (8809:7): [True: 1.24k, False: 608k] ------------------ 8810| 2.27k| case OP_TYPEMINUPTO: ------------------ | Branch (8810:7): [True: 758, False: 608k] ------------------ 8811| 3.61k| case OP_TYPEEXACT: ------------------ | Branch (8811:7): [True: 1.34k, False: 608k] ------------------ 8812| 3.61k| if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP) ------------------ | | 193| 3.61k|#define IMM2_SIZE 2 ------------------ if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP) ------------------ | | 193| 3.29k|#define IMM2_SIZE 2 ------------------ | Branch (8812:11): [True: 322, False: 3.29k] | Branch (8812:45): [True: 577, False: 2.71k] ------------------ 8813| 899| code += 2; 8814| 3.61k| break; 8815| | 8816| 436| case OP_MARK: ------------------ | Branch (8816:7): [True: 436, False: 609k] ------------------ 8817| 715| case OP_COMMIT_ARG: ------------------ | Branch (8817:7): [True: 279, False: 609k] ------------------ 8818| 993| case OP_PRUNE_ARG: ------------------ | Branch (8818:7): [True: 278, False: 609k] ------------------ 8819| 3.16k| case OP_SKIP_ARG: ------------------ | Branch (8819:7): [True: 2.16k, False: 607k] ------------------ 8820| 3.75k| case OP_THEN_ARG: ------------------ | Branch (8820:7): [True: 597, False: 609k] ------------------ 8821| 3.75k| code += code[1]; 8822| 3.75k| break; 8823| 609k| } 8824| | 8825| | /* Add in the fixed length from the table */ 8826| | 8827| 609k| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 609k|#define PRIV(name) _pcre2_##name ------------------ 8828| | 8829| | /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may 8830| | be followed by a multi-unit character. The length in the table is a 8831| | minimum, so we have to arrange to skip the extra units. */ 8832| | 8833| 609k|#ifdef MAYBE_UTF_MULTI 8834| 609k| if (utf) switch(c) ------------------ | Branch (8834:9): [True: 55.1k, False: 554k] | Branch (8834:21): [True: 51.8k, False: 3.35k] ------------------ 8835| 55.1k| { 8836| 1.24k| case OP_CHAR: ------------------ | Branch (8836:7): [True: 1.24k, False: 53.9k] ------------------ 8837| 3.23k| case OP_CHARI: ------------------ | Branch (8837:7): [True: 1.98k, False: 53.1k] ------------------ 8838| 3.23k| case OP_NOT: ------------------ | Branch (8838:7): [True: 2, False: 55.1k] ------------------ 8839| 3.23k| case OP_NOTI: ------------------ | Branch (8839:7): [True: 6, False: 55.1k] ------------------ 8840| 3.24k| case OP_EXACT: ------------------ | Branch (8840:7): [True: 3, False: 55.1k] ------------------ 8841| 3.25k| case OP_EXACTI: ------------------ | Branch (8841:7): [True: 10, False: 55.1k] ------------------ 8842| 3.25k| case OP_NOTEXACT: ------------------ | Branch (8842:7): [True: 0, False: 55.1k] ------------------ 8843| 3.25k| case OP_NOTEXACTI: ------------------ | Branch (8843:7): [True: 2, False: 55.1k] ------------------ 8844| 3.25k| case OP_UPTO: ------------------ | Branch (8844:7): [True: 1, False: 55.1k] ------------------ 8845| 3.25k| case OP_UPTOI: ------------------ | Branch (8845:7): [True: 0, False: 55.1k] ------------------ 8846| 3.25k| case OP_NOTUPTO: ------------------ | Branch (8846:7): [True: 1, False: 55.1k] ------------------ 8847| 3.25k| case OP_NOTUPTOI: ------------------ | Branch (8847:7): [True: 0, False: 55.1k] ------------------ 8848| 3.25k| case OP_MINUPTO: ------------------ | Branch (8848:7): [True: 1, False: 55.1k] ------------------ 8849| 3.25k| case OP_MINUPTOI: ------------------ | Branch (8849:7): [True: 0, False: 55.1k] ------------------ 8850| 3.25k| case OP_NOTMINUPTO: ------------------ | Branch (8850:7): [True: 0, False: 55.1k] ------------------ 8851| 3.25k| case OP_NOTMINUPTOI: ------------------ | Branch (8851:7): [True: 0, False: 55.1k] ------------------ 8852| 3.25k| case OP_POSUPTO: ------------------ | Branch (8852:7): [True: 0, False: 55.1k] ------------------ 8853| 3.25k| case OP_POSUPTOI: ------------------ | Branch (8853:7): [True: 0, False: 55.1k] ------------------ 8854| 3.25k| case OP_NOTPOSUPTO: ------------------ | Branch (8854:7): [True: 0, False: 55.1k] ------------------ 8855| 3.25k| case OP_NOTPOSUPTOI: ------------------ | Branch (8855:7): [True: 0, False: 55.1k] ------------------ 8856| 3.28k| case OP_STAR: ------------------ | Branch (8856:7): [True: 25, False: 55.1k] ------------------ 8857| 3.30k| case OP_STARI: ------------------ | Branch (8857:7): [True: 21, False: 55.1k] ------------------ 8858| 3.30k| case OP_NOTSTAR: ------------------ | Branch (8858:7): [True: 0, False: 55.1k] ------------------ 8859| 3.30k| case OP_NOTSTARI: ------------------ | Branch (8859:7): [True: 0, False: 55.1k] ------------------ 8860| 3.31k| case OP_MINSTAR: ------------------ | Branch (8860:7): [True: 13, False: 55.1k] ------------------ 8861| 3.31k| case OP_MINSTARI: ------------------ | Branch (8861:7): [True: 2, False: 55.1k] ------------------ 8862| 3.31k| case OP_NOTMINSTAR: ------------------ | Branch (8862:7): [True: 0, False: 55.1k] ------------------ 8863| 3.31k| case OP_NOTMINSTARI: ------------------ | Branch (8863:7): [True: 0, False: 55.1k] ------------------ 8864| 3.31k| case OP_POSSTAR: ------------------ | Branch (8864:7): [True: 0, False: 55.1k] ------------------ 8865| 3.31k| case OP_POSSTARI: ------------------ | Branch (8865:7): [True: 0, False: 55.1k] ------------------ 8866| 3.31k| case OP_NOTPOSSTAR: ------------------ | Branch (8866:7): [True: 0, False: 55.1k] ------------------ 8867| 3.31k| case OP_NOTPOSSTARI: ------------------ | Branch (8867:7): [True: 0, False: 55.1k] ------------------ 8868| 3.32k| case OP_PLUS: ------------------ | Branch (8868:7): [True: 4, False: 55.1k] ------------------ 8869| 3.32k| case OP_PLUSI: ------------------ | Branch (8869:7): [True: 3, False: 55.1k] ------------------ 8870| 3.32k| case OP_NOTPLUS: ------------------ | Branch (8870:7): [True: 0, False: 55.1k] ------------------ 8871| 3.32k| case OP_NOTPLUSI: ------------------ | Branch (8871:7): [True: 0, False: 55.1k] ------------------ 8872| 3.32k| case OP_MINPLUS: ------------------ | Branch (8872:7): [True: 0, False: 55.1k] ------------------ 8873| 3.32k| case OP_MINPLUSI: ------------------ | Branch (8873:7): [True: 3, False: 55.1k] ------------------ 8874| 3.32k| case OP_NOTMINPLUS: ------------------ | Branch (8874:7): [True: 0, False: 55.1k] ------------------ 8875| 3.32k| case OP_NOTMINPLUSI: ------------------ | Branch (8875:7): [True: 0, False: 55.1k] ------------------ 8876| 3.32k| case OP_POSPLUS: ------------------ | Branch (8876:7): [True: 0, False: 55.1k] ------------------ 8877| 3.32k| case OP_POSPLUSI: ------------------ | Branch (8877:7): [True: 1, False: 55.1k] ------------------ 8878| 3.32k| case OP_NOTPOSPLUS: ------------------ | Branch (8878:7): [True: 0, False: 55.1k] ------------------ 8879| 3.32k| case OP_NOTPOSPLUSI: ------------------ | Branch (8879:7): [True: 0, False: 55.1k] ------------------ 8880| 3.33k| case OP_QUERY: ------------------ | Branch (8880:7): [True: 7, False: 55.1k] ------------------ 8881| 3.34k| case OP_QUERYI: ------------------ | Branch (8881:7): [True: 7, False: 55.1k] ------------------ 8882| 3.34k| case OP_NOTQUERY: ------------------ | Branch (8882:7): [True: 0, False: 55.1k] ------------------ 8883| 3.34k| case OP_NOTQUERYI: ------------------ | Branch (8883:7): [True: 0, False: 55.1k] ------------------ 8884| 3.34k| case OP_MINQUERY: ------------------ | Branch (8884:7): [True: 3, False: 55.1k] ------------------ 8885| 3.34k| case OP_MINQUERYI: ------------------ | Branch (8885:7): [True: 3, False: 55.1k] ------------------ 8886| 3.34k| case OP_NOTMINQUERY: ------------------ | Branch (8886:7): [True: 0, False: 55.1k] ------------------ 8887| 3.34k| case OP_NOTMINQUERYI: ------------------ | Branch (8887:7): [True: 0, False: 55.1k] ------------------ 8888| 3.34k| case OP_POSQUERY: ------------------ | Branch (8888:7): [True: 0, False: 55.1k] ------------------ 8889| 3.35k| case OP_POSQUERYI: ------------------ | Branch (8889:7): [True: 3, False: 55.1k] ------------------ 8890| 3.35k| case OP_NOTPOSQUERY: ------------------ | Branch (8890:7): [True: 0, False: 55.1k] ------------------ 8891| 3.35k| case OP_NOTPOSQUERYI: ------------------ | Branch (8891:7): [True: 0, False: 55.1k] ------------------ 8892| 3.35k| if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]); ------------------ | | 286| 3.35k|#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c) | | ------------------ | | | | 254| 3.35k|#define HASUTF8EXTRALEN(c) ((c) >= 0xc0) | | | | ------------------ | | | | | Branch (254:28): [True: 369, False: 2.98k] | | | | ------------------ | | ------------------ ------------------ if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]); ------------------ | | 291| 369|#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu]) | | ------------------ | | | | 177| 369|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ 8893| 3.35k| break; 8894| 55.1k| } 8895| |#else 8896| | (void)(utf); /* Keep compiler happy by referencing function argument */ 8897| |#endif /* MAYBE_UTF_MULTI */ 8898| 609k| } 8899| 610k| } 8900| 186k|} pcre2_compile.c:is_anchored: 8546| 76.4k|{ 8547| 78.7k|do { 8548| 78.7k| PCRE2_SPTR scode = first_significant_code( ------------------ | | 814| 78.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 78.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 78.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 78.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8549| 78.7k| code + PRIV(OP_lengths)[*code], FALSE); ------------------ | | 177| 78.7k|#define PRIV(name) _pcre2_##name ------------------ code + PRIV(OP_lengths)[*code], FALSE); ------------------ | | 69| 78.7k|#define FALSE 0 ------------------ 8550| 78.7k| int op = *scode; 8551| | 8552| | /* Non-capturing brackets */ 8553| | 8554| 78.7k| if (op == OP_BRA || op == OP_BRAPOS || ------------------ | Branch (8554:8): [True: 3.20k, False: 75.5k] | Branch (8554:25): [True: 427, False: 75.1k] ------------------ 8555| 78.7k| op == OP_SBRA || op == OP_SBRAPOS) ------------------ | Branch (8555:8): [True: 271, False: 74.8k] | Branch (8555:25): [True: 138, False: 74.7k] ------------------ 8556| 4.03k| { 8557| 4.03k| if (!is_anchored(scode, bracket_map, cb, atomcount, inassert)) ------------------ | Branch (8557:10): [True: 3.62k, False: 418] ------------------ 8558| 3.62k| return FALSE; ------------------ | | 69| 3.62k|#define FALSE 0 ------------------ 8559| 4.03k| } 8560| | 8561| | /* Capturing brackets */ 8562| | 8563| 74.7k| else if (op == OP_CBRA || op == OP_CBRAPOS || ------------------ | Branch (8563:13): [True: 12.7k, False: 61.9k] | Branch (8563:31): [True: 479, False: 61.4k] ------------------ 8564| 74.7k| op == OP_SCBRA || op == OP_SCBRAPOS) ------------------ | Branch (8564:13): [True: 180, False: 61.3k] | Branch (8564:31): [True: 291, False: 61.0k] ------------------ 8565| 13.6k| { 8566| 13.6k| int n = GET2(scode, 1+LINK_SIZE); ------------------ | | 194| 13.6k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 8567| 13.6k| uint32_t new_map = bracket_map | ((n < 32)? (1u << n) : 1); ------------------ | Branch (8567:40): [True: 12.4k, False: 1.26k] ------------------ 8568| 13.6k| if (!is_anchored(scode, new_map, cb, atomcount, inassert)) return FALSE; ------------------ | | 69| 13.1k|#define FALSE 0 ------------------ | Branch (8568:10): [True: 13.1k, False: 492] ------------------ 8569| 13.6k| } 8570| | 8571| | /* Positive forward assertion */ 8572| | 8573| 61.0k| else if (op == OP_ASSERT || op == OP_ASSERT_NA) ------------------ | Branch (8573:13): [True: 672, False: 60.3k] | Branch (8573:32): [True: 521, False: 59.8k] ------------------ 8574| 1.19k| { 8575| 1.19k| if (!is_anchored(scode, bracket_map, cb, atomcount, TRUE)) return FALSE; ------------------ | | 70| 1.19k|#define TRUE 1 ------------------ if (!is_anchored(scode, bracket_map, cb, atomcount, TRUE)) return FALSE; ------------------ | | 69| 911|#define FALSE 0 ------------------ | Branch (8575:10): [True: 911, False: 282] ------------------ 8576| 1.19k| } 8577| | 8578| | /* Condition. If there is no second branch, it can't be anchored. */ 8579| | 8580| 59.8k| else if (op == OP_COND || op == OP_SCOND) ------------------ | Branch (8580:13): [True: 874, False: 58.9k] | Branch (8580:30): [True: 77, False: 58.8k] ------------------ 8581| 951| { 8582| 951| if (scode[GET(scode,1)] != OP_ALT) return FALSE; ------------------ | | 109| 951| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ if (scode[GET(scode,1)] != OP_ALT) return FALSE; ------------------ | | 69| 467|#define FALSE 0 ------------------ | Branch (8582:10): [True: 467, False: 484] ------------------ 8583| 484| if (!is_anchored(scode, bracket_map, cb, atomcount, inassert)) ------------------ | Branch (8583:10): [True: 418, False: 66] ------------------ 8584| 418| return FALSE; ------------------ | | 69| 418|#define FALSE 0 ------------------ 8585| 484| } 8586| | 8587| | /* Atomic groups */ 8588| | 8589| 58.8k| else if (op == OP_ONCE) ------------------ | Branch (8589:13): [True: 662, False: 58.2k] ------------------ 8590| 662| { 8591| 662| if (!is_anchored(scode, bracket_map, cb, atomcount + 1, inassert)) ------------------ | Branch (8591:10): [True: 561, False: 101] ------------------ 8592| 561| return FALSE; ------------------ | | 69| 561|#define FALSE 0 ------------------ 8593| 662| } 8594| | 8595| | /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and 8596| | it isn't in brackets that are or may be referenced or inside an atomic 8597| | group or an assertion. Also the pattern must not contain *PRUNE or *SKIP, 8598| | because these break the feature. Consider, for example, /(?s).*?(*PRUNE)b/ 8599| | with the subject "aab", which matches "b", i.e. not at the start of a line. 8600| | There is also an option that disables auto-anchoring. */ 8601| | 8602| 58.2k| else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR || ------------------ | Branch (8602:14): [True: 5.30k, False: 52.9k] | Branch (8602:35): [True: 1.84k, False: 51.0k] ------------------ 8603| 58.2k| op == OP_TYPEPOSSTAR)) ------------------ | Branch (8603:14): [True: 1.46k, False: 49.6k] ------------------ 8604| 8.60k| { 8605| 8.60k| if (scode[1] != OP_ALLANY || (bracket_map & cb->backref_map) != 0 || ------------------ | Branch (8605:10): [True: 7.33k, False: 1.27k] | Branch (8605:35): [True: 42, False: 1.22k] ------------------ 8606| 8.60k| atomcount > 0 || cb->had_pruneorskip || inassert || ------------------ | Branch (8606:10): [True: 3, False: 1.22k] | Branch (8606:27): [True: 6, False: 1.21k] | Branch (8606:50): [True: 3, False: 1.21k] ------------------ 8607| 8.60k| (cb->external_options & PCRE2_NO_DOTSTAR_ANCHOR) != 0) ------------------ | | 134| 1.21k|#define PCRE2_NO_DOTSTAR_ANCHOR 0x00008000u /* C */ ------------------ | Branch (8607:10): [True: 312, False: 904] ------------------ 8608| 7.70k| return FALSE; ------------------ | | 69| 7.70k|#define FALSE 0 ------------------ 8609| 8.60k| } 8610| | 8611| | /* Check for explicit anchoring */ 8612| | 8613| 49.6k| else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE; ------------------ | | 69| 47.4k|#define FALSE 0 ------------------ | Branch (8613:13): [True: 49.3k, False: 253] | Branch (8613:29): [True: 49.1k, False: 219] | Branch (8613:45): [True: 47.4k, False: 1.66k] ------------------ 8614| | 8615| 4.39k| code += GET(code, 1); ------------------ | | 109| 4.39k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 8616| 4.39k| } 8617| 76.4k|while (*code == OP_ALT); /* Loop for each alternative */ ------------------ | Branch (8617:8): [True: 2.30k, False: 2.08k] ------------------ 8618| 2.08k|return TRUE; ------------------ | | 70| 2.08k|#define TRUE 1 ------------------ 8619| 76.4k|} pcre2_compile.c:first_significant_code: 4939| 196k|{ 4940| 196k|for (;;) 4941| 242k| { 4942| 242k| switch ((int)*code) 4943| 242k| { 4944| 5.40k| case OP_ASSERT_NOT: ------------------ | Branch (4944:5): [True: 5.40k, False: 237k] ------------------ 4945| 7.66k| case OP_ASSERTBACK: ------------------ | Branch (4945:5): [True: 2.25k, False: 240k] ------------------ 4946| 11.2k| case OP_ASSERTBACK_NOT: ------------------ | Branch (4946:5): [True: 3.61k, False: 238k] ------------------ 4947| 12.2k| case OP_ASSERTBACK_NA: ------------------ | Branch (4947:5): [True: 969, False: 241k] ------------------ 4948| 12.2k| if (!skipassert) return code; ------------------ | Branch (4948:9): [True: 3.41k, False: 8.83k] ------------------ 4949| 10.4k| do code += GET(code, 1); while (*code == OP_ALT); ------------------ | | 109| 10.4k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (4949:37): [True: 1.57k, False: 8.83k] ------------------ 4950| 8.83k| code += PRIV(OP_lengths)[*code]; ------------------ | | 177| 8.83k|#define PRIV(name) _pcre2_##name ------------------ 4951| 8.83k| break; 4952| | 4953| 820| case OP_WORD_BOUNDARY: ------------------ | Branch (4953:5): [True: 820, False: 241k] ------------------ 4954| 1.49k| case OP_NOT_WORD_BOUNDARY: ------------------ | Branch (4954:5): [True: 678, False: 241k] ------------------ 4955| 1.78k| case OP_UCP_WORD_BOUNDARY: ------------------ | Branch (4955:5): [True: 284, False: 242k] ------------------ 4956| 2.04k| case OP_NOT_UCP_WORD_BOUNDARY: ------------------ | Branch (4956:5): [True: 258, False: 242k] ------------------ 4957| 2.04k| if (!skipassert) return code; ------------------ | Branch (4957:9): [True: 579, False: 1.46k] ------------------ 4958| | /* Fall through */ 4959| | 4960| 31.0k| case OP_CALLOUT: ------------------ | Branch (4960:5): [True: 29.5k, False: 213k] ------------------ 4961| 31.0k| case OP_CREF: ------------------ | Branch (4961:5): [True: 43, False: 242k] ------------------ 4962| 31.0k| case OP_DNCREF: ------------------ | Branch (4962:5): [True: 18, False: 242k] ------------------ 4963| 31.1k| case OP_RREF: ------------------ | Branch (4963:5): [True: 107, False: 242k] ------------------ 4964| 31.2k| case OP_DNRREF: ------------------ | Branch (4964:5): [True: 34, False: 242k] ------------------ 4965| 31.3k| case OP_FALSE: ------------------ | Branch (4965:5): [True: 129, False: 242k] ------------------ 4966| 31.4k| case OP_TRUE: ------------------ | Branch (4966:5): [True: 70, False: 242k] ------------------ 4967| 31.4k| code += PRIV(OP_lengths)[*code]; ------------------ | | 177| 31.4k|#define PRIV(name) _pcre2_##name ------------------ 4968| 31.4k| break; 4969| | 4970| 2.11k| case OP_CALLOUT_STR: ------------------ | Branch (4970:5): [True: 2.11k, False: 240k] ------------------ 4971| 2.11k| code += GET(code, 1 + 2*LINK_SIZE); ------------------ | | 109| 2.11k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 4972| 2.11k| break; 4973| | 4974| 320| case OP_SKIPZERO: ------------------ | Branch (4974:5): [True: 320, False: 242k] ------------------ 4975| 320| code += 2 + GET(code, 2) + LINK_SIZE; ------------------ | | 109| 320| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ code += 2 + GET(code, 2) + LINK_SIZE; ------------------ | | 165| 320|#define LINK_SIZE 2 ------------------ 4976| 320| break; 4977| | 4978| 2.94k| case OP_COND: ------------------ | Branch (4978:5): [True: 2.94k, False: 239k] ------------------ 4979| 3.12k| case OP_SCOND: ------------------ | Branch (4979:5): [True: 171, False: 242k] ------------------ 4980| 3.12k| if (code[1+LINK_SIZE] != OP_FALSE || /* Not DEFINE */ ------------------ | | 165| 3.12k|#define LINK_SIZE 2 ------------------ | Branch (4980:9): [True: 2.25k, False: 869] ------------------ 4981| 3.12k| code[GET(code, 1)] != OP_KET) /* More than one branch */ ------------------ | | 109| 869| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (4981:9): [True: 166, False: 703] ------------------ 4982| 2.41k| return code; 4983| 703| code += GET(code, 1) + 1 + LINK_SIZE; ------------------ | | 109| 703| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ code += GET(code, 1) + 1 + LINK_SIZE; ------------------ | | 165| 703|#define LINK_SIZE 2 ------------------ 4984| 703| break; 4985| | 4986| 857| case OP_MARK: ------------------ | Branch (4986:5): [True: 857, False: 241k] ------------------ 4987| 1.21k| case OP_COMMIT_ARG: ------------------ | Branch (4987:5): [True: 354, False: 242k] ------------------ 4988| 1.55k| case OP_PRUNE_ARG: ------------------ | Branch (4988:5): [True: 339, False: 242k] ------------------ 4989| 2.12k| case OP_SKIP_ARG: ------------------ | Branch (4989:5): [True: 574, False: 241k] ------------------ 4990| 2.49k| case OP_THEN_ARG: ------------------ | Branch (4990:5): [True: 370, False: 242k] ------------------ 4991| 2.49k| code += code[1] + PRIV(OP_lengths)[*code]; ------------------ | | 177| 2.49k|#define PRIV(name) _pcre2_##name ------------------ 4992| 2.49k| break; 4993| | 4994| 190k| default: ------------------ | Branch (4994:5): [True: 190k, False: 52.2k] ------------------ 4995| 190k| return code; 4996| 242k| } 4997| 242k| } 4998| |/* Control never reaches here */ 4999| 196k|} pcre2_compile.c:find_firstassertedcu: 8928| 58.5k|{ 8929| 58.5k|uint32_t c = 0; 8930| 58.5k|uint32_t cflags = REQ_NONE; ------------------ | | 394| 58.5k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 8931| | 8932| 58.5k|*flags = REQ_NONE; ------------------ | | 394| 58.5k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ 8933| 62.2k|do { 8934| 62.2k| uint32_t d; 8935| 62.2k| uint32_t dflags; 8936| 62.2k| int xl = (*code == OP_CBRA || *code == OP_SCBRA || ------------------ | Branch (8936:14): [True: 10.8k, False: 51.4k] | Branch (8936:34): [True: 196, False: 51.2k] ------------------ 8937| 62.2k| *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0; ------------------ | | 193| 11.7k|#define IMM2_SIZE 2 ------------------ | Branch (8937:14): [True: 354, False: 50.8k] | Branch (8937:37): [True: 286, False: 50.5k] ------------------ 8938| 62.2k| PCRE2_SPTR scode = first_significant_code(code + 1+LINK_SIZE + xl, TRUE); ------------------ | | 814| 62.2k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 62.2k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 62.2k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 62.2k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR scode = first_significant_code(code + 1+LINK_SIZE + xl, TRUE); ------------------ | | 165| 62.2k|#define LINK_SIZE 2 ------------------ PCRE2_SPTR scode = first_significant_code(code + 1+LINK_SIZE + xl, TRUE); ------------------ | | 70| 62.2k|#define TRUE 1 ------------------ 8939| 62.2k| PCRE2_UCHAR op = *scode; ------------------ | | 813| 62.2k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 62.2k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 62.2k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 62.2k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8940| | 8941| 62.2k| switch(op) 8942| 62.2k| { 8943| 39.7k| default: ------------------ | Branch (8943:6): [True: 39.7k, False: 22.5k] ------------------ 8944| 39.7k| return 0; 8945| | 8946| 2.52k| case OP_BRA: ------------------ | Branch (8946:6): [True: 2.52k, False: 59.7k] ------------------ 8947| 2.90k| case OP_BRAPOS: ------------------ | Branch (8947:6): [True: 381, False: 61.9k] ------------------ 8948| 13.8k| case OP_CBRA: ------------------ | Branch (8948:6): [True: 10.8k, False: 51.4k] ------------------ 8949| 13.9k| case OP_SCBRA: ------------------ | Branch (8949:6): [True: 196, False: 62.1k] ------------------ 8950| 14.3k| case OP_CBRAPOS: ------------------ | Branch (8950:6): [True: 354, False: 61.9k] ------------------ 8951| 14.6k| case OP_SCBRAPOS: ------------------ | Branch (8951:6): [True: 286, False: 62.0k] ------------------ 8952| 15.1k| case OP_ASSERT: ------------------ | Branch (8952:6): [True: 470, False: 61.8k] ------------------ 8953| 15.6k| case OP_ASSERT_NA: ------------------ | Branch (8953:6): [True: 579, False: 61.7k] ------------------ 8954| 16.2k| case OP_ONCE: ------------------ | Branch (8954:6): [True: 549, False: 61.7k] ------------------ 8955| 16.4k| case OP_SCRIPT_RUN: ------------------ | Branch (8955:6): [True: 254, False: 62.0k] ------------------ 8956| 16.4k| d = find_firstassertedcu(scode, &dflags, inassert + 8957| 16.4k| ((op == OP_ASSERT || op == OP_ASSERT_NA)?1:0)); ------------------ | Branch (8957:10): [True: 470, False: 16.0k] | Branch (8957:29): [True: 579, False: 15.4k] ------------------ 8958| 16.4k| if (dflags >= REQ_NONE) return 0; ------------------ | | 394| 16.4k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (8958:10): [True: 15.5k, False: 985] ------------------ 8959| 985| if (cflags >= REQ_NONE) { c = d; cflags = dflags; } ------------------ | | 394| 985|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (8959:10): [True: 425, False: 560] ------------------ 8960| 560| else if (c != d || cflags != dflags) return 0; ------------------ | Branch (8960:17): [True: 14, False: 546] | Branch (8960:27): [True: 3, False: 543] ------------------ 8961| 968| break; 8962| | 8963| 968| case OP_EXACT: ------------------ | Branch (8963:6): [True: 234, False: 62.0k] ------------------ 8964| 234| scode += IMM2_SIZE; ------------------ | | 193| 234|#define IMM2_SIZE 2 ------------------ 8965| | /* Fall through */ 8966| | 8967| 3.02k| case OP_CHAR: ------------------ | Branch (8967:6): [True: 2.79k, False: 59.5k] ------------------ 8968| 3.26k| case OP_PLUS: ------------------ | Branch (8968:6): [True: 240, False: 62.0k] ------------------ 8969| 3.46k| case OP_MINPLUS: ------------------ | Branch (8969:6): [True: 203, False: 62.0k] ------------------ 8970| 4.29k| case OP_POSPLUS: ------------------ | Branch (8970:6): [True: 824, False: 61.4k] ------------------ 8971| 4.29k| if (inassert == 0) return 0; ------------------ | Branch (8971:10): [True: 1.64k, False: 2.64k] ------------------ 8972| 2.64k| if (cflags >= REQ_NONE) { c = scode[1]; cflags = 0; } ------------------ | | 394| 2.64k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ | Branch (8972:10): [True: 597, False: 2.05k] ------------------ 8973| 2.05k| else if (c != scode[1]) return 0; ------------------ | Branch (8973:17): [True: 26, False: 2.02k] ------------------ 8974| 2.62k| break; 8975| | 8976| 2.62k| case OP_EXACTI: ------------------ | Branch (8976:6): [True: 248, False: 62.0k] ------------------ 8977| 248| scode += IMM2_SIZE; ------------------ | | 193| 248|#define IMM2_SIZE 2 ------------------ 8978| | /* Fall through */ 8979| | 8980| 1.08k| case OP_CHARI: ------------------ | Branch (8980:6): [True: 837, False: 61.4k] ------------------ 8981| 1.30k| case OP_PLUSI: ------------------ | Branch (8981:6): [True: 215, False: 62.0k] ------------------ 8982| 1.51k| case OP_MINPLUSI: ------------------ | Branch (8982:6): [True: 210, False: 62.0k] ------------------ 8983| 1.73k| case OP_POSPLUSI: ------------------ | Branch (8983:6): [True: 226, False: 62.0k] ------------------ 8984| 1.73k| if (inassert == 0) return 0; ------------------ | Branch (8984:10): [True: 417, False: 1.31k] ------------------ 8985| | 8986| | /* If the character is more than one code unit long, we cannot set its 8987| | first code unit when matching caselessly. Later scanning may pick up 8988| | multiple code units. */ 8989| | 8990| 1.31k|#ifdef SUPPORT_UNICODE 8991| 1.31k|#if PCRE2_CODE_UNIT_WIDTH == 8 8992| 1.31k| if (scode[1] >= 0x80) return 0; ------------------ | Branch (8992:10): [True: 10, False: 1.30k] ------------------ 8993| |#elif PCRE2_CODE_UNIT_WIDTH == 16 8994| | if (scode[1] >= 0xd800 && scode[1] <= 0xdfff) return 0; 8995| |#endif 8996| 1.30k|#endif 8997| | 8998| 1.30k| if (cflags >= REQ_NONE) { c = scode[1]; cflags = REQ_CASELESS; } ------------------ | | 394| 1.30k|#define REQ_NONE 0xfffffffeu /* Found not fixed character */ ------------------ if (cflags >= REQ_NONE) { c = scode[1]; cflags = REQ_CASELESS; } ------------------ | | 395| 251|#define REQ_CASELESS 0x00000001u /* Code unit in xxcu is caseless */ ------------------ | Branch (8998:10): [True: 251, False: 1.05k] ------------------ 8999| 1.05k| else if (c != scode[1]) return 0; ------------------ | Branch (8999:17): [True: 6, False: 1.05k] ------------------ 9000| 1.30k| break; 9001| 62.2k| } 9002| | 9003| 4.89k| code += GET(code, 1); ------------------ | | 109| 4.89k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 9004| 4.89k| } 9005| 58.5k|while (*code == OP_ALT); ------------------ | Branch (9005:8): [True: 3.72k, False: 1.16k] ------------------ 9006| | 9007| 1.16k|*flags = cflags; 9008| 1.16k|return c; 9009| 58.5k|} pcre2_compile.c:is_startline: 8651| 52.5k|{ 8652| 55.4k|do { 8653| 55.4k| PCRE2_SPTR scode = first_significant_code( ------------------ | | 814| 55.4k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 55.4k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 55.4k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 55.4k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 8654| 55.4k| code + PRIV(OP_lengths)[*code], FALSE); ------------------ | | 177| 55.4k|#define PRIV(name) _pcre2_##name ------------------ code + PRIV(OP_lengths)[*code], FALSE); ------------------ | | 69| 55.4k|#define FALSE 0 ------------------ 8655| 55.4k| int op = *scode; 8656| | 8657| | /* If we are at the start of a conditional assertion group, *both* the 8658| | conditional assertion *and* what follows the condition must satisfy the test 8659| | for start of line. Other kinds of condition fail. Note that there may be an 8660| | auto-callout at the start of a condition. */ 8661| | 8662| 55.4k| if (op == OP_COND) ------------------ | Branch (8662:8): [True: 864, False: 54.5k] ------------------ 8663| 864| { 8664| 864| scode += 1 + LINK_SIZE; ------------------ | | 165| 864|#define LINK_SIZE 2 ------------------ 8665| | 8666| 864| if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT]; ------------------ | | 177| 73|#define PRIV(name) _pcre2_##name ------------------ | Branch (8666:10): [True: 73, False: 791] ------------------ 8667| 791| else if (*scode == OP_CALLOUT_STR) scode += GET(scode, 1 + 2*LINK_SIZE); ------------------ | | 109| 91| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (8667:17): [True: 91, False: 700] ------------------ 8668| | 8669| 864| switch (*scode) 8670| 864| { 8671| 35| case OP_CREF: ------------------ | Branch (8671:8): [True: 35, False: 829] ------------------ 8672| 56| case OP_DNCREF: ------------------ | Branch (8672:8): [True: 21, False: 843] ------------------ 8673| 151| case OP_RREF: ------------------ | Branch (8673:8): [True: 95, False: 769] ------------------ 8674| 171| case OP_DNRREF: ------------------ | Branch (8674:8): [True: 20, False: 844] ------------------ 8675| 183| case OP_FAIL: ------------------ | Branch (8675:8): [True: 12, False: 852] ------------------ 8676| 198| case OP_FALSE: ------------------ | Branch (8676:8): [True: 15, False: 849] ------------------ 8677| 219| case OP_TRUE: ------------------ | Branch (8677:8): [True: 21, False: 843] ------------------ 8678| 219| return FALSE; ------------------ | | 69| 219|#define FALSE 0 ------------------ 8679| | 8680| 645| default: /* Assertion */ ------------------ | Branch (8680:8): [True: 645, False: 219] ------------------ 8681| 645| if (!is_startline(scode, bracket_map, cb, atomcount, TRUE)) return FALSE; ------------------ | | 70| 645|#define TRUE 1 ------------------ if (!is_startline(scode, bracket_map, cb, atomcount, TRUE)) return FALSE; ------------------ | | 69| 457|#define FALSE 0 ------------------ | Branch (8681:12): [True: 457, False: 188] ------------------ 8682| 394| do scode += GET(scode, 1); while (*scode == OP_ALT); ------------------ | | 109| 394| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (8682:42): [True: 206, False: 188] ------------------ 8683| 188| scode += 1 + LINK_SIZE; ------------------ | | 165| 188|#define LINK_SIZE 2 ------------------ 8684| 188| break; 8685| 864| } 8686| 188| scode = first_significant_code(scode, FALSE); ------------------ | | 69| 188|#define FALSE 0 ------------------ 8687| 188| op = *scode; 8688| 188| } 8689| | 8690| | /* Non-capturing brackets */ 8691| | 8692| 54.7k| if (op == OP_BRA || op == OP_BRAPOS || ------------------ | Branch (8692:8): [True: 2.00k, False: 52.7k] | Branch (8692:25): [True: 266, False: 52.5k] ------------------ 8693| 54.7k| op == OP_SBRA || op == OP_SBRAPOS) ------------------ | Branch (8693:8): [True: 247, False: 52.2k] | Branch (8693:25): [True: 90, False: 52.1k] ------------------ 8694| 2.60k| { 8695| 2.60k| if (!is_startline(scode, bracket_map, cb, atomcount, inassert)) ------------------ | Branch (8695:10): [True: 2.15k, False: 451] ------------------ 8696| 2.15k| return FALSE; ------------------ | | 69| 2.15k|#define FALSE 0 ------------------ 8697| 2.60k| } 8698| | 8699| | /* Capturing brackets */ 8700| | 8701| 52.1k| else if (op == OP_CBRA || op == OP_CBRAPOS || ------------------ | Branch (8701:13): [True: 9.62k, False: 42.5k] | Branch (8701:31): [True: 475, False: 42.0k] ------------------ 8702| 52.1k| op == OP_SCBRA || op == OP_SCBRAPOS) ------------------ | Branch (8702:13): [True: 152, False: 41.9k] | Branch (8702:31): [True: 247, False: 41.6k] ------------------ 8703| 10.5k| { 8704| 10.5k| int n = GET2(scode, 1+LINK_SIZE); ------------------ | | 194| 10.5k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 8705| 10.5k| unsigned int new_map = bracket_map | ((n < 32)? (1u << n) : 1); ------------------ | Branch (8705:44): [True: 9.67k, False: 826] ------------------ 8706| 10.5k| if (!is_startline(scode, new_map, cb, atomcount, inassert)) return FALSE; ------------------ | | 69| 9.99k|#define FALSE 0 ------------------ | Branch (8706:10): [True: 9.99k, False: 505] ------------------ 8707| 10.5k| } 8708| | 8709| | /* Positive forward assertions */ 8710| | 8711| 41.6k| else if (op == OP_ASSERT || op == OP_ASSERT_NA) ------------------ | Branch (8711:13): [True: 478, False: 41.1k] | Branch (8711:32): [True: 308, False: 40.8k] ------------------ 8712| 786| { 8713| 786| if (!is_startline(scode, bracket_map, cb, atomcount, TRUE)) ------------------ | | 70| 786|#define TRUE 1 ------------------ | Branch (8713:10): [True: 589, False: 197] ------------------ 8714| 589| return FALSE; ------------------ | | 69| 589|#define FALSE 0 ------------------ 8715| 786| } 8716| | 8717| | /* Atomic brackets */ 8718| | 8719| 40.8k| else if (op == OP_ONCE) ------------------ | Branch (8719:13): [True: 498, False: 40.3k] ------------------ 8720| 498| { 8721| 498| if (!is_startline(scode, bracket_map, cb, atomcount + 1, inassert)) ------------------ | Branch (8721:10): [True: 422, False: 76] ------------------ 8722| 422| return FALSE; ------------------ | | 69| 422|#define FALSE 0 ------------------ 8723| 498| } 8724| | 8725| | /* .* means "start at start or after \n" if it isn't in atomic brackets or 8726| | brackets that may be referenced or an assertion, and as long as the pattern 8727| | does not contain *PRUNE or *SKIP, because these break the feature. Consider, 8728| | for example, /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab", 8729| | i.e. not at the start of a line. There is also an option that disables this 8730| | optimization. */ 8731| | 8732| 40.3k| else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR) ------------------ | Branch (8732:13): [True: 4.37k, False: 36.0k] | Branch (8732:34): [True: 1.13k, False: 34.8k] | Branch (8732:58): [True: 1.32k, False: 33.5k] ------------------ 8733| 6.84k| { 8734| 6.84k| if (scode[1] != OP_ANY || (bracket_map & cb->backref_map) != 0 || ------------------ | Branch (8734:10): [True: 3.66k, False: 3.17k] | Branch (8734:32): [True: 124, False: 3.05k] ------------------ 8735| 6.84k| atomcount > 0 || cb->had_pruneorskip || inassert || ------------------ | Branch (8735:10): [True: 7, False: 3.04k] | Branch (8735:27): [True: 11, False: 3.03k] | Branch (8735:50): [True: 6, False: 3.02k] ------------------ 8736| 6.84k| (cb->external_options & PCRE2_NO_DOTSTAR_ANCHOR) != 0) ------------------ | | 134| 3.02k|#define PCRE2_NO_DOTSTAR_ANCHOR 0x00008000u /* C */ ------------------ | Branch (8736:10): [True: 103, False: 2.92k] ------------------ 8737| 3.91k| return FALSE; ------------------ | | 69| 3.91k|#define FALSE 0 ------------------ 8738| 6.84k| } 8739| | 8740| | /* Check for explicit circumflex; anything else gives a FALSE result. Note 8741| | in particular that this includes atomic brackets OP_ONCE because the number 8742| | of characters matched by .* cannot be adjusted inside them. */ 8743| | 8744| 33.5k| else if (op != OP_CIRC && op != OP_CIRCM) return FALSE; ------------------ | | 69| 31.6k|#define FALSE 0 ------------------ | Branch (8744:13): [True: 32.3k, False: 1.17k] | Branch (8744:30): [True: 31.6k, False: 677] ------------------ 8745| | 8746| | /* Move on to the next alternative */ 8747| | 8748| 6.00k| code += GET(code, 1); ------------------ | | 109| 6.00k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 8749| 6.00k| } 8750| 52.5k|while (*code == OP_ALT); /* Loop for each alternative */ ------------------ | Branch (8750:8): [True: 2.85k, False: 3.14k] ------------------ 8751| 3.14k|return TRUE; ------------------ | | 70| 3.14k|#define TRUE 1 ------------------ 8752| 52.5k|} _pcre2_memctl_malloc_8: 87| 68.0k|{ 88| 68.0k|pcre2_memctl *newmemctl; 89| 68.0k|void *yield = (memctl == NULL)? malloc(size) : ------------------ | Branch (89:15): [True: 68.0k, False: 0] ------------------ 90| 68.0k| memctl->malloc(size, memctl->memory_data); 91| 68.0k|if (yield == NULL) return NULL; ------------------ | Branch (91:5): [True: 0, False: 68.0k] ------------------ 92| 68.0k|newmemctl = (pcre2_memctl *)yield; 93| 68.0k|if (memctl == NULL) ------------------ | Branch (93:5): [True: 68.0k, False: 0] ------------------ 94| 68.0k| { 95| 68.0k| newmemctl->malloc = default_malloc; 96| 68.0k| newmemctl->free = default_free; 97| 68.0k| newmemctl->memory_data = NULL; 98| 68.0k| } 99| 0|else *newmemctl = *memctl; 100| 68.0k|return yield; 101| 68.0k|} pcre2_match_context_create_8: 183| 34.0k|{ 184| 34.0k|pcre2_match_context *mcontext = PRIV(memctl_malloc)( ------------------ | | 837| 34.0k|#define pcre2_match_context PCRE2_SUFFIX(pcre2_match_context_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ pcre2_match_context *mcontext = PRIV(memctl_malloc)( ------------------ | | 177| 34.0k|#define PRIV(name) _pcre2_##name ------------------ 185| 34.0k| sizeof(pcre2_real_match_context), (pcre2_memctl *)gcontext); 186| 34.0k|if (mcontext == NULL) return NULL; ------------------ | Branch (186:5): [True: 0, False: 34.0k] ------------------ 187| 34.0k|*mcontext = PRIV(default_match_context); ------------------ | | 177| 34.0k|#define PRIV(name) _pcre2_##name ------------------ 188| 34.0k|if (gcontext != NULL) ------------------ | Branch (188:5): [True: 0, False: 34.0k] ------------------ 189| 0| *((pcre2_memctl *)mcontext) = *((pcre2_memctl *)gcontext); 190| 34.0k|return mcontext; 191| 34.0k|} pcre2_match_context_free_8: 298| 34.0k|{ 299| 34.0k|if (mcontext != NULL) ------------------ | Branch (299:5): [True: 34.0k, False: 0] ------------------ 300| 34.0k| mcontext->memctl.free(mcontext, mcontext->memctl.memory_data); 301| 34.0k|} pcre2_set_callout_8: 401| 34.0k|{ 402| 34.0k|mcontext->callout = callout; 403| 34.0k|mcontext->callout_data = callout_data; 404| 34.0k|return 0; 405| 34.0k|} pcre2_set_match_limit_8: 426| 34.0k|{ 427| 34.0k|mcontext->match_limit = limit; 428| 34.0k|return 0; 429| 34.0k|} pcre2_set_depth_limit_8: 433| 34.0k|{ 434| 34.0k|mcontext->depth_limit = limit; 435| 34.0k|return 0; 436| 34.0k|} pcre2_context.c:default_malloc: 57| 105k|{ 58| 105k|(void)data; 59| 105k|return malloc(size); 60| 105k|} pcre2_context.c:default_free: 64| 207k|{ 65| 207k|(void)data; 66| 207k|free(block); 67| 207k|} pcre2_dfa_match_8: 3308| 130k|{ 3309| 130k|int rc; 3310| 130k|int was_zero_terminated = 0; 3311| | 3312| 130k|const pcre2_real_code *re = (const pcre2_real_code *)code; 3313| | 3314| 130k|PCRE2_SPTR start_match; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3315| 130k|PCRE2_SPTR end_subject; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3316| 130k|PCRE2_SPTR bumpalong_limit; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3317| 130k|PCRE2_SPTR req_cu_ptr; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3318| | 3319| 130k|BOOL utf, anchored, startline, firstline; 3320| 130k|BOOL has_first_cu = FALSE; ------------------ | | 69| 130k|#define FALSE 0 ------------------ 3321| 130k|BOOL has_req_cu = FALSE; ------------------ | | 69| 130k|#define FALSE 0 ------------------ 3322| | 3323| 130k|#if PCRE2_CODE_UNIT_WIDTH == 8 3324| 130k|PCRE2_SPTR memchr_found_first_cu = NULL; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3325| 130k|PCRE2_SPTR memchr_found_first_cu2 = NULL; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3326| 130k|#endif 3327| | 3328| 130k|PCRE2_UCHAR first_cu = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3329| 130k|PCRE2_UCHAR first_cu2 = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3330| 130k|PCRE2_UCHAR req_cu = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3331| 130k|PCRE2_UCHAR req_cu2 = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3332| | 3333| 130k|const uint8_t *start_bits = NULL; 3334| | 3335| |/* We need to have mb pointing to a match block, because the IS_NEWLINE macro 3336| |is used below, and it expects NLBLOCK to be defined as a pointer. */ 3337| | 3338| 130k|pcre2_callout_block cb; ------------------ | | 831| 130k|#define pcre2_callout_block PCRE2_SUFFIX(pcre2_callout_block_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3339| 130k|dfa_match_block actual_match_block; ------------------ | | 1981| 130k|#define dfa_match_block PCRE2_SUFFIX(dfa_match_block_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3340| 130k|dfa_match_block *mb = &actual_match_block; ------------------ | | 1981| 130k|#define dfa_match_block PCRE2_SUFFIX(dfa_match_block_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3341| | 3342| |/* Set up a starting block of memory for use during recursive calls to 3343| |internal_dfa_match(). By putting this on the stack, it minimizes resource use 3344| |in the case when it is not needed. If this is too small, more memory is 3345| |obtained from the heap. At the start of each block is an anchor structure.*/ 3346| | 3347| 130k|int base_recursion_workspace[RWS_BASE_SIZE]; 3348| 130k|RWS_anchor *rws = (RWS_anchor *)base_recursion_workspace; 3349| 130k|rws->next = NULL; 3350| 130k|rws->size = RWS_BASE_SIZE; ------------------ | | 319| 130k|#define RWS_BASE_SIZE (DFA_START_RWS_SIZE/sizeof(int)) /* Stack vector */ | | ------------------ | | | | 235| 130k|#define DFA_START_RWS_SIZE 30720 | | ------------------ ------------------ 3351| 130k|rws->free = RWS_BASE_SIZE - RWS_ANCHOR_SIZE; ------------------ | | 319| 130k|#define RWS_BASE_SIZE (DFA_START_RWS_SIZE/sizeof(int)) /* Stack vector */ | | ------------------ | | | | 235| 130k|#define DFA_START_RWS_SIZE 30720 | | ------------------ ------------------ rws->free = RWS_BASE_SIZE - RWS_ANCHOR_SIZE; ------------------ | | 332| 130k|#define RWS_ANCHOR_SIZE (sizeof(RWS_anchor)/sizeof(int)) ------------------ 3352| | 3353| |/* Recognize NULL, length 0 as an empty string. */ 3354| | 3355| 130k|if (subject == NULL && length == 0) subject = (PCRE2_SPTR)""; ------------------ | Branch (3355:5): [True: 0, False: 130k] | Branch (3355:24): [True: 0, False: 0] ------------------ 3356| | 3357| |/* Plausibility checks */ 3358| | 3359| 130k|if ((options & ~PUBLIC_DFA_MATCH_OPTIONS) != 0) return PCRE2_ERROR_BADOPTION; ------------------ | | 86| 130k| (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 105| 130k|#define PCRE2_ANCHORED 0x80000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 107| 130k|#define PCRE2_ENDANCHORED 0x20000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 176| 130k|#define PCRE2_NOTBOL 0x00000001u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 177| 130k|#define PCRE2_NOTEOL 0x00000002u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 178| 130k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ | | ------------------ | | 87| 130k| PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 179| 130k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ | | ------------------ | | PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 106| 130k|#define PCRE2_NO_UTF_CHECK 0x40000000u | | ------------------ | | PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 181| 130k|#define PCRE2_PARTIAL_HARD 0x00000020u | | ------------------ | | 88| 130k| PCRE2_PARTIAL_SOFT|PCRE2_DFA_SHORTEST|PCRE2_DFA_RESTART| \ | | ------------------ | | | | 180| 130k|#define PCRE2_PARTIAL_SOFT 0x00000010u | | ------------------ | | PCRE2_PARTIAL_SOFT|PCRE2_DFA_SHORTEST|PCRE2_DFA_RESTART| \ | | ------------------ | | | | 183| 130k|#define PCRE2_DFA_SHORTEST 0x00000080u /* pcre2_dfa_match() only */ | | ------------------ | | PCRE2_PARTIAL_SOFT|PCRE2_DFA_SHORTEST|PCRE2_DFA_RESTART| \ | | ------------------ | | | | 182| 130k|#define PCRE2_DFA_RESTART 0x00000040u /* pcre2_dfa_match() only */ | | ------------------ | | 89| 130k| PCRE2_COPY_MATCHED_SUBJECT) | | ------------------ | | | | 190| 130k|#define PCRE2_COPY_MATCHED_SUBJECT 0x00004000u | | ------------------ ------------------ if ((options & ~PUBLIC_DFA_MATCH_OPTIONS) != 0) return PCRE2_ERROR_BADOPTION; ------------------ | | 374| 0|#define PCRE2_ERROR_BADOPTION (-34) ------------------ | Branch (3359:5): [True: 0, False: 130k] ------------------ 3360| 130k|if (re == NULL || subject == NULL || workspace == NULL || match_data == NULL) ------------------ | Branch (3360:5): [True: 0, False: 130k] | Branch (3360:19): [True: 0, False: 130k] | Branch (3360:38): [True: 0, False: 130k] | Branch (3360:59): [True: 0, False: 130k] ------------------ 3361| 0| return PCRE2_ERROR_NULL; ------------------ | | 391| 0|#define PCRE2_ERROR_NULL (-51) ------------------ 3362| | 3363| 130k|if (length == PCRE2_ZERO_TERMINATED) ------------------ | | 479| 130k|#define PCRE2_ZERO_TERMINATED (~(PCRE2_SIZE)0) ------------------ | Branch (3363:5): [True: 0, False: 130k] ------------------ 3364| 0| { 3365| 0| length = PRIV(strlen)(subject); ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 3366| 0| was_zero_terminated = 1; 3367| 0| } 3368| | 3369| 130k|if (wscount < 20) return PCRE2_ERROR_DFA_WSSIZE; ------------------ | | 383| 0|#define PCRE2_ERROR_DFA_WSSIZE (-43) ------------------ | Branch (3369:5): [True: 0, False: 130k] ------------------ 3370| 130k|if (start_offset > length) return PCRE2_ERROR_BADOFFSET; ------------------ | | 373| 0|#define PCRE2_ERROR_BADOFFSET (-33) ------------------ | Branch (3370:5): [True: 0, False: 130k] ------------------ 3371| | 3372| |/* Partial matching and PCRE2_ENDANCHORED are currently not allowed at the same 3373| |time. */ 3374| | 3375| 130k|if ((options & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && ------------------ | | 181| 130k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ if ((options & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && ------------------ | | 180| 130k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (3375:5): [True: 27.8k, False: 102k] ------------------ 3376| 130k| ((re->overall_options | options) & PCRE2_ENDANCHORED) != 0) ------------------ | | 107| 27.8k|#define PCRE2_ENDANCHORED 0x20000000u ------------------ | Branch (3376:4): [True: 0, False: 27.8k] ------------------ 3377| 0| return PCRE2_ERROR_BADOPTION; ------------------ | | 374| 0|#define PCRE2_ERROR_BADOPTION (-34) ------------------ 3378| | 3379| |/* Invalid UTF support is not available for DFA matching. */ 3380| | 3381| 130k|if ((re->overall_options & PCRE2_MATCH_INVALID_UTF) != 0) ------------------ | | 145| 130k|#define PCRE2_MATCH_INVALID_UTF 0x04000000u /* J M D */ ------------------ | Branch (3381:5): [True: 0, False: 130k] ------------------ 3382| 0| return PCRE2_ERROR_DFA_UINVALID_UTF; ------------------ | | 407| 0|#define PCRE2_ERROR_DFA_UINVALID_UTF (-66) ------------------ 3383| | 3384| |/* Check that the first field in the block is the magic number. If it is not, 3385| |return with PCRE2_ERROR_BADMAGIC. */ 3386| | 3387| 130k|if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC; ------------------ | | 546| 130k|#define MAGIC_NUMBER 0x50435245UL /* 'PCRE' */ ------------------ if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC; ------------------ | | 371| 0|#define PCRE2_ERROR_BADMAGIC (-31) ------------------ | Branch (3387:5): [True: 0, False: 130k] ------------------ 3388| | 3389| |/* Check the code unit width. */ 3390| | 3391| 130k|if ((re->flags & PCRE2_MODE_MASK) != PCRE2_CODE_UNIT_WIDTH/8) ------------------ | | 532| 130k|#define PCRE2_MODE_MASK (PCRE2_MODE8 | PCRE2_MODE16 | PCRE2_MODE32) | | ------------------ | | | | 508| 130k|#define PCRE2_MODE8 0x00000001 /* compiled in 8 bit mode */ | | ------------------ | | #define PCRE2_MODE_MASK (PCRE2_MODE8 | PCRE2_MODE16 | PCRE2_MODE32) | | ------------------ | | | | 509| 130k|#define PCRE2_MODE16 0x00000002 /* compiled in 16 bit mode */ | | ------------------ | | #define PCRE2_MODE_MASK (PCRE2_MODE8 | PCRE2_MODE16 | PCRE2_MODE32) | | ------------------ | | | | 510| 130k|#define PCRE2_MODE32 0x00000004 /* compiled in 32 bit mode */ | | ------------------ ------------------ | Branch (3391:5): [True: 0, False: 130k] ------------------ 3392| 0| return PCRE2_ERROR_BADMODE; ------------------ | | 372| 0|#define PCRE2_ERROR_BADMODE (-32) ------------------ 3393| | 3394| |/* PCRE2_NOTEMPTY and PCRE2_NOTEMPTY_ATSTART are match-time flags in the 3395| |options variable for this function. Users of PCRE2 who are not calling the 3396| |function directly would like to have a way of setting these flags, in the same 3397| |way that they can set pcre2_compile() flags like PCRE2_NO_AUTOPOSSESS with 3398| |constructions like (*NO_AUTOPOSSESS). To enable this, (*NOTEMPTY) and 3399| |(*NOTEMPTY_ATSTART) set bits in the pattern's "flag" function which can now be 3400| |transferred to the options for this function. The bits are guaranteed to be 3401| |adjacent, but do not have the same values. This bit of Boolean trickery assumes 3402| |that the match-time bits are not more significant than the flag bits. If by 3403| |accident this is not the case, a compile-time division by zero error will 3404| |occur. */ 3405| | 3406| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) 3407| 130k|#define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) 3408| 130k|options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 3406| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 523| 130k|#define PCRE2_NOTEMPTY_SET 0x00010000 /* (*NOTEMPTY) used ) keep */ | | ------------------ | | #define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 524| 130k|#define PCRE2_NE_ATST_SET 0x00020000 /* (*NOTEMPTY_ATSTART) used) together */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 3406| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 523| 130k|#define PCRE2_NOTEMPTY_SET 0x00010000 /* (*NOTEMPTY) used ) keep */ | | ------------------ | | #define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 524| 130k|#define PCRE2_NE_ATST_SET 0x00020000 /* (*NOTEMPTY_ATSTART) used) together */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 3406| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 523| 130k|#define PCRE2_NOTEMPTY_SET 0x00010000 /* (*NOTEMPTY) used ) keep */ | | ------------------ | | #define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 524| 130k|#define PCRE2_NE_ATST_SET 0x00020000 /* (*NOTEMPTY_ATSTART) used) together */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 3407| 130k|#define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 178| 130k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ | | ------------------ | | #define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 179| 130k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 3407| 130k|#define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 178| 130k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ | | ------------------ | | #define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 179| 130k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ | | ------------------ ------------------ 3409| 130k|#undef FF 3410| 130k|#undef OO 3411| | 3412| |/* If restarting after a partial match, do some sanity checks on the contents 3413| |of the workspace. */ 3414| | 3415| 130k|if ((options & PCRE2_DFA_RESTART) != 0) ------------------ | | 182| 130k|#define PCRE2_DFA_RESTART 0x00000040u /* pcre2_dfa_match() only */ ------------------ | Branch (3415:5): [True: 0, False: 130k] ------------------ 3416| 0| { 3417| 0| if ((workspace[0] & (-2)) != 0 || workspace[1] < 1 || ------------------ | Branch (3417:7): [True: 0, False: 0] | Branch (3417:37): [True: 0, False: 0] ------------------ 3418| 0| workspace[1] > (int)((wscount - 2)/INTS_PER_STATEBLOCK)) ------------------ | | 303| 0|#define INTS_PER_STATEBLOCK (int)(sizeof(stateblock)/sizeof(int)) ------------------ | Branch (3418:5): [True: 0, False: 0] ------------------ 3419| 0| return PCRE2_ERROR_DFA_BADRESTART; ------------------ | | 378| 0|#define PCRE2_ERROR_DFA_BADRESTART (-38) ------------------ 3420| 0| } 3421| | 3422| |/* Set some local values */ 3423| | 3424| 130k|utf = (re->overall_options & PCRE2_UTF) != 0; ------------------ | | 138| 130k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 3425| 130k|start_match = subject + start_offset; 3426| 130k|end_subject = subject + length; 3427| 130k|req_cu_ptr = start_match - 1; 3428| 130k|anchored = (options & (PCRE2_ANCHORED|PCRE2_DFA_RESTART)) != 0 || ------------------ | | 105| 130k|#define PCRE2_ANCHORED 0x80000000u ------------------ anchored = (options & (PCRE2_ANCHORED|PCRE2_DFA_RESTART)) != 0 || ------------------ | | 182| 130k|#define PCRE2_DFA_RESTART 0x00000040u /* pcre2_dfa_match() only */ ------------------ | Branch (3428:12): [True: 18.7k, False: 111k] ------------------ 3429| 130k| (re->overall_options & PCRE2_ANCHORED) != 0; ------------------ | | 105| 111k|#define PCRE2_ANCHORED 0x80000000u ------------------ | Branch (3429:3): [True: 10.1k, False: 101k] ------------------ 3430| | 3431| |/* The "must be at the start of a line" flags are used in a loop when finding 3432| |where to start. */ 3433| | 3434| 130k|startline = (re->flags & PCRE2_STARTLINE) != 0; ------------------ | | 516| 130k|#define PCRE2_STARTLINE 0x00000200 /* start after \n for multiline */ ------------------ 3435| 130k|firstline = (re->overall_options & PCRE2_FIRSTLINE) != 0; ------------------ | | 127| 130k|#define PCRE2_FIRSTLINE 0x00000100u /* J M D */ ------------------ 3436| 130k|bumpalong_limit = end_subject; 3437| | 3438| |/* Initialize and set up the fixed fields in the callout block, with a pointer 3439| |in the match block. */ 3440| | 3441| 130k|mb->cb = &cb; 3442| 130k|cb.version = 2; 3443| 130k|cb.subject = subject; 3444| 130k|cb.subject_length = (PCRE2_SIZE)(end_subject - subject); 3445| 130k|cb.callout_flags = 0; 3446| 130k|cb.capture_top = 1; /* No capture support */ 3447| 130k|cb.capture_last = 0; 3448| 130k|cb.mark = NULL; /* No (*MARK) support */ 3449| | 3450| |/* Get data from the match context, if present, and fill in the remaining 3451| |fields in the match block. It is an error to set an offset limit without 3452| |setting the flag at compile time. */ 3453| | 3454| 130k|if (mcontext == NULL) ------------------ | Branch (3454:5): [True: 0, False: 130k] ------------------ 3455| 0| { 3456| 0| mb->callout = NULL; 3457| 0| mb->memctl = re->memctl; 3458| 0| mb->match_limit = PRIV(default_match_context).match_limit; ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 3459| 0| mb->match_limit_depth = PRIV(default_match_context).depth_limit; ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 3460| 0| mb->heap_limit = PRIV(default_match_context).heap_limit; ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 3461| 0| } 3462| 130k|else 3463| 130k| { 3464| 130k| if (mcontext->offset_limit != PCRE2_UNSET) ------------------ | | 480| 130k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (3464:7): [True: 0, False: 130k] ------------------ 3465| 0| { 3466| 0| if ((re->overall_options & PCRE2_USE_OFFSET_LIMIT) == 0) ------------------ | | 142| 0|#define PCRE2_USE_OFFSET_LIMIT 0x00800000u /* J M D */ ------------------ | Branch (3466:9): [True: 0, False: 0] ------------------ 3467| 0| return PCRE2_ERROR_BADOFFSETLIMIT; ------------------ | | 397| 0|#define PCRE2_ERROR_BADOFFSETLIMIT (-56) ------------------ 3468| 0| bumpalong_limit = subject + mcontext->offset_limit; 3469| 0| } 3470| 130k| mb->callout = mcontext->callout; 3471| 130k| mb->callout_data = mcontext->callout_data; 3472| 130k| mb->memctl = mcontext->memctl; 3473| 130k| mb->match_limit = mcontext->match_limit; 3474| 130k| mb->match_limit_depth = mcontext->depth_limit; 3475| 130k| mb->heap_limit = mcontext->heap_limit; 3476| 130k| } 3477| | 3478| 130k|if (mb->match_limit > re->limit_match) ------------------ | Branch (3478:5): [True: 0, False: 130k] ------------------ 3479| 0| mb->match_limit = re->limit_match; 3480| | 3481| 130k|if (mb->match_limit_depth > re->limit_depth) ------------------ | Branch (3481:5): [True: 0, False: 130k] ------------------ 3482| 0| mb->match_limit_depth = re->limit_depth; 3483| | 3484| 130k|if (mb->heap_limit > re->limit_heap) ------------------ | Branch (3484:5): [True: 0, False: 130k] ------------------ 3485| 0| mb->heap_limit = re->limit_heap; 3486| | 3487| 130k|mb->start_code = (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code)) + 3488| 130k| re->name_count * re->name_entry_size; 3489| 130k|mb->tables = re->tables; 3490| 130k|mb->start_subject = subject; 3491| 130k|mb->end_subject = end_subject; 3492| 130k|mb->start_offset = start_offset; 3493| 130k|mb->allowemptypartial = (re->max_lookbehind > 0) || ------------------ | Branch (3493:25): [True: 5.83k, False: 124k] ------------------ 3494| 130k| (re->flags & PCRE2_MATCH_EMPTY) != 0; ------------------ | | 520| 124k|#define PCRE2_MATCH_EMPTY 0x00002000 /* pattern can match empty string */ ------------------ | Branch (3494:3): [True: 32.8k, False: 91.8k] ------------------ 3495| 130k|mb->moptions = options; 3496| 130k|mb->poptions = re->overall_options; 3497| 130k|mb->match_call_count = 0; 3498| 130k|mb->heap_used = 0; 3499| | 3500| |/* Process the \R and newline settings. */ 3501| | 3502| 130k|mb->bsr_convention = re->bsr_convention; 3503| 130k|mb->nltype = NLTYPE_FIXED; ------------------ | | 472| 130k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ 3504| 130k|switch(re->newline_convention) 3505| 130k| { 3506| 170| case PCRE2_NEWLINE_CR: ------------------ | | 209| 170|#define PCRE2_NEWLINE_CR 1 ------------------ | Branch (3506:3): [True: 170, False: 130k] ------------------ 3507| 170| mb->nllen = 1; 3508| 170| mb->nl[0] = CHAR_CR; ------------------ | | 972| 170|#define CHAR_CR '\015' ------------------ 3509| 170| break; 3510| | 3511| 125k| case PCRE2_NEWLINE_LF: ------------------ | | 210| 125k|#define PCRE2_NEWLINE_LF 2 ------------------ | Branch (3511:3): [True: 125k, False: 5.09k] ------------------ 3512| 125k| mb->nllen = 1; 3513| 125k| mb->nl[0] = CHAR_NL; ------------------ | | 974| 125k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 125k|#define CHAR_LF '\012' | | ------------------ ------------------ 3514| 125k| break; 3515| | 3516| 10| case PCRE2_NEWLINE_NUL: ------------------ | | 214| 10|#define PCRE2_NEWLINE_NUL 6 ------------------ | Branch (3516:3): [True: 10, False: 130k] ------------------ 3517| 10| mb->nllen = 1; 3518| 10| mb->nl[0] = CHAR_NUL; ------------------ | | 981| 10|#define CHAR_NUL '\0' ------------------ 3519| 10| break; 3520| | 3521| 2.34k| case PCRE2_NEWLINE_CRLF: ------------------ | | 211| 2.34k|#define PCRE2_NEWLINE_CRLF 3 ------------------ | Branch (3521:3): [True: 2.34k, False: 128k] ------------------ 3522| 2.34k| mb->nllen = 2; 3523| 2.34k| mb->nl[0] = CHAR_CR; ------------------ | | 972| 2.34k|#define CHAR_CR '\015' ------------------ 3524| 2.34k| mb->nl[1] = CHAR_NL; ------------------ | | 974| 2.34k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 2.34k|#define CHAR_LF '\012' | | ------------------ ------------------ 3525| 2.34k| break; 3526| | 3527| 2.31k| case PCRE2_NEWLINE_ANY: ------------------ | | 212| 2.31k|#define PCRE2_NEWLINE_ANY 4 ------------------ | Branch (3527:3): [True: 2.31k, False: 128k] ------------------ 3528| 2.31k| mb->nltype = NLTYPE_ANY; ------------------ | | 473| 2.31k|#define NLTYPE_ANY 1 /* Newline is any Unicode line ending */ ------------------ 3529| 2.31k| break; 3530| | 3531| 252| case PCRE2_NEWLINE_ANYCRLF: ------------------ | | 213| 252|#define PCRE2_NEWLINE_ANYCRLF 5 ------------------ | Branch (3531:3): [True: 252, False: 130k] ------------------ 3532| 252| mb->nltype = NLTYPE_ANYCRLF; ------------------ | | 474| 252|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ 3533| 252| break; 3534| | 3535| 0| default: return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ | Branch (3535:3): [True: 0, False: 130k] ------------------ 3536| 130k| } 3537| | 3538| |/* Check a UTF string for validity if required. For 8-bit and 16-bit strings, 3539| |we must also check that a starting offset does not point into the middle of a 3540| |multiunit character. We check only the portion of the subject that is going to 3541| |be inspected during matching - from the offset minus the maximum back reference 3542| |to the given length. This saves time when a small part of a large subject is 3543| |being matched by the use of a starting offset. Note that the maximum lookbehind 3544| |is a number of characters, not code units. */ 3545| | 3546| 130k|#ifdef SUPPORT_UNICODE 3547| 130k|if (utf && (options & PCRE2_NO_UTF_CHECK) == 0) ------------------ | | 106| 43.9k|#define PCRE2_NO_UTF_CHECK 0x40000000u ------------------ | Branch (3547:5): [True: 43.9k, False: 86.5k] | Branch (3547:12): [True: 43.9k, False: 0] ------------------ 3548| 43.9k| { 3549| 43.9k| PCRE2_SPTR check_subject = start_match; /* start_match includes offset */ ------------------ | | 814| 43.9k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 43.9k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 43.9k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 43.9k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3550| | 3551| 43.9k| if (start_offset > 0) ------------------ | Branch (3551:7): [True: 0, False: 43.9k] ------------------ 3552| 0| { 3553| 0|#if PCRE2_CODE_UNIT_WIDTH != 32 3554| 0| unsigned int i; 3555| 0| if (start_match < end_subject && NOT_FIRSTCU(*start_match)) ------------------ | | 296| 0|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3555:9): [True: 0, False: 0] ------------------ 3556| 0| return PCRE2_ERROR_BADUTFOFFSET; ------------------ | | 376| 0|#define PCRE2_ERROR_BADUTFOFFSET (-36) ------------------ 3557| 0| for (i = re->max_lookbehind; i > 0 && check_subject > subject; i--) ------------------ | Branch (3557:34): [True: 0, False: 0] | Branch (3557:43): [True: 0, False: 0] ------------------ 3558| 0| { 3559| 0| check_subject--; 3560| 0| while (check_subject > subject && ------------------ | Branch (3560:14): [True: 0, False: 0] ------------------ 3561| 0|#if PCRE2_CODE_UNIT_WIDTH == 8 3562| 0| (*check_subject & 0xc0) == 0x80) ------------------ | Branch (3562:7): [True: 0, False: 0] ------------------ 3563| |#else /* 16-bit */ 3564| | (*check_subject & 0xfc00) == 0xdc00) 3565| |#endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 3566| 0| check_subject--; 3567| 0| } 3568| |#else /* In the 32-bit library, one code unit equals one character. */ 3569| | check_subject -= re->max_lookbehind; 3570| | if (check_subject < subject) check_subject = subject; 3571| |#endif /* PCRE2_CODE_UNIT_WIDTH != 32 */ 3572| 0| } 3573| | 3574| | /* Validate the relevant portion of the subject. After an error, adjust the 3575| | offset to be an absolute offset in the whole string. */ 3576| | 3577| 43.9k| match_data->rc = PRIV(valid_utf)(check_subject, ------------------ | | 177| 43.9k|#define PRIV(name) _pcre2_##name ------------------ 3578| 43.9k| length - (PCRE2_SIZE)(check_subject - subject), &(match_data->startchar)); 3579| 43.9k| if (match_data->rc != 0) ------------------ | Branch (3579:7): [True: 20, False: 43.9k] ------------------ 3580| 20| { 3581| 20| match_data->startchar += (PCRE2_SIZE)(check_subject - subject); 3582| 20| return match_data->rc; 3583| 20| } 3584| 43.9k| } 3585| 130k|#endif /* SUPPORT_UNICODE */ 3586| | 3587| |/* Set up the first code unit to match, if available. If there's no first code 3588| |unit there may be a bitmap of possible first characters. */ 3589| | 3590| 130k|if ((re->flags & PCRE2_FIRSTSET) != 0) ------------------ | | 511| 130k|#define PCRE2_FIRSTSET 0x00000010 /* first_code unit is set */ ------------------ | Branch (3590:5): [True: 17.3k, False: 113k] ------------------ 3591| 17.3k| { 3592| 17.3k| has_first_cu = TRUE; ------------------ | | 70| 17.3k|#define TRUE 1 ------------------ 3593| 17.3k| first_cu = first_cu2 = (PCRE2_UCHAR)(re->first_codeunit); 3594| 17.3k| if ((re->flags & PCRE2_FIRSTCASELESS) != 0) ------------------ | | 512| 17.3k|#define PCRE2_FIRSTCASELESS 0x00000020 /* caseless first code unit */ ------------------ | Branch (3594:7): [True: 890, False: 16.4k] ------------------ 3595| 890| { 3596| 890| first_cu2 = TABLE_GET(first_cu, mb->tables + fcc_offset, first_cu); ------------------ | | 214| 890|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 3597| 890|#ifdef SUPPORT_UNICODE 3598| 890|#if PCRE2_CODE_UNIT_WIDTH == 8 3599| 890| if (first_cu > 127 && !utf && (re->overall_options & PCRE2_UCP) != 0) ------------------ | | 136| 128|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (3599:9): [True: 128, False: 762] | Branch (3599:27): [True: 128, False: 0] | Branch (3599:35): [True: 128, False: 0] ------------------ 3600| 128| first_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(first_cu); ------------------ | | 1862| 128|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 128|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 128|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 128|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 128| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 128|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 128|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 128|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 128| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 128|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 128|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3601| |#else 3602| | if (first_cu > 127 && (utf || (re->overall_options & PCRE2_UCP) != 0)) 3603| | first_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(first_cu); 3604| |#endif 3605| 890|#endif /* SUPPORT_UNICODE */ 3606| 890| } 3607| 17.3k| } 3608| 113k|else 3609| 113k| if (!startline && (re->flags & PCRE2_FIRSTMAPSET) != 0) ------------------ | | 513| 109k|#define PCRE2_FIRSTMAPSET 0x00000040 /* bitmap of first code units is set */ ------------------ | Branch (3609:7): [True: 109k, False: 3.46k] | Branch (3609:21): [True: 18.8k, False: 90.7k] ------------------ 3610| 18.8k| start_bits = re->start_bitmap; 3611| | 3612| |/* There may be a "last known required code unit" set. */ 3613| | 3614| 130k|if ((re->flags & PCRE2_LASTSET) != 0) ------------------ | | 514| 130k|#define PCRE2_LASTSET 0x00000080 /* last code unit is set */ ------------------ | Branch (3614:5): [True: 45.7k, False: 84.8k] ------------------ 3615| 45.7k| { 3616| 45.7k| has_req_cu = TRUE; ------------------ | | 70| 45.7k|#define TRUE 1 ------------------ 3617| 45.7k| req_cu = req_cu2 = (PCRE2_UCHAR)(re->last_codeunit); 3618| 45.7k| if ((re->flags & PCRE2_LASTCASELESS) != 0) ------------------ | | 515| 45.7k|#define PCRE2_LASTCASELESS 0x00000100 /* caseless last code unit */ ------------------ | Branch (3618:7): [True: 1.70k, False: 43.9k] ------------------ 3619| 1.70k| { 3620| 1.70k| req_cu2 = TABLE_GET(req_cu, mb->tables + fcc_offset, req_cu); ------------------ | | 214| 1.70k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 3621| 1.70k|#ifdef SUPPORT_UNICODE 3622| 1.70k|#if PCRE2_CODE_UNIT_WIDTH == 8 3623| 1.70k| if (req_cu > 127 && !utf && (re->overall_options & PCRE2_UCP) != 0) ------------------ | | 136| 262|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (3623:9): [True: 262, False: 1.44k] | Branch (3623:25): [True: 262, False: 0] | Branch (3623:33): [True: 262, False: 0] ------------------ 3624| 262| req_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(req_cu); ------------------ | | 1862| 262|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 262|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 262|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 262|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 262| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 262|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 262|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 262|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 262| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 262|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 262|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3625| |#else 3626| | if (req_cu > 127 && (utf || (re->overall_options & PCRE2_UCP) != 0)) 3627| | req_cu2 = (PCRE2_UCHAR)UCD_OTHERCASE(req_cu); 3628| |#endif 3629| 1.70k|#endif /* SUPPORT_UNICODE */ 3630| 1.70k| } 3631| 45.7k| } 3632| | 3633| |/* If the match data block was previously used with PCRE2_COPY_MATCHED_SUBJECT, 3634| |free the memory that was obtained. */ 3635| | 3636| 130k|if ((match_data->flags & PCRE2_MD_COPIED_SUBJECT) != 0) ------------------ | | 542| 130k|#define PCRE2_MD_COPIED_SUBJECT 0x01u ------------------ | Branch (3636:5): [True: 0, False: 130k] ------------------ 3637| 0| { 3638| 0| match_data->memctl.free((void *)match_data->subject, 3639| 0| match_data->memctl.memory_data); 3640| 0| match_data->flags &= ~PCRE2_MD_COPIED_SUBJECT; ------------------ | | 542| 0|#define PCRE2_MD_COPIED_SUBJECT 0x01u ------------------ 3641| 0| } 3642| | 3643| |/* Fill in fields that are always returned in the match data. */ 3644| | 3645| 130k|match_data->code = re; 3646| 130k|match_data->subject = NULL; /* Default for no match */ 3647| 130k|match_data->mark = NULL; 3648| 130k|match_data->matchedby = PCRE2_MATCHEDBY_DFA_INTERPRETER; 3649| | 3650| |/* Call the main matching function, looping for a non-anchored regex after a 3651| |failed match. If not restarting, perform certain optimizations at the start of 3652| |a match. */ 3653| | 3654| 130k|for (;;) 3655| 558k| { 3656| | /* ----------------- Start of match optimizations ---------------- */ 3657| | 3658| | /* There are some optimizations that avoid running the match if a known 3659| | starting point is not found, or if a known later code unit is not present. 3660| | However, there is an option (settable at compile time) that disables 3661| | these, for testing and for ensuring that all callouts do actually occur. 3662| | The optimizations must also be avoided when restarting a DFA match. */ 3663| | 3664| 558k| if ((re->overall_options & PCRE2_NO_START_OPTIMIZE) == 0 && ------------------ | | 135| 558k|#define PCRE2_NO_START_OPTIMIZE 0x00010000u /* J M D */ ------------------ | Branch (3664:7): [True: 374k, False: 183k] ------------------ 3665| 558k| (options & PCRE2_DFA_RESTART) == 0) ------------------ | | 182| 374k|#define PCRE2_DFA_RESTART 0x00000040u /* pcre2_dfa_match() only */ ------------------ | Branch (3665:7): [True: 374k, False: 0] ------------------ 3666| 374k| { 3667| | /* If firstline is TRUE, the start of the match is constrained to the first 3668| | line of a multiline string. That is, the match must be before or at the 3669| | first newline following the start of matching. Temporarily adjust 3670| | end_subject so that we stop the optimization scans for a first code unit 3671| | immediately after the first character of a newline (the first code unit can 3672| | legitimately be a newline). If the match fails at the newline, later code 3673| | breaks this loop. */ 3674| | 3675| 374k| if (firstline) ------------------ | Branch (3675:9): [True: 76.7k, False: 297k] ------------------ 3676| 76.7k| { 3677| 76.7k| PCRE2_SPTR t = start_match; ------------------ | | 814| 76.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 76.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3678| 76.7k|#ifdef SUPPORT_UNICODE 3679| 76.7k| if (utf) ------------------ | Branch (3679:11): [True: 49.7k, False: 26.9k] ------------------ 3680| 49.7k| { 3681| 808k| while (t < end_subject && !IS_NEWLINE(t)) ------------------ | | 479| 761k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 761k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 761k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 9.27k, False: 751k] | | ------------------ | | 480| 761k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 9.27k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 18.5k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 9.27k, False: 0] | | ------------------ | | 481| 9.27k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 9.27k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 9.27k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 9.27k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 9.27k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 448, False: 8.82k] | | ------------------ | | 482| 9.27k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 9.27k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 761k| : \ | | 484| 761k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 751k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 751k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 751k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 750k, False: 1.44k] | | ------------------ | | 485| 751k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 750k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 750k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 9.29k, False: 741k] | | ------------------ | | 486| 751k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 9.29k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 7.80k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 7.80k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.49k, False: 7.80k] | | | Branch (486:30): [True: 252, False: 7.55k] | | ------------------ | | 487| 751k| ) \ | | 488| 761k| ) ------------------ | Branch (3681:16): [True: 761k, False: 47.5k] | Branch (3681:35): [True: 759k, False: 2.19k] ------------------ 3682| 759k| { 3683| 759k| t++; 3684| 759k| ACROSSCHAR(t < end_subject, t, t++); ------------------ | | 353| 815k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 769k, False: 45.5k] | | | Branch (353:24): [True: 56.1k, False: 713k] | | ------------------ ------------------ 3685| 759k| } 3686| 49.7k| } 3687| 26.9k| else 3688| 26.9k|#endif 3689| 437k| while (t < end_subject && !IS_NEWLINE(t)) t++; ------------------ | | 479| 411k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 411k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 411k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 6.60k, False: 404k] | | ------------------ | | 480| 411k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 6.60k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 13.2k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 6.60k, False: 0] | | ------------------ | | 481| 6.60k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 6.60k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 6.60k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 6.60k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 6.60k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 286, False: 6.31k] | | ------------------ | | 482| 6.60k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 6.60k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 411k| : \ | | 484| 411k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 404k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 404k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 404k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 403k, False: 904] | | ------------------ | | 485| 404k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 403k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 403k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 7.63k, False: 396k] | | ------------------ | | 486| 404k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 7.63k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 6.95k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 6.95k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 673, False: 6.95k] | | | Branch (486:30): [True: 102, False: 6.85k] | | ------------------ | | 487| 404k| ) \ | | 488| 411k| ) ------------------ | Branch (3689:14): [True: 411k, False: 25.8k] | Branch (3689:33): [True: 410k, False: 1.06k] ------------------ 3690| 76.7k| end_subject = t; 3691| 76.7k| } 3692| | 3693| | /* Anchored: check the first code unit if one is recorded. This may seem 3694| | pointless but it can help in detecting a no match case without scanning for 3695| | the required code unit. */ 3696| | 3697| 374k| if (anchored) ------------------ | Branch (3697:9): [True: 20.3k, False: 354k] ------------------ 3698| 20.3k| { 3699| 20.3k| if (has_first_cu || start_bits != NULL) ------------------ | Branch (3699:11): [True: 4.31k, False: 15.9k] | Branch (3699:27): [True: 2.56k, False: 13.4k] ------------------ 3700| 6.87k| { 3701| 6.87k| BOOL ok = start_match < end_subject; 3702| 6.87k| if (ok) ------------------ | Branch (3702:13): [True: 6.83k, False: 46] ------------------ 3703| 6.83k| { 3704| 6.83k| PCRE2_UCHAR c = UCHAR21TEST(start_match); ------------------ | | 813| 6.83k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 6.83k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 6.83k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 6.83k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_UCHAR c = UCHAR21TEST(start_match); ------------------ | | 244| 6.83k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 3705| 6.83k| ok = has_first_cu && (c == first_cu || c == first_cu2); ------------------ | Branch (3705:16): [True: 4.27k, False: 2.55k] | Branch (3705:33): [True: 1.76k, False: 2.50k] | Branch (3705:50): [True: 4, False: 2.50k] ------------------ 3706| 6.83k| if (!ok && start_bits != NULL) ------------------ | Branch (3706:15): [True: 5.05k, False: 1.77k] | Branch (3706:22): [True: 2.55k, False: 2.50k] ------------------ 3707| 2.55k| { 3708| |#if PCRE2_CODE_UNIT_WIDTH != 8 3709| | if (c > 255) c = 255; 3710| |#endif 3711| 2.55k| ok = (start_bits[c/8] & (1u << (c&7))) != 0; 3712| 2.55k| } 3713| 6.83k| } 3714| 6.87k| if (!ok) break; ------------------ | Branch (3714:13): [True: 3.90k, False: 2.97k] ------------------ 3715| 6.87k| } 3716| 20.3k| } 3717| | 3718| | /* Not anchored. Advance to a unique first code unit if there is one. */ 3719| | 3720| 354k| else 3721| 354k| { 3722| 354k| if (has_first_cu) ------------------ | Branch (3722:11): [True: 25.8k, False: 328k] ------------------ 3723| 25.8k| { 3724| 25.8k| if (first_cu != first_cu2) /* Caseless */ ------------------ | Branch (3724:13): [True: 2.26k, False: 23.5k] ------------------ 3725| 2.26k| { 3726| | /* In 16-bit and 32_bit modes we have to do our own search, so can 3727| | look for both cases at once. */ 3728| | 3729| |#if PCRE2_CODE_UNIT_WIDTH != 8 3730| | PCRE2_UCHAR smc; 3731| | while (start_match < end_subject && 3732| | (smc = UCHAR21TEST(start_match)) != first_cu && 3733| | smc != first_cu2) 3734| | start_match++; 3735| |#else 3736| | /* In 8-bit mode, the use of memchr() gives a big speed up, even 3737| | though we have to call it twice in order to find the earliest 3738| | occurrence of the code unit in either of its cases. Caching is used 3739| | to remember the positions of previously found code units. This can 3740| | make a huge difference when the strings are very long and only one 3741| | case is actually present. */ 3742| | 3743| 2.26k| PCRE2_SPTR pp1 = NULL; ------------------ | | 814| 2.26k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 2.26k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 2.26k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 2.26k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3744| 2.26k| PCRE2_SPTR pp2 = NULL; ------------------ | | 814| 2.26k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 2.26k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 2.26k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 2.26k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3745| 2.26k| PCRE2_SIZE searchlength = end_subject - start_match; ------------------ | | 477| 2.26k|#define PCRE2_SIZE size_t ------------------ 3746| | 3747| | /* If we haven't got a previously found position for first_cu, or if 3748| | the current starting position is later, we need to do a search. If 3749| | the code unit is not found, set it to the end. */ 3750| | 3751| 2.26k| if (memchr_found_first_cu == NULL || ------------------ | Branch (3751:15): [True: 638, False: 1.63k] ------------------ 3752| 2.26k| start_match > memchr_found_first_cu) ------------------ | Branch (3752:15): [True: 989, False: 642] ------------------ 3753| 1.62k| { 3754| 1.62k| pp1 = memchr(start_match, first_cu, searchlength); 3755| 1.62k| memchr_found_first_cu = (pp1 == NULL)? end_subject : pp1; ------------------ | Branch (3755:37): [True: 301, False: 1.32k] ------------------ 3756| 1.62k| } 3757| | 3758| | /* If the start is before a previously found position, use the 3759| | previous position, or NULL if a previous search failed. */ 3760| | 3761| 642| else pp1 = (memchr_found_first_cu == end_subject)? NULL : ------------------ | Branch (3761:22): [True: 258, False: 384] ------------------ 3762| 642| memchr_found_first_cu; 3763| | 3764| | /* Do the same thing for the other case. */ 3765| | 3766| 2.26k| if (memchr_found_first_cu2 == NULL || ------------------ | Branch (3766:15): [True: 638, False: 1.63k] ------------------ 3767| 2.26k| start_match > memchr_found_first_cu2) ------------------ | Branch (3767:15): [True: 642, False: 989] ------------------ 3768| 1.28k| { 3769| 1.28k| pp2 = memchr(start_match, first_cu2, searchlength); 3770| 1.28k| memchr_found_first_cu2 = (pp2 == NULL)? end_subject : pp2; ------------------ | Branch (3770:38): [True: 505, False: 775] ------------------ 3771| 1.28k| } 3772| | 3773| 989| else pp2 = (memchr_found_first_cu2 == end_subject)? NULL : ------------------ | Branch (3773:22): [True: 526, False: 463] ------------------ 3774| 989| memchr_found_first_cu2; 3775| | 3776| | /* Set the start to the end of the subject if neither case was found. 3777| | Otherwise, use the earlier found point. */ 3778| | 3779| 2.26k| if (pp1 == NULL) ------------------ | Branch (3779:15): [True: 559, False: 1.71k] ------------------ 3780| 559| start_match = (pp2 == NULL)? end_subject : pp2; ------------------ | Branch (3780:27): [True: 242, False: 317] ------------------ 3781| 1.71k| else 3782| 1.71k| start_match = (pp2 == NULL || pp1 < pp2)? pp1 : pp2; ------------------ | Branch (3782:28): [True: 789, False: 921] | Branch (3782:43): [True: 520, False: 401] ------------------ 3783| | 3784| 2.26k|#endif /* 8-bit handling */ 3785| 2.26k| } 3786| | 3787| | /* The caseful case is much simpler. */ 3788| | 3789| 23.5k| else 3790| 23.5k| { 3791| |#if PCRE2_CODE_UNIT_WIDTH != 8 3792| | while (start_match < end_subject && UCHAR21TEST(start_match) != 3793| | first_cu) 3794| | start_match++; 3795| |#else /* 8-bit code units */ 3796| 23.5k| start_match = memchr(start_match, first_cu, end_subject - start_match); 3797| 23.5k| if (start_match == NULL) start_match = end_subject; ------------------ | Branch (3797:15): [True: 4.43k, False: 19.1k] ------------------ 3798| 23.5k|#endif 3799| 23.5k| } 3800| | 3801| | /* If we can't find the required code unit, having reached the true end 3802| | of the subject, break the bumpalong loop, to force a match failure, 3803| | except when doing partial matching, when we let the next cycle run at 3804| | the end of the subject. To see why, consider the pattern /(?<=abc)def/, 3805| | which partially matches "abc", even though the string does not contain 3806| | the starting character "d". If we have not reached the true end of the 3807| | subject (PCRE2_FIRSTLINE caused end_subject to be temporarily modified) 3808| | we also let the cycle run, because the matching string is legitimately 3809| | allowed to start with the first code unit of a newline. */ 3810| | 3811| 25.8k| if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0 && ------------------ | | 181| 25.8k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0 && ------------------ | | 180| 25.8k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (3811:13): [True: 20.7k, False: 5.10k] ------------------ 3812| 25.8k| start_match >= mb->end_subject) ------------------ | Branch (3812:13): [True: 3.56k, False: 17.1k] ------------------ 3813| 3.56k| break; 3814| 25.8k| } 3815| | 3816| | /* If there's no first code unit, advance to just after a linebreak for a 3817| | multiline match if required. */ 3818| | 3819| 328k| else if (startline) ------------------ | Branch (3819:16): [True: 6.28k, False: 322k] ------------------ 3820| 6.28k| { 3821| 6.28k| if (start_match > mb->start_subject + start_offset) ------------------ | Branch (3821:13): [True: 3.11k, False: 3.17k] ------------------ 3822| 3.11k| { 3823| 3.11k|#ifdef SUPPORT_UNICODE 3824| 3.11k| if (utf) ------------------ | Branch (3824:15): [True: 639, False: 2.47k] ------------------ 3825| 639| { 3826| 4.68k| while (start_match < end_subject && !WAS_NEWLINE(start_match)) ------------------ | | 493| 4.44k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 4.44k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 4.44k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (493:4): [True: 2.20k, False: 2.23k] | | ------------------ | | 494| 4.44k| ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 79| 2.20k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 80| 4.41k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (494:6): [True: 2.20k, False: 0] | | ------------------ | | 495| 2.20k| PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 177| 2.20k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 79| 2.20k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 79| 2.20k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 80| 2.20k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (495:6): [True: 65, False: 2.14k] | | ------------------ | | 496| 2.20k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 2.20k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 497| 4.44k| : \ | | 498| 4.44k| ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 79| 2.23k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 80| 2.23k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 79| 2.23k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (498:6): [True: 2.19k, False: 39] | | ------------------ | | 499| 2.23k| UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 2.19k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 2.19k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (499:6): [True: 546, False: 1.65k] | | ------------------ | | 500| 2.23k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 546|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 228|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 228|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (500:7): [True: 318, False: 228] | | | Branch (500:30): [True: 18, False: 210] | | ------------------ | | 501| 2.23k| ) \ | | 502| 4.44k| ) ------------------ | Branch (3826:20): [True: 4.44k, False: 238] | Branch (3826:49): [True: 4.04k, False: 401] ------------------ 3827| 4.04k| { 3828| 4.04k| start_match++; 3829| 4.04k| ACROSSCHAR(start_match < end_subject, start_match, start_match++); ------------------ | | 353| 4.47k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 4.25k, False: 224] | | | Branch (353:24): [True: 433, False: 3.82k] | | ------------------ ------------------ 3830| 4.04k| } 3831| 639| } 3832| 2.47k| else 3833| 2.47k|#endif 3834| 18.8k| while (start_match < end_subject && !WAS_NEWLINE(start_match)) ------------------ | | 493| 17.3k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 17.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 17.3k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (493:4): [True: 3.73k, False: 13.6k] | | ------------------ | | 494| 17.3k| ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 79| 3.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 80| 7.46k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (494:6): [True: 3.73k, False: 0] | | ------------------ | | 495| 3.73k| PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 177| 3.73k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 79| 3.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 79| 3.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 80| 3.73k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (495:6): [True: 668, False: 3.06k] | | ------------------ | | 496| 3.73k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 3.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 497| 17.3k| : \ | | 498| 17.3k| ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 79| 13.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 80| 13.6k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 79| 13.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (498:6): [True: 13.5k, False: 49] | | ------------------ | | 499| 13.6k| UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 13.5k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 13.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (499:6): [True: 536, False: 13.0k] | | ------------------ | | 500| 13.6k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 536|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 220|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 220|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (500:7): [True: 316, False: 220] | | | Branch (500:30): [True: 3, False: 217] | | ------------------ | | 501| 13.6k| ) \ | | 502| 17.3k| ) ------------------ | Branch (3834:18): [True: 17.3k, False: 1.48k] | Branch (3834:47): [True: 16.3k, False: 987] ------------------ 3835| 16.3k| start_match++; 3836| | 3837| | /* If we have just passed a CR and the newline option is ANY or 3838| | ANYCRLF, and we are now at a LF, advance the match position by one 3839| | more code unit. */ 3840| | 3841| 3.11k| if (start_match[-1] == CHAR_CR && ------------------ | | 972| 6.22k|#define CHAR_CR '\015' ------------------ | Branch (3841:15): [True: 888, False: 2.22k] ------------------ 3842| 3.11k| (mb->nltype == NLTYPE_ANY || mb->nltype == NLTYPE_ANYCRLF) && ------------------ | | 473| 1.77k|#define NLTYPE_ANY 1 /* Newline is any Unicode line ending */ ------------------ (mb->nltype == NLTYPE_ANY || mb->nltype == NLTYPE_ANYCRLF) && ------------------ | | 474| 441|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ | Branch (3842:17): [True: 447, False: 441] | Branch (3842:45): [True: 209, False: 232] ------------------ 3843| 3.11k| start_match < end_subject && ------------------ | Branch (3843:16): [True: 638, False: 18] ------------------ 3844| 3.11k| UCHAR21TEST(start_match) == CHAR_NL) ------------------ | | 244| 638|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ UCHAR21TEST(start_match) == CHAR_NL) ------------------ | | 974| 638|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 638|#define CHAR_LF '\012' | | ------------------ ------------------ | Branch (3844:16): [True: 194, False: 444] ------------------ 3845| 194| start_match++; 3846| 3.11k| } 3847| 6.28k| } 3848| | 3849| | /* If there's no first code unit or a requirement for a multiline line 3850| | start, advance to a non-unique first code unit if any have been 3851| | identified. The bitmap contains only 256 bits. When code units are 16 or 3852| | 32 bits wide, all code units greater than 254 set the 255 bit. */ 3853| | 3854| 322k| else if (start_bits != NULL) ------------------ | Branch (3854:16): [True: 53.4k, False: 268k] ------------------ 3855| 53.4k| { 3856| 137k| while (start_match < end_subject) ------------------ | Branch (3856:16): [True: 132k, False: 4.81k] ------------------ 3857| 132k| { 3858| 132k| uint32_t c = UCHAR21TEST(start_match); ------------------ | | 244| 132k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 3859| |#if PCRE2_CODE_UNIT_WIDTH != 8 3860| | if (c > 255) c = 255; 3861| |#endif 3862| 132k| if ((start_bits[c/8] & (1u << (c&7))) != 0) break; ------------------ | Branch (3862:15): [True: 48.6k, False: 83.6k] ------------------ 3863| 83.6k| start_match++; 3864| 83.6k| } 3865| | 3866| | /* See comment above in first_cu checking about the next line. */ 3867| | 3868| 53.4k| if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0 && ------------------ | | 181| 53.4k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0 && ------------------ | | 180| 53.4k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (3868:13): [True: 43.9k, False: 9.49k] ------------------ 3869| 53.4k| start_match >= mb->end_subject) ------------------ | Branch (3869:13): [True: 3.52k, False: 40.4k] ------------------ 3870| 3.52k| break; 3871| 53.4k| } 3872| 354k| } /* End of first code unit handling */ 3873| | 3874| | /* Restore fudged end_subject */ 3875| | 3876| 363k| end_subject = mb->end_subject; 3877| | 3878| | /* The following two optimizations are disabled for partial matching. */ 3879| | 3880| 363k| if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0) ------------------ | | 181| 363k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ if ((mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) == 0) ------------------ | | 180| 363k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (3880:9): [True: 285k, False: 78.5k] ------------------ 3881| 285k| { 3882| 285k| PCRE2_SPTR p; ------------------ | | 814| 285k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 285k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 285k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 285k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3883| | 3884| | /* The minimum matching length is a lower bound; no actual string of that 3885| | length may actually match the pattern. Although the value is, strictly, 3886| | in characters, we treat it as code units to avoid spending too much time 3887| | in this optimization. */ 3888| | 3889| 285k| if (end_subject - start_match < re->minlength) goto NOMATCH_EXIT; ------------------ | Branch (3889:11): [True: 19.6k, False: 265k] ------------------ 3890| | 3891| | /* If req_cu is set, we know that that code unit must appear in the 3892| | subject for the match to succeed. If the first code unit is set, req_cu 3893| | must be later in the subject; otherwise the test starts at the match 3894| | point. This optimization can save a huge amount of backtracking in 3895| | patterns with nested unlimited repeats that aren't going to match. 3896| | Writing separate code for cased/caseless versions makes it go faster, as 3897| | does using an autoincrement and backing off on a match. As in the case of 3898| | the first code unit, using memchr() in the 8-bit library gives a big 3899| | speed up. Unlike the first_cu check above, we do not need to call 3900| | memchr() twice in the caseless case because we only need to check for the 3901| | presence of the character in either case, not find the first occurrence. 3902| | 3903| | The search can be skipped if the code unit was found later than the 3904| | current starting point in a previous iteration of the bumpalong loop. 3905| | 3906| | HOWEVER: when the subject string is very, very long, searching to its end 3907| | can take a long time, and give bad performance on quite ordinary 3908| | patterns. This showed up when somebody was matching something like 3909| | /^\d+C/ on a 32-megabyte string... so we don't do this when the string is 3910| | sufficiently long, but it's worth searching a lot more for unanchored 3911| | patterns. */ 3912| | 3913| 265k| p = start_match + (has_first_cu? 1:0); ------------------ | Branch (3913:26): [True: 16.1k, False: 249k] ------------------ 3914| 265k| if (has_req_cu && p > req_cu_ptr) ------------------ | Branch (3914:11): [True: 115k, False: 149k] | Branch (3914:25): [True: 34.8k, False: 81.0k] ------------------ 3915| 34.8k| { 3916| 34.8k| PCRE2_SIZE check_length = end_subject - start_match; ------------------ | | 477| 34.8k|#define PCRE2_SIZE size_t ------------------ 3917| | 3918| 34.8k| if (check_length < REQ_CU_MAX || ------------------ | | 554| 69.6k|#define REQ_CU_MAX 5000 ------------------ | Branch (3918:13): [True: 34.8k, False: 0] ------------------ 3919| 34.8k| (!anchored && check_length < REQ_CU_MAX * 1000)) ------------------ | | 554| 0|#define REQ_CU_MAX 5000 ------------------ | Branch (3919:16): [True: 0, False: 0] | Branch (3919:29): [True: 0, False: 0] ------------------ 3920| 34.8k| { 3921| 34.8k| if (req_cu != req_cu2) /* Caseless */ ------------------ | Branch (3921:15): [True: 1.68k, False: 33.1k] ------------------ 3922| 1.68k| { 3923| |#if PCRE2_CODE_UNIT_WIDTH != 8 3924| | while (p < end_subject) 3925| | { 3926| | uint32_t pp = UCHAR21INCTEST(p); 3927| | if (pp == req_cu || pp == req_cu2) { p--; break; } 3928| | } 3929| |#else /* 8-bit code units */ 3930| 1.68k| PCRE2_SPTR pp = p; ------------------ | | 814| 1.68k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.68k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.68k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.68k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3931| 1.68k| p = memchr(pp, req_cu, end_subject - pp); 3932| 1.68k| if (p == NULL) ------------------ | Branch (3932:17): [True: 320, False: 1.36k] ------------------ 3933| 320| { 3934| 320| p = memchr(pp, req_cu2, end_subject - pp); 3935| 320| if (p == NULL) p = end_subject; ------------------ | Branch (3935:19): [True: 110, False: 210] ------------------ 3936| 320| } 3937| 1.68k|#endif /* PCRE2_CODE_UNIT_WIDTH != 8 */ 3938| 1.68k| } 3939| | 3940| | /* The caseful case */ 3941| | 3942| 33.1k| else 3943| 33.1k| { 3944| |#if PCRE2_CODE_UNIT_WIDTH != 8 3945| | while (p < end_subject) 3946| | { 3947| | if (UCHAR21INCTEST(p) == req_cu) { p--; break; } 3948| | } 3949| | 3950| |#else /* 8-bit code units */ 3951| 33.1k| p = memchr(p, req_cu, end_subject - p); 3952| 33.1k| if (p == NULL) p = end_subject; ------------------ | Branch (3952:17): [True: 1.49k, False: 31.6k] ------------------ 3953| 33.1k|#endif 3954| 33.1k| } 3955| | 3956| | /* If we can't find the required code unit, break the matching loop, 3957| | forcing a match failure. */ 3958| | 3959| 34.8k| if (p >= end_subject) break; ------------------ | Branch (3959:15): [True: 1.60k, False: 33.2k] ------------------ 3960| | 3961| | /* If we have found the required code unit, save the point where we 3962| | found it, so that we don't search again next time round the loop if 3963| | the start hasn't passed this code unit yet. */ 3964| | 3965| 33.2k| req_cu_ptr = p; 3966| 33.2k| } 3967| 34.8k| } 3968| 265k| } 3969| 363k| } 3970| | 3971| | /* ------------ End of start of match optimizations ------------ */ 3972| | 3973| | /* Give no match if we have passed the bumpalong limit. */ 3974| | 3975| 525k| if (start_match > bumpalong_limit) break; ------------------ | Branch (3975:7): [True: 0, False: 525k] ------------------ 3976| | 3977| | /* OK, now we can do the business */ 3978| | 3979| 525k| mb->start_used_ptr = start_match; 3980| 525k| mb->last_used_ptr = start_match; 3981| 525k| mb->recursive = NULL; 3982| | 3983| 525k| rc = internal_dfa_match( 3984| 525k| mb, /* fixed match data */ 3985| 525k| mb->start_code, /* this subexpression's code */ 3986| 525k| start_match, /* where we currently are */ 3987| 525k| start_offset, /* start offset in subject */ 3988| 525k| match_data->ovector, /* offset vector */ 3989| 525k| (uint32_t)match_data->oveccount * 2, /* actual size of same */ 3990| 525k| workspace, /* workspace vector */ 3991| 525k| (int)wscount, /* size of same */ 3992| 525k| 0, /* function recurse level */ 3993| 525k| base_recursion_workspace); /* initial workspace for recursion */ 3994| | 3995| | /* Anything other than "no match" means we are done, always; otherwise, carry 3996| | on only if not anchored. */ 3997| | 3998| 525k| if (rc != PCRE2_ERROR_NOMATCH || anchored) ------------------ | | 326| 1.05M|#define PCRE2_ERROR_NOMATCH (-1) ------------------ | Branch (3998:7): [True: 71.5k, False: 454k] | Branch (3998:36): [True: 10.8k, False: 443k] ------------------ 3999| 82.4k| { 4000| 82.4k| if (rc == PCRE2_ERROR_PARTIAL && match_data->oveccount > 0) ------------------ | | 327| 164k|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (4000:9): [True: 8.39k, False: 74.0k] | Branch (4000:38): [True: 8.39k, False: 0] ------------------ 4001| 8.39k| { 4002| 8.39k| match_data->ovector[0] = (PCRE2_SIZE)(start_match - subject); 4003| 8.39k| match_data->ovector[1] = (PCRE2_SIZE)(end_subject - subject); 4004| 8.39k| } 4005| 82.4k| match_data->leftchar = (PCRE2_SIZE)(mb->start_used_ptr - subject); 4006| 82.4k| match_data->rightchar = (PCRE2_SIZE)( mb->last_used_ptr - subject); 4007| 82.4k| match_data->startchar = (PCRE2_SIZE)(start_match - subject); 4008| 82.4k| match_data->rc = rc; 4009| | 4010| 82.4k| if (rc >= 0 &&(options & PCRE2_COPY_MATCHED_SUBJECT) != 0) ------------------ | | 190| 36.6k|#define PCRE2_COPY_MATCHED_SUBJECT 0x00004000u ------------------ | Branch (4010:9): [True: 36.6k, False: 45.8k] | Branch (4010:19): [True: 0, False: 36.6k] ------------------ 4011| 0| { 4012| 0| length = CU2BYTES(length + was_zero_terminated); ------------------ | | 545| 0|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 4013| 0| match_data->subject = match_data->memctl.malloc(length, 4014| 0| match_data->memctl.memory_data); 4015| 0| if (match_data->subject == NULL) return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ | Branch (4015:11): [True: 0, False: 0] ------------------ 4016| 0| memcpy((void *)match_data->subject, subject, length); 4017| 0| match_data->flags |= PCRE2_MD_COPIED_SUBJECT; ------------------ | | 542| 0|#define PCRE2_MD_COPIED_SUBJECT 0x01u ------------------ 4018| 0| } 4019| 82.4k| else 4020| 82.4k| { 4021| 82.4k| if (rc >= 0 || rc == PCRE2_ERROR_PARTIAL) match_data->subject = subject; ------------------ | | 327| 45.8k|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (4021:11): [True: 36.6k, False: 45.8k] | Branch (4021:22): [True: 8.39k, False: 37.4k] ------------------ 4022| 82.4k| } 4023| 82.4k| goto EXIT; 4024| 82.4k| } 4025| | 4026| | /* Advance to the next subject character unless we are at the end of a line 4027| | and firstline is set. */ 4028| | 4029| 443k| if (firstline && IS_NEWLINE(start_match)) break; ------------------ | | 479| 168k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 168k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 168k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 880, False: 167k] | | | Branch (479:4): [True: 2.78k, False: 165k] | | ------------------ | | 480| 168k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 2.78k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 5.57k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 2.73k, False: 49] | | ------------------ | | 481| 2.78k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 2.73k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 2.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 2.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 2.73k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 127, False: 2.61k] | | ------------------ | | 482| 2.73k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 2.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 168k| : \ | | 484| 168k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 165k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 165k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 165k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 158k, False: 7.53k] | | ------------------ | | 485| 165k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 158k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 158k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.17k, False: 157k] | | ------------------ | | 486| 165k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.17k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 492|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 492|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 685, False: 492] | | | Branch (486:30): [True: 68, False: 424] | | ------------------ | | 487| 165k| ) \ | | 488| 168k| ) ------------------ | Branch (4029:7): [True: 168k, False: 274k] ------------------ 4030| 442k| start_match++; 4031| 442k|#ifdef SUPPORT_UNICODE 4032| 442k| if (utf) ------------------ | Branch (4032:7): [True: 190k, False: 252k] ------------------ 4033| 190k| { 4034| 190k| ACROSSCHAR(start_match < end_subject, start_match, start_match++); ------------------ | | 353| 210k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 188k, False: 21.9k] | | | Branch (353:24): [True: 19.8k, False: 168k] | | ------------------ ------------------ 4035| 190k| } 4036| 442k|#endif 4037| 442k| if (start_match > end_subject) break; ------------------ | Branch (4037:7): [True: 14.9k, False: 427k] ------------------ 4038| | 4039| | /* If we have just passed a CR and we are now at a LF, and the pattern does 4040| | not contain any explicit matches for \r or \n, and the newline option is CRLF 4041| | or ANY or ANYCRLF, advance the match position by one more character. */ 4042| | 4043| 427k| if (UCHAR21TEST(start_match - 1) == CHAR_CR && ------------------ | | 244| 427k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ if (UCHAR21TEST(start_match - 1) == CHAR_CR && ------------------ | | 972| 854k|#define CHAR_CR '\015' ------------------ | Branch (4043:7): [True: 4.52k, False: 422k] ------------------ 4044| 427k| start_match < end_subject && ------------------ | Branch (4044:7): [True: 4.12k, False: 394] ------------------ 4045| 427k| UCHAR21TEST(start_match) == CHAR_NL && ------------------ | | 244| 4.12k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ UCHAR21TEST(start_match) == CHAR_NL && ------------------ | | 974| 4.12k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 431k|#define CHAR_LF '\012' | | ------------------ ------------------ | Branch (4045:7): [True: 1.40k, False: 2.72k] ------------------ 4046| 427k| (re->flags & PCRE2_HASCRORLF) == 0 && ------------------ | | 518| 1.40k|#define PCRE2_HASCRORLF 0x00000800 /* explicit \r or \n in pattern */ ------------------ | Branch (4046:7): [True: 903, False: 503] ------------------ 4047| 427k| (mb->nltype == NLTYPE_ANY || ------------------ | | 473| 1.80k|#define NLTYPE_ANY 1 /* Newline is any Unicode line ending */ ------------------ | Branch (4047:10): [True: 198, False: 705] ------------------ 4048| 903| mb->nltype == NLTYPE_ANYCRLF || ------------------ | | 474| 1.60k|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ | Branch (4048:10): [True: 194, False: 511] ------------------ 4049| 903| mb->nllen == 2)) ------------------ | Branch (4049:10): [True: 269, False: 242] ------------------ 4050| 661| start_match++; 4051| | 4052| 427k| } /* "Bumpalong" loop */ 4053| | 4054| 48.0k|NOMATCH_EXIT: 4055| 48.0k|rc = PCRE2_ERROR_NOMATCH; ------------------ | | 326| 48.0k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ 4056| | 4057| 130k|EXIT: 4058| 134k|while (rws->next != NULL) ------------------ | Branch (4058:8): [True: 4.43k, False: 130k] ------------------ 4059| 4.43k| { 4060| 4.43k| RWS_anchor *next = rws->next; 4061| 4.43k| rws->next = next->next; 4062| 4.43k| mb->memctl.free(next, mb->memctl.memory_data); 4063| 4.43k| } 4064| | 4065| 130k|return rc; 4066| 48.0k|} pcre2_dfa_match.c:internal_dfa_match: 535| 758k|{ 536| 758k|stateblock *active_states, *new_states, *temp_states; 537| 758k|stateblock *next_active_state, *next_new_state; 538| 758k|const uint8_t *ctypes, *lcc, *fcc; 539| 758k|PCRE2_SPTR ptr; ------------------ | | 814| 758k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 758k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 758k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 758k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 540| 758k|PCRE2_SPTR end_code; ------------------ | | 814| 758k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 758k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 758k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 758k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 541| 758k|dfa_recursion_info new_recursive; 542| 758k|int active_count, new_count, match_count; 543| | 544| |/* Some fields in the mb block are frequently referenced, so we load them into 545| |independent variables in the hope that this will perform better. */ 546| | 547| 758k|PCRE2_SPTR start_subject = mb->start_subject; ------------------ | | 814| 758k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 758k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 758k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 758k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 548| 758k|PCRE2_SPTR end_subject = mb->end_subject; ------------------ | | 814| 758k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 758k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 758k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 758k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 549| 758k|PCRE2_SPTR start_code = mb->start_code; ------------------ | | 814| 758k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 758k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 758k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 758k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 550| | 551| 758k|#ifdef SUPPORT_UNICODE 552| 758k|BOOL utf = (mb->poptions & PCRE2_UTF) != 0; ------------------ | | 138| 758k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 553| 758k|BOOL utf_or_ucp = utf || (mb->poptions & PCRE2_UCP) != 0; ------------------ | | 136| 458k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (553:19): [True: 299k, False: 458k] | Branch (553:26): [True: 69.8k, False: 388k] ------------------ 554| |#else 555| |BOOL utf = FALSE; 556| |#endif 557| | 558| 758k|BOOL reset_could_continue = FALSE; ------------------ | | 69| 758k|#define FALSE 0 ------------------ 559| | 560| 758k|if (mb->match_call_count++ >= mb->match_limit) return PCRE2_ERROR_MATCHLIMIT; ------------------ | | 387| 1.75k|#define PCRE2_ERROR_MATCHLIMIT (-47) ------------------ | Branch (560:5): [True: 1.75k, False: 756k] ------------------ 561| 756k|if (rlevel++ > mb->match_limit_depth) return PCRE2_ERROR_DEPTHLIMIT; ------------------ | | 393| 0|#define PCRE2_ERROR_DEPTHLIMIT (-53) ------------------ | Branch (561:5): [True: 0, False: 756k] ------------------ 562| 756k|offsetcount &= (uint32_t)(-2); /* Round down */ 563| | 564| 756k|wscount -= 2; 565| 756k|wscount = (wscount - (wscount % (INTS_PER_STATEBLOCK * 2))) / ------------------ | | 303| 756k|#define INTS_PER_STATEBLOCK (int)(sizeof(stateblock)/sizeof(int)) ------------------ 566| 756k| (2 * INTS_PER_STATEBLOCK); ------------------ | | 303| 756k|#define INTS_PER_STATEBLOCK (int)(sizeof(stateblock)/sizeof(int)) ------------------ 567| | 568| 756k|ctypes = mb->tables + ctypes_offset; ------------------ | | 591| 756k|#define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | ------------------ | | | | 590| 756k|#define cbits_offset 512 /* Character classes */ | | ------------------ | | #define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | ------------------ | | | | 573| 756k|#define cbit_length 320 /* Length of the cbits table */ | | ------------------ ------------------ 569| 756k|lcc = mb->tables + lcc_offset; ------------------ | | 588| 756k|#define lcc_offset 0 /* Lower case */ ------------------ 570| 756k|fcc = mb->tables + fcc_offset; ------------------ | | 589| 756k|#define fcc_offset 256 /* Flip case */ ------------------ 571| | 572| 756k|match_count = PCRE2_ERROR_NOMATCH; /* A negative number */ ------------------ | | 326| 756k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ 573| | 574| 756k|active_states = (stateblock *)(workspace + 2); 575| 756k|next_new_state = new_states = active_states + wscount; 576| 756k|new_count = 0; 577| | 578| |/* The first thing in any (sub) pattern is a bracket of some sort. Push all 579| |the alternative states onto the list, and find out where the end is. This 580| |makes is possible to use this function recursively, when we want to stop at a 581| |matching internal ket rather than at the end. 582| | 583| |If we are dealing with a backward assertion we have to find out the maximum 584| |amount to move back, and set up each alternative appropriately. */ 585| | 586| 756k|if (*this_start_code == OP_ASSERTBACK || *this_start_code == OP_ASSERTBACK_NOT) ------------------ | Branch (586:5): [True: 11.3k, False: 745k] | Branch (586:42): [True: 18.2k, False: 727k] ------------------ 587| 29.6k| { 588| 29.6k| size_t max_back = 0; 589| 29.6k| size_t gone_back; 590| | 591| 29.6k| end_code = this_start_code; 592| 29.6k| do 593| 61.0k| { 594| 61.0k| size_t back = (size_t)GET(end_code, 2+LINK_SIZE); ------------------ | | 109| 61.0k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 595| 61.0k| if (back > max_back) max_back = back; ------------------ | Branch (595:9): [True: 32.0k, False: 29.0k] ------------------ 596| 61.0k| end_code += GET(end_code, 1); ------------------ | | 109| 61.0k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 597| 61.0k| } 598| 61.0k| while (*end_code == OP_ALT); ------------------ | Branch (598:10): [True: 31.4k, False: 29.6k] ------------------ 599| | 600| | /* If we can't go back the amount required for the longest lookbehind 601| | pattern, go back as far as we can; some alternatives may still be viable. */ 602| | 603| 29.6k|#ifdef SUPPORT_UNICODE 604| | /* In character mode we have to step back character by character */ 605| | 606| 29.6k| if (utf) ------------------ | Branch (606:7): [True: 9.83k, False: 19.8k] ------------------ 607| 9.83k| { 608| 67.6k| for (gone_back = 0; gone_back < max_back; gone_back++) ------------------ | Branch (608:25): [True: 63.9k, False: 3.68k] ------------------ 609| 63.9k| { 610| 63.9k| if (current_subject <= start_subject) break; ------------------ | Branch (610:11): [True: 6.15k, False: 57.7k] ------------------ 611| 57.7k| current_subject--; 612| 57.7k| ACROSSCHAR(current_subject > start_subject, current_subject, ------------------ | | 353| 58.3k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 53.7k, False: 4.58k] | | | Branch (353:24): [True: 538, False: 53.1k] | | ------------------ ------------------ 613| 57.7k| current_subject--); 614| 57.7k| } 615| 9.83k| } 616| 19.8k| else 617| 19.8k|#endif 618| | 619| | /* In byte-mode we can do this quickly. */ 620| | 621| 19.8k| { 622| 19.8k| size_t current_offset = (size_t)(current_subject - start_subject); 623| 19.8k| gone_back = (current_offset < max_back)? current_offset : max_back; ------------------ | Branch (623:17): [True: 10.7k, False: 9.10k] ------------------ 624| 19.8k| current_subject -= gone_back; 625| 19.8k| } 626| | 627| | /* Save the earliest consulted character */ 628| | 629| 29.6k| if (current_subject < mb->start_used_ptr) ------------------ | Branch (629:7): [True: 18.4k, False: 11.1k] ------------------ 630| 18.4k| mb->start_used_ptr = current_subject; 631| | 632| | /* Now we can process the individual branches. There will be an OP_REVERSE at 633| | the start of each branch, except when the length of the branch is zero. */ 634| | 635| 29.6k| end_code = this_start_code; 636| 29.6k| do 637| 61.0k| { 638| 61.0k| uint32_t revlen = (end_code[1+LINK_SIZE] == OP_REVERSE)? 1 + LINK_SIZE : 0; ------------------ | | 165| 61.0k|#define LINK_SIZE 2 ------------------ uint32_t revlen = (end_code[1+LINK_SIZE] == OP_REVERSE)? 1 + LINK_SIZE : 0; ------------------ | | 165| 14.3k|#define LINK_SIZE 2 ------------------ | Branch (638:23): [True: 14.3k, False: 46.7k] ------------------ 639| 61.0k| size_t back = (revlen == 0)? 0 : (size_t)GET(end_code, 2+LINK_SIZE); ------------------ | | 109| 14.3k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (639:19): [True: 46.7k, False: 14.3k] ------------------ 640| 61.0k| if (back <= gone_back) ------------------ | Branch (640:9): [True: 53.6k, False: 7.43k] ------------------ 641| 53.6k| { 642| 53.6k| int bstate = (int)(end_code - start_code + 1 + LINK_SIZE + revlen); ------------------ | | 165| 53.6k|#define LINK_SIZE 2 ------------------ 643| 53.6k| ADD_NEW_DATA(-bstate, 0, (int)(gone_back - back)); ------------------ | | 512| 53.6k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 53.6k, False: 10] | | ------------------ | | 513| 53.6k| { \ | | 514| 53.6k| next_new_state->offset = (x); \ | | 515| 53.6k| next_new_state->count = (y); \ | | 516| 53.6k| next_new_state->data = (z); \ | | 517| 53.6k| next_new_state++; \ | | 518| 53.6k| } \ | | 519| 53.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 644| 53.6k| } 645| 61.0k| end_code += GET(end_code, 1); ------------------ | | 109| 61.0k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 646| 61.0k| } 647| 61.0k| while (*end_code == OP_ALT); ------------------ | Branch (647:10): [True: 31.4k, False: 29.6k] ------------------ 648| 29.6k| } 649| | 650| |/* This is the code for a "normal" subpattern (not a backward assertion). The 651| |start of a whole pattern is always one of these. If we are at the top level, 652| |we may be asked to restart matching from the same point that we reached for a 653| |previous partial match. We still have to scan through the top-level branches to 654| |find the end state. */ 655| | 656| 727k|else 657| 727k| { 658| 727k| end_code = this_start_code; 659| | 660| | /* Restarting */ 661| | 662| 727k| if (rlevel == 1 && (mb->moptions & PCRE2_DFA_RESTART) != 0) ------------------ | | 182| 525k|#define PCRE2_DFA_RESTART 0x00000040u /* pcre2_dfa_match() only */ ------------------ | Branch (662:7): [True: 525k, False: 201k] | Branch (662:22): [True: 0, False: 525k] ------------------ 663| 0| { 664| 0| do { end_code += GET(end_code, 1); } while (*end_code == OP_ALT); ------------------ | | 109| 0| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (664:49): [True: 0, False: 0] ------------------ 665| 0| new_count = workspace[1]; 666| 0| if (!workspace[0]) ------------------ | Branch (666:9): [True: 0, False: 0] ------------------ 667| 0| memcpy(new_states, active_states, (size_t)new_count * sizeof(stateblock)); 668| 0| } 669| | 670| | /* Not restarting */ 671| | 672| 727k| else 673| 727k| { 674| 727k| int length = 1 + LINK_SIZE + ------------------ | | 165| 727k|#define LINK_SIZE 2 ------------------ 675| 727k| ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA || ------------------ | Branch (675:9): [True: 21.1k, False: 705k] | Branch (675:40): [True: 602, False: 705k] ------------------ 676| 727k| *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS) ------------------ | Branch (676:9): [True: 11.2k, False: 694k] | Branch (676:43): [True: 10.1k, False: 683k] ------------------ 677| 727k| ? IMM2_SIZE:0); ------------------ | | 193| 43.1k|#define IMM2_SIZE 2 ------------------ 678| 727k| do 679| 892k| { 680| 892k| ADD_NEW((int)(end_code - start_code + length), 0); ------------------ | | 503| 892k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 891k, False: 226] | | ------------------ | | 504| 892k| { \ | | 505| 891k| next_new_state->offset = (x); \ | | 506| 891k| next_new_state->count = (y); \ | | 507| 891k| next_new_state++; \ | | 508| 891k| } \ | | 509| 892k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 226|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 681| 891k| end_code += GET(end_code, 1); ------------------ | | 109| 891k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 682| 891k| length = 1 + LINK_SIZE; ------------------ | | 165| 891k|#define LINK_SIZE 2 ------------------ 683| 891k| } 684| 891k| while (*end_code == OP_ALT); ------------------ | Branch (684:12): [True: 164k, False: 726k] ------------------ 685| 727k| } 686| 727k| } 687| | 688| 756k|workspace[0] = 0; /* Bit indicating which vector is current */ 689| | 690| |/* Loop for scanning the subject */ 691| | 692| 756k|ptr = current_subject; 693| 756k|for (;;) 694| 3.49M| { 695| 3.49M| int i, j; 696| 3.49M| int clen, dlen; 697| 3.49M| uint32_t c, d; 698| 3.49M| int forced_fail = 0; 699| 3.49M| BOOL partial_newline = FALSE; ------------------ | | 69| 3.49M|#define FALSE 0 ------------------ 700| 3.49M| BOOL could_continue = reset_could_continue; 701| 3.49M| reset_could_continue = FALSE; ------------------ | | 69| 3.49M|#define FALSE 0 ------------------ 702| | 703| 3.49M| if (ptr > mb->last_used_ptr) mb->last_used_ptr = ptr; ------------------ | Branch (703:7): [True: 2.40M, False: 1.09M] ------------------ 704| | 705| | /* Make the new state list into the active state list and empty the 706| | new state list. */ 707| | 708| 3.49M| temp_states = active_states; 709| 3.49M| active_states = new_states; 710| 3.49M| new_states = temp_states; 711| 3.49M| active_count = new_count; 712| 3.49M| new_count = 0; 713| | 714| 3.49M| workspace[0] ^= 1; /* Remember for the restarting feature */ 715| 3.49M| workspace[1] = active_count; 716| | 717| | /* Set the pointers for adding new states */ 718| | 719| 3.49M| next_active_state = active_states + active_count; 720| 3.49M| next_new_state = new_states; 721| | 722| | /* Load the current character from the subject outside the loop, as many 723| | different states may want to look at it, and we assume that at least one 724| | will. */ 725| | 726| 3.49M| if (ptr < end_subject) ------------------ | Branch (726:7): [True: 3.26M, False: 237k] ------------------ 727| 3.26M| { 728| 3.26M| clen = 1; /* Number of data items in the character */ 729| 3.26M|#ifdef SUPPORT_UNICODE 730| 3.26M| GETCHARLENTEST(c, ptr, clen); ------------------ | | 338| 3.26M| c = *eptr; \ | | 339| 3.26M| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 81.7k| { \ | | | | 323| 81.7k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 23.4k, False: 58.3k] | | | | ------------------ | | | | 324| 81.7k| { \ | | | | 325| 23.4k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 23.4k| len++; \ | | | | 327| 23.4k| } \ | | | | 328| 81.7k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 48.1k, False: 10.1k] | | | | ------------------ | | | | 329| 58.3k| { \ | | | | 330| 48.1k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 48.1k| len += 2; \ | | | | 332| 48.1k| } \ | | | | 333| 58.3k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 10.1k, False: 0] | | | | ------------------ | | | | 334| 10.1k| {\ | | | | 335| 10.1k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 10.1k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 10.1k| len += 3; \ | | | | 338| 10.1k| } \ | | | | 339| 10.1k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 81.7k| } | | ------------------ | | | Branch (339:7): [True: 951k, False: 2.30M] | | | Branch (339:14): [True: 81.7k, False: 869k] | | ------------------ ------------------ 731| |#else 732| | c = *ptr; 733| |#endif /* SUPPORT_UNICODE */ 734| 3.26M| } 735| 237k| else 736| 237k| { 737| 237k| clen = 0; /* This indicates the end of the subject */ 738| 237k| c = NOTACHAR; /* This value should never actually be used */ ------------------ | | 205| 237k|#define NOTACHAR 0xffffffff ------------------ 739| 237k| } 740| | 741| | /* Scan up the active states and act on each one. The result of an action 742| | may be to add more states to the currently active list (e.g. on hitting a 743| | parenthesis) or it may be to put states on the new list, for considering 744| | when we move the character pointer on. */ 745| | 746| 14.1M| for (i = 0; i < active_count; i++) ------------------ | Branch (746:15): [True: 10.6M, False: 3.45M] ------------------ 747| 10.6M| { 748| 10.6M| stateblock *current_state = active_states + i; 749| 10.6M| BOOL caseless = FALSE; ------------------ | | 69| 10.6M|#define FALSE 0 ------------------ 750| 10.6M| PCRE2_SPTR code; ------------------ | | 814| 10.6M|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 10.6M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 10.6M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 10.6M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 751| 10.6M| uint32_t codevalue; 752| 10.6M| int state_offset = current_state->offset; 753| 10.6M| int rrc; 754| 10.6M| int count; 755| | 756| | /* A negative offset is a special case meaning "hold off going to this 757| | (negated) state until the number of characters in the data field have 758| | been skipped". If the could_continue flag was passed over from a previous 759| | state, arrange for it to passed on. */ 760| | 761| 10.6M| if (state_offset < 0) ------------------ | Branch (761:9): [True: 1.88M, False: 8.79M] ------------------ 762| 1.88M| { 763| 1.88M| if (current_state->data > 0) ------------------ | Branch (763:11): [True: 1.22M, False: 667k] ------------------ 764| 1.22M| { 765| 1.22M| ADD_NEW_DATA(state_offset, current_state->count, ------------------ | | 512| 1.22M| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 1.22M, False: 10] | | ------------------ | | 513| 1.22M| { \ | | 514| 1.22M| next_new_state->offset = (x); \ | | 515| 1.22M| next_new_state->count = (y); \ | | 516| 1.22M| next_new_state->data = (z); \ | | 517| 1.22M| next_new_state++; \ | | 518| 1.22M| } \ | | 519| 1.22M| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 766| 1.22M| current_state->data - 1); 767| 1.22M| if (could_continue) reset_could_continue = TRUE; ------------------ | | 70| 1.29k|#define TRUE 1 ------------------ | Branch (767:13): [True: 1.29k, False: 1.22M] ------------------ 768| 1.22M| continue; 769| 1.22M| } 770| 667k| else 771| 667k| { 772| 667k| current_state->offset = state_offset = -state_offset; 773| 667k| } 774| 1.88M| } 775| | 776| | /* Check for a duplicate state with the same count, and skip if found. 777| | See the note at the head of this module about the possibility of improving 778| | performance here. */ 779| | 780| 41.0M| for (j = 0; j < i; j++) ------------------ | Branch (780:17): [True: 32.0M, False: 8.93M] ------------------ 781| 32.0M| { 782| 32.0M| if (active_states[j].offset == state_offset && ------------------ | Branch (782:11): [True: 4.00M, False: 28.0M] ------------------ 783| 32.0M| active_states[j].count == current_state->count) ------------------ | Branch (783:11): [True: 525k, False: 3.47M] ------------------ 784| 525k| goto NEXT_ACTIVE_STATE; 785| 32.0M| } 786| | 787| | /* The state offset is the offset to the opcode */ 788| | 789| 8.93M| code = start_code + state_offset; 790| 8.93M| codevalue = *code; 791| | 792| | /* If this opcode inspects a character, but we are at the end of the 793| | subject, remember the fact for use when testing for a partial match. */ 794| | 795| 8.93M| if (clen == 0 && poptable[codevalue] != 0) ------------------ | Branch (795:9): [True: 733k, False: 8.19M] | Branch (795:22): [True: 500k, False: 233k] ------------------ 796| 500k| could_continue = TRUE; ------------------ | | 70| 500k|#define TRUE 1 ------------------ 797| | 798| | /* If this opcode is followed by an inline character, load it. It is 799| | tempting to test for the presence of a subject character here, but that 800| | is wrong, because sometimes zero repetitions of the subject are 801| | permitted. 802| | 803| | We also use this mechanism for opcodes such as OP_TYPEPLUS that take an 804| | argument that is not a data character - but is always one byte long because 805| | the values are small. We have to take special action to deal with \P, \p, 806| | \H, \h, \V, \v and \X in this case. To keep the other cases fast, convert 807| | these ones to new opcodes. */ 808| | 809| 8.93M| if (coptable[codevalue] > 0) ------------------ | Branch (809:9): [True: 5.33M, False: 3.59M] ------------------ 810| 5.33M| { 811| 5.33M| dlen = 1; 812| 5.33M|#ifdef SUPPORT_UNICODE 813| 5.33M| if (utf) { GETCHARLEN(d, (code + coptable[codevalue]), dlen); } else ------------------ | | 330| 1.53M| c = *eptr; \ | | 331| 1.53M| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 101k| { \ | | | | 323| 101k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 45.6k, False: 55.4k] | | | | ------------------ | | | | 324| 101k| { \ | | | | 325| 45.6k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 45.6k| len++; \ | | | | 327| 45.6k| } \ | | | | 328| 101k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 38.9k, False: 16.4k] | | | | ------------------ | | | | 329| 55.4k| { \ | | | | 330| 38.9k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 38.9k| len += 2; \ | | | | 332| 38.9k| } \ | | | | 333| 55.4k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 16.4k, False: 0] | | | | ------------------ | | | | 334| 16.4k| {\ | | | | 335| 16.4k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 16.4k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 16.4k| len += 3; \ | | | | 338| 16.4k| } \ | | | | 339| 16.4k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 101k| } | | ------------------ | | | Branch (331:7): [True: 101k, False: 1.43M] | | ------------------ ------------------ | Branch (813:11): [True: 1.53M, False: 3.79M] ------------------ 814| 3.79M|#endif /* SUPPORT_UNICODE */ 815| 3.79M| d = code[coptable[codevalue]]; 816| 5.33M| if (codevalue >= OP_TYPESTAR) ------------------ | Branch (816:11): [True: 3.47M, False: 1.86M] ------------------ 817| 3.47M| { 818| 3.47M| switch(d) 819| 3.47M| { 820| 0| case OP_ANYBYTE: return PCRE2_ERROR_DFA_UITEM; ------------------ | | 382| 0|#define PCRE2_ERROR_DFA_UITEM (-42) ------------------ | Branch (820:11): [True: 0, False: 3.47M] ------------------ 821| 468k| case OP_NOTPROP: ------------------ | Branch (821:11): [True: 468k, False: 3.00M] ------------------ 822| 554k| case OP_PROP: codevalue += OP_PROP_EXTRA; break; ------------------ | | 101| 554k|#define OP_PROP_EXTRA 300 ------------------ | Branch (822:11): [True: 85.6k, False: 3.38M] ------------------ 823| 65.0k| case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break; ------------------ | | 103| 65.0k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (823:11): [True: 65.0k, False: 3.40M] ------------------ 824| 268k| case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break; ------------------ | | 102| 268k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (824:11): [True: 268k, False: 3.20M] ------------------ 825| 225k| case OP_NOT_HSPACE: ------------------ | Branch (825:11): [True: 225k, False: 3.24M] ------------------ 826| 270k| case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break; ------------------ | | 104| 270k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (826:11): [True: 44.5k, False: 3.42M] ------------------ 827| 94.3k| case OP_NOT_VSPACE: ------------------ | Branch (827:11): [True: 94.3k, False: 3.37M] ------------------ 828| 122k| case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break; ------------------ | | 105| 122k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (828:11): [True: 28.1k, False: 3.44M] ------------------ 829| 2.19M| default: break; ------------------ | Branch (829:11): [True: 2.19M, False: 1.28M] ------------------ 830| 3.47M| } 831| 3.47M| } 832| 5.33M| } 833| 3.59M| else 834| 3.59M| { 835| 3.59M| dlen = 0; /* Not strictly necessary, but compilers moan */ 836| 3.59M| d = NOTACHAR; /* if these variables are not set. */ ------------------ | | 205| 3.59M|#define NOTACHAR 0xffffffff ------------------ 837| 3.59M| } 838| | 839| | 840| | /* Now process the individual opcodes */ 841| | 842| 8.93M| switch (codevalue) 843| 8.93M| { 844| |/* ========================================================================== */ 845| | /* These cases are never obeyed. This is a fudge that causes a compile- 846| | time error if the vectors coptable or poptable, which are indexed by 847| | opcode, are not the correct length. It seems to be the only way to do 848| | such a check at compile time, as the sizeof() operator does not work 849| | in the C preprocessor. */ 850| | 851| 0| case OP_TABLE_LENGTH: ------------------ | Branch (851:7): [True: 0, False: 8.93M] ------------------ 852| 0| case OP_TABLE_LENGTH + ------------------ | Branch (852:7): [True: 0, False: 8.93M] ------------------ 853| 0| ((sizeof(coptable) == OP_TABLE_LENGTH) && ------------------ | Branch (853:10): [Folded - Ignored] ------------------ 854| 0| (sizeof(poptable) == OP_TABLE_LENGTH)): ------------------ | Branch (854:10): [Folded - Ignored] ------------------ 855| 0| return 0; 856| | 857| |/* ========================================================================== */ 858| | /* Reached a closing bracket. If not at the end of the pattern, carry 859| | on with the next opcode. For repeating opcodes, also add the repeat 860| | state. Note that KETRPOS will always be encountered at the end of the 861| | subpattern, because the possessive subpattern repeats are always handled 862| | using recursive calls. Thus, it never adds any new states. 863| | 864| | At the end of the (sub)pattern, unless we have an empty string and 865| | PCRE2_NOTEMPTY is set, or PCRE2_NOTEMPTY_ATSTART is set and we are at the 866| | start of the subject, save the match data, shifting up all previous 867| | matches so we always have the longest first. */ 868| | 869| 432k| case OP_KET: ------------------ | Branch (869:7): [True: 432k, False: 8.50M] ------------------ 870| 438k| case OP_KETRMIN: ------------------ | Branch (870:7): [True: 6.00k, False: 8.92M] ------------------ 871| 468k| case OP_KETRMAX: ------------------ | Branch (871:7): [True: 29.2k, False: 8.90M] ------------------ 872| 528k| case OP_KETRPOS: ------------------ | Branch (872:7): [True: 59.9k, False: 8.87M] ------------------ 873| 528k| if (code != end_code) ------------------ | Branch (873:11): [True: 172k, False: 355k] ------------------ 874| 172k| { 875| 172k| ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0); ------------------ | | 484| 172k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 169k, False: 3.33k] | | ------------------ | | 485| 172k| { \ | | 486| 169k| next_active_state->offset = (x); \ | | 487| 169k| next_active_state->count = (y); \ | | 488| 169k| next_active_state++; \ | | 489| 169k| } \ | | 490| 172k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 3.33k|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 876| 169k| if (codevalue != OP_KET) ------------------ | Branch (876:13): [True: 25.4k, False: 144k] ------------------ 877| 25.4k| { 878| 25.4k| ADD_ACTIVE(state_offset - (int)GET(code, 1), 0); ------------------ | | 484| 25.4k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 25.4k, False: 28] | | ------------------ | | 485| 25.4k| { \ | | 486| 25.4k| next_active_state->offset = (x); \ | | 487| 25.4k| next_active_state->count = (y); \ | | 488| 25.4k| next_active_state++; \ | | 489| 25.4k| } \ | | 490| 25.4k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 28|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 879| 25.4k| } 880| 169k| } 881| 355k| else 882| 355k| { 883| 355k| if (ptr > current_subject || ------------------ | Branch (883:13): [True: 234k, False: 120k] ------------------ 884| 355k| ((mb->moptions & PCRE2_NOTEMPTY) == 0 && ------------------ | | 178| 120k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ ------------------ | Branch (884:14): [True: 98.5k, False: 22.1k] ------------------ 885| 120k| ((mb->moptions & PCRE2_NOTEMPTY_ATSTART) == 0 || ------------------ | | 179| 98.5k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ ------------------ | Branch (885:16): [True: 84.1k, False: 14.3k] ------------------ 886| 98.5k| current_subject > start_subject + mb->start_offset))) ------------------ | Branch (886:17): [True: 10.2k, False: 4.15k] ------------------ 887| 328k| { 888| 328k| if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0; ------------------ | Branch (888:15): [True: 179k, False: 149k] | Branch (888:46): [True: 179k, False: 0] ------------------ 889| 149k| else if (match_count > 0 && ++match_count * 2 > (int)offsetcount) ------------------ | Branch (889:22): [True: 101k, False: 47.7k] | Branch (889:41): [True: 6.70k, False: 94.7k] ------------------ 890| 6.70k| match_count = 0; 891| 328k| count = ((match_count == 0)? (int)offsetcount : match_count * 2) - 2; ------------------ | Branch (891:20): [True: 54.4k, False: 274k] ------------------ 892| 328k| if (count > 0) (void)memmove(offsets + 2, offsets, ------------------ | Branch (892:15): [True: 97.8k, False: 231k] ------------------ 893| 97.8k| (size_t)count * sizeof(PCRE2_SIZE)); 894| 328k| if (offsetcount >= 2) ------------------ | Branch (894:15): [True: 328k, False: 0] ------------------ 895| 328k| { 896| 328k| offsets[0] = (PCRE2_SIZE)(current_subject - start_subject); 897| 328k| offsets[1] = (PCRE2_SIZE)(ptr - start_subject); 898| 328k| } 899| 328k| if ((mb->moptions & PCRE2_DFA_SHORTEST) != 0) return match_count; ------------------ | | 183| 328k|#define PCRE2_DFA_SHORTEST 0x00000080u /* pcre2_dfa_match() only */ ------------------ | Branch (899:15): [True: 0, False: 328k] ------------------ 900| 328k| } 901| 355k| } 902| 524k| break; 903| | 904| |/* ========================================================================== */ 905| | /* These opcodes add to the current list of states without looking 906| | at the current character. */ 907| | 908| | /*-----------------------------------------------------------------*/ 909| 524k| case OP_ALT: ------------------ | Branch (909:7): [True: 178k, False: 8.75M] ------------------ 910| 1.49M| do { code += GET(code, 1); } while (*code == OP_ALT); ------------------ | | 109| 1.49M| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (910:43): [True: 1.31M, False: 178k] ------------------ 911| 178k| ADD_ACTIVE((int)(code - start_code), 0); ------------------ | | 484| 178k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 177k, False: 518] | | ------------------ | | 485| 178k| { \ | | 486| 177k| next_active_state->offset = (x); \ | | 487| 177k| next_active_state->count = (y); \ | | 488| 177k| next_active_state++; \ | | 489| 177k| } \ | | 490| 178k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 518|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 912| 177k| break; 913| | 914| | /*-----------------------------------------------------------------*/ 915| 177k| case OP_BRA: ------------------ | Branch (915:7): [True: 58.8k, False: 8.87M] ------------------ 916| 70.3k| case OP_SBRA: ------------------ | Branch (916:7): [True: 11.5k, False: 8.92M] ------------------ 917| 70.3k| do 918| 88.2k| { 919| 88.2k| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); ------------------ | | 484| 88.2k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 87.2k, False: 980] | | ------------------ | | 485| 88.2k| { \ | | 486| 87.2k| next_active_state->offset = (x); \ | | 487| 87.2k| next_active_state->count = (y); \ | | 488| 87.2k| next_active_state++; \ | | 489| 87.2k| } \ | | 490| 88.2k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 980|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 920| 87.2k| code += GET(code, 1); ------------------ | | 109| 87.2k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 921| 87.2k| } 922| 87.2k| while (*code == OP_ALT); ------------------ | Branch (922:14): [True: 17.9k, False: 69.3k] ------------------ 923| 69.3k| break; 924| | 925| | /*-----------------------------------------------------------------*/ 926| 168k| case OP_CBRA: ------------------ | Branch (926:7): [True: 168k, False: 8.76M] ------------------ 927| 176k| case OP_SCBRA: ------------------ | Branch (927:7): [True: 8.39k, False: 8.92M] ------------------ 928| 176k| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE + IMM2_SIZE), 0); ------------------ | | 484| 176k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 174k, False: 2.00k] | | ------------------ | | 485| 176k| { \ | | 486| 174k| next_active_state->offset = (x); \ | | 487| 174k| next_active_state->count = (y); \ | | 488| 174k| next_active_state++; \ | | 489| 174k| } \ | | 490| 176k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 2.00k|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 929| 174k| code += GET(code, 1); ------------------ | | 109| 174k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 930| 227k| while (*code == OP_ALT) ------------------ | Branch (930:14): [True: 52.9k, False: 174k] ------------------ 931| 52.9k| { 932| 52.9k| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); ------------------ | | 484| 52.9k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 52.8k, False: 82] | | ------------------ | | 485| 52.9k| { \ | | 486| 52.8k| next_active_state->offset = (x); \ | | 487| 52.8k| next_active_state->count = (y); \ | | 488| 52.8k| next_active_state++; \ | | 489| 52.8k| } \ | | 490| 52.9k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 82|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 933| 52.8k| code += GET(code, 1); ------------------ | | 109| 52.8k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 934| 52.8k| } 935| 174k| break; 936| | 937| | /*-----------------------------------------------------------------*/ 938| 174k| case OP_BRAZERO: ------------------ | Branch (938:7): [True: 19.2k, False: 8.91M] ------------------ 939| 23.5k| case OP_BRAMINZERO: ------------------ | Branch (939:7): [True: 4.33k, False: 8.92M] ------------------ 940| 23.5k| ADD_ACTIVE(state_offset + 1, 0); ------------------ | | 484| 23.5k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 23.4k, False: 115] | | ------------------ | | 485| 23.5k| { \ | | 486| 23.4k| next_active_state->offset = (x); \ | | 487| 23.4k| next_active_state->count = (y); \ | | 488| 23.4k| next_active_state++; \ | | 489| 23.4k| } \ | | 490| 23.5k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 115|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 941| 23.4k| code += 1 + GET(code, 2); ------------------ | | 109| 23.4k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 942| 26.3k| while (*code == OP_ALT) code += GET(code, 1); ------------------ | | 109| 26.3k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (942:14): [True: 2.87k, False: 23.4k] ------------------ 943| 23.4k| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); ------------------ | | 484| 23.4k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 23.4k, False: 65] | | ------------------ | | 485| 23.4k| { \ | | 486| 23.4k| next_active_state->offset = (x); \ | | 487| 23.4k| next_active_state->count = (y); \ | | 488| 23.4k| next_active_state++; \ | | 489| 23.4k| } \ | | 490| 23.4k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 65|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 944| 23.4k| break; 945| | 946| | /*-----------------------------------------------------------------*/ 947| 23.4k| case OP_SKIPZERO: ------------------ | Branch (947:7): [True: 1.25k, False: 8.93M] ------------------ 948| 1.25k| code += 1 + GET(code, 2); ------------------ | | 109| 1.25k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 949| 2.38k| while (*code == OP_ALT) code += GET(code, 1); ------------------ | | 109| 2.38k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (949:14): [True: 1.13k, False: 1.25k] ------------------ 950| 1.25k| ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0); ------------------ | | 484| 1.25k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 1.23k, False: 15] | | ------------------ | | 485| 1.25k| { \ | | 486| 1.23k| next_active_state->offset = (x); \ | | 487| 1.23k| next_active_state->count = (y); \ | | 488| 1.23k| next_active_state++; \ | | 489| 1.23k| } \ | | 490| 1.25k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 15|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 951| 1.23k| break; 952| | 953| | /*-----------------------------------------------------------------*/ 954| 210k| case OP_CIRC: ------------------ | Branch (954:7): [True: 210k, False: 8.72M] ------------------ 955| 210k| if (ptr == start_subject && (mb->moptions & PCRE2_NOTBOL) == 0) ------------------ | | 176| 5.60k|#define PCRE2_NOTBOL 0x00000001u ------------------ | Branch (955:11): [True: 5.60k, False: 205k] | Branch (955:35): [True: 4.15k, False: 1.45k] ------------------ 956| 4.15k| { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 4.15k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 4.11k, False: 40] | | ------------------ | | 485| 4.15k| { \ | | 486| 4.11k| next_active_state->offset = (x); \ | | 487| 4.11k| next_active_state->count = (y); \ | | 488| 4.11k| next_active_state++; \ | | 489| 4.11k| } \ | | 490| 4.15k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 40|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 957| 210k| break; 958| | 959| | /*-----------------------------------------------------------------*/ 960| 210k| case OP_CIRCM: ------------------ | Branch (960:7): [True: 32.6k, False: 8.90M] ------------------ 961| 32.6k| if ((ptr == start_subject && (mb->moptions & PCRE2_NOTBOL) == 0) || ------------------ | | 176| 2.50k|#define PCRE2_NOTBOL 0x00000001u ------------------ | Branch (961:12): [True: 2.50k, False: 30.1k] | Branch (961:36): [True: 1.72k, False: 782] ------------------ 962| 32.6k| ((ptr != end_subject || (mb->poptions & PCRE2_ALT_CIRCUMFLEX) != 0 ) ------------------ | | 140| 3.39k|#define PCRE2_ALT_CIRCUMFLEX 0x00200000u /* J M D */ ------------------ | Branch (962:13): [True: 27.5k, False: 3.39k] | Branch (962:35): [True: 2.00k, False: 1.38k] ------------------ 963| 30.9k| && WAS_NEWLINE(ptr))) ------------------ | | 493| 29.5k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 29.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 29.5k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (493:3): [True: 1.93k, False: 27.6k] | | | Branch (493:4): [True: 7.47k, False: 22.1k] | | ------------------ | | 494| 29.5k| ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 79| 7.47k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 80| 14.9k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (494:6): [True: 7.12k, False: 350] | | ------------------ | | 495| 7.47k| PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 177| 7.12k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 79| 7.12k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 79| 7.12k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 80| 7.12k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (495:6): [True: 1.30k, False: 5.82k] | | ------------------ | | 496| 7.12k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 7.12k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 497| 29.5k| : \ | | 498| 29.5k| ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 79| 22.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 80| 22.1k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 79| 22.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (498:6): [True: 21.6k, False: 484] | | ------------------ | | 499| 22.1k| UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 21.6k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 21.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (499:6): [True: 851, False: 20.7k] | | ------------------ | | 500| 22.1k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 851|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 417|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 417|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (500:7): [True: 434, False: 417] | | | Branch (500:30): [True: 199, False: 218] | | ------------------ | | 501| 22.1k| ) \ | | 502| 29.5k| ) ------------------ 964| 3.66k| { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 3.66k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 3.64k, False: 18] | | ------------------ | | 485| 3.66k| { \ | | 486| 3.64k| next_active_state->offset = (x); \ | | 487| 3.64k| next_active_state->count = (y); \ | | 488| 3.64k| next_active_state++; \ | | 489| 3.64k| } \ | | 490| 3.66k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 18|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 965| 32.6k| break; 966| | 967| | /*-----------------------------------------------------------------*/ 968| 32.6k| case OP_EOD: ------------------ | Branch (968:7): [True: 7.81k, False: 8.92M] ------------------ 969| 7.81k| if (ptr >= end_subject) ------------------ | Branch (969:11): [True: 1.07k, False: 6.74k] ------------------ 970| 1.07k| { 971| 1.07k| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 1.07k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (971:13): [True: 14, False: 1.05k] ------------------ 972| 14| return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 14|#define PCRE2_ERROR_PARTIAL (-2) ------------------ 973| 1.05k| else { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 1.05k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 1.04k, False: 11] | | ------------------ | | 485| 1.05k| { \ | | 486| 1.04k| next_active_state->offset = (x); \ | | 487| 1.04k| next_active_state->count = (y); \ | | 488| 1.04k| next_active_state++; \ | | 489| 1.04k| } \ | | 490| 1.05k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 11|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 974| 1.07k| } 975| 7.79k| break; 976| | 977| | /*-----------------------------------------------------------------*/ 978| 9.68k| case OP_SOD: ------------------ | Branch (978:7): [True: 9.68k, False: 8.92M] ------------------ 979| 9.68k| if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 688| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 668, False: 20] | | ------------------ | | 485| 688| { \ | | 486| 668| next_active_state->offset = (x); \ | | 487| 668| next_active_state->count = (y); \ | | 488| 668| next_active_state++; \ | | 489| 668| } \ | | 490| 688| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 20|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (979:11): [True: 688, False: 8.99k] ------------------ 980| 9.66k| break; 981| | 982| | /*-----------------------------------------------------------------*/ 983| 9.66k| case OP_SOM: ------------------ | Branch (983:7): [True: 1.10k, False: 8.93M] ------------------ 984| 1.10k| if (ptr == start_subject + start_offset) { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 619| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 605, False: 14] | | ------------------ | | 485| 619| { \ | | 486| 605| next_active_state->offset = (x); \ | | 487| 605| next_active_state->count = (y); \ | | 488| 605| next_active_state++; \ | | 489| 605| } \ | | 490| 619| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 14|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (984:11): [True: 619, False: 483] ------------------ 985| 1.08k| break; 986| | 987| | 988| |/* ========================================================================== */ 989| | /* These opcodes inspect the next subject character, and sometimes 990| | the previous one as well, but do not have an argument. The variable 991| | clen contains the length of the current character and is zero if we are 992| | at the end of the subject. */ 993| | 994| | /*-----------------------------------------------------------------*/ 995| 248k| case OP_ANY: ------------------ | Branch (995:7): [True: 248k, False: 8.68M] ------------------ 996| 248k| if (clen > 0 && !IS_NEWLINE(ptr)) ------------------ | | 479| 236k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 236k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 236k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 12.6k, False: 223k] | | ------------------ | | 480| 236k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 12.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 25.3k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 12.6k, False: 0] | | ------------------ | | 481| 12.6k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 12.6k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 12.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 12.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 12.6k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 726, False: 11.9k] | | ------------------ | | 482| 12.6k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 12.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 236k| : \ | | 484| 236k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 223k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 223k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 223k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 222k, False: 1.69k] | | ------------------ | | 485| 223k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 222k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 222k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 2.13k, False: 220k] | | ------------------ | | 486| 223k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 2.13k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.03k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.03k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.10k, False: 1.03k] | | | Branch (486:30): [True: 477, False: 553] | | ------------------ | | 487| 223k| ) \ | | 488| 236k| ) ------------------ | Branch (996:11): [True: 236k, False: 11.4k] | Branch (996:23): [True: 234k, False: 2.31k] ------------------ 997| 234k| { 998| 234k| if (ptr + 1 >= mb->end_subject && ------------------ | Branch (998:13): [True: 9.31k, False: 224k] ------------------ 999| 234k| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && ------------------ | | 181| 9.31k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (999:13): [True: 1.20k, False: 8.11k] ------------------ 1000| 234k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 1.20k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 235k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1000:13): [True: 985, False: 222] ------------------ 1001| 234k| NLBLOCK->nllen == 2 && ------------------ | | 79| 985|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1001:13): [True: 536, False: 449] ------------------ 1002| 234k| c == NLBLOCK->nl[0]) ------------------ | | 79| 536|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1002:13): [True: 316, False: 220] ------------------ 1003| 316| { 1004| 316| could_continue = partial_newline = TRUE; ------------------ | | 70| 316|#define TRUE 1 ------------------ 1005| 316| } 1006| 233k| else 1007| 233k| { 1008| 233k| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 233k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 233k, False: 13] | | ------------------ | | 504| 233k| { \ | | 505| 233k| next_new_state->offset = (x); \ | | 506| 233k| next_new_state->count = (y); \ | | 507| 233k| next_new_state++; \ | | 508| 233k| } \ | | 509| 233k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 13|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1009| 233k| } 1010| 234k| } 1011| 248k| break; 1012| | 1013| | /*-----------------------------------------------------------------*/ 1014| 248k| case OP_ALLANY: ------------------ | Branch (1014:7): [True: 35.0k, False: 8.89M] ------------------ 1015| 35.0k| if (clen > 0) ------------------ | Branch (1015:11): [True: 29.8k, False: 5.14k] ------------------ 1016| 29.8k| { ADD_NEW(state_offset + 1, 0); } ------------------ | | 503| 29.8k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 29.8k, False: 10] | | ------------------ | | 504| 29.8k| { \ | | 505| 29.8k| next_new_state->offset = (x); \ | | 506| 29.8k| next_new_state->count = (y); \ | | 507| 29.8k| next_new_state++; \ | | 508| 29.8k| } \ | | 509| 29.8k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1017| 35.0k| break; 1018| | 1019| | /*-----------------------------------------------------------------*/ 1020| 35.0k| case OP_EODN: ------------------ | Branch (1020:7): [True: 24.6k, False: 8.90M] ------------------ 1021| 24.6k| if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - mb->nllen)) ------------------ | | 479| 45.1k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 22.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 22.5k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 1.32k, False: 21.2k] | | | Branch (479:4): [True: 1.39k, False: 21.2k] | | ------------------ | | 480| 45.1k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 1.39k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 2.78k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 1.39k, False: 0] | | ------------------ | | 481| 1.39k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 1.39k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 1.39k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 1.39k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 1.39k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 239, False: 1.15k] | | ------------------ | | 482| 1.39k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 1.39k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 45.1k| : \ | | 484| 45.1k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 21.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 21.2k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 21.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 20.7k, False: 501] | | ------------------ | | 485| 21.2k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 20.7k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 20.7k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.67k, False: 19.0k] | | ------------------ | | 486| 21.2k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.67k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 814|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 814|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 856, False: 814] | | | Branch (486:30): [True: 225, False: 589] | | ------------------ | | 487| 21.2k| ) \ | | 488| 45.1k| ) ------------------ | Branch (1021:11): [True: 2.05k, False: 22.5k] | Branch (1021:44): [True: 467, False: 853] ------------------ 1022| 2.51k| { 1023| 2.51k| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 2.51k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1023:13): [True: 33, False: 2.48k] ------------------ 1024| 33| return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 33|#define PCRE2_ERROR_PARTIAL (-2) ------------------ 1025| 2.48k| ADD_ACTIVE(state_offset + 1, 0); ------------------ | | 484| 2.48k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 2.46k, False: 16] | | ------------------ | | 485| 2.48k| { \ | | 486| 2.46k| next_active_state->offset = (x); \ | | 487| 2.46k| next_active_state->count = (y); \ | | 488| 2.46k| next_active_state++; \ | | 489| 2.46k| } \ | | 490| 2.48k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 16|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1026| 2.48k| } 1027| 24.5k| break; 1028| | 1029| | /*-----------------------------------------------------------------*/ 1030| 228k| case OP_DOLL: ------------------ | Branch (1030:7): [True: 228k, False: 8.70M] ------------------ 1031| 228k| if ((mb->moptions & PCRE2_NOTEOL) == 0) ------------------ | | 177| 228k|#define PCRE2_NOTEOL 0x00000002u ------------------ | Branch (1031:11): [True: 191k, False: 36.6k] ------------------ 1032| 191k| { 1033| 191k| if (clen == 0 && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 13.5k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1033:13): [True: 13.5k, False: 178k] | Branch (1033:26): [True: 678, False: 12.8k] ------------------ 1034| 678| could_continue = TRUE; ------------------ | | 70| 678|#define TRUE 1 ------------------ 1035| 190k| else if (clen == 0 || ------------------ | Branch (1035:18): [True: 12.8k, False: 178k] ------------------ 1036| 190k| ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) && ------------------ | | 123| 178k|#define PCRE2_DOLLAR_ENDONLY 0x00000010u /* J M D */ ------------------ ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) && ------------------ | | 479| 338k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 160k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 160k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 3.04k, False: 157k] | | | Branch (479:4): [True: 19.2k, False: 141k] | | ------------------ | | 480| 338k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 19.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 38.5k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 19.2k, False: 0] | | ------------------ | | 481| 19.2k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 19.2k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 19.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 19.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 19.2k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 1.06k, False: 18.1k] | | ------------------ | | 482| 19.2k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 19.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 338k| : \ | | 484| 338k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 141k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 141k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 141k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 137k, False: 4.27k] | | ------------------ | | 485| 141k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 137k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 137k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 2.64k, False: 134k] | | ------------------ | | 486| 141k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 2.64k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.13k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.13k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.51k, False: 1.13k] | | | Branch (486:30): [True: 465, False: 666] | | ------------------ | | 487| 141k| ) \ | | 488| 338k| ) ------------------ | Branch (1036:14): [True: 160k, False: 17.1k] ------------------ 1037| 178k| (ptr == end_subject - mb->nllen) ------------------ | Branch (1037:16): [True: 2.00k, False: 1.04k] ------------------ 1038| 178k| )) 1039| 14.8k| { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 14.8k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 14.7k, False: 100] | | ------------------ | | 485| 14.8k| { \ | | 486| 14.7k| next_active_state->offset = (x); \ | | 487| 14.7k| next_active_state->count = (y); \ | | 488| 14.7k| next_active_state++; \ | | 489| 14.7k| } \ | | 490| 14.8k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 100|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1040| 176k| else if (ptr + 1 >= mb->end_subject && ------------------ | Branch (1040:18): [True: 14.4k, False: 161k] ------------------ 1041| 176k| (mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && ------------------ | | 181| 14.4k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ (mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && ------------------ | | 180| 14.4k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (1041:18): [True: 3.53k, False: 10.9k] ------------------ 1042| 176k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 3.53k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 179k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1042:18): [True: 3.31k, False: 226] ------------------ 1043| 176k| NLBLOCK->nllen == 2 && ------------------ | | 79| 3.31k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1043:18): [True: 1.52k, False: 1.78k] ------------------ 1044| 176k| c == NLBLOCK->nl[0]) ------------------ | | 79| 1.52k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1044:18): [True: 1.03k, False: 493] ------------------ 1045| 1.03k| { 1046| 1.03k| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 1.03k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1046:15): [True: 815, False: 221] ------------------ 1047| 815| { 1048| 815| reset_could_continue = TRUE; ------------------ | | 70| 815|#define TRUE 1 ------------------ 1049| 815| ADD_NEW_DATA(-(state_offset + 1), 0, 1); ------------------ | | 512| 815| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 815, False: 0] | | ------------------ | | 513| 815| { \ | | 514| 815| next_new_state->offset = (x); \ | | 515| 815| next_new_state->count = (y); \ | | 516| 815| next_new_state->data = (z); \ | | 517| 815| next_new_state++; \ | | 518| 815| } \ | | 519| 815| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 0|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1050| 815| } 1051| 221| else could_continue = partial_newline = TRUE; ------------------ | | 70| 221|#define TRUE 1 ------------------ 1052| 1.03k| } 1053| 191k| } 1054| 228k| break; 1055| | 1056| | /*-----------------------------------------------------------------*/ 1057| 228k| case OP_DOLLM: ------------------ | Branch (1057:7): [True: 117k, False: 8.81M] ------------------ 1058| 117k| if ((mb->moptions & PCRE2_NOTEOL) == 0) ------------------ | | 177| 117k|#define PCRE2_NOTEOL 0x00000002u ------------------ | Branch (1058:11): [True: 104k, False: 13.3k] ------------------ 1059| 104k| { 1060| 104k| if (clen == 0 && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 6.73k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1060:13): [True: 6.73k, False: 97.5k] | Branch (1060:26): [True: 439, False: 6.29k] ------------------ 1061| 439| could_continue = TRUE; ------------------ | | 70| 439|#define TRUE 1 ------------------ 1062| 103k| else if (clen == 0 || ------------------ | Branch (1062:18): [True: 6.29k, False: 97.5k] ------------------ 1063| 103k| ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr))) ------------------ | | 123| 97.5k|#define PCRE2_DOLLAR_ENDONLY 0x00000010u /* J M D */ ------------------ ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr))) ------------------ | | 479| 24.3k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 24.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 24.3k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 1.79k, False: 22.5k] | | | Branch (479:4): [True: 3.33k, False: 21.0k] | | ------------------ | | 480| 24.3k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 3.33k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 6.66k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 3.33k, False: 0] | | ------------------ | | 481| 3.33k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 3.33k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 3.33k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 3.33k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 3.33k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 427, False: 2.90k] | | ------------------ | | 482| 3.33k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 3.33k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 24.3k| : \ | | 484| 24.3k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 21.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 21.0k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 21.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 20.3k, False: 682] | | ------------------ | | 485| 21.0k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 20.3k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 20.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.85k, False: 18.5k] | | ------------------ | | 486| 21.0k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.85k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 975|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 975|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 883, False: 975] | | | Branch (486:30): [True: 485, False: 490] | | ------------------ | | 487| 21.0k| ) \ | | 488| 24.3k| ) ------------------ | Branch (1063:14): [True: 24.3k, False: 73.1k] ------------------ 1064| 8.09k| { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 8.09k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 8.02k, False: 62] | | ------------------ | | 485| 8.09k| { \ | | 486| 8.02k| next_active_state->offset = (x); \ | | 487| 8.02k| next_active_state->count = (y); \ | | 488| 8.02k| next_active_state++; \ | | 489| 8.02k| } \ | | 490| 8.09k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 62|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1065| 95.7k| else if (ptr + 1 >= mb->end_subject && ------------------ | Branch (1065:18): [True: 6.98k, False: 88.7k] ------------------ 1066| 95.7k| (mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && ------------------ | | 181| 6.98k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ (mb->moptions & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0 && ------------------ | | 180| 6.98k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (1066:18): [True: 2.22k, False: 4.75k] ------------------ 1067| 95.7k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 2.22k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 97.9k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1067:18): [True: 1.70k, False: 520] ------------------ 1068| 95.7k| NLBLOCK->nllen == 2 && ------------------ | | 79| 1.70k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1068:18): [True: 631, False: 1.07k] ------------------ 1069| 95.7k| c == NLBLOCK->nl[0]) ------------------ | | 79| 631|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1069:18): [True: 413, False: 218] ------------------ 1070| 413| { 1071| 413| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 413|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1071:15): [True: 201, False: 212] ------------------ 1072| 201| { 1073| 201| reset_could_continue = TRUE; ------------------ | | 70| 201|#define TRUE 1 ------------------ 1074| 201| ADD_NEW_DATA(-(state_offset + 1), 0, 1); ------------------ | | 512| 201| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 201, False: 0] | | ------------------ | | 513| 201| { \ | | 514| 201| next_new_state->offset = (x); \ | | 515| 201| next_new_state->count = (y); \ | | 516| 201| next_new_state->data = (z); \ | | 517| 201| next_new_state++; \ | | 518| 201| } \ | | 519| 201| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 0|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1075| 201| } 1076| 212| else could_continue = partial_newline = TRUE; ------------------ | | 70| 212|#define TRUE 1 ------------------ 1077| 413| } 1078| 104k| } 1079| 13.3k| else if (IS_NEWLINE(ptr)) ------------------ | | 479| 13.3k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 13.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 13.3k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 880, False: 12.4k] | | | Branch (479:4): [True: 4.92k, False: 8.41k] | | ------------------ | | 480| 13.3k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 4.92k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 9.84k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 4.68k, False: 239] | | ------------------ | | 481| 4.92k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 4.68k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 4.68k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 4.68k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 4.68k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 251, False: 4.43k] | | ------------------ | | 482| 4.68k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 4.68k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 13.3k| : \ | | 484| 13.3k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 8.41k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 8.41k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 8.41k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 7.11k, False: 1.30k] | | ------------------ | | 485| 8.41k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 7.11k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 7.11k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 916, False: 6.19k] | | ------------------ | | 486| 8.41k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 916|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 583|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 583|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 333, False: 583] | | | Branch (486:30): [True: 296, False: 287] | | ------------------ | | 487| 8.41k| ) \ | | 488| 13.3k| ) ------------------ 1080| 880| { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 880| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 877, False: 3] | | ------------------ | | 485| 880| { \ | | 486| 877| next_active_state->offset = (x); \ | | 487| 877| next_active_state->count = (y); \ | | 488| 877| next_active_state++; \ | | 489| 877| } \ | | 490| 880| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 3|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1081| 117k| break; 1082| | 1083| | /*-----------------------------------------------------------------*/ 1084| | 1085| 117k| case OP_DIGIT: ------------------ | Branch (1085:7): [True: 7.81k, False: 8.92M] ------------------ 1086| 21.6k| case OP_WHITESPACE: ------------------ | Branch (1086:7): [True: 13.8k, False: 8.91M] ------------------ 1087| 31.8k| case OP_WORDCHAR: ------------------ | Branch (1087:7): [True: 10.1k, False: 8.92M] ------------------ 1088| 31.8k| if (clen > 0 && c < 256 && ------------------ | Branch (1088:11): [True: 28.2k, False: 3.57k] | Branch (1088:23): [True: 27.3k, False: 950] ------------------ 1089| 31.8k| ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0) ------------------ | Branch (1089:13): [True: 3.76k, False: 23.5k] ------------------ 1090| 3.76k| { ADD_NEW(state_offset + 1, 0); } ------------------ | | 503| 3.76k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 3.75k, False: 10] | | ------------------ | | 504| 3.76k| { \ | | 505| 3.75k| next_new_state->offset = (x); \ | | 506| 3.75k| next_new_state->count = (y); \ | | 507| 3.75k| next_new_state++; \ | | 508| 3.75k| } \ | | 509| 3.76k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1091| 31.8k| break; 1092| | 1093| | /*-----------------------------------------------------------------*/ 1094| 37.0k| case OP_NOT_DIGIT: ------------------ | Branch (1094:7): [True: 37.0k, False: 8.89M] ------------------ 1095| 83.0k| case OP_NOT_WHITESPACE: ------------------ | Branch (1095:7): [True: 45.9k, False: 8.88M] ------------------ 1096| 95.5k| case OP_NOT_WORDCHAR: ------------------ | Branch (1096:7): [True: 12.5k, False: 8.92M] ------------------ 1097| 95.5k| if (clen > 0 && (c >= 256 || ------------------ | Branch (1097:11): [True: 86.3k, False: 9.19k] | Branch (1097:24): [True: 894, False: 85.4k] ------------------ 1098| 86.3k| ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0)) ------------------ | Branch (1098:13): [True: 80.4k, False: 5.04k] ------------------ 1099| 81.3k| { ADD_NEW(state_offset + 1, 0); } ------------------ | | 503| 81.3k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 81.3k, False: 10] | | ------------------ | | 504| 81.3k| { \ | | 505| 81.3k| next_new_state->offset = (x); \ | | 506| 81.3k| next_new_state->count = (y); \ | | 507| 81.3k| next_new_state++; \ | | 508| 81.3k| } \ | | 509| 81.3k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1100| 95.5k| break; 1101| | 1102| | /*-----------------------------------------------------------------*/ 1103| 95.5k| case OP_WORD_BOUNDARY: ------------------ | Branch (1103:7): [True: 13.4k, False: 8.91M] ------------------ 1104| 26.8k| case OP_NOT_WORD_BOUNDARY: ------------------ | Branch (1104:7): [True: 13.4k, False: 8.91M] ------------------ 1105| 35.7k| case OP_NOT_UCP_WORD_BOUNDARY: ------------------ | Branch (1105:7): [True: 8.89k, False: 8.92M] ------------------ 1106| 44.0k| case OP_UCP_WORD_BOUNDARY: ------------------ | Branch (1106:7): [True: 8.30k, False: 8.92M] ------------------ 1107| 44.0k| { 1108| 44.0k| int left_word, right_word; 1109| | 1110| 44.0k| if (ptr > start_subject) ------------------ | Branch (1110:13): [True: 42.2k, False: 1.81k] ------------------ 1111| 42.2k| { 1112| 42.2k| PCRE2_SPTR temp = ptr - 1; ------------------ | | 814| 42.2k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 42.2k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 42.2k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 42.2k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1113| 42.2k| if (temp < mb->start_used_ptr) mb->start_used_ptr = temp; ------------------ | Branch (1113:15): [True: 6.94k, False: 35.2k] ------------------ 1114| 42.2k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 1115| 42.2k| if (utf) { BACKCHAR(temp); } ------------------ | | 345| 23.6k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 3.17k, False: 20.4k] | | ------------------ ------------------ | Branch (1115:15): [True: 20.4k, False: 21.7k] ------------------ 1116| 42.2k|#endif 1117| 42.2k| GETCHARTEST(d, temp); ------------------ | | 309| 42.2k| c = *eptr; \ | | 310| 42.2k| if (utf && c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 1.68k| { \ | | | | 267| 1.68k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 673, False: 1.01k] | | | | ------------------ | | | | 268| 1.68k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 1.68k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 537, False: 477] | | | | ------------------ | | | | 270| 1.01k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 1.01k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 477, False: 0] | | | | ------------------ | | | | 272| 477| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 477| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 477| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 1.68k| } | | ------------------ | | | Branch (310:7): [True: 20.4k, False: 21.7k] | | | Branch (310:14): [True: 1.68k, False: 18.7k] | | ------------------ ------------------ 1118| 42.2k|#ifdef SUPPORT_UNICODE 1119| 42.2k| if (codevalue == OP_UCP_WORD_BOUNDARY || ------------------ | Branch (1119:15): [True: 8.10k, False: 34.1k] ------------------ 1120| 42.2k| codevalue == OP_NOT_UCP_WORD_BOUNDARY) ------------------ | Branch (1120:15): [True: 8.52k, False: 25.6k] ------------------ 1121| 16.6k| { 1122| 16.6k| if (d == '_') left_word = TRUE; else ------------------ | | 70| 440|#define TRUE 1 ------------------ | Branch (1122:17): [True: 440, False: 16.1k] ------------------ 1123| 16.1k| { 1124| 16.1k| uint32_t cat = UCD_CATEGORY(d); ------------------ | | 1859| 16.1k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 16.1k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 16.1k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 16.1k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 16.1k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 16.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 16.1k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 16.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 16.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 16.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 16.1k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 16.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 16.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1125| 16.1k| left_word = (cat == ucp_L || cat == ucp_N); ------------------ | Branch (1125:28): [True: 5.04k, False: 11.1k] | Branch (1125:44): [True: 192, False: 10.9k] ------------------ 1126| 16.1k| } 1127| 16.6k| } 1128| 25.6k| else 1129| 25.6k|#endif 1130| 25.6k| left_word = d < 256 && (ctypes[d] & ctype_word) != 0; ------------------ | | 583| 25.1k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (1130:23): [True: 25.1k, False: 453] | Branch (1130:34): [True: 6.54k, False: 18.6k] ------------------ 1131| 42.2k| } 1132| 1.81k| else left_word = FALSE; ------------------ | | 69| 1.81k|#define FALSE 0 ------------------ 1133| | 1134| 44.0k| if (clen > 0) ------------------ | Branch (1134:13): [True: 39.4k, False: 4.63k] ------------------ 1135| 39.4k| { 1136| 39.4k| if (ptr >= mb->last_used_ptr) ------------------ | Branch (1136:15): [True: 27.4k, False: 11.9k] ------------------ 1137| 27.4k| { 1138| 27.4k| PCRE2_SPTR temp = ptr + 1; ------------------ | | 814| 27.4k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 27.4k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 27.4k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 27.4k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1139| 27.4k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 1140| 27.4k| if (utf) { FORWARDCHARTEST(temp, mb->end_subject); } ------------------ | | 349| 15.5k|#define FORWARDCHARTEST(eptr,end) while(eptr < end && (*eptr & 0xc0u) == 0x80u) eptr++ | | ------------------ | | | Branch (349:41): [True: 13.8k, False: 1.67k] | | | Branch (349:55): [True: 2.10k, False: 11.7k] | | ------------------ ------------------ | Branch (1140:17): [True: 13.4k, False: 14.0k] ------------------ 1141| 27.4k|#endif 1142| 27.4k| mb->last_used_ptr = temp; 1143| 27.4k| } 1144| 39.4k|#ifdef SUPPORT_UNICODE 1145| 39.4k| if (codevalue == OP_UCP_WORD_BOUNDARY || ------------------ | Branch (1145:15): [True: 7.23k, False: 32.1k] ------------------ 1146| 39.4k| codevalue == OP_NOT_UCP_WORD_BOUNDARY) ------------------ | Branch (1146:15): [True: 7.74k, False: 24.4k] ------------------ 1147| 14.9k| { 1148| 14.9k| if (c == '_') right_word = TRUE; else ------------------ | | 70| 350|#define TRUE 1 ------------------ | Branch (1148:17): [True: 350, False: 14.6k] ------------------ 1149| 14.6k| { 1150| 14.6k| uint32_t cat = UCD_CATEGORY(c); ------------------ | | 1859| 14.6k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 14.6k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 14.6k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 14.6k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 14.6k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 14.6k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 14.6k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 14.6k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 14.6k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 14.6k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 14.6k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 14.6k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 14.6k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1151| 14.6k| right_word = (cat == ucp_L || cat == ucp_N); ------------------ | Branch (1151:29): [True: 4.45k, False: 10.1k] | Branch (1151:45): [True: 149, False: 10.0k] ------------------ 1152| 14.6k| } 1153| 14.9k| } 1154| 24.4k| else 1155| 24.4k|#endif 1156| 24.4k| right_word = c < 256 && (ctypes[c] & ctype_word) != 0; ------------------ | | 583| 24.0k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (1156:24): [True: 24.0k, False: 379] | Branch (1156:35): [True: 6.19k, False: 17.8k] ------------------ 1157| 39.4k| } 1158| 4.63k| else right_word = FALSE; ------------------ | | 69| 4.63k|#define FALSE 0 ------------------ 1159| | 1160| 44.0k| if ((left_word == right_word) == ------------------ | Branch (1160:13): [True: 23.6k, False: 20.3k] ------------------ 1161| 44.0k| (codevalue == OP_NOT_WORD_BOUNDARY || ------------------ | Branch (1161:14): [True: 13.4k, False: 30.6k] ------------------ 1162| 44.0k| codevalue == OP_NOT_UCP_WORD_BOUNDARY)) ------------------ | Branch (1162:14): [True: 8.89k, False: 21.7k] ------------------ 1163| 23.6k| { ADD_ACTIVE(state_offset + 1, 0); } ------------------ | | 484| 23.6k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 23.5k, False: 87] | | ------------------ | | 485| 23.6k| { \ | | 486| 23.5k| next_active_state->offset = (x); \ | | 487| 23.5k| next_active_state->count = (y); \ | | 488| 23.5k| next_active_state++; \ | | 489| 23.5k| } \ | | 490| 23.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 87|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1164| 44.0k| } 1165| 43.9k| break; 1166| | 1167| | 1168| | /*-----------------------------------------------------------------*/ 1169| | /* Check the next character by Unicode property. We will get here only 1170| | if the support is in the binary; otherwise a compile-time error occurs. 1171| | */ 1172| | 1173| 43.9k|#ifdef SUPPORT_UNICODE 1174| 43.9k| case OP_PROP: ------------------ | Branch (1174:7): [True: 39.2k, False: 8.89M] ------------------ 1175| 174k| case OP_NOTPROP: ------------------ | Branch (1175:7): [True: 135k, False: 8.79M] ------------------ 1176| 174k| if (clen > 0) ------------------ | Branch (1176:11): [True: 165k, False: 8.67k] ------------------ 1177| 165k| { 1178| 165k| BOOL OK; 1179| 165k| const uint32_t *cp; 1180| 165k| const ucd_record * prop = GET_UCD(c); ------------------ | | 1846| 165k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 165k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 165k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 165k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 165k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 165k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 165k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 165k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 165k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 165k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 1181| 165k| switch(code[1]) 1182| 165k| { 1183| 263| case PT_ANY: ------------------ | | 1275| 263|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (1183:11): [True: 263, False: 165k] ------------------ 1184| 263| OK = TRUE; ------------------ | | 70| 263|#define TRUE 1 ------------------ 1185| 263| break; 1186| | 1187| 1.36k| case PT_LAMP: ------------------ | | 1276| 1.36k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (1187:11): [True: 1.36k, False: 164k] ------------------ 1188| 1.36k| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || ------------------ | Branch (1188:16): [True: 248, False: 1.11k] | Branch (1188:44): [True: 390, False: 725] ------------------ 1189| 1.36k| prop->chartype == ucp_Lt; ------------------ | Branch (1189:16): [True: 0, False: 725] ------------------ 1190| 1.36k| break; 1191| | 1192| 12.0k| case PT_GC: ------------------ | | 1277| 12.0k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (1192:11): [True: 12.0k, False: 153k] ------------------ 1193| 12.0k| OK = PRIV(ucp_gentype)[prop->chartype] == code[2]; ------------------ | | 177| 12.0k|#define PRIV(name) _pcre2_##name ------------------ 1194| 12.0k| break; 1195| | 1196| 42.0k| case PT_PC: ------------------ | | 1278| 42.0k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (1196:11): [True: 42.0k, False: 123k] ------------------ 1197| 42.0k| OK = prop->chartype == code[2]; 1198| 42.0k| break; 1199| | 1200| 8.33k| case PT_SC: ------------------ | | 1279| 8.33k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (1200:11): [True: 8.33k, False: 157k] ------------------ 1201| 8.33k| OK = prop->script == code[2]; 1202| 8.33k| break; 1203| | 1204| 1.32k| case PT_SCX: ------------------ | | 1280| 1.32k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (1204:11): [True: 1.32k, False: 164k] ------------------ 1205| 1.32k| OK = (prop->script == code[2] || ------------------ | Branch (1205:17): [True: 226, False: 1.09k] ------------------ 1206| 1.32k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), code[2]) != 0); ------------------ | | 1871| 1.09k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (1206:17): [True: 0, False: 1.09k] ------------------ 1207| 1.32k| break; 1208| | 1209| | /* These are specials for combination cases. */ 1210| | 1211| 1.18k| case PT_ALNUM: ------------------ | | 1281| 1.18k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (1211:11): [True: 1.18k, False: 164k] ------------------ 1212| 1.18k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 1.18k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1212:16): [True: 499, False: 690] ------------------ 1213| 1.18k| PRIV(ucp_gentype)[prop->chartype] == ucp_N; ------------------ | | 177| 690|#define PRIV(name) _pcre2_##name ------------------ | Branch (1213:16): [True: 39, False: 651] ------------------ 1214| 1.18k| break; 1215| | 1216| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 1217| | which means that Perl space and POSIX space are now identical. PCRE 1218| | was changed at release 8.34. */ 1219| | 1220| 49.8k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 49.8k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (1220:11): [True: 49.8k, False: 115k] ------------------ 1221| 50.2k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 50.2k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (1221:11): [True: 392, False: 165k] ------------------ 1222| 50.2k| switch(c) 1223| 50.2k| { 1224| 75.1k| HSPACE_CASES: ------------------ | | 412| 1.13k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 335| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 335|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 335, False: 49.9k] | | | | ------------------ | | | | 408| 841| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 841|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 506, False: 49.7k] | | | | ------------------ | | | | 409| 1.13k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.43k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.43k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 299, False: 49.9k] | | | | ------------------ | | | | 390| 1.73k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 297, False: 49.9k] | | | | ------------------ | | | | 391| 2.23k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 508, False: 49.7k] | | | | ------------------ | | | | 392| 2.53k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 300, False: 49.9k] | | | | ------------------ | | | | 393| 2.88k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 348, False: 49.9k] | | | | ------------------ | | | | 394| 3.38k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 498, False: 49.7k] | | | | ------------------ | | | | 395| 3.70k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 321, False: 49.9k] | | | | ------------------ | | | | 396| 4.12k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 420, False: 49.8k] | | | | ------------------ | | | | 397| 4.56k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 434, False: 49.8k] | | | | ------------------ | | | | 398| 5.00k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 447, False: 49.8k] | | | | ------------------ | | | | 399| 5.70k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 696, False: 49.5k] | | | | ------------------ | | | | 400| 6.29k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 594, False: 49.6k] | | | | ------------------ | | | | 401| 6.80k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 512, False: 49.7k] | | | | ------------------ | | | | 402| 7.14k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 337, False: 49.9k] | | | | ------------------ | | | | 403| 7.40k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 254, False: 50.0k] | | | | ------------------ | | | | 404| 7.90k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 1225| 75.1k| VSPACE_CASES: ------------------ | | 430| 10.2k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 8.44k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 8.44k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 541, False: 49.7k] | | | | ------------------ | | | | 424| 8.78k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 8.78k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 342, False: 49.9k] | | | | ------------------ | | | | 425| 9.16k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 9.16k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 379, False: 49.8k] | | | | ------------------ | | | | 426| 9.81k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 9.81k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 649, False: 49.6k] | | | | ------------------ | | | | 427| 10.2k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 7.90k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 10.5k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 10.5k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 302, False: 49.9k] | | | | ------------------ | | | | 420| 10.8k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 1226| 10.8k| OK = TRUE; ------------------ | | 70| 10.8k|#define TRUE 1 ------------------ 1227| 10.8k| break; 1228| | 1229| 39.4k| default: ------------------ | Branch (1229:13): [True: 39.4k, False: 10.8k] ------------------ 1230| 39.4k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; ------------------ | | 177| 39.4k|#define PRIV(name) _pcre2_##name ------------------ 1231| 39.4k| break; 1232| 50.2k| } 1233| 50.2k| break; 1234| | 1235| 50.2k| case PT_WORD: ------------------ | | 1284| 9.14k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (1235:11): [True: 9.14k, False: 156k] ------------------ 1236| 9.14k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 9.14k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1236:16): [True: 2.59k, False: 6.54k] ------------------ 1237| 9.14k| PRIV(ucp_gentype)[prop->chartype] == ucp_N || ------------------ | | 177| 6.54k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1237:16): [True: 570, False: 5.97k] ------------------ 1238| 9.14k| c == CHAR_UNDERSCORE; ------------------ | | 1045| 15.1k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (1238:16): [True: 10, False: 5.96k] ------------------ 1239| 9.14k| break; 1240| | 1241| 8.97k| case PT_CLIST: ------------------ | | 1285| 8.97k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (1241:11): [True: 8.97k, False: 156k] ------------------ 1242| 8.97k| cp = PRIV(ucd_caseless_sets) + code[2]; ------------------ | | 177| 8.97k|#define PRIV(name) _pcre2_##name ------------------ 1243| 8.97k| for (;;) 1244| 14.8k| { 1245| 14.8k| if (c < *cp) { OK = FALSE; break; } ------------------ | | 69| 5.98k|#define FALSE 0 ------------------ | Branch (1245:17): [True: 5.98k, False: 8.84k] ------------------ 1246| 8.84k| if (c == *cp++) { OK = TRUE; break; } ------------------ | | 70| 2.98k|#define TRUE 1 ------------------ | Branch (1246:17): [True: 2.98k, False: 5.86k] ------------------ 1247| 8.84k| } 1248| 8.97k| break; 1249| | 1250| 8.34k| case PT_UCNC: ------------------ | | 1286| 8.34k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (1250:11): [True: 8.34k, False: 157k] ------------------ 1251| 8.34k| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 986| 16.6k|#define CHAR_DOLLAR_SIGN '\044' ------------------ OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 16.2k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (1251:16): [True: 429, False: 7.91k] | Branch (1251:41): [True: 231, False: 7.68k] ------------------ 1252| 8.34k| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || ------------------ | | 1046| 16.0k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (1252:16): [True: 252, False: 7.43k] | Branch (1252:43): [True: 1.06k, False: 6.37k] | Branch (1252:56): [True: 831, False: 230] ------------------ 1253| 8.34k| c >= 0xe000; ------------------ | Branch (1253:16): [True: 230, False: 6.37k] ------------------ 1254| 8.34k| break; 1255| | 1256| 2.35k| case PT_BIDICL: ------------------ | | 1287| 2.35k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (1256:11): [True: 2.35k, False: 163k] ------------------ 1257| 2.35k| OK = UCD_BIDICLASS(c) == code[2]; ------------------ | | 1865| 2.35k|#define UCD_BIDICLASS(ch) UCD_BIDICLASS_PROP(GET_UCD(ch)) | | ------------------ | | | | 1854| 2.35k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | | | ------------------ | | | | | | 1850| 2.35k|#define UCD_BIDICLASS_SHIFT 11 | | | | ------------------ | | ------------------ ------------------ 1258| 2.35k| break; 1259| | 1260| 20.0k| case PT_BOOL: ------------------ | | 1288| 20.0k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (1260:11): [True: 20.0k, False: 145k] ------------------ 1261| 20.0k| OK = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 20.0k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 1262| 20.0k| UCD_BPROPS_PROP(prop), code[2]) != 0; 1263| 20.0k| break; 1264| | 1265| | /* Should never occur, but keep compilers from grumbling. */ 1266| | 1267| 0| default: ------------------ | Branch (1267:11): [True: 0, False: 165k] ------------------ 1268| 0| OK = codevalue != OP_PROP; 1269| 0| break; 1270| 165k| } 1271| | 1272| 165k| if (OK == (codevalue == OP_PROP)) { ADD_NEW(state_offset + 3, 0); } ------------------ | | 503| 123k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 123k, False: 12] | | ------------------ | | 504| 123k| { \ | | 505| 123k| next_new_state->offset = (x); \ | | 506| 123k| next_new_state->count = (y); \ | | 507| 123k| next_new_state++; \ | | 508| 123k| } \ | | 509| 123k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 12|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (1272:13): [True: 123k, False: 41.7k] ------------------ 1273| 165k| } 1274| 174k| break; 1275| 174k|#endif 1276| | 1277| | 1278| | 1279| |/* ========================================================================== */ 1280| | /* These opcodes likewise inspect the subject character, but have an 1281| | argument that is not a data character. It is one of these opcodes: 1282| | OP_ANY, OP_ALLANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE, 1283| | OP_WORDCHAR, OP_NOT_WORDCHAR. The value is loaded into d. */ 1284| | 1285| 813k| case OP_TYPEPLUS: ------------------ | Branch (1285:7): [True: 813k, False: 8.12M] ------------------ 1286| 958k| case OP_TYPEMINPLUS: ------------------ | Branch (1286:7): [True: 145k, False: 8.78M] ------------------ 1287| 1.04M| case OP_TYPEPOSPLUS: ------------------ | Branch (1287:7): [True: 90.4k, False: 8.84M] ------------------ 1288| 1.04M| count = current_state->count; /* Already matched */ 1289| 1.04M| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } ------------------ | | 484| 919k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 918k, False: 1.11k] | | ------------------ | | 485| 919k| { \ | | 486| 918k| next_active_state->offset = (x); \ | | 487| 918k| next_active_state->count = (y); \ | | 488| 918k| next_active_state++; \ | | 489| 918k| } \ | | 490| 919k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 1.11k|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (1289:11): [True: 919k, False: 129k] ------------------ 1290| 1.04M| if (clen > 0) ------------------ | Branch (1290:11): [True: 960k, False: 86.7k] ------------------ 1291| 960k| { 1292| 960k| if (d == OP_ANY && ptr + 1 >= mb->end_subject && ------------------ | Branch (1292:13): [True: 759k, False: 201k] | Branch (1292:28): [True: 53.7k, False: 705k] ------------------ 1293| 960k| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && ------------------ | | 181| 53.7k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1293:13): [True: 2.39k, False: 51.3k] ------------------ 1294| 960k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 2.39k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 963k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1294:13): [True: 2.07k, False: 324] ------------------ 1295| 960k| NLBLOCK->nllen == 2 && ------------------ | | 79| 2.07k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1295:13): [True: 1.23k, False: 840] ------------------ 1296| 960k| c == NLBLOCK->nl[0]) ------------------ | | 79| 1.23k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1296:13): [True: 974, False: 261] ------------------ 1297| 974| { 1298| 974| could_continue = partial_newline = TRUE; ------------------ | | 70| 974|#define TRUE 1 ------------------ 1299| 974| } 1300| 959k| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || ------------------ | Branch (1300:19): [True: 19.0k, False: 940k] | Branch (1300:31): [True: 18.5k, False: 547] | Branch (1300:48): [True: 18.2k, False: 260] | Branch (1300:70): [True: 17.7k, False: 514] ------------------ 1301| 959k| (c < 256 && ------------------ | Branch (1301:14): [True: 940k, False: 1.32k] ------------------ 1302| 942k| (d != OP_ANY || !IS_NEWLINE(ptr)) && ------------------ | | 479| 748k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 748k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 748k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 40.1k, False: 708k] | | ------------------ | | 480| 748k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 40.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 80.2k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 40.1k, False: 0] | | ------------------ | | 481| 40.1k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 40.1k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 40.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 40.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 40.1k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 1.93k, False: 38.2k] | | ------------------ | | 482| 40.1k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 40.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 748k| : \ | | 484| 748k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 708k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 708k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 708k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 702k, False: 6.54k] | | ------------------ | | 485| 708k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 702k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 702k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 8.53k, False: 693k] | | ------------------ | | 486| 708k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 8.53k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 3.18k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 3.18k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 5.35k, False: 3.18k] | | | Branch (486:30): [True: 882, False: 2.30k] | | ------------------ | | 487| 708k| ) \ | | 488| 748k| ) ------------------ | Branch (1302:16): [True: 192k, False: 748k] | Branch (1302:31): [True: 740k, False: 8.16k] ------------------ 1303| 942k| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) ------------------ | Branch (1303:15): [True: 914k, False: 18.3k] ------------------ 1304| 931k| { 1305| 931k| if (count > 0 && codevalue == OP_TYPEPOSPLUS) ------------------ | Branch (1305:15): [True: 830k, False: 101k] | Branch (1305:28): [True: 64.5k, False: 765k] ------------------ 1306| 64.5k| { 1307| 64.5k| active_count--; /* Remove non-match possibility */ 1308| 64.5k| next_active_state--; 1309| 64.5k| } 1310| 931k| count++; 1311| 931k| ADD_NEW(state_offset, count); ------------------ | | 503| 931k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 931k, False: 12] | | ------------------ | | 504| 931k| { \ | | 505| 931k| next_new_state->offset = (x); \ | | 506| 931k| next_new_state->count = (y); \ | | 507| 931k| next_new_state++; \ | | 508| 931k| } \ | | 509| 931k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 12|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1312| 931k| } 1313| 960k| } 1314| 1.04M| break; 1315| | 1316| | /*-----------------------------------------------------------------*/ 1317| 1.04M| case OP_TYPEQUERY: ------------------ | Branch (1317:7): [True: 62.9k, False: 8.87M] ------------------ 1318| 74.6k| case OP_TYPEMINQUERY: ------------------ | Branch (1318:7): [True: 11.7k, False: 8.92M] ------------------ 1319| 84.4k| case OP_TYPEPOSQUERY: ------------------ | Branch (1319:7): [True: 9.80k, False: 8.92M] ------------------ 1320| 84.4k| ADD_ACTIVE(state_offset + 2, 0); ------------------ | | 484| 84.4k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 84.2k, False: 225] | | ------------------ | | 485| 84.4k| { \ | | 486| 84.2k| next_active_state->offset = (x); \ | | 487| 84.2k| next_active_state->count = (y); \ | | 488| 84.2k| next_active_state++; \ | | 489| 84.2k| } \ | | 490| 84.4k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 225|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1321| 84.2k| if (clen > 0) ------------------ | Branch (1321:11): [True: 77.3k, False: 6.93k] ------------------ 1322| 77.3k| { 1323| 77.3k| if (d == OP_ANY && ptr + 1 >= mb->end_subject && ------------------ | Branch (1323:13): [True: 50.7k, False: 26.5k] | Branch (1323:28): [True: 4.57k, False: 46.2k] ------------------ 1324| 77.3k| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && ------------------ | | 181| 4.57k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1324:13): [True: 1.11k, False: 3.45k] ------------------ 1325| 77.3k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 1.11k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 78.4k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1325:13): [True: 911, False: 208] ------------------ 1326| 77.3k| NLBLOCK->nllen == 2 && ------------------ | | 79| 911|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1326:13): [True: 415, False: 496] ------------------ 1327| 77.3k| c == NLBLOCK->nl[0]) ------------------ | | 79| 415|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1327:13): [True: 204, False: 211] ------------------ 1328| 204| { 1329| 204| could_continue = partial_newline = TRUE; ------------------ | | 70| 204|#define TRUE 1 ------------------ 1330| 204| } 1331| 77.0k| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || ------------------ | Branch (1331:19): [True: 1.56k, False: 75.5k] | Branch (1331:31): [True: 1.31k, False: 247] | Branch (1331:48): [True: 1.04k, False: 272] | Branch (1331:70): [True: 784, False: 261] ------------------ 1332| 77.0k| (c < 256 && ------------------ | Branch (1332:14): [True: 75.5k, False: 780] ------------------ 1333| 76.3k| (d != OP_ANY || !IS_NEWLINE(ptr)) && ------------------ | | 479| 50.3k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 50.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 50.3k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 5.45k, False: 44.9k] | | ------------------ | | 480| 50.3k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 5.45k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 10.9k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 5.45k, False: 0] | | ------------------ | | 481| 5.45k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 5.45k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 5.45k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 5.45k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 5.45k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 482, False: 4.96k] | | ------------------ | | 482| 5.45k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 5.45k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 50.3k| : \ | | 484| 50.3k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 44.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 44.9k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 44.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 43.9k, False: 994] | | ------------------ | | 485| 44.9k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 43.9k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 43.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.50k, False: 42.4k] | | ------------------ | | 486| 44.9k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.50k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 496|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 496|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.01k, False: 496] | | | Branch (486:30): [True: 275, False: 221] | | ------------------ | | 487| 44.9k| ) \ | | 488| 50.3k| ) ------------------ | Branch (1333:16): [True: 25.1k, False: 50.3k] | Branch (1333:31): [True: 48.6k, False: 1.76k] ------------------ 1334| 76.3k| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) ------------------ | Branch (1334:15): [True: 65.7k, False: 7.98k] ------------------ 1335| 66.5k| { 1336| 66.5k| if (codevalue == OP_TYPEPOSQUERY) ------------------ | Branch (1336:15): [True: 5.13k, False: 61.4k] ------------------ 1337| 5.13k| { 1338| 5.13k| active_count--; /* Remove non-match possibility */ 1339| 5.13k| next_active_state--; 1340| 5.13k| } 1341| 66.5k| ADD_NEW(state_offset + 2, 0); ------------------ | | 503| 66.5k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 66.5k, False: 10] | | ------------------ | | 504| 66.5k| { \ | | 505| 66.5k| next_new_state->offset = (x); \ | | 506| 66.5k| next_new_state->count = (y); \ | | 507| 66.5k| next_new_state++; \ | | 508| 66.5k| } \ | | 509| 66.5k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1342| 66.5k| } 1343| 77.3k| } 1344| 84.2k| break; 1345| | 1346| | /*-----------------------------------------------------------------*/ 1347| 586k| case OP_TYPESTAR: ------------------ | Branch (1347:7): [True: 586k, False: 8.34M] ------------------ 1348| 711k| case OP_TYPEMINSTAR: ------------------ | Branch (1348:7): [True: 124k, False: 8.80M] ------------------ 1349| 806k| case OP_TYPEPOSSTAR: ------------------ | Branch (1349:7): [True: 95.0k, False: 8.83M] ------------------ 1350| 806k| ADD_ACTIVE(state_offset + 2, 0); ------------------ | | 484| 806k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 805k, False: 178] | | ------------------ | | 485| 806k| { \ | | 486| 805k| next_active_state->offset = (x); \ | | 487| 805k| next_active_state->count = (y); \ | | 488| 805k| next_active_state++; \ | | 489| 805k| } \ | | 490| 806k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 178|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1351| 805k| if (clen > 0) ------------------ | Branch (1351:11): [True: 745k, False: 60.0k] ------------------ 1352| 745k| { 1353| 745k| if (d == OP_ANY && ptr + 1 >= mb->end_subject && ------------------ | Branch (1353:13): [True: 485k, False: 260k] | Branch (1353:28): [True: 28.9k, False: 456k] ------------------ 1354| 745k| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && ------------------ | | 181| 28.9k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1354:13): [True: 2.48k, False: 26.5k] ------------------ 1355| 745k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 2.48k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 748k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1355:13): [True: 1.88k, False: 601] ------------------ 1356| 745k| NLBLOCK->nllen == 2 && ------------------ | | 79| 1.88k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1356:13): [True: 1.05k, False: 827] ------------------ 1357| 745k| c == NLBLOCK->nl[0]) ------------------ | | 79| 1.05k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1357:13): [True: 820, False: 234] ------------------ 1358| 820| { 1359| 820| could_continue = partial_newline = TRUE; ------------------ | | 70| 820|#define TRUE 1 ------------------ 1360| 820| } 1361| 745k| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || ------------------ | Branch (1361:19): [True: 15.2k, False: 729k] | Branch (1361:31): [True: 14.9k, False: 372] | Branch (1361:48): [True: 14.5k, False: 380] | Branch (1361:70): [True: 14.2k, False: 227] ------------------ 1362| 745k| (c < 256 && ------------------ | Branch (1362:14): [True: 729k, False: 979] ------------------ 1363| 730k| (d != OP_ANY || !IS_NEWLINE(ptr)) && ------------------ | | 479| 475k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 475k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 475k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 38.9k, False: 436k] | | ------------------ | | 480| 475k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 38.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 77.9k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 38.9k, False: 0] | | ------------------ | | 481| 38.9k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 38.9k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 38.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 38.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 38.9k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 3.28k, False: 35.6k] | | ------------------ | | 482| 38.9k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 38.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 475k| : \ | | 484| 475k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 436k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 436k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 436k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 432k, False: 3.81k] | | ------------------ | | 485| 436k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 432k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 432k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 5.98k, False: 426k] | | ------------------ | | 486| 436k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 5.98k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 2.00k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 2.00k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 3.98k, False: 2.00k] | | | Branch (486:30): [True: 825, False: 1.18k] | | ------------------ | | 487| 436k| ) \ | | 488| 475k| ) ------------------ | Branch (1363:16): [True: 254k, False: 475k] | Branch (1363:31): [True: 467k, False: 8.08k] ------------------ 1364| 730k| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) ------------------ | Branch (1364:15): [True: 704k, False: 17.0k] ------------------ 1365| 718k| { 1366| 718k| if (codevalue == OP_TYPEPOSSTAR) ------------------ | Branch (1366:15): [True: 84.4k, False: 634k] ------------------ 1367| 84.4k| { 1368| 84.4k| active_count--; /* Remove non-match possibility */ 1369| 84.4k| next_active_state--; 1370| 84.4k| } 1371| 718k| ADD_NEW(state_offset, 0); ------------------ | | 503| 718k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 718k, False: 10] | | ------------------ | | 504| 718k| { \ | | 505| 718k| next_new_state->offset = (x); \ | | 506| 718k| next_new_state->count = (y); \ | | 507| 718k| next_new_state++; \ | | 508| 718k| } \ | | 509| 718k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1372| 718k| } 1373| 745k| } 1374| 805k| break; 1375| | 1376| | /*-----------------------------------------------------------------*/ 1377| 805k| case OP_TYPEEXACT: ------------------ | Branch (1377:7): [True: 180k, False: 8.75M] ------------------ 1378| 180k| count = current_state->count; /* Number already matched */ 1379| 180k| if (clen > 0) ------------------ | Branch (1379:11): [True: 165k, False: 14.9k] ------------------ 1380| 165k| { 1381| 165k| if (d == OP_ANY && ptr + 1 >= mb->end_subject && ------------------ | Branch (1381:13): [True: 96.2k, False: 69.2k] | Branch (1381:28): [True: 6.65k, False: 89.6k] ------------------ 1382| 165k| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && ------------------ | | 181| 6.65k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1382:13): [True: 1.39k, False: 5.25k] ------------------ 1383| 165k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 1.39k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 166k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1383:13): [True: 1.08k, False: 312] ------------------ 1384| 165k| NLBLOCK->nllen == 2 && ------------------ | | 79| 1.08k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1384:13): [True: 505, False: 582] ------------------ 1385| 165k| c == NLBLOCK->nl[0]) ------------------ | | 79| 505|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1385:13): [True: 289, False: 216] ------------------ 1386| 289| { 1387| 289| could_continue = partial_newline = TRUE; ------------------ | | 70| 289|#define TRUE 1 ------------------ 1388| 289| } 1389| 165k| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || ------------------ | Branch (1389:19): [True: 2.02k, False: 163k] | Branch (1389:31): [True: 1.81k, False: 212] | Branch (1389:48): [True: 1.61k, False: 206] | Branch (1389:70): [True: 1.40k, False: 205] ------------------ 1390| 165k| (c < 256 && ------------------ | Branch (1390:14): [True: 163k, False: 623] ------------------ 1391| 163k| (d != OP_ANY || !IS_NEWLINE(ptr)) && ------------------ | | 479| 95.5k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 95.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 95.5k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 15.8k, False: 79.6k] | | ------------------ | | 480| 95.5k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 15.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 31.7k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 15.8k, False: 0] | | ------------------ | | 481| 15.8k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 15.8k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 15.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 15.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 15.8k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 825, False: 15.0k] | | ------------------ | | 482| 15.8k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 15.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 95.5k| : \ | | 484| 95.5k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 79.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 79.6k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 79.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 77.5k, False: 2.12k] | | ------------------ | | 485| 79.6k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 77.5k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 77.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 2.22k, False: 75.3k] | | ------------------ | | 486| 79.6k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 2.22k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.20k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.20k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.01k, False: 1.20k] | | | Branch (486:30): [True: 637, False: 564] | | ------------------ | | 487| 79.6k| ) \ | | 488| 95.5k| ) ------------------ | Branch (1391:16): [True: 67.6k, False: 95.5k] | Branch (1391:31): [True: 93.0k, False: 2.48k] ------------------ 1392| 163k| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) ------------------ | Branch (1392:15): [True: 153k, False: 7.63k] ------------------ 1393| 154k| { 1394| 154k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 154k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (1394:15): [True: 16.3k, False: 138k] ------------------ 1395| 16.3k| { ADD_NEW(state_offset + 1 + IMM2_SIZE + 1, 0); } ------------------ | | 503| 16.3k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 16.3k, False: 10] | | ------------------ | | 504| 16.3k| { \ | | 505| 16.3k| next_new_state->offset = (x); \ | | 506| 16.3k| next_new_state->count = (y); \ | | 507| 16.3k| next_new_state++; \ | | 508| 16.3k| } \ | | 509| 16.3k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1396| 138k| else 1397| 138k| { ADD_NEW(state_offset, count); } ------------------ | | 503| 138k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 138k, False: 11] | | ------------------ | | 504| 138k| { \ | | 505| 138k| next_new_state->offset = (x); \ | | 506| 138k| next_new_state->count = (y); \ | | 507| 138k| next_new_state++; \ | | 508| 138k| } \ | | 509| 138k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 11|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1398| 154k| } 1399| 165k| } 1400| 180k| break; 1401| | 1402| | /*-----------------------------------------------------------------*/ 1403| 180k| case OP_TYPEUPTO: ------------------ | Branch (1403:7): [True: 33.7k, False: 8.89M] ------------------ 1404| 41.3k| case OP_TYPEMINUPTO: ------------------ | Branch (1404:7): [True: 7.56k, False: 8.92M] ------------------ 1405| 71.9k| case OP_TYPEPOSUPTO: ------------------ | Branch (1405:7): [True: 30.6k, False: 8.90M] ------------------ 1406| 71.9k| ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); ------------------ | | 484| 71.9k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 71.9k, False: 35] | | ------------------ | | 485| 71.9k| { \ | | 486| 71.9k| next_active_state->offset = (x); \ | | 487| 71.9k| next_active_state->count = (y); \ | | 488| 71.9k| next_active_state++; \ | | 489| 71.9k| } \ | | 490| 71.9k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 35|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1407| 71.9k| count = current_state->count; /* Number already matched */ 1408| 71.9k| if (clen > 0) ------------------ | Branch (1408:11): [True: 67.6k, False: 4.26k] ------------------ 1409| 67.6k| { 1410| 67.6k| if (d == OP_ANY && ptr + 1 >= mb->end_subject && ------------------ | Branch (1410:13): [True: 52.6k, False: 14.9k] | Branch (1410:28): [True: 4.47k, False: 48.2k] ------------------ 1411| 67.6k| (mb->moptions & (PCRE2_PARTIAL_HARD)) != 0 && ------------------ | | 181| 4.47k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (1411:13): [True: 1.11k, False: 3.36k] ------------------ 1412| 67.6k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 79| 1.11k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 68.7k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (1412:13): [True: 881, False: 234] ------------------ 1413| 67.6k| NLBLOCK->nllen == 2 && ------------------ | | 79| 881|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1413:13): [True: 491, False: 390] ------------------ 1414| 67.6k| c == NLBLOCK->nl[0]) ------------------ | | 79| 491|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (1414:13): [True: 288, False: 203] ------------------ 1415| 288| { 1416| 288| could_continue = partial_newline = TRUE; ------------------ | | 70| 288|#define TRUE 1 ------------------ 1417| 288| } 1418| 67.3k| else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) || ------------------ | Branch (1418:19): [True: 887, False: 66.4k] | Branch (1418:31): [True: 667, False: 220] | Branch (1418:48): [True: 468, False: 199] | Branch (1418:70): [True: 260, False: 208] ------------------ 1419| 67.3k| (c < 256 && ------------------ | Branch (1419:14): [True: 66.4k, False: 627] ------------------ 1420| 67.1k| (d != OP_ANY || !IS_NEWLINE(ptr)) && ------------------ | | 479| 52.2k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 79| 52.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 52.2k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 3.92k, False: 48.3k] | | ------------------ | | 480| 52.2k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 79| 3.92k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 81| 7.85k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 3.92k, False: 0] | | ------------------ | | 481| 3.92k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 3.92k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 3.92k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 79| 3.92k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 81| 3.92k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 604, False: 3.32k] | | ------------------ | | 482| 3.92k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 79| 3.92k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 52.2k| : \ | | 484| 52.2k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 48.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 81| 48.3k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 79| 48.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 47.1k, False: 1.22k] | | ------------------ | | 485| 48.3k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 47.1k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 79| 47.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.64k, False: 45.4k] | | ------------------ | | 486| 48.3k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 1.64k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 701|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 79| 701|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 940, False: 701] | | | Branch (486:30): [True: 298, False: 403] | | ------------------ | | 487| 48.3k| ) \ | | 488| 52.2k| ) ------------------ | Branch (1420:16): [True: 14.1k, False: 52.2k] | Branch (1420:31): [True: 50.4k, False: 1.84k] ------------------ 1421| 67.1k| ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0)) ------------------ | Branch (1421:15): [True: 60.5k, False: 4.05k] ------------------ 1422| 60.8k| { 1423| 60.8k| if (codevalue == OP_TYPEPOSUPTO) ------------------ | Branch (1423:15): [True: 27.1k, False: 33.7k] ------------------ 1424| 27.1k| { 1425| 27.1k| active_count--; /* Remove non-match possibility */ 1426| 27.1k| next_active_state--; 1427| 27.1k| } 1428| 60.8k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 60.8k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (1428:15): [True: 5.49k, False: 55.3k] ------------------ 1429| 5.49k| { ADD_NEW(state_offset + 2 + IMM2_SIZE, 0); } ------------------ | | 503| 5.49k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 5.48k, False: 10] | | ------------------ | | 504| 5.49k| { \ | | 505| 5.48k| next_new_state->offset = (x); \ | | 506| 5.48k| next_new_state->count = (y); \ | | 507| 5.48k| next_new_state++; \ | | 508| 5.48k| } \ | | 509| 5.49k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1430| 55.3k| else 1431| 55.3k| { ADD_NEW(state_offset, count); } ------------------ | | 503| 55.3k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 55.3k, False: 10] | | ------------------ | | 504| 55.3k| { \ | | 505| 55.3k| next_new_state->offset = (x); \ | | 506| 55.3k| next_new_state->count = (y); \ | | 507| 55.3k| next_new_state++; \ | | 508| 55.3k| } \ | | 509| 55.3k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1432| 60.8k| } 1433| 67.6k| } 1434| 71.8k| break; 1435| | 1436| |/* ========================================================================== */ 1437| | /* These are virtual opcodes that are used when something like 1438| | OP_TYPEPLUS has OP_PROP, OP_NOTPROP, OP_ANYNL, or OP_EXTUNI as its 1439| | argument. It keeps the code above fast for the other cases. The argument 1440| | is in the d variable. */ 1441| | 1442| 71.8k|#ifdef SUPPORT_UNICODE 1443| 125k| case OP_PROP_EXTRA + OP_TYPEPLUS: ------------------ | | 101| 125k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1443:7): [True: 125k, False: 8.80M] ------------------ 1444| 203k| case OP_PROP_EXTRA + OP_TYPEMINPLUS: ------------------ | | 101| 203k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1444:7): [True: 78.6k, False: 8.85M] ------------------ 1445| 236k| case OP_PROP_EXTRA + OP_TYPEPOSPLUS: ------------------ | | 101| 236k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1445:7): [True: 32.9k, False: 8.90M] ------------------ 1446| 236k| count = current_state->count; /* Already matched */ 1447| 236k| if (count > 0) { ADD_ACTIVE(state_offset + 4, 0); } ------------------ | | 484| 153k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 153k, False: 356] | | ------------------ | | 485| 153k| { \ | | 486| 153k| next_active_state->offset = (x); \ | | 487| 153k| next_active_state->count = (y); \ | | 488| 153k| next_active_state++; \ | | 489| 153k| } \ | | 490| 153k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 356|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (1447:11): [True: 153k, False: 83.4k] ------------------ 1448| 236k| if (clen > 0) ------------------ | Branch (1448:11): [True: 213k, False: 23.3k] ------------------ 1449| 213k| { 1450| 213k| BOOL OK; 1451| 213k| const uint32_t *cp; 1452| 213k| const ucd_record * prop = GET_UCD(c); ------------------ | | 1846| 213k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 213k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 213k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 213k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 213k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 213k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 213k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 213k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 213k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 213k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 1453| 213k| switch(code[2]) 1454| 213k| { 1455| 404| case PT_ANY: ------------------ | | 1275| 404|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (1455:11): [True: 404, False: 212k] ------------------ 1456| 404| OK = TRUE; ------------------ | | 70| 404|#define TRUE 1 ------------------ 1457| 404| break; 1458| | 1459| 18.1k| case PT_LAMP: ------------------ | | 1276| 18.1k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (1459:11): [True: 18.1k, False: 195k] ------------------ 1460| 18.1k| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || ------------------ | Branch (1460:16): [True: 2.64k, False: 15.4k] | Branch (1460:44): [True: 1.98k, False: 13.4k] ------------------ 1461| 18.1k| prop->chartype == ucp_Lt; ------------------ | Branch (1461:13): [True: 0, False: 13.4k] ------------------ 1462| 18.1k| break; 1463| | 1464| 15.6k| case PT_GC: ------------------ | | 1277| 15.6k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (1464:11): [True: 15.6k, False: 197k] ------------------ 1465| 15.6k| OK = PRIV(ucp_gentype)[prop->chartype] == code[3]; ------------------ | | 177| 15.6k|#define PRIV(name) _pcre2_##name ------------------ 1466| 15.6k| break; 1467| | 1468| 7.61k| case PT_PC: ------------------ | | 1278| 7.61k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (1468:11): [True: 7.61k, False: 205k] ------------------ 1469| 7.61k| OK = prop->chartype == code[3]; 1470| 7.61k| break; 1471| | 1472| 16.8k| case PT_SC: ------------------ | | 1279| 16.8k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (1472:11): [True: 16.8k, False: 196k] ------------------ 1473| 16.8k| OK = prop->script == code[3]; 1474| 16.8k| break; 1475| | 1476| 21.1k| case PT_SCX: ------------------ | | 1280| 21.1k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (1476:11): [True: 21.1k, False: 192k] ------------------ 1477| 21.1k| OK = (prop->script == code[3] || ------------------ | Branch (1477:17): [True: 814, False: 20.3k] ------------------ 1478| 21.1k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), code[3]) != 0); ------------------ | | 1871| 20.3k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (1478:17): [True: 0, False: 20.3k] ------------------ 1479| 21.1k| break; 1480| | 1481| | /* These are specials for combination cases. */ 1482| | 1483| 16.8k| case PT_ALNUM: ------------------ | | 1281| 16.8k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (1483:11): [True: 16.8k, False: 196k] ------------------ 1484| 16.8k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 16.8k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1484:16): [True: 6.18k, False: 10.6k] ------------------ 1485| 16.8k| PRIV(ucp_gentype)[prop->chartype] == ucp_N; ------------------ | | 177| 10.6k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1485:16): [True: 419, False: 10.2k] ------------------ 1486| 16.8k| break; 1487| | 1488| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 1489| | which means that Perl space and POSIX space are now identical. PCRE 1490| | was changed at release 8.34. */ 1491| | 1492| 43.3k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 43.3k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (1492:11): [True: 43.3k, False: 169k] ------------------ 1493| 44.0k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 44.0k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (1493:11): [True: 633, False: 212k] ------------------ 1494| 44.0k| switch(c) 1495| 44.0k| { 1496| 78.4k| HSPACE_CASES: ------------------ | | 412| 1.42k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 398| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 398|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 398, False: 43.6k] | | | | ------------------ | | | | 408| 958| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 958|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 560, False: 43.4k] | | | | ------------------ | | | | 409| 1.42k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.78k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.78k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 365, False: 43.6k] | | | | ------------------ | | | | 390| 2.14k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 354, False: 43.6k] | | | | ------------------ | | | | 391| 2.48k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 344, False: 43.6k] | | | | ------------------ | | | | 392| 2.83k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 346, False: 43.6k] | | | | ------------------ | | | | 393| 3.25k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 426, False: 43.5k] | | | | ------------------ | | | | 394| 3.69k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 437, False: 43.5k] | | | | ------------------ | | | | 395| 4.06k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 366, False: 43.6k] | | | | ------------------ | | | | 396| 4.43k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 374, False: 43.6k] | | | | ------------------ | | | | 397| 4.97k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 540, False: 43.4k] | | | | ------------------ | | | | 398| 5.46k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 487, False: 43.5k] | | | | ------------------ | | | | 399| 5.78k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 324, False: 43.6k] | | | | ------------------ | | | | 400| 6.28k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 500, False: 43.5k] | | | | ------------------ | | | | 401| 6.65k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 364, False: 43.6k] | | | | ------------------ | | | | 402| 6.95k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 306, False: 43.7k] | | | | ------------------ | | | | 403| 7.25k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 294, False: 43.7k] | | | | ------------------ | | | | 404| 7.65k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 1497| 78.4k| VSPACE_CASES: ------------------ | | 430| 9.59k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 8.01k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 8.01k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 361, False: 43.6k] | | | | ------------------ | | | | 424| 8.43k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 8.43k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 417, False: 43.6k] | | | | ------------------ | | | | 425| 8.74k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 8.74k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 310, False: 43.7k] | | | | ------------------ | | | | 426| 9.26k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 9.26k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 522, False: 43.4k] | | | | ------------------ | | | | 427| 9.59k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 7.65k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 9.90k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 9.90k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 318, False: 43.7k] | | | | ------------------ | | | | 420| 10.2k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 1498| 10.2k| OK = TRUE; ------------------ | | 70| 10.2k|#define TRUE 1 ------------------ 1499| 10.2k| break; 1500| | 1501| 33.7k| default: ------------------ | Branch (1501:13): [True: 33.7k, False: 10.2k] ------------------ 1502| 33.7k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; ------------------ | | 177| 33.7k|#define PRIV(name) _pcre2_##name ------------------ 1503| 33.7k| break; 1504| 44.0k| } 1505| 44.0k| break; 1506| | 1507| 44.0k| case PT_WORD: ------------------ | | 1284| 6.59k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (1507:11): [True: 6.59k, False: 206k] ------------------ 1508| 6.59k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 6.59k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1508:16): [True: 1.88k, False: 4.70k] ------------------ 1509| 6.59k| PRIV(ucp_gentype)[prop->chartype] == ucp_N || ------------------ | | 177| 4.70k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1509:16): [True: 440, False: 4.26k] ------------------ 1510| 6.59k| c == CHAR_UNDERSCORE; ------------------ | | 1045| 10.8k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (1510:16): [True: 0, False: 4.26k] ------------------ 1511| 6.59k| break; 1512| | 1513| 6.02k| case PT_CLIST: ------------------ | | 1285| 6.02k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (1513:11): [True: 6.02k, False: 207k] ------------------ 1514| 6.02k| cp = PRIV(ucd_caseless_sets) + code[3]; ------------------ | | 177| 6.02k|#define PRIV(name) _pcre2_##name ------------------ 1515| 6.02k| for (;;) 1516| 9.55k| { 1517| 9.55k| if (c < *cp) { OK = FALSE; break; } ------------------ | | 69| 4.89k|#define FALSE 0 ------------------ | Branch (1517:17): [True: 4.89k, False: 4.66k] ------------------ 1518| 4.66k| if (c == *cp++) { OK = TRUE; break; } ------------------ | | 70| 1.12k|#define TRUE 1 ------------------ | Branch (1518:17): [True: 1.12k, False: 3.53k] ------------------ 1519| 4.66k| } 1520| 6.02k| break; 1521| | 1522| 26.1k| case PT_UCNC: ------------------ | | 1286| 26.1k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (1522:11): [True: 26.1k, False: 187k] ------------------ 1523| 26.1k| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 986| 52.2k|#define CHAR_DOLLAR_SIGN '\044' ------------------ OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 51.7k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (1523:16): [True: 516, False: 25.6k] | Branch (1523:41): [True: 434, False: 25.1k] ------------------ 1524| 26.1k| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || ------------------ | | 1046| 51.3k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (1524:16): [True: 294, False: 24.9k] | Branch (1524:43): [True: 3.08k, False: 21.8k] | Branch (1524:56): [True: 2.44k, False: 639] ------------------ 1525| 26.1k| c >= 0xe000; ------------------ | Branch (1525:16): [True: 639, False: 21.8k] ------------------ 1526| 26.1k| break; 1527| | 1528| 20.4k| case PT_BIDICL: ------------------ | | 1287| 20.4k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (1528:11): [True: 20.4k, False: 192k] ------------------ 1529| 20.4k| OK = UCD_BIDICLASS(c) == code[3]; ------------------ | | 1865| 20.4k|#define UCD_BIDICLASS(ch) UCD_BIDICLASS_PROP(GET_UCD(ch)) | | ------------------ | | | | 1854| 20.4k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | | | ------------------ | | | | | | 1850| 20.4k|#define UCD_BIDICLASS_SHIFT 11 | | | | ------------------ | | ------------------ ------------------ 1530| 20.4k| break; 1531| | 1532| 13.2k| case PT_BOOL: ------------------ | | 1288| 13.2k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (1532:11): [True: 13.2k, False: 199k] ------------------ 1533| 13.2k| OK = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 13.2k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 1534| 13.2k| UCD_BPROPS_PROP(prop), code[3]) != 0; 1535| 13.2k| break; 1536| | 1537| | /* Should never occur, but keep compilers from grumbling. */ 1538| | 1539| 0| default: ------------------ | Branch (1539:11): [True: 0, False: 213k] ------------------ 1540| 0| OK = codevalue != OP_PROP; 1541| 0| break; 1542| 213k| } 1543| | 1544| 213k| if (OK == (d == OP_PROP)) ------------------ | Branch (1544:13): [True: 157k, False: 55.4k] ------------------ 1545| 157k| { 1546| 157k| if (count > 0 && codevalue == OP_PROP_EXTRA + OP_TYPEPOSPLUS) ------------------ | | 101| 116k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1546:15): [True: 116k, False: 41.2k] | Branch (1546:28): [True: 15.2k, False: 101k] ------------------ 1547| 15.2k| { 1548| 15.2k| active_count--; /* Remove non-match possibility */ 1549| 15.2k| next_active_state--; 1550| 15.2k| } 1551| 157k| count++; 1552| 157k| ADD_NEW(state_offset, count); ------------------ | | 503| 157k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 157k, False: 10] | | ------------------ | | 504| 157k| { \ | | 505| 157k| next_new_state->offset = (x); \ | | 506| 157k| next_new_state->count = (y); \ | | 507| 157k| next_new_state++; \ | | 508| 157k| } \ | | 509| 157k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1553| 157k| } 1554| 213k| } 1555| 236k| break; 1556| | 1557| | /*-----------------------------------------------------------------*/ 1558| 236k| case OP_EXTUNI_EXTRA + OP_TYPEPLUS: ------------------ | | 102| 209k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1558:7): [True: 209k, False: 8.72M] ------------------ 1559| 215k| case OP_EXTUNI_EXTRA + OP_TYPEMINPLUS: ------------------ | | 102| 215k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1559:7): [True: 6.11k, False: 8.92M] ------------------ 1560| 217k| case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS: ------------------ | | 102| 217k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1560:7): [True: 1.67k, False: 8.93M] ------------------ 1561| 217k| count = current_state->count; /* Already matched */ 1562| 217k| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } ------------------ | | 484| 212k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 212k, False: 76] | | ------------------ | | 485| 212k| { \ | | 486| 212k| next_active_state->offset = (x); \ | | 487| 212k| next_active_state->count = (y); \ | | 488| 212k| next_active_state++; \ | | 489| 212k| } \ | | 490| 212k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 76|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (1562:11): [True: 212k, False: 5.08k] ------------------ 1563| 217k| if (clen > 0) ------------------ | Branch (1563:11): [True: 212k, False: 4.27k] ------------------ 1564| 212k| { 1565| 212k| int ncount = 0; 1566| 212k| if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS) ------------------ | | 102| 208k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1566:13): [True: 208k, False: 3.93k] | Branch (1566:26): [True: 1.14k, False: 207k] ------------------ 1567| 1.14k| { 1568| 1.14k| active_count--; /* Remove non-match possibility */ 1569| 1.14k| next_active_state--; 1570| 1.14k| } 1571| 212k| (void)PRIV(extuni)(c, ptr + clen, mb->start_subject, end_subject, utf, ------------------ | | 177| 212k|#define PRIV(name) _pcre2_##name ------------------ 1572| 212k| &ncount); 1573| 212k| count++; 1574| 212k| ADD_NEW_DATA(-state_offset, count, ncount); ------------------ | | 512| 212k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 212k, False: 10] | | ------------------ | | 513| 212k| { \ | | 514| 212k| next_new_state->offset = (x); \ | | 515| 212k| next_new_state->count = (y); \ | | 516| 212k| next_new_state->data = (z); \ | | 517| 212k| next_new_state++; \ | | 518| 212k| } \ | | 519| 212k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1575| 212k| } 1576| 217k| break; 1577| 217k|#endif 1578| | 1579| | /*-----------------------------------------------------------------*/ 1580| 217k| case OP_ANYNL_EXTRA + OP_TYPEPLUS: ------------------ | | 103| 15.4k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1580:7): [True: 15.4k, False: 8.91M] ------------------ 1581| 17.8k| case OP_ANYNL_EXTRA + OP_TYPEMINPLUS: ------------------ | | 103| 17.8k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1581:7): [True: 2.38k, False: 8.93M] ------------------ 1582| 22.8k| case OP_ANYNL_EXTRA + OP_TYPEPOSPLUS: ------------------ | | 103| 22.8k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1582:7): [True: 5.03k, False: 8.92M] ------------------ 1583| 22.8k| count = current_state->count; /* Already matched */ 1584| 22.8k| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } ------------------ | | 484| 6.33k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 6.32k, False: 11] | | ------------------ | | 485| 6.33k| { \ | | 486| 6.32k| next_active_state->offset = (x); \ | | 487| 6.32k| next_active_state->count = (y); \ | | 488| 6.32k| next_active_state++; \ | | 489| 6.32k| } \ | | 490| 6.33k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 11|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (1584:11): [True: 6.33k, False: 16.5k] ------------------ 1585| 22.8k| if (clen > 0) ------------------ | Branch (1585:11): [True: 17.2k, False: 5.60k] ------------------ 1586| 17.2k| { 1587| 17.2k| int ncount = 0; 1588| 17.2k| switch (c) 1589| 17.2k| { 1590| 950| case CHAR_VT: ------------------ | | 970| 950|#define CHAR_VT '\013' ------------------ | Branch (1590:11): [True: 950, False: 16.3k] ------------------ 1591| 1.55k| case CHAR_FF: ------------------ | | 971| 1.55k|#define CHAR_FF '\014' ------------------ | Branch (1591:11): [True: 605, False: 16.6k] ------------------ 1592| 2.03k| case CHAR_NEL: ------------------ | | 975| 2.03k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (1592:11): [True: 480, False: 16.7k] ------------------ 1593| 2.03k|#ifndef EBCDIC 1594| 2.31k| case 0x2028: ------------------ | Branch (1594:11): [True: 275, False: 16.9k] ------------------ 1595| 2.59k| case 0x2029: ------------------ | Branch (1595:11): [True: 281, False: 16.9k] ------------------ 1596| 2.59k|#endif /* Not EBCDIC */ 1597| 2.59k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; ------------------ | | 217| 2.59k|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (1597:15): [True: 0, False: 2.59k] ------------------ 1598| 2.59k| goto ANYNL01; 1599| | 1600| 2.59k| case CHAR_CR: ------------------ | | 972| 2.40k|#define CHAR_CR '\015' ------------------ | Branch (1600:11): [True: 2.40k, False: 14.8k] ------------------ 1601| 2.40k| if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; ------------------ | | 244| 1.63k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; ------------------ | | 973| 1.63k|#define CHAR_LF '\012' ------------------ | Branch (1601:15): [True: 1.63k, False: 768] | Branch (1601:40): [True: 589, False: 1.04k] ------------------ 1602| | /* Fall through */ 1603| | 1604| 4.99k| ANYNL01: 1605| 6.60k| case CHAR_LF: ------------------ | | 973| 6.60k|#define CHAR_LF '\012' ------------------ | Branch (1605:11): [True: 1.61k, False: 15.6k] ------------------ 1606| 6.60k| if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS) ------------------ | | 103| 2.62k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1606:15): [True: 2.62k, False: 3.98k] | Branch (1606:28): [True: 422, False: 2.20k] ------------------ 1607| 422| { 1608| 422| active_count--; /* Remove non-match possibility */ 1609| 422| next_active_state--; 1610| 422| } 1611| 6.60k| count++; 1612| 6.60k| ADD_NEW_DATA(-state_offset, count, ncount); ------------------ | | 512| 6.60k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 6.59k, False: 10] | | ------------------ | | 513| 6.60k| { \ | | 514| 6.59k| next_new_state->offset = (x); \ | | 515| 6.59k| next_new_state->count = (y); \ | | 516| 6.59k| next_new_state->data = (z); \ | | 517| 6.59k| next_new_state++; \ | | 518| 6.59k| } \ | | 519| 6.60k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1613| 6.59k| break; 1614| | 1615| 10.6k| default: ------------------ | Branch (1615:11): [True: 10.6k, False: 6.60k] ------------------ 1616| 10.6k| break; 1617| 17.2k| } 1618| 17.2k| } 1619| 22.8k| break; 1620| | 1621| | /*-----------------------------------------------------------------*/ 1622| 22.8k| case OP_VSPACE_EXTRA + OP_TYPEPLUS: ------------------ | | 105| 22.0k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1622:7): [True: 22.0k, False: 8.91M] ------------------ 1623| 32.7k| case OP_VSPACE_EXTRA + OP_TYPEMINPLUS: ------------------ | | 105| 32.7k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1623:7): [True: 10.7k, False: 8.92M] ------------------ 1624| 41.7k| case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS: ------------------ | | 105| 41.7k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1624:7): [True: 9.03k, False: 8.92M] ------------------ 1625| 41.7k| count = current_state->count; /* Already matched */ 1626| 41.7k| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } ------------------ | | 484| 24.4k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 24.3k, False: 100] | | ------------------ | | 485| 24.4k| { \ | | 486| 24.3k| next_active_state->offset = (x); \ | | 487| 24.3k| next_active_state->count = (y); \ | | 488| 24.3k| next_active_state++; \ | | 489| 24.3k| } \ | | 490| 24.4k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 100|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (1626:11): [True: 24.4k, False: 17.2k] ------------------ 1627| 41.6k| if (clen > 0) ------------------ | Branch (1627:11): [True: 35.6k, False: 6.04k] ------------------ 1628| 35.6k| { 1629| 35.6k| BOOL OK; 1630| 35.6k| switch (c) 1631| 35.6k| { 1632| 6.71k| VSPACE_CASES: ------------------ | | 430| 6.05k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 1.35k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 1.35k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 1.35k, False: 34.2k] | | | | ------------------ | | | | 424| 2.49k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 2.49k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 1.14k, False: 34.4k] | | | | ------------------ | | | | 425| 4.23k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 4.23k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 1.74k, False: 33.8k] | | | | ------------------ | | | | 426| 5.23k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 5.23k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 999, False: 34.6k] | | | | ------------------ | | | | 427| 6.05k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 6.36k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 6.36k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 313, False: 35.3k] | | | | ------------------ | | | | 420| 6.71k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 1633| 6.71k| OK = TRUE; ------------------ | | 70| 6.71k|#define TRUE 1 ------------------ 1634| 6.71k| break; 1635| | 1636| 28.9k| default: ------------------ | Branch (1636:11): [True: 28.9k, False: 6.71k] ------------------ 1637| 28.9k| OK = FALSE; ------------------ | | 69| 28.9k|#define FALSE 0 ------------------ 1638| 28.9k| break; 1639| 35.6k| } 1640| | 1641| 35.6k| if (OK == (d == OP_VSPACE)) ------------------ | Branch (1641:13): [True: 25.1k, False: 10.4k] ------------------ 1642| 25.1k| { 1643| 25.1k| if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS) ------------------ | | 105| 17.8k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1643:15): [True: 17.8k, False: 7.33k] | Branch (1643:28): [True: 3.42k, False: 14.4k] ------------------ 1644| 3.42k| { 1645| 3.42k| active_count--; /* Remove non-match possibility */ 1646| 3.42k| next_active_state--; 1647| 3.42k| } 1648| 25.1k| count++; 1649| 25.1k| ADD_NEW_DATA(-state_offset, count, 0); ------------------ | | 512| 25.1k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 25.1k, False: 10] | | ------------------ | | 513| 25.1k| { \ | | 514| 25.1k| next_new_state->offset = (x); \ | | 515| 25.1k| next_new_state->count = (y); \ | | 516| 25.1k| next_new_state->data = (z); \ | | 517| 25.1k| next_new_state++; \ | | 518| 25.1k| } \ | | 519| 25.1k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1650| 25.1k| } 1651| 35.6k| } 1652| 41.6k| break; 1653| | 1654| | /*-----------------------------------------------------------------*/ 1655| 66.9k| case OP_HSPACE_EXTRA + OP_TYPEPLUS: ------------------ | | 104| 66.9k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1655:7): [True: 66.9k, False: 8.86M] ------------------ 1656| 85.4k| case OP_HSPACE_EXTRA + OP_TYPEMINPLUS: ------------------ | | 104| 85.4k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1656:7): [True: 18.5k, False: 8.91M] ------------------ 1657| 99.4k| case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS: ------------------ | | 104| 99.4k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1657:7): [True: 13.9k, False: 8.91M] ------------------ 1658| 99.4k| count = current_state->count; /* Already matched */ 1659| 99.4k| if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); } ------------------ | | 484| 67.9k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 67.7k, False: 128] | | ------------------ | | 485| 67.9k| { \ | | 486| 67.7k| next_active_state->offset = (x); \ | | 487| 67.7k| next_active_state->count = (y); \ | | 488| 67.7k| next_active_state++; \ | | 489| 67.7k| } \ | | 490| 67.9k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 128|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (1659:11): [True: 67.9k, False: 31.5k] ------------------ 1660| 99.3k| if (clen > 0) ------------------ | Branch (1660:11): [True: 87.5k, False: 11.7k] ------------------ 1661| 87.5k| { 1662| 87.5k| BOOL OK; 1663| 87.5k| switch (c) 1664| 87.5k| { 1665| 10.6k| HSPACE_CASES: ------------------ | | 412| 4.60k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 1.20k| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 1.20k|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 1.20k, False: 86.3k] | | | | ------------------ | | | | 408| 2.89k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 2.89k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 1.68k, False: 85.8k] | | | | ------------------ | | | | 409| 4.60k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 5.01k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 5.01k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 408, False: 87.1k] | | | | ------------------ | | | | 390| 5.35k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 342, False: 87.2k] | | | | ------------------ | | | | 391| 5.77k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 422, False: 87.1k] | | | | ------------------ | | | | 392| 6.13k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 360, False: 87.2k] | | | | ------------------ | | | | 393| 6.48k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 351, False: 87.2k] | | | | ------------------ | | | | 394| 6.84k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 355, False: 87.2k] | | | | ------------------ | | | | 395| 7.16k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 326, False: 87.2k] | | | | ------------------ | | | | 396| 7.52k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 354, False: 87.2k] | | | | ------------------ | | | | 397| 7.84k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 326, False: 87.2k] | | | | ------------------ | | | | 398| 8.19k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 349, False: 87.2k] | | | | ------------------ | | | | 399| 8.60k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 413, False: 87.1k] | | | | ------------------ | | | | 400| 9.04k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 441, False: 87.1k] | | | | ------------------ | | | | 401| 9.42k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 372, False: 87.1k] | | | | ------------------ | | | | 402| 9.84k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 421, False: 87.1k] | | | | ------------------ | | | | 403| 10.2k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 379, False: 87.1k] | | | | ------------------ | | | | 404| 10.6k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 1666| 10.6k| OK = TRUE; ------------------ | | 70| 10.6k|#define TRUE 1 ------------------ 1667| 10.6k| break; 1668| | 1669| 76.9k| default: ------------------ | Branch (1669:11): [True: 76.9k, False: 10.6k] ------------------ 1670| 76.9k| OK = FALSE; ------------------ | | 69| 76.9k|#define FALSE 0 ------------------ 1671| 76.9k| break; 1672| 87.5k| } 1673| | 1674| 87.5k| if (OK == (d == OP_HSPACE)) ------------------ | Branch (1674:13): [True: 69.3k, False: 18.2k] ------------------ 1675| 69.3k| { 1676| 69.3k| if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS) ------------------ | | 104| 55.3k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1676:15): [True: 55.3k, False: 13.9k] | Branch (1676:28): [True: 5.35k, False: 49.9k] ------------------ 1677| 5.35k| { 1678| 5.35k| active_count--; /* Remove non-match possibility */ 1679| 5.35k| next_active_state--; 1680| 5.35k| } 1681| 69.3k| count++; 1682| 69.3k| ADD_NEW_DATA(-state_offset, count, 0); ------------------ | | 512| 69.3k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 69.3k, False: 10] | | ------------------ | | 513| 69.3k| { \ | | 514| 69.3k| next_new_state->offset = (x); \ | | 515| 69.3k| next_new_state->count = (y); \ | | 516| 69.3k| next_new_state->data = (z); \ | | 517| 69.3k| next_new_state++; \ | | 518| 69.3k| } \ | | 519| 69.3k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1683| 69.3k| } 1684| 87.5k| } 1685| 99.3k| break; 1686| | 1687| | /*-----------------------------------------------------------------*/ 1688| 99.3k|#ifdef SUPPORT_UNICODE 1689| 99.3k| case OP_PROP_EXTRA + OP_TYPEQUERY: ------------------ | | 101| 21.4k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1689:7): [True: 21.4k, False: 8.91M] ------------------ 1690| 40.8k| case OP_PROP_EXTRA + OP_TYPEMINQUERY: ------------------ | | 101| 40.8k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1690:7): [True: 19.4k, False: 8.91M] ------------------ 1691| 46.0k| case OP_PROP_EXTRA + OP_TYPEPOSQUERY: ------------------ | | 101| 46.0k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1691:7): [True: 5.15k, False: 8.92M] ------------------ 1692| 46.0k| count = 4; 1693| 46.0k| goto QS1; 1694| | 1695| 85.4k| case OP_PROP_EXTRA + OP_TYPESTAR: ------------------ | | 101| 85.4k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1695:7): [True: 85.4k, False: 8.84M] ------------------ 1696| 149k| case OP_PROP_EXTRA + OP_TYPEMINSTAR: ------------------ | | 101| 149k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1696:7): [True: 64.0k, False: 8.86M] ------------------ 1697| 158k| case OP_PROP_EXTRA + OP_TYPEPOSSTAR: ------------------ | | 101| 158k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1697:7): [True: 8.92k, False: 8.92M] ------------------ 1698| 158k| count = 0; 1699| | 1700| 204k| QS1: 1701| | 1702| 204k| ADD_ACTIVE(state_offset + 4, 0); ------------------ | | 484| 204k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 204k, False: 202] | | ------------------ | | 485| 204k| { \ | | 486| 204k| next_active_state->offset = (x); \ | | 487| 204k| next_active_state->count = (y); \ | | 488| 204k| next_active_state++; \ | | 489| 204k| } \ | | 490| 204k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 202|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1703| 204k| if (clen > 0) ------------------ | Branch (1703:11): [True: 188k, False: 16.1k] ------------------ 1704| 188k| { 1705| 188k| BOOL OK; 1706| 188k| const uint32_t *cp; 1707| 188k| const ucd_record * prop = GET_UCD(c); ------------------ | | 1846| 188k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 188k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 188k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 188k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 188k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 188k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 188k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 188k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 188k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 188k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 1708| 188k| switch(code[2]) 1709| 188k| { 1710| 12.4k| case PT_ANY: ------------------ | | 1275| 12.4k|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (1710:11): [True: 12.4k, False: 175k] ------------------ 1711| 12.4k| OK = TRUE; ------------------ | | 70| 12.4k|#define TRUE 1 ------------------ 1712| 12.4k| break; 1713| | 1714| 6.09k| case PT_LAMP: ------------------ | | 1276| 6.09k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (1714:11): [True: 6.09k, False: 182k] ------------------ 1715| 6.09k| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || ------------------ | Branch (1715:16): [True: 989, False: 5.10k] | Branch (1715:44): [True: 651, False: 4.45k] ------------------ 1716| 6.09k| prop->chartype == ucp_Lt; ------------------ | Branch (1716:13): [True: 0, False: 4.45k] ------------------ 1717| 6.09k| break; 1718| | 1719| 10.8k| case PT_GC: ------------------ | | 1277| 10.8k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (1719:11): [True: 10.8k, False: 177k] ------------------ 1720| 10.8k| OK = PRIV(ucp_gentype)[prop->chartype] == code[3]; ------------------ | | 177| 10.8k|#define PRIV(name) _pcre2_##name ------------------ 1721| 10.8k| break; 1722| | 1723| 18.1k| case PT_PC: ------------------ | | 1278| 18.1k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (1723:11): [True: 18.1k, False: 169k] ------------------ 1724| 18.1k| OK = prop->chartype == code[3]; 1725| 18.1k| break; 1726| | 1727| 6.01k| case PT_SC: ------------------ | | 1279| 6.01k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (1727:11): [True: 6.01k, False: 182k] ------------------ 1728| 6.01k| OK = prop->script == code[3]; 1729| 6.01k| break; 1730| | 1731| 10.3k| case PT_SCX: ------------------ | | 1280| 10.3k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (1731:11): [True: 10.3k, False: 177k] ------------------ 1732| 10.3k| OK = (prop->script == code[3] || ------------------ | Branch (1732:17): [True: 405, False: 9.91k] ------------------ 1733| 10.3k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), code[3]) != 0); ------------------ | | 1871| 9.91k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (1733:17): [True: 0, False: 9.91k] ------------------ 1734| 10.3k| break; 1735| | 1736| | /* These are specials for combination cases. */ 1737| | 1738| 9.90k| case PT_ALNUM: ------------------ | | 1281| 9.90k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (1738:11): [True: 9.90k, False: 178k] ------------------ 1739| 9.90k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 9.90k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1739:16): [True: 3.61k, False: 6.28k] ------------------ 1740| 9.90k| PRIV(ucp_gentype)[prop->chartype] == ucp_N; ------------------ | | 177| 6.28k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1740:16): [True: 293, False: 5.99k] ------------------ 1741| 9.90k| break; 1742| | 1743| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 1744| | which means that Perl space and POSIX space are now identical. PCRE 1745| | was changed at release 8.34. */ 1746| | 1747| 63.2k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 63.2k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (1747:11): [True: 63.2k, False: 124k] ------------------ 1748| 64.2k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 64.2k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (1748:11): [True: 964, False: 187k] ------------------ 1749| 64.2k| switch(c) 1750| 64.2k| { 1751| 83.7k| HSPACE_CASES: ------------------ | | 412| 1.65k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 410| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 410|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 410, False: 63.8k] | | | | ------------------ | | | | 408| 1.26k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.26k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 858, False: 63.3k] | | | | ------------------ | | | | 409| 1.65k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 2.17k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 2.17k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 518, False: 63.7k] | | | | ------------------ | | | | 390| 2.46k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 289, False: 63.9k] | | | | ------------------ | | | | 391| 2.89k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 428, False: 63.8k] | | | | ------------------ | | | | 392| 3.24k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 351, False: 63.8k] | | | | ------------------ | | | | 393| 3.60k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 360, False: 63.8k] | | | | ------------------ | | | | 394| 4.00k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 395, False: 63.8k] | | | | ------------------ | | | | 395| 4.38k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 380, False: 63.8k] | | | | ------------------ | | | | 396| 4.83k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 454, False: 63.7k] | | | | ------------------ | | | | 397| 5.17k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 336, False: 63.9k] | | | | ------------------ | | | | 398| 5.61k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 441, False: 63.7k] | | | | ------------------ | | | | 399| 6.04k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 433, False: 63.8k] | | | | ------------------ | | | | 400| 6.44k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 399, False: 63.8k] | | | | ------------------ | | | | 401| 6.83k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 393, False: 63.8k] | | | | ------------------ | | | | 402| 7.22k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 387, False: 63.8k] | | | | ------------------ | | | | 403| 7.51k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 292, False: 63.9k] | | | | ------------------ | | | | 404| 7.94k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 1752| 83.7k| VSPACE_CASES: ------------------ | | 430| 10.4k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 8.46k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 8.46k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 523, False: 63.7k] | | | | ------------------ | | | | 424| 8.97k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 8.97k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 515, False: 63.7k] | | | | ------------------ | | | | 425| 9.43k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 9.43k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 455, False: 63.7k] | | | | ------------------ | | | | 426| 10.0k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 10.0k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 574, False: 63.6k] | | | | ------------------ | | | | 427| 10.4k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 7.94k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 10.8k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 10.8k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 391, False: 63.8k] | | | | ------------------ | | | | 420| 11.1k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 1753| 11.1k| OK = TRUE; ------------------ | | 70| 11.1k|#define TRUE 1 ------------------ 1754| 11.1k| break; 1755| | 1756| 53.0k| default: ------------------ | Branch (1756:13): [True: 53.0k, False: 11.1k] ------------------ 1757| 53.0k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; ------------------ | | 177| 53.0k|#define PRIV(name) _pcre2_##name ------------------ 1758| 53.0k| break; 1759| 64.2k| } 1760| 64.2k| break; 1761| | 1762| 64.2k| case PT_WORD: ------------------ | | 1284| 10.3k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (1762:11): [True: 10.3k, False: 177k] ------------------ 1763| 10.3k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 10.3k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1763:16): [True: 1.55k, False: 8.79k] ------------------ 1764| 10.3k| PRIV(ucp_gentype)[prop->chartype] == ucp_N || ------------------ | | 177| 8.79k|#define PRIV(name) _pcre2_##name ------------------ | Branch (1764:16): [True: 457, False: 8.33k] ------------------ 1765| 10.3k| c == CHAR_UNDERSCORE; ------------------ | | 1045| 18.6k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (1765:16): [True: 0, False: 8.33k] ------------------ 1766| 10.3k| break; 1767| | 1768| 6.65k| case PT_CLIST: ------------------ | | 1285| 6.65k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (1768:11): [True: 6.65k, False: 181k] ------------------ 1769| 6.65k| cp = PRIV(ucd_caseless_sets) + code[3]; ------------------ | | 177| 6.65k|#define PRIV(name) _pcre2_##name ------------------ 1770| 6.65k| for (;;) 1771| 10.3k| { 1772| 10.3k| if (c < *cp) { OK = FALSE; break; } ------------------ | | 69| 5.01k|#define FALSE 0 ------------------ | Branch (1772:17): [True: 5.01k, False: 5.37k] ------------------ 1773| 5.37k| if (c == *cp++) { OK = TRUE; break; } ------------------ | | 70| 1.63k|#define TRUE 1 ------------------ | Branch (1773:17): [True: 1.63k, False: 3.73k] ------------------ 1774| 5.37k| } 1775| 6.65k| break; 1776| | 1777| 13.5k| case PT_UCNC: ------------------ | | 1286| 13.5k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (1777:11): [True: 13.5k, False: 174k] ------------------ 1778| 13.5k| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 986| 27.1k|#define CHAR_DOLLAR_SIGN '\044' ------------------ OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 26.7k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (1778:16): [True: 409, False: 13.1k] | Branch (1778:41): [True: 340, False: 12.8k] ------------------ 1779| 13.5k| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || ------------------ | | 1046| 26.4k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (1779:16): [True: 280, False: 12.5k] | Branch (1779:43): [True: 922, False: 11.6k] | Branch (1779:56): [True: 685, False: 237] ------------------ 1780| 13.5k| c >= 0xe000; ------------------ | Branch (1780:16): [True: 237, False: 11.6k] ------------------ 1781| 13.5k| break; 1782| | 1783| 6.44k| case PT_BIDICL: ------------------ | | 1287| 6.44k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (1783:11): [True: 6.44k, False: 181k] ------------------ 1784| 6.44k| OK = UCD_BIDICLASS(c) == code[3]; ------------------ | | 1865| 6.44k|#define UCD_BIDICLASS(ch) UCD_BIDICLASS_PROP(GET_UCD(ch)) | | ------------------ | | | | 1854| 6.44k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | | | ------------------ | | | | | | 1850| 6.44k|#define UCD_BIDICLASS_SHIFT 11 | | | | ------------------ | | ------------------ ------------------ 1785| 6.44k| break; 1786| | 1787| 12.9k| case PT_BOOL: ------------------ | | 1288| 12.9k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (1787:11): [True: 12.9k, False: 175k] ------------------ 1788| 12.9k| OK = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 12.9k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 1789| 12.9k| UCD_BPROPS_PROP(prop), code[3]) != 0; 1790| 12.9k| break; 1791| | 1792| | /* Should never occur, but keep compilers from grumbling. */ 1793| | 1794| 0| default: ------------------ | Branch (1794:11): [True: 0, False: 188k] ------------------ 1795| 0| OK = codevalue != OP_PROP; 1796| 0| break; 1797| 188k| } 1798| | 1799| 188k| if (OK == (d == OP_PROP)) ------------------ | Branch (1799:13): [True: 133k, False: 54.9k] ------------------ 1800| 133k| { 1801| 133k| if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSSTAR || ------------------ | | 101| 133k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1801:15): [True: 5.42k, False: 127k] ------------------ 1802| 133k| codevalue == OP_PROP_EXTRA + OP_TYPEPOSQUERY) ------------------ | | 101| 127k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1802:15): [True: 2.34k, False: 125k] ------------------ 1803| 7.76k| { 1804| 7.76k| active_count--; /* Remove non-match possibility */ 1805| 7.76k| next_active_state--; 1806| 7.76k| } 1807| 133k| ADD_NEW(state_offset + count, 0); ------------------ | | 503| 133k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 133k, False: 11] | | ------------------ | | 504| 133k| { \ | | 505| 133k| next_new_state->offset = (x); \ | | 506| 133k| next_new_state->count = (y); \ | | 507| 133k| next_new_state++; \ | | 508| 133k| } \ | | 509| 133k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 11|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1808| 133k| } 1809| 188k| } 1810| 204k| break; 1811| | 1812| | /*-----------------------------------------------------------------*/ 1813| 204k| case OP_EXTUNI_EXTRA + OP_TYPEQUERY: ------------------ | | 102| 930|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1813:7): [True: 930, False: 8.93M] ------------------ 1814| 1.77k| case OP_EXTUNI_EXTRA + OP_TYPEMINQUERY: ------------------ | | 102| 1.77k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1814:7): [True: 843, False: 8.93M] ------------------ 1815| 2.27k| case OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY: ------------------ | | 102| 2.27k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1815:7): [True: 497, False: 8.93M] ------------------ 1816| 2.27k| count = 2; 1817| 2.27k| goto QS2; 1818| | 1819| 21.0k| case OP_EXTUNI_EXTRA + OP_TYPESTAR: ------------------ | | 102| 21.0k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1819:7): [True: 21.0k, False: 8.91M] ------------------ 1820| 27.1k| case OP_EXTUNI_EXTRA + OP_TYPEMINSTAR: ------------------ | | 102| 27.1k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1820:7): [True: 6.15k, False: 8.92M] ------------------ 1821| 28.0k| case OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR: ------------------ | | 102| 28.0k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1821:7): [True: 840, False: 8.93M] ------------------ 1822| 28.0k| count = 0; 1823| | 1824| 30.3k| QS2: 1825| | 1826| 30.3k| ADD_ACTIVE(state_offset + 2, 0); ------------------ | | 484| 30.3k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 30.2k, False: 46] | | ------------------ | | 485| 30.3k| { \ | | 486| 30.2k| next_active_state->offset = (x); \ | | 487| 30.2k| next_active_state->count = (y); \ | | 488| 30.2k| next_active_state++; \ | | 489| 30.2k| } \ | | 490| 30.3k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 46|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1827| 30.2k| if (clen > 0) ------------------ | Branch (1827:11): [True: 26.5k, False: 3.70k] ------------------ 1828| 26.5k| { 1829| 26.5k| int ncount = 0; 1830| 26.5k| if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR || ------------------ | | 102| 26.5k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1830:13): [True: 699, False: 25.8k] ------------------ 1831| 26.5k| codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY) ------------------ | | 102| 25.8k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (1831:13): [True: 435, False: 25.4k] ------------------ 1832| 1.13k| { 1833| 1.13k| active_count--; /* Remove non-match possibility */ 1834| 1.13k| next_active_state--; 1835| 1.13k| } 1836| 26.5k| (void)PRIV(extuni)(c, ptr + clen, mb->start_subject, end_subject, utf, ------------------ | | 177| 26.5k|#define PRIV(name) _pcre2_##name ------------------ 1837| 26.5k| &ncount); 1838| 26.5k| ADD_NEW_DATA(-(state_offset + count), 0, ncount); ------------------ | | 512| 26.5k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 26.5k, False: 10] | | ------------------ | | 513| 26.5k| { \ | | 514| 26.5k| next_new_state->offset = (x); \ | | 515| 26.5k| next_new_state->count = (y); \ | | 516| 26.5k| next_new_state->data = (z); \ | | 517| 26.5k| next_new_state++; \ | | 518| 26.5k| } \ | | 519| 26.5k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1839| 26.5k| } 1840| 30.2k| break; 1841| 30.2k|#endif 1842| | 1843| | /*-----------------------------------------------------------------*/ 1844| 30.2k| case OP_ANYNL_EXTRA + OP_TYPEQUERY: ------------------ | | 103| 5.21k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1844:7): [True: 5.21k, False: 8.92M] ------------------ 1845| 7.09k| case OP_ANYNL_EXTRA + OP_TYPEMINQUERY: ------------------ | | 103| 7.09k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1845:7): [True: 1.88k, False: 8.93M] ------------------ 1846| 11.0k| case OP_ANYNL_EXTRA + OP_TYPEPOSQUERY: ------------------ | | 103| 11.0k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1846:7): [True: 3.96k, False: 8.92M] ------------------ 1847| 11.0k| count = 2; 1848| 11.0k| goto QS3; 1849| | 1850| 8.74k| case OP_ANYNL_EXTRA + OP_TYPESTAR: ------------------ | | 103| 8.74k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1850:7): [True: 8.74k, False: 8.92M] ------------------ 1851| 14.6k| case OP_ANYNL_EXTRA + OP_TYPEMINSTAR: ------------------ | | 103| 14.6k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1851:7): [True: 5.86k, False: 8.92M] ------------------ 1852| 17.7k| case OP_ANYNL_EXTRA + OP_TYPEPOSSTAR: ------------------ | | 103| 17.7k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1852:7): [True: 3.17k, False: 8.93M] ------------------ 1853| 17.7k| count = 0; 1854| | 1855| 28.8k| QS3: 1856| 28.8k| ADD_ACTIVE(state_offset + 2, 0); ------------------ | | 484| 28.8k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 28.7k, False: 52] | | ------------------ | | 485| 28.8k| { \ | | 486| 28.7k| next_active_state->offset = (x); \ | | 487| 28.7k| next_active_state->count = (y); \ | | 488| 28.7k| next_active_state++; \ | | 489| 28.7k| } \ | | 490| 28.8k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 52|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1857| 28.7k| if (clen > 0) ------------------ | Branch (1857:11): [True: 24.8k, False: 3.89k] ------------------ 1858| 24.8k| { 1859| 24.8k| int ncount = 0; 1860| 24.8k| switch (c) 1861| 24.8k| { 1862| 1.33k| case CHAR_VT: ------------------ | | 970| 1.33k|#define CHAR_VT '\013' ------------------ | Branch (1862:11): [True: 1.33k, False: 23.5k] ------------------ 1863| 2.13k| case CHAR_FF: ------------------ | | 971| 2.13k|#define CHAR_FF '\014' ------------------ | Branch (1863:11): [True: 793, False: 24.0k] ------------------ 1864| 2.70k| case CHAR_NEL: ------------------ | | 975| 2.70k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (1864:11): [True: 577, False: 24.3k] ------------------ 1865| 2.70k|#ifndef EBCDIC 1866| 3.01k| case 0x2028: ------------------ | Branch (1866:11): [True: 307, False: 24.5k] ------------------ 1867| 3.34k| case 0x2029: ------------------ | Branch (1867:11): [True: 330, False: 24.5k] ------------------ 1868| 3.34k|#endif /* Not EBCDIC */ 1869| 3.34k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; ------------------ | | 217| 3.34k|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (1869:15): [True: 0, False: 3.34k] ------------------ 1870| 3.34k| goto ANYNL02; 1871| | 1872| 3.34k| case CHAR_CR: ------------------ | | 972| 2.22k|#define CHAR_CR '\015' ------------------ | Branch (1872:11): [True: 2.22k, False: 22.6k] ------------------ 1873| 2.22k| if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; ------------------ | | 244| 1.63k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; ------------------ | | 973| 1.63k|#define CHAR_LF '\012' ------------------ | Branch (1873:15): [True: 1.63k, False: 595] | Branch (1873:40): [True: 536, False: 1.09k] ------------------ 1874| | /* Fall through */ 1875| | 1876| 5.57k| ANYNL02: 1877| 6.93k| case CHAR_LF: ------------------ | | 973| 6.93k|#define CHAR_LF '\012' ------------------ | Branch (1877:11): [True: 1.36k, False: 23.5k] ------------------ 1878| 6.93k| if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR || ------------------ | | 103| 6.93k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1878:15): [True: 659, False: 6.27k] ------------------ 1879| 6.93k| codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY) ------------------ | | 103| 6.27k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (1879:15): [True: 615, False: 5.65k] ------------------ 1880| 1.27k| { 1881| 1.27k| active_count--; /* Remove non-match possibility */ 1882| 1.27k| next_active_state--; 1883| 1.27k| } 1884| 6.93k| ADD_NEW_DATA(-(state_offset + (int)count), 0, ncount); ------------------ | | 512| 6.93k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 6.92k, False: 10] | | ------------------ | | 513| 6.93k| { \ | | 514| 6.92k| next_new_state->offset = (x); \ | | 515| 6.92k| next_new_state->count = (y); \ | | 516| 6.92k| next_new_state->data = (z); \ | | 517| 6.92k| next_new_state++; \ | | 518| 6.92k| } \ | | 519| 6.93k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1885| 6.92k| break; 1886| | 1887| 17.9k| default: ------------------ | Branch (1887:11): [True: 17.9k, False: 6.93k] ------------------ 1888| 17.9k| break; 1889| 24.8k| } 1890| 24.8k| } 1891| 28.7k| break; 1892| | 1893| | /*-----------------------------------------------------------------*/ 1894| 28.7k| case OP_VSPACE_EXTRA + OP_TYPEQUERY: ------------------ | | 105| 2.46k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1894:7): [True: 2.46k, False: 8.93M] ------------------ 1895| 5.45k| case OP_VSPACE_EXTRA + OP_TYPEMINQUERY: ------------------ | | 105| 5.45k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1895:7): [True: 2.99k, False: 8.93M] ------------------ 1896| 9.59k| case OP_VSPACE_EXTRA + OP_TYPEPOSQUERY: ------------------ | | 105| 9.59k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1896:7): [True: 4.14k, False: 8.92M] ------------------ 1897| 9.59k| count = 2; 1898| 9.59k| goto QS4; 1899| | 1900| 33.2k| case OP_VSPACE_EXTRA + OP_TYPESTAR: ------------------ | | 105| 33.2k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1900:7): [True: 33.2k, False: 8.90M] ------------------ 1901| 47.0k| case OP_VSPACE_EXTRA + OP_TYPEMINSTAR: ------------------ | | 105| 47.0k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1901:7): [True: 13.7k, False: 8.91M] ------------------ 1902| 53.1k| case OP_VSPACE_EXTRA + OP_TYPEPOSSTAR: ------------------ | | 105| 53.1k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1902:7): [True: 6.08k, False: 8.92M] ------------------ 1903| 53.1k| count = 0; 1904| | 1905| 62.7k| QS4: 1906| 62.7k| ADD_ACTIVE(state_offset + 2, 0); ------------------ | | 484| 62.7k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 62.6k, False: 72] | | ------------------ | | 485| 62.7k| { \ | | 486| 62.6k| next_active_state->offset = (x); \ | | 487| 62.6k| next_active_state->count = (y); \ | | 488| 62.6k| next_active_state++; \ | | 489| 62.6k| } \ | | 490| 62.7k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 72|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1907| 62.6k| if (clen > 0) ------------------ | Branch (1907:11): [True: 56.4k, False: 6.22k] ------------------ 1908| 56.4k| { 1909| 56.4k| BOOL OK; 1910| 56.4k| switch (c) 1911| 56.4k| { 1912| 7.57k| VSPACE_CASES: ------------------ | | 430| 6.33k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 858| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 858|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 858, False: 55.5k] | | | | ------------------ | | | | 424| 2.05k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 2.05k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 1.20k, False: 55.2k] | | | | ------------------ | | | | 425| 3.64k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 3.64k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 1.58k, False: 54.8k] | | | | ------------------ | | | | 426| 5.40k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 5.40k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 1.75k, False: 54.6k] | | | | ------------------ | | | | 427| 6.33k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 6.95k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 6.95k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 617, False: 55.7k] | | | | ------------------ | | | | 420| 7.57k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 1913| 7.57k| OK = TRUE; ------------------ | | 70| 7.57k|#define TRUE 1 ------------------ 1914| 7.57k| break; 1915| | 1916| 48.8k| default: ------------------ | Branch (1916:11): [True: 48.8k, False: 7.57k] ------------------ 1917| 48.8k| OK = FALSE; ------------------ | | 69| 48.8k|#define FALSE 0 ------------------ 1918| 48.8k| break; 1919| 56.4k| } 1920| 56.4k| if (OK == (d == OP_VSPACE)) ------------------ | Branch (1920:13): [True: 42.6k, False: 13.7k] ------------------ 1921| 42.6k| { 1922| 42.6k| if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR || ------------------ | | 105| 42.6k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1922:15): [True: 4.53k, False: 38.1k] ------------------ 1923| 42.6k| codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY) ------------------ | | 105| 38.1k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (1923:15): [True: 837, False: 37.3k] ------------------ 1924| 5.37k| { 1925| 5.37k| active_count--; /* Remove non-match possibility */ 1926| 5.37k| next_active_state--; 1927| 5.37k| } 1928| 42.6k| ADD_NEW_DATA(-(state_offset + (int)count), 0, 0); ------------------ | | 512| 42.6k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 42.6k, False: 10] | | ------------------ | | 513| 42.6k| { \ | | 514| 42.6k| next_new_state->offset = (x); \ | | 515| 42.6k| next_new_state->count = (y); \ | | 516| 42.6k| next_new_state->data = (z); \ | | 517| 42.6k| next_new_state++; \ | | 518| 42.6k| } \ | | 519| 42.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1929| 42.6k| } 1930| 56.4k| } 1931| 62.6k| break; 1932| | 1933| | /*-----------------------------------------------------------------*/ 1934| 62.6k| case OP_HSPACE_EXTRA + OP_TYPEQUERY: ------------------ | | 104| 5.48k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1934:7): [True: 5.48k, False: 8.92M] ------------------ 1935| 10.1k| case OP_HSPACE_EXTRA + OP_TYPEMINQUERY: ------------------ | | 104| 10.1k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1935:7): [True: 4.66k, False: 8.92M] ------------------ 1936| 11.9k| case OP_HSPACE_EXTRA + OP_TYPEPOSQUERY: ------------------ | | 104| 11.9k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1936:7): [True: 1.81k, False: 8.93M] ------------------ 1937| 11.9k| count = 2; 1938| 11.9k| goto QS5; 1939| | 1940| 71.6k| case OP_HSPACE_EXTRA + OP_TYPESTAR: ------------------ | | 104| 71.6k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1940:7): [True: 71.6k, False: 8.86M] ------------------ 1941| 95.7k| case OP_HSPACE_EXTRA + OP_TYPEMINSTAR: ------------------ | | 104| 95.7k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1941:7): [True: 24.0k, False: 8.90M] ------------------ 1942| 107k| case OP_HSPACE_EXTRA + OP_TYPEPOSSTAR: ------------------ | | 104| 107k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1942:7): [True: 11.4k, False: 8.92M] ------------------ 1943| 107k| count = 0; 1944| | 1945| 119k| QS5: 1946| 119k| ADD_ACTIVE(state_offset + 2, 0); ------------------ | | 484| 119k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 119k, False: 72] | | ------------------ | | 485| 119k| { \ | | 486| 119k| next_active_state->offset = (x); \ | | 487| 119k| next_active_state->count = (y); \ | | 488| 119k| next_active_state++; \ | | 489| 119k| } \ | | 490| 119k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 72|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1947| 119k| if (clen > 0) ------------------ | Branch (1947:11): [True: 105k, False: 13.0k] ------------------ 1948| 105k| { 1949| 105k| BOOL OK; 1950| 105k| switch (c) 1951| 105k| { 1952| 12.8k| HSPACE_CASES: ------------------ | | 412| 4.40k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 1.74k| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 1.74k|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 1.74k, False: 104k] | | | | ------------------ | | | | 408| 3.39k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 3.39k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 1.65k, False: 104k] | | | | ------------------ | | | | 409| 4.40k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 4.88k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 4.88k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 483, False: 105k] | | | | ------------------ | | | | 390| 5.41k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 533, False: 105k] | | | | ------------------ | | | | 391| 5.83k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 420, False: 105k] | | | | ------------------ | | | | 392| 6.35k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 514, False: 105k] | | | | ------------------ | | | | 393| 6.81k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 465, False: 105k] | | | | ------------------ | | | | 394| 7.34k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 526, False: 105k] | | | | ------------------ | | | | 395| 7.97k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 633, False: 105k] | | | | ------------------ | | | | 396| 8.51k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 536, False: 105k] | | | | ------------------ | | | | 397| 9.19k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 686, False: 105k] | | | | ------------------ | | | | 398| 9.69k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 499, False: 105k] | | | | ------------------ | | | | 399| 10.2k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 520, False: 105k] | | | | ------------------ | | | | 400| 10.7k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 570, False: 105k] | | | | ------------------ | | | | 401| 11.2k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 492, False: 105k] | | | | ------------------ | | | | 402| 11.7k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 470, False: 105k] | | | | ------------------ | | | | 403| 12.3k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 571, False: 105k] | | | | ------------------ | | | | 404| 12.8k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 1953| 12.8k| OK = TRUE; ------------------ | | 70| 12.8k|#define TRUE 1 ------------------ 1954| 12.8k| break; 1955| | 1956| 93.1k| default: ------------------ | Branch (1956:11): [True: 93.1k, False: 12.8k] ------------------ 1957| 93.1k| OK = FALSE; ------------------ | | 69| 93.1k|#define FALSE 0 ------------------ 1958| 93.1k| break; 1959| 105k| } 1960| | 1961| 105k| if (OK == (d == OP_HSPACE)) ------------------ | Branch (1961:13): [True: 79.8k, False: 26.1k] ------------------ 1962| 79.8k| { 1963| 79.8k| if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSSTAR || ------------------ | | 104| 79.8k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1963:15): [True: 7.66k, False: 72.1k] ------------------ 1964| 79.8k| codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSQUERY) ------------------ | | 104| 72.1k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (1964:15): [True: 702, False: 71.4k] ------------------ 1965| 8.36k| { 1966| 8.36k| active_count--; /* Remove non-match possibility */ 1967| 8.36k| next_active_state--; 1968| 8.36k| } 1969| 79.8k| ADD_NEW_DATA(-(state_offset + (int)count), 0, 0); ------------------ | | 512| 79.8k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 79.8k, False: 10] | | ------------------ | | 513| 79.8k| { \ | | 514| 79.8k| next_new_state->offset = (x); \ | | 515| 79.8k| next_new_state->count = (y); \ | | 516| 79.8k| next_new_state->data = (z); \ | | 517| 79.8k| next_new_state++; \ | | 518| 79.8k| } \ | | 519| 79.8k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1970| 79.8k| } 1971| 105k| } 1972| 119k| break; 1973| | 1974| | /*-----------------------------------------------------------------*/ 1975| 119k|#ifdef SUPPORT_UNICODE 1976| 119k| case OP_PROP_EXTRA + OP_TYPEEXACT: ------------------ | | 101| 110k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1976:7): [True: 110k, False: 8.82M] ------------------ 1977| 110k| case OP_PROP_EXTRA + OP_TYPEUPTO: ------------------ | | 101| 110k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1977:7): [True: 733, False: 8.93M] ------------------ 1978| 111k| case OP_PROP_EXTRA + OP_TYPEMINUPTO: ------------------ | | 101| 111k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1978:7): [True: 658, False: 8.93M] ------------------ 1979| 112k| case OP_PROP_EXTRA + OP_TYPEPOSUPTO: ------------------ | | 101| 112k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1979:7): [True: 1.05k, False: 8.93M] ------------------ 1980| 112k| if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT) ------------------ | | 101| 112k|#define OP_PROP_EXTRA 300 ------------------ | Branch (1980:11): [True: 2.44k, False: 110k] ------------------ 1981| 2.44k| { ADD_ACTIVE(state_offset + 1 + IMM2_SIZE + 3, 0); } ------------------ | | 484| 2.44k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 2.43k, False: 12] | | ------------------ | | 485| 2.44k| { \ | | 486| 2.43k| next_active_state->offset = (x); \ | | 487| 2.43k| next_active_state->count = (y); \ | | 488| 2.43k| next_active_state++; \ | | 489| 2.43k| } \ | | 490| 2.44k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 12|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 1982| 112k| count = current_state->count; /* Number already matched */ 1983| 112k| if (clen > 0) ------------------ | Branch (1983:11): [True: 104k, False: 7.94k] ------------------ 1984| 104k| { 1985| 104k| BOOL OK; 1986| 104k| const uint32_t *cp; 1987| 104k| const ucd_record * prop = GET_UCD(c); ------------------ | | 1846| 104k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 104k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 104k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 104k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 104k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 104k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 104k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 104k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 104k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 104k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 1988| 104k| switch(code[1 + IMM2_SIZE + 1]) ------------------ | | 193| 104k|#define IMM2_SIZE 2 ------------------ 1989| 104k| { 1990| 201| case PT_ANY: ------------------ | | 1275| 201|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (1990:11): [True: 201, False: 104k] ------------------ 1991| 201| OK = TRUE; ------------------ | | 70| 201|#define TRUE 1 ------------------ 1992| 201| break; 1993| | 1994| 4.67k| case PT_LAMP: ------------------ | | 1276| 4.67k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (1994:11): [True: 4.67k, False: 100k] ------------------ 1995| 4.67k| OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || ------------------ | Branch (1995:16): [True: 951, False: 3.72k] | Branch (1995:44): [True: 476, False: 3.24k] ------------------ 1996| 4.67k| prop->chartype == ucp_Lt; ------------------ | Branch (1996:13): [True: 0, False: 3.24k] ------------------ 1997| 4.67k| break; 1998| | 1999| 6.95k| case PT_GC: ------------------ | | 1277| 6.95k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (1999:11): [True: 6.95k, False: 97.7k] ------------------ 2000| 6.95k| OK = PRIV(ucp_gentype)[prop->chartype] == code[1 + IMM2_SIZE + 2]; ------------------ | | 177| 6.95k|#define PRIV(name) _pcre2_##name ------------------ OK = PRIV(ucp_gentype)[prop->chartype] == code[1 + IMM2_SIZE + 2]; ------------------ | | 193| 6.95k|#define IMM2_SIZE 2 ------------------ 2001| 6.95k| break; 2002| | 2003| 1.63k| case PT_PC: ------------------ | | 1278| 1.63k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (2003:11): [True: 1.63k, False: 103k] ------------------ 2004| 1.63k| OK = prop->chartype == code[1 + IMM2_SIZE + 2]; ------------------ | | 193| 1.63k|#define IMM2_SIZE 2 ------------------ 2005| 1.63k| break; 2006| | 2007| 9.88k| case PT_SC: ------------------ | | 1279| 9.88k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (2007:11): [True: 9.88k, False: 94.8k] ------------------ 2008| 9.88k| OK = prop->script == code[1 + IMM2_SIZE + 2]; ------------------ | | 193| 9.88k|#define IMM2_SIZE 2 ------------------ 2009| 9.88k| break; 2010| | 2011| 7.85k| case PT_SCX: ------------------ | | 1280| 7.85k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (2011:11): [True: 7.85k, False: 96.8k] ------------------ 2012| 7.85k| OK = (prop->script == code[1 + IMM2_SIZE + 2] || ------------------ | | 193| 7.85k|#define IMM2_SIZE 2 ------------------ | Branch (2012:17): [True: 222, False: 7.63k] ------------------ 2013| 7.85k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), ------------------ | | 1871| 7.63k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (2013:17): [True: 0, False: 7.63k] ------------------ 2014| 7.63k| code[1 + IMM2_SIZE + 2]) != 0); 2015| 7.85k| break; 2016| | 2017| | /* These are specials for combination cases. */ 2018| | 2019| 4.47k| case PT_ALNUM: ------------------ | | 1281| 4.47k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (2019:11): [True: 4.47k, False: 100k] ------------------ 2020| 4.47k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 4.47k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2020:16): [True: 1.29k, False: 3.18k] ------------------ 2021| 4.47k| PRIV(ucp_gentype)[prop->chartype] == ucp_N; ------------------ | | 177| 3.18k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2021:16): [True: 425, False: 2.75k] ------------------ 2022| 4.47k| break; 2023| | 2024| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 2025| | which means that Perl space and POSIX space are now identical. PCRE 2026| | was changed at release 8.34. */ 2027| | 2028| 32.8k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 32.8k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (2028:11): [True: 32.8k, False: 71.9k] ------------------ 2029| 33.0k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 33.0k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (2029:11): [True: 216, False: 104k] ------------------ 2030| 33.0k| switch(c) 2031| 33.0k| { 2032| 46.4k| HSPACE_CASES: ------------------ | | 412| 713| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 233| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 233|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 233, False: 32.8k] | | | | ------------------ | | | | 408| 470| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 470|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 237, False: 32.8k] | | | | ------------------ | | | | 409| 713| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 976| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 976| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 263, False: 32.7k] | | | | ------------------ | | | | 390| 1.19k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 216, False: 32.8k] | | | | ------------------ | | | | 391| 1.41k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 219, False: 32.8k] | | | | ------------------ | | | | 392| 1.64k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 238, False: 32.8k] | | | | ------------------ | | | | 393| 1.86k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 217, False: 32.8k] | | | | ------------------ | | | | 394| 2.15k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 291, False: 32.7k] | | | | ------------------ | | | | 395| 2.43k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 279, False: 32.7k] | | | | ------------------ | | | | 396| 2.65k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 218, False: 32.8k] | | | | ------------------ | | | | 397| 2.93k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 279, False: 32.7k] | | | | ------------------ | | | | 398| 3.21k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 279, False: 32.7k] | | | | ------------------ | | | | 399| 3.50k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 295, False: 32.7k] | | | | ------------------ | | | | 400| 3.74k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 234, False: 32.8k] | | | | ------------------ | | | | 401| 3.95k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 217, False: 32.8k] | | | | ------------------ | | | | 402| 4.19k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 236, False: 32.8k] | | | | ------------------ | | | | 403| 4.42k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 229, False: 32.8k] | | | | ------------------ | | | | 404| 4.73k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 2033| 46.4k| VSPACE_CASES: ------------------ | | 430| 5.97k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 4.96k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 4.96k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 233, False: 32.8k] | | | | ------------------ | | | | 424| 5.23k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 5.23k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 264, False: 32.7k] | | | | ------------------ | | | | 425| 5.46k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 5.46k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 233, False: 32.8k] | | | | ------------------ | | | | 426| 5.72k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 5.72k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 257, False: 32.7k] | | | | ------------------ | | | | 427| 5.97k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 4.73k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 6.24k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 6.24k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 275, False: 32.7k] | | | | ------------------ | | | | 420| 6.46k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 2034| 6.46k| OK = TRUE; ------------------ | | 70| 6.46k|#define TRUE 1 ------------------ 2035| 6.46k| break; 2036| | 2037| 26.5k| default: ------------------ | Branch (2037:13): [True: 26.5k, False: 6.46k] ------------------ 2038| 26.5k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z; ------------------ | | 177| 26.5k|#define PRIV(name) _pcre2_##name ------------------ 2039| 26.5k| break; 2040| 33.0k| } 2041| 33.0k| break; 2042| | 2043| 33.0k| case PT_WORD: ------------------ | | 1284| 2.20k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (2043:11): [True: 2.20k, False: 102k] ------------------ 2044| 2.20k| OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 2.20k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2044:16): [True: 461, False: 1.73k] ------------------ 2045| 2.20k| PRIV(ucp_gentype)[prop->chartype] == ucp_N || ------------------ | | 177| 1.73k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2045:16): [True: 463, False: 1.27k] ------------------ 2046| 2.20k| c == CHAR_UNDERSCORE; ------------------ | | 1045| 3.47k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (2046:16): [True: 0, False: 1.27k] ------------------ 2047| 2.20k| break; 2048| | 2049| 1.38k| case PT_CLIST: ------------------ | | 1285| 1.38k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (2049:11): [True: 1.38k, False: 103k] ------------------ 2050| 1.38k| cp = PRIV(ucd_caseless_sets) + code[1 + IMM2_SIZE + 2]; ------------------ | | 177| 1.38k|#define PRIV(name) _pcre2_##name ------------------ cp = PRIV(ucd_caseless_sets) + code[1 + IMM2_SIZE + 2]; ------------------ | | 193| 1.38k|#define IMM2_SIZE 2 ------------------ 2051| 1.38k| for (;;) 2052| 2.57k| { 2053| 2.57k| if (c < *cp) { OK = FALSE; break; } ------------------ | | 69| 1.04k|#define FALSE 0 ------------------ | Branch (2053:17): [True: 1.04k, False: 1.52k] ------------------ 2054| 1.52k| if (c == *cp++) { OK = TRUE; break; } ------------------ | | 70| 337|#define TRUE 1 ------------------ | Branch (2054:17): [True: 337, False: 1.18k] ------------------ 2055| 1.52k| } 2056| 1.38k| break; 2057| | 2058| 17.0k| case PT_UCNC: ------------------ | | 1286| 17.0k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (2058:11): [True: 17.0k, False: 87.6k] ------------------ 2059| 17.0k| OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 986| 34.1k|#define CHAR_DOLLAR_SIGN '\044' ------------------ OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 33.6k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (2059:16): [True: 458, False: 16.6k] | Branch (2059:41): [True: 306, False: 16.2k] ------------------ 2060| 17.0k| c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) || ------------------ | | 1046| 33.3k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (2060:16): [True: 365, False: 15.9k] | Branch (2060:43): [True: 1.52k, False: 14.4k] | Branch (2060:56): [True: 1.28k, False: 240] ------------------ 2061| 17.0k| c >= 0xe000; ------------------ | Branch (2061:16): [True: 240, False: 14.4k] ------------------ 2062| 17.0k| break; 2063| | 2064| 5.37k| case PT_BIDICL: ------------------ | | 1287| 5.37k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (2064:11): [True: 5.37k, False: 99.3k] ------------------ 2065| 5.37k| OK = UCD_BIDICLASS(c) == code[1 + IMM2_SIZE + 2]; ------------------ | | 1865| 5.37k|#define UCD_BIDICLASS(ch) UCD_BIDICLASS_PROP(GET_UCD(ch)) | | ------------------ | | | | 1854| 5.37k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | | | ------------------ | | | | | | 1850| 5.37k|#define UCD_BIDICLASS_SHIFT 11 | | | | ------------------ | | ------------------ ------------------ OK = UCD_BIDICLASS(c) == code[1 + IMM2_SIZE + 2]; ------------------ | | 193| 5.37k|#define IMM2_SIZE 2 ------------------ 2066| 5.37k| break; 2067| | 2068| 9.99k| case PT_BOOL: ------------------ | | 1288| 9.99k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (2068:11): [True: 9.99k, False: 94.7k] ------------------ 2069| 9.99k| OK = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 9.99k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 2070| 9.99k| UCD_BPROPS_PROP(prop), code[1 + IMM2_SIZE + 2]) != 0; 2071| 9.99k| break; 2072| | 2073| | /* Should never occur, but keep compilers from grumbling. */ 2074| | 2075| 0| default: ------------------ | Branch (2075:11): [True: 0, False: 104k] ------------------ 2076| 0| OK = codevalue != OP_PROP; 2077| 0| break; 2078| 104k| } 2079| | 2080| 104k| if (OK == (d == OP_PROP)) ------------------ | Branch (2080:13): [True: 86.0k, False: 18.7k] ------------------ 2081| 86.0k| { 2082| 86.0k| if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSUPTO) ------------------ | | 101| 86.0k|#define OP_PROP_EXTRA 300 ------------------ | Branch (2082:15): [True: 831, False: 85.1k] ------------------ 2083| 831| { 2084| 831| active_count--; /* Remove non-match possibility */ 2085| 831| next_active_state--; 2086| 831| } 2087| 86.0k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 86.0k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2087:15): [True: 8.12k, False: 77.8k] ------------------ 2088| 8.12k| { ADD_NEW(state_offset + 1 + IMM2_SIZE + 3, 0); } ------------------ | | 503| 8.12k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 8.11k, False: 10] | | ------------------ | | 504| 8.12k| { \ | | 505| 8.11k| next_new_state->offset = (x); \ | | 506| 8.11k| next_new_state->count = (y); \ | | 507| 8.11k| next_new_state++; \ | | 508| 8.11k| } \ | | 509| 8.12k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2089| 77.8k| else 2090| 77.8k| { ADD_NEW(state_offset, count); } ------------------ | | 503| 77.8k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 77.8k, False: 10] | | ------------------ | | 504| 77.8k| { \ | | 505| 77.8k| next_new_state->offset = (x); \ | | 506| 77.8k| next_new_state->count = (y); \ | | 507| 77.8k| next_new_state++; \ | | 508| 77.8k| } \ | | 509| 77.8k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2091| 86.0k| } 2092| 104k| } 2093| 112k| break; 2094| | 2095| | /*-----------------------------------------------------------------*/ 2096| 112k| case OP_EXTUNI_EXTRA + OP_TYPEEXACT: ------------------ | | 102| 12.7k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (2096:7): [True: 12.7k, False: 8.92M] ------------------ 2097| 20.7k| case OP_EXTUNI_EXTRA + OP_TYPEUPTO: ------------------ | | 102| 20.7k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (2097:7): [True: 8.02k, False: 8.92M] ------------------ 2098| 20.9k| case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO: ------------------ | | 102| 20.9k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (2098:7): [True: 214, False: 8.93M] ------------------ 2099| 21.3k| case OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO: ------------------ | | 102| 21.3k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (2099:7): [True: 342, False: 8.93M] ------------------ 2100| 21.3k| if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT) ------------------ | | 102| 21.3k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (2100:11): [True: 8.58k, False: 12.7k] ------------------ 2101| 8.58k| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } ------------------ | | 484| 8.58k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 8.57k, False: 10] | | ------------------ | | 485| 8.58k| { \ | | 486| 8.57k| next_active_state->offset = (x); \ | | 487| 8.57k| next_active_state->count = (y); \ | | 488| 8.57k| next_active_state++; \ | | 489| 8.57k| } \ | | 490| 8.58k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2102| 21.3k| count = current_state->count; /* Number already matched */ 2103| 21.3k| if (clen > 0) ------------------ | Branch (2103:11): [True: 18.2k, False: 3.06k] ------------------ 2104| 18.2k| { 2105| 18.2k| PCRE2_SPTR nptr; ------------------ | | 814| 18.2k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 18.2k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 18.2k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 18.2k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2106| 18.2k| int ncount = 0; 2107| 18.2k| if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO) ------------------ | | 102| 18.2k|#define OP_EXTUNI_EXTRA 320 ------------------ | Branch (2107:13): [True: 298, False: 17.9k] ------------------ 2108| 298| { 2109| 298| active_count--; /* Remove non-match possibility */ 2110| 298| next_active_state--; 2111| 298| } 2112| 18.2k| nptr = PRIV(extuni)(c, ptr + clen, mb->start_subject, end_subject, utf, ------------------ | | 177| 18.2k|#define PRIV(name) _pcre2_##name ------------------ 2113| 18.2k| &ncount); 2114| 18.2k| if (nptr >= end_subject && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 2.54k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (2114:13): [True: 2.54k, False: 15.7k] | Branch (2114:36): [True: 238, False: 2.30k] ------------------ 2115| 238| reset_could_continue = TRUE; ------------------ | | 70| 238|#define TRUE 1 ------------------ 2116| 18.2k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 18.2k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2116:13): [True: 1.56k, False: 16.6k] ------------------ 2117| 1.56k| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); } ------------------ | | 512| 1.56k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 1.55k, False: 10] | | ------------------ | | 513| 1.56k| { \ | | 514| 1.55k| next_new_state->offset = (x); \ | | 515| 1.55k| next_new_state->count = (y); \ | | 516| 1.55k| next_new_state->data = (z); \ | | 517| 1.55k| next_new_state++; \ | | 518| 1.55k| } \ | | 519| 1.56k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2118| 16.6k| else 2119| 16.6k| { ADD_NEW_DATA(-state_offset, count, ncount); } ------------------ | | 512| 16.6k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 16.6k, False: 10] | | ------------------ | | 513| 16.6k| { \ | | 514| 16.6k| next_new_state->offset = (x); \ | | 515| 16.6k| next_new_state->count = (y); \ | | 516| 16.6k| next_new_state->data = (z); \ | | 517| 16.6k| next_new_state++; \ | | 518| 16.6k| } \ | | 519| 16.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2120| 18.2k| } 2121| 21.3k| break; 2122| 21.3k|#endif 2123| | 2124| | /*-----------------------------------------------------------------*/ 2125| 21.3k| case OP_ANYNL_EXTRA + OP_TYPEEXACT: ------------------ | | 103| 10.8k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (2125:7): [True: 10.8k, False: 8.92M] ------------------ 2126| 12.1k| case OP_ANYNL_EXTRA + OP_TYPEUPTO: ------------------ | | 103| 12.1k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (2126:7): [True: 1.28k, False: 8.93M] ------------------ 2127| 12.4k| case OP_ANYNL_EXTRA + OP_TYPEMINUPTO: ------------------ | | 103| 12.4k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (2127:7): [True: 269, False: 8.93M] ------------------ 2128| 13.3k| case OP_ANYNL_EXTRA + OP_TYPEPOSUPTO: ------------------ | | 103| 13.3k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (2128:7): [True: 928, False: 8.93M] ------------------ 2129| 13.3k| if (codevalue != OP_ANYNL_EXTRA + OP_TYPEEXACT) ------------------ | | 103| 13.3k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (2129:11): [True: 2.48k, False: 10.8k] ------------------ 2130| 2.48k| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } ------------------ | | 484| 2.48k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 2.47k, False: 10] | | ------------------ | | 485| 2.48k| { \ | | 486| 2.47k| next_active_state->offset = (x); \ | | 487| 2.47k| next_active_state->count = (y); \ | | 488| 2.47k| next_active_state++; \ | | 489| 2.47k| } \ | | 490| 2.48k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2131| 13.3k| count = current_state->count; /* Number already matched */ 2132| 13.3k| if (clen > 0) ------------------ | Branch (2132:11): [True: 11.0k, False: 2.27k] ------------------ 2133| 11.0k| { 2134| 11.0k| int ncount = 0; 2135| 11.0k| switch (c) 2136| 11.0k| { 2137| 783| case CHAR_VT: ------------------ | | 970| 783|#define CHAR_VT '\013' ------------------ | Branch (2137:11): [True: 783, False: 10.2k] ------------------ 2138| 1.04k| case CHAR_FF: ------------------ | | 971| 1.04k|#define CHAR_FF '\014' ------------------ | Branch (2138:11): [True: 258, False: 10.8k] ------------------ 2139| 1.26k| case CHAR_NEL: ------------------ | | 975| 1.26k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (2139:11): [True: 226, False: 10.8k] ------------------ 2140| 1.26k|#ifndef EBCDIC 2141| 1.46k| case 0x2028: ------------------ | Branch (2141:11): [True: 198, False: 10.8k] ------------------ 2142| 1.70k| case 0x2029: ------------------ | Branch (2142:11): [True: 241, False: 10.8k] ------------------ 2143| 1.70k|#endif /* Not EBCDIC */ 2144| 1.70k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; ------------------ | | 217| 1.70k|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (2144:15): [True: 0, False: 1.70k] ------------------ 2145| 1.70k| goto ANYNL03; 2146| | 2147| 1.70k| case CHAR_CR: ------------------ | | 972| 1.61k|#define CHAR_CR '\015' ------------------ | Branch (2147:11): [True: 1.61k, False: 9.45k] ------------------ 2148| 1.61k| if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; ------------------ | | 244| 1.17k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; ------------------ | | 973| 1.17k|#define CHAR_LF '\012' ------------------ | Branch (2148:15): [True: 1.17k, False: 443] | Branch (2148:40): [True: 234, False: 938] ------------------ 2149| | /* Fall through */ 2150| | 2151| 3.32k| ANYNL03: 2152| 4.11k| case CHAR_LF: ------------------ | | 973| 4.11k|#define CHAR_LF '\012' ------------------ | Branch (2152:11): [True: 794, False: 10.2k] ------------------ 2153| 4.11k| if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO) ------------------ | | 103| 4.11k|#define OP_ANYNL_EXTRA 340 ------------------ | Branch (2153:15): [True: 240, False: 3.87k] ------------------ 2154| 240| { 2155| 240| active_count--; /* Remove non-match possibility */ 2156| 240| next_active_state--; 2157| 240| } 2158| 4.11k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 4.11k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2158:15): [True: 326, False: 3.78k] ------------------ 2159| 326| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); } ------------------ | | 512| 326| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 316, False: 10] | | ------------------ | | 513| 326| { \ | | 514| 316| next_new_state->offset = (x); \ | | 515| 316| next_new_state->count = (y); \ | | 516| 316| next_new_state->data = (z); \ | | 517| 316| next_new_state++; \ | | 518| 316| } \ | | 519| 326| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2160| 3.78k| else 2161| 3.78k| { ADD_NEW_DATA(-state_offset, count, ncount); } ------------------ | | 512| 3.78k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 3.77k, False: 10] | | ------------------ | | 513| 3.78k| { \ | | 514| 3.77k| next_new_state->offset = (x); \ | | 515| 3.77k| next_new_state->count = (y); \ | | 516| 3.77k| next_new_state->data = (z); \ | | 517| 3.77k| next_new_state++; \ | | 518| 3.77k| } \ | | 519| 3.78k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2162| 4.09k| break; 2163| | 2164| 6.95k| default: ------------------ | Branch (2164:11): [True: 6.95k, False: 4.11k] ------------------ 2165| 6.95k| break; 2166| 11.0k| } 2167| 11.0k| } 2168| 13.3k| break; 2169| | 2170| | /*-----------------------------------------------------------------*/ 2171| 16.0k| case OP_VSPACE_EXTRA + OP_TYPEEXACT: ------------------ | | 105| 16.0k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (2171:7): [True: 16.0k, False: 8.91M] ------------------ 2172| 16.5k| case OP_VSPACE_EXTRA + OP_TYPEUPTO: ------------------ | | 105| 16.5k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (2172:7): [True: 490, False: 8.93M] ------------------ 2173| 16.9k| case OP_VSPACE_EXTRA + OP_TYPEMINUPTO: ------------------ | | 105| 16.9k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (2173:7): [True: 366, False: 8.93M] ------------------ 2174| 17.9k| case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO: ------------------ | | 105| 17.9k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (2174:7): [True: 1.01k, False: 8.93M] ------------------ 2175| 17.9k| if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT) ------------------ | | 105| 17.9k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (2175:11): [True: 1.87k, False: 16.0k] ------------------ 2176| 1.87k| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } ------------------ | | 484| 1.87k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 1.86k, False: 10] | | ------------------ | | 485| 1.87k| { \ | | 486| 1.86k| next_active_state->offset = (x); \ | | 487| 1.86k| next_active_state->count = (y); \ | | 488| 1.86k| next_active_state++; \ | | 489| 1.86k| } \ | | 490| 1.87k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2177| 17.9k| count = current_state->count; /* Number already matched */ 2178| 17.9k| if (clen > 0) ------------------ | Branch (2178:11): [True: 16.3k, False: 1.57k] ------------------ 2179| 16.3k| { 2180| 16.3k| BOOL OK; 2181| 16.3k| switch (c) 2182| 16.3k| { 2183| 1.95k| VSPACE_CASES: ------------------ | | 430| 1.48k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 263| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 263|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 263, False: 16.1k] | | | | ------------------ | | | | 424| 641| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 641|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 378, False: 16.0k] | | | | ------------------ | | | | 425| 1.00k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.00k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 368, False: 16.0k] | | | | ------------------ | | | | 426| 1.25k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.25k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 245, False: 16.1k] | | | | ------------------ | | | | 427| 1.48k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 1.71k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 1.71k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 233, False: 16.1k] | | | | ------------------ | | | | 420| 1.95k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 2184| 1.95k| OK = TRUE; ------------------ | | 70| 1.95k|#define TRUE 1 ------------------ 2185| 1.95k| break; 2186| | 2187| 14.4k| default: ------------------ | Branch (2187:11): [True: 14.4k, False: 1.95k] ------------------ 2188| 14.4k| OK = FALSE; ------------------ | | 69| 14.4k|#define FALSE 0 ------------------ 2189| 16.3k| } 2190| | 2191| 16.3k| if (OK == (d == OP_VSPACE)) ------------------ | Branch (2191:13): [True: 13.7k, False: 2.64k] ------------------ 2192| 13.7k| { 2193| 13.7k| if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO) ------------------ | | 105| 13.7k|#define OP_VSPACE_EXTRA 380 ------------------ | Branch (2193:15): [True: 755, False: 12.9k] ------------------ 2194| 755| { 2195| 755| active_count--; /* Remove non-match possibility */ 2196| 755| next_active_state--; 2197| 755| } 2198| 13.7k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 13.7k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2198:15): [True: 1.46k, False: 12.2k] ------------------ 2199| 1.46k| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); } ------------------ | | 512| 1.46k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 1.45k, False: 10] | | ------------------ | | 513| 1.46k| { \ | | 514| 1.45k| next_new_state->offset = (x); \ | | 515| 1.45k| next_new_state->count = (y); \ | | 516| 1.45k| next_new_state->data = (z); \ | | 517| 1.45k| next_new_state++; \ | | 518| 1.45k| } \ | | 519| 1.46k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2200| 12.2k| else 2201| 12.2k| { ADD_NEW_DATA(-state_offset, count, 0); } ------------------ | | 512| 12.2k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 12.2k, False: 10] | | ------------------ | | 513| 12.2k| { \ | | 514| 12.2k| next_new_state->offset = (x); \ | | 515| 12.2k| next_new_state->count = (y); \ | | 516| 12.2k| next_new_state->data = (z); \ | | 517| 12.2k| next_new_state++; \ | | 518| 12.2k| } \ | | 519| 12.2k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2202| 13.7k| } 2203| 16.3k| } 2204| 17.9k| break; 2205| | 2206| | /*-----------------------------------------------------------------*/ 2207| 50.4k| case OP_HSPACE_EXTRA + OP_TYPEEXACT: ------------------ | | 104| 50.4k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (2207:7): [True: 50.4k, False: 8.88M] ------------------ 2208| 50.9k| case OP_HSPACE_EXTRA + OP_TYPEUPTO: ------------------ | | 104| 50.9k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (2208:7): [True: 437, False: 8.93M] ------------------ 2209| 51.2k| case OP_HSPACE_EXTRA + OP_TYPEMINUPTO: ------------------ | | 104| 51.2k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (2209:7): [True: 308, False: 8.93M] ------------------ 2210| 51.8k| case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO: ------------------ | | 104| 51.8k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (2210:7): [True: 593, False: 8.93M] ------------------ 2211| 51.8k| if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT) ------------------ | | 104| 51.8k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (2211:11): [True: 1.33k, False: 50.4k] ------------------ 2212| 1.33k| { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); } ------------------ | | 484| 1.33k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 1.32k, False: 10] | | ------------------ | | 485| 1.33k| { \ | | 486| 1.32k| next_active_state->offset = (x); \ | | 487| 1.32k| next_active_state->count = (y); \ | | 488| 1.32k| next_active_state++; \ | | 489| 1.32k| } \ | | 490| 1.33k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2213| 51.8k| count = current_state->count; /* Number already matched */ 2214| 51.8k| if (clen > 0) ------------------ | Branch (2214:11): [True: 46.1k, False: 5.67k] ------------------ 2215| 46.1k| { 2216| 46.1k| BOOL OK; 2217| 46.1k| switch (c) 2218| 46.1k| { 2219| 5.60k| HSPACE_CASES: ------------------ | | 412| 1.92k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 810| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 810|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 810, False: 45.3k] | | | | ------------------ | | | | 408| 1.38k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.38k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 577, False: 45.5k] | | | | ------------------ | | | | 409| 1.92k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 2.16k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 2.16k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 236, False: 45.9k] | | | | ------------------ | | | | 390| 2.41k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 257, False: 45.8k] | | | | ------------------ | | | | 391| 2.63k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 217, False: 45.9k] | | | | ------------------ | | | | 392| 2.85k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 217, False: 45.9k] | | | | ------------------ | | | | 393| 3.09k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 241, False: 45.9k] | | | | ------------------ | | | | 394| 3.32k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 229, False: 45.9k] | | | | ------------------ | | | | 395| 3.57k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 253, False: 45.9k] | | | | ------------------ | | | | 396| 3.78k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 215, False: 45.9k] | | | | ------------------ | | | | 397| 4.03k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 245, False: 45.9k] | | | | ------------------ | | | | 398| 4.25k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 221, False: 45.9k] | | | | ------------------ | | | | 399| 4.47k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 221, False: 45.9k] | | | | ------------------ | | | | 400| 4.69k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 223, False: 45.9k] | | | | ------------------ | | | | 401| 4.94k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 241, False: 45.9k] | | | | ------------------ | | | | 402| 5.15k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 216, False: 45.9k] | | | | ------------------ | | | | 403| 5.38k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 225, False: 45.9k] | | | | ------------------ | | | | 404| 5.60k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 2220| 5.60k| OK = TRUE; ------------------ | | 70| 5.60k|#define TRUE 1 ------------------ 2221| 5.60k| break; 2222| | 2223| 40.5k| default: ------------------ | Branch (2223:11): [True: 40.5k, False: 5.60k] ------------------ 2224| 40.5k| OK = FALSE; ------------------ | | 69| 40.5k|#define FALSE 0 ------------------ 2225| 40.5k| break; 2226| 46.1k| } 2227| | 2228| 46.1k| if (OK == (d == OP_HSPACE)) ------------------ | Branch (2228:13): [True: 39.8k, False: 6.32k] ------------------ 2229| 39.8k| { 2230| 39.8k| if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSUPTO) ------------------ | | 104| 39.8k|#define OP_HSPACE_EXTRA 360 ------------------ | Branch (2230:15): [True: 450, False: 39.3k] ------------------ 2231| 450| { 2232| 450| active_count--; /* Remove non-match possibility */ 2233| 450| next_active_state--; 2234| 450| } 2235| 39.8k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 39.8k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2235:15): [True: 2.41k, False: 37.4k] ------------------ 2236| 2.41k| { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); } ------------------ | | 512| 2.41k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 2.40k, False: 10] | | ------------------ | | 513| 2.41k| { \ | | 514| 2.40k| next_new_state->offset = (x); \ | | 515| 2.40k| next_new_state->count = (y); \ | | 516| 2.40k| next_new_state->data = (z); \ | | 517| 2.40k| next_new_state++; \ | | 518| 2.40k| } \ | | 519| 2.41k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2237| 37.4k| else 2238| 37.4k| { ADD_NEW_DATA(-state_offset, count, 0); } ------------------ | | 512| 37.4k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 37.4k, False: 10] | | ------------------ | | 513| 37.4k| { \ | | 514| 37.4k| next_new_state->offset = (x); \ | | 515| 37.4k| next_new_state->count = (y); \ | | 516| 37.4k| next_new_state->data = (z); \ | | 517| 37.4k| next_new_state++; \ | | 518| 37.4k| } \ | | 519| 37.4k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2239| 39.8k| } 2240| 46.1k| } 2241| 51.8k| break; 2242| | 2243| |/* ========================================================================== */ 2244| | /* These opcodes are followed by a character that is usually compared 2245| | to the current subject character; it is loaded into d. We still get 2246| | here even if there is no subject character, because in some cases zero 2247| | repetitions are permitted. */ 2248| | 2249| | /*-----------------------------------------------------------------*/ 2250| 1.17M| case OP_CHAR: ------------------ | Branch (2250:7): [True: 1.17M, False: 7.75M] ------------------ 2251| 1.17M| if (clen > 0 && c == d) { ADD_NEW(state_offset + dlen + 1, 0); } ------------------ | | 503| 228k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 228k, False: 16] | | ------------------ | | 504| 228k| { \ | | 505| 228k| next_new_state->offset = (x); \ | | 506| 228k| next_new_state->count = (y); \ | | 507| 228k| next_new_state++; \ | | 508| 228k| } \ | | 509| 228k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 16|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (2251:11): [True: 1.11M, False: 59.3k] | Branch (2251:23): [True: 228k, False: 887k] ------------------ 2252| 1.17M| break; 2253| | 2254| | /*-----------------------------------------------------------------*/ 2255| 1.17M| case OP_CHARI: ------------------ | Branch (2255:7): [True: 267k, False: 8.66M] ------------------ 2256| 267k| if (clen == 0) break; ------------------ | Branch (2256:11): [True: 29.8k, False: 237k] ------------------ 2257| | 2258| 237k|#ifdef SUPPORT_UNICODE 2259| 237k| if (utf_or_ucp) ------------------ | Branch (2259:11): [True: 209k, False: 28.5k] ------------------ 2260| 209k| { 2261| 209k| if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else ------------------ | | 503| 75.9k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 75.9k, False: 3] | | ------------------ | | 504| 75.9k| { \ | | 505| 75.9k| next_new_state->offset = (x); \ | | 506| 75.9k| next_new_state->count = (y); \ | | 507| 75.9k| next_new_state++; \ | | 508| 75.9k| } \ | | 509| 75.9k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 3|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (2261:13): [True: 75.9k, False: 133k] ------------------ 2262| 133k| { 2263| 133k| unsigned int othercase; 2264| 133k| if (c < 128) ------------------ | Branch (2264:15): [True: 117k, False: 16.3k] ------------------ 2265| 117k| othercase = fcc[c]; 2266| 16.3k| else 2267| 16.3k| othercase = UCD_OTHERCASE(c); ------------------ | | 1862| 16.3k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 16.3k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 16.3k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 16.3k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 16.3k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 16.3k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 16.3k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 16.3k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 16.3k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 16.3k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 16.3k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2268| 133k| if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); } ------------------ | | 503| 1.59k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 1.58k, False: 3] | | ------------------ | | 504| 1.59k| { \ | | 505| 1.58k| next_new_state->offset = (x); \ | | 506| 1.58k| next_new_state->count = (y); \ | | 507| 1.58k| next_new_state++; \ | | 508| 1.58k| } \ | | 509| 1.59k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 3|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (2268:15): [True: 1.59k, False: 131k] ------------------ 2269| 133k| } 2270| 209k| } 2271| 28.5k| else 2272| 28.5k|#endif /* SUPPORT_UNICODE */ 2273| | /* Not UTF or UCP mode */ 2274| 28.5k| { 2275| 28.5k| if (TABLE_GET(c, lcc, c) == TABLE_GET(d, lcc, d)) ------------------ | | 214| 28.5k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ if (TABLE_GET(c, lcc, c) == TABLE_GET(d, lcc, d)) ------------------ | | 214| 28.5k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ | Branch (2275:13): [True: 7.40k, False: 21.1k] ------------------ 2276| 7.40k| { ADD_NEW(state_offset + 2, 0); } ------------------ | | 503| 7.40k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 7.39k, False: 7] | | ------------------ | | 504| 7.40k| { \ | | 505| 7.39k| next_new_state->offset = (x); \ | | 506| 7.39k| next_new_state->count = (y); \ | | 507| 7.39k| next_new_state++; \ | | 508| 7.39k| } \ | | 509| 7.40k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 7|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2277| 28.5k| } 2278| 237k| break; 2279| | 2280| | 2281| 237k|#ifdef SUPPORT_UNICODE 2282| | /*-----------------------------------------------------------------*/ 2283| | /* This is a tricky one because it can match more than one character. 2284| | Find out how many characters to skip, and then set up a negative state 2285| | to wait for them to pass before continuing. */ 2286| | 2287| 237k| case OP_EXTUNI: ------------------ | Branch (2287:7): [True: 19.9k, False: 8.91M] ------------------ 2288| 19.9k| if (clen > 0) ------------------ | Branch (2288:11): [True: 17.6k, False: 2.28k] ------------------ 2289| 17.6k| { 2290| 17.6k| int ncount = 0; 2291| 17.6k| PCRE2_SPTR nptr = PRIV(extuni)(c, ptr + clen, mb->start_subject, ------------------ | | 814| 17.6k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 17.6k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 17.6k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 17.6k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR nptr = PRIV(extuni)(c, ptr + clen, mb->start_subject, ------------------ | | 177| 17.6k|#define PRIV(name) _pcre2_##name ------------------ 2292| 17.6k| end_subject, utf, &ncount); 2293| 17.6k| if (nptr >= end_subject && (mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 2.02k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (2293:13): [True: 2.02k, False: 15.6k] | Branch (2293:36): [True: 295, False: 1.72k] ------------------ 2294| 295| reset_could_continue = TRUE; ------------------ | | 70| 295|#define TRUE 1 ------------------ 2295| 17.6k| ADD_NEW_DATA(-(state_offset + 1), 0, ncount); ------------------ | | 512| 17.6k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 17.6k, False: 10] | | ------------------ | | 513| 17.6k| { \ | | 514| 17.6k| next_new_state->offset = (x); \ | | 515| 17.6k| next_new_state->count = (y); \ | | 516| 17.6k| next_new_state->data = (z); \ | | 517| 17.6k| next_new_state++; \ | | 518| 17.6k| } \ | | 519| 17.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2296| 17.6k| } 2297| 19.9k| break; 2298| 19.9k|#endif 2299| | 2300| | /*-----------------------------------------------------------------*/ 2301| | /* This is a tricky like EXTUNI because it too can match more than one 2302| | character (when CR is followed by LF). In this case, set up a negative 2303| | state to wait for one character to pass before continuing. */ 2304| | 2305| 19.9k| case OP_ANYNL: ------------------ | Branch (2305:7): [True: 18.3k, False: 8.91M] ------------------ 2306| 18.3k| if (clen > 0) switch(c) ------------------ | Branch (2306:11): [True: 15.3k, False: 3.01k] | Branch (2306:28): [True: 11.3k, False: 3.99k] ------------------ 2307| 15.3k| { 2308| 336| case CHAR_VT: ------------------ | | 970| 336|#define CHAR_VT '\013' ------------------ | Branch (2308:9): [True: 336, False: 15.0k] ------------------ 2309| 603| case CHAR_FF: ------------------ | | 971| 603|#define CHAR_FF '\014' ------------------ | Branch (2309:9): [True: 267, False: 15.1k] ------------------ 2310| 908| case CHAR_NEL: ------------------ | | 975| 908|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (2310:9): [True: 305, False: 15.0k] ------------------ 2311| 908|#ifndef EBCDIC 2312| 1.18k| case 0x2028: ------------------ | Branch (2312:9): [True: 276, False: 15.0k] ------------------ 2313| 1.44k| case 0x2029: ------------------ | Branch (2313:9): [True: 262, False: 15.1k] ------------------ 2314| 1.44k|#endif /* Not EBCDIC */ 2315| 1.44k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) break; ------------------ | | 217| 1.44k|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (2315:13): [True: 0, False: 1.44k] ------------------ 2316| | /* Fall through */ 2317| | 2318| 2.32k| case CHAR_LF: ------------------ | | 973| 2.32k|#define CHAR_LF '\012' ------------------ | Branch (2318:9): [True: 879, False: 14.4k] ------------------ 2319| 2.32k| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 2.32k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 2.31k, False: 10] | | ------------------ | | 504| 2.32k| { \ | | 505| 2.31k| next_new_state->offset = (x); \ | | 506| 2.31k| next_new_state->count = (y); \ | | 507| 2.31k| next_new_state++; \ | | 508| 2.31k| } \ | | 509| 2.32k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2320| 2.31k| break; 2321| | 2322| 2.31k| case CHAR_CR: ------------------ | | 972| 1.67k|#define CHAR_CR '\015' ------------------ | Branch (2322:9): [True: 1.67k, False: 13.6k] ------------------ 2323| 1.67k| if (ptr + 1 >= end_subject) ------------------ | Branch (2323:13): [True: 799, False: 871] ------------------ 2324| 799| { 2325| 799| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 799| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 799, False: 0] | | ------------------ | | 504| 799| { \ | | 505| 799| next_new_state->offset = (x); \ | | 506| 799| next_new_state->count = (y); \ | | 507| 799| next_new_state++; \ | | 508| 799| } \ | | 509| 799| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 0|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2326| 799| if ((mb->moptions & PCRE2_PARTIAL_HARD) != 0) ------------------ | | 181| 799|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (2326:15): [True: 199, False: 600] ------------------ 2327| 199| reset_could_continue = TRUE; ------------------ | | 70| 199|#define TRUE 1 ------------------ 2328| 799| } 2329| 871| else if (UCHAR21TEST(ptr + 1) == CHAR_LF) ------------------ | | 244| 871|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ else if (UCHAR21TEST(ptr + 1) == CHAR_LF) ------------------ | | 973| 871|#define CHAR_LF '\012' ------------------ | Branch (2329:18): [True: 303, False: 568] ------------------ 2330| 303| { 2331| 303| ADD_NEW_DATA(-(state_offset + 1), 0, 1); ------------------ | | 512| 303| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 300, False: 3] | | ------------------ | | 513| 303| { \ | | 514| 300| next_new_state->offset = (x); \ | | 515| 300| next_new_state->count = (y); \ | | 516| 300| next_new_state->data = (z); \ | | 517| 300| next_new_state++; \ | | 518| 300| } \ | | 519| 303| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 3|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2332| 303| } 2333| 568| else 2334| 568| { 2335| 568| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 568| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 558, False: 10] | | ------------------ | | 504| 568| { \ | | 505| 558| next_new_state->offset = (x); \ | | 506| 558| next_new_state->count = (y); \ | | 507| 558| next_new_state++; \ | | 508| 558| } \ | | 509| 568| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2336| 568| } 2337| 1.65k| break; 2338| 15.3k| } 2339| 18.3k| break; 2340| | 2341| | /*-----------------------------------------------------------------*/ 2342| 31.7k| case OP_NOT_VSPACE: ------------------ | Branch (2342:7): [True: 31.7k, False: 8.90M] ------------------ 2343| 31.7k| if (clen > 0) switch(c) ------------------ | Branch (2343:11): [True: 29.3k, False: 2.39k] ------------------ 2344| 29.3k| { 2345| 2.27k| VSPACE_CASES: ------------------ | | 430| 1.79k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 298| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 298|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 298, False: 29.1k] | | | | ------------------ | | | | 424| 804| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 804|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 506, False: 28.8k] | | | | ------------------ | | | | 425| 1.28k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.28k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 476, False: 28.9k] | | | | ------------------ | | | | 426| 1.55k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.55k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 277, False: 29.1k] | | | | ------------------ | | | | 427| 1.79k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 2.06k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 2.06k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 262, False: 29.1k] | | | | ------------------ | | | | 420| 2.27k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 2346| 2.27k| break; 2347| | 2348| 27.1k| default: ------------------ | Branch (2348:9): [True: 27.1k, False: 2.27k] ------------------ 2349| 27.1k| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 27.1k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 27.1k, False: 10] | | ------------------ | | 504| 27.1k| { \ | | 505| 27.1k| next_new_state->offset = (x); \ | | 506| 27.1k| next_new_state->count = (y); \ | | 507| 27.1k| next_new_state++; \ | | 508| 27.1k| } \ | | 509| 27.1k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2350| 27.1k| break; 2351| 29.3k| } 2352| 31.7k| break; 2353| | 2354| | /*-----------------------------------------------------------------*/ 2355| 31.7k| case OP_VSPACE: ------------------ | Branch (2355:7): [True: 13.4k, False: 8.91M] ------------------ 2356| 13.4k| if (clen > 0) switch(c) ------------------ | Branch (2356:11): [True: 11.1k, False: 2.25k] ------------------ 2357| 11.1k| { 2358| 8.48k| VSPACE_CASES: ------------------ | | 430| 1.51k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 242| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 242|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 242, False: 10.9k] | | | | ------------------ | | | | 424| 662| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 662|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 420, False: 10.7k] | | | | ------------------ | | | | 425| 908| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 908|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 246, False: 10.9k] | | | | ------------------ | | | | 426| 1.28k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.28k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 375, False: 10.7k] | | | | ------------------ | | | | 427| 1.51k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 1.80k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 1.80k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 288, False: 10.8k] | | | | ------------------ | | | | 420| 2.07k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 2359| 8.48k| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 2.07k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 2.06k, False: 10] | | ------------------ | | 504| 2.07k| { \ | | 505| 2.06k| next_new_state->offset = (x); \ | | 506| 2.06k| next_new_state->count = (y); \ | | 507| 2.06k| next_new_state++; \ | | 508| 2.06k| } \ | | 509| 2.07k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2360| 2.06k| break; 2361| | 2362| 9.08k| default: ------------------ | Branch (2362:9): [True: 9.08k, False: 2.07k] ------------------ 2363| 9.08k| break; 2364| 11.1k| } 2365| 13.4k| break; 2366| | 2367| | /*-----------------------------------------------------------------*/ 2368| 50.4k| case OP_NOT_HSPACE: ------------------ | Branch (2368:7): [True: 50.4k, False: 8.88M] ------------------ 2369| 50.4k| if (clen > 0) switch(c) ------------------ | Branch (2369:11): [True: 42.8k, False: 7.59k] ------------------ 2370| 42.8k| { 2371| 6.09k| HSPACE_CASES: ------------------ | | 412| 1.45k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 459| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 459|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 459, False: 42.3k] | | | | ------------------ | | | | 408| 962| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 962|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 503, False: 42.3k] | | | | ------------------ | | | | 409| 1.45k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.72k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.72k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 268, False: 42.5k] | | | | ------------------ | | | | 390| 2.02k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 308, False: 42.5k] | | | | ------------------ | | | | 391| 2.45k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 422, False: 42.3k] | | | | ------------------ | | | | 392| 2.73k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 284, False: 42.5k] | | | | ------------------ | | | | 393| 3.00k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 266, False: 42.5k] | | | | ------------------ | | | | 394| 3.28k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 288, False: 42.5k] | | | | ------------------ | | | | 395| 3.57k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 284, False: 42.5k] | | | | ------------------ | | | | 396| 3.93k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 366, False: 42.4k] | | | | ------------------ | | | | 397| 4.22k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 288, False: 42.5k] | | | | ------------------ | | | | 398| 4.48k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 258, False: 42.5k] | | | | ------------------ | | | | 399| 4.78k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 300, False: 42.5k] | | | | ------------------ | | | | 400| 5.06k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 282, False: 42.5k] | | | | ------------------ | | | | 401| 5.29k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 224, False: 42.5k] | | | | ------------------ | | | | 402| 5.64k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 356, False: 42.4k] | | | | ------------------ | | | | 403| 5.87k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 232, False: 42.5k] | | | | ------------------ | | | | 404| 6.09k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 2372| 6.09k| break; 2373| | 2374| 36.7k| default: ------------------ | Branch (2374:9): [True: 36.7k, False: 6.09k] ------------------ 2375| 36.7k| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 36.7k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 36.7k, False: 10] | | ------------------ | | 504| 36.7k| { \ | | 505| 36.7k| next_new_state->offset = (x); \ | | 506| 36.7k| next_new_state->count = (y); \ | | 507| 36.7k| next_new_state++; \ | | 508| 36.7k| } \ | | 509| 36.7k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2376| 36.7k| break; 2377| 42.8k| } 2378| 50.4k| break; 2379| | 2380| | /*-----------------------------------------------------------------*/ 2381| 50.4k| case OP_HSPACE: ------------------ | Branch (2381:7): [True: 39.4k, False: 8.89M] ------------------ 2382| 39.4k| if (clen > 0) switch(c) ------------------ | Branch (2382:11): [True: 33.0k, False: 6.38k] ------------------ 2383| 33.0k| { 2384| 64.8k| HSPACE_CASES: ------------------ | | 412| 1.54k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 391| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 391|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 391, False: 32.6k] | | | | ------------------ | | | | 408| 1.20k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.20k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 812, False: 32.2k] | | | | ------------------ | | | | 409| 1.54k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.80k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.80k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 258, False: 32.8k] | | | | ------------------ | | | | 390| 2.06k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 260, False: 32.8k] | | | | ------------------ | | | | 391| 2.37k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 315, False: 32.7k] | | | | ------------------ | | | | 392| 2.64k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 264, False: 32.8k] | | | | ------------------ | | | | 393| 2.92k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 286, False: 32.7k] | | | | ------------------ | | | | 394| 3.18k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 260, False: 32.8k] | | | | ------------------ | | | | 395| 3.45k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 263, False: 32.8k] | | | | ------------------ | | | | 396| 3.72k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 272, False: 32.8k] | | | | ------------------ | | | | 397| 3.97k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 250, False: 32.8k] | | | | ------------------ | | | | 398| 4.23k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 266, False: 32.8k] | | | | ------------------ | | | | 399| 4.51k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 280, False: 32.8k] | | | | ------------------ | | | | 400| 4.77k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 254, False: 32.8k] | | | | ------------------ | | | | 401| 5.04k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 276, False: 32.8k] | | | | ------------------ | | | | 402| 5.34k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 291, False: 32.7k] | | | | ------------------ | | | | 403| 5.65k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 319, False: 32.7k] | | | | ------------------ | | | | 404| 5.96k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 2385| 64.8k| ADD_NEW(state_offset + 1, 0); ------------------ | | 503| 5.96k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 5.95k, False: 10] | | ------------------ | | 504| 5.96k| { \ | | 505| 5.95k| next_new_state->offset = (x); \ | | 506| 5.95k| next_new_state->count = (y); \ | | 507| 5.95k| next_new_state++; \ | | 508| 5.95k| } \ | | 509| 5.96k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2386| 5.95k| break; 2387| | 2388| 27.1k| default: ------------------ | Branch (2388:9): [True: 27.1k, False: 5.96k] ------------------ 2389| 27.1k| break; 2390| 33.0k| } 2391| 39.4k| break; 2392| | 2393| | /*-----------------------------------------------------------------*/ 2394| | /* Match a negated single character casefully. */ 2395| | 2396| 39.4k| case OP_NOT: ------------------ | Branch (2396:7): [True: 14.9k, False: 8.91M] ------------------ 2397| 14.9k| if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); } ------------------ | | 503| 11.7k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 11.7k, False: 10] | | ------------------ | | 504| 11.7k| { \ | | 505| 11.7k| next_new_state->offset = (x); \ | | 506| 11.7k| next_new_state->count = (y); \ | | 507| 11.7k| next_new_state++; \ | | 508| 11.7k| } \ | | 509| 11.7k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (2397:11): [True: 13.6k, False: 1.23k] | Branch (2397:23): [True: 11.7k, False: 1.95k] ------------------ 2398| 14.8k| break; 2399| | 2400| | /*-----------------------------------------------------------------*/ 2401| | /* Match a negated single character caselessly. */ 2402| | 2403| 14.8k| case OP_NOTI: ------------------ | Branch (2403:7): [True: 11.4k, False: 8.92M] ------------------ 2404| 11.4k| if (clen > 0) ------------------ | Branch (2404:11): [True: 10.6k, False: 844] ------------------ 2405| 10.6k| { 2406| 10.6k| uint32_t otherd; 2407| 10.6k|#ifdef SUPPORT_UNICODE 2408| 10.6k| if (utf_or_ucp && d >= 128) ------------------ | Branch (2408:13): [True: 7.56k, False: 3.06k] | Branch (2408:27): [True: 1.16k, False: 6.40k] ------------------ 2409| 1.16k| otherd = UCD_OTHERCASE(d); ------------------ | | 1862| 1.16k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 1.16k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 1.16k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 1.16k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 1.16k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 1.16k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 1.16k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 1.16k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 1.16k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 1.16k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 1.16k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2410| 9.47k| else 2411| 9.47k|#endif /* SUPPORT_UNICODE */ 2412| 9.47k| otherd = TABLE_GET(d, fcc, d); ------------------ | | 214| 9.47k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 2413| 10.6k| if (c != d && c != otherd) ------------------ | Branch (2413:13): [True: 8.97k, False: 1.66k] | Branch (2413:23): [True: 8.12k, False: 846] ------------------ 2414| 8.12k| { ADD_NEW(state_offset + dlen + 1, 0); } ------------------ | | 503| 8.12k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 8.11k, False: 10] | | ------------------ | | 504| 8.12k| { \ | | 505| 8.11k| next_new_state->offset = (x); \ | | 506| 8.11k| next_new_state->count = (y); \ | | 507| 8.11k| next_new_state++; \ | | 508| 8.11k| } \ | | 509| 8.12k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2415| 10.6k| } 2416| 11.4k| break; 2417| | 2418| | /*-----------------------------------------------------------------*/ 2419| 11.4k| case OP_PLUSI: ------------------ | Branch (2419:7): [True: 8.90k, False: 8.92M] ------------------ 2420| 14.9k| case OP_MINPLUSI: ------------------ | Branch (2420:7): [True: 6.02k, False: 8.92M] ------------------ 2421| 21.4k| case OP_POSPLUSI: ------------------ | Branch (2421:7): [True: 6.49k, False: 8.92M] ------------------ 2422| 28.2k| case OP_NOTPLUSI: ------------------ | Branch (2422:7): [True: 6.87k, False: 8.92M] ------------------ 2423| 36.7k| case OP_NOTMINPLUSI: ------------------ | Branch (2423:7): [True: 8.46k, False: 8.92M] ------------------ 2424| 38.6k| case OP_NOTPOSPLUSI: ------------------ | Branch (2424:7): [True: 1.86k, False: 8.93M] ------------------ 2425| 38.6k| caseless = TRUE; ------------------ | | 70| 38.6k|#define TRUE 1 ------------------ 2426| 38.6k| codevalue -= OP_STARI - OP_STAR; 2427| | 2428| | /* Fall through */ 2429| 49.2k| case OP_PLUS: ------------------ | Branch (2429:7): [True: 10.6k, False: 8.92M] ------------------ 2430| 62.3k| case OP_MINPLUS: ------------------ | Branch (2430:7): [True: 13.1k, False: 8.92M] ------------------ 2431| 99.7k| case OP_POSPLUS: ------------------ | Branch (2431:7): [True: 37.3k, False: 8.89M] ------------------ 2432| 133k| case OP_NOTPLUS: ------------------ | Branch (2432:7): [True: 33.4k, False: 8.89M] ------------------ 2433| 151k| case OP_NOTMINPLUS: ------------------ | Branch (2433:7): [True: 18.7k, False: 8.91M] ------------------ 2434| 164k| case OP_NOTPOSPLUS: ------------------ | Branch (2434:7): [True: 12.8k, False: 8.92M] ------------------ 2435| 164k| count = current_state->count; /* Already matched */ 2436| 164k| if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); } ------------------ | | 484| 86.0k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 85.9k, False: 84] | | ------------------ | | 485| 86.0k| { \ | | 486| 85.9k| next_active_state->offset = (x); \ | | 487| 85.9k| next_active_state->count = (y); \ | | 488| 85.9k| next_active_state++; \ | | 489| 85.9k| } \ | | 490| 86.0k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 84|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (2436:11): [True: 86.0k, False: 78.7k] ------------------ 2437| 164k| if (clen > 0) ------------------ | Branch (2437:11): [True: 148k, False: 16.4k] ------------------ 2438| 148k| { 2439| 148k| uint32_t otherd = NOTACHAR; ------------------ | | 205| 148k|#define NOTACHAR 0xffffffff ------------------ 2440| 148k| if (caseless) ------------------ | Branch (2440:13): [True: 33.2k, False: 115k] ------------------ 2441| 33.2k| { 2442| 33.2k|#ifdef SUPPORT_UNICODE 2443| 33.2k| if (utf_or_ucp && d >= 128) ------------------ | Branch (2443:15): [True: 27.7k, False: 5.45k] | Branch (2443:29): [True: 7.06k, False: 20.7k] ------------------ 2444| 7.06k| otherd = UCD_OTHERCASE(d); ------------------ | | 1862| 7.06k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 7.06k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 7.06k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 7.06k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 7.06k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 7.06k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 7.06k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 7.06k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 7.06k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 7.06k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 7.06k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2445| 26.1k| else 2446| 26.1k|#endif /* SUPPORT_UNICODE */ 2447| 26.1k| otherd = TABLE_GET(d, fcc, d); ------------------ | | 214| 26.1k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 2448| 33.2k| } 2449| 148k| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) ------------------ | Branch (2449:13): [True: 87.6k, False: 60.5k] | Branch (2449:14): [True: 30.6k, False: 117k] | Branch (2449:24): [True: 1.14k, False: 116k] ------------------ 2450| 87.6k| { 2451| 87.6k| if (count > 0 && ------------------ | Branch (2451:15): [True: 56.2k, False: 31.4k] ------------------ 2452| 87.6k| (codevalue == OP_POSPLUS || codevalue == OP_NOTPOSPLUS)) ------------------ | Branch (2452:16): [True: 2.77k, False: 53.5k] | Branch (2452:43): [True: 8.24k, False: 45.2k] ------------------ 2453| 11.0k| { 2454| 11.0k| active_count--; /* Remove non-match possibility */ 2455| 11.0k| next_active_state--; 2456| 11.0k| } 2457| 87.6k| count++; 2458| 87.6k| ADD_NEW(state_offset, count); ------------------ | | 503| 87.6k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 87.6k, False: 10] | | ------------------ | | 504| 87.6k| { \ | | 505| 87.6k| next_new_state->offset = (x); \ | | 506| 87.6k| next_new_state->count = (y); \ | | 507| 87.6k| next_new_state++; \ | | 508| 87.6k| } \ | | 509| 87.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2459| 87.6k| } 2460| 148k| } 2461| 164k| break; 2462| | 2463| | /*-----------------------------------------------------------------*/ 2464| 164k| case OP_QUERYI: ------------------ | Branch (2464:7): [True: 6.05k, False: 8.92M] ------------------ 2465| 12.0k| case OP_MINQUERYI: ------------------ | Branch (2465:7): [True: 5.95k, False: 8.92M] ------------------ 2466| 14.4k| case OP_POSQUERYI: ------------------ | Branch (2466:7): [True: 2.42k, False: 8.93M] ------------------ 2467| 16.2k| case OP_NOTQUERYI: ------------------ | Branch (2467:7): [True: 1.78k, False: 8.93M] ------------------ 2468| 19.0k| case OP_NOTMINQUERYI: ------------------ | Branch (2468:7): [True: 2.88k, False: 8.93M] ------------------ 2469| 19.6k| case OP_NOTPOSQUERYI: ------------------ | Branch (2469:7): [True: 599, False: 8.93M] ------------------ 2470| 19.6k| caseless = TRUE; ------------------ | | 70| 19.6k|#define TRUE 1 ------------------ 2471| 19.6k| codevalue -= OP_STARI - OP_STAR; 2472| | /* Fall through */ 2473| 33.0k| case OP_QUERY: ------------------ | Branch (2473:7): [True: 13.3k, False: 8.91M] ------------------ 2474| 38.5k| case OP_MINQUERY: ------------------ | Branch (2474:7): [True: 5.43k, False: 8.92M] ------------------ 2475| 51.9k| case OP_POSQUERY: ------------------ | Branch (2475:7): [True: 13.4k, False: 8.91M] ------------------ 2476| 55.0k| case OP_NOTQUERY: ------------------ | Branch (2476:7): [True: 3.15k, False: 8.93M] ------------------ 2477| 57.0k| case OP_NOTMINQUERY: ------------------ | Branch (2477:7): [True: 1.97k, False: 8.93M] ------------------ 2478| 58.1k| case OP_NOTPOSQUERY: ------------------ | Branch (2478:7): [True: 1.09k, False: 8.93M] ------------------ 2479| 58.1k| ADD_ACTIVE(state_offset + dlen + 1, 0); ------------------ | | 484| 58.1k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 57.9k, False: 213] | | ------------------ | | 485| 58.1k| { \ | | 486| 57.9k| next_active_state->offset = (x); \ | | 487| 57.9k| next_active_state->count = (y); \ | | 488| 57.9k| next_active_state++; \ | | 489| 57.9k| } \ | | 490| 58.1k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 213|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2480| 57.9k| if (clen > 0) ------------------ | Branch (2480:11): [True: 52.0k, False: 5.87k] ------------------ 2481| 52.0k| { 2482| 52.0k| uint32_t otherd = NOTACHAR; ------------------ | | 205| 52.0k|#define NOTACHAR 0xffffffff ------------------ 2483| 52.0k| if (caseless) ------------------ | Branch (2483:13): [True: 17.7k, False: 34.3k] ------------------ 2484| 17.7k| { 2485| 17.7k|#ifdef SUPPORT_UNICODE 2486| 17.7k| if (utf_or_ucp && d >= 128) ------------------ | Branch (2486:15): [True: 14.7k, False: 2.92k] | Branch (2486:29): [True: 5.60k, False: 9.17k] ------------------ 2487| 5.60k| otherd = UCD_OTHERCASE(d); ------------------ | | 1862| 5.60k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 5.60k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 5.60k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 5.60k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 5.60k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 5.60k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 5.60k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 5.60k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 5.60k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 5.60k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 5.60k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2488| 12.1k| else 2489| 12.1k|#endif /* SUPPORT_UNICODE */ 2490| 12.1k| otherd = TABLE_GET(d, fcc, d); ------------------ | | 214| 12.1k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 2491| 17.7k| } 2492| 52.0k| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) ------------------ | Branch (2492:13): [True: 19.2k, False: 32.7k] | Branch (2492:14): [True: 12.3k, False: 39.6k] | Branch (2492:24): [True: 95, False: 39.5k] ------------------ 2493| 19.2k| { 2494| 19.2k| if (codevalue == OP_POSQUERY || codevalue == OP_NOTPOSQUERY) ------------------ | Branch (2494:15): [True: 4.03k, False: 15.2k] | Branch (2494:43): [True: 1.31k, False: 13.9k] ------------------ 2495| 5.34k| { 2496| 5.34k| active_count--; /* Remove non-match possibility */ 2497| 5.34k| next_active_state--; 2498| 5.34k| } 2499| 19.2k| ADD_NEW(state_offset + dlen + 1, 0); ------------------ | | 503| 19.2k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 19.2k, False: 10] | | ------------------ | | 504| 19.2k| { \ | | 505| 19.2k| next_new_state->offset = (x); \ | | 506| 19.2k| next_new_state->count = (y); \ | | 507| 19.2k| next_new_state++; \ | | 508| 19.2k| } \ | | 509| 19.2k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2500| 19.2k| } 2501| 52.0k| } 2502| 57.9k| break; 2503| | 2504| | /*-----------------------------------------------------------------*/ 2505| 57.9k| case OP_STARI: ------------------ | Branch (2505:7): [True: 10.8k, False: 8.92M] ------------------ 2506| 21.4k| case OP_MINSTARI: ------------------ | Branch (2506:7): [True: 10.6k, False: 8.92M] ------------------ 2507| 25.8k| case OP_POSSTARI: ------------------ | Branch (2507:7): [True: 4.40k, False: 8.92M] ------------------ 2508| 28.6k| case OP_NOTSTARI: ------------------ | Branch (2508:7): [True: 2.76k, False: 8.93M] ------------------ 2509| 32.5k| case OP_NOTMINSTARI: ------------------ | Branch (2509:7): [True: 3.85k, False: 8.92M] ------------------ 2510| 33.1k| case OP_NOTPOSSTARI: ------------------ | Branch (2510:7): [True: 688, False: 8.93M] ------------------ 2511| 33.1k| caseless = TRUE; ------------------ | | 70| 33.1k|#define TRUE 1 ------------------ 2512| 33.1k| codevalue -= OP_STARI - OP_STAR; 2513| | /* Fall through */ 2514| 49.0k| case OP_STAR: ------------------ | Branch (2514:7): [True: 15.8k, False: 8.91M] ------------------ 2515| 55.1k| case OP_MINSTAR: ------------------ | Branch (2515:7): [True: 6.09k, False: 8.92M] ------------------ 2516| 79.9k| case OP_POSSTAR: ------------------ | Branch (2516:7): [True: 24.7k, False: 8.90M] ------------------ 2517| 89.2k| case OP_NOTSTAR: ------------------ | Branch (2517:7): [True: 9.36k, False: 8.92M] ------------------ 2518| 94.6k| case OP_NOTMINSTAR: ------------------ | Branch (2518:7): [True: 5.35k, False: 8.92M] ------------------ 2519| 97.1k| case OP_NOTPOSSTAR: ------------------ | Branch (2519:7): [True: 2.48k, False: 8.93M] ------------------ 2520| 97.1k| ADD_ACTIVE(state_offset + dlen + 1, 0); ------------------ | | 484| 97.1k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 96.9k, False: 164] | | ------------------ | | 485| 97.1k| { \ | | 486| 96.9k| next_active_state->offset = (x); \ | | 487| 96.9k| next_active_state->count = (y); \ | | 488| 96.9k| next_active_state++; \ | | 489| 96.9k| } \ | | 490| 97.1k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 164|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2521| 96.9k| if (clen > 0) ------------------ | Branch (2521:11): [True: 88.1k, False: 8.79k] ------------------ 2522| 88.1k| { 2523| 88.1k| uint32_t otherd = NOTACHAR; ------------------ | | 205| 88.1k|#define NOTACHAR 0xffffffff ------------------ 2524| 88.1k| if (caseless) ------------------ | Branch (2524:13): [True: 29.8k, False: 58.2k] ------------------ 2525| 29.8k| { 2526| 29.8k|#ifdef SUPPORT_UNICODE 2527| 29.8k| if (utf_or_ucp && d >= 128) ------------------ | Branch (2527:15): [True: 26.3k, False: 3.58k] | Branch (2527:29): [True: 10.0k, False: 16.2k] ------------------ 2528| 10.0k| otherd = UCD_OTHERCASE(d); ------------------ | | 1862| 10.0k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 10.0k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 10.0k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 10.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 10.0k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 10.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 10.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 10.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 10.0k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 10.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 10.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2529| 19.7k| else 2530| 19.7k|#endif /* SUPPORT_UNICODE */ 2531| 19.7k| otherd = TABLE_GET(d, fcc, d); ------------------ | | 214| 19.7k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 2532| 29.8k| } 2533| 88.1k| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) ------------------ | Branch (2533:13): [True: 37.1k, False: 51.0k] | Branch (2533:14): [True: 21.4k, False: 66.7k] | Branch (2533:24): [True: 499, False: 66.2k] ------------------ 2534| 37.1k| { 2535| 37.1k| if (codevalue == OP_POSSTAR || codevalue == OP_NOTPOSSTAR) ------------------ | Branch (2535:15): [True: 6.42k, False: 30.6k] | Branch (2535:42): [True: 2.14k, False: 28.5k] ------------------ 2536| 8.56k| { 2537| 8.56k| active_count--; /* Remove non-match possibility */ 2538| 8.56k| next_active_state--; 2539| 8.56k| } 2540| 37.1k| ADD_NEW(state_offset, 0); ------------------ | | 503| 37.1k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 37.0k, False: 10] | | ------------------ | | 504| 37.1k| { \ | | 505| 37.0k| next_new_state->offset = (x); \ | | 506| 37.0k| next_new_state->count = (y); \ | | 507| 37.0k| next_new_state++; \ | | 508| 37.0k| } \ | | 509| 37.1k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2541| 37.1k| } 2542| 88.1k| } 2543| 96.9k| break; 2544| | 2545| | /*-----------------------------------------------------------------*/ 2546| 96.9k| case OP_EXACTI: ------------------ | Branch (2546:7): [True: 6.81k, False: 8.92M] ------------------ 2547| 16.0k| case OP_NOTEXACTI: ------------------ | Branch (2547:7): [True: 9.22k, False: 8.92M] ------------------ 2548| 16.0k| caseless = TRUE; ------------------ | | 70| 16.0k|#define TRUE 1 ------------------ 2549| 16.0k| codevalue -= OP_STARI - OP_STAR; 2550| | /* Fall through */ 2551| 23.9k| case OP_EXACT: ------------------ | Branch (2551:7): [True: 7.94k, False: 8.92M] ------------------ 2552| 38.3k| case OP_NOTEXACT: ------------------ | Branch (2552:7): [True: 14.3k, False: 8.91M] ------------------ 2553| 38.3k| count = current_state->count; /* Number already matched */ 2554| 38.3k| if (clen > 0) ------------------ | Branch (2554:11): [True: 34.9k, False: 3.40k] ------------------ 2555| 34.9k| { 2556| 34.9k| uint32_t otherd = NOTACHAR; ------------------ | | 205| 34.9k|#define NOTACHAR 0xffffffff ------------------ 2557| 34.9k| if (caseless) ------------------ | Branch (2557:13): [True: 14.4k, False: 20.4k] ------------------ 2558| 14.4k| { 2559| 14.4k|#ifdef SUPPORT_UNICODE 2560| 14.4k| if (utf_or_ucp && d >= 128) ------------------ | Branch (2560:15): [True: 8.79k, False: 5.64k] | Branch (2560:29): [True: 2.44k, False: 6.35k] ------------------ 2561| 2.44k| otherd = UCD_OTHERCASE(d); ------------------ | | 1862| 2.44k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 2.44k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 2.44k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 2.44k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 2.44k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 2.44k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 2.44k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 2.44k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 2.44k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 2.44k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 2.44k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2562| 11.9k| else 2563| 11.9k|#endif /* SUPPORT_UNICODE */ 2564| 11.9k| otherd = TABLE_GET(d, fcc, d); ------------------ | | 214| 11.9k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 2565| 14.4k| } 2566| 34.9k| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) ------------------ | Branch (2566:13): [True: 24.7k, False: 10.1k] | Branch (2566:14): [True: 8.44k, False: 26.4k] | Branch (2566:24): [True: 312, False: 26.1k] ------------------ 2567| 24.7k| { 2568| 24.7k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 24.7k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2568:15): [True: 4.07k, False: 20.6k] ------------------ 2569| 4.07k| { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); } ------------------ | | 503| 4.07k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 4.06k, False: 10] | | ------------------ | | 504| 4.07k| { \ | | 505| 4.06k| next_new_state->offset = (x); \ | | 506| 4.06k| next_new_state->count = (y); \ | | 507| 4.06k| next_new_state++; \ | | 508| 4.06k| } \ | | 509| 4.07k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2570| 20.6k| else 2571| 20.6k| { ADD_NEW(state_offset, count); } ------------------ | | 503| 20.6k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 20.6k, False: 10] | | ------------------ | | 504| 20.6k| { \ | | 505| 20.6k| next_new_state->offset = (x); \ | | 506| 20.6k| next_new_state->count = (y); \ | | 507| 20.6k| next_new_state++; \ | | 508| 20.6k| } \ | | 509| 20.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2572| 24.7k| } 2573| 34.9k| } 2574| 38.2k| break; 2575| | 2576| | /*-----------------------------------------------------------------*/ 2577| 38.2k| case OP_UPTOI: ------------------ | Branch (2577:7): [True: 963, False: 8.93M] ------------------ 2578| 1.43k| case OP_MINUPTOI: ------------------ | Branch (2578:7): [True: 471, False: 8.93M] ------------------ 2579| 1.85k| case OP_POSUPTOI: ------------------ | Branch (2579:7): [True: 423, False: 8.93M] ------------------ 2580| 5.87k| case OP_NOTUPTOI: ------------------ | Branch (2580:7): [True: 4.01k, False: 8.92M] ------------------ 2581| 6.98k| case OP_NOTMINUPTOI: ------------------ | Branch (2581:7): [True: 1.11k, False: 8.93M] ------------------ 2582| 10.3k| case OP_NOTPOSUPTOI: ------------------ | Branch (2582:7): [True: 3.37k, False: 8.92M] ------------------ 2583| 10.3k| caseless = TRUE; ------------------ | | 70| 10.3k|#define TRUE 1 ------------------ 2584| 10.3k| codevalue -= OP_STARI - OP_STAR; 2585| | /* Fall through */ 2586| 14.9k| case OP_UPTO: ------------------ | Branch (2586:7): [True: 4.62k, False: 8.92M] ------------------ 2587| 16.0k| case OP_MINUPTO: ------------------ | Branch (2587:7): [True: 1.03k, False: 8.93M] ------------------ 2588| 18.8k| case OP_POSUPTO: ------------------ | Branch (2588:7): [True: 2.81k, False: 8.93M] ------------------ 2589| 26.1k| case OP_NOTUPTO: ------------------ | Branch (2589:7): [True: 7.31k, False: 8.92M] ------------------ 2590| 27.1k| case OP_NOTMINUPTO: ------------------ | Branch (2590:7): [True: 1.05k, False: 8.93M] ------------------ 2591| 37.4k| case OP_NOTPOSUPTO: ------------------ | Branch (2591:7): [True: 10.2k, False: 8.92M] ------------------ 2592| 37.4k| ADD_ACTIVE(state_offset + dlen + 1 + IMM2_SIZE, 0); ------------------ | | 484| 37.4k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 37.4k, False: 20] | | ------------------ | | 485| 37.4k| { \ | | 486| 37.4k| next_active_state->offset = (x); \ | | 487| 37.4k| next_active_state->count = (y); \ | | 488| 37.4k| next_active_state++; \ | | 489| 37.4k| } \ | | 490| 37.4k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 20|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2593| 37.4k| count = current_state->count; /* Number already matched */ 2594| 37.4k| if (clen > 0) ------------------ | Branch (2594:11): [True: 35.6k, False: 1.75k] ------------------ 2595| 35.6k| { 2596| 35.6k| uint32_t otherd = NOTACHAR; ------------------ | | 205| 35.6k|#define NOTACHAR 0xffffffff ------------------ 2597| 35.6k| if (caseless) ------------------ | Branch (2597:13): [True: 9.85k, False: 25.7k] ------------------ 2598| 9.85k| { 2599| 9.85k|#ifdef SUPPORT_UNICODE 2600| 9.85k| if (utf_or_ucp && d >= 128) ------------------ | Branch (2600:15): [True: 5.49k, False: 4.36k] | Branch (2600:29): [True: 377, False: 5.11k] ------------------ 2601| 377| otherd = UCD_OTHERCASE(d); ------------------ | | 1862| 377|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 377|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 377|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 377|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 377| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 377|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 377|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 377|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 377| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 377|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 377|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2602| 9.48k| else 2603| 9.48k|#endif /* SUPPORT_UNICODE */ 2604| 9.48k| otherd = TABLE_GET(d, fcc, d); ------------------ | | 214| 9.48k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 2605| 9.85k| } 2606| 35.6k| if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR)) ------------------ | Branch (2606:13): [True: 25.9k, False: 9.72k] | Branch (2606:14): [True: 2.92k, False: 32.7k] | Branch (2606:24): [True: 12, False: 32.7k] ------------------ 2607| 25.9k| { 2608| 25.9k| if (codevalue == OP_POSUPTO || codevalue == OP_NOTPOSUPTO) ------------------ | Branch (2608:15): [True: 599, False: 25.3k] | Branch (2608:42): [True: 12.3k, False: 12.9k] ------------------ 2609| 12.9k| { 2610| 12.9k| active_count--; /* Remove non-match possibility */ 2611| 12.9k| next_active_state--; 2612| 12.9k| } 2613| 25.9k| if (++count >= (int)GET2(code, 1)) ------------------ | | 194| 25.9k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2613:15): [True: 5.40k, False: 20.5k] ------------------ 2614| 5.40k| { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); } ------------------ | | 503| 5.40k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 5.39k, False: 10] | | ------------------ | | 504| 5.40k| { \ | | 505| 5.39k| next_new_state->offset = (x); \ | | 506| 5.39k| next_new_state->count = (y); \ | | 507| 5.39k| next_new_state++; \ | | 508| 5.39k| } \ | | 509| 5.40k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2615| 20.5k| else 2616| 20.5k| { ADD_NEW(state_offset, count); } ------------------ | | 503| 20.5k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 20.5k, False: 10] | | ------------------ | | 504| 20.5k| { \ | | 505| 20.5k| next_new_state->offset = (x); \ | | 506| 20.5k| next_new_state->count = (y); \ | | 507| 20.5k| next_new_state++; \ | | 508| 20.5k| } \ | | 509| 20.5k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2617| 25.9k| } 2618| 35.6k| } 2619| 37.3k| break; 2620| | 2621| | 2622| |/* ========================================================================== */ 2623| | /* These are the class-handling opcodes */ 2624| | 2625| 126k| case OP_CLASS: ------------------ | Branch (2625:7): [True: 126k, False: 8.80M] ------------------ 2626| 277k| case OP_NCLASS: ------------------ | Branch (2626:7): [True: 151k, False: 8.78M] ------------------ 2627| 483k| case OP_XCLASS: ------------------ | Branch (2627:7): [True: 205k, False: 8.72M] ------------------ 2628| 483k| { 2629| 483k| BOOL isinclass = FALSE; ------------------ | | 69| 483k|#define FALSE 0 ------------------ 2630| 483k| int next_state_offset; 2631| 483k| PCRE2_SPTR ecode; ------------------ | | 814| 483k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 483k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 483k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 483k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2632| | 2633| | /* For a simple class, there is always just a 32-byte table, and we 2634| | can set isinclass from it. */ 2635| | 2636| 483k| if (codevalue != OP_XCLASS) ------------------ | Branch (2636:13): [True: 277k, False: 205k] ------------------ 2637| 277k| { 2638| 277k| ecode = code + 1 + (32 / sizeof(PCRE2_UCHAR)); 2639| 277k| if (clen > 0) ------------------ | Branch (2639:15): [True: 265k, False: 11.8k] ------------------ 2640| 265k| { 2641| 265k| isinclass = (c > 255)? (codevalue == OP_NCLASS) : ------------------ | Branch (2641:25): [True: 1.37k, False: 264k] ------------------ 2642| 265k| ((((uint8_t *)(code + 1))[c/8] & (1u << (c&7))) != 0); 2643| 265k| } 2644| 277k| } 2645| | 2646| | /* An extended class may have a table or a list of single characters, 2647| | ranges, or both, and it may be positive or negative. There's a 2648| | function that sorts all this out. */ 2649| | 2650| 205k| else 2651| 205k| { 2652| 205k| ecode = code + GET(code, 1); ------------------ | | 109| 205k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2653| 205k| if (clen > 0) isinclass = PRIV(xclass)(c, code + 1 + LINK_SIZE, utf); ------------------ | | 177| 200k|#define PRIV(name) _pcre2_##name ------------------ if (clen > 0) isinclass = PRIV(xclass)(c, code + 1 + LINK_SIZE, utf); ------------------ | | 165| 200k|#define LINK_SIZE 2 ------------------ | Branch (2653:14): [True: 200k, False: 5.19k] ------------------ 2654| 205k| } 2655| | 2656| | /* At this point, isinclass is set for all kinds of class, and ecode 2657| | points to the byte after the end of the class. If there is a 2658| | quantifier, this is where it will be. */ 2659| | 2660| 483k| next_state_offset = (int)(ecode - start_code); 2661| | 2662| 483k| switch (*ecode) 2663| 483k| { 2664| 30.6k| case OP_CRSTAR: ------------------ | Branch (2664:11): [True: 30.6k, False: 452k] ------------------ 2665| 42.5k| case OP_CRMINSTAR: ------------------ | Branch (2665:11): [True: 11.9k, False: 471k] ------------------ 2666| 54.4k| case OP_CRPOSSTAR: ------------------ | Branch (2666:11): [True: 11.8k, False: 471k] ------------------ 2667| 54.4k| ADD_ACTIVE(next_state_offset + 1, 0); ------------------ | | 484| 54.4k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 54.4k, False: 42] | | ------------------ | | 485| 54.4k| { \ | | 486| 54.4k| next_active_state->offset = (x); \ | | 487| 54.4k| next_active_state->count = (y); \ | | 488| 54.4k| next_active_state++; \ | | 489| 54.4k| } \ | | 490| 54.4k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 42|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2668| 54.4k| if (isinclass) ------------------ | Branch (2668:15): [True: 39.8k, False: 14.6k] ------------------ 2669| 39.8k| { 2670| 39.8k| if (*ecode == OP_CRPOSSTAR) ------------------ | Branch (2670:17): [True: 6.56k, False: 33.2k] ------------------ 2671| 6.56k| { 2672| 6.56k| active_count--; /* Remove non-match possibility */ 2673| 6.56k| next_active_state--; 2674| 6.56k| } 2675| 39.8k| ADD_NEW(state_offset, 0); ------------------ | | 503| 39.8k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 39.7k, False: 10] | | ------------------ | | 504| 39.8k| { \ | | 505| 39.7k| next_new_state->offset = (x); \ | | 506| 39.7k| next_new_state->count = (y); \ | | 507| 39.7k| next_new_state++; \ | | 508| 39.7k| } \ | | 509| 39.8k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2676| 39.8k| } 2677| 54.3k| break; 2678| | 2679| 54.3k| case OP_CRPLUS: ------------------ | Branch (2679:11): [True: 24.0k, False: 459k] ------------------ 2680| 41.7k| case OP_CRMINPLUS: ------------------ | Branch (2680:11): [True: 17.7k, False: 465k] ------------------ 2681| 60.0k| case OP_CRPOSPLUS: ------------------ | Branch (2681:11): [True: 18.3k, False: 464k] ------------------ 2682| 60.0k| count = current_state->count; /* Already matched */ 2683| 60.0k| if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); } ------------------ | | 484| 44.9k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 44.8k, False: 89] | | ------------------ | | 485| 44.9k| { \ | | 486| 44.8k| next_active_state->offset = (x); \ | | 487| 44.8k| next_active_state->count = (y); \ | | 488| 44.8k| next_active_state++; \ | | 489| 44.8k| } \ | | 490| 44.9k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 89|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (2683:15): [True: 44.9k, False: 15.1k] ------------------ 2684| 59.9k| if (isinclass) ------------------ | Branch (2684:15): [True: 45.7k, False: 14.2k] ------------------ 2685| 45.7k| { 2686| 45.7k| if (count > 0 && *ecode == OP_CRPOSPLUS) ------------------ | Branch (2686:17): [True: 35.9k, False: 9.77k] | Branch (2686:30): [True: 10.0k, False: 25.8k] ------------------ 2687| 10.0k| { 2688| 10.0k| active_count--; /* Remove non-match possibility */ 2689| 10.0k| next_active_state--; 2690| 10.0k| } 2691| 45.7k| count++; 2692| 45.7k| ADD_NEW(state_offset, count); ------------------ | | 503| 45.7k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 45.7k, False: 10] | | ------------------ | | 504| 45.7k| { \ | | 505| 45.7k| next_new_state->offset = (x); \ | | 506| 45.7k| next_new_state->count = (y); \ | | 507| 45.7k| next_new_state++; \ | | 508| 45.7k| } \ | | 509| 45.7k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2693| 45.7k| } 2694| 59.9k| break; 2695| | 2696| 59.9k| case OP_CRQUERY: ------------------ | Branch (2696:11): [True: 6.39k, False: 476k] ------------------ 2697| 10.0k| case OP_CRMINQUERY: ------------------ | Branch (2697:11): [True: 3.65k, False: 479k] ------------------ 2698| 13.6k| case OP_CRPOSQUERY: ------------------ | Branch (2698:11): [True: 3.60k, False: 479k] ------------------ 2699| 13.6k| ADD_ACTIVE(next_state_offset + 1, 0); ------------------ | | 484| 13.6k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 13.6k, False: 37] | | ------------------ | | 485| 13.6k| { \ | | 486| 13.6k| next_active_state->offset = (x); \ | | 487| 13.6k| next_active_state->count = (y); \ | | 488| 13.6k| next_active_state++; \ | | 489| 13.6k| } \ | | 490| 13.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 37|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2700| 13.6k| if (isinclass) ------------------ | Branch (2700:15): [True: 6.57k, False: 7.04k] ------------------ 2701| 6.57k| { 2702| 6.57k| if (*ecode == OP_CRPOSQUERY) ------------------ | Branch (2702:17): [True: 1.99k, False: 4.57k] ------------------ 2703| 1.99k| { 2704| 1.99k| active_count--; /* Remove non-match possibility */ 2705| 1.99k| next_active_state--; 2706| 1.99k| } 2707| 6.57k| ADD_NEW(next_state_offset + 1, 0); ------------------ | | 503| 6.57k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 6.56k, False: 10] | | ------------------ | | 504| 6.57k| { \ | | 505| 6.56k| next_new_state->offset = (x); \ | | 506| 6.56k| next_new_state->count = (y); \ | | 507| 6.56k| next_new_state++; \ | | 508| 6.56k| } \ | | 509| 6.57k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2708| 6.57k| } 2709| 13.6k| break; 2710| | 2711| 79.0k| case OP_CRRANGE: ------------------ | Branch (2711:11): [True: 79.0k, False: 404k] ------------------ 2712| 207k| case OP_CRMINRANGE: ------------------ | Branch (2712:11): [True: 128k, False: 354k] ------------------ 2713| 233k| case OP_CRPOSRANGE: ------------------ | Branch (2713:11): [True: 25.4k, False: 457k] ------------------ 2714| 233k| count = current_state->count; /* Already matched */ 2715| 233k| if (count >= (int)GET2(ecode, 1)) ------------------ | | 194| 233k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2715:15): [True: 26.6k, False: 206k] ------------------ 2716| 26.6k| { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); } ------------------ | | 484| 26.6k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 26.5k, False: 28] | | ------------------ | | 485| 26.6k| { \ | | 486| 26.5k| next_active_state->offset = (x); \ | | 487| 26.5k| next_active_state->count = (y); \ | | 488| 26.5k| next_active_state++; \ | | 489| 26.5k| } \ | | 490| 26.6k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 28|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2717| 233k| if (isinclass) ------------------ | Branch (2717:15): [True: 221k, False: 12.0k] ------------------ 2718| 221k| { 2719| 221k| int max = (int)GET2(ecode, 1 + IMM2_SIZE); ------------------ | | 194| 221k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2720| | 2721| 221k| if (*ecode == OP_CRPOSRANGE && count >= (int)GET2(ecode, 1)) ------------------ | | 194| 21.5k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2721:17): [True: 21.5k, False: 199k] | Branch (2721:44): [True: 15.9k, False: 5.64k] ------------------ 2722| 15.9k| { 2723| 15.9k| active_count--; /* Remove non-match possibility */ 2724| 15.9k| next_active_state--; 2725| 15.9k| } 2726| | 2727| 221k| if (++count >= max && max != 0) /* Max 0 => no limit */ ------------------ | Branch (2727:17): [True: 211k, False: 9.73k] | Branch (2727:35): [True: 785, False: 210k] ------------------ 2728| 785| { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); } ------------------ | | 503| 785| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 775, False: 10] | | ------------------ | | 504| 785| { \ | | 505| 775| next_new_state->offset = (x); \ | | 506| 775| next_new_state->count = (y); \ | | 507| 775| next_new_state++; \ | | 508| 775| } \ | | 509| 785| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2729| 220k| else 2730| 220k| { ADD_NEW(state_offset, count); } ------------------ | | 503| 220k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 220k, False: 10] | | ------------------ | | 504| 220k| { \ | | 505| 220k| next_new_state->offset = (x); \ | | 506| 220k| next_new_state->count = (y); \ | | 507| 220k| next_new_state++; \ | | 508| 220k| } \ | | 509| 220k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2731| 221k| } 2732| 233k| break; 2733| | 2734| 233k| default: ------------------ | Branch (2734:11): [True: 121k, False: 361k] ------------------ 2735| 121k| if (isinclass) { ADD_NEW(next_state_offset, 0); } ------------------ | | 503| 64.2k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 64.2k, False: 10] | | ------------------ | | 504| 64.2k| { \ | | 505| 64.2k| next_new_state->offset = (x); \ | | 506| 64.2k| next_new_state->count = (y); \ | | 507| 64.2k| next_new_state++; \ | | 508| 64.2k| } \ | | 509| 64.2k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ | Branch (2735:15): [True: 64.2k, False: 57.6k] ------------------ 2736| 121k| break; 2737| 483k| } 2738| 483k| } 2739| 483k| break; 2740| | 2741| |/* ========================================================================== */ 2742| | /* These are the opcodes for fancy brackets of various kinds. We have 2743| | to use recursion in order to handle them. The "always failing" assertion 2744| | (?!) is optimised to OP_FAIL when compiling, so we have to support that, 2745| | though the other "backtracking verbs" are not supported. */ 2746| | 2747| 483k| case OP_FAIL: ------------------ | Branch (2747:7): [True: 37.2k, False: 8.89M] ------------------ 2748| 37.2k| forced_fail++; /* Count FAILs for multiple states */ 2749| 37.2k| break; 2750| | 2751| 12.3k| case OP_ASSERT: ------------------ | Branch (2751:7): [True: 12.3k, False: 8.92M] ------------------ 2752| 26.5k| case OP_ASSERT_NOT: ------------------ | Branch (2752:7): [True: 14.2k, False: 8.91M] ------------------ 2753| 37.6k| case OP_ASSERTBACK: ------------------ | Branch (2753:7): [True: 11.0k, False: 8.92M] ------------------ 2754| 55.7k| case OP_ASSERTBACK_NOT: ------------------ | Branch (2754:7): [True: 18.1k, False: 8.91M] ------------------ 2755| 55.7k| { 2756| 55.7k| int rc; 2757| 55.7k| int *local_workspace; 2758| 55.7k| PCRE2_SIZE *local_offsets; ------------------ | | 477| 55.7k|#define PCRE2_SIZE size_t ------------------ 2759| 55.7k| PCRE2_SPTR endasscode = code + GET(code, 1); ------------------ | | 814| 55.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 55.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 55.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 55.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR endasscode = code + GET(code, 1); ------------------ | | 109| 55.7k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2760| 55.7k| RWS_anchor *rws = (RWS_anchor *)RWS; 2761| | 2762| 55.7k| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 320| 55.7k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 322| 55.7k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 55.7k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ | Branch (2762:13): [True: 1.35k, False: 54.3k] ------------------ 2763| 1.35k| { 2764| 1.35k| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); ------------------ | | 322| 1.35k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 1.35k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2765| 1.35k| if (rc != 0) return rc; ------------------ | Branch (2765:15): [True: 0, False: 1.35k] ------------------ 2766| 1.35k| RWS = (int *)rws; 2767| 1.35k| } 2768| | 2769| 55.7k| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); 2770| 55.7k| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; ------------------ | | 322| 55.7k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 55.7k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2771| 55.7k| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 55.7k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 55.7k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 55.7k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2772| | 2773| 128k| while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1); ------------------ | | 109| 128k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2773:16): [True: 72.3k, False: 55.7k] ------------------ 2774| | 2775| 55.7k| rc = internal_dfa_match( 2776| 55.7k| mb, /* static match data */ 2777| 55.7k| code, /* this subexpression's code */ 2778| 55.7k| ptr, /* where we currently are */ 2779| 55.7k| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ 2780| 55.7k| local_offsets, /* offset vector */ 2781| 55.7k| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 322| 55.7k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 55.7k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 317| 55.7k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) ------------------ 2782| 55.7k| local_workspace, /* workspace vector */ 2783| 55.7k| RWS_RSIZE, /* size of same */ ------------------ | | 320| 55.7k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ 2784| 55.7k| rlevel, /* function recursion level */ 2785| 55.7k| RWS); /* recursion workspace */ 2786| | 2787| 55.7k| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 55.7k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 55.7k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 55.7k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2788| | 2789| 55.7k| if (rc < 0 && rc != PCRE2_ERROR_NOMATCH) return rc; ------------------ | | 326| 40.8k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ | Branch (2789:13): [True: 40.8k, False: 14.8k] | Branch (2789:23): [True: 2.41k, False: 38.3k] ------------------ 2790| 53.2k| if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK)) ------------------ | Branch (2790:13): [True: 30.7k, False: 22.5k] | Branch (2790:27): [True: 11.4k, False: 41.8k] | Branch (2790:53): [True: 10.8k, False: 30.9k] ------------------ 2791| 30.7k| { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); } ------------------ | | 484| 30.7k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 30.3k, False: 328] | | ------------------ | | 485| 30.7k| { \ | | 486| 30.3k| next_active_state->offset = (x); \ | | 487| 30.3k| next_active_state->count = (y); \ | | 488| 30.3k| next_active_state++; \ | | 489| 30.3k| } \ | | 490| 30.7k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 328|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2792| 53.2k| } 2793| 52.9k| break; 2794| | 2795| | /*-----------------------------------------------------------------*/ 2796| 52.9k| case OP_COND: ------------------ | Branch (2796:7): [True: 28.5k, False: 8.90M] ------------------ 2797| 30.4k| case OP_SCOND: ------------------ | Branch (2797:7): [True: 1.86k, False: 8.93M] ------------------ 2798| 30.4k| { 2799| 30.4k| int codelink = (int)GET(code, 1); ------------------ | | 109| 30.4k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2800| 30.4k| PCRE2_UCHAR condcode; ------------------ | | 813| 30.4k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 30.4k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 30.4k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 30.4k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2801| | 2802| | /* Because of the way auto-callout works during compile, a callout item 2803| | is inserted between OP_COND and an assertion condition. This does not 2804| | happen for the other conditions. */ 2805| | 2806| 30.4k| if (code[LINK_SIZE + 1] == OP_CALLOUT ------------------ | | 165| 30.4k|#define LINK_SIZE 2 ------------------ | Branch (2806:13): [True: 1.88k, False: 28.5k] ------------------ 2807| 30.4k| || code[LINK_SIZE + 1] == OP_CALLOUT_STR) ------------------ | | 165| 28.5k|#define LINK_SIZE 2 ------------------ | Branch (2807:16): [True: 1.20k, False: 27.3k] ------------------ 2808| 3.09k| { 2809| 3.09k| PCRE2_SIZE callout_length; ------------------ | | 477| 3.09k|#define PCRE2_SIZE size_t ------------------ 2810| 3.09k| rrc = do_callout_dfa(code, offsets, current_subject, ptr, mb, 2811| 3.09k| 1 + LINK_SIZE, &callout_length); ------------------ | | 165| 3.09k|#define LINK_SIZE 2 ------------------ 2812| 3.09k| if (rrc < 0) return rrc; /* Abandon */ ------------------ | Branch (2812:15): [True: 15, False: 3.07k] ------------------ 2813| 3.07k| if (rrc > 0) break; /* Fail this thread */ ------------------ | Branch (2813:15): [True: 0, False: 3.07k] ------------------ 2814| 3.07k| code += callout_length; /* Skip callout data */ 2815| 3.07k| } 2816| | 2817| 30.4k| condcode = code[LINK_SIZE+1]; ------------------ | | 165| 30.4k|#define LINK_SIZE 2 ------------------ 2818| | 2819| | /* Back reference conditions and duplicate named recursion conditions 2820| | are not supported */ 2821| | 2822| 30.4k| if (condcode == OP_CREF || condcode == OP_DNCREF || ------------------ | Branch (2822:13): [True: 204, False: 30.1k] | Branch (2822:36): [True: 158, False: 30.0k] ------------------ 2823| 30.4k| condcode == OP_DNRREF) ------------------ | Branch (2823:13): [True: 136, False: 29.9k] ------------------ 2824| 498| return PCRE2_ERROR_DFA_UCOND; ------------------ | | 380| 498|#define PCRE2_ERROR_DFA_UCOND (-40) ------------------ 2825| | 2826| | /* The DEFINE condition is always false, and the assertion (?!) is 2827| | converted to OP_FAIL. */ 2828| | 2829| 29.9k| if (condcode == OP_FALSE || condcode == OP_FAIL) ------------------ | Branch (2829:13): [True: 7.04k, False: 22.8k] | Branch (2829:37): [True: 1.90k, False: 20.9k] ------------------ 2830| 8.95k| { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); } ------------------ | | 484| 8.95k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 8.92k, False: 28] | | ------------------ | | 485| 8.95k| { \ | | 486| 8.92k| next_active_state->offset = (x); \ | | 487| 8.92k| next_active_state->count = (y); \ | | 488| 8.92k| next_active_state++; \ | | 489| 8.92k| } \ | | 490| 8.95k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 28|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2831| | 2832| | /* There is also an always-true condition */ 2833| | 2834| 20.9k| else if (condcode == OP_TRUE) ------------------ | Branch (2834:18): [True: 5.74k, False: 15.2k] ------------------ 2835| 5.74k| { ADD_ACTIVE(state_offset + LINK_SIZE + 2, 0); } ------------------ | | 484| 5.74k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 5.72k, False: 18] | | ------------------ | | 485| 5.74k| { \ | | 486| 5.72k| next_active_state->offset = (x); \ | | 487| 5.72k| next_active_state->count = (y); \ | | 488| 5.72k| next_active_state++; \ | | 489| 5.72k| } \ | | 490| 5.74k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 18|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2836| | 2837| | /* The only supported version of OP_RREF is for the value RREF_ANY, 2838| | which means "test if in any recursion". We can't test for specifically 2839| | recursed groups. */ 2840| | 2841| 15.2k| else if (condcode == OP_RREF) ------------------ | Branch (2841:18): [True: 6.05k, False: 9.14k] ------------------ 2842| 6.05k| { 2843| 6.05k| unsigned int value = GET2(code, LINK_SIZE + 2); ------------------ | | 194| 6.05k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2844| 6.05k| if (value != RREF_ANY) return PCRE2_ERROR_DFA_UCOND; ------------------ | | 1789| 6.05k|#define RREF_ANY 0xffff ------------------ if (value != RREF_ANY) return PCRE2_ERROR_DFA_UCOND; ------------------ | | 380| 136|#define PCRE2_ERROR_DFA_UCOND (-40) ------------------ | Branch (2844:15): [True: 136, False: 5.92k] ------------------ 2845| 5.92k| if (mb->recursive != NULL) ------------------ | Branch (2845:15): [True: 1.73k, False: 4.18k] ------------------ 2846| 1.73k| { ADD_ACTIVE(state_offset + LINK_SIZE + 2 + IMM2_SIZE, 0); } ------------------ | | 484| 1.73k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 1.72k, False: 10] | | ------------------ | | 485| 1.73k| { \ | | 486| 1.72k| next_active_state->offset = (x); \ | | 487| 1.72k| next_active_state->count = (y); \ | | 488| 1.72k| next_active_state++; \ | | 489| 1.72k| } \ | | 490| 1.73k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2847| 4.18k| else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); } ------------------ | | 484| 4.18k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 4.16k, False: 23] | | ------------------ | | 485| 4.18k| { \ | | 486| 4.16k| next_active_state->offset = (x); \ | | 487| 4.16k| next_active_state->count = (y); \ | | 488| 4.16k| next_active_state++; \ | | 489| 4.16k| } \ | | 490| 4.18k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 23|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2848| 5.92k| } 2849| | 2850| | /* Otherwise, the condition is an assertion */ 2851| | 2852| 9.14k| else 2853| 9.14k| { 2854| 9.14k| int rc; 2855| 9.14k| int *local_workspace; 2856| 9.14k| PCRE2_SIZE *local_offsets; ------------------ | | 477| 9.14k|#define PCRE2_SIZE size_t ------------------ 2857| 9.14k| PCRE2_SPTR asscode = code + LINK_SIZE + 1; ------------------ | | 814| 9.14k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 9.14k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 9.14k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 9.14k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR asscode = code + LINK_SIZE + 1; ------------------ | | 165| 9.14k|#define LINK_SIZE 2 ------------------ 2858| 9.14k| PCRE2_SPTR endasscode = asscode + GET(asscode, 1); ------------------ | | 814| 9.14k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 9.14k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 9.14k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 9.14k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR endasscode = asscode + GET(asscode, 1); ------------------ | | 109| 9.14k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2859| 9.14k| RWS_anchor *rws = (RWS_anchor *)RWS; 2860| | 2861| 9.14k| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 320| 9.14k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 322| 9.14k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 9.14k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ | Branch (2861:15): [True: 560, False: 8.58k] ------------------ 2862| 560| { 2863| 560| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); ------------------ | | 322| 560|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 560|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2864| 560| if (rc != 0) return rc; ------------------ | Branch (2864:17): [True: 0, False: 560] ------------------ 2865| 560| RWS = (int *)rws; 2866| 560| } 2867| | 2868| 9.14k| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); 2869| 9.14k| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; ------------------ | | 322| 9.14k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 9.14k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2870| 9.14k| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 9.14k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 9.14k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 9.14k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2871| | 2872| 12.6k| while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1); ------------------ | | 109| 12.6k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (2872:18): [True: 3.47k, False: 9.14k] ------------------ 2873| | 2874| 9.14k| rc = internal_dfa_match( 2875| 9.14k| mb, /* fixed match data */ 2876| 9.14k| asscode, /* this subexpression's code */ 2877| 9.14k| ptr, /* where we currently are */ 2878| 9.14k| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ 2879| 9.14k| local_offsets, /* offset vector */ 2880| 9.14k| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 322| 9.14k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 9.14k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 317| 9.14k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) ------------------ 2881| 9.14k| local_workspace, /* workspace vector */ 2882| 9.14k| RWS_RSIZE, /* size of same */ ------------------ | | 320| 9.14k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ 2883| 9.14k| rlevel, /* function recursion level */ 2884| 9.14k| RWS); /* recursion workspace */ 2885| | 2886| 9.14k| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 9.14k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 9.14k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 9.14k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2887| | 2888| 9.14k| if (rc < 0 && rc != PCRE2_ERROR_NOMATCH) return rc; ------------------ | | 326| 6.33k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ | Branch (2888:15): [True: 6.33k, False: 2.81k] | Branch (2888:25): [True: 1.10k, False: 5.22k] ------------------ 2889| 8.03k| if ((rc >= 0) == ------------------ | Branch (2889:15): [True: 3.51k, False: 4.52k] ------------------ 2890| 8.03k| (condcode == OP_ASSERT || condcode == OP_ASSERTBACK)) ------------------ | Branch (2890:18): [True: 6.22k, False: 1.81k] | Branch (2890:43): [True: 358, False: 1.45k] ------------------ 2891| 3.51k| { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); } ------------------ | | 484| 3.51k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 3.50k, False: 10] | | ------------------ | | 485| 3.51k| { \ | | 486| 3.50k| next_active_state->offset = (x); \ | | 487| 3.50k| next_active_state->count = (y); \ | | 488| 3.50k| next_active_state++; \ | | 489| 3.50k| } \ | | 490| 3.51k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2892| 4.52k| else 2893| 4.52k| { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); } ------------------ | | 484| 4.52k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 4.50k, False: 16] | | ------------------ | | 485| 4.52k| { \ | | 486| 4.50k| next_active_state->offset = (x); \ | | 487| 4.50k| next_active_state->count = (y); \ | | 488| 4.50k| next_active_state++; \ | | 489| 4.50k| } \ | | 490| 4.52k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 16|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2894| 8.03k| } 2895| 29.9k| } 2896| 28.5k| break; 2897| | 2898| | /*-----------------------------------------------------------------*/ 2899| 121k| case OP_RECURSE: ------------------ | Branch (2899:7): [True: 121k, False: 8.81M] ------------------ 2900| 121k| { 2901| 121k| int rc; 2902| 121k| int *local_workspace; 2903| 121k| PCRE2_SIZE *local_offsets; ------------------ | | 477| 121k|#define PCRE2_SIZE size_t ------------------ 2904| 121k| RWS_anchor *rws = (RWS_anchor *)RWS; 2905| 121k| dfa_recursion_info *ri; 2906| 121k| PCRE2_SPTR callpat = start_code + GET(code, 1); ------------------ | | 814| 121k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 121k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 121k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 121k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR callpat = start_code + GET(code, 1); ------------------ | | 109| 121k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2907| 121k| uint32_t recno = (callpat == mb->start_code)? 0 : ------------------ | Branch (2907:26): [True: 99.1k, False: 22.0k] ------------------ 2908| 121k| GET2(callpat, 1 + LINK_SIZE); ------------------ | | 194| 22.0k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2909| | 2910| 121k| if (rws->free < RWS_RSIZE + RWS_OVEC_RSIZE) ------------------ | | 320| 121k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ if (rws->free < RWS_RSIZE + RWS_OVEC_RSIZE) ------------------ | | 321| 121k|#define RWS_OVEC_RSIZE (1000*OVEC_UNIT) /* Ovector for recursion */ | | ------------------ | | | | 317| 121k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ | Branch (2910:13): [True: 13.5k, False: 107k] ------------------ 2911| 13.5k| { 2912| 13.5k| rc = more_workspace(&rws, RWS_OVEC_RSIZE, mb); ------------------ | | 321| 13.5k|#define RWS_OVEC_RSIZE (1000*OVEC_UNIT) /* Ovector for recursion */ | | ------------------ | | | | 317| 13.5k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2913| 13.5k| if (rc != 0) return rc; ------------------ | Branch (2913:15): [True: 0, False: 13.5k] ------------------ 2914| 13.5k| RWS = (int *)rws; 2915| 13.5k| } 2916| | 2917| 121k| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); 2918| 121k| local_workspace = ((int *)local_offsets) + RWS_OVEC_RSIZE; ------------------ | | 321| 121k|#define RWS_OVEC_RSIZE (1000*OVEC_UNIT) /* Ovector for recursion */ | | ------------------ | | | | 317| 121k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2919| 121k| rws->free -= RWS_RSIZE + RWS_OVEC_RSIZE; ------------------ | | 320| 121k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free -= RWS_RSIZE + RWS_OVEC_RSIZE; ------------------ | | 321| 121k|#define RWS_OVEC_RSIZE (1000*OVEC_UNIT) /* Ovector for recursion */ | | ------------------ | | | | 317| 121k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2920| | 2921| | /* Check for repeating a recursion without advancing the subject 2922| | pointer. This should catch convoluted mutual recursions. (Some simple 2923| | cases are caught at compile time.) */ 2924| | 2925| 739k| for (ri = mb->recursive; ri != NULL; ri = ri->prevrec) ------------------ | Branch (2925:34): [True: 618k, False: 120k] ------------------ 2926| 618k| if (recno == ri->group_num && ptr == ri->subject_position) ------------------ | Branch (2926:15): [True: 574k, False: 44.2k] | Branch (2926:41): [True: 911, False: 573k] ------------------ 2927| 911| return PCRE2_ERROR_RECURSELOOP; ------------------ | | 392| 122k|#define PCRE2_ERROR_RECURSELOOP (-52) ------------------ 2928| | 2929| | /* Remember this recursion and where we started it so as to 2930| | catch infinite loops. */ 2931| | 2932| 120k| new_recursive.group_num = recno; 2933| 120k| new_recursive.subject_position = ptr; 2934| 120k| new_recursive.prevrec = mb->recursive; 2935| 120k| mb->recursive = &new_recursive; 2936| | 2937| 120k| rc = internal_dfa_match( 2938| 120k| mb, /* fixed match data */ 2939| 120k| callpat, /* this subexpression's code */ 2940| 120k| ptr, /* where we currently are */ 2941| 120k| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ 2942| 120k| local_offsets, /* offset vector */ 2943| 120k| RWS_OVEC_RSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 321| 120k|#define RWS_OVEC_RSIZE (1000*OVEC_UNIT) /* Ovector for recursion */ | | ------------------ | | | | 317| 120k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ RWS_OVEC_RSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 317| 120k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) ------------------ 2944| 120k| local_workspace, /* workspace vector */ 2945| 120k| RWS_RSIZE, /* size of same */ ------------------ | | 320| 120k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ 2946| 120k| rlevel, /* function recursion level */ 2947| 120k| RWS); /* recursion workspace */ 2948| | 2949| 120k| rws->free += RWS_RSIZE + RWS_OVEC_RSIZE; ------------------ | | 320| 120k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free += RWS_RSIZE + RWS_OVEC_RSIZE; ------------------ | | 321| 120k|#define RWS_OVEC_RSIZE (1000*OVEC_UNIT) /* Ovector for recursion */ | | ------------------ | | | | 317| 120k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 2950| 120k| mb->recursive = new_recursive.prevrec; /* Done this recursion */ 2951| | 2952| | /* Ran out of internal offsets */ 2953| | 2954| 120k| if (rc == 0) return PCRE2_ERROR_DFA_RECURSE; ------------------ | | 379| 10|#define PCRE2_ERROR_DFA_RECURSE (-39) ------------------ | Branch (2954:13): [True: 10, False: 120k] ------------------ 2955| | 2956| | /* For each successful matched substring, set up the next state with a 2957| | count of characters to skip before trying it. Note that the count is in 2958| | characters, not bytes. */ 2959| | 2960| 120k| if (rc > 0) ------------------ | Branch (2960:13): [True: 22.7k, False: 97.4k] ------------------ 2961| 22.7k| { 2962| 96.7k| for (rc = rc*2 - 2; rc >= 0; rc -= 2) ------------------ | Branch (2962:31): [True: 74.0k, False: 22.7k] ------------------ 2963| 74.0k| { 2964| 74.0k| PCRE2_SIZE charcount = local_offsets[rc+1] - local_offsets[rc]; ------------------ | | 477| 74.0k|#define PCRE2_SIZE size_t ------------------ 2965| 74.0k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 2966| 74.0k| if (utf) ------------------ | Branch (2966:17): [True: 16.7k, False: 57.2k] ------------------ 2967| 16.7k| { 2968| 16.7k| PCRE2_SPTR p = start_subject + local_offsets[rc]; ------------------ | | 814| 16.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 16.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 16.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 16.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2969| 16.7k| PCRE2_SPTR pp = start_subject + local_offsets[rc+1]; ------------------ | | 814| 16.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 16.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 16.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 16.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2970| 78.0k| while (p < pp) if (NOT_FIRSTCU(*p++)) charcount--; ------------------ | | 296| 61.2k|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 1.02k, False: 60.2k] | | ------------------ ------------------ | Branch (2970:22): [True: 61.2k, False: 16.7k] ------------------ 2971| 16.7k| } 2972| 74.0k|#endif 2973| 74.0k| if (charcount > 0) ------------------ | Branch (2973:17): [True: 58.0k, False: 16.0k] ------------------ 2974| 58.0k| { 2975| 58.0k| ADD_NEW_DATA(-(state_offset + LINK_SIZE + 1), 0, ------------------ | | 512| 58.0k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 57.9k, False: 36] | | ------------------ | | 513| 58.0k| { \ | | 514| 57.9k| next_new_state->offset = (x); \ | | 515| 57.9k| next_new_state->count = (y); \ | | 516| 57.9k| next_new_state->data = (z); \ | | 517| 57.9k| next_new_state++; \ | | 518| 57.9k| } \ | | 519| 58.0k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 36|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2976| 58.0k| (int)(charcount - 1)); 2977| 58.0k| } 2978| 16.0k| else 2979| 16.0k| { 2980| 16.0k| ADD_ACTIVE(state_offset + LINK_SIZE + 1, 0); ------------------ | | 484| 16.0k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 15.9k, False: 25] | | ------------------ | | 485| 16.0k| { \ | | 486| 15.9k| next_active_state->offset = (x); \ | | 487| 15.9k| next_active_state->count = (y); \ | | 488| 15.9k| next_active_state++; \ | | 489| 15.9k| } \ | | 490| 16.0k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 25|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 2981| 16.0k| } 2982| 74.0k| } 2983| 22.7k| } 2984| 97.4k| else if (rc != PCRE2_ERROR_NOMATCH) return rc; ------------------ | | 326| 97.4k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ | Branch (2984:18): [True: 13.1k, False: 84.3k] ------------------ 2985| 120k| } 2986| 107k| break; 2987| | 2988| | /*-----------------------------------------------------------------*/ 2989| 107k| case OP_BRAPOS: ------------------ | Branch (2989:7): [True: 1.86k, False: 8.93M] ------------------ 2990| 4.68k| case OP_SBRAPOS: ------------------ | Branch (2990:7): [True: 2.81k, False: 8.93M] ------------------ 2991| 7.92k| case OP_CBRAPOS: ------------------ | Branch (2991:7): [True: 3.23k, False: 8.93M] ------------------ 2992| 11.9k| case OP_SCBRAPOS: ------------------ | Branch (2992:7): [True: 4.01k, False: 8.92M] ------------------ 2993| 25.5k| case OP_BRAPOSZERO: ------------------ | Branch (2993:7): [True: 13.5k, False: 8.91M] ------------------ 2994| 25.5k| { 2995| 25.5k| int rc; 2996| 25.5k| int *local_workspace; 2997| 25.5k| PCRE2_SIZE *local_offsets; ------------------ | | 477| 25.5k|#define PCRE2_SIZE size_t ------------------ 2998| 25.5k| PCRE2_SIZE charcount, matched_count; ------------------ | | 477| 25.5k|#define PCRE2_SIZE size_t ------------------ 2999| 25.5k| PCRE2_SPTR local_ptr = ptr; ------------------ | | 814| 25.5k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 25.5k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 25.5k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 25.5k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3000| 25.5k| RWS_anchor *rws = (RWS_anchor *)RWS; 3001| 25.5k| BOOL allow_zero; 3002| | 3003| 25.5k| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 320| 25.5k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 322| 25.5k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 25.5k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ | Branch (3003:13): [True: 801, False: 24.7k] ------------------ 3004| 801| { 3005| 801| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); ------------------ | | 322| 801|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 801|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3006| 801| if (rc != 0) return rc; ------------------ | Branch (3006:15): [True: 0, False: 801] ------------------ 3007| 801| RWS = (int *)rws; 3008| 801| } 3009| | 3010| 25.5k| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); 3011| 25.5k| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; ------------------ | | 322| 25.5k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 25.5k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3012| 25.5k| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 25.5k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 25.5k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 25.5k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3013| | 3014| 25.5k| if (codevalue == OP_BRAPOSZERO) ------------------ | Branch (3014:13): [True: 13.5k, False: 11.9k] ------------------ 3015| 13.5k| { 3016| 13.5k| allow_zero = TRUE; ------------------ | | 70| 13.5k|#define TRUE 1 ------------------ 3017| 13.5k| codevalue = *(++code); /* Codevalue will be one of above BRAs */ 3018| 13.5k| } 3019| 11.9k| else allow_zero = FALSE; ------------------ | | 69| 11.9k|#define FALSE 0 ------------------ 3020| | 3021| | /* Loop to match the subpattern as many times as possible as if it were 3022| | a complete pattern. */ 3023| | 3024| 25.5k| for (matched_count = 0;; matched_count++) 3025| 32.3k| { 3026| 32.3k| rc = internal_dfa_match( 3027| 32.3k| mb, /* fixed match data */ 3028| 32.3k| code, /* this subexpression's code */ 3029| 32.3k| local_ptr, /* where we currently are */ 3030| 32.3k| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ 3031| 32.3k| local_offsets, /* offset vector */ 3032| 32.3k| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 322| 32.3k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 32.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 317| 32.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) ------------------ 3033| 32.3k| local_workspace, /* workspace vector */ 3034| 32.3k| RWS_RSIZE, /* size of same */ ------------------ | | 320| 32.3k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ 3035| 32.3k| rlevel, /* function recursion level */ 3036| 32.3k| RWS); /* recursion workspace */ 3037| | 3038| | /* Failed to match */ 3039| | 3040| 32.3k| if (rc < 0) ------------------ | Branch (3040:15): [True: 20.6k, False: 11.6k] ------------------ 3041| 20.6k| { 3042| 20.6k| if (rc != PCRE2_ERROR_NOMATCH) return rc; ------------------ | | 326| 20.6k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ | Branch (3042:17): [True: 2.03k, False: 18.6k] ------------------ 3043| 18.6k| break; 3044| 20.6k| } 3045| | 3046| | /* Matched: break the loop if zero characters matched. */ 3047| | 3048| 11.6k| charcount = local_offsets[1] - local_offsets[0]; 3049| 11.6k| if (charcount == 0) break; ------------------ | Branch (3049:15): [True: 4.82k, False: 6.82k] ------------------ 3050| 6.82k| local_ptr += charcount; /* Advance temporary position ptr */ 3051| 6.82k| } 3052| | 3053| 23.4k| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 23.4k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 23.4k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 23.4k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3054| | 3055| | /* At this point we have matched the subpattern matched_count 3056| | times, and local_ptr is pointing to the character after the end of the 3057| | last match. */ 3058| | 3059| 23.4k| if (matched_count > 0 || allow_zero) ------------------ | Branch (3059:13): [True: 3.49k, False: 19.9k] | Branch (3059:34): [True: 10.4k, False: 9.56k] ------------------ 3060| 13.9k| { 3061| 13.9k| PCRE2_SPTR end_subpattern = code; ------------------ | | 814| 13.9k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 13.9k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 13.9k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 13.9k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3062| 13.9k| int next_state_offset; 3063| | 3064| 14.5k| do { end_subpattern += GET(end_subpattern, 1); } ------------------ | | 109| 14.5k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 3065| 14.5k| while (*end_subpattern == OP_ALT); ------------------ | Branch (3065:20): [True: 604, False: 13.9k] ------------------ 3066| 13.9k| next_state_offset = 3067| 13.9k| (int)(end_subpattern - start_code + LINK_SIZE + 1); ------------------ | | 165| 13.9k|#define LINK_SIZE 2 ------------------ 3068| | 3069| | /* Optimization: if there are no more active states, and there 3070| | are no new states yet set up, then skip over the subject string 3071| | right here, to save looping. Otherwise, set up the new state to swing 3072| | into action when the end of the matched substring is reached. */ 3073| | 3074| 13.9k| if (i + 1 >= active_count && new_count == 0) ------------------ | Branch (3074:15): [True: 11.0k, False: 2.86k] | Branch (3074:40): [True: 8.59k, False: 2.46k] ------------------ 3075| 8.59k| { 3076| 8.59k| ptr = local_ptr; 3077| 8.59k| clen = 0; 3078| 8.59k| ADD_NEW(next_state_offset, 0); ------------------ | | 503| 8.59k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 8.59k, False: 0] | | ------------------ | | 504| 8.59k| { \ | | 505| 8.59k| next_new_state->offset = (x); \ | | 506| 8.59k| next_new_state->count = (y); \ | | 507| 8.59k| next_new_state++; \ | | 508| 8.59k| } \ | | 509| 8.59k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 0|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3079| 8.59k| } 3080| 5.32k| else 3081| 5.32k| { 3082| 5.32k| PCRE2_SPTR p = ptr; ------------------ | | 814| 5.32k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 5.32k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 5.32k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 5.32k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3083| 5.32k| PCRE2_SPTR pp = local_ptr; ------------------ | | 814| 5.32k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 5.32k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 5.32k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 5.32k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3084| 5.32k| charcount = (PCRE2_SIZE)(pp - p); 3085| 5.32k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3086| 6.09k| if (utf) while (p < pp) if (NOT_FIRSTCU(*p++)) charcount--; ------------------ | | 296| 3.73k|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 252, False: 3.48k] | | ------------------ ------------------ | Branch (3086:17): [True: 2.36k, False: 2.96k] | Branch (3086:29): [True: 3.73k, False: 2.36k] ------------------ 3087| 5.32k|#endif 3088| 5.32k| ADD_NEW_DATA(-next_state_offset, 0, (int)(charcount - 1)); ------------------ | | 512| 5.32k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 5.31k, False: 10] | | ------------------ | | 513| 5.32k| { \ | | 514| 5.31k| next_new_state->offset = (x); \ | | 515| 5.31k| next_new_state->count = (y); \ | | 516| 5.31k| next_new_state->data = (z); \ | | 517| 5.31k| next_new_state++; \ | | 518| 5.31k| } \ | | 519| 5.32k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3089| 5.32k| } 3090| 13.9k| } 3091| 23.4k| } 3092| 23.4k| break; 3093| | 3094| | /*-----------------------------------------------------------------*/ 3095| 23.4k| case OP_ONCE: ------------------ | Branch (3095:7): [True: 15.3k, False: 8.91M] ------------------ 3096| 15.3k| { 3097| 15.3k| int rc; 3098| 15.3k| int *local_workspace; 3099| 15.3k| PCRE2_SIZE *local_offsets; ------------------ | | 477| 15.3k|#define PCRE2_SIZE size_t ------------------ 3100| 15.3k| RWS_anchor *rws = (RWS_anchor *)RWS; 3101| | 3102| 15.3k| if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 320| 15.3k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ if (rws->free < RWS_RSIZE + RWS_OVEC_OSIZE) ------------------ | | 322| 15.3k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 15.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ | Branch (3102:13): [True: 615, False: 14.7k] ------------------ 3103| 615| { 3104| 615| rc = more_workspace(&rws, RWS_OVEC_OSIZE, mb); ------------------ | | 322| 615|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 615|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3105| 615| if (rc != 0) return rc; ------------------ | Branch (3105:15): [True: 0, False: 615] ------------------ 3106| 615| RWS = (int *)rws; 3107| 615| } 3108| | 3109| 15.3k| local_offsets = (PCRE2_SIZE *)(RWS + rws->size - rws->free); 3110| 15.3k| local_workspace = ((int *)local_offsets) + RWS_OVEC_OSIZE; ------------------ | | 322| 15.3k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 15.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3111| 15.3k| rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 15.3k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free -= RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 15.3k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 15.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3112| | 3113| 15.3k| rc = internal_dfa_match( 3114| 15.3k| mb, /* fixed match data */ 3115| 15.3k| code, /* this subexpression's code */ 3116| 15.3k| ptr, /* where we currently are */ 3117| 15.3k| (PCRE2_SIZE)(ptr - start_subject), /* start offset */ 3118| 15.3k| local_offsets, /* offset vector */ 3119| 15.3k| RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 322| 15.3k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 15.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ RWS_OVEC_OSIZE/OVEC_UNIT, /* size of same */ ------------------ | | 317| 15.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) ------------------ 3120| 15.3k| local_workspace, /* workspace vector */ 3121| 15.3k| RWS_RSIZE, /* size of same */ ------------------ | | 320| 15.3k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ 3122| 15.3k| rlevel, /* function recursion level */ 3123| 15.3k| RWS); /* recursion workspace */ 3124| | 3125| 15.3k| rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 320| 15.3k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ rws->free += RWS_RSIZE + RWS_OVEC_OSIZE; ------------------ | | 322| 15.3k|#define RWS_OVEC_OSIZE (2*OVEC_UNIT) /* Ovector in other cases */ | | ------------------ | | | | 317| 15.3k|#define OVEC_UNIT (sizeof(PCRE2_SIZE)/sizeof(int)) | | ------------------ ------------------ 3126| | 3127| 15.3k| if (rc >= 0) ------------------ | Branch (3127:13): [True: 7.67k, False: 7.68k] ------------------ 3128| 7.67k| { 3129| 7.67k| PCRE2_SPTR end_subpattern = code; ------------------ | | 814| 7.67k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 7.67k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 7.67k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 7.67k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3130| 7.67k| PCRE2_SIZE charcount = local_offsets[1] - local_offsets[0]; ------------------ | | 477| 7.67k|#define PCRE2_SIZE size_t ------------------ 3131| 7.67k| int next_state_offset, repeat_state_offset; 3132| | 3133| 9.41k| do { end_subpattern += GET(end_subpattern, 1); } ------------------ | | 109| 9.41k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 3134| 9.41k| while (*end_subpattern == OP_ALT); ------------------ | Branch (3134:20): [True: 1.74k, False: 7.67k] ------------------ 3135| 7.67k| next_state_offset = 3136| 7.67k| (int)(end_subpattern - start_code + LINK_SIZE + 1); ------------------ | | 165| 7.67k|#define LINK_SIZE 2 ------------------ 3137| | 3138| | /* If the end of this subpattern is KETRMAX or KETRMIN, we must 3139| | arrange for the repeat state also to be added to the relevant list. 3140| | Calculate the offset, or set -1 for no repeat. */ 3141| | 3142| 7.67k| repeat_state_offset = (*end_subpattern == OP_KETRMAX || ------------------ | Branch (3142:34): [True: 1.54k, False: 6.12k] ------------------ 3143| 7.67k| *end_subpattern == OP_KETRMIN)? ------------------ | Branch (3143:34): [True: 396, False: 5.73k] ------------------ 3144| 5.73k| (int)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1; ------------------ | | 109| 1.94k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 3145| | 3146| | /* If we have matched an empty string, add the next state at the 3147| | current character pointer. This is important so that the duplicate 3148| | checking kicks in, which is what breaks infinite loops that match an 3149| | empty string. */ 3150| | 3151| 7.67k| if (charcount == 0) ------------------ | Branch (3151:15): [True: 3.50k, False: 4.17k] ------------------ 3152| 3.50k| { 3153| 3.50k| ADD_ACTIVE(next_state_offset, 0); ------------------ | | 484| 3.50k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 3.48k, False: 27] | | ------------------ | | 485| 3.50k| { \ | | 486| 3.48k| next_active_state->offset = (x); \ | | 487| 3.48k| next_active_state->count = (y); \ | | 488| 3.48k| next_active_state++; \ | | 489| 3.48k| } \ | | 490| 3.50k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 27|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3154| 3.50k| } 3155| | 3156| | /* Optimization: if there are no more active states, and there 3157| | are no new states yet set up, then skip over the subject string 3158| | right here, to save looping. Otherwise, set up the new state to swing 3159| | into action when the end of the matched substring is reached. */ 3160| | 3161| 4.17k| else if (i + 1 >= active_count && new_count == 0) ------------------ | Branch (3161:20): [True: 3.52k, False: 648] | Branch (3161:45): [True: 1.50k, False: 2.01k] ------------------ 3162| 1.50k| { 3163| 1.50k| ptr += charcount; 3164| 1.50k| clen = 0; 3165| 1.50k| ADD_NEW(next_state_offset, 0); ------------------ | | 503| 1.50k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (503:7): [True: 1.50k, False: 0] | | ------------------ | | 504| 1.50k| { \ | | 505| 1.50k| next_new_state->offset = (x); \ | | 506| 1.50k| next_new_state->count = (y); \ | | 507| 1.50k| next_new_state++; \ | | 508| 1.50k| } \ | | 509| 1.50k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 0|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3166| | 3167| | /* If we are adding a repeat state at the new character position, 3168| | we must fudge things so that it is the only current state. 3169| | Otherwise, it might be a duplicate of one we processed before, and 3170| | that would cause it to be skipped. */ 3171| | 3172| 1.50k| if (repeat_state_offset >= 0) ------------------ | Branch (3172:17): [True: 686, False: 821] ------------------ 3173| 686| { 3174| 686| next_active_state = active_states; 3175| 686| active_count = 0; 3176| 686| i = -1; 3177| 686| ADD_ACTIVE(repeat_state_offset, 0); ------------------ | | 484| 686| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 686, False: 0] | | ------------------ | | 485| 686| { \ | | 486| 686| next_active_state->offset = (x); \ | | 487| 686| next_active_state->count = (y); \ | | 488| 686| next_active_state++; \ | | 489| 686| } \ | | 490| 686| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 0|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3178| 686| } 3179| 1.50k| } 3180| 2.66k| else 3181| 2.66k| { 3182| 2.66k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH != 32 3183| 2.66k| if (utf) ------------------ | Branch (3183:17): [True: 1.06k, False: 1.60k] ------------------ 3184| 1.06k| { 3185| 1.06k| PCRE2_SPTR p = start_subject + local_offsets[0]; ------------------ | | 814| 1.06k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.06k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.06k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.06k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3186| 1.06k| PCRE2_SPTR pp = start_subject + local_offsets[1]; ------------------ | | 814| 1.06k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.06k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.06k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.06k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3187| 4.85k| while (p < pp) if (NOT_FIRSTCU(*p++)) charcount--; ------------------ | | 296| 3.79k|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 326, False: 3.46k] | | ------------------ ------------------ | Branch (3187:22): [True: 3.79k, False: 1.06k] ------------------ 3188| 1.06k| } 3189| 2.66k|#endif 3190| 2.66k| ADD_NEW_DATA(-next_state_offset, 0, (int)(charcount - 1)); ------------------ | | 512| 2.66k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 2.65k, False: 10] | | ------------------ | | 513| 2.66k| { \ | | 514| 2.65k| next_new_state->offset = (x); \ | | 515| 2.65k| next_new_state->count = (y); \ | | 516| 2.65k| next_new_state->data = (z); \ | | 517| 2.65k| next_new_state++; \ | | 518| 2.65k| } \ | | 519| 2.66k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3191| 2.65k| if (repeat_state_offset >= 0) ------------------ | Branch (3191:17): [True: 1.17k, False: 1.48k] ------------------ 3192| 1.17k| { ADD_NEW_DATA(-repeat_state_offset, 0, (int)(charcount - 1)); } ------------------ | | 512| 1.17k| if (new_count++ < wscount) \ | | ------------------ | | | Branch (512:7): [True: 1.16k, False: 10] | | ------------------ | | 513| 1.17k| { \ | | 514| 1.16k| next_new_state->offset = (x); \ | | 515| 1.16k| next_new_state->count = (y); \ | | 516| 1.16k| next_new_state->data = (z); \ | | 517| 1.16k| next_new_state++; \ | | 518| 1.16k| } \ | | 519| 1.17k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 10|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3193| 2.65k| } 3194| 7.67k| } 3195| 7.68k| else if (rc != PCRE2_ERROR_NOMATCH) return rc; ------------------ | | 326| 7.68k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ | Branch (3195:18): [True: 977, False: 6.70k] ------------------ 3196| 15.3k| } 3197| 14.3k| break; 3198| | 3199| | 3200| |/* ========================================================================== */ 3201| | /* Handle callouts */ 3202| | 3203| 400k| case OP_CALLOUT: ------------------ | Branch (3203:7): [True: 400k, False: 8.53M] ------------------ 3204| 404k| case OP_CALLOUT_STR: ------------------ | Branch (3204:7): [True: 4.17k, False: 8.92M] ------------------ 3205| 404k| { 3206| 404k| PCRE2_SIZE callout_length; ------------------ | | 477| 404k|#define PCRE2_SIZE size_t ------------------ 3207| 404k| rrc = do_callout_dfa(code, offsets, current_subject, ptr, mb, 0, 3208| 404k| &callout_length); 3209| 404k| if (rrc < 0) return rrc; /* Abandon */ ------------------ | Branch (3209:13): [True: 728, False: 403k] ------------------ 3210| 403k| if (rrc == 0) ------------------ | Branch (3210:13): [True: 403k, False: 0] ------------------ 3211| 403k| { ADD_ACTIVE(state_offset + (int)callout_length, 0); } ------------------ | | 484| 403k| if (active_count++ < wscount) \ | | ------------------ | | | Branch (484:7): [True: 402k, False: 954] | | ------------------ | | 485| 403k| { \ | | 486| 402k| next_active_state->offset = (x); \ | | 487| 402k| next_active_state->count = (y); \ | | 488| 402k| next_active_state++; \ | | 489| 402k| } \ | | 490| 403k| else return PCRE2_ERROR_DFA_WSSIZE | | ------------------ | | | | 383| 954|#define PCRE2_ERROR_DFA_WSSIZE (-43) | | ------------------ ------------------ 3212| 403k| } 3213| 402k| break; 3214| | 3215| | 3216| |/* ========================================================================== */ 3217| 402k| default: /* Unsupported opcode */ ------------------ | Branch (3217:7): [True: 9.25k, False: 8.92M] ------------------ 3218| 9.25k| return PCRE2_ERROR_DFA_UITEM; ------------------ | | 382| 9.25k|#define PCRE2_ERROR_DFA_UITEM (-42) ------------------ 3219| 8.93M| } 3220| | 3221| 9.41M| NEXT_ACTIVE_STATE: continue; 3222| | 3223| 8.93M| } /* End of loop scanning active states */ 3224| | 3225| | /* We have finished the processing at the current subject character. If no 3226| | new states have been set for the next character, we have found all the 3227| | matches that we are going to find. If partial matching has been requested, 3228| | check for appropriate conditions. 3229| | 3230| | The "forced_ fail" variable counts the number of (*F) encountered for the 3231| | character. If it is equal to the original active_count (saved in 3232| | workspace[1]) it means that (*F) was found on every active state. In this 3233| | case we don't want to give a partial match. 3234| | 3235| | The "could_continue" variable is true if a state could have continued but 3236| | for the fact that the end of the subject was reached. */ 3237| | 3238| 3.45M| if (new_count <= 0) ------------------ | Branch (3238:7): [True: 712k, False: 2.74M] ------------------ 3239| 712k| { 3240| 712k| if (could_continue && /* Some could go on, and */ ------------------ | Branch (3240:9): [True: 203k, False: 508k] ------------------ 3241| 712k| forced_fail != workspace[1] && /* Not all forced fail & */ ------------------ | Branch (3241:9): [True: 200k, False: 3.38k] ------------------ 3242| 712k| ( /* either... */ 3243| 200k| (mb->moptions & PCRE2_PARTIAL_HARD) != 0 /* Hard partial */ ------------------ | | 181| 200k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (3243:9): [True: 8.12k, False: 192k] ------------------ 3244| 200k| || /* or... */ 3245| 200k| ((mb->moptions & PCRE2_PARTIAL_SOFT) != 0 && /* Soft partial and */ ------------------ | | 180| 192k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (3245:10): [True: 6.25k, False: 185k] ------------------ 3246| 192k| match_count < 0) /* no matches */ ------------------ | Branch (3246:10): [True: 5.19k, False: 1.05k] ------------------ 3247| 200k| ) && /* And... */ 3248| 712k| ( 3249| 13.3k| partial_newline || /* Either partial NL */ ------------------ | Branch (3249:9): [True: 42, False: 13.2k] ------------------ 3250| 13.3k| ( /* or ... */ 3251| 13.2k| ptr >= end_subject && /* End of subject and */ ------------------ | Branch (3251:11): [True: 13.2k, False: 0] ------------------ 3252| 13.2k| ( /* either */ 3253| 13.2k| ptr > mb->start_used_ptr || /* Inspected non-empty string */ ------------------ | Branch (3253:13): [True: 7.51k, False: 5.75k] ------------------ 3254| 13.2k| mb->allowemptypartial /* or pattern has lookbehind */ ------------------ | Branch (3254:13): [True: 790, False: 4.96k] ------------------ 3255| 13.2k| ) /* or could match empty */ 3256| 13.2k| ) 3257| 13.3k| )) 3258| 8.35k| match_count = PCRE2_ERROR_PARTIAL; ------------------ | | 327| 8.35k|#define PCRE2_ERROR_PARTIAL (-2) ------------------ 3259| 712k| break; /* Exit from loop along the subject string */ 3260| 712k| } 3261| | 3262| | /* One or more states are active for the next character. */ 3263| | 3264| 2.74M| ptr += clen; /* Advance to next subject character */ 3265| 2.74M| } /* Loop to move along the subject string */ 3266| | 3267| |/* Control gets here from "break" a few lines above. If we have a match and 3268| |PCRE2_ENDANCHORED is set, the match fails. */ 3269| | 3270| 712k|if (match_count >= 0 && ------------------ | Branch (3270:5): [True: 175k, False: 537k] ------------------ 3271| 712k| ((mb->moptions | mb->poptions) & PCRE2_ENDANCHORED) != 0 && ------------------ | | 107| 175k|#define PCRE2_ENDANCHORED 0x20000000u ------------------ | Branch (3271:5): [True: 103k, False: 71.5k] ------------------ 3272| 712k| ptr < end_subject) ------------------ | Branch (3272:5): [True: 78.7k, False: 24.9k] ------------------ 3273| 78.7k| match_count = PCRE2_ERROR_NOMATCH; ------------------ | | 326| 78.7k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ 3274| | 3275| 712k|return match_count; 3276| 756k|} pcre2_dfa_match.c:more_workspace: 416| 16.8k|{ 417| 16.8k|RWS_anchor *rws = *rwsptr; 418| 16.8k|RWS_anchor *new; 419| | 420| 16.8k|if (rws->next != NULL) ------------------ | Branch (420:5): [True: 12.4k, False: 4.43k] ------------------ 421| 12.4k| { 422| 12.4k| new = rws->next; 423| 12.4k| } 424| | 425| |/* Sizes in the RWS_anchor blocks are in units of sizeof(int), but 426| |mb->heap_limit and mb->heap_used are in kibibytes. Play carefully, to avoid 427| |overflow. */ 428| | 429| 4.43k|else 430| 4.43k| { 431| 4.43k| uint32_t newsize = (rws->size >= UINT32_MAX/2)? UINT32_MAX/2 : rws->size * 2; ------------------ | Branch (431:22): [True: 0, False: 4.43k] ------------------ 432| 4.43k| uint32_t newsizeK = newsize/(1024/sizeof(int)); 433| | 434| 4.43k| if (newsizeK + mb->heap_used > mb->heap_limit) ------------------ | Branch (434:7): [True: 0, False: 4.43k] ------------------ 435| 0| newsizeK = (uint32_t)(mb->heap_limit - mb->heap_used); 436| 4.43k| newsize = newsizeK*(1024/sizeof(int)); 437| | 438| 4.43k| if (newsize < RWS_RSIZE + ovecsize + RWS_ANCHOR_SIZE) ------------------ | | 320| 4.43k|#define RWS_RSIZE 1000 /* Work size for recursion */ ------------------ if (newsize < RWS_RSIZE + ovecsize + RWS_ANCHOR_SIZE) ------------------ | | 332| 4.43k|#define RWS_ANCHOR_SIZE (sizeof(RWS_anchor)/sizeof(int)) ------------------ | Branch (438:7): [True: 0, False: 4.43k] ------------------ 439| 0| return PCRE2_ERROR_HEAPLIMIT; ------------------ | | 404| 0|#define PCRE2_ERROR_HEAPLIMIT (-63) ------------------ 440| 4.43k| new = mb->memctl.malloc(newsize*sizeof(int), mb->memctl.memory_data); 441| 4.43k| if (new == NULL) return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ | Branch (441:7): [True: 0, False: 4.43k] ------------------ 442| 4.43k| mb->heap_used += newsizeK; 443| 4.43k| new->next = NULL; 444| 4.43k| new->size = newsize; 445| 4.43k| rws->next = new; 446| 4.43k| } 447| | 448| 16.8k|new->free = new->size - RWS_ANCHOR_SIZE; ------------------ | | 332| 16.8k|#define RWS_ANCHOR_SIZE (sizeof(RWS_anchor)/sizeof(int)) ------------------ 449| 16.8k|*rwsptr = new; 450| 16.8k|return 0; 451| 16.8k|} pcre2_dfa_match.c:do_callout_dfa: 358| 407k|{ 359| 407k|pcre2_callout_block *cb = mb->cb; ------------------ | | 831| 407k|#define pcre2_callout_block PCRE2_SUFFIX(pcre2_callout_block_) | | ------------------ | | | | 986| 407k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 407k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 407k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 360| | 361| 407k|*lengthptr = (code[extracode] == OP_CALLOUT)? ------------------ | Branch (361:14): [True: 402k, False: 5.38k] ------------------ 362| 402k| (PCRE2_SIZE)PRIV(OP_lengths)[OP_CALLOUT] : ------------------ | | 177| 402k|#define PRIV(name) _pcre2_##name ------------------ 363| 407k| (PCRE2_SIZE)GET(code, 1 + 2*LINK_SIZE + extracode); ------------------ | | 109| 412k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 364| | 365| 407k|if (mb->callout == NULL) return 0; /* No callout provided */ ------------------ | Branch (365:5): [True: 0, False: 407k] ------------------ 366| | 367| |/* Fixed fields in the callout block are set once and for all at the start of 368| |matching. */ 369| | 370| 407k|cb->offset_vector = offsets; 371| 407k|cb->start_match = (PCRE2_SIZE)(current_subject - mb->start_subject); 372| 407k|cb->current_position = (PCRE2_SIZE)(ptr - mb->start_subject); 373| 407k|cb->pattern_position = GET(code, 1 + extracode); ------------------ | | 109| 407k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 374| 407k|cb->next_item_length = GET(code, 1 + LINK_SIZE + extracode); ------------------ | | 109| 407k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 375| | 376| 407k|if (code[extracode] == OP_CALLOUT) ------------------ | Branch (376:5): [True: 402k, False: 5.38k] ------------------ 377| 402k| { 378| 402k| cb->callout_number = code[1 + 2*LINK_SIZE + extracode]; ------------------ | | 165| 402k|#define LINK_SIZE 2 ------------------ 379| 402k| cb->callout_string_offset = 0; 380| 402k| cb->callout_string = NULL; 381| 402k| cb->callout_string_length = 0; 382| 402k| } 383| 5.38k|else 384| 5.38k| { 385| 5.38k| cb->callout_number = 0; 386| 5.38k| cb->callout_string_offset = GET(code, 1 + 3*LINK_SIZE + extracode); ------------------ | | 109| 5.38k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 387| 5.38k| cb->callout_string = code + (1 + 4*LINK_SIZE + extracode) + 1; ------------------ | | 165| 5.38k|#define LINK_SIZE 2 ------------------ 388| 5.38k| cb->callout_string_length = *lengthptr - (1 + 4*LINK_SIZE) - 2; ------------------ | | 165| 5.38k|#define LINK_SIZE 2 ------------------ 389| 5.38k| } 390| | 391| 407k|return (mb->callout)(cb, mb->callout_data); 392| 407k|} pcre2_get_error_message_8: 298| 10.8k|{ 299| 10.8k|const unsigned char *message; 300| 10.8k|PCRE2_SIZE i; ------------------ | | 477| 10.8k|#define PCRE2_SIZE size_t ------------------ 301| 10.8k|int n; 302| | 303| 10.8k|if (size == 0) return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ | Branch (303:5): [True: 0, False: 10.8k] ------------------ 304| | 305| 10.8k|if (enumber >= COMPILE_ERROR_BASE) /* Compile error */ ------------------ | | 221| 10.8k|#define COMPILE_ERROR_BASE 100 ------------------ | Branch (305:5): [True: 8.45k, False: 2.34k] ------------------ 306| 8.45k| { 307| 8.45k| message = compile_error_texts; 308| 8.45k| n = enumber - COMPILE_ERROR_BASE; ------------------ | | 221| 8.45k|#define COMPILE_ERROR_BASE 100 ------------------ 309| 8.45k| } 310| 2.34k|else if (enumber < 0) /* Match or UTF error */ ------------------ | Branch (310:10): [True: 2.34k, False: 0] ------------------ 311| 2.34k| { 312| 2.34k| message = match_error_texts; 313| 2.34k| n = -enumber; 314| 2.34k| } 315| 0|else /* Invalid error number */ 316| 0| { 317| 0| message = (unsigned char *)"\0"; /* Empty message list */ 318| 0| n = 1; 319| 0| } 320| | 321| 265k|for (; n > 0; n--) ------------------ | Branch (321:8): [True: 254k, False: 10.8k] ------------------ 322| 254k| { 323| 9.55M| while (*message++ != CHAR_NUL) {}; ------------------ | | 981| 9.55M|#define CHAR_NUL '\0' ------------------ | Branch (323:10): [True: 9.30M, False: 254k] ------------------ 324| 254k| if (*message == CHAR_NUL) return PCRE2_ERROR_BADDATA; ------------------ | | 981| 254k|#define CHAR_NUL '\0' ------------------ if (*message == CHAR_NUL) return PCRE2_ERROR_BADDATA; ------------------ | | 369| 0|#define PCRE2_ERROR_BADDATA (-29) ------------------ | Branch (324:7): [True: 0, False: 254k] ------------------ 325| 254k| } 326| | 327| 421k|for (i = 0; *message != 0; i++) ------------------ | Branch (327:13): [True: 411k, False: 10.8k] ------------------ 328| 411k| { 329| 411k| if (i >= size - 1) ------------------ | Branch (329:7): [True: 0, False: 411k] ------------------ 330| 0| { 331| 0| buffer[i] = 0; /* Terminate partial message */ 332| 0| return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ 333| 0| } 334| 411k| buffer[i] = *message++; 335| 411k| } 336| | 337| 10.8k|buffer[i] = 0; 338| 10.8k|return (int)i; 339| 10.8k|} _pcre2_extuni_8: 94| 424k|{ 95| 424k|int lgb = UCD_GRAPHBREAK(c); ------------------ | | 1860| 424k|#define UCD_GRAPHBREAK(ch) GET_UCD(ch)->gbprop | | ------------------ | | | | 1846| 424k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 424k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 424k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 424k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 424k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 424k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 424k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 424k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 424k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 424k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 96| | 97| 429k|while (eptr < end_subject) ------------------ | Branch (97:8): [True: 398k, False: 31.2k] ------------------ 98| 398k| { 99| 398k| int rgb; 100| 398k| int len = 1; 101| 398k| if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); } ------------------ | | 330| 61.3k| c = *eptr; \ | | 331| 61.3k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 9.48k| { \ | | | | 323| 9.48k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 2.58k, False: 6.89k] | | | | ------------------ | | | | 324| 9.48k| { \ | | | | 325| 2.58k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 2.58k| len++; \ | | | | 327| 2.58k| } \ | | | | 328| 9.48k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 2.32k, False: 4.57k] | | | | ------------------ | | | | 329| 6.89k| { \ | | | | 330| 2.32k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 2.32k| len += 2; \ | | | | 332| 2.32k| } \ | | | | 333| 6.89k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 4.57k, False: 0] | | | | ------------------ | | | | 334| 4.57k| {\ | | | | 335| 4.57k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 4.57k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 4.57k| len += 3; \ | | | | 338| 4.57k| } \ | | | | 339| 4.57k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 9.48k| } | | ------------------ | | | Branch (331:7): [True: 9.48k, False: 51.8k] | | ------------------ ------------------ | Branch (101:7): [True: 336k, False: 61.3k] ------------------ 102| 398k| rgb = UCD_GRAPHBREAK(c); ------------------ | | 1860| 398k|#define UCD_GRAPHBREAK(ch) GET_UCD(ch)->gbprop | | ------------------ | | | | 1846| 398k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 398k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 398k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 398k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 398k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 398k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 398k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 398k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 398k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 398k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 103| 398k| if ((PRIV(ucp_gbtable)[lgb] & (1u << rgb)) == 0) break; ------------------ | | 177| 398k|#define PRIV(name) _pcre2_##name ------------------ | Branch (103:7): [True: 392k, False: 5.78k] ------------------ 104| | 105| | /* Not breaking between Regional Indicators is allowed only if there 106| | are an even number of preceding RIs. */ 107| | 108| 5.78k| if (lgb == ucp_gbRegional_Indicator && rgb == ucp_gbRegional_Indicator) ------------------ | Branch (108:7): [True: 1.89k, False: 3.89k] | Branch (108:42): [True: 1.89k, False: 0] ------------------ 109| 1.89k| { 110| 1.89k| int ricount = 0; 111| 1.89k| PCRE2_SPTR bptr = eptr - 1; ------------------ | | 814| 1.89k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.89k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.89k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.89k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 112| 1.89k| if (utf) BACKCHAR(bptr); ------------------ | | 345| 7.57k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 5.68k, False: 1.89k] | | ------------------ ------------------ | Branch (112:9): [True: 1.89k, False: 0] ------------------ 113| | 114| | /* bptr is pointing to the left-hand character */ 115| | 116| 2.37k| while (bptr > start_subject) ------------------ | Branch (116:12): [True: 1.63k, False: 742] ------------------ 117| 1.63k| { 118| 1.63k| bptr--; 119| 1.63k| if (utf) ------------------ | Branch (119:11): [True: 1.63k, False: 0] ------------------ 120| 1.63k| { 121| 1.63k| BACKCHAR(bptr); ------------------ | | 345| 4.01k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 2.37k, False: 1.63k] | | ------------------ ------------------ 122| 1.63k| GETCHAR(c, bptr); ------------------ | | 302| 1.63k| c = *eptr; \ | | 303| 1.63k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 1.12k| { \ | | | | 267| 1.12k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 391, False: 736] | | | | ------------------ | | | | 268| 1.12k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 1.12k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 222, False: 514] | | | | ------------------ | | | | 270| 736| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 736| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 514, False: 0] | | | | ------------------ | | | | 272| 514| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 514| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 514| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 1.12k| } | | ------------------ | | | Branch (303:7): [True: 1.12k, False: 507] | | ------------------ ------------------ 123| 1.63k| } 124| 0| else 125| 0| c = *bptr; 126| 1.63k| if (UCD_GRAPHBREAK(c) != ucp_gbRegional_Indicator) break; ------------------ | | 1860| 1.63k|#define UCD_GRAPHBREAK(ch) GET_UCD(ch)->gbprop | | ------------------ | | | | 1846| 1.63k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 1.63k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 1.63k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 1.63k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 1.63k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 1.63k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 1.63k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 1.63k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 1.63k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 1.63k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (126:11): [True: 1.15k, False: 482] ------------------ 127| 482| ricount++; 128| 482| } 129| 1.89k| if ((ricount & 1) != 0) break; /* Grapheme break required */ ------------------ | Branch (129:9): [True: 482, False: 1.41k] ------------------ 130| 1.89k| } 131| | 132| | /* If Extend or ZWJ follows Extended_Pictographic, do not update lgb; this 133| | allows any number of them before a following Extended_Pictographic. */ 134| | 135| 5.30k| if ((rgb != ucp_gbExtend && rgb != ucp_gbZWJ) || ------------------ | Branch (135:8): [True: 4.10k, False: 1.19k] | Branch (135:31): [True: 3.86k, False: 238] ------------------ 136| 5.30k| lgb != ucp_gbExtended_Pictographic) ------------------ | Branch (136:8): [True: 1.21k, False: 218] ------------------ 137| 5.08k| lgb = rgb; 138| | 139| 5.30k| eptr += len; 140| 5.30k| if (xcount != NULL) *xcount += 1; ------------------ | Branch (140:7): [True: 1.73k, False: 3.56k] ------------------ 141| 5.30k| } 142| | 143| 424k|return eptr; 144| 424k|} _pcre2_find_bracket_8: 71| 32.5k|{ 72| 32.5k|for (;;) 73| 4.56M| { 74| 4.56M| PCRE2_UCHAR c = *code; ------------------ | | 813| 4.56M|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 4.56M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 4.56M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 4.56M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 75| | 76| 4.56M| if (c == OP_END) return NULL; ------------------ | Branch (76:7): [True: 1.41k, False: 4.56M] ------------------ 77| | 78| | /* XCLASS is used for classes that cannot be represented just by a bit map. 79| | This includes negated single high-valued characters. CALLOUT_STR is used for 80| | callouts with string arguments. In both cases the length in the table is 81| | zero; the actual length is stored in the compiled code. */ 82| | 83| 4.56M| if (c == OP_XCLASS) code += GET(code, 1); ------------------ | | 109| 880| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (83:7): [True: 880, False: 4.56M] ------------------ 84| 4.56M| else if (c == OP_CALLOUT_STR) code += GET(code, 1 + 2*LINK_SIZE); ------------------ | | 109| 284| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (84:14): [True: 284, False: 4.55M] ------------------ 85| | 86| | /* Handle lookbehind */ 87| | 88| 4.55M| else if (c == OP_REVERSE) ------------------ | Branch (88:12): [True: 857, False: 4.55M] ------------------ 89| 857| { 90| 857| if (number < 0) return (PCRE2_UCHAR *)code; ------------------ | Branch (90:9): [True: 0, False: 857] ------------------ 91| 857| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 857|#define PRIV(name) _pcre2_##name ------------------ 92| 857| } 93| | 94| | /* Handle capturing bracket */ 95| | 96| 4.55M| else if (c == OP_CBRA || c == OP_SCBRA || ------------------ | Branch (96:12): [True: 856k, False: 3.70M] | Branch (96:28): [True: 3.33k, False: 3.69M] ------------------ 97| 4.55M| c == OP_CBRAPOS || c == OP_SCBRAPOS) ------------------ | Branch (97:12): [True: 860, False: 3.69M] | Branch (97:31): [True: 617, False: 3.69M] ------------------ 98| 861k| { 99| 861k| int n = (int)GET2(code, 1+LINK_SIZE); ------------------ | | 194| 861k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 100| 861k| if (n == number) return (PCRE2_UCHAR *)code; ------------------ | Branch (100:9): [True: 31.1k, False: 830k] ------------------ 101| 830k| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 830k|#define PRIV(name) _pcre2_##name ------------------ 102| 830k| } 103| | 104| | /* Otherwise, we can get the item's length from the table, except that for 105| | repeated character types, we have to test for \p and \P, which have an extra 106| | two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we 107| | must add in its length. */ 108| | 109| 3.69M| else 110| 3.69M| { 111| 3.69M| switch(c) ------------------ | Branch (111:12): [True: 3.65M, False: 45.9k] ------------------ 112| 3.69M| { 113| 1.41k| case OP_TYPESTAR: ------------------ | Branch (113:7): [True: 1.41k, False: 3.69M] ------------------ 114| 7.19k| case OP_TYPEMINSTAR: ------------------ | Branch (114:7): [True: 5.77k, False: 3.69M] ------------------ 115| 10.3k| case OP_TYPEPLUS: ------------------ | Branch (115:7): [True: 3.10k, False: 3.69M] ------------------ 116| 11.6k| case OP_TYPEMINPLUS: ------------------ | Branch (116:7): [True: 1.33k, False: 3.69M] ------------------ 117| 12.1k| case OP_TYPEQUERY: ------------------ | Branch (117:7): [True: 512, False: 3.69M] ------------------ 118| 12.4k| case OP_TYPEMINQUERY: ------------------ | Branch (118:7): [True: 351, False: 3.69M] ------------------ 119| 20.1k| case OP_TYPEPOSSTAR: ------------------ | Branch (119:7): [True: 7.63k, False: 3.68M] ------------------ 120| 21.0k| case OP_TYPEPOSPLUS: ------------------ | Branch (120:7): [True: 893, False: 3.69M] ------------------ 121| 21.5k| case OP_TYPEPOSQUERY: ------------------ | Branch (121:7): [True: 551, False: 3.69M] ------------------ 122| 21.5k| if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2; ------------------ | Branch (122:11): [True: 346, False: 21.2k] | Branch (122:33): [True: 614, False: 20.6k] ------------------ 123| 21.5k| break; 124| | 125| 5.23k| case OP_TYPEUPTO: ------------------ | Branch (125:7): [True: 5.23k, False: 3.69M] ------------------ 126| 9.79k| case OP_TYPEMINUPTO: ------------------ | Branch (126:7): [True: 4.55k, False: 3.69M] ------------------ 127| 20.7k| case OP_TYPEEXACT: ------------------ | Branch (127:7): [True: 10.9k, False: 3.68M] ------------------ 128| 21.3k| case OP_TYPEPOSUPTO: ------------------ | Branch (128:7): [True: 584, False: 3.69M] ------------------ 129| 21.3k| if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP) ------------------ | | 193| 21.3k|#define IMM2_SIZE 2 ------------------ if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP) ------------------ | | 193| 20.9k|#define IMM2_SIZE 2 ------------------ | Branch (129:11): [True: 364, False: 20.9k] | Branch (129:45): [True: 215, False: 20.7k] ------------------ 130| 579| code += 2; 131| 21.3k| break; 132| | 133| 268| case OP_MARK: ------------------ | Branch (133:7): [True: 268, False: 3.69M] ------------------ 134| 599| case OP_COMMIT_ARG: ------------------ | Branch (134:7): [True: 331, False: 3.69M] ------------------ 135| 834| case OP_PRUNE_ARG: ------------------ | Branch (135:7): [True: 235, False: 3.69M] ------------------ 136| 2.74k| case OP_SKIP_ARG: ------------------ | Branch (136:7): [True: 1.90k, False: 3.69M] ------------------ 137| 3.06k| case OP_THEN_ARG: ------------------ | Branch (137:7): [True: 325, False: 3.69M] ------------------ 138| 3.06k| code += code[1]; 139| 3.06k| break; 140| 3.69M| } 141| | 142| | /* Add in the fixed length from the table */ 143| | 144| 3.69M| code += PRIV(OP_lengths)[c]; ------------------ | | 177| 3.69M|#define PRIV(name) _pcre2_##name ------------------ 145| | 146| | /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may be 147| | followed by a multi-byte character. The length in the table is a minimum, so 148| | we have to arrange to skip the extra bytes. */ 149| | 150| 3.69M|#ifdef MAYBE_UTF_MULTI 151| 3.69M| if (utf) switch(c) ------------------ | Branch (151:9): [True: 17.5k, False: 3.68M] | Branch (151:21): [True: 14.3k, False: 3.20k] ------------------ 152| 17.5k| { 153| 2.72k| case OP_CHAR: ------------------ | Branch (153:7): [True: 2.72k, False: 14.7k] ------------------ 154| 3.13k| case OP_CHARI: ------------------ | Branch (154:7): [True: 416, False: 17.1k] ------------------ 155| 3.13k| case OP_NOT: ------------------ | Branch (155:7): [True: 2, False: 17.5k] ------------------ 156| 3.14k| case OP_NOTI: ------------------ | Branch (156:7): [True: 2, False: 17.5k] ------------------ 157| 3.15k| case OP_EXACT: ------------------ | Branch (157:7): [True: 12, False: 17.5k] ------------------ 158| 3.15k| case OP_EXACTI: ------------------ | Branch (158:7): [True: 1, False: 17.5k] ------------------ 159| 3.15k| case OP_NOTEXACT: ------------------ | Branch (159:7): [True: 0, False: 17.5k] ------------------ 160| 3.15k| case OP_NOTEXACTI: ------------------ | Branch (160:7): [True: 0, False: 17.5k] ------------------ 161| 3.15k| case OP_UPTO: ------------------ | Branch (161:7): [True: 0, False: 17.5k] ------------------ 162| 3.15k| case OP_UPTOI: ------------------ | Branch (162:7): [True: 0, False: 17.5k] ------------------ 163| 3.15k| case OP_NOTUPTO: ------------------ | Branch (163:7): [True: 0, False: 17.5k] ------------------ 164| 3.15k| case OP_NOTUPTOI: ------------------ | Branch (164:7): [True: 0, False: 17.5k] ------------------ 165| 3.15k| case OP_MINUPTO: ------------------ | Branch (165:7): [True: 0, False: 17.5k] ------------------ 166| 3.15k| case OP_MINUPTOI: ------------------ | Branch (166:7): [True: 0, False: 17.5k] ------------------ 167| 3.15k| case OP_NOTMINUPTO: ------------------ | Branch (167:7): [True: 0, False: 17.5k] ------------------ 168| 3.15k| case OP_NOTMINUPTOI: ------------------ | Branch (168:7): [True: 0, False: 17.5k] ------------------ 169| 3.15k| case OP_POSUPTO: ------------------ | Branch (169:7): [True: 0, False: 17.5k] ------------------ 170| 3.15k| case OP_POSUPTOI: ------------------ | Branch (170:7): [True: 0, False: 17.5k] ------------------ 171| 3.15k| case OP_NOTPOSUPTO: ------------------ | Branch (171:7): [True: 0, False: 17.5k] ------------------ 172| 3.15k| case OP_NOTPOSUPTOI: ------------------ | Branch (172:7): [True: 0, False: 17.5k] ------------------ 173| 3.17k| case OP_STAR: ------------------ | Branch (173:7): [True: 21, False: 17.4k] ------------------ 174| 3.18k| case OP_STARI: ------------------ | Branch (174:7): [True: 12, False: 17.5k] ------------------ 175| 3.18k| case OP_NOTSTAR: ------------------ | Branch (175:7): [True: 0, False: 17.5k] ------------------ 176| 3.18k| case OP_NOTSTARI: ------------------ | Branch (176:7): [True: 0, False: 17.5k] ------------------ 177| 3.19k| case OP_MINSTAR: ------------------ | Branch (177:7): [True: 8, False: 17.5k] ------------------ 178| 3.19k| case OP_MINSTARI: ------------------ | Branch (178:7): [True: 0, False: 17.5k] ------------------ 179| 3.19k| case OP_NOTMINSTAR: ------------------ | Branch (179:7): [True: 0, False: 17.5k] ------------------ 180| 3.19k| case OP_NOTMINSTARI: ------------------ | Branch (180:7): [True: 0, False: 17.5k] ------------------ 181| 3.19k| case OP_POSSTAR: ------------------ | Branch (181:7): [True: 0, False: 17.5k] ------------------ 182| 3.19k| case OP_POSSTARI: ------------------ | Branch (182:7): [True: 1, False: 17.5k] ------------------ 183| 3.19k| case OP_NOTPOSSTAR: ------------------ | Branch (183:7): [True: 0, False: 17.5k] ------------------ 184| 3.19k| case OP_NOTPOSSTARI: ------------------ | Branch (184:7): [True: 0, False: 17.5k] ------------------ 185| 3.19k| case OP_PLUS: ------------------ | Branch (185:7): [True: 0, False: 17.5k] ------------------ 186| 3.19k| case OP_PLUSI: ------------------ | Branch (186:7): [True: 0, False: 17.5k] ------------------ 187| 3.19k| case OP_NOTPLUS: ------------------ | Branch (187:7): [True: 0, False: 17.5k] ------------------ 188| 3.19k| case OP_NOTPLUSI: ------------------ | Branch (188:7): [True: 0, False: 17.5k] ------------------ 189| 3.19k| case OP_MINPLUS: ------------------ | Branch (189:7): [True: 0, False: 17.5k] ------------------ 190| 3.19k| case OP_MINPLUSI: ------------------ | Branch (190:7): [True: 4, False: 17.5k] ------------------ 191| 3.19k| case OP_NOTMINPLUS: ------------------ | Branch (191:7): [True: 0, False: 17.5k] ------------------ 192| 3.19k| case OP_NOTMINPLUSI: ------------------ | Branch (192:7): [True: 0, False: 17.5k] ------------------ 193| 3.19k| case OP_POSPLUS: ------------------ | Branch (193:7): [True: 0, False: 17.5k] ------------------ 194| 3.20k| case OP_POSPLUSI: ------------------ | Branch (194:7): [True: 1, False: 17.5k] ------------------ 195| 3.20k| case OP_NOTPOSPLUS: ------------------ | Branch (195:7): [True: 0, False: 17.5k] ------------------ 196| 3.20k| case OP_NOTPOSPLUSI: ------------------ | Branch (196:7): [True: 0, False: 17.5k] ------------------ 197| 3.20k| case OP_QUERY: ------------------ | Branch (197:7): [True: 0, False: 17.5k] ------------------ 198| 3.20k| case OP_QUERYI: ------------------ | Branch (198:7): [True: 0, False: 17.5k] ------------------ 199| 3.20k| case OP_NOTQUERY: ------------------ | Branch (199:7): [True: 0, False: 17.5k] ------------------ 200| 3.20k| case OP_NOTQUERYI: ------------------ | Branch (200:7): [True: 0, False: 17.5k] ------------------ 201| 3.20k| case OP_MINQUERY: ------------------ | Branch (201:7): [True: 0, False: 17.5k] ------------------ 202| 3.20k| case OP_MINQUERYI: ------------------ | Branch (202:7): [True: 0, False: 17.5k] ------------------ 203| 3.20k| case OP_NOTMINQUERY: ------------------ | Branch (203:7): [True: 0, False: 17.5k] ------------------ 204| 3.20k| case OP_NOTMINQUERYI: ------------------ | Branch (204:7): [True: 0, False: 17.5k] ------------------ 205| 3.20k| case OP_POSQUERY: ------------------ | Branch (205:7): [True: 0, False: 17.5k] ------------------ 206| 3.20k| case OP_POSQUERYI: ------------------ | Branch (206:7): [True: 3, False: 17.5k] ------------------ 207| 3.20k| case OP_NOTPOSQUERY: ------------------ | Branch (207:7): [True: 0, False: 17.5k] ------------------ 208| 3.20k| case OP_NOTPOSQUERYI: ------------------ | Branch (208:7): [True: 0, False: 17.5k] ------------------ 209| 3.20k| if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]); ------------------ | | 286| 3.20k|#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c) | | ------------------ | | | | 254| 3.20k|#define HASUTF8EXTRALEN(c) ((c) >= 0xc0) | | | | ------------------ | | | | | Branch (254:28): [True: 262, False: 2.94k] | | | | ------------------ | | ------------------ ------------------ if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]); ------------------ | | 291| 262|#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu]) | | ------------------ | | | | 177| 262|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ 210| 3.20k| break; 211| 17.5k| } 212| |#else 213| | (void)(utf); /* Keep compiler happy by referencing function argument */ 214| |#endif /* MAYBE_UTF_MULTI */ 215| 3.69M| } 216| 4.56M| } 217| 32.5k|} LLVMFuzzerTestOneInput: 58| 38.0k|{ 59| 38.0k|uint32_t compile_options; 60| 38.0k|uint32_t match_options; 61| 38.0k|pcre2_match_data *match_data = NULL; ------------------ | | 838| 38.0k|#define pcre2_match_data PCRE2_SUFFIX(pcre2_match_data_) | | ------------------ | | | | 986| 38.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 38.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 38.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 62| 38.0k|pcre2_match_context *match_context = NULL; ------------------ | | 837| 38.0k|#define pcre2_match_context PCRE2_SUFFIX(pcre2_match_context_) | | ------------------ | | | | 986| 38.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 38.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 38.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 38.0k|size_t match_size; 64| 38.0k|int dfa_workspace[DFA_WORKSPACE_COUNT]; 65| 38.0k|int r1, r2; 66| 38.0k|int i; 67| | 68| 38.0k|if (size < 1) return 0; ------------------ | Branch (68:5): [True: 0, False: 38.0k] ------------------ 69| | 70| |/* Limiting the length of the subject for matching stops fruitless searches 71| |in large trees taking too much time. */ 72| | 73| 38.0k|match_size = (size > MAX_MATCH_SIZE)? MAX_MATCH_SIZE : size; ------------------ | | 20| 38.0k|#define MAX_MATCH_SIZE 1000 ------------------ match_size = (size > MAX_MATCH_SIZE)? MAX_MATCH_SIZE : size; ------------------ | | 20| 341|#define MAX_MATCH_SIZE 1000 ------------------ | Branch (73:14): [True: 341, False: 37.6k] ------------------ 74| | 75| |/* Figure out some options to use. Initialize the random number to ensure 76| |repeatability. Ensure that we get a 32-bit unsigned random number for testing 77| |options. (RAND_MAX is required to be at least 32767, but is commonly 78| |2147483647, which excludes the top bit.) */ 79| | 80| 38.0k|srand((unsigned int)(data[size/2])); 81| 38.0k|r1 = rand(); 82| 38.0k|r2 = rand(); 83| | 84| |/* Ensure that all undefined option bits are zero (waste of time trying them) 85| |and also that PCRE2_NO_UTF_CHECK is unset, as there is no guarantee that the 86| |input is UTF-8. Also unset PCRE2_NEVER_UTF and PCRE2_NEVER_UCP as there is no 87| |reason to disallow UTF and UCP. Force PCRE2_NEVER_BACKSLASH_C to be set because 88| |\C in random patterns is highly likely to cause a crash. */ 89| | 90| 38.0k|compile_options = 91| 38.0k| ((((uint32_t)r1 << 16) | ((uint32_t)r2 & 0xffff)) & ALLOWED_COMPILE_OPTIONS) | ------------------ | | 25| 38.0k| (PCRE2_ANCHORED|PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \ | | ------------------ | | | | 105| 38.0k|#define PCRE2_ANCHORED 0x80000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \ | | ------------------ | | | | 119| 38.0k|#define PCRE2_ALLOW_EMPTY_CLASS 0x00000001u /* C */ | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \ | | ------------------ | | | | 120| 38.0k|#define PCRE2_ALT_BSUX 0x00000002u /* C */ | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \ | | ------------------ | | | | 140| 38.0k|#define PCRE2_ALT_CIRCUMFLEX 0x00200000u /* J M D */ | | ------------------ | | 26| 38.0k| PCRE2_ALT_VERBNAMES|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_DOLLAR_ENDONLY| \ | | ------------------ | | | | 141| 38.0k|#define PCRE2_ALT_VERBNAMES 0x00400000u /* C */ | | ------------------ | | PCRE2_ALT_VERBNAMES|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_DOLLAR_ENDONLY| \ | | ------------------ | | | | 121| 38.0k|#define PCRE2_AUTO_CALLOUT 0x00000004u /* C */ | | ------------------ | | PCRE2_ALT_VERBNAMES|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_DOLLAR_ENDONLY| \ | | ------------------ | | | | 122| 38.0k|#define PCRE2_CASELESS 0x00000008u /* C */ | | ------------------ | | PCRE2_ALT_VERBNAMES|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_DOLLAR_ENDONLY| \ | | ------------------ | | | | 123| 38.0k|#define PCRE2_DOLLAR_ENDONLY 0x00000010u /* J M D */ | | ------------------ | | 27| 38.0k| PCRE2_DOTALL|PCRE2_DUPNAMES|PCRE2_ENDANCHORED|PCRE2_EXTENDED|PCRE2_FIRSTLINE| \ | | ------------------ | | | | 124| 38.0k|#define PCRE2_DOTALL 0x00000020u /* C */ | | ------------------ | | PCRE2_DOTALL|PCRE2_DUPNAMES|PCRE2_ENDANCHORED|PCRE2_EXTENDED|PCRE2_FIRSTLINE| \ | | ------------------ | | | | 125| 38.0k|#define PCRE2_DUPNAMES 0x00000040u /* C */ | | ------------------ | | PCRE2_DOTALL|PCRE2_DUPNAMES|PCRE2_ENDANCHORED|PCRE2_EXTENDED|PCRE2_FIRSTLINE| \ | | ------------------ | | | | 107| 38.0k|#define PCRE2_ENDANCHORED 0x20000000u | | ------------------ | | PCRE2_DOTALL|PCRE2_DUPNAMES|PCRE2_ENDANCHORED|PCRE2_EXTENDED|PCRE2_FIRSTLINE| \ | | ------------------ | | | | 126| 38.0k|#define PCRE2_EXTENDED 0x00000080u /* C */ | | ------------------ | | PCRE2_DOTALL|PCRE2_DUPNAMES|PCRE2_ENDANCHORED|PCRE2_EXTENDED|PCRE2_FIRSTLINE| \ | | ------------------ | | | | 127| 38.0k|#define PCRE2_FIRSTLINE 0x00000100u /* J M D */ | | ------------------ | | 28| 38.0k| PCRE2_MATCH_UNSET_BACKREF|PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C| \ | | ------------------ | | | | 128| 38.0k|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ | | ------------------ | | PCRE2_MATCH_UNSET_BACKREF|PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C| \ | | ------------------ | | | | 129| 38.0k|#define PCRE2_MULTILINE 0x00000400u /* C */ | | ------------------ | | PCRE2_MATCH_UNSET_BACKREF|PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C| \ | | ------------------ | | | | 139| 38.0k|#define PCRE2_NEVER_BACKSLASH_C 0x00100000u /* C */ | | ------------------ | | 29| 38.0k| PCRE2_NO_AUTO_CAPTURE| \ | | ------------------ | | | | 132| 38.0k|#define PCRE2_NO_AUTO_CAPTURE 0x00002000u /* C */ | | ------------------ | | 30| 38.0k| PCRE2_NO_AUTO_POSSESS|PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_NO_START_OPTIMIZE| \ | | ------------------ | | | | 133| 38.0k|#define PCRE2_NO_AUTO_POSSESS 0x00004000u /* C */ | | ------------------ | | PCRE2_NO_AUTO_POSSESS|PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_NO_START_OPTIMIZE| \ | | ------------------ | | | | 134| 38.0k|#define PCRE2_NO_DOTSTAR_ANCHOR 0x00008000u /* C */ | | ------------------ | | PCRE2_NO_AUTO_POSSESS|PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_NO_START_OPTIMIZE| \ | | ------------------ | | | | 135| 38.0k|#define PCRE2_NO_START_OPTIMIZE 0x00010000u /* J M D */ | | ------------------ | | 31| 38.0k| PCRE2_UCP|PCRE2_UNGREEDY|PCRE2_USE_OFFSET_LIMIT| \ | | ------------------ | | | | 136| 38.0k|#define PCRE2_UCP 0x00020000u /* C J M D */ | | ------------------ | | PCRE2_UCP|PCRE2_UNGREEDY|PCRE2_USE_OFFSET_LIMIT| \ | | ------------------ | | | | 137| 38.0k|#define PCRE2_UNGREEDY 0x00040000u /* C */ | | ------------------ | | PCRE2_UCP|PCRE2_UNGREEDY|PCRE2_USE_OFFSET_LIMIT| \ | | ------------------ | | | | 142| 38.0k|#define PCRE2_USE_OFFSET_LIMIT 0x00800000u /* J M D */ | | ------------------ | | 32| 38.0k| PCRE2_UTF) | | ------------------ | | | | 138| 38.0k|#define PCRE2_UTF 0x00080000u /* C J M D */ | | ------------------ ------------------ 92| 38.0k| PCRE2_NEVER_BACKSLASH_C; ------------------ | | 139| 38.0k|#define PCRE2_NEVER_BACKSLASH_C 0x00100000u /* C */ ------------------ 93| | 94| 38.0k|match_options = 95| 38.0k| ((((uint32_t)r1 << 16) | ((uint32_t)r2 & 0xffff)) & ALLOWED_MATCH_OPTIONS); ------------------ | | 35| 38.0k| (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 105| 38.0k|#define PCRE2_ANCHORED 0x80000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 107| 38.0k|#define PCRE2_ENDANCHORED 0x20000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 176| 38.0k|#define PCRE2_NOTBOL 0x00000001u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 177| 38.0k|#define PCRE2_NOTEOL 0x00000002u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 178| 38.0k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ | | ------------------ | | 36| 38.0k| PCRE2_NOTEMPTY_ATSTART|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 179| 38.0k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ | | ------------------ | | PCRE2_NOTEMPTY_ATSTART|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 181| 38.0k|#define PCRE2_PARTIAL_HARD 0x00000020u | | ------------------ | | 37| 38.0k| PCRE2_PARTIAL_SOFT|PCRE2_NO_JIT) | | ------------------ | | | | 180| 38.0k|#define PCRE2_PARTIAL_SOFT 0x00000010u | | ------------------ | | PCRE2_PARTIAL_SOFT|PCRE2_NO_JIT) | | ------------------ | | | | 189| 38.0k|#define PCRE2_NO_JIT 0x00002000u /* Not for pcre2_dfa_match() */ | | ------------------ ------------------ 96| | 97| |/* Discard partial matching if PCRE2_ENDANCHORED is set, because they are not 98| |allowed together and just give an immediate error return. */ 99| | 100| 38.0k|if (((compile_options|match_options) & PCRE2_ENDANCHORED) != 0) ------------------ | | 107| 38.0k|#define PCRE2_ENDANCHORED 0x20000000u ------------------ | Branch (100:5): [True: 18.3k, False: 19.6k] ------------------ 101| 18.3k| match_options &= ~(PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT); ------------------ | | 181| 18.3k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ match_options &= ~(PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT); ------------------ | | 180| 18.3k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ 102| | 103| |/* Do the compile with and without the options, and after a successful compile, 104| |likewise do the match with and without the options. */ 105| | 106| 114k|for (i = 0; i < 2; i++) ------------------ | Branch (106:13): [True: 76.0k, False: 38.0k] ------------------ 107| 76.0k| { 108| 76.0k| uint32_t callout_count; 109| 76.0k| int errorcode; 110| 76.0k| PCRE2_SIZE erroroffset; ------------------ | | 477| 76.0k|#define PCRE2_SIZE size_t ------------------ 111| 76.0k| pcre2_code *code; ------------------ | | 816| 76.0k|#define pcre2_code PCRE2_SUFFIX(pcre2_code_) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 112| | 113| |#ifdef STANDALONE 114| | printf("Compile options %.8x never_backslash_c", compile_options); 115| | printf("%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", 116| | ((compile_options & PCRE2_ALT_BSUX) != 0)? ",alt_bsux" : "", 117| | ((compile_options & PCRE2_ALT_CIRCUMFLEX) != 0)? ",alt_circumflex" : "", 118| | ((compile_options & PCRE2_ALT_VERBNAMES) != 0)? ",alt_verbnames" : "", 119| | ((compile_options & PCRE2_ALLOW_EMPTY_CLASS) != 0)? ",allow_empty_class" : "", 120| | ((compile_options & PCRE2_ANCHORED) != 0)? ",anchored" : "", 121| | ((compile_options & PCRE2_AUTO_CALLOUT) != 0)? ",auto_callout" : "", 122| | ((compile_options & PCRE2_CASELESS) != 0)? ",caseless" : "", 123| | ((compile_options & PCRE2_DOLLAR_ENDONLY) != 0)? ",dollar_endonly" : "", 124| | ((compile_options & PCRE2_DOTALL) != 0)? ",dotall" : "", 125| | ((compile_options & PCRE2_DUPNAMES) != 0)? ",dupnames" : "", 126| | ((compile_options & PCRE2_ENDANCHORED) != 0)? ",endanchored" : "", 127| | ((compile_options & PCRE2_EXTENDED) != 0)? ",extended" : "", 128| | ((compile_options & PCRE2_FIRSTLINE) != 0)? ",firstline" : "", 129| | ((compile_options & PCRE2_MATCH_UNSET_BACKREF) != 0)? ",match_unset_backref" : "", 130| | ((compile_options & PCRE2_MULTILINE) != 0)? ",multiline" : "", 131| | ((compile_options & PCRE2_NEVER_UCP) != 0)? ",never_ucp" : "", 132| | ((compile_options & PCRE2_NEVER_UTF) != 0)? ",never_utf" : "", 133| | ((compile_options & PCRE2_NO_AUTO_CAPTURE) != 0)? ",no_auto_capture" : "", 134| | ((compile_options & PCRE2_NO_AUTO_POSSESS) != 0)? ",no_auto_possess" : "", 135| | ((compile_options & PCRE2_NO_DOTSTAR_ANCHOR) != 0)? ",no_dotstar_anchor" : "", 136| | ((compile_options & PCRE2_NO_UTF_CHECK) != 0)? ",no_utf_check" : "", 137| | ((compile_options & PCRE2_NO_START_OPTIMIZE) != 0)? ",no_start_optimize" : "", 138| | ((compile_options & PCRE2_UCP) != 0)? ",ucp" : "", 139| | ((compile_options & PCRE2_UNGREEDY) != 0)? ",ungreedy" : "", 140| | ((compile_options & PCRE2_USE_OFFSET_LIMIT) != 0)? ",use_offset_limit" : "", 141| | ((compile_options & PCRE2_UTF) != 0)? ",utf" : ""); 142| |#endif 143| | 144| 76.0k| code = pcre2_compile((PCRE2_SPTR)data, (PCRE2_SIZE)size, compile_options, ------------------ | | 847| 76.0k|#define pcre2_compile PCRE2_SUFFIX(pcre2_compile_) | | ------------------ | | | | 986| 76.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 145| 76.0k| &errorcode, &erroroffset, NULL); 146| | 147| | /* Compilation succeeded */ 148| | 149| 76.0k| if (code != NULL) ------------------ | Branch (149:7): [True: 65.2k, False: 10.8k] ------------------ 150| 65.2k| { 151| 65.2k| int j; 152| 65.2k| uint32_t save_match_options = match_options; 153| | 154| |#ifdef SUPPORT_JIT 155| | pcre2_jit_compile(code, PCRE2_JIT_COMPLETE); 156| |#endif 157| | 158| | /* Create match data and context blocks only when we first need them. Set 159| | low match and depth limits to avoid wasting too much searching large 160| | pattern trees. Almost all matches are going to fail. */ 161| | 162| 65.2k| if (match_data == NULL) ------------------ | Branch (162:9): [True: 34.0k, False: 31.2k] ------------------ 163| 34.0k| { 164| 34.0k| match_data = pcre2_match_data_create(32, NULL); ------------------ | | 879| 34.0k|#define pcre2_match_data_create PCRE2_SUFFIX(pcre2_match_data_create_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 165| 34.0k| if (match_data == NULL) ------------------ | Branch (165:11): [True: 0, False: 34.0k] ------------------ 166| 0| { 167| |#ifdef STANDALONE 168| | printf("** Failed to create match data block\n"); 169| |#endif 170| 0| return 0; 171| 0| } 172| 34.0k| } 173| | 174| 65.2k| if (match_context == NULL) ------------------ | Branch (174:9): [True: 34.0k, False: 31.2k] ------------------ 175| 34.0k| { 176| 34.0k| match_context = pcre2_match_context_create(NULL); ------------------ | | 877| 34.0k|#define pcre2_match_context_create PCRE2_SUFFIX(pcre2_match_context_create_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 177| 34.0k| if (match_context == NULL) ------------------ | Branch (177:11): [True: 0, False: 34.0k] ------------------ 178| 0| { 179| |#ifdef STANDALONE 180| | printf("** Failed to create match context block\n"); 181| |#endif 182| 0| return 0; 183| 0| } 184| 34.0k| (void)pcre2_set_match_limit(match_context, 100); ------------------ | | 897| 34.0k|#define pcre2_set_match_limit PCRE2_SUFFIX(pcre2_set_match_limit_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 185| 34.0k| (void)pcre2_set_depth_limit(match_context, 100); ------------------ | | 893| 34.0k|#define pcre2_set_depth_limit PCRE2_SUFFIX(pcre2_set_depth_limit_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 186| 34.0k| (void)pcre2_set_callout(match_context, callout_function, &callout_count); ------------------ | | 889| 34.0k|#define pcre2_set_callout PCRE2_SUFFIX(pcre2_set_callout_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 187| 34.0k| } 188| | 189| | /* Match twice, with and without options. */ 190| | 191| 195k| for (j = 0; j < 2; j++) ------------------ | Branch (191:17): [True: 130k, False: 65.2k] ------------------ 192| 130k| { 193| |#ifdef STANDALONE 194| | printf("Match options %.8x", match_options); 195| | printf("%s%s%s%s%s%s%s%s%s%s\n", 196| | ((match_options & PCRE2_ANCHORED) != 0)? ",anchored" : "", 197| | ((match_options & PCRE2_ENDANCHORED) != 0)? ",endanchored" : "", 198| | ((match_options & PCRE2_NO_JIT) != 0)? ",no_jit" : "", 199| | ((match_options & PCRE2_NO_UTF_CHECK) != 0)? ",no_utf_check" : "", 200| | ((match_options & PCRE2_NOTBOL) != 0)? ",notbol" : "", 201| | ((match_options & PCRE2_NOTEMPTY) != 0)? ",notempty" : "", 202| | ((match_options & PCRE2_NOTEMPTY_ATSTART) != 0)? ",notempty_atstart" : "", 203| | ((match_options & PCRE2_NOTEOL) != 0)? ",noteol" : "", 204| | ((match_options & PCRE2_PARTIAL_HARD) != 0)? ",partial_hard" : "", 205| | ((match_options & PCRE2_PARTIAL_SOFT) != 0)? ",partial_soft" : ""); 206| |#endif 207| | 208| 130k| callout_count = 0; 209| 130k| errorcode = pcre2_match(code, (PCRE2_SPTR)data, (PCRE2_SIZE)match_size, 0, ------------------ | | 875| 130k|#define pcre2_match PCRE2_SUFFIX(pcre2_match_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 210| 130k| match_options, match_data, match_context); 211| | 212| |#ifdef STANDALONE 213| | if (errorcode >= 0) printf("Match returned %d\n", errorcode); else 214| | { 215| | unsigned char buffer[256]; 216| | pcre2_get_error_message(errorcode, buffer, 256); 217| | printf("Match failed: error %d: %s\n", errorcode, buffer); 218| | } 219| |#endif 220| | 221| 130k| match_options = 0; /* For second time */ 222| 130k| } 223| | 224| | /* Match with DFA twice, with and without options. */ 225| | 226| 65.2k| match_options = save_match_options & ~PCRE2_NO_JIT; /* Not valid for DFA */ ------------------ | | 189| 65.2k|#define PCRE2_NO_JIT 0x00002000u /* Not for pcre2_dfa_match() */ ------------------ 227| | 228| 195k| for (j = 0; j < 2; j++) ------------------ | Branch (228:17): [True: 130k, False: 65.2k] ------------------ 229| 130k| { 230| |#ifdef STANDALONE 231| | printf("DFA match options %.8x", match_options); 232| | printf("%s%s%s%s%s%s%s%s%s\n", 233| | ((match_options & PCRE2_ANCHORED) != 0)? ",anchored" : "", 234| | ((match_options & PCRE2_ENDANCHORED) != 0)? ",endanchored" : "", 235| | ((match_options & PCRE2_NO_UTF_CHECK) != 0)? ",no_utf_check" : "", 236| | ((match_options & PCRE2_NOTBOL) != 0)? ",notbol" : "", 237| | ((match_options & PCRE2_NOTEMPTY) != 0)? ",notempty" : "", 238| | ((match_options & PCRE2_NOTEMPTY_ATSTART) != 0)? ",notempty_atstart" : "", 239| | ((match_options & PCRE2_NOTEOL) != 0)? ",noteol" : "", 240| | ((match_options & PCRE2_PARTIAL_HARD) != 0)? ",partial_hard" : "", 241| | ((match_options & PCRE2_PARTIAL_SOFT) != 0)? ",partial_soft" : ""); 242| |#endif 243| | 244| 130k| callout_count = 0; 245| 130k| errorcode = pcre2_dfa_match(code, (PCRE2_SPTR)data, ------------------ | | 856| 130k|#define pcre2_dfa_match PCRE2_SUFFIX(pcre2_dfa_match_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 246| 130k| (PCRE2_SIZE)match_size, 0, match_options, match_data, match_context, 247| 130k| dfa_workspace, DFA_WORKSPACE_COUNT); ------------------ | | 22| 130k|#define DFA_WORKSPACE_COUNT 100 ------------------ 248| | 249| |#ifdef STANDALONE 250| | if (errorcode >= 0) printf("Match returned %d\n", errorcode); else 251| | { 252| | unsigned char buffer[256]; 253| | pcre2_get_error_message(errorcode, buffer, 256); 254| | printf("Match failed: error %d: %s\n", errorcode, buffer); 255| | } 256| |#endif 257| | 258| 130k| match_options = 0; /* For second time */ 259| 130k| } 260| | 261| 65.2k| match_options = save_match_options; /* Reset for the second compile */ 262| 65.2k| pcre2_code_free(code); ------------------ | | 846| 65.2k|#define pcre2_code_free PCRE2_SUFFIX(pcre2_code_free_) | | ------------------ | | | | 986| 65.2k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 65.2k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 65.2k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 263| 65.2k| } 264| | 265| | /* Compilation failed */ 266| | 267| 10.8k| else 268| 10.8k| { 269| 10.8k| unsigned char buffer[256]; 270| 10.8k| pcre2_get_error_message(errorcode, buffer, 256); ------------------ | | 860| 10.8k|#define pcre2_get_error_message PCRE2_SUFFIX(pcre2_get_error_message_) | | ------------------ | | | | 986| 10.8k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 10.8k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 10.8k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 271| |#ifdef STANDALONE 272| | printf("Error %d at offset %lu: %s\n", errorcode, erroroffset, buffer); 273| |#else 274| 10.8k| if (strstr((const char *)buffer, "internal error") != NULL) abort(); ------------------ | Branch (274:9): [True: 0, False: 10.8k] ------------------ 275| 10.8k|#endif 276| 10.8k| } 277| | 278| 76.0k| compile_options = PCRE2_NEVER_BACKSLASH_C; /* For second time */ ------------------ | | 139| 76.0k|#define PCRE2_NEVER_BACKSLASH_C 0x00100000u /* C */ ------------------ 279| 76.0k| } 280| | 281| 38.0k|if (match_data != NULL) pcre2_match_data_free(match_data); ------------------ | | 881| 34.0k|#define pcre2_match_data_free PCRE2_SUFFIX(pcre2_match_data_free_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (281:5): [True: 34.0k, False: 4.02k] ------------------ 282| 38.0k|if (match_context != NULL) pcre2_match_context_free(match_context); ------------------ | | 878| 34.0k|#define pcre2_match_context_free PCRE2_SUFFIX(pcre2_match_context_free_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (282:5): [True: 34.0k, False: 4.02k] ------------------ 283| | 284| 38.0k|return 0; 285| 38.0k|} pcre2_fuzzsupport.c:callout_function: 44| 1.02M|{ 45| 1.02M|(void)cb; /* Avoid unused parameter warning */ 46| 1.02M|*((uint32_t *)callout_data) += 1; 47| 1.02M|return (*((uint32_t *)callout_data) > 100)? PCRE2_ERROR_CALLOUT : 0; ------------------ | | 377| 2.99k|#define PCRE2_ERROR_CALLOUT (-37) /* Never used by PCRE2 itself */ ------------------ | Branch (47:8): [True: 2.99k, False: 1.02M] ------------------ 48| 1.02M|} pcre2_match_8: 6331| 130k|{ 6332| 130k|int rc; 6333| 130k|int was_zero_terminated = 0; 6334| 130k|const uint8_t *start_bits = NULL; 6335| 130k|const pcre2_real_code *re = (const pcre2_real_code *)code; 6336| | 6337| 130k|BOOL anchored; 6338| 130k|BOOL firstline; 6339| 130k|BOOL has_first_cu = FALSE; ------------------ | | 69| 130k|#define FALSE 0 ------------------ 6340| 130k|BOOL has_req_cu = FALSE; ------------------ | | 69| 130k|#define FALSE 0 ------------------ 6341| 130k|BOOL startline; 6342| | 6343| 130k|#if PCRE2_CODE_UNIT_WIDTH == 8 6344| 130k|PCRE2_SPTR memchr_found_first_cu; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6345| 130k|PCRE2_SPTR memchr_found_first_cu2; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6346| 130k|#endif 6347| | 6348| 130k|PCRE2_UCHAR first_cu = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6349| 130k|PCRE2_UCHAR first_cu2 = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6350| 130k|PCRE2_UCHAR req_cu = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6351| 130k|PCRE2_UCHAR req_cu2 = 0; ------------------ | | 813| 130k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6352| | 6353| 130k|PCRE2_SPTR bumpalong_limit; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6354| 130k|PCRE2_SPTR end_subject; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6355| 130k|PCRE2_SPTR true_end_subject; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6356| 130k|PCRE2_SPTR start_match; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6357| 130k|PCRE2_SPTR req_cu_ptr; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6358| 130k|PCRE2_SPTR start_partial; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6359| 130k|PCRE2_SPTR match_partial; ------------------ | | 814| 130k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6360| | 6361| |#ifdef SUPPORT_JIT 6362| |BOOL use_jit; 6363| |#endif 6364| | 6365| |/* This flag is needed even when Unicode is not supported for convenience 6366| |(it is used by the IS_NEWLINE macro). */ 6367| | 6368| 130k|BOOL utf = FALSE; ------------------ | | 69| 130k|#define FALSE 0 ------------------ 6369| | 6370| 130k|#ifdef SUPPORT_UNICODE 6371| 130k|BOOL ucp = FALSE; ------------------ | | 69| 130k|#define FALSE 0 ------------------ 6372| 130k|BOOL allow_invalid; 6373| 130k|uint32_t fragment_options = 0; 6374| |#ifdef SUPPORT_JIT 6375| |BOOL jit_checked_utf = FALSE; 6376| |#endif 6377| 130k|#endif /* SUPPORT_UNICODE */ 6378| | 6379| 130k|PCRE2_SIZE frame_size; ------------------ | | 477| 130k|#define PCRE2_SIZE size_t ------------------ 6380| 130k|PCRE2_SIZE heapframes_size; ------------------ | | 477| 130k|#define PCRE2_SIZE size_t ------------------ 6381| | 6382| |/* We need to have mb as a pointer to a match block, because the IS_NEWLINE 6383| |macro is used below, and it expects NLBLOCK to be defined as a pointer. */ 6384| | 6385| 130k|pcre2_callout_block cb; ------------------ | | 831| 130k|#define pcre2_callout_block PCRE2_SUFFIX(pcre2_callout_block_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6386| 130k|match_block actual_match_block; ------------------ | | 1982| 130k|#define match_block PCRE2_SUFFIX(match_block_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6387| 130k|match_block *mb = &actual_match_block; ------------------ | | 1982| 130k|#define match_block PCRE2_SUFFIX(match_block_) | | ------------------ | | | | 986| 130k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 130k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 130k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6388| | 6389| |/* Recognize NULL, length 0 as an empty string. */ 6390| | 6391| 130k|if (subject == NULL && length == 0) subject = (PCRE2_SPTR)""; ------------------ | Branch (6391:5): [True: 0, False: 130k] | Branch (6391:24): [True: 0, False: 0] ------------------ 6392| | 6393| |/* Plausibility checks */ 6394| | 6395| 130k|if ((options & ~PUBLIC_MATCH_OPTIONS) != 0) return PCRE2_ERROR_BADOPTION; ------------------ | | 70| 130k| (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 105| 130k|#define PCRE2_ANCHORED 0x80000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 107| 130k|#define PCRE2_ENDANCHORED 0x20000000u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 176| 130k|#define PCRE2_NOTBOL 0x00000001u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 177| 130k|#define PCRE2_NOTEOL 0x00000002u | | ------------------ | | (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \ | | ------------------ | | | | 178| 130k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ | | ------------------ | | 71| 130k| PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 179| 130k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ | | ------------------ | | PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 106| 130k|#define PCRE2_NO_UTF_CHECK 0x40000000u | | ------------------ | | PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \ | | ------------------ | | | | 181| 130k|#define PCRE2_PARTIAL_HARD 0x00000020u | | ------------------ | | 72| 130k| PCRE2_PARTIAL_SOFT|PCRE2_NO_JIT|PCRE2_COPY_MATCHED_SUBJECT) | | ------------------ | | | | 180| 130k|#define PCRE2_PARTIAL_SOFT 0x00000010u | | ------------------ | | PCRE2_PARTIAL_SOFT|PCRE2_NO_JIT|PCRE2_COPY_MATCHED_SUBJECT) | | ------------------ | | | | 189| 130k|#define PCRE2_NO_JIT 0x00002000u /* Not for pcre2_dfa_match() */ | | ------------------ | | PCRE2_PARTIAL_SOFT|PCRE2_NO_JIT|PCRE2_COPY_MATCHED_SUBJECT) | | ------------------ | | | | 190| 130k|#define PCRE2_COPY_MATCHED_SUBJECT 0x00004000u | | ------------------ ------------------ if ((options & ~PUBLIC_MATCH_OPTIONS) != 0) return PCRE2_ERROR_BADOPTION; ------------------ | | 374| 0|#define PCRE2_ERROR_BADOPTION (-34) ------------------ | Branch (6395:5): [True: 0, False: 130k] ------------------ 6396| 130k|if (code == NULL || subject == NULL || match_data == NULL) ------------------ | Branch (6396:5): [True: 0, False: 130k] | Branch (6396:21): [True: 0, False: 130k] | Branch (6396:40): [True: 0, False: 130k] ------------------ 6397| 0| return PCRE2_ERROR_NULL; ------------------ | | 391| 0|#define PCRE2_ERROR_NULL (-51) ------------------ 6398| | 6399| 130k|start_match = subject + start_offset; 6400| 130k|req_cu_ptr = start_match - 1; 6401| 130k|if (length == PCRE2_ZERO_TERMINATED) ------------------ | | 479| 130k|#define PCRE2_ZERO_TERMINATED (~(PCRE2_SIZE)0) ------------------ | Branch (6401:5): [True: 0, False: 130k] ------------------ 6402| 0| { 6403| 0| length = PRIV(strlen)(subject); ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 6404| 0| was_zero_terminated = 1; 6405| 0| } 6406| 130k|true_end_subject = end_subject = subject + length; 6407| | 6408| 130k|if (start_offset > length) return PCRE2_ERROR_BADOFFSET; ------------------ | | 373| 0|#define PCRE2_ERROR_BADOFFSET (-33) ------------------ | Branch (6408:5): [True: 0, False: 130k] ------------------ 6409| | 6410| |/* Check that the first field in the block is the magic number. */ 6411| | 6412| 130k|if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC; ------------------ | | 546| 130k|#define MAGIC_NUMBER 0x50435245UL /* 'PCRE' */ ------------------ if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC; ------------------ | | 371| 0|#define PCRE2_ERROR_BADMAGIC (-31) ------------------ | Branch (6412:5): [True: 0, False: 130k] ------------------ 6413| | 6414| |/* Check the code unit width. */ 6415| | 6416| 130k|if ((re->flags & PCRE2_MODE_MASK) != PCRE2_CODE_UNIT_WIDTH/8) ------------------ | | 532| 130k|#define PCRE2_MODE_MASK (PCRE2_MODE8 | PCRE2_MODE16 | PCRE2_MODE32) | | ------------------ | | | | 508| 130k|#define PCRE2_MODE8 0x00000001 /* compiled in 8 bit mode */ | | ------------------ | | #define PCRE2_MODE_MASK (PCRE2_MODE8 | PCRE2_MODE16 | PCRE2_MODE32) | | ------------------ | | | | 509| 130k|#define PCRE2_MODE16 0x00000002 /* compiled in 16 bit mode */ | | ------------------ | | #define PCRE2_MODE_MASK (PCRE2_MODE8 | PCRE2_MODE16 | PCRE2_MODE32) | | ------------------ | | | | 510| 130k|#define PCRE2_MODE32 0x00000004 /* compiled in 32 bit mode */ | | ------------------ ------------------ | Branch (6416:5): [True: 0, False: 130k] ------------------ 6417| 0| return PCRE2_ERROR_BADMODE; ------------------ | | 372| 0|#define PCRE2_ERROR_BADMODE (-32) ------------------ 6418| | 6419| |/* PCRE2_NOTEMPTY and PCRE2_NOTEMPTY_ATSTART are match-time flags in the 6420| |options variable for this function. Users of PCRE2 who are not calling the 6421| |function directly would like to have a way of setting these flags, in the same 6422| |way that they can set pcre2_compile() flags like PCRE2_NO_AUTOPOSSESS with 6423| |constructions like (*NO_AUTOPOSSESS). To enable this, (*NOTEMPTY) and 6424| |(*NOTEMPTY_ATSTART) set bits in the pattern's "flag" function which we now 6425| |transfer to the options for this function. The bits are guaranteed to be 6426| |adjacent, but do not have the same values. This bit of Boolean trickery assumes 6427| |that the match-time bits are not more significant than the flag bits. If by 6428| |accident this is not the case, a compile-time division by zero error will 6429| |occur. */ 6430| | 6431| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) 6432| 130k|#define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) 6433| 130k|options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 6431| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 523| 130k|#define PCRE2_NOTEMPTY_SET 0x00010000 /* (*NOTEMPTY) used ) keep */ | | ------------------ | | #define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 524| 130k|#define PCRE2_NE_ATST_SET 0x00020000 /* (*NOTEMPTY_ATSTART) used) together */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 6431| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 523| 130k|#define PCRE2_NOTEMPTY_SET 0x00010000 /* (*NOTEMPTY) used ) keep */ | | ------------------ | | #define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 524| 130k|#define PCRE2_NE_ATST_SET 0x00020000 /* (*NOTEMPTY_ATSTART) used) together */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 6431| 130k|#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 523| 130k|#define PCRE2_NOTEMPTY_SET 0x00010000 /* (*NOTEMPTY) used ) keep */ | | ------------------ | | #define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET) | | ------------------ | | | | 524| 130k|#define PCRE2_NE_ATST_SET 0x00020000 /* (*NOTEMPTY_ATSTART) used) together */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 6432| 130k|#define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 178| 130k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ | | ------------------ | | #define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 179| 130k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ | | ------------------ ------------------ options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1))); ------------------ | | 6432| 130k|#define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 178| 130k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ | | ------------------ | | #define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART) | | ------------------ | | | | 179| 130k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ | | ------------------ ------------------ 6434| 130k|#undef FF 6435| 130k|#undef OO 6436| | 6437| |/* If the pattern was successfully studied with JIT support, we will run the 6438| |JIT executable instead of the rest of this function. Most options must be set 6439| |at compile time for the JIT code to be usable. */ 6440| | 6441| |#ifdef SUPPORT_JIT 6442| |use_jit = (re->executable_jit != NULL && 6443| | (options & ~PUBLIC_JIT_MATCH_OPTIONS) == 0); 6444| |#endif 6445| | 6446| |/* Initialize UTF/UCP parameters. */ 6447| | 6448| 130k|#ifdef SUPPORT_UNICODE 6449| 130k|utf = (re->overall_options & PCRE2_UTF) != 0; ------------------ | | 138| 130k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 6450| 130k|allow_invalid = (re->overall_options & PCRE2_MATCH_INVALID_UTF) != 0; ------------------ | | 145| 130k|#define PCRE2_MATCH_INVALID_UTF 0x04000000u /* J M D */ ------------------ 6451| 130k|ucp = (re->overall_options & PCRE2_UCP) != 0; ------------------ | | 136| 130k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ 6452| 130k|#endif /* SUPPORT_UNICODE */ 6453| | 6454| |/* Convert the partial matching flags into an integer. */ 6455| | 6456| 130k|mb->partial = ((options & PCRE2_PARTIAL_HARD) != 0)? 2 : ------------------ | | 181| 130k|#define PCRE2_PARTIAL_HARD 0x00000020u ------------------ | Branch (6456:15): [True: 18.4k, False: 112k] ------------------ 6457| 130k| ((options & PCRE2_PARTIAL_SOFT) != 0)? 1 : 0; ------------------ | | 180| 112k|#define PCRE2_PARTIAL_SOFT 0x00000010u ------------------ | Branch (6457:15): [True: 9.45k, False: 102k] ------------------ 6458| | 6459| |/* Partial matching and PCRE2_ENDANCHORED are currently not allowed at the same 6460| |time. */ 6461| | 6462| 130k|if (mb->partial != 0 && ------------------ | Branch (6462:5): [True: 27.8k, False: 102k] ------------------ 6463| 130k| ((re->overall_options | options) & PCRE2_ENDANCHORED) != 0) ------------------ | | 107| 27.8k|#define PCRE2_ENDANCHORED 0x20000000u ------------------ | Branch (6463:4): [True: 0, False: 27.8k] ------------------ 6464| 0| return PCRE2_ERROR_BADOPTION; ------------------ | | 374| 0|#define PCRE2_ERROR_BADOPTION (-34) ------------------ 6465| | 6466| |/* It is an error to set an offset limit without setting the flag at compile 6467| |time. */ 6468| | 6469| 130k|if (mcontext != NULL && mcontext->offset_limit != PCRE2_UNSET && ------------------ | | 480| 261k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (6469:5): [True: 130k, False: 0] | Branch (6469:25): [True: 0, False: 130k] ------------------ 6470| 130k| (re->overall_options & PCRE2_USE_OFFSET_LIMIT) == 0) ------------------ | | 142| 0|#define PCRE2_USE_OFFSET_LIMIT 0x00800000u /* J M D */ ------------------ | Branch (6470:6): [True: 0, False: 0] ------------------ 6471| 0| return PCRE2_ERROR_BADOFFSETLIMIT; ------------------ | | 397| 0|#define PCRE2_ERROR_BADOFFSETLIMIT (-56) ------------------ 6472| | 6473| |/* If the match data block was previously used with PCRE2_COPY_MATCHED_SUBJECT, 6474| |free the memory that was obtained. Set the field to NULL for no match cases. */ 6475| | 6476| 130k|if ((match_data->flags & PCRE2_MD_COPIED_SUBJECT) != 0) ------------------ | | 542| 130k|#define PCRE2_MD_COPIED_SUBJECT 0x01u ------------------ | Branch (6476:5): [True: 0, False: 130k] ------------------ 6477| 0| { 6478| 0| match_data->memctl.free((void *)match_data->subject, 6479| 0| match_data->memctl.memory_data); 6480| 0| match_data->flags &= ~PCRE2_MD_COPIED_SUBJECT; ------------------ | | 542| 0|#define PCRE2_MD_COPIED_SUBJECT 0x01u ------------------ 6481| 0| } 6482| 130k|match_data->subject = NULL; 6483| | 6484| |/* Zero the error offset in case the first code unit is invalid UTF. */ 6485| | 6486| 130k|match_data->startchar = 0; 6487| | 6488| | 6489| |/* ============================= JIT matching ============================== */ 6490| | 6491| |/* Prepare for JIT matching. Check a UTF string for validity unless no check is 6492| |requested or invalid UTF can be handled. We check only the portion of the 6493| |subject that might be be inspected during matching - from the offset minus the 6494| |maximum lookbehind to the given length. This saves time when a small part of a 6495| |large subject is being matched by the use of a starting offset. Note that the 6496| |maximum lookbehind is a number of characters, not code units. */ 6497| | 6498| |#ifdef SUPPORT_JIT 6499| |if (use_jit) 6500| | { 6501| |#ifdef SUPPORT_UNICODE 6502| | if (utf && (options & PCRE2_NO_UTF_CHECK) == 0 && !allow_invalid) 6503| | { 6504| |#if PCRE2_CODE_UNIT_WIDTH != 32 6505| | unsigned int i; 6506| |#endif 6507| | 6508| | /* For 8-bit and 16-bit UTF, check that the first code unit is a valid 6509| | character start. */ 6510| | 6511| |#if PCRE2_CODE_UNIT_WIDTH != 32 6512| | if (start_match < end_subject && NOT_FIRSTCU(*start_match)) 6513| | { 6514| | if (start_offset > 0) return PCRE2_ERROR_BADUTFOFFSET; 6515| |#if PCRE2_CODE_UNIT_WIDTH == 8 6516| | return PCRE2_ERROR_UTF8_ERR20; /* Isolated 0x80 byte */ 6517| |#else 6518| | return PCRE2_ERROR_UTF16_ERR3; /* Isolated low surrogate */ 6519| |#endif 6520| | } 6521| |#endif /* WIDTH != 32 */ 6522| | 6523| | /* Move back by the maximum lookbehind, just in case it happens at the very 6524| | start of matching. */ 6525| | 6526| |#if PCRE2_CODE_UNIT_WIDTH != 32 6527| | for (i = re->max_lookbehind; i > 0 && start_match > subject; i--) 6528| | { 6529| | start_match--; 6530| | while (start_match > subject && 6531| |#if PCRE2_CODE_UNIT_WIDTH == 8 6532| | (*start_match & 0xc0) == 0x80) 6533| |#else /* 16-bit */ 6534| | (*start_match & 0xfc00) == 0xdc00) 6535| |#endif 6536| | start_match--; 6537| | } 6538| |#else /* PCRE2_CODE_UNIT_WIDTH != 32 */ 6539| | 6540| | /* In the 32-bit library, one code unit equals one character. However, 6541| | we cannot just subtract the lookbehind and then compare pointers, because 6542| | a very large lookbehind could create an invalid pointer. */ 6543| | 6544| | if (start_offset >= re->max_lookbehind) 6545| | start_match -= re->max_lookbehind; 6546| | else 6547| | start_match = subject; 6548| |#endif /* PCRE2_CODE_UNIT_WIDTH != 32 */ 6549| | 6550| | /* Validate the relevant portion of the subject. Adjust the offset of an 6551| | invalid code point to be an absolute offset in the whole string. */ 6552| | 6553| | match_data->rc = PRIV(valid_utf)(start_match, 6554| | length - (start_match - subject), &(match_data->startchar)); 6555| | if (match_data->rc != 0) 6556| | { 6557| | match_data->startchar += start_match - subject; 6558| | return match_data->rc; 6559| | } 6560| | jit_checked_utf = TRUE; 6561| | } 6562| |#endif /* SUPPORT_UNICODE */ 6563| | 6564| | /* If JIT returns BADOPTION, which means that the selected complete or 6565| | partial matching mode was not compiled, fall through to the interpreter. */ 6566| | 6567| | rc = pcre2_jit_match(code, subject, length, start_offset, options, 6568| | match_data, mcontext); 6569| | if (rc != PCRE2_ERROR_JIT_BADOPTION) 6570| | { 6571| | if (rc >= 0 && (options & PCRE2_COPY_MATCHED_SUBJECT) != 0) 6572| | { 6573| | length = CU2BYTES(length + was_zero_terminated); 6574| | match_data->subject = match_data->memctl.malloc(length, 6575| | match_data->memctl.memory_data); 6576| | if (match_data->subject == NULL) return PCRE2_ERROR_NOMEMORY; 6577| | memcpy((void *)match_data->subject, subject, length); 6578| | match_data->flags |= PCRE2_MD_COPIED_SUBJECT; 6579| | } 6580| | return rc; 6581| | } 6582| | } 6583| |#endif /* SUPPORT_JIT */ 6584| | 6585| |/* ========================= End of JIT matching ========================== */ 6586| | 6587| | 6588| |/* Proceed with non-JIT matching. The default is to allow lookbehinds to the 6589| |start of the subject. A UTF check when there is a non-zero offset may change 6590| |this. */ 6591| | 6592| 130k|mb->check_subject = subject; 6593| | 6594| |/* If a UTF subject string was not checked for validity in the JIT code above, 6595| |check it here, and handle support for invalid UTF strings. The check above 6596| |happens only when invalid UTF is not supported and PCRE2_NO_CHECK_UTF is unset. 6597| |If we get here in those circumstances, it means the subject string is valid, 6598| |but for some reason JIT matching was not successful. There is no need to check 6599| |the subject again. 6600| | 6601| |We check only the portion of the subject that might be be inspected during 6602| |matching - from the offset minus the maximum lookbehind to the given length. 6603| |This saves time when a small part of a large subject is being matched by the 6604| |use of a starting offset. Note that the maximum lookbehind is a number of 6605| |characters, not code units. 6606| | 6607| |Note also that support for invalid UTF forces a check, overriding the setting 6608| |of PCRE2_NO_CHECK_UTF. */ 6609| | 6610| 130k|#ifdef SUPPORT_UNICODE 6611| 130k|if (utf && ------------------ | Branch (6611:5): [True: 43.9k, False: 86.5k] ------------------ 6612| |#ifdef SUPPORT_JIT 6613| | !jit_checked_utf && 6614| |#endif 6615| 130k| ((options & PCRE2_NO_UTF_CHECK) == 0 || allow_invalid)) ------------------ | | 106| 43.9k|#define PCRE2_NO_UTF_CHECK 0x40000000u ------------------ | Branch (6615:6): [True: 43.9k, False: 0] | Branch (6615:45): [True: 0, False: 0] ------------------ 6616| 43.9k| { 6617| 43.9k|#if PCRE2_CODE_UNIT_WIDTH != 32 6618| 43.9k| BOOL skipped_bad_start = FALSE; ------------------ | | 69| 43.9k|#define FALSE 0 ------------------ 6619| 43.9k|#endif 6620| | 6621| | /* For 8-bit and 16-bit UTF, check that the first code unit is a valid 6622| | character start. If we are handling invalid UTF, just skip over such code 6623| | units. Otherwise, give an appropriate error. */ 6624| | 6625| 43.9k|#if PCRE2_CODE_UNIT_WIDTH != 32 6626| 43.9k| if (allow_invalid) ------------------ | Branch (6626:7): [True: 0, False: 43.9k] ------------------ 6627| 0| { 6628| 0| while (start_match < end_subject && NOT_FIRSTCU(*start_match)) ------------------ | | 296| 0|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6628:12): [True: 0, False: 0] ------------------ 6629| 0| { 6630| 0| start_match++; 6631| 0| skipped_bad_start = TRUE; ------------------ | | 70| 0|#define TRUE 1 ------------------ 6632| 0| } 6633| 0| } 6634| 43.9k| else if (start_match < end_subject && NOT_FIRSTCU(*start_match)) ------------------ | | 296| 43.9k|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 0, False: 43.9k] | | ------------------ ------------------ | Branch (6634:12): [True: 43.9k, False: 0] ------------------ 6635| 0| { 6636| 0| if (start_offset > 0) return PCRE2_ERROR_BADUTFOFFSET; ------------------ | | 376| 0|#define PCRE2_ERROR_BADUTFOFFSET (-36) ------------------ | Branch (6636:9): [True: 0, False: 0] ------------------ 6637| 0|#if PCRE2_CODE_UNIT_WIDTH == 8 6638| 0| return PCRE2_ERROR_UTF8_ERR20; /* Isolated 0x80 byte */ ------------------ | | 350| 0|#define PCRE2_ERROR_UTF8_ERR20 (-22) ------------------ 6639| |#else 6640| | return PCRE2_ERROR_UTF16_ERR3; /* Isolated low surrogate */ 6641| |#endif 6642| 0| } 6643| 43.9k|#endif /* WIDTH != 32 */ 6644| | 6645| | /* The mb->check_subject field points to the start of UTF checking; 6646| | lookbehinds can go back no further than this. */ 6647| | 6648| 43.9k| mb->check_subject = start_match; 6649| | 6650| | /* Move back by the maximum lookbehind, just in case it happens at the very 6651| | start of matching, but don't do this if we skipped bad 8-bit or 16-bit code 6652| | units above. */ 6653| | 6654| 43.9k|#if PCRE2_CODE_UNIT_WIDTH != 32 6655| 43.9k| if (!skipped_bad_start) ------------------ | Branch (6655:7): [True: 43.9k, False: 0] ------------------ 6656| 43.9k| { 6657| 43.9k| unsigned int i; 6658| 43.9k| for (i = re->max_lookbehind; i > 0 && mb->check_subject > subject; i--) ------------------ | Branch (6658:34): [True: 1.78k, False: 42.1k] | Branch (6658:43): [True: 0, False: 1.78k] ------------------ 6659| 0| { 6660| 0| mb->check_subject--; 6661| 0| while (mb->check_subject > subject && ------------------ | Branch (6661:14): [True: 0, False: 0] ------------------ 6662| 0|#if PCRE2_CODE_UNIT_WIDTH == 8 6663| 0| (*mb->check_subject & 0xc0) == 0x80) ------------------ | Branch (6663:7): [True: 0, False: 0] ------------------ 6664| |#else /* 16-bit */ 6665| | (*mb->check_subject & 0xfc00) == 0xdc00) 6666| |#endif 6667| 0| mb->check_subject--; 6668| 0| } 6669| 43.9k| } 6670| |#else /* PCRE2_CODE_UNIT_WIDTH != 32 */ 6671| | 6672| | /* In the 32-bit library, one code unit equals one character. However, 6673| | we cannot just subtract the lookbehind and then compare pointers, because 6674| | a very large lookbehind could create an invalid pointer. */ 6675| | 6676| | if (start_offset >= re->max_lookbehind) 6677| | mb->check_subject -= re->max_lookbehind; 6678| | else 6679| | mb->check_subject = subject; 6680| |#endif /* PCRE2_CODE_UNIT_WIDTH != 32 */ 6681| | 6682| | /* Validate the relevant portion of the subject. There's a loop in case we 6683| | encounter bad UTF in the characters preceding start_match which we are 6684| | scanning because of a lookbehind. */ 6685| | 6686| 43.9k| for (;;) 6687| 43.9k| { 6688| 43.9k| match_data->rc = PRIV(valid_utf)(mb->check_subject, ------------------ | | 177| 43.9k|#define PRIV(name) _pcre2_##name ------------------ 6689| 43.9k| length - (mb->check_subject - subject), &(match_data->startchar)); 6690| | 6691| 43.9k| if (match_data->rc == 0) break; /* Valid UTF string */ ------------------ | Branch (6691:9): [True: 43.9k, False: 20] ------------------ 6692| | 6693| | /* Invalid UTF string. Adjust the offset to be an absolute offset in the 6694| | whole string. If we are handling invalid UTF strings, set end_subject to 6695| | stop before the bad code unit, and set the options to "not end of line". 6696| | Otherwise return the error. */ 6697| | 6698| 20| match_data->startchar += mb->check_subject - subject; 6699| 20| if (!allow_invalid || match_data->rc > 0) return match_data->rc; ------------------ | Branch (6699:9): [True: 20, False: 0] | Branch (6699:27): [True: 0, False: 0] ------------------ 6700| 0| end_subject = subject + match_data->startchar; 6701| | 6702| | /* If the end precedes start_match, it means there is invalid UTF in the 6703| | extra code units we reversed over because of a lookbehind. Advance past the 6704| | first bad code unit, and then skip invalid character starting code units in 6705| | 8-bit and 16-bit modes, and try again with the original end point. */ 6706| | 6707| 0| if (end_subject < start_match) ------------------ | Branch (6707:9): [True: 0, False: 0] ------------------ 6708| 0| { 6709| 0| mb->check_subject = end_subject + 1; 6710| 0|#if PCRE2_CODE_UNIT_WIDTH != 32 6711| 0| while (mb->check_subject < start_match && NOT_FIRSTCU(*mb->check_subject)) ------------------ | | 296| 0|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6711:14): [True: 0, False: 0] ------------------ 6712| 0| mb->check_subject++; 6713| 0|#endif 6714| 0| end_subject = true_end_subject; 6715| 0| } 6716| | 6717| | /* Otherwise, set the not end of line option, and do the match. */ 6718| | 6719| 0| else 6720| 0| { 6721| 0| fragment_options = PCRE2_NOTEOL; ------------------ | | 177| 0|#define PCRE2_NOTEOL 0x00000002u ------------------ 6722| 0| break; 6723| 0| } 6724| 0| } 6725| 43.9k| } 6726| 130k|#endif /* SUPPORT_UNICODE */ 6727| | 6728| |/* A NULL match context means "use a default context", but we take the memory 6729| |control functions from the pattern. */ 6730| | 6731| 130k|if (mcontext == NULL) ------------------ | Branch (6731:5): [True: 0, False: 130k] ------------------ 6732| 0| { 6733| 0| mcontext = (pcre2_match_context *)(&PRIV(default_match_context)); ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 6734| 0| mb->memctl = re->memctl; 6735| 0| } 6736| 130k|else mb->memctl = mcontext->memctl; 6737| | 6738| 130k|anchored = ((re->overall_options | options) & PCRE2_ANCHORED) != 0; ------------------ | | 105| 130k|#define PCRE2_ANCHORED 0x80000000u ------------------ 6739| 130k|firstline = (re->overall_options & PCRE2_FIRSTLINE) != 0; ------------------ | | 127| 130k|#define PCRE2_FIRSTLINE 0x00000100u /* J M D */ ------------------ 6740| 130k|startline = (re->flags & PCRE2_STARTLINE) != 0; ------------------ | | 516| 130k|#define PCRE2_STARTLINE 0x00000200 /* start after \n for multiline */ ------------------ 6741| 130k|bumpalong_limit = (mcontext->offset_limit == PCRE2_UNSET)? ------------------ | | 480| 130k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (6741:19): [True: 130k, False: 0] ------------------ 6742| 130k| true_end_subject : subject + mcontext->offset_limit; 6743| | 6744| |/* Initialize and set up the fixed fields in the callout block, with a pointer 6745| |in the match block. */ 6746| | 6747| 130k|mb->cb = &cb; 6748| 130k|cb.version = 2; 6749| 130k|cb.subject = subject; 6750| 130k|cb.subject_length = (PCRE2_SIZE)(end_subject - subject); 6751| 130k|cb.callout_flags = 0; 6752| | 6753| |/* Fill in the remaining fields in the match block, except for moptions, which 6754| |gets set later. */ 6755| | 6756| 130k|mb->callout = mcontext->callout; 6757| 130k|mb->callout_data = mcontext->callout_data; 6758| | 6759| 130k|mb->start_subject = subject; 6760| 130k|mb->start_offset = start_offset; 6761| 130k|mb->end_subject = end_subject; 6762| 130k|mb->hasthen = (re->flags & PCRE2_HASTHEN) != 0; ------------------ | | 519| 130k|#define PCRE2_HASTHEN 0x00001000 /* pattern contains (*THEN) */ ------------------ 6763| 130k|mb->allowemptypartial = (re->max_lookbehind > 0) || ------------------ | Branch (6763:25): [True: 5.82k, False: 124k] ------------------ 6764| 130k| (re->flags & PCRE2_MATCH_EMPTY) != 0; ------------------ | | 520| 124k|#define PCRE2_MATCH_EMPTY 0x00002000 /* pattern can match empty string */ ------------------ | Branch (6764:5): [True: 32.8k, False: 91.8k] ------------------ 6765| 130k|mb->poptions = re->overall_options; /* Pattern options */ 6766| 130k|mb->ignore_skip_arg = 0; 6767| 130k|mb->mark = mb->nomatch_mark = NULL; /* In case never set */ 6768| | 6769| |/* The name table is needed for finding all the numbers associated with a 6770| |given name, for condition testing. The code follows the name table. */ 6771| | 6772| 130k|mb->name_table = (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code)); 6773| 130k|mb->name_count = re->name_count; 6774| 130k|mb->name_entry_size = re->name_entry_size; 6775| 130k|mb->start_code = mb->name_table + re->name_count * re->name_entry_size; 6776| | 6777| |/* Process the \R and newline settings. */ 6778| | 6779| 130k|mb->bsr_convention = re->bsr_convention; 6780| 130k|mb->nltype = NLTYPE_FIXED; ------------------ | | 472| 130k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ 6781| 130k|switch(re->newline_convention) 6782| 130k| { 6783| 170| case PCRE2_NEWLINE_CR: ------------------ | | 209| 170|#define PCRE2_NEWLINE_CR 1 ------------------ | Branch (6783:3): [True: 170, False: 130k] ------------------ 6784| 170| mb->nllen = 1; 6785| 170| mb->nl[0] = CHAR_CR; ------------------ | | 972| 170|#define CHAR_CR '\015' ------------------ 6786| 170| break; 6787| | 6788| 125k| case PCRE2_NEWLINE_LF: ------------------ | | 210| 125k|#define PCRE2_NEWLINE_LF 2 ------------------ | Branch (6788:3): [True: 125k, False: 5.09k] ------------------ 6789| 125k| mb->nllen = 1; 6790| 125k| mb->nl[0] = CHAR_NL; ------------------ | | 974| 125k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 125k|#define CHAR_LF '\012' | | ------------------ ------------------ 6791| 125k| break; 6792| | 6793| 10| case PCRE2_NEWLINE_NUL: ------------------ | | 214| 10|#define PCRE2_NEWLINE_NUL 6 ------------------ | Branch (6793:3): [True: 10, False: 130k] ------------------ 6794| 10| mb->nllen = 1; 6795| 10| mb->nl[0] = CHAR_NUL; ------------------ | | 981| 10|#define CHAR_NUL '\0' ------------------ 6796| 10| break; 6797| | 6798| 2.34k| case PCRE2_NEWLINE_CRLF: ------------------ | | 211| 2.34k|#define PCRE2_NEWLINE_CRLF 3 ------------------ | Branch (6798:3): [True: 2.34k, False: 128k] ------------------ 6799| 2.34k| mb->nllen = 2; 6800| 2.34k| mb->nl[0] = CHAR_CR; ------------------ | | 972| 2.34k|#define CHAR_CR '\015' ------------------ 6801| 2.34k| mb->nl[1] = CHAR_NL; ------------------ | | 974| 2.34k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 2.34k|#define CHAR_LF '\012' | | ------------------ ------------------ 6802| 2.34k| break; 6803| | 6804| 2.31k| case PCRE2_NEWLINE_ANY: ------------------ | | 212| 2.31k|#define PCRE2_NEWLINE_ANY 4 ------------------ | Branch (6804:3): [True: 2.31k, False: 128k] ------------------ 6805| 2.31k| mb->nltype = NLTYPE_ANY; ------------------ | | 473| 2.31k|#define NLTYPE_ANY 1 /* Newline is any Unicode line ending */ ------------------ 6806| 2.31k| break; 6807| | 6808| 252| case PCRE2_NEWLINE_ANYCRLF: ------------------ | | 213| 252|#define PCRE2_NEWLINE_ANYCRLF 5 ------------------ | Branch (6808:3): [True: 252, False: 130k] ------------------ 6809| 252| mb->nltype = NLTYPE_ANYCRLF; ------------------ | | 474| 252|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ 6810| 252| break; 6811| | 6812| 0| default: return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ | Branch (6812:3): [True: 0, False: 130k] ------------------ 6813| 130k| } 6814| | 6815| |/* The backtracking frames have fixed data at the front, and a PCRE2_SIZE 6816| |vector at the end, whose size depends on the number of capturing parentheses in 6817| |the pattern. It is not used at all if there are no capturing parentheses. 6818| | 6819| | frame_size is the total size of each frame 6820| | match_data->heapframes is the pointer to the frames vector 6821| | match_data->heapframes_size is the allocated size of the vector 6822| | 6823| |We must pad the frame_size for alignment to ensure subsequent frames are as 6824| |aligned as heapframe. Whilst ovector is word-aligned due to being a PCRE2_SIZE 6825| |array, that does not guarantee it is suitably aligned for pointers, as some 6826| |architectures have pointers that are larger than a size_t. */ 6827| | 6828| 130k|frame_size = (offsetof(heapframe, ovector) + 6829| 130k| re->top_bracket * 2 * sizeof(PCRE2_SIZE) + HEAPFRAME_ALIGNMENT - 1) & ------------------ | | 853| 130k|#define HEAPFRAME_ALIGNMENT offsetof(heapframe_align, frame) ------------------ 6830| 130k| ~(HEAPFRAME_ALIGNMENT - 1); ------------------ | | 853| 130k|#define HEAPFRAME_ALIGNMENT offsetof(heapframe_align, frame) ------------------ 6831| | 6832| |/* Limits set in the pattern override the match context only if they are 6833| |smaller. */ 6834| | 6835| 130k|mb->heap_limit = ((mcontext->heap_limit < re->limit_heap)? ------------------ | Branch (6835:19): [True: 130k, False: 0] ------------------ 6836| 130k| mcontext->heap_limit : re->limit_heap); 6837| | 6838| 130k|mb->match_limit = (mcontext->match_limit < re->limit_match)? ------------------ | Branch (6838:19): [True: 130k, False: 0] ------------------ 6839| 130k| mcontext->match_limit : re->limit_match; 6840| | 6841| 130k|mb->match_limit_depth = (mcontext->depth_limit < re->limit_depth)? ------------------ | Branch (6841:25): [True: 130k, False: 0] ------------------ 6842| 130k| mcontext->depth_limit : re->limit_depth; 6843| | 6844| |/* If a pattern has very many capturing parentheses, the frame size may be very 6845| |large. Set the initial frame vector size to ensure that there are at least 10 6846| |available frames, but enforce a minimum of START_FRAMES_SIZE. If this is 6847| |greater than the heap limit, get as large a vector as possible. Always round 6848| |the size to a multiple of the frame size. */ 6849| | 6850| 130k|heapframes_size = frame_size * 10; 6851| 130k|if (heapframes_size < START_FRAMES_SIZE) heapframes_size = START_FRAMES_SIZE; ------------------ | | 230| 130k|#define START_FRAMES_SIZE 20480 ------------------ if (heapframes_size < START_FRAMES_SIZE) heapframes_size = START_FRAMES_SIZE; ------------------ | | 230| 130k|#define START_FRAMES_SIZE 20480 ------------------ | Branch (6851:5): [True: 130k, False: 332] ------------------ 6852| 130k|if (heapframes_size / 1024 > mb->heap_limit) ------------------ | Branch (6852:5): [True: 0, False: 130k] ------------------ 6853| 0| { 6854| 0| PCRE2_SIZE max_size = 1024 * mb->heap_limit; ------------------ | | 477| 0|#define PCRE2_SIZE size_t ------------------ 6855| 0| if (max_size < frame_size) return PCRE2_ERROR_HEAPLIMIT; ------------------ | | 404| 0|#define PCRE2_ERROR_HEAPLIMIT (-63) ------------------ | Branch (6855:7): [True: 0, False: 0] ------------------ 6856| 0| heapframes_size = max_size; 6857| 0| } 6858| | 6859| |/* If an existing frame vector in the match_data block is large enough, we can 6860| |use it. Otherwise, free any pre-existing vector and get a new one. */ 6861| | 6862| 130k|if (match_data->heapframes_size < heapframes_size) ------------------ | Branch (6862:5): [True: 34.0k, False: 96.4k] ------------------ 6863| 34.0k| { 6864| 34.0k| match_data->memctl.free(match_data->heapframes, 6865| 34.0k| match_data->memctl.memory_data); 6866| 34.0k| match_data->heapframes = match_data->memctl.malloc(heapframes_size, 6867| 34.0k| match_data->memctl.memory_data); 6868| 34.0k| if (match_data->heapframes == NULL) ------------------ | Branch (6868:7): [True: 0, False: 34.0k] ------------------ 6869| 0| { 6870| 0| match_data->heapframes_size = 0; 6871| 0| return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ 6872| 0| } 6873| 34.0k| match_data->heapframes_size = heapframes_size; 6874| 34.0k| } 6875| | 6876| |/* Write to the ovector within the first frame to mark every capture unset and 6877| |to avoid uninitialized memory read errors when it is copied to a new frame. */ 6878| | 6879| 130k|memset((char *)(match_data->heapframes) + offsetof(heapframe, ovector), 0xff, 6880| 130k| frame_size - offsetof(heapframe, ovector)); 6881| | 6882| |/* Pointers to the individual character tables */ 6883| | 6884| 130k|mb->lcc = re->tables + lcc_offset; ------------------ | | 588| 130k|#define lcc_offset 0 /* Lower case */ ------------------ 6885| 130k|mb->fcc = re->tables + fcc_offset; ------------------ | | 589| 130k|#define fcc_offset 256 /* Flip case */ ------------------ 6886| 130k|mb->ctypes = re->tables + ctypes_offset; ------------------ | | 591| 130k|#define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | ------------------ | | | | 590| 130k|#define cbits_offset 512 /* Character classes */ | | ------------------ | | #define ctypes_offset (cbits_offset + cbit_length) /* Character types */ | | ------------------ | | | | 573| 130k|#define cbit_length 320 /* Length of the cbits table */ | | ------------------ ------------------ 6887| | 6888| |/* Set up the first code unit to match, if available. If there's no first code 6889| |unit there may be a bitmap of possible first characters. */ 6890| | 6891| 130k|if ((re->flags & PCRE2_FIRSTSET) != 0) ------------------ | | 511| 130k|#define PCRE2_FIRSTSET 0x00000010 /* first_code unit is set */ ------------------ | Branch (6891:5): [True: 17.3k, False: 113k] ------------------ 6892| 17.3k| { 6893| 17.3k| has_first_cu = TRUE; ------------------ | | 70| 17.3k|#define TRUE 1 ------------------ 6894| 17.3k| first_cu = first_cu2 = (PCRE2_UCHAR)(re->first_codeunit); 6895| 17.3k| if ((re->flags & PCRE2_FIRSTCASELESS) != 0) ------------------ | | 512| 17.3k|#define PCRE2_FIRSTCASELESS 0x00000020 /* caseless first code unit */ ------------------ | Branch (6895:7): [True: 890, False: 16.4k] ------------------ 6896| 890| { 6897| 890| first_cu2 = TABLE_GET(first_cu, mb->fcc, first_cu); ------------------ | | 214| 890|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 6898| 890|#ifdef SUPPORT_UNICODE 6899| 890|#if PCRE2_CODE_UNIT_WIDTH == 8 6900| 890| if (first_cu > 127 && ucp && !utf) first_cu2 = UCD_OTHERCASE(first_cu); ------------------ | | 1862| 128|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 128|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 128|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 128|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 128| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 128|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 128|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 128|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 128| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 128|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 128|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (6900:9): [True: 128, False: 762] | Branch (6900:27): [True: 128, False: 0] | Branch (6900:34): [True: 128, False: 0] ------------------ 6901| |#else 6902| | if (first_cu > 127 && (utf || ucp)) first_cu2 = UCD_OTHERCASE(first_cu); 6903| |#endif 6904| 890|#endif /* SUPPORT_UNICODE */ 6905| 890| } 6906| 17.3k| } 6907| 113k|else 6908| 113k| if (!startline && (re->flags & PCRE2_FIRSTMAPSET) != 0) ------------------ | | 513| 109k|#define PCRE2_FIRSTMAPSET 0x00000040 /* bitmap of first code units is set */ ------------------ | Branch (6908:7): [True: 109k, False: 3.46k] | Branch (6908:21): [True: 18.8k, False: 90.7k] ------------------ 6909| 18.8k| start_bits = re->start_bitmap; 6910| | 6911| |/* There may also be a "last known required character" set. */ 6912| | 6913| 130k|if ((re->flags & PCRE2_LASTSET) != 0) ------------------ | | 514| 130k|#define PCRE2_LASTSET 0x00000080 /* last code unit is set */ ------------------ | Branch (6913:5): [True: 45.7k, False: 84.8k] ------------------ 6914| 45.7k| { 6915| 45.7k| has_req_cu = TRUE; ------------------ | | 70| 45.7k|#define TRUE 1 ------------------ 6916| 45.7k| req_cu = req_cu2 = (PCRE2_UCHAR)(re->last_codeunit); 6917| 45.7k| if ((re->flags & PCRE2_LASTCASELESS) != 0) ------------------ | | 515| 45.7k|#define PCRE2_LASTCASELESS 0x00000100 /* caseless last code unit */ ------------------ | Branch (6917:7): [True: 1.70k, False: 43.9k] ------------------ 6918| 1.70k| { 6919| 1.70k| req_cu2 = TABLE_GET(req_cu, mb->fcc, req_cu); ------------------ | | 214| 1.70k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 6920| 1.70k|#ifdef SUPPORT_UNICODE 6921| 1.70k|#if PCRE2_CODE_UNIT_WIDTH == 8 6922| 1.70k| if (req_cu > 127 && ucp && !utf) req_cu2 = UCD_OTHERCASE(req_cu); ------------------ | | 1862| 262|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 262|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 262|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 262|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 262| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 262|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 262|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 262|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 262| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 262|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 262|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (6922:9): [True: 262, False: 1.44k] | Branch (6922:25): [True: 262, False: 0] | Branch (6922:32): [True: 262, False: 0] ------------------ 6923| |#else 6924| | if (req_cu > 127 && (utf || ucp)) req_cu2 = UCD_OTHERCASE(req_cu); 6925| |#endif 6926| 1.70k|#endif /* SUPPORT_UNICODE */ 6927| 1.70k| } 6928| 45.7k| } 6929| | 6930| | 6931| |/* ==========================================================================*/ 6932| | 6933| |/* Loop for handling unanchored repeated matching attempts; for anchored regexs 6934| |the loop runs just once. */ 6935| | 6936| 130k|#ifdef SUPPORT_UNICODE 6937| 131k|FRAGMENT_RESTART: 6938| 131k|#endif 6939| | 6940| 131k|start_partial = match_partial = NULL; 6941| 131k|mb->hitend = FALSE; ------------------ | | 69| 131k|#define FALSE 0 ------------------ 6942| | 6943| 131k|#if PCRE2_CODE_UNIT_WIDTH == 8 6944| 131k|memchr_found_first_cu = NULL; 6945| 131k|memchr_found_first_cu2 = NULL; 6946| 131k|#endif 6947| | 6948| 131k|for(;;) 6949| 1.06M| { 6950| 1.06M| PCRE2_SPTR new_start_match; ------------------ | | 814| 1.06M|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.06M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.06M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.06M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6951| | 6952| | /* ----------------- Start of match optimizations ---------------- */ 6953| | 6954| | /* There are some optimizations that avoid running the match if a known 6955| | starting point is not found, or if a known later code unit is not present. 6956| | However, there is an option (settable at compile time) that disables these, 6957| | for testing and for ensuring that all callouts do actually occur. */ 6958| | 6959| 1.06M| if ((re->overall_options & PCRE2_NO_START_OPTIMIZE) == 0) ------------------ | | 135| 1.06M|#define PCRE2_NO_START_OPTIMIZE 0x00010000u /* J M D */ ------------------ | Branch (6959:7): [True: 753k, False: 313k] ------------------ 6960| 753k| { 6961| | /* If firstline is TRUE, the start of the match is constrained to the first 6962| | line of a multiline string. That is, the match must be before or at the 6963| | first newline following the start of matching. Temporarily adjust 6964| | end_subject so that we stop the scans for a first code unit at a newline. 6965| | If the match fails at the newline, later code breaks the loop. */ 6966| | 6967| 753k| if (firstline) ------------------ | Branch (6967:9): [True: 143k, False: 609k] ------------------ 6968| 143k| { 6969| 143k| PCRE2_SPTR t = start_match; ------------------ | | 814| 143k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 143k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 143k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 143k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6970| 143k|#ifdef SUPPORT_UNICODE 6971| 143k| if (utf) ------------------ | Branch (6971:11): [True: 89.3k, False: 54.2k] ------------------ 6972| 89.3k| { 6973| 1.83M| while (t < end_subject && !IS_NEWLINE(t)) ------------------ | | 479| 1.75M| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 1.75M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 1.75M|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 12.2k, False: 1.73M] | | ------------------ | | 480| 1.75M| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 12.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 24.5k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 12.2k, False: 0] | | ------------------ | | 481| 12.2k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 12.2k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 12.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 12.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 12.2k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 930, False: 11.3k] | | ------------------ | | 482| 12.2k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 12.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 1.75M| : \ | | 484| 1.75M| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 1.73M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 1.73M|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 1.73M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 1.73M, False: 3.10k] | | ------------------ | | 485| 1.73M| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 1.73M|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 1.73M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 10.7k, False: 1.72M] | | ------------------ | | 486| 1.73M| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 10.7k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 7.97k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 7.97k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 2.76k, False: 7.97k] | | | Branch (486:30): [True: 251, False: 7.72k] | | ------------------ | | 487| 1.73M| ) \ | | 488| 1.75M| ) ------------------ | Branch (6973:16): [True: 1.75M, False: 85.3k] | Branch (6973:35): [True: 1.74M, False: 3.94k] ------------------ 6974| 1.74M| { 6975| 1.74M| t++; 6976| 1.74M| ACROSSCHAR(t < end_subject, t, t++); ------------------ | | 353| 1.82M| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 1.74M, False: 82.0k] | | | Branch (353:24): [True: 75.5k, False: 1.66M] | | ------------------ ------------------ 6977| 1.74M| } 6978| 89.3k| } 6979| 54.2k| else 6980| 54.2k|#endif 6981| 2.08M| while (t < end_subject && !IS_NEWLINE(t)) t++; ------------------ | | 479| 2.03M| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 2.03M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 2.03M|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 6.59k, False: 2.02M] | | ------------------ | | 480| 2.03M| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 6.59k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 13.1k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 6.59k, False: 0] | | ------------------ | | 481| 6.59k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 6.59k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 6.59k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 6.59k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 6.59k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 274, False: 6.31k] | | ------------------ | | 482| 6.59k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 6.59k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 2.03M| : \ | | 484| 2.03M| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 2.02M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 2.02M|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 2.02M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 2.02M, False: 937] | | ------------------ | | 485| 2.02M| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 2.02M|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 2.02M|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 9.09k, False: 2.01M] | | ------------------ | | 486| 2.02M| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 9.09k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 7.09k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 7.09k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.99k, False: 7.09k] | | | Branch (486:30): [True: 122, False: 6.97k] | | ------------------ | | 487| 2.02M| ) \ | | 488| 2.03M| ) ------------------ | Branch (6981:14): [True: 2.03M, False: 51.9k] | Branch (6981:33): [True: 2.03M, False: 2.39k] ------------------ 6982| 143k| end_subject = t; 6983| 143k| } 6984| | 6985| | /* Anchored: check the first code unit if one is recorded. This may seem 6986| | pointless but it can help in detecting a no match case without scanning for 6987| | the required code unit. */ 6988| | 6989| 753k| if (anchored) ------------------ | Branch (6989:9): [True: 21.5k, False: 731k] ------------------ 6990| 21.5k| { 6991| 21.5k| if (has_first_cu || start_bits != NULL) ------------------ | Branch (6991:11): [True: 5.14k, False: 16.4k] | Branch (6991:27): [True: 3.02k, False: 13.4k] ------------------ 6992| 8.16k| { 6993| 8.16k| BOOL ok = start_match < end_subject; 6994| 8.16k| if (ok) ------------------ | Branch (6994:13): [True: 7.36k, False: 804] ------------------ 6995| 7.36k| { 6996| 7.36k| PCRE2_UCHAR c = UCHAR21TEST(start_match); ------------------ | | 813| 7.36k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 7.36k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 7.36k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 7.36k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_UCHAR c = UCHAR21TEST(start_match); ------------------ | | 244| 7.36k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 6997| 7.36k| ok = has_first_cu && (c == first_cu || c == first_cu2); ------------------ | Branch (6997:16): [True: 4.55k, False: 2.80k] | Branch (6997:33): [True: 1.77k, False: 2.78k] | Branch (6997:50): [True: 4, False: 2.77k] ------------------ 6998| 7.36k| if (!ok && start_bits != NULL) ------------------ | Branch (6998:15): [True: 5.58k, False: 1.77k] | Branch (6998:22): [True: 2.80k, False: 2.77k] ------------------ 6999| 2.80k| { 7000| |#if PCRE2_CODE_UNIT_WIDTH != 8 7001| | if (c > 255) c = 255; 7002| |#endif 7003| 2.80k| ok = (start_bits[c/8] & (1u << (c&7))) != 0; 7004| 2.80k| } 7005| 7.36k| } 7006| 8.16k| if (!ok) ------------------ | Branch (7006:13): [True: 5.16k, False: 3.00k] ------------------ 7007| 5.16k| { 7008| 5.16k| rc = MATCH_NOMATCH; ------------------ | | 83| 5.16k|#define MATCH_NOMATCH 0 ------------------ 7009| 5.16k| break; 7010| 5.16k| } 7011| 8.16k| } 7012| 21.5k| } 7013| | 7014| | /* Not anchored. Advance to a unique first code unit if there is one. */ 7015| | 7016| 731k| else 7017| 731k| { 7018| 731k| if (has_first_cu) ------------------ | Branch (7018:11): [True: 32.9k, False: 698k] ------------------ 7019| 32.9k| { 7020| 32.9k| if (first_cu != first_cu2) /* Caseless */ ------------------ | Branch (7020:13): [True: 3.70k, False: 29.1k] ------------------ 7021| 3.70k| { 7022| | /* In 16-bit and 32_bit modes we have to do our own search, so can 7023| | look for both cases at once. */ 7024| | 7025| |#if PCRE2_CODE_UNIT_WIDTH != 8 7026| | PCRE2_UCHAR smc; 7027| | while (start_match < end_subject && 7028| | (smc = UCHAR21TEST(start_match)) != first_cu && 7029| | smc != first_cu2) 7030| | start_match++; 7031| |#else 7032| | /* In 8-bit mode, the use of memchr() gives a big speed up, even 7033| | though we have to call it twice in order to find the earliest 7034| | occurrence of the code unit in either of its cases. Caching is used 7035| | to remember the positions of previously found code units. This can 7036| | make a huge difference when the strings are very long and only one 7037| | case is actually present. */ 7038| | 7039| 3.70k| PCRE2_SPTR pp1 = NULL; ------------------ | | 814| 3.70k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 3.70k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 3.70k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 3.70k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7040| 3.70k| PCRE2_SPTR pp2 = NULL; ------------------ | | 814| 3.70k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 3.70k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 3.70k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 3.70k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7041| 3.70k| PCRE2_SIZE searchlength = end_subject - start_match; ------------------ | | 477| 3.70k|#define PCRE2_SIZE size_t ------------------ 7042| | 7043| | /* If we haven't got a previously found position for first_cu, or if 7044| | the current starting position is later, we need to do a search. If 7045| | the code unit is not found, set it to the end. */ 7046| | 7047| 3.70k| if (memchr_found_first_cu == NULL || ------------------ | Branch (7047:15): [True: 638, False: 3.06k] ------------------ 7048| 3.70k| start_match > memchr_found_first_cu) ------------------ | Branch (7048:15): [True: 1.08k, False: 1.98k] ------------------ 7049| 1.72k| { 7050| 1.72k| pp1 = memchr(start_match, first_cu, searchlength); 7051| 1.72k| memchr_found_first_cu = (pp1 == NULL)? end_subject : pp1; ------------------ | Branch (7051:37): [True: 370, False: 1.35k] ------------------ 7052| 1.72k| } 7053| | 7054| | /* If the start is before a previously found position, use the 7055| | previous position, or NULL if a previous search failed. */ 7056| | 7057| 1.98k| else pp1 = (memchr_found_first_cu == end_subject)? NULL : ------------------ | Branch (7057:22): [True: 809, False: 1.17k] ------------------ 7058| 1.98k| memchr_found_first_cu; 7059| | 7060| | /* Do the same thing for the other case. */ 7061| | 7062| 3.70k| if (memchr_found_first_cu2 == NULL || ------------------ | Branch (7062:15): [True: 638, False: 3.06k] ------------------ 7063| 3.70k| start_match > memchr_found_first_cu2) ------------------ | Branch (7063:15): [True: 674, False: 2.39k] ------------------ 7064| 1.31k| { 7065| 1.31k| pp2 = memchr(start_match, first_cu2, searchlength); 7066| 1.31k| memchr_found_first_cu2 = (pp2 == NULL)? end_subject : pp2; ------------------ | Branch (7066:38): [True: 530, False: 782] ------------------ 7067| 1.31k| } 7068| | 7069| 2.39k| else pp2 = (memchr_found_first_cu2 == end_subject)? NULL : ------------------ | Branch (7069:22): [True: 988, False: 1.40k] ------------------ 7070| 2.39k| memchr_found_first_cu2; 7071| | 7072| | /* Set the start to the end of the subject if neither case was found. 7073| | Otherwise, use the earlier found point. */ 7074| | 7075| 3.70k| if (pp1 == NULL) ------------------ | Branch (7075:15): [True: 1.17k, False: 2.52k] ------------------ 7076| 1.17k| start_match = (pp2 == NULL)? end_subject : pp2; ------------------ | Branch (7076:27): [True: 477, False: 702] ------------------ 7077| 2.52k| else 7078| 2.52k| start_match = (pp2 == NULL || pp1 < pp2)? pp1 : pp2; ------------------ | Branch (7078:28): [True: 1.04k, False: 1.48k] | Branch (7078:43): [True: 958, False: 529] ------------------ 7079| | 7080| 3.70k|#endif /* 8-bit handling */ 7081| 3.70k| } 7082| | 7083| | /* The caseful case is much simpler. */ 7084| | 7085| 29.1k| else 7086| 29.1k| { 7087| |#if PCRE2_CODE_UNIT_WIDTH != 8 7088| | while (start_match < end_subject && UCHAR21TEST(start_match) != 7089| | first_cu) 7090| | start_match++; 7091| |#else 7092| 29.1k| start_match = memchr(start_match, first_cu, end_subject - start_match); 7093| 29.1k| if (start_match == NULL) start_match = end_subject; ------------------ | Branch (7093:15): [True: 5.72k, False: 23.4k] ------------------ 7094| 29.1k|#endif 7095| 29.1k| } 7096| | 7097| | /* If we can't find the required first code unit, having reached the 7098| | true end of the subject, break the bumpalong loop, to force a match 7099| | failure, except when doing partial matching, when we let the next cycle 7100| | run at the end of the subject. To see why, consider the pattern 7101| | /(?<=abc)def/, which partially matches "abc", even though the string 7102| | does not contain the starting character "d". If we have not reached the 7103| | true end of the subject (PCRE2_FIRSTLINE caused end_subject to be 7104| | temporarily modified) we also let the cycle run, because the matching 7105| | string is legitimately allowed to start with the first code unit of a 7106| | newline. */ 7107| | 7108| 32.9k| if (mb->partial == 0 && start_match >= mb->end_subject) ------------------ | Branch (7108:13): [True: 25.2k, False: 7.60k] | Branch (7108:33): [True: 4.15k, False: 21.1k] ------------------ 7109| 4.15k| { 7110| 4.15k| rc = MATCH_NOMATCH; ------------------ | | 83| 4.15k|#define MATCH_NOMATCH 0 ------------------ 7111| 4.15k| break; 7112| 4.15k| } 7113| 32.9k| } 7114| | 7115| | /* If there's no first code unit, advance to just after a linebreak for a 7116| | multiline match if required. */ 7117| | 7118| 698k| else if (startline) ------------------ | Branch (7118:16): [True: 9.53k, False: 689k] ------------------ 7119| 9.53k| { 7120| 9.53k| if (start_match > mb->start_subject + start_offset) ------------------ | Branch (7120:13): [True: 4.84k, False: 4.69k] ------------------ 7121| 4.84k| { 7122| 4.84k|#ifdef SUPPORT_UNICODE 7123| 4.84k| if (utf) ------------------ | Branch (7123:15): [True: 1.72k, False: 3.12k] ------------------ 7124| 1.72k| { 7125| 7.11k| while (start_match < end_subject && !WAS_NEWLINE(start_match)) ------------------ | | 493| 6.53k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 6.53k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 6.53k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (493:4): [True: 3.10k, False: 3.42k] | | ------------------ | | 494| 6.53k| ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 59| 3.10k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 60| 6.20k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (494:6): [True: 3.10k, False: 0] | | ------------------ | | 495| 3.10k| PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 177| 3.10k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 59| 3.10k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 59| 3.10k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 60| 3.10k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (495:6): [True: 506, False: 2.59k] | | ------------------ | | 496| 3.10k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 3.10k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 497| 6.53k| : \ | | 498| 6.53k| ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 59| 3.42k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 60| 3.42k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 59| 3.42k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (498:6): [True: 3.38k, False: 39] | | ------------------ | | 499| 3.42k| UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 3.38k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 3.38k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (499:6): [True: 840, False: 2.54k] | | ------------------ | | 500| 3.42k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 840|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 228|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 228|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (500:7): [True: 612, False: 228] | | | Branch (500:30): [True: 18, False: 210] | | ------------------ | | 501| 3.42k| ) \ | | 502| 6.53k| ) ------------------ | Branch (7125:20): [True: 6.53k, False: 586] | Branch (7125:49): [True: 5.39k, False: 1.13k] ------------------ 7126| 5.39k| { 7127| 5.39k| start_match++; 7128| 5.39k| ACROSSCHAR(start_match < end_subject, start_match, start_match++); ------------------ | | 353| 5.90k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 5.61k, False: 289] | | | Branch (353:24): [True: 510, False: 5.10k] | | ------------------ ------------------ 7129| 5.39k| } 7130| 1.72k| } 7131| 3.12k| else 7132| 3.12k|#endif 7133| 24.1k| while (start_match < end_subject && !WAS_NEWLINE(start_match)) ------------------ | | 493| 22.2k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 22.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 22.2k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (493:4): [True: 3.99k, False: 18.2k] | | ------------------ | | 494| 22.2k| ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 59| 3.99k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 60| 7.99k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (494:6): [True: 3.99k, False: 0] | | ------------------ | | 495| 3.99k| PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 177| 3.99k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 59| 3.99k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 59| 3.99k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 60| 3.99k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (495:6): [True: 672, False: 3.32k] | | ------------------ | | 496| 3.99k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 3.99k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 497| 22.2k| : \ | | 498| 22.2k| ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 59| 18.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 60| 18.2k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 59| 18.2k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (498:6): [True: 18.1k, False: 52] | | ------------------ | | 499| 18.2k| UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 18.1k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 18.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (499:6): [True: 684, False: 17.4k] | | ------------------ | | 500| 18.2k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 684|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 220|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 220|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (500:7): [True: 464, False: 220] | | | Branch (500:30): [True: 3, False: 217] | | ------------------ | | 501| 18.2k| ) \ | | 502| 22.2k| ) ------------------ | Branch (7133:18): [True: 22.2k, False: 1.98k] | Branch (7133:47): [True: 21.0k, False: 1.13k] ------------------ 7134| 21.0k| start_match++; 7135| | 7136| | /* If we have just passed a CR and the newline option is ANY or 7137| | ANYCRLF, and we are now at a LF, advance the match position by one 7138| | more code unit. */ 7139| | 7140| 4.84k| if (start_match[-1] == CHAR_CR && ------------------ | | 972| 9.68k|#define CHAR_CR '\015' ------------------ | Branch (7140:15): [True: 1.68k, False: 3.15k] ------------------ 7141| 4.84k| (mb->nltype == NLTYPE_ANY || mb->nltype == NLTYPE_ANYCRLF) && ------------------ | | 473| 3.36k|#define NLTYPE_ANY 1 /* Newline is any Unicode line ending */ ------------------ (mb->nltype == NLTYPE_ANY || mb->nltype == NLTYPE_ANYCRLF) && ------------------ | | 474| 736|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ | Branch (7141:17): [True: 948, False: 736] | Branch (7141:45): [True: 207, False: 529] ------------------ 7142| 4.84k| start_match < end_subject && ------------------ | Branch (7142:16): [True: 931, False: 224] ------------------ 7143| 4.84k| UCHAR21TEST(start_match) == CHAR_NL) ------------------ | | 244| 931|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ UCHAR21TEST(start_match) == CHAR_NL) ------------------ | | 974| 931|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 931|#define CHAR_LF '\012' | | ------------------ ------------------ | Branch (7143:16): [True: 194, False: 737] ------------------ 7144| 194| start_match++; 7145| 4.84k| } 7146| 9.53k| } 7147| | 7148| | /* If there's no first code unit or a requirement for a multiline line 7149| | start, advance to a non-unique first code unit if any have been 7150| | identified. The bitmap contains only 256 bits. When code units are 16 or 7151| | 32 bits wide, all code units greater than 254 set the 255 bit. */ 7152| | 7153| 689k| else if (start_bits != NULL) ------------------ | Branch (7153:16): [True: 71.2k, False: 617k] ------------------ 7154| 71.2k| { 7155| 163k| while (start_match < end_subject) ------------------ | Branch (7155:16): [True: 158k, False: 5.76k] ------------------ 7156| 158k| { 7157| 158k| uint32_t c = UCHAR21TEST(start_match); ------------------ | | 244| 158k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 7158| |#if PCRE2_CODE_UNIT_WIDTH != 8 7159| | if (c > 255) c = 255; 7160| |#endif 7161| 158k| if ((start_bits[c/8] & (1u << (c&7))) != 0) break; ------------------ | Branch (7161:15): [True: 65.4k, False: 92.5k] ------------------ 7162| 92.5k| start_match++; 7163| 92.5k| } 7164| | 7165| | /* See comment above in first_cu checking about the next few lines. */ 7166| | 7167| 71.2k| if (mb->partial == 0 && start_match >= mb->end_subject) ------------------ | Branch (7167:13): [True: 57.2k, False: 13.9k] | Branch (7167:33): [True: 3.73k, False: 53.5k] ------------------ 7168| 3.73k| { 7169| 3.73k| rc = MATCH_NOMATCH; ------------------ | | 83| 3.73k|#define MATCH_NOMATCH 0 ------------------ 7170| 3.73k| break; 7171| 3.73k| } 7172| 71.2k| } 7173| 731k| } /* End first code unit handling */ 7174| | 7175| | /* Restore fudged end_subject */ 7176| | 7177| 740k| end_subject = mb->end_subject; 7178| | 7179| | /* The following two optimizations must be disabled for partial matching. */ 7180| | 7181| 740k| if (mb->partial == 0) ------------------ | Branch (7181:9): [True: 530k, False: 209k] ------------------ 7182| 530k| { 7183| 530k| PCRE2_SPTR p; ------------------ | | 814| 530k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 530k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 530k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 530k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7184| | 7185| | /* The minimum matching length is a lower bound; no string of that length 7186| | may actually match the pattern. Although the value is, strictly, in 7187| | characters, we treat it as code units to avoid spending too much time in 7188| | this optimization. */ 7189| | 7190| 530k| if (end_subject - start_match < re->minlength) ------------------ | Branch (7190:11): [True: 22.0k, False: 508k] ------------------ 7191| 22.0k| { 7192| 22.0k| rc = MATCH_NOMATCH; ------------------ | | 83| 22.0k|#define MATCH_NOMATCH 0 ------------------ 7193| 22.0k| break; 7194| 22.0k| } 7195| | 7196| | /* If req_cu is set, we know that that code unit must appear in the 7197| | subject for the (non-partial) match to succeed. If the first code unit is 7198| | set, req_cu must be later in the subject; otherwise the test starts at 7199| | the match point. This optimization can save a huge amount of backtracking 7200| | in patterns with nested unlimited repeats that aren't going to match. 7201| | Writing separate code for caseful/caseless versions makes it go faster, 7202| | as does using an autoincrement and backing off on a match. As in the case 7203| | of the first code unit, using memchr() in the 8-bit library gives a big 7204| | speed up. Unlike the first_cu check above, we do not need to call 7205| | memchr() twice in the caseless case because we only need to check for the 7206| | presence of the character in either case, not find the first occurrence. 7207| | 7208| | The search can be skipped if the code unit was found later than the 7209| | current starting point in a previous iteration of the bumpalong loop. 7210| | 7211| | HOWEVER: when the subject string is very, very long, searching to its end 7212| | can take a long time, and give bad performance on quite ordinary 7213| | anchored patterns. This showed up when somebody was matching something 7214| | like /^\d+C/ on a 32-megabyte string... so we don't do this when the 7215| | string is sufficiently long, but it's worth searching a lot more for 7216| | unanchored patterns. */ 7217| | 7218| 508k| p = start_match + (has_first_cu? 1:0); ------------------ | Branch (7218:26): [True: 20.0k, False: 488k] ------------------ 7219| 508k| if (has_req_cu && p > req_cu_ptr) ------------------ | Branch (7219:11): [True: 267k, False: 241k] | Branch (7219:25): [True: 39.7k, False: 227k] ------------------ 7220| 39.7k| { 7221| 39.7k| PCRE2_SIZE check_length = end_subject - start_match; ------------------ | | 477| 39.7k|#define PCRE2_SIZE size_t ------------------ 7222| | 7223| 39.7k| if (check_length < REQ_CU_MAX || ------------------ | | 554| 79.4k|#define REQ_CU_MAX 5000 ------------------ | Branch (7223:13): [True: 39.7k, False: 0] ------------------ 7224| 39.7k| (!anchored && check_length < REQ_CU_MAX * 1000)) ------------------ | | 554| 0|#define REQ_CU_MAX 5000 ------------------ | Branch (7224:16): [True: 0, False: 0] | Branch (7224:29): [True: 0, False: 0] ------------------ 7225| 39.7k| { 7226| 39.7k| if (req_cu != req_cu2) /* Caseless */ ------------------ | Branch (7226:15): [True: 1.75k, False: 37.9k] ------------------ 7227| 1.75k| { 7228| |#if PCRE2_CODE_UNIT_WIDTH != 8 7229| | while (p < end_subject) 7230| | { 7231| | uint32_t pp = UCHAR21INCTEST(p); 7232| | if (pp == req_cu || pp == req_cu2) { p--; break; } 7233| | } 7234| |#else /* 8-bit code units */ 7235| 1.75k| PCRE2_SPTR pp = p; ------------------ | | 814| 1.75k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.75k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.75k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.75k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 7236| 1.75k| p = memchr(pp, req_cu, end_subject - pp); 7237| 1.75k| if (p == NULL) ------------------ | Branch (7237:17): [True: 366, False: 1.39k] ------------------ 7238| 366| { 7239| 366| p = memchr(pp, req_cu2, end_subject - pp); 7240| 366| if (p == NULL) p = end_subject; ------------------ | Branch (7240:19): [True: 156, False: 210] ------------------ 7241| 366| } 7242| 1.75k|#endif /* PCRE2_CODE_UNIT_WIDTH != 8 */ 7243| 1.75k| } 7244| | 7245| | /* The caseful case */ 7246| | 7247| 37.9k| else 7248| 37.9k| { 7249| |#if PCRE2_CODE_UNIT_WIDTH != 8 7250| | while (p < end_subject) 7251| | { 7252| | if (UCHAR21INCTEST(p) == req_cu) { p--; break; } 7253| | } 7254| | 7255| |#else /* 8-bit code units */ 7256| 37.9k| p = memchr(p, req_cu, end_subject - p); 7257| 37.9k| if (p == NULL) p = end_subject; ------------------ | Branch (7257:17): [True: 1.86k, False: 36.1k] ------------------ 7258| 37.9k|#endif 7259| 37.9k| } 7260| | 7261| | /* If we can't find the required code unit, break the bumpalong loop, 7262| | forcing a match failure. */ 7263| | 7264| 39.7k| if (p >= end_subject) ------------------ | Branch (7264:15): [True: 2.02k, False: 37.7k] ------------------ 7265| 2.02k| { 7266| 2.02k| rc = MATCH_NOMATCH; ------------------ | | 83| 2.02k|#define MATCH_NOMATCH 0 ------------------ 7267| 2.02k| break; 7268| 2.02k| } 7269| | 7270| | /* If we have found the required code unit, save the point where we 7271| | found it, so that we don't search again next time round the bumpalong 7272| | loop if the start hasn't yet passed this code unit. */ 7273| | 7274| 37.7k| req_cu_ptr = p; 7275| 37.7k| } 7276| 39.7k| } 7277| 508k| } 7278| 740k| } 7279| | 7280| | /* ------------ End of start of match optimizations ------------ */ 7281| | 7282| | /* Give no match if we have passed the bumpalong limit. */ 7283| | 7284| 1.02M| if (start_match > bumpalong_limit) ------------------ | Branch (7284:7): [True: 0, False: 1.02M] ------------------ 7285| 0| { 7286| 0| rc = MATCH_NOMATCH; ------------------ | | 83| 0|#define MATCH_NOMATCH 0 ------------------ 7287| 0| break; 7288| 0| } 7289| | 7290| | /* OK, we can now run the match. If "hitend" is set afterwards, remember the 7291| | first starting point for which a partial match was found. */ 7292| | 7293| 1.02M| cb.start_match = (PCRE2_SIZE)(start_match - subject); 7294| 1.02M| cb.callout_flags |= PCRE2_CALLOUT_STARTMATCH; ------------------ | | 518| 1.02M|#define PCRE2_CALLOUT_STARTMATCH 0x00000001u /* Set for each bumpalong */ ------------------ 7295| | 7296| 1.02M| mb->start_used_ptr = start_match; 7297| 1.02M| mb->last_used_ptr = start_match; 7298| 1.02M|#ifdef SUPPORT_UNICODE 7299| 1.02M| mb->moptions = options | fragment_options; 7300| |#else 7301| | mb->moptions = options; 7302| |#endif 7303| 1.02M| mb->match_call_count = 0; 7304| 1.02M| mb->end_offset_top = 0; 7305| 1.02M| mb->skip_arg_count = 0; 7306| | 7307| 1.02M| rc = match(start_match, mb->start_code, re->top_bracket, frame_size, 7308| 1.02M| match_data, mb); 7309| | 7310| 1.02M| if (mb->hitend && start_partial == NULL) ------------------ | Branch (7310:7): [True: 39.5k, False: 990k] | Branch (7310:21): [True: 11.9k, False: 27.6k] ------------------ 7311| 11.9k| { 7312| 11.9k| start_partial = mb->start_used_ptr; 7313| 11.9k| match_partial = start_match; 7314| 11.9k| } 7315| | 7316| 1.02M| switch(rc) 7317| 1.02M| { 7318| | /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched 7319| | the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP 7320| | entirely. The only way we can do that is to re-do the match at the same 7321| | point, with a flag to force SKIP with an argument to be ignored. Just 7322| | treating this case as NOMATCH does not work because it does not check other 7323| | alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */ 7324| | 7325| 270k| case MATCH_SKIP_ARG: ------------------ | | 95| 270k|#define MATCH_SKIP_ARG (-994) ------------------ | Branch (7325:5): [True: 270k, False: 759k] ------------------ 7326| 270k| new_start_match = start_match; 7327| 270k| mb->ignore_skip_arg = mb->skip_arg_count; 7328| 270k| break; 7329| | 7330| | /* SKIP passes back the next starting point explicitly, but if it is no 7331| | greater than the match we have just done, treat it as NOMATCH. */ 7332| | 7333| 1.53k| case MATCH_SKIP: ------------------ | | 94| 1.53k|#define MATCH_SKIP (-995) ------------------ | Branch (7333:5): [True: 1.53k, False: 1.02M] ------------------ 7334| 1.53k| if (mb->verb_skip_ptr > start_match) ------------------ | Branch (7334:9): [True: 523, False: 1.00k] ------------------ 7335| 523| { 7336| 523| new_start_match = mb->verb_skip_ptr; 7337| 523| break; 7338| 523| } 7339| | /* Fall through */ 7340| | 7341| | /* NOMATCH and PRUNE advance by one character. THEN at this level acts 7342| | exactly like PRUNE. Unset ignore SKIP-with-argument. */ 7343| | 7344| 696k| case MATCH_NOMATCH: ------------------ | | 83| 696k|#define MATCH_NOMATCH 0 ------------------ | Branch (7344:5): [True: 695k, False: 334k] ------------------ 7345| 697k| case MATCH_PRUNE: ------------------ | | 93| 697k|#define MATCH_PRUNE (-996) ------------------ | Branch (7345:5): [True: 1.12k, False: 1.02M] ------------------ 7346| 700k| case MATCH_THEN: ------------------ | | 96| 700k|#define MATCH_THEN (-993) ------------------ | Branch (7346:5): [True: 2.66k, False: 1.02M] ------------------ 7347| 700k| mb->ignore_skip_arg = 0; 7348| 700k| new_start_match = start_match + 1; 7349| 700k|#ifdef SUPPORT_UNICODE 7350| 700k| if (utf) ------------------ | Branch (7350:9): [True: 267k, False: 432k] ------------------ 7351| 267k| ACROSSCHAR(new_start_match < end_subject, new_start_match, ------------------ | | 353| 291k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 263k, False: 27.4k] | | | Branch (353:24): [True: 23.5k, False: 240k] | | ------------------ ------------------ 7352| 700k| new_start_match++); 7353| 700k|#endif 7354| 700k| break; 7355| | 7356| | /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */ 7357| | 7358| 164| case MATCH_COMMIT: ------------------ | | 92| 164|#define MATCH_COMMIT (-997) ------------------ | Branch (7358:5): [True: 164, False: 1.02M] ------------------ 7359| 164| rc = MATCH_NOMATCH; ------------------ | | 83| 164|#define MATCH_NOMATCH 0 ------------------ 7360| 164| goto ENDLOOP; 7361| | 7362| | /* Any other return is either a match, or some kind of error. */ 7363| | 7364| 58.2k| default: ------------------ | Branch (7364:5): [True: 58.2k, False: 971k] ------------------ 7365| 58.2k| goto ENDLOOP; 7366| 1.02M| } 7367| | 7368| | /* Control reaches here for the various types of "no match at this point" 7369| | result. Reset the code to MATCH_NOMATCH for subsequent checking. */ 7370| | 7371| 971k| rc = MATCH_NOMATCH; ------------------ | | 83| 971k|#define MATCH_NOMATCH 0 ------------------ 7372| | 7373| | /* If PCRE2_FIRSTLINE is set, the match must happen before or at the first 7374| | newline in the subject (though it may continue over the newline). Therefore, 7375| | if we have just failed to match, starting at a newline, do not continue. */ 7376| | 7377| 971k| if (firstline && IS_NEWLINE(start_match)) break; ------------------ | | 479| 308k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 308k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 308k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 952, False: 307k] | | | Branch (479:4): [True: 10.3k, False: 297k] | | ------------------ | | 480| 308k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 10.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 20.6k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 10.0k, False: 275] | | ------------------ | | 481| 10.3k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 10.0k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 10.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 10.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 10.0k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 133, False: 9.92k] | | ------------------ | | 482| 10.0k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 10.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 308k| : \ | | 484| 308k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 297k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 297k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 297k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 285k, False: 12.0k] | | ------------------ | | 485| 297k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 285k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 285k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.27k, False: 284k] | | ------------------ | | 486| 297k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.27k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 530|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 530|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 741, False: 530] | | | Branch (486:30): [True: 78, False: 452] | | ------------------ | | 487| 297k| ) \ | | 488| 308k| ) ------------------ | Branch (7377:7): [True: 308k, False: 663k] ------------------ 7378| | 7379| | /* Advance to new matching position */ 7380| | 7381| 970k| start_match = new_start_match; 7382| | 7383| | /* Break the loop if the pattern is anchored or if we have passed the end of 7384| | the subject. */ 7385| | 7386| 970k| if (anchored || start_match > end_subject) break; ------------------ | Branch (7386:7): [True: 13.7k, False: 956k] | Branch (7386:19): [True: 21.5k, False: 935k] ------------------ 7387| | 7388| | /* If we have just passed a CR and we are now at a LF, and the pattern does 7389| | not contain any explicit matches for \r or \n, and the newline option is CRLF 7390| | or ANY or ANYCRLF, advance the match position by one more code unit. In 7391| | normal matching start_match will aways be greater than the first position at 7392| | this stage, but a failed *SKIP can cause a return at the same point, which is 7393| | why the first test exists. */ 7394| | 7395| 935k| if (start_match > subject + start_offset && ------------------ | Branch (7395:7): [True: 923k, False: 11.8k] ------------------ 7396| 935k| start_match[-1] == CHAR_CR && ------------------ | | 972| 1.85M|#define CHAR_CR '\015' ------------------ | Branch (7396:7): [True: 6.69k, False: 916k] ------------------ 7397| 935k| start_match < end_subject && ------------------ | Branch (7397:7): [True: 5.47k, False: 1.21k] ------------------ 7398| 935k| *start_match == CHAR_NL && ------------------ | | 974| 5.47k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 940k|#define CHAR_LF '\012' | | ------------------ ------------------ | Branch (7398:7): [True: 1.80k, False: 3.66k] ------------------ 7399| 935k| (re->flags & PCRE2_HASCRORLF) == 0 && ------------------ | | 518| 1.80k|#define PCRE2_HASCRORLF 0x00000800 /* explicit \r or \n in pattern */ ------------------ | Branch (7399:7): [True: 1.11k, False: 693] ------------------ 7400| 935k| (mb->nltype == NLTYPE_ANY || ------------------ | | 473| 2.22k|#define NLTYPE_ANY 1 /* Newline is any Unicode line ending */ ------------------ | Branch (7400:10): [True: 198, False: 916] ------------------ 7401| 1.11k| mb->nltype == NLTYPE_ANYCRLF || ------------------ | | 474| 2.03k|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ | Branch (7401:10): [True: 194, False: 722] ------------------ 7402| 1.11k| mb->nllen == 2)) ------------------ | Branch (7402:10): [True: 269, False: 453] ------------------ 7403| 661| start_match++; 7404| | 7405| 935k| mb->mark = NULL; /* Reset for start of next match attempt */ 7406| 935k| } /* End of for(;;) "bumpalong" loop */ 7407| | 7408| |/* ==========================================================================*/ 7409| | 7410| |/* When we reach here, one of the following stopping conditions is true: 7411| | 7412| |(1) The match succeeded, either completely, or partially; 7413| | 7414| |(2) The pattern is anchored or the match was failed after (*COMMIT); 7415| | 7416| |(3) We are past the end of the subject or the bumpalong limit; 7417| | 7418| |(4) PCRE2_FIRSTLINE is set and we have failed to match at a newline, because 7419| | this option requests that a match occur at or before the first newline in 7420| | the subject. 7421| | 7422| |(5) Some kind of error occurred. 7423| | 7424| |*/ 7425| | 7426| 131k|ENDLOOP: 7427| | 7428| |/* If end_subject != true_end_subject, it means we are handling invalid UTF, 7429| |and have just processed a non-terminal fragment. If this resulted in no match 7430| |or a partial match we must carry on to the next fragment (a partial match is 7431| |returned to the caller only at the very end of the subject). A loop is used to 7432| |avoid trying to match against empty fragments; if the pattern can match an 7433| |empty string it would have done so already. */ 7434| | 7435| 131k|#ifdef SUPPORT_UNICODE 7436| 131k|if (utf && end_subject != true_end_subject && ------------------ | Branch (7436:5): [True: 45.2k, False: 86.5k] | Branch (7436:12): [True: 1.32k, False: 43.9k] ------------------ 7437| 131k| (rc == MATCH_NOMATCH || rc == PCRE2_ERROR_PARTIAL)) ------------------ | | 83| 2.65k|#define MATCH_NOMATCH 0 ------------------ (rc == MATCH_NOMATCH || rc == PCRE2_ERROR_PARTIAL)) ------------------ | | 327| 0|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (7437:6): [True: 1.32k, False: 0] | Branch (7437:29): [True: 0, False: 0] ------------------ 7438| 1.32k| { 7439| 1.32k| for (;;) 7440| 1.32k| { 7441| | /* Advance past the first bad code unit, and then skip invalid character 7442| | starting code units in 8-bit and 16-bit modes. */ 7443| | 7444| 1.32k| start_match = end_subject + 1; 7445| | 7446| 1.32k|#if PCRE2_CODE_UNIT_WIDTH != 32 7447| 1.55k| while (start_match < true_end_subject && NOT_FIRSTCU(*start_match)) ------------------ | | 296| 1.51k|#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u) | | ------------------ | | | Branch (296:24): [True: 226, False: 1.29k] | | ------------------ ------------------ | Branch (7447:12): [True: 1.51k, False: 36] ------------------ 7448| 226| start_match++; 7449| 1.32k|#endif 7450| | 7451| | /* If we have hit the end of the subject, there isn't another non-empty 7452| | fragment, so give up. */ 7453| | 7454| 1.32k| if (start_match >= true_end_subject) ------------------ | Branch (7454:9): [True: 36, False: 1.29k] ------------------ 7455| 36| { 7456| 36| rc = MATCH_NOMATCH; /* In case it was partial */ ------------------ | | 83| 36|#define MATCH_NOMATCH 0 ------------------ 7457| 36| match_partial = NULL; 7458| 36| break; 7459| 36| } 7460| | 7461| | /* Check the rest of the subject */ 7462| | 7463| 1.29k| mb->check_subject = start_match; 7464| 1.29k| rc = PRIV(valid_utf)(start_match, length - (start_match - subject), ------------------ | | 177| 1.29k|#define PRIV(name) _pcre2_##name ------------------ 7465| 1.29k| &(match_data->startchar)); 7466| | 7467| | /* The rest of the subject is valid UTF. */ 7468| | 7469| 1.29k| if (rc == 0) ------------------ | Branch (7469:9): [True: 1.29k, False: 0] ------------------ 7470| 1.29k| { 7471| 1.29k| mb->end_subject = end_subject = true_end_subject; 7472| 1.29k| fragment_options = PCRE2_NOTBOL; ------------------ | | 176| 1.29k|#define PCRE2_NOTBOL 0x00000001u ------------------ 7473| 1.29k| goto FRAGMENT_RESTART; 7474| 1.29k| } 7475| | 7476| | /* A subsequent UTF error has been found; if the next fragment is 7477| | non-empty, set up to process it. Otherwise, let the loop advance. */ 7478| | 7479| 0| else if (rc < 0) ------------------ | Branch (7479:14): [True: 0, False: 0] ------------------ 7480| 0| { 7481| 0| mb->end_subject = end_subject = start_match + match_data->startchar; 7482| 0| if (end_subject > start_match) ------------------ | Branch (7482:11): [True: 0, False: 0] ------------------ 7483| 0| { 7484| 0| fragment_options = PCRE2_NOTBOL|PCRE2_NOTEOL; ------------------ | | 176| 0|#define PCRE2_NOTBOL 0x00000001u ------------------ fragment_options = PCRE2_NOTBOL|PCRE2_NOTEOL; ------------------ | | 177| 0|#define PCRE2_NOTEOL 0x00000002u ------------------ 7485| 0| goto FRAGMENT_RESTART; 7486| 0| } 7487| 0| } 7488| 1.29k| } 7489| 1.32k| } 7490| 130k|#endif /* SUPPORT_UNICODE */ 7491| | 7492| |/* Fill in fields that are always returned in the match data. */ 7493| | 7494| 130k|match_data->code = re; 7495| 130k|match_data->mark = mb->mark; 7496| 130k|match_data->matchedby = PCRE2_MATCHEDBY_INTERPRETER; 7497| | 7498| |/* Handle a fully successful match. Set the return code to the number of 7499| |captured strings, or 0 if there were too many to fit into the ovector, and then 7500| |set the remaining returned values before returning. Make a copy of the subject 7501| |string if requested. */ 7502| | 7503| 130k|if (rc == MATCH_MATCH) ------------------ | | 82| 130k|#define MATCH_MATCH 1 ------------------ | Branch (7503:5): [True: 45.2k, False: 85.2k] ------------------ 7504| 45.2k| { 7505| 45.2k| match_data->rc = ((int)mb->end_offset_top >= 2 * match_data->oveccount)? ------------------ | Branch (7505:20): [True: 94, False: 45.1k] ------------------ 7506| 45.1k| 0 : (int)mb->end_offset_top/2 + 1; 7507| 45.2k| match_data->startchar = start_match - subject; 7508| 45.2k| match_data->leftchar = mb->start_used_ptr - subject; 7509| 45.2k| match_data->rightchar = ((mb->last_used_ptr > mb->end_match_ptr)? ------------------ | Branch (7509:28): [True: 3.11k, False: 42.1k] ------------------ 7510| 42.1k| mb->last_used_ptr : mb->end_match_ptr) - subject; 7511| 45.2k| if ((options & PCRE2_COPY_MATCHED_SUBJECT) != 0) ------------------ | | 190| 45.2k|#define PCRE2_COPY_MATCHED_SUBJECT 0x00004000u ------------------ | Branch (7511:7): [True: 0, False: 45.2k] ------------------ 7512| 0| { 7513| 0| length = CU2BYTES(length + was_zero_terminated); ------------------ | | 545| 0|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ 7514| 0| match_data->subject = match_data->memctl.malloc(length, 7515| 0| match_data->memctl.memory_data); 7516| 0| if (match_data->subject == NULL) return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ | Branch (7516:9): [True: 0, False: 0] ------------------ 7517| 0| memcpy((void *)match_data->subject, subject, length); 7518| 0| match_data->flags |= PCRE2_MD_COPIED_SUBJECT; ------------------ | | 542| 0|#define PCRE2_MD_COPIED_SUBJECT 0x01u ------------------ 7519| 0| } 7520| 45.2k| else match_data->subject = subject; 7521| 45.2k| return match_data->rc; 7522| 45.2k| } 7523| | 7524| |/* Control gets here if there has been a partial match, an error, or if the 7525| |overall match attempt has failed at all permitted starting positions. Any mark 7526| |data is in the nomatch_mark field. */ 7527| | 7528| 85.2k|match_data->mark = mb->nomatch_mark; 7529| | 7530| |/* For anything other than nomatch or partial match, just return the code. */ 7531| | 7532| 85.2k|if (rc != MATCH_NOMATCH && rc != PCRE2_ERROR_PARTIAL) match_data->rc = rc; ------------------ | | 83| 170k|#define MATCH_NOMATCH 0 ------------------ if (rc != MATCH_NOMATCH && rc != PCRE2_ERROR_PARTIAL) match_data->rc = rc; ------------------ | | 327| 12.9k|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (7532:5): [True: 12.9k, False: 72.2k] | Branch (7532:28): [True: 7.06k, False: 5.92k] ------------------ 7533| | 7534| |/* Handle a partial match. If a "soft" partial match was requested, searching 7535| |for a complete match will have continued, and the value of rc at this point 7536| |will be MATCH_NOMATCH. For a "hard" partial match, it will already be 7537| |PCRE2_ERROR_PARTIAL. */ 7538| | 7539| 78.1k|else if (match_partial != NULL) ------------------ | Branch (7539:10): [True: 10.2k, False: 67.9k] ------------------ 7540| 10.2k| { 7541| 10.2k| match_data->subject = subject; 7542| 10.2k| match_data->ovector[0] = match_partial - subject; 7543| 10.2k| match_data->ovector[1] = end_subject - subject; 7544| 10.2k| match_data->startchar = match_partial - subject; 7545| 10.2k| match_data->leftchar = start_partial - subject; 7546| 10.2k| match_data->rightchar = end_subject - subject; 7547| 10.2k| match_data->rc = PCRE2_ERROR_PARTIAL; ------------------ | | 327| 10.2k|#define PCRE2_ERROR_PARTIAL (-2) ------------------ 7548| 10.2k| } 7549| | 7550| |/* Else this is the classic nomatch case. */ 7551| | 7552| 67.9k|else match_data->rc = PCRE2_ERROR_NOMATCH; ------------------ | | 326| 67.9k|#define PCRE2_ERROR_NOMATCH (-1) ------------------ 7553| | 7554| 85.2k|return match_data->rc; 7555| 130k|} pcre2_match.c:match: 591| 1.02M|{ 592| |/* Frame-handling variables */ 593| | 594| 1.02M|heapframe *F; /* Current frame pointer */ 595| 1.02M|heapframe *N = NULL; /* Temporary frame pointers */ 596| 1.02M|heapframe *P = NULL; 597| | 598| 1.02M|heapframe *frames_top; /* End of frames vector */ 599| 1.02M|heapframe *assert_accept_frame = NULL; /* For passing back a frame with captures */ 600| 1.02M|PCRE2_SIZE heapframes_size; /* Usable size of frames vector */ ------------------ | | 477| 1.02M|#define PCRE2_SIZE size_t ------------------ 601| 1.02M|PCRE2_SIZE frame_copy_size; /* Amount to copy when creating a new frame */ ------------------ | | 477| 1.02M|#define PCRE2_SIZE size_t ------------------ 602| | 603| |/* Local variables that do not need to be preserved over calls to RRMATCH(). */ 604| | 605| 1.02M|PCRE2_SPTR bracode; /* Temp pointer to start of group */ ------------------ | | 814| 1.02M|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.02M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.02M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.02M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 606| 1.02M|PCRE2_SIZE offset; /* Used for group offsets */ ------------------ | | 477| 1.02M|#define PCRE2_SIZE size_t ------------------ 607| 1.02M|PCRE2_SIZE length; /* Used for various length calculations */ ------------------ | | 477| 1.02M|#define PCRE2_SIZE size_t ------------------ 608| | 609| 1.02M|int rrc; /* Return from functions & backtracking "recursions" */ 610| 1.02M|#ifdef SUPPORT_UNICODE 611| 1.02M|int proptype; /* Type of character property */ 612| 1.02M|#endif 613| | 614| 1.02M|uint32_t i; /* Used for local loops */ 615| 1.02M|uint32_t fc; /* Character values */ 616| 1.02M|uint32_t number; /* Used for group and other numbers */ 617| 1.02M|uint32_t reptype = 0; /* Type of repetition (0 to avoid compiler warning) */ 618| 1.02M|uint32_t group_frame_type; /* Specifies type for new group frames */ 619| | 620| 1.02M|BOOL condition; /* Used in conditional groups */ 621| 1.02M|BOOL cur_is_word; /* Used in "word" tests */ 622| 1.02M|BOOL prev_is_word; /* Used in "word" tests */ 623| | 624| |/* UTF and UCP flags */ 625| | 626| 1.02M|#ifdef SUPPORT_UNICODE 627| 1.02M|BOOL utf = (mb->poptions & PCRE2_UTF) != 0; ------------------ | | 138| 1.02M|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 628| 1.02M|BOOL ucp = (mb->poptions & PCRE2_UCP) != 0; ------------------ | | 136| 1.02M|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ 629| |#else 630| |BOOL utf = FALSE; /* Required for convenience even when no Unicode support */ 631| |#endif 632| | 633| |/* This is the length of the last part of a backtracking frame that must be 634| |copied when a new frame is created. */ 635| | 636| 1.02M|frame_copy_size = frame_size - offsetof(heapframe, eptr); 637| | 638| |/* Set up the first frame and the end of the frames vector. We set the local 639| |heapframes_size to the usuable amount of the vector, that is, a whole number of 640| |frames. */ 641| | 642| 1.02M|F = match_data->heapframes; 643| 1.02M|heapframes_size = (match_data->heapframes_size / frame_size) * frame_size; 644| 1.02M|frames_top = (heapframe *)((char *)F + heapframes_size); 645| | 646| 1.02M|Frdepth = 0; /* "Recursion" depth */ ------------------ | | 182| 1.02M|#define Frdepth F->rdepth ------------------ 647| 1.02M|Fcapture_last = 0; /* Number of most recent capture */ ------------------ | | 174| 1.02M|#define Fcapture_last F->capture_last ------------------ 648| 1.02M|Fcurrent_recurse = RECURSE_UNSET; /* Not pattern recursing. */ ------------------ | | 175| 1.02M|#define Fcurrent_recurse F->current_recurse ------------------ Fcurrent_recurse = RECURSE_UNSET; /* Not pattern recursing. */ ------------------ | | 65| 1.02M|#define RECURSE_UNSET 0xffffffffu /* Bigger than max group number */ ------------------ 649| 1.02M|Fstart_match = Feptr = start_eptr; /* Current data pointer and start match */ ------------------ | | 183| 1.02M|#define Fstart_match F->start_match ------------------ Fstart_match = Feptr = start_eptr; /* Current data pointer and start match */ ------------------ | | 177| 1.02M|#define Feptr F->eptr ------------------ 650| 1.02M|Fmark = NULL; /* Most recent mark */ ------------------ | | 181| 1.02M|#define Fmark F->mark ------------------ 651| 1.02M|Foffset_top = 0; /* End of captures within the frame */ ------------------ | | 184| 1.02M|#define Foffset_top F->offset_top ------------------ 652| 1.02M|Flast_group_offset = PCRE2_UNSET; /* Saved frame of most recent group */ ------------------ | | 179| 1.02M|#define Flast_group_offset F->last_group_offset ------------------ Flast_group_offset = PCRE2_UNSET; /* Saved frame of most recent group */ ------------------ | | 480| 1.02M|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ 653| 1.02M|group_frame_type = 0; /* Not a start of group frame */ 654| 1.02M|goto NEW_FRAME; /* Start processing with this frame */ 655| | 656| |/* Come back here when we want to create a new frame for remembering a 657| |backtracking point. */ 658| | 659| 13.1M|MATCH_RECURSE: 660| | 661| |/* Set up a new backtracking frame. If the vector is full, get a new one, 662| |doubling the size, but constrained by the heap limit (which is in KiB). */ 663| | 664| 13.1M|N = (heapframe *)((char *)F + frame_size); 665| 13.1M|if (N >= frames_top) ------------------ | Branch (665:5): [True: 436, False: 13.1M] ------------------ 666| 436| { 667| 436| heapframe *new; 668| 436| PCRE2_SIZE newsize; ------------------ | | 477| 436|#define PCRE2_SIZE size_t ------------------ 669| | 670| 436| if (match_data->heapframes_size >= PCRE2_SIZE_MAX / 2) ------------------ | | 478| 436|#define PCRE2_SIZE_MAX SIZE_MAX ------------------ | Branch (670:7): [True: 0, False: 436] ------------------ 671| 0| { 672| 0| if (match_data->heapframes_size == PCRE2_SIZE_MAX - 1) ------------------ | | 478| 0|#define PCRE2_SIZE_MAX SIZE_MAX ------------------ | Branch (672:9): [True: 0, False: 0] ------------------ 673| 0| return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ 674| 0| newsize = PCRE2_SIZE_MAX - 1; ------------------ | | 478| 0|#define PCRE2_SIZE_MAX SIZE_MAX ------------------ 675| 0| } 676| 436| else 677| 436| newsize = match_data->heapframes_size * 2; 678| | 679| 436| if (newsize / 1024 >= mb->heap_limit) ------------------ | Branch (679:7): [True: 0, False: 436] ------------------ 680| 0| { 681| 0| PCRE2_SIZE old_size = match_data->heapframes_size / 1024; ------------------ | | 477| 0|#define PCRE2_SIZE size_t ------------------ 682| 0| if (mb->heap_limit <= old_size) return PCRE2_ERROR_HEAPLIMIT; ------------------ | | 404| 0|#define PCRE2_ERROR_HEAPLIMIT (-63) ------------------ | Branch (682:9): [True: 0, False: 0] ------------------ 683| 0| else 684| 0| { 685| 0| PCRE2_SIZE max_delta = 1024 * (mb->heap_limit - old_size); ------------------ | | 477| 0|#define PCRE2_SIZE size_t ------------------ 686| 0| int over_bytes = match_data->heapframes_size % 1024; 687| 0| if (over_bytes) max_delta -= (1024 - over_bytes); ------------------ | Branch (687:11): [True: 0, False: 0] ------------------ 688| 0| newsize = match_data->heapframes_size + max_delta; 689| 0| } 690| 0| } 691| | 692| 436| new = match_data->memctl.malloc(newsize, match_data->memctl.memory_data); 693| 436| if (new == NULL) return PCRE2_ERROR_NOMEMORY; ------------------ | | 388| 0|#define PCRE2_ERROR_NOMEMORY (-48) ------------------ | Branch (693:7): [True: 0, False: 436] ------------------ 694| 436| memcpy(new, match_data->heapframes, heapframes_size); 695| | 696| 436| F = (heapframe *)((char *)new + ((char *)F - (char *)match_data->heapframes)); 697| 436| N = (heapframe *)((char *)F + frame_size); 698| | 699| 436| match_data->memctl.free(match_data->heapframes, match_data->memctl.memory_data); 700| 436| match_data->heapframes = new; 701| 436| match_data->heapframes_size = newsize; 702| | 703| 436| heapframes_size = (newsize / frame_size) * frame_size; 704| 436| frames_top = (heapframe *)((char *)new + heapframes_size); 705| 436| } 706| | 707| |#ifdef DEBUG_SHOW_RMATCH 708| |fprintf(stderr, "++ RMATCH %2d frame=%d", Freturn_id, Frdepth + 1); 709| |if (group_frame_type != 0) 710| | { 711| | fprintf(stderr, " type=%x ", group_frame_type); 712| | switch (GF_IDMASK(group_frame_type)) 713| | { 714| | case GF_CAPTURE: 715| | fprintf(stderr, "capture=%d", GF_DATAMASK(group_frame_type)); 716| | break; 717| | 718| | case GF_NOCAPTURE: 719| | fprintf(stderr, "nocapture op=%d", GF_DATAMASK(group_frame_type)); 720| | break; 721| | 722| | case GF_CONDASSERT: 723| | fprintf(stderr, "condassert op=%d", GF_DATAMASK(group_frame_type)); 724| | break; 725| | 726| | case GF_RECURSE: 727| | fprintf(stderr, "recurse=%d", GF_DATAMASK(group_frame_type)); 728| | break; 729| | 730| | default: 731| | fprintf(stderr, "*** unknown ***"); 732| | break; 733| | } 734| | } 735| |fprintf(stderr, "\n"); 736| |#endif 737| | 738| |/* Copy those fields that must be copied into the new frame, increase the 739| |"recursion" depth (i.e. the new frame's index) and then make the new frame 740| |current. */ 741| | 742| 13.1M|memcpy((char *)N + offsetof(heapframe, eptr), 743| 13.1M| (char *)F + offsetof(heapframe, eptr), 744| 13.1M| frame_copy_size); 745| | 746| 13.1M|N->rdepth = Frdepth + 1; ------------------ | | 182| 13.1M|#define Frdepth F->rdepth ------------------ 747| 13.1M|F = N; 748| | 749| |/* Carry on processing with a new frame. */ 750| | 751| 14.2M|NEW_FRAME: 752| 14.2M|Fgroup_frame_type = group_frame_type; ------------------ | | 178| 14.2M|#define Fgroup_frame_type F->group_frame_type ------------------ 753| 14.2M|Fecode = start_ecode; /* Starting code pointer */ ------------------ | | 176| 14.2M|#define Fecode F->ecode ------------------ 754| 14.2M|Fback_frame = frame_size; /* Default is go back one frame */ ------------------ | | 173| 14.2M|#define Fback_frame F->back_frame ------------------ 755| | 756| |/* If this is a special type of group frame, remember its offset for quick 757| |access at the end of the group. If this is a recursion, set a new current 758| |recursion value. */ 759| | 760| 14.2M|if (group_frame_type != 0) ------------------ | Branch (760:5): [True: 6.40M, False: 7.80M] ------------------ 761| 6.40M| { 762| 6.40M| Flast_group_offset = (char *)F - (char *)match_data->heapframes; ------------------ | | 179| 6.40M|#define Flast_group_offset F->last_group_offset ------------------ 763| 6.40M| if (GF_IDMASK(group_frame_type) == GF_RECURSE) ------------------ | | 113| 6.40M|#define GF_IDMASK(a) ((a) & 0xffff0000u) ------------------ if (GF_IDMASK(group_frame_type) == GF_RECURSE) ------------------ | | 109| 6.40M|#define GF_RECURSE 0x00040000u ------------------ | Branch (763:7): [True: 210k, False: 6.19M] ------------------ 764| 210k| Fcurrent_recurse = GF_DATAMASK(group_frame_type); ------------------ | | 175| 210k|#define Fcurrent_recurse F->current_recurse ------------------ Fcurrent_recurse = GF_DATAMASK(group_frame_type); ------------------ | | 114| 210k|#define GF_DATAMASK(a) ((a) & 0x0000ffffu) ------------------ 765| 6.40M| group_frame_type = 0; 766| 6.40M| } 767| | 768| | 769| |/* ========================================================================= */ 770| |/* This is the main processing loop. First check that we haven't recorded too 771| |many backtracks (search tree is too large), or that we haven't exceeded the 772| |recursive depth limit (used too many backtracking frames). If not, process the 773| |opcodes. */ 774| | 775| 14.2M|if (mb->match_call_count++ >= mb->match_limit) return PCRE2_ERROR_MATCHLIMIT; ------------------ | | 387| 3.80k|#define PCRE2_ERROR_MATCHLIMIT (-47) ------------------ | Branch (775:5): [True: 3.80k, False: 14.1M] ------------------ 776| 14.1M|if (Frdepth >= mb->match_limit_depth) return PCRE2_ERROR_DEPTHLIMIT; ------------------ | | 182| 14.1M|#define Frdepth F->rdepth ------------------ if (Frdepth >= mb->match_limit_depth) return PCRE2_ERROR_DEPTHLIMIT; ------------------ | | 393| 0|#define PCRE2_ERROR_DEPTHLIMIT (-53) ------------------ | Branch (776:5): [True: 0, False: 14.1M] ------------------ 777| | 778| 14.1M|for (;;) 779| 2.33G| { 780| |#ifdef DEBUG_SHOW_OPS 781| |fprintf(stderr, "++ op=%d\n", *Fecode); 782| |#endif 783| | 784| 2.33G| Fop = (uint8_t)(*Fecode); /* Cast needed for 16-bit and 32-bit modes */ ------------------ | | 186| 2.33G|#define Fop F->op ------------------ Fop = (uint8_t)(*Fecode); /* Cast needed for 16-bit and 32-bit modes */ ------------------ | | 176| 2.33G|#define Fecode F->ecode ------------------ 785| 2.33G| switch(Fop) ------------------ | | 186| 2.33G|#define Fop F->op ------------------ 786| 2.33G| { 787| | /* ===================================================================== */ 788| | /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes, to close 789| | any currently open capturing brackets. Unlike reaching the end of a group, 790| | where we know the starting frame is at the top of the chained frames, in 791| | this case we have to search back for the relevant frame in case other types 792| | of group that use chained frames have intervened. Multiple OP_CLOSEs always 793| | come innermost first, which matches the chain order. We can ignore this in 794| | a recursion, because captures are not passed out of recursions. */ 795| | 796| 13.1k| case OP_CLOSE: ------------------ | Branch (796:5): [True: 13.1k, False: 2.33G] ------------------ 797| 13.1k| if (Fcurrent_recurse == RECURSE_UNSET) ------------------ | | 175| 13.1k|#define Fcurrent_recurse F->current_recurse ------------------ if (Fcurrent_recurse == RECURSE_UNSET) ------------------ | | 65| 13.1k|#define RECURSE_UNSET 0xffffffffu /* Bigger than max group number */ ------------------ | Branch (797:9): [True: 9.89k, False: 3.24k] ------------------ 798| 9.89k| { 799| 9.89k| number = GET2(Fecode, 1); ------------------ | | 194| 9.89k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 800| 9.89k| offset = Flast_group_offset; ------------------ | | 179| 9.89k|#define Flast_group_offset F->last_group_offset ------------------ 801| 9.89k| for(;;) 802| 31.3k| { 803| 31.3k| if (offset == PCRE2_UNSET) return PCRE2_ERROR_INTERNAL; ------------------ | | 480| 31.3k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ if (offset == PCRE2_UNSET) return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ | Branch (803:13): [True: 0, False: 31.3k] ------------------ 804| 31.3k| N = (heapframe *)((char *)match_data->heapframes + offset); 805| 31.3k| P = (heapframe *)((char *)N - frame_size); 806| 31.3k| if (N->group_frame_type == (GF_CAPTURE | number)) break; ------------------ | | 106| 31.3k|#define GF_CAPTURE 0x00010000u ------------------ | Branch (806:13): [True: 9.89k, False: 21.4k] ------------------ 807| 21.4k| offset = P->last_group_offset; 808| 21.4k| } 809| 9.89k| offset = (number << 1) - 2; 810| 9.89k| Fcapture_last = number; ------------------ | | 174| 9.89k|#define Fcapture_last F->capture_last ------------------ 811| 9.89k| Fovector[offset] = P->eptr - mb->start_subject; ------------------ | | 187| 9.89k|#define Fovector F->ovector ------------------ 812| 9.89k| Fovector[offset+1] = Feptr - mb->start_subject; ------------------ | | 187| 9.89k|#define Fovector F->ovector ------------------ Fovector[offset+1] = Feptr - mb->start_subject; ------------------ | | 177| 9.89k|#define Feptr F->eptr ------------------ 813| 9.89k| if (offset >= Foffset_top) Foffset_top = offset + 2; ------------------ | | 184| 9.89k|#define Foffset_top F->offset_top ------------------ if (offset >= Foffset_top) Foffset_top = offset + 2; ------------------ | | 184| 590|#define Foffset_top F->offset_top ------------------ | Branch (813:11): [True: 590, False: 9.30k] ------------------ 814| 9.89k| } 815| 13.1k| Fecode += PRIV(OP_lengths)[*Fecode]; ------------------ | | 176| 13.1k|#define Fecode F->ecode ------------------ Fecode += PRIV(OP_lengths)[*Fecode]; ------------------ | | 177| 13.1k|#define PRIV(name) _pcre2_##name ------------------ Fecode += PRIV(OP_lengths)[*Fecode]; ------------------ | | 176| 13.1k|#define Fecode F->ecode ------------------ 816| 13.1k| break; 817| | 818| | 819| | /* ===================================================================== */ 820| | /* Real or forced end of the pattern, assertion, or recursion. In an 821| | assertion ACCEPT, update the last used pointer and remember the current 822| | frame so that the captures and mark can be fished out of it. */ 823| | 824| 4.87k| case OP_ASSERT_ACCEPT: ------------------ | Branch (824:5): [True: 4.87k, False: 2.33G] ------------------ 825| 4.87k| if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 4.87k|#define Feptr F->eptr ------------------ if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 254|#define Feptr F->eptr ------------------ | Branch (825:9): [True: 254, False: 4.61k] ------------------ 826| 4.87k| assert_accept_frame = F; 827| 4.87k| RRETURN(MATCH_ACCEPT); ------------------ | | 554| 4.87k| {\ | | 555| 4.87k| rrc = ra;\ | | 556| 4.87k| goto RETURN_SWITCH;\ | | 557| 4.87k| } ------------------ 828| | 829| | /* If recursing, we have to find the most recent recursion. */ 830| | 831| 6.72k| case OP_ACCEPT: ------------------ | Branch (831:5): [True: 6.72k, False: 2.33G] ------------------ 832| 468k| case OP_END: ------------------ | Branch (832:5): [True: 461k, False: 2.33G] ------------------ 833| | 834| | /* Handle end of a recursion. */ 835| | 836| 468k| if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 175| 468k|#define Fcurrent_recurse F->current_recurse ------------------ if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 65| 468k|#define RECURSE_UNSET 0xffffffffu /* Bigger than max group number */ ------------------ | Branch (836:9): [True: 12.1k, False: 456k] ------------------ 837| 12.1k| { 838| 12.1k| offset = Flast_group_offset; ------------------ | | 179| 12.1k|#define Flast_group_offset F->last_group_offset ------------------ 839| 12.1k| for(;;) 840| 12.6k| { 841| 12.6k| if (offset == PCRE2_UNSET) return PCRE2_ERROR_INTERNAL; ------------------ | | 480| 12.6k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ if (offset == PCRE2_UNSET) return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ | Branch (841:13): [True: 0, False: 12.6k] ------------------ 842| 12.6k| N = (heapframe *)((char *)match_data->heapframes + offset); 843| 12.6k| P = (heapframe *)((char *)N - frame_size); 844| 12.6k| if (GF_IDMASK(N->group_frame_type) == GF_RECURSE) break; ------------------ | | 113| 12.6k|#define GF_IDMASK(a) ((a) & 0xffff0000u) ------------------ if (GF_IDMASK(N->group_frame_type) == GF_RECURSE) break; ------------------ | | 109| 12.6k|#define GF_RECURSE 0x00040000u ------------------ | Branch (844:13): [True: 12.1k, False: 507] ------------------ 845| 507| offset = P->last_group_offset; 846| 507| } 847| | 848| | /* N is now the frame of the recursion; the previous frame is at the 849| | OP_RECURSE position. Go back there, copying the current subject position 850| | and mark, and the start_match position (\K might have changed it), and 851| | then move on past the OP_RECURSE. */ 852| | 853| 12.1k| P->eptr = Feptr; ------------------ | | 177| 12.1k|#define Feptr F->eptr ------------------ 854| 12.1k| P->mark = Fmark; ------------------ | | 181| 12.1k|#define Fmark F->mark ------------------ 855| 12.1k| P->start_match = Fstart_match; ------------------ | | 183| 12.1k|#define Fstart_match F->start_match ------------------ 856| 12.1k| F = P; 857| 12.1k| Fecode += 1 + LINK_SIZE; ------------------ | | 176| 12.1k|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; ------------------ | | 165| 12.1k|#define LINK_SIZE 2 ------------------ 858| 12.1k| continue; 859| 12.1k| } 860| | 861| | /* Not a recursion. Fail for an empty string match if either PCRE2_NOTEMPTY 862| | is set, or if PCRE2_NOTEMPTY_ATSTART is set and we have matched at the 863| | start of the subject. In both cases, backtracking will then try other 864| | alternatives, if any. */ 865| | 866| 456k| if (Feptr == Fstart_match && ------------------ | | 177| 456k|#define Feptr F->eptr ------------------ if (Feptr == Fstart_match && ------------------ | | 183| 912k|#define Fstart_match F->start_match ------------------ | Branch (866:9): [True: 281k, False: 175k] ------------------ 867| 456k| ((mb->moptions & PCRE2_NOTEMPTY) != 0 || ------------------ | | 178| 281k|#define PCRE2_NOTEMPTY 0x00000004u /* ) These two must be kept */ ------------------ | Branch (867:11): [True: 44.7k, False: 236k] ------------------ 868| 281k| ((mb->moptions & PCRE2_NOTEMPTY_ATSTART) != 0 && ------------------ | | 179| 236k|#define PCRE2_NOTEMPTY_ATSTART 0x00000008u /* ) adjacent to each other. */ ------------------ | Branch (868:13): [True: 16.8k, False: 219k] ------------------ 869| 236k| Fstart_match == mb->start_subject + mb->start_offset))) ------------------ | | 183| 16.8k|#define Fstart_match F->start_match ------------------ | Branch (869:14): [True: 5.22k, False: 11.6k] ------------------ 870| 406k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 49.9k| {\ | | 555| 49.9k| rrc = ra;\ | | 556| 49.9k| goto RETURN_SWITCH;\ | | 557| 49.9k| } ------------------ 871| | 872| | /* Also fail if PCRE2_ENDANCHORED is set and the end of the match is not 873| | the end of the subject. After (*ACCEPT) we fail the entire match (at this 874| | position) but backtrack on reaching the end of the pattern. */ 875| | 876| 406k| if (Feptr < mb->end_subject && ------------------ | | 177| 406k|#define Feptr F->eptr ------------------ | Branch (876:9): [True: 380k, False: 25.7k] ------------------ 877| 406k| ((mb->moptions | mb->poptions) & PCRE2_ENDANCHORED) != 0) ------------------ | | 107| 380k|#define PCRE2_ENDANCHORED 0x20000000u ------------------ | Branch (877:9): [True: 361k, False: 19.4k] ------------------ 878| 361k| { 879| 361k| if (Fop == OP_END) RRETURN(MATCH_NOMATCH); ------------------ | | 186| 361k|#define Fop F->op ------------------ if (Fop == OP_END) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 358k| {\ | | 555| 358k| rrc = ra;\ | | 556| 358k| goto RETURN_SWITCH;\ | | 557| 358k| } ------------------ | Branch (879:11): [True: 358k, False: 2.34k] ------------------ 880| 2.34k| return MATCH_NOMATCH; ------------------ | | 83| 2.34k|#define MATCH_NOMATCH 0 ------------------ 881| 361k| } 882| | 883| | /* We have a successful match of the whole pattern. Record the result and 884| | then do a direct return from the function. If there is space in the offset 885| | vector, set any pairs that follow the highest-numbered captured string but 886| | are less than the number of capturing groups in the pattern to PCRE2_UNSET. 887| | It is documented that this happens. "Gaps" are set to PCRE2_UNSET 888| | dynamically. It is only those at the end that need setting here. */ 889| | 890| 45.2k| mb->end_match_ptr = Feptr; /* Record where we ended */ ------------------ | | 177| 45.2k|#define Feptr F->eptr ------------------ 891| 45.2k| mb->end_offset_top = Foffset_top; /* and how many extracts were taken */ ------------------ | | 184| 45.2k|#define Foffset_top F->offset_top ------------------ 892| 45.2k| mb->mark = Fmark; /* and the last success mark */ ------------------ | | 181| 45.2k|#define Fmark F->mark ------------------ 893| 45.2k| if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 45.2k|#define Feptr F->eptr ------------------ if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 21.9k|#define Feptr F->eptr ------------------ | Branch (893:9): [True: 21.9k, False: 23.3k] ------------------ 894| | 895| 45.2k| match_data->ovector[0] = Fstart_match - mb->start_subject; ------------------ | | 183| 45.2k|#define Fstart_match F->start_match ------------------ 896| 45.2k| match_data->ovector[1] = Feptr - mb->start_subject; ------------------ | | 177| 45.2k|#define Feptr F->eptr ------------------ 897| | 898| | /* Set i to the smaller of the sizes of the external and frame ovectors. */ 899| | 900| 45.2k| i = 2 * ((top_bracket + 1 > match_data->oveccount)? ------------------ | Branch (900:14): [True: 130, False: 45.1k] ------------------ 901| 45.1k| match_data->oveccount : top_bracket + 1); 902| 45.2k| memcpy(match_data->ovector + 2, Fovector, (i - 2) * sizeof(PCRE2_SIZE)); ------------------ | | 187| 45.2k|#define Fovector F->ovector ------------------ 903| 56.6k| while (--i >= Foffset_top + 2) match_data->ovector[i] = PCRE2_UNSET; ------------------ | | 184| 56.6k|#define Foffset_top F->offset_top ------------------ while (--i >= Foffset_top + 2) match_data->ovector[i] = PCRE2_UNSET; ------------------ | | 480| 56.6k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (903:12): [True: 11.3k, False: 45.2k] ------------------ 904| 45.2k| return MATCH_MATCH; /* Note: NOT RRETURN */ ------------------ | | 82| 45.2k|#define MATCH_MATCH 1 ------------------ 905| | 906| | 907| | /*===================================================================== */ 908| | /* Match any single character type except newline; have to take care with 909| | CRLF newlines and partial matching. */ 910| | 911| 168k| case OP_ANY: ------------------ | Branch (911:5): [True: 168k, False: 2.33G] ------------------ 912| 168k| if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 479| 168k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 168k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 168k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 2.05k, False: 166k] | | | Branch (479:4): [True: 16.7k, False: 151k] | | ------------------ | | 480| 168k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 16.7k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 33.5k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 15.6k, False: 1.13k] | | ------------------ | | 481| 16.7k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 15.6k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 15.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 15.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 15.6k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 835, False: 14.7k] | | ------------------ | | 482| 15.6k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 15.6k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 168k| : \ | | 484| 168k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 151k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 151k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 151k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 131k, False: 19.4k] | | ------------------ | | 485| 151k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 131k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 131k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 2.20k, False: 129k] | | ------------------ | | 486| 151k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 2.20k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.37k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.37k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 833, False: 1.37k] | | | Branch (486:30): [True: 382, False: 993] | | ------------------ | | 487| 151k| ) \ | | 488| 168k| ) ------------------ if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.05k| {\ | | 555| 2.05k| rrc = ra;\ | | 556| 2.05k| goto RETURN_SWITCH;\ | | 557| 2.05k| } ------------------ 913| 166k| if (mb->partial != 0 && ------------------ | Branch (913:9): [True: 33.6k, False: 132k] ------------------ 914| 166k| Feptr == mb->end_subject - 1 && ------------------ | | 177| 33.6k|#define Feptr F->eptr ------------------ | Branch (914:9): [True: 2.82k, False: 30.8k] ------------------ 915| 166k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 2.82k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 168k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (915:9): [True: 2.22k, False: 597] ------------------ 916| 166k| NLBLOCK->nllen == 2 && ------------------ | | 59| 2.22k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (916:9): [True: 672, False: 1.55k] ------------------ 917| 166k| UCHAR21TEST(Feptr) == NLBLOCK->nl[0]) ------------------ | | 244| 672|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ UCHAR21TEST(Feptr) == NLBLOCK->nl[0]) ------------------ | | 59| 672|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (917:9): [True: 238, False: 434] ------------------ 918| 238| { 919| 238| mb->hitend = TRUE; ------------------ | | 70| 238|#define TRUE 1 ------------------ 920| 238| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 9|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (920:11): [True: 9, False: 229] ------------------ 921| 238| } 922| | /* Fall through */ 923| | 924| | /* Match any single character whatsoever. */ 925| | 926| 240k| case OP_ALLANY: ------------------ | Branch (926:5): [True: 74.0k, False: 2.33G] ------------------ 927| 240k| if (Feptr >= mb->end_subject) /* DO NOT merge the Feptr++ here; it must */ ------------------ | | 177| 240k|#define Feptr F->eptr ------------------ | Branch (927:9): [True: 22.8k, False: 217k] ------------------ 928| 22.8k| { /* not be updated before SCHECK_PARTIAL. */ 929| 22.8k| SCHECK_PARTIAL(); ------------------ | | 533| 22.8k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 4.64k, False: 18.1k] | | ------------------ | | 534| 22.8k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 4.64k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 2.55k, False: 2.09k] | | | Branch (534:38): [True: 1.15k, False: 938] | | ------------------ | | 535| 22.8k| { \ | | 536| 3.70k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 3.70k|#define TRUE 1 | | ------------------ | | 537| 3.70k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 205|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 205, False: 3.50k] | | ------------------ | | 538| 3.70k| } ------------------ 930| 22.6k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 22.6k| {\ | | 555| 22.6k| rrc = ra;\ | | 556| 22.6k| goto RETURN_SWITCH;\ | | 557| 22.6k| } ------------------ 931| 0| } 932| 217k| Feptr++; ------------------ | | 177| 217k|#define Feptr F->eptr ------------------ 933| 217k|#ifdef SUPPORT_UNICODE 934| 217k| if (utf) ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++); ------------------ | | 353| 69.3k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 63.5k, False: 5.77k] | | | Branch (353:24): [True: 3.52k, False: 60.0k] | | ------------------ ------------------ | Branch (934:9): [True: 65.7k, False: 151k] ------------------ 935| 217k|#endif 936| 217k| Fecode++; ------------------ | | 176| 217k|#define Fecode F->ecode ------------------ 937| 217k| break; 938| | 939| | 940| | /* ===================================================================== */ 941| | /* Match a single code unit, even in UTF mode. This opcode really does 942| | match any code unit, even newline. (It really should be called ANYCODEUNIT, 943| | of course - the byte name is from pre-16 bit days.) */ 944| | 945| 0| case OP_ANYBYTE: ------------------ | Branch (945:5): [True: 0, False: 2.33G] ------------------ 946| 0| if (Feptr >= mb->end_subject) /* DO NOT merge the Feptr++ here; it must */ ------------------ | | 177| 0|#define Feptr F->eptr ------------------ | Branch (946:9): [True: 0, False: 0] ------------------ 947| 0| { /* not be updated before SCHECK_PARTIAL. */ 948| 0| SCHECK_PARTIAL(); ------------------ | | 533| 0| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 0, False: 0] | | ------------------ | | 534| 0| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 0|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 0, False: 0] | | | Branch (534:38): [True: 0, False: 0] | | ------------------ | | 535| 0| { \ | | 536| 0| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 0|#define TRUE 1 | | ------------------ | | 537| 0| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 0|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 0, False: 0] | | ------------------ | | 538| 0| } ------------------ 949| 0| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ 950| 0| } 951| 0| Feptr++; ------------------ | | 177| 0|#define Feptr F->eptr ------------------ 952| 0| Fecode++; ------------------ | | 176| 0|#define Fecode F->ecode ------------------ 953| 0| break; 954| | 955| | 956| | /* ===================================================================== */ 957| | /* Match a single character, casefully */ 958| | 959| 2.42M| case OP_CHAR: ------------------ | Branch (959:5): [True: 2.42M, False: 2.33G] ------------------ 960| 2.42M|#ifdef SUPPORT_UNICODE 961| 2.42M| if (utf) ------------------ | Branch (961:9): [True: 412k, False: 2.01M] ------------------ 962| 412k| { 963| 412k| Flength = 1; ------------------ | | 180| 412k|#define Flength F->length ------------------ 964| 412k| Fecode++; ------------------ | | 176| 412k|#define Fecode F->ecode ------------------ 965| 412k| GETCHARLEN(fc, Fecode, Flength); ------------------ | | 330| 412k| c = *eptr; \ | | 331| 412k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 47.6k| { \ | | | | 323| 47.6k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 17.6k, False: 29.9k] | | | | ------------------ | | | | 324| 47.6k| { \ | | | | 325| 17.6k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 17.6k| len++; \ | | | | 327| 17.6k| } \ | | | | 328| 47.6k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 18.7k, False: 11.2k] | | | | ------------------ | | | | 329| 29.9k| { \ | | | | 330| 18.7k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 18.7k| len += 2; \ | | | | 332| 18.7k| } \ | | | | 333| 29.9k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 11.2k, False: 0] | | | | ------------------ | | | | 334| 11.2k| {\ | | | | 335| 11.2k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 11.2k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 11.2k| len += 3; \ | | | | 338| 11.2k| } \ | | | | 339| 11.2k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 47.6k| } | | ------------------ | | | Branch (331:7): [True: 47.6k, False: 364k] | | ------------------ ------------------ 966| 412k| if (Flength > (PCRE2_SIZE)(mb->end_subject - Feptr)) ------------------ | | 180| 412k|#define Flength F->length ------------------ if (Flength > (PCRE2_SIZE)(mb->end_subject - Feptr)) ------------------ | | 177| 412k|#define Feptr F->eptr ------------------ | Branch (966:11): [True: 52.1k, False: 360k] ------------------ 967| 52.1k| { 968| 52.1k| CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */ ------------------ | | 527| 52.1k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 52.1k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 48.1k, False: 4.01k] | | ------------------ | | 528| 52.1k| { \ | | 529| 48.1k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 48.1k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 8.02k, False: 40.1k] | | | | ------------------ | | | | 534| 48.1k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 8.02k|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 4.55k, False: 3.47k] | | | | | Branch (534:38): [True: 1.28k, False: 2.18k] | | | | ------------------ | | | | 535| 48.1k| { \ | | | | 536| 5.84k| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 5.84k|#define TRUE 1 | | | | ------------------ | | | | 537| 5.84k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 123|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 123, False: 5.71k] | | | | ------------------ | | | | 538| 5.84k| } | | ------------------ | | 530| 48.0k| } ------------------ 969| 52.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 52.0k| {\ | | 555| 52.0k| rrc = ra;\ | | 556| 52.0k| goto RETURN_SWITCH;\ | | 557| 52.0k| } ------------------ 970| 0| } 971| 440k| for (; Flength > 0; Flength--) ------------------ | | 180| 440k|#define Flength F->length ------------------ for (; Flength > 0; Flength--) ------------------ | | 180| 80.4k|#define Flength F->length ------------------ | Branch (971:14): [True: 375k, False: 64.8k] ------------------ 972| 375k| { 973| 375k| if (*Fecode++ != UCHAR21INC(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 176| 375k|#define Fecode F->ecode ------------------ if (*Fecode++ != UCHAR21INC(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 245| 375k|#define UCHAR21INC(eptr) (*(eptr)++) ------------------ if (*Fecode++ != UCHAR21INC(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 295k| {\ | | 555| 295k| rrc = ra;\ | | 556| 295k| goto RETURN_SWITCH;\ | | 557| 295k| } ------------------ | Branch (973:13): [True: 295k, False: 80.4k] ------------------ 974| 80.4k| } 975| 360k| } 976| 2.01M| else 977| 2.01M|#endif 978| | 979| | /* Not UTF mode */ 980| 2.01M| { 981| 2.01M| if (mb->end_subject - Feptr < 1) ------------------ | | 177| 2.01M|#define Feptr F->eptr ------------------ | Branch (981:11): [True: 196k, False: 1.81M] ------------------ 982| 196k| { 983| 196k| SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */ ------------------ | | 533| 196k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 74.4k, False: 121k] | | ------------------ | | 534| 196k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 74.4k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 33.6k, False: 40.7k] | | | Branch (534:38): [True: 12.4k, False: 28.3k] | | ------------------ | | 535| 196k| { \ | | 536| 46.0k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 46.0k|#define TRUE 1 | | ------------------ | | 537| 46.0k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 311|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 311, False: 45.7k] | | ------------------ | | 538| 46.0k| } ------------------ 984| 196k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 196k| {\ | | 555| 196k| rrc = ra;\ | | 556| 196k| goto RETURN_SWITCH;\ | | 557| 196k| } ------------------ 985| 0| } 986| 1.81M| if (Fecode[1] != *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 176| 1.81M|#define Fecode F->ecode ------------------ if (Fecode[1] != *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 1.81M|#define Feptr F->eptr ------------------ if (Fecode[1] != *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.48M| {\ | | 555| 1.48M| rrc = ra;\ | | 556| 1.48M| goto RETURN_SWITCH;\ | | 557| 1.48M| } ------------------ | Branch (986:11): [True: 1.48M, False: 336k] ------------------ 987| 336k| Fecode += 2; ------------------ | | 176| 336k|#define Fecode F->ecode ------------------ 988| 336k| } 989| 401k| break; 990| | 991| | 992| | /* ===================================================================== */ 993| | /* Match a single character, caselessly. If we are at the end of the 994| | subject, give up immediately. We get here only when the pattern character 995| | has at most one other case. Characters with more than two cases are coded 996| | as OP_PROP with the pseudo-property PT_CLIST. */ 997| | 998| 1.14M| case OP_CHARI: ------------------ | Branch (998:5): [True: 1.14M, False: 2.33G] ------------------ 999| 1.14M| if (Feptr >= mb->end_subject) ------------------ | | 177| 1.14M|#define Feptr F->eptr ------------------ | Branch (999:9): [True: 135k, False: 1.00M] ------------------ 1000| 135k| { 1001| 135k| SCHECK_PARTIAL(); ------------------ | | 533| 135k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 36.8k, False: 98.8k] | | ------------------ | | 534| 135k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 36.8k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 17.8k, False: 19.0k] | | | Branch (534:38): [True: 4.32k, False: 14.6k] | | ------------------ | | 535| 135k| { \ | | 536| 22.1k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 22.1k|#define TRUE 1 | | ------------------ | | 537| 22.1k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 338|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 338, False: 21.8k] | | ------------------ | | 538| 22.1k| } ------------------ 1002| 135k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 135k| {\ | | 555| 135k| rrc = ra;\ | | 556| 135k| goto RETURN_SWITCH;\ | | 557| 135k| } ------------------ 1003| 0| } 1004| | 1005| 1.00M|#ifdef SUPPORT_UNICODE 1006| 1.00M| if (utf) ------------------ | Branch (1006:9): [True: 433k, False: 571k] ------------------ 1007| 433k| { 1008| 433k| Flength = 1; ------------------ | | 180| 433k|#define Flength F->length ------------------ 1009| 433k| Fecode++; ------------------ | | 176| 433k|#define Fecode F->ecode ------------------ 1010| 433k| GETCHARLEN(fc, Fecode, Flength); ------------------ | | 330| 433k| c = *eptr; \ | | 331| 433k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 71.9k| { \ | | | | 323| 71.9k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 50.0k, False: 21.8k] | | | | ------------------ | | | | 324| 71.9k| { \ | | | | 325| 50.0k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 50.0k| len++; \ | | | | 327| 50.0k| } \ | | | | 328| 71.9k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 16.3k, False: 5.55k] | | | | ------------------ | | | | 329| 21.8k| { \ | | | | 330| 16.3k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 16.3k| len += 2; \ | | | | 332| 16.3k| } \ | | | | 333| 21.8k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 5.55k, False: 0] | | | | ------------------ | | | | 334| 5.55k| {\ | | | | 335| 5.55k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 5.55k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 5.55k| len += 3; \ | | | | 338| 5.55k| } \ | | | | 339| 5.55k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 71.9k| } | | ------------------ | | | Branch (331:7): [True: 71.9k, False: 361k] | | ------------------ ------------------ 1011| | 1012| | /* If the pattern character's value is < 128, we know that its other case 1013| | (if any) is also < 128 (and therefore only one code unit long in all 1014| | code-unit widths), so we can use the fast lookup table. We checked above 1015| | that there is at least one character left in the subject. */ 1016| | 1017| 433k| if (fc < 128) ------------------ | Branch (1017:11): [True: 361k, False: 71.9k] ------------------ 1018| 361k| { 1019| 361k| uint32_t cc = UCHAR21(Feptr); ------------------ | | 243| 361k|#define UCHAR21(eptr) (*(eptr)) ------------------ 1020| 361k| if (mb->lcc[fc] != TABLE_GET(cc, mb->lcc, cc)) RRETURN(MATCH_NOMATCH); ------------------ | | 214| 361k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ if (mb->lcc[fc] != TABLE_GET(cc, mb->lcc, cc)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 277k| {\ | | 555| 277k| rrc = ra;\ | | 556| 277k| goto RETURN_SWITCH;\ | | 557| 277k| } ------------------ | Branch (1020:13): [True: 277k, False: 83.6k] ------------------ 1021| 83.6k| Fecode++; ------------------ | | 176| 83.6k|#define Fecode F->ecode ------------------ 1022| 83.6k| Feptr++; ------------------ | | 177| 83.6k|#define Feptr F->eptr ------------------ 1023| 83.6k| } 1024| | 1025| | /* Otherwise we must pick up the subject character and use Unicode 1026| | property support to test its other case. Note that we cannot use the 1027| | value of "Flength" to check for sufficient bytes left, because the other 1028| | case of the character may have more or fewer code units. */ 1029| | 1030| 71.9k| else 1031| 71.9k| { 1032| 71.9k| uint32_t dc; 1033| 71.9k| GETCHARINC(dc, Feptr); ------------------ | | 316| 71.9k| c = *eptr++; \ | | 317| 71.9k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 33.4k| { \ | | | | 289| 33.4k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 28.7k, False: 4.66k] | | | | ------------------ | | | | 290| 33.4k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 33.4k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 3.35k, False: 1.30k] | | | | ------------------ | | | | 292| 4.66k| { \ | | | | 293| 3.35k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 3.35k| eptr += 2; \ | | | | 295| 3.35k| } \ | | | | 296| 4.66k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 1.30k, False: 0] | | | | ------------------ | | | | 297| 1.30k| { \ | | | | 298| 1.30k| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 1.30k| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 1.30k| eptr += 3; \ | | | | 301| 1.30k| } \ | | | | 302| 1.30k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 33.4k| } | | ------------------ | | | Branch (317:7): [True: 33.4k, False: 38.5k] | | ------------------ ------------------ 1034| 71.9k| Fecode += Flength; ------------------ | | 176| 71.9k|#define Fecode F->ecode ------------------ Fecode += Flength; ------------------ | | 180| 71.9k|#define Flength F->length ------------------ 1035| 71.9k| if (dc != fc && dc != UCD_OTHERCASE(fc)) RRETURN(MATCH_NOMATCH); ------------------ | | 1862| 41.8k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 41.8k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 41.8k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 41.8k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 41.8k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 41.8k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 41.8k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 41.8k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 41.8k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 41.8k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 41.8k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (dc != fc && dc != UCD_OTHERCASE(fc)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 40.8k| {\ | | 555| 40.8k| rrc = ra;\ | | 556| 40.8k| goto RETURN_SWITCH;\ | | 557| 40.8k| } ------------------ | Branch (1035:13): [True: 41.8k, False: 30.1k] | Branch (1035:25): [True: 40.8k, False: 925] ------------------ 1036| 31.0k| } 1037| 433k| } 1038| | 1039| | /* If UCP is set without UTF we must do the same as above, but with one 1040| | character per code unit. */ 1041| | 1042| 571k| else if (ucp) ------------------ | Branch (1042:14): [True: 118k, False: 453k] ------------------ 1043| 118k| { 1044| 118k| uint32_t cc = UCHAR21(Feptr); ------------------ | | 243| 118k|#define UCHAR21(eptr) (*(eptr)) ------------------ 1045| 118k| fc = Fecode[1]; ------------------ | | 176| 118k|#define Fecode F->ecode ------------------ 1046| 118k| if (fc < 128) ------------------ | Branch (1046:11): [True: 55.1k, False: 62.9k] ------------------ 1047| 55.1k| { 1048| 55.1k| if (mb->lcc[fc] != TABLE_GET(cc, mb->lcc, cc)) RRETURN(MATCH_NOMATCH); ------------------ | | 214| 55.1k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ if (mb->lcc[fc] != TABLE_GET(cc, mb->lcc, cc)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 46.7k| {\ | | 555| 46.7k| rrc = ra;\ | | 556| 46.7k| goto RETURN_SWITCH;\ | | 557| 46.7k| } ------------------ | Branch (1048:13): [True: 46.7k, False: 8.35k] ------------------ 1049| 8.35k| } 1050| 62.9k| else 1051| 62.9k| { 1052| 62.9k| if (cc != fc && cc != UCD_OTHERCASE(fc)) RRETURN(MATCH_NOMATCH); ------------------ | | 1862| 17.7k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 17.7k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 17.7k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 17.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 17.7k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 17.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 17.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 17.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 17.7k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 17.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 17.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (cc != fc && cc != UCD_OTHERCASE(fc)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 17.3k| {\ | | 555| 17.3k| rrc = ra;\ | | 556| 17.3k| goto RETURN_SWITCH;\ | | 557| 17.3k| } ------------------ | Branch (1052:13): [True: 17.7k, False: 45.1k] | Branch (1052:25): [True: 17.3k, False: 395] ------------------ 1053| 45.5k| } 1054| 53.9k| Feptr++; ------------------ | | 177| 53.9k|#define Feptr F->eptr ------------------ 1055| 53.9k| Fecode += 2; ------------------ | | 176| 53.9k|#define Fecode F->ecode ------------------ 1056| 53.9k| } 1057| | 1058| 453k| else 1059| 453k|#endif /* SUPPORT_UNICODE */ 1060| | 1061| | /* Not UTF or UCP mode; use the table for characters < 256. */ 1062| 453k| { 1063| 453k| if (TABLE_GET(Fecode[1], mb->lcc, Fecode[1]) ------------------ | | 214| 453k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ | Branch (1063:11): [True: 414k, False: 38.8k] ------------------ 1064| 453k| != TABLE_GET(*Feptr, mb->lcc, *Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 214| 453k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ != TABLE_GET(*Feptr, mb->lcc, *Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 414k| {\ | | 555| 414k| rrc = ra;\ | | 556| 414k| goto RETURN_SWITCH;\ | | 557| 414k| } ------------------ 1065| 38.8k| Feptr++; ------------------ | | 177| 38.8k|#define Feptr F->eptr ------------------ 1066| 38.8k| Fecode += 2; ------------------ | | 176| 38.8k|#define Fecode F->ecode ------------------ 1067| 38.8k| } 1068| 207k| break; 1069| | 1070| | 1071| | /* ===================================================================== */ 1072| | /* Match not a single character. */ 1073| | 1074| 207k| case OP_NOT: ------------------ | Branch (1074:5): [True: 23.9k, False: 2.33G] ------------------ 1075| 41.8k| case OP_NOTI: ------------------ | Branch (1075:5): [True: 17.9k, False: 2.33G] ------------------ 1076| 41.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 41.8k|#define Feptr F->eptr ------------------ | Branch (1076:9): [True: 4.43k, False: 37.4k] ------------------ 1077| 4.43k| { 1078| 4.43k| SCHECK_PARTIAL(); ------------------ | | 533| 4.43k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 885, False: 3.54k] | | ------------------ | | 534| 4.43k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 885|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 371, False: 514] | | | Branch (534:38): [True: 234, False: 280] | | ------------------ | | 535| 4.43k| { \ | | 536| 605| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 605|#define TRUE 1 | | ------------------ | | 537| 605| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 30|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 30, False: 575] | | ------------------ | | 538| 605| } ------------------ 1079| 4.40k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.40k| {\ | | 555| 4.40k| rrc = ra;\ | | 556| 4.40k| goto RETURN_SWITCH;\ | | 557| 4.40k| } ------------------ 1080| 0| } 1081| | 1082| 37.4k|#ifdef SUPPORT_UNICODE 1083| 37.4k| if (utf) ------------------ | Branch (1083:9): [True: 16.1k, False: 21.2k] ------------------ 1084| 16.1k| { 1085| 16.1k| uint32_t ch; 1086| 16.1k| Fecode++; ------------------ | | 176| 16.1k|#define Fecode F->ecode ------------------ 1087| 16.1k| GETCHARINC(ch, Fecode); ------------------ | | 316| 16.1k| c = *eptr++; \ | | 317| 16.1k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 5.25k| { \ | | | | 289| 5.25k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 4.13k, False: 1.12k] | | | | ------------------ | | | | 290| 5.25k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 5.25k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 758, False: 366] | | | | ------------------ | | | | 292| 1.12k| { \ | | | | 293| 758| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 758| eptr += 2; \ | | | | 295| 758| } \ | | | | 296| 1.12k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 366, False: 0] | | | | ------------------ | | | | 297| 366| { \ | | | | 298| 366| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 366| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 366| eptr += 3; \ | | | | 301| 366| } \ | | | | 302| 366| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 5.25k| } | | ------------------ | | | Branch (317:7): [True: 5.25k, False: 10.9k] | | ------------------ ------------------ 1088| 16.1k| GETCHARINC(fc, Feptr); ------------------ | | 316| 16.1k| c = *eptr++; \ | | 317| 16.1k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.70k| { \ | | | | 289| 1.70k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 1.07k, False: 632] | | | | ------------------ | | | | 290| 1.70k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.70k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 382, False: 250] | | | | ------------------ | | | | 292| 632| { \ | | | | 293| 382| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 382| eptr += 2; \ | | | | 295| 382| } \ | | | | 296| 632| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 250, False: 0] | | | | ------------------ | | | | 297| 250| { \ | | | | 298| 250| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 250| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 250| eptr += 3; \ | | | | 301| 250| } \ | | | | 302| 250| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.70k| } | | ------------------ | | | Branch (317:7): [True: 1.70k, False: 14.4k] | | ------------------ ------------------ 1089| 16.1k| if (ch == fc) ------------------ | Branch (1089:11): [True: 2.87k, False: 13.3k] ------------------ 1090| 2.87k| { 1091| 2.87k| RRETURN(MATCH_NOMATCH); /* Caseful match */ ------------------ | | 554| 2.87k| {\ | | 555| 2.87k| rrc = ra;\ | | 556| 2.87k| goto RETURN_SWITCH;\ | | 557| 2.87k| } ------------------ 1092| 0| } 1093| 13.3k| else if (Fop == OP_NOTI) /* If caseless */ ------------------ | | 186| 13.3k|#define Fop F->op ------------------ | Branch (1093:16): [True: 7.31k, False: 6.00k] ------------------ 1094| 7.31k| { 1095| 7.31k| if (ch > 127) ------------------ | Branch (1095:13): [True: 917, False: 6.39k] ------------------ 1096| 917| ch = UCD_OTHERCASE(ch); ------------------ | | 1862| 917|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 917|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 917|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 917|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 917| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 917|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 917|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 917|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 917| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 917|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 917|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1097| 6.39k| else 1098| 6.39k| ch = (mb->fcc)[ch]; 1099| 7.31k| if (ch == fc) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 814| {\ | | 555| 814| rrc = ra;\ | | 556| 814| goto RETURN_SWITCH;\ | | 557| 814| } ------------------ | Branch (1099:13): [True: 814, False: 6.50k] ------------------ 1100| 6.50k| } 1101| 16.1k| } 1102| | 1103| | /* UCP without UTF is as above, but with one character per code unit. */ 1104| | 1105| 21.2k| else if (ucp) ------------------ | Branch (1105:14): [True: 5.14k, False: 16.1k] ------------------ 1106| 5.14k| { 1107| 5.14k| uint32_t ch; 1108| 5.14k| fc = UCHAR21INC(Feptr); ------------------ | | 245| 5.14k|#define UCHAR21INC(eptr) (*(eptr)++) ------------------ 1109| 5.14k| ch = Fecode[1]; ------------------ | | 176| 5.14k|#define Fecode F->ecode ------------------ 1110| 5.14k| Fecode += 2; ------------------ | | 176| 5.14k|#define Fecode F->ecode ------------------ 1111| | 1112| 5.14k| if (ch == fc) ------------------ | Branch (1112:11): [True: 621, False: 4.52k] ------------------ 1113| 621| { 1114| 621| RRETURN(MATCH_NOMATCH); /* Caseful match */ ------------------ | | 554| 621| {\ | | 555| 621| rrc = ra;\ | | 556| 621| goto RETURN_SWITCH;\ | | 557| 621| } ------------------ 1115| 0| } 1116| 4.52k| else if (Fop == OP_NOTI) /* If caseless */ ------------------ | | 186| 4.52k|#define Fop F->op ------------------ | Branch (1116:16): [True: 1.79k, False: 2.73k] ------------------ 1117| 1.79k| { 1118| 1.79k| if (ch > 127) ------------------ | Branch (1118:13): [True: 747, False: 1.04k] ------------------ 1119| 747| ch = UCD_OTHERCASE(ch); ------------------ | | 1862| 747|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 747|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 747|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 747|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 747| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 747|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 747|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 747|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 747| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 747|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 747|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1120| 1.04k| else 1121| 1.04k| ch = (mb->fcc)[ch]; 1122| 1.79k| if (ch == fc) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 234| {\ | | 555| 234| rrc = ra;\ | | 556| 234| goto RETURN_SWITCH;\ | | 557| 234| } ------------------ | Branch (1122:13): [True: 234, False: 1.55k] ------------------ 1123| 1.55k| } 1124| 5.14k| } 1125| | 1126| 16.1k| else 1127| 16.1k|#endif /* SUPPORT_UNICODE */ 1128| | 1129| | /* Neither UTF nor UCP is set */ 1130| | 1131| 16.1k| { 1132| 16.1k| uint32_t ch = Fecode[1]; ------------------ | | 176| 16.1k|#define Fecode F->ecode ------------------ 1133| 16.1k| fc = UCHAR21INC(Feptr); ------------------ | | 245| 16.1k|#define UCHAR21INC(eptr) (*(eptr)++) ------------------ 1134| 16.1k| if (ch == fc || (Fop == OP_NOTI && TABLE_GET(ch, mb->fcc, ch) == fc)) ------------------ | | 186| 13.2k|#define Fop F->op ------------------ if (ch == fc || (Fop == OP_NOTI && TABLE_GET(ch, mb->fcc, ch) == fc)) ------------------ | | 214| 4.17k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ | Branch (1134:11): [True: 2.87k, False: 13.2k] | Branch (1134:24): [True: 4.17k, False: 9.06k] | Branch (1134:42): [True: 243, False: 3.93k] ------------------ 1135| 12.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.11k| {\ | | 555| 3.11k| rrc = ra;\ | | 556| 3.11k| goto RETURN_SWITCH;\ | | 557| 3.11k| } ------------------ 1136| 12.9k| Fecode += 2; ------------------ | | 176| 12.9k|#define Fecode F->ecode ------------------ 1137| 12.9k| } 1138| 29.7k| break; 1139| | 1140| | 1141| | /* ===================================================================== */ 1142| | /* Match a single character repeatedly. */ 1143| | 1144| 29.7k|#define Loclength F->temp_size 1145| 29.7k|#define Lstart_eptr F->temp_sptr[0] 1146| 29.7k|#define Lcharptr F->temp_sptr[1] 1147| 29.7k|#define Lmin F->temp_32[0] 1148| 29.7k|#define Lmax F->temp_32[1] 1149| 29.7k|#define Lc F->temp_32[2] 1150| 29.7k|#define Loc F->temp_32[3] 1151| | 1152| 29.7k| case OP_EXACT: ------------------ | Branch (1152:5): [True: 18.3k, False: 2.33G] ------------------ 1153| 26.5k| case OP_EXACTI: ------------------ | Branch (1153:5): [True: 8.14k, False: 2.33G] ------------------ 1154| 26.5k| Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 1147| 26.5k|#define Lmin F->temp_32[0] ------------------ Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 1148| 26.5k|#define Lmax F->temp_32[1] ------------------ Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 194| 26.5k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1155| 26.5k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 26.5k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 26.5k|#define IMM2_SIZE 2 ------------------ 1156| 26.5k| goto REPEATCHAR; 1157| | 1158| 3.99k| case OP_POSUPTO: ------------------ | Branch (1158:5): [True: 3.99k, False: 2.33G] ------------------ 1159| 4.89k| case OP_POSUPTOI: ------------------ | Branch (1159:5): [True: 902, False: 2.33G] ------------------ 1160| 4.89k| reptype = REPTYPE_POS; 1161| 4.89k| Lmin = 0; ------------------ | | 1147| 4.89k|#define Lmin F->temp_32[0] ------------------ 1162| 4.89k| Lmax = GET2(Fecode, 1); ------------------ | | 1148| 4.89k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 4.89k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1163| 4.89k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 4.89k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 4.89k|#define IMM2_SIZE 2 ------------------ 1164| 4.89k| goto REPEATCHAR; 1165| | 1166| 3.42k| case OP_UPTO: ------------------ | Branch (1166:5): [True: 3.42k, False: 2.33G] ------------------ 1167| 5.07k| case OP_UPTOI: ------------------ | Branch (1167:5): [True: 1.65k, False: 2.33G] ------------------ 1168| 5.07k| reptype = REPTYPE_MAX; 1169| 5.07k| Lmin = 0; ------------------ | | 1147| 5.07k|#define Lmin F->temp_32[0] ------------------ 1170| 5.07k| Lmax = GET2(Fecode, 1); ------------------ | | 1148| 5.07k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 5.07k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1171| 5.07k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 5.07k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 5.07k|#define IMM2_SIZE 2 ------------------ 1172| 5.07k| goto REPEATCHAR; 1173| | 1174| 1.45k| case OP_MINUPTO: ------------------ | Branch (1174:5): [True: 1.45k, False: 2.33G] ------------------ 1175| 2.13k| case OP_MINUPTOI: ------------------ | Branch (1175:5): [True: 675, False: 2.33G] ------------------ 1176| 2.13k| reptype = REPTYPE_MIN; 1177| 2.13k| Lmin = 0; ------------------ | | 1147| 2.13k|#define Lmin F->temp_32[0] ------------------ 1178| 2.13k| Lmax = GET2(Fecode, 1); ------------------ | | 1148| 2.13k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 2.13k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1179| 2.13k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 2.13k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 2.13k|#define IMM2_SIZE 2 ------------------ 1180| 2.13k| goto REPEATCHAR; 1181| | 1182| 46.7k| case OP_POSSTAR: ------------------ | Branch (1182:5): [True: 46.7k, False: 2.33G] ------------------ 1183| 59.2k| case OP_POSSTARI: ------------------ | Branch (1183:5): [True: 12.4k, False: 2.33G] ------------------ 1184| 59.2k| reptype = REPTYPE_POS; 1185| 59.2k| Lmin = 0; ------------------ | | 1147| 59.2k|#define Lmin F->temp_32[0] ------------------ 1186| 59.2k| Lmax = UINT32_MAX; ------------------ | | 1148| 59.2k|#define Lmax F->temp_32[1] ------------------ 1187| 59.2k| Fecode++; ------------------ | | 176| 59.2k|#define Fecode F->ecode ------------------ 1188| 59.2k| goto REPEATCHAR; 1189| | 1190| 683k| case OP_POSPLUS: ------------------ | Branch (1190:5): [True: 683k, False: 2.33G] ------------------ 1191| 706k| case OP_POSPLUSI: ------------------ | Branch (1191:5): [True: 22.9k, False: 2.33G] ------------------ 1192| 706k| reptype = REPTYPE_POS; 1193| 706k| Lmin = 1; ------------------ | | 1147| 706k|#define Lmin F->temp_32[0] ------------------ 1194| 706k| Lmax = UINT32_MAX; ------------------ | | 1148| 706k|#define Lmax F->temp_32[1] ------------------ 1195| 706k| Fecode++; ------------------ | | 176| 706k|#define Fecode F->ecode ------------------ 1196| 706k| goto REPEATCHAR; 1197| | 1198| 228k| case OP_POSQUERY: ------------------ | Branch (1198:5): [True: 228k, False: 2.33G] ------------------ 1199| 236k| case OP_POSQUERYI: ------------------ | Branch (1199:5): [True: 8.14k, False: 2.33G] ------------------ 1200| 236k| reptype = REPTYPE_POS; 1201| 236k| Lmin = 0; ------------------ | | 1147| 236k|#define Lmin F->temp_32[0] ------------------ 1202| 236k| Lmax = 1; ------------------ | | 1148| 236k|#define Lmax F->temp_32[1] ------------------ 1203| 236k| Fecode++; ------------------ | | 176| 236k|#define Fecode F->ecode ------------------ 1204| 236k| goto REPEATCHAR; 1205| | 1206| 63.5k| case OP_STAR: ------------------ | Branch (1206:5): [True: 63.5k, False: 2.33G] ------------------ 1207| 230k| case OP_STARI: ------------------ | Branch (1207:5): [True: 166k, False: 2.33G] ------------------ 1208| 240k| case OP_MINSTAR: ------------------ | Branch (1208:5): [True: 10.4k, False: 2.33G] ------------------ 1209| 258k| case OP_MINSTARI: ------------------ | Branch (1209:5): [True: 17.7k, False: 2.33G] ------------------ 1210| 286k| case OP_PLUS: ------------------ | Branch (1210:5): [True: 27.8k, False: 2.33G] ------------------ 1211| 308k| case OP_PLUSI: ------------------ | Branch (1211:5): [True: 22.2k, False: 2.33G] ------------------ 1212| 316k| case OP_MINPLUS: ------------------ | Branch (1212:5): [True: 8.17k, False: 2.33G] ------------------ 1213| 332k| case OP_MINPLUSI: ------------------ | Branch (1213:5): [True: 16.5k, False: 2.33G] ------------------ 1214| 400k| case OP_QUERY: ------------------ | Branch (1214:5): [True: 67.6k, False: 2.33G] ------------------ 1215| 1.87M| case OP_QUERYI: ------------------ | Branch (1215:5): [True: 1.47M, False: 2.33G] ------------------ 1216| 1.89M| case OP_MINQUERY: ------------------ | Branch (1216:5): [True: 24.7k, False: 2.33G] ------------------ 1217| 1.92M| case OP_MINQUERYI: ------------------ | Branch (1217:5): [True: 25.7k, False: 2.33G] ------------------ 1218| 1.92M| fc = *Fecode++ - ((Fop < OP_STARI)? OP_STAR : OP_STARI); ------------------ | | 176| 1.92M|#define Fecode F->ecode ------------------ fc = *Fecode++ - ((Fop < OP_STARI)? OP_STAR : OP_STARI); ------------------ | | 186| 1.92M|#define Fop F->op ------------------ | Branch (1218:23): [True: 202k, False: 1.72M] ------------------ 1219| 1.92M| Lmin = rep_min[fc]; ------------------ | | 1147| 1.92M|#define Lmin F->temp_32[0] ------------------ 1220| 1.92M| Lmax = rep_max[fc]; ------------------ | | 1148| 1.92M|#define Lmax F->temp_32[1] ------------------ 1221| 1.92M| reptype = rep_typ[fc]; 1222| | 1223| | /* Common code for all repeated single-character matches. We first check 1224| | for the minimum number of characters. If the minimum equals the maximum, we 1225| | are done. Otherwise, if minimizing, check the rest of the pattern for a 1226| | match; if there isn't one, advance up to the maximum, one character at a 1227| | time. 1228| | 1229| | If maximizing, advance up to the maximum number of matching characters, 1230| | until Feptr is past the end of the maximum run. If possessive, we are 1231| | then done (no backing up). Otherwise, match at this position; anything 1232| | other than no match is immediately returned. For nomatch, back up one 1233| | character, unless we are matching \R and the last thing matched was 1234| | \r\n, in which case, back up two code units until we reach the first 1235| | optional character position. 1236| | 1237| | The various UTF/non-UTF and caseful/caseless cases are handled separately, 1238| | for speed. */ 1239| | 1240| 2.96M| REPEATCHAR: 1241| 2.96M|#ifdef SUPPORT_UNICODE 1242| 2.96M| if (utf) ------------------ | Branch (1242:9): [True: 1.82M, False: 1.14M] ------------------ 1243| 1.82M| { 1244| 1.82M| Flength = 1; ------------------ | | 180| 1.82M|#define Flength F->length ------------------ 1245| 1.82M| Lcharptr = Fecode; ------------------ | | 1146| 1.82M|#define Lcharptr F->temp_sptr[1] ------------------ Lcharptr = Fecode; ------------------ | | 176| 1.82M|#define Fecode F->ecode ------------------ 1246| 1.82M| GETCHARLEN(fc, Fecode, Flength); ------------------ | | 330| 1.82M| c = *eptr; \ | | 331| 1.82M| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.38M| { \ | | | | 323| 1.38M| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 1.36M, False: 15.6k] | | | | ------------------ | | | | 324| 1.38M| { \ | | | | 325| 1.36M| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 1.36M| len++; \ | | | | 327| 1.36M| } \ | | | | 328| 1.38M| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 11.5k, False: 4.07k] | | | | ------------------ | | | | 329| 15.6k| { \ | | | | 330| 11.5k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 11.5k| len += 2; \ | | | | 332| 11.5k| } \ | | | | 333| 15.6k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 4.07k, False: 0] | | | | ------------------ | | | | 334| 4.07k| {\ | | | | 335| 4.07k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 4.07k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 4.07k| len += 3; \ | | | | 338| 4.07k| } \ | | | | 339| 4.07k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.38M| } | | ------------------ | | | Branch (331:7): [True: 1.38M, False: 442k] | | ------------------ ------------------ 1247| 1.82M| Fecode += Flength; ------------------ | | 176| 1.82M|#define Fecode F->ecode ------------------ Fecode += Flength; ------------------ | | 180| 1.82M|#define Flength F->length ------------------ 1248| | 1249| | /* Handle multi-code-unit character matching, caseful and caseless. */ 1250| | 1251| 1.82M| if (Flength > 1) ------------------ | | 180| 1.82M|#define Flength F->length ------------------ | Branch (1251:11): [True: 1.38M, False: 442k] ------------------ 1252| 1.38M| { 1253| 1.38M| uint32_t othercase; 1254| | 1255| 1.38M| if (Fop >= OP_STARI && /* Caseless */ ------------------ | | 186| 1.38M|#define Fop F->op ------------------ | Branch (1255:13): [True: 1.34M, False: 35.6k] ------------------ 1256| 1.38M| (othercase = UCD_OTHERCASE(fc)) != fc) ------------------ | | 1862| 1.34M|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 1.34M|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 1.34M|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 1.34M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 1.34M| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 1.34M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 1.34M|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 1.34M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 1.34M| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 1.34M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 1.34M|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1256:13): [True: 43.2k, False: 1.30M] ------------------ 1257| 43.2k| Loclength = PRIV(ord2utf)(othercase, Foccu); ------------------ | | 1144| 43.2k|#define Loclength F->temp_size ------------------ Loclength = PRIV(ord2utf)(othercase, Foccu); ------------------ | | 177| 43.2k|#define PRIV(name) _pcre2_##name ------------------ Loclength = PRIV(ord2utf)(othercase, Foccu); ------------------ | | 185| 43.2k|#define Foccu F->occu ------------------ 1258| 1.33M| else Loclength = 0; ------------------ | | 1144| 1.33M|#define Loclength F->temp_size ------------------ 1259| | 1260| 1.38M| for (i = 1; i <= Lmin; i++) ------------------ | | 1147| 1.38M|#define Lmin F->temp_32[0] ------------------ | Branch (1260:21): [True: 33.7k, False: 1.35M] ------------------ 1261| 33.7k| { 1262| 33.7k| if (Feptr <= mb->end_subject - Flength && ------------------ | | 177| 33.7k|#define Feptr F->eptr ------------------ if (Feptr <= mb->end_subject - Flength && ------------------ | | 180| 67.4k|#define Flength F->length ------------------ | Branch (1262:15): [True: 27.5k, False: 6.12k] ------------------ 1263| 33.7k| memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 177| 27.5k|#define Feptr F->eptr ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 1146| 27.5k|#define Lcharptr F->temp_sptr[1] ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 545| 27.5k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 177| 4.29k|#define Feptr F->eptr ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 180| 4.29k|#define Flength F->length ------------------ | Branch (1263:13): [True: 4.29k, False: 23.3k] ------------------ 1264| 29.4k| else if (Loclength > 0 && ------------------ | | 1144| 29.4k|#define Loclength F->temp_size ------------------ | Branch (1264:20): [True: 13.6k, False: 15.8k] ------------------ 1265| 29.4k| Feptr <= mb->end_subject - Loclength && ------------------ | | 177| 13.6k|#define Feptr F->eptr ------------------ Feptr <= mb->end_subject - Loclength && ------------------ | | 1144| 43.0k|#define Loclength F->temp_size ------------------ | Branch (1265:20): [True: 11.4k, False: 2.17k] ------------------ 1266| 29.4k| memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 177| 11.4k|#define Feptr F->eptr ------------------ memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 185| 11.4k|#define Foccu F->occu ------------------ memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 545| 11.4k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ | Branch (1266:20): [True: 992, False: 10.4k] ------------------ 1267| 992| Feptr += Loclength; ------------------ | | 177| 992|#define Feptr F->eptr ------------------ Feptr += Loclength; ------------------ | | 1144| 992|#define Loclength F->temp_size ------------------ 1268| 28.4k| else 1269| 28.4k| { 1270| 28.4k| CHECK_PARTIAL(); ------------------ | | 527| 28.4k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 28.4k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 3.79k, False: 24.6k] | | ------------------ | | 528| 28.4k| { \ | | 529| 3.79k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 3.79k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 870, False: 2.92k] | | | | ------------------ | | | | 534| 3.79k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 870|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 384, False: 486] | | | | | Branch (534:38): [True: 228, False: 258] | | | | ------------------ | | | | 535| 3.79k| { \ | | | | 536| 612| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 612|#define TRUE 1 | | | | ------------------ | | | | 537| 612| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 9|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 9, False: 603] | | | | ------------------ | | | | 538| 612| } | | ------------------ | | 530| 3.78k| } ------------------ 1271| 28.4k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 28.4k| {\ | | 555| 28.4k| rrc = ra;\ | | 556| 28.4k| goto RETURN_SWITCH;\ | | 557| 28.4k| } ------------------ 1272| 0| } 1273| 33.7k| } 1274| | 1275| 1.35M| if (Lmin == Lmax) continue; ------------------ | | 1147| 1.35M|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 1148| 1.35M|#define Lmax F->temp_32[1] ------------------ | Branch (1275:13): [True: 222, False: 1.35M] ------------------ 1276| | 1277| 1.35M| if (reptype == REPTYPE_MIN) ------------------ | Branch (1277:13): [True: 28.8k, False: 1.32M] ------------------ 1278| 28.8k| { 1279| 28.8k| for (;;) 1280| 37.8k| { 1281| 37.8k| RMATCH(Fecode, RM202); ------------------ | | 546| 37.8k| {\ | | 547| 37.8k| start_ecode = ra;\ | | 548| 37.8k| Freturn_id = rb;\ | | ------------------ | | | | 188| 37.8k|#define Freturn_id F->return_id | | ------------------ | | 549| 37.8k| goto MATCH_RECURSE;\ | | 550| 37.8k| L_##rb:;\ | | 551| 37.2k| } ------------------ 1282| 37.2k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 37.2k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 326| {\ | | 555| 326| rrc = ra;\ | | 556| 326| goto RETURN_SWITCH;\ | | 557| 326| } ------------------ | Branch (1282:17): [True: 326, False: 36.8k] ------------------ 1283| 36.8k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1147| 36.8k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1148| 36.8k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.80k| {\ | | 555| 1.80k| rrc = ra;\ | | 556| 1.80k| goto RETURN_SWITCH;\ | | 557| 1.80k| } ------------------ | Branch (1283:17): [True: 1.80k, False: 35.0k] ------------------ 1284| 35.0k| if (Feptr <= mb->end_subject - Flength && ------------------ | | 177| 35.0k|#define Feptr F->eptr ------------------ if (Feptr <= mb->end_subject - Flength && ------------------ | | 180| 70.1k|#define Flength F->length ------------------ | Branch (1284:17): [True: 29.8k, False: 5.20k] ------------------ 1285| 35.0k| memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 177| 29.8k|#define Feptr F->eptr ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 1146| 29.8k|#define Lcharptr F->temp_sptr[1] ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 545| 29.8k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 177| 8.50k|#define Feptr F->eptr ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength; ------------------ | | 180| 8.50k|#define Flength F->length ------------------ | Branch (1285:15): [True: 8.50k, False: 21.3k] ------------------ 1286| 26.5k| else if (Loclength > 0 && ------------------ | | 1144| 26.5k|#define Loclength F->temp_size ------------------ | Branch (1286:22): [True: 13.8k, False: 12.6k] ------------------ 1287| 26.5k| Feptr <= mb->end_subject - Loclength && ------------------ | | 177| 13.8k|#define Feptr F->eptr ------------------ Feptr <= mb->end_subject - Loclength && ------------------ | | 1144| 40.4k|#define Loclength F->temp_size ------------------ | Branch (1287:22): [True: 11.3k, False: 2.55k] ------------------ 1288| 26.5k| memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 177| 11.3k|#define Feptr F->eptr ------------------ memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 185| 11.3k|#define Foccu F->occu ------------------ memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 545| 11.3k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ | Branch (1288:22): [True: 428, False: 10.9k] ------------------ 1289| 428| Feptr += Loclength; ------------------ | | 177| 428|#define Feptr F->eptr ------------------ Feptr += Loclength; ------------------ | | 1144| 428|#define Loclength F->temp_size ------------------ 1290| 26.1k| else 1291| 26.1k| { 1292| 26.1k| CHECK_PARTIAL(); ------------------ | | 527| 26.1k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 26.1k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 2.63k, False: 23.5k] | | ------------------ | | 528| 26.1k| { \ | | 529| 2.63k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 2.63k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 993, False: 1.64k] | | | | ------------------ | | | | 534| 2.63k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 993|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 484, False: 509] | | | | | Branch (534:38): [True: 237, False: 272] | | | | ------------------ | | | | 535| 2.63k| { \ | | | | 536| 721| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 721|#define TRUE 1 | | | | ------------------ | | | | 537| 721| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 9|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 9, False: 712] | | | | ------------------ | | | | 538| 721| } | | ------------------ | | 530| 2.62k| } ------------------ 1293| 26.1k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 26.1k| {\ | | 555| 26.1k| rrc = ra;\ | | 556| 26.1k| goto RETURN_SWITCH;\ | | 557| 26.1k| } ------------------ 1294| 0| } 1295| 35.0k| } 1296| | /* Control never gets here */ 1297| 28.8k| } 1298| | 1299| 1.32M| else /* Maximize */ 1300| 1.32M| { 1301| 1.32M| Lstart_eptr = Feptr; ------------------ | | 1145| 1.32M|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; ------------------ | | 177| 1.32M|#define Feptr F->eptr ------------------ 1302| 1.32M| for (i = Lmin; i < Lmax; i++) ------------------ | | 1147| 1.32M|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1148| 1.32M|#define Lmax F->temp_32[1] ------------------ | Branch (1302:26): [True: 1.32M, False: 1.80k] ------------------ 1303| 1.32M| { 1304| 1.32M| if (Feptr <= mb->end_subject - Flength && ------------------ | | 177| 1.32M|#define Feptr F->eptr ------------------ if (Feptr <= mb->end_subject - Flength && ------------------ | | 180| 2.65M|#define Flength F->length ------------------ | Branch (1304:17): [True: 1.31M, False: 7.20k] ------------------ 1305| 1.32M| memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) ------------------ | | 177| 1.31M|#define Feptr F->eptr ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) ------------------ | | 1146| 1.31M|#define Lcharptr F->temp_sptr[1] ------------------ memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) ------------------ | | 545| 1.31M|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ | Branch (1305:17): [True: 2.98k, False: 1.31M] ------------------ 1306| 2.98k| Feptr += Flength; ------------------ | | 177| 2.98k|#define Feptr F->eptr ------------------ Feptr += Flength; ------------------ | | 180| 2.98k|#define Flength F->length ------------------ 1307| 1.32M| else if (Loclength > 0 && ------------------ | | 1144| 1.32M|#define Loclength F->temp_size ------------------ | Branch (1307:22): [True: 15.5k, False: 1.30M] ------------------ 1308| 1.32M| Feptr <= mb->end_subject - Loclength && ------------------ | | 177| 15.5k|#define Feptr F->eptr ------------------ Feptr <= mb->end_subject - Loclength && ------------------ | | 1144| 1.33M|#define Loclength F->temp_size ------------------ | Branch (1308:22): [True: 13.4k, False: 2.13k] ------------------ 1309| 1.32M| memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 177| 13.4k|#define Feptr F->eptr ------------------ memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 185| 13.4k|#define Foccu F->occu ------------------ memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0) ------------------ | | 545| 13.4k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ | Branch (1309:22): [True: 257, False: 13.2k] ------------------ 1310| 257| Feptr += Loclength; ------------------ | | 177| 257|#define Feptr F->eptr ------------------ Feptr += Loclength; ------------------ | | 1144| 257|#define Loclength F->temp_size ------------------ 1311| 1.32M| else 1312| 1.32M| { 1313| 1.32M| CHECK_PARTIAL(); ------------------ | | 527| 1.32M| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 1.32M|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 3.57k, False: 1.31M] | | ------------------ | | 528| 1.32M| { \ | | 529| 3.57k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 3.57k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 1.51k, False: 2.05k] | | | | ------------------ | | | | 534| 3.57k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 1.51k|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 457, False: 1.06k] | | | | | Branch (534:38): [True: 286, False: 776] | | | | ------------------ | | | | 535| 3.57k| { \ | | | | 536| 743| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 743|#define TRUE 1 | | | | ------------------ | | | | 537| 743| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 19|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 19, False: 724] | | | | ------------------ | | | | 538| 743| } | | ------------------ | | 530| 3.55k| } ------------------ 1314| 1.32M| break; 1315| 1.32M| } 1316| 1.32M| } 1317| | 1318| | /* After \C in UTF mode, Lstart_eptr might be in the middle of a 1319| | Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't 1320| | go too far. */ 1321| | 1322| 1.32M| if (reptype != REPTYPE_POS) for(;;) ------------------ | Branch (1322:15): [True: 1.31M, False: 8.20k] ------------------ 1323| 1.31M| { 1324| 1.31M| if (Feptr <= Lstart_eptr) break; ------------------ | | 177| 1.31M|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; ------------------ | | 1145| 1.31M|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (1324:17): [True: 1.31M, False: 2.44k] ------------------ 1325| 2.44k| RMATCH(Fecode, RM203); ------------------ | | 546| 2.44k| {\ | | 547| 2.44k| start_ecode = ra;\ | | 548| 2.44k| Freturn_id = rb;\ | | ------------------ | | | | 188| 2.44k|#define Freturn_id F->return_id | | ------------------ | | 549| 2.44k| goto MATCH_RECURSE;\ | | 550| 2.44k| L_##rb:;\ | | 551| 2.39k| } ------------------ 1326| 2.39k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 2.39k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 248| {\ | | 555| 248| rrc = ra;\ | | 556| 248| goto RETURN_SWITCH;\ | | 557| 248| } ------------------ | Branch (1326:17): [True: 248, False: 2.14k] ------------------ 1327| 2.14k| Feptr--; ------------------ | | 177| 2.14k|#define Feptr F->eptr ------------------ 1328| 2.14k| BACKCHAR(Feptr); ------------------ | | 345| 4.81k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 2.66k, False: 2.14k] | | ------------------ ------------------ 1329| 2.14k| } 1330| 1.32M| } 1331| 1.32M| break; /* End of repeated wide character handling */ 1332| 1.35M| } 1333| | 1334| | /* Length of UTF character is 1. Put it into the preserved variable and 1335| | fall through to the non-UTF code. */ 1336| | 1337| 442k| Lc = fc; ------------------ | | 1149| 442k|#define Lc F->temp_32[2] ------------------ 1338| 442k| } 1339| 1.14M| else 1340| 1.14M|#endif /* SUPPORT_UNICODE */ 1341| | 1342| | /* When not in UTF mode, load a single-code-unit character. Then proceed as 1343| | above, using Unicode casing if either UTF or UCP is set. */ 1344| | 1345| 1.14M| Lc = *Fecode++; ------------------ | | 1149| 1.14M|#define Lc F->temp_32[2] ------------------ Lc = *Fecode++; ------------------ | | 176| 1.14M|#define Fecode F->ecode ------------------ 1346| | 1347| | /* Caseless comparison */ 1348| | 1349| 1.58M| if (Fop >= OP_STARI) ------------------ | | 186| 1.58M|#define Fop F->op ------------------ | Branch (1349:9): [True: 431k, False: 1.15M] ------------------ 1350| 431k| { 1351| 431k|#if PCRE2_CODE_UNIT_WIDTH == 8 1352| 431k|#ifdef SUPPORT_UNICODE 1353| 431k| if (ucp && !utf && Lc > 127) Loc = UCD_OTHERCASE(Lc); ------------------ | | 1149| 10.7k|#define Lc F->temp_32[2] ------------------ if (ucp && !utf && Lc > 127) Loc = UCD_OTHERCASE(Lc); ------------------ | | 1150| 3.72k|#define Loc F->temp_32[3] ------------------ if (ucp && !utf && Lc > 127) Loc = UCD_OTHERCASE(Lc); ------------------ | | 1862| 3.72k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 3.72k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 3.72k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 3.72k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 3.72k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 3.72k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 3.72k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 3.72k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 3.72k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 3.72k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 3.72k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1353:11): [True: 50.2k, False: 381k] | Branch (1353:18): [True: 10.7k, False: 39.5k] | Branch (1353:26): [True: 3.72k, False: 6.98k] ------------------ 1354| 427k| else 1355| 427k|#endif /* SUPPORT_UNICODE */ 1356| | /* Lc will be < 128 in UTF-8 mode. */ 1357| 427k| Loc = mb->fcc[Lc]; ------------------ | | 1150| 427k|#define Loc F->temp_32[3] ------------------ Loc = mb->fcc[Lc]; ------------------ | | 1149| 427k|#define Lc F->temp_32[2] ------------------ 1358| |#else /* 16-bit & 32-bit */ 1359| |#ifdef SUPPORT_UNICODE 1360| | if ((utf || ucp) && Lc > 127) Loc = UCD_OTHERCASE(Lc); 1361| | else 1362| |#endif /* SUPPORT_UNICODE */ 1363| | Loc = TABLE_GET(Lc, mb->fcc, Lc); 1364| |#endif /* PCRE2_CODE_UNIT_WIDTH == 8 */ 1365| | 1366| 442k| for (i = 1; i <= Lmin; i++) ------------------ | | 1147| 442k|#define Lmin F->temp_32[0] ------------------ | Branch (1366:19): [True: 55.6k, False: 386k] ------------------ 1367| 55.6k| { 1368| 55.6k| uint32_t cc; /* Faster than PCRE2_UCHAR */ 1369| 55.6k| if (Feptr >= mb->end_subject) ------------------ | | 177| 55.6k|#define Feptr F->eptr ------------------ | Branch (1369:13): [True: 8.04k, False: 47.6k] ------------------ 1370| 8.04k| { 1371| 8.04k| SCHECK_PARTIAL(); ------------------ | | 533| 8.04k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.43k, False: 5.61k] | | ------------------ | | 534| 8.04k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.43k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.63k, False: 799] | | | Branch (534:38): [True: 233, False: 566] | | ------------------ | | 535| 8.04k| { \ | | 536| 1.86k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.86k|#define TRUE 1 | | ------------------ | | 537| 1.86k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 23|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 23, False: 1.84k] | | ------------------ | | 538| 1.86k| } ------------------ 1372| 8.02k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 8.02k| {\ | | 555| 8.02k| rrc = ra;\ | | 556| 8.02k| goto RETURN_SWITCH;\ | | 557| 8.02k| } ------------------ 1373| 0| } 1374| 47.6k| cc = UCHAR21TEST(Feptr); ------------------ | | 244| 47.6k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 1375| 47.6k| if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH); ------------------ | | 1149| 47.6k|#define Lc F->temp_32[2] ------------------ if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH); ------------------ | | 1150| 36.7k|#define Loc F->temp_32[3] ------------------ if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 36.3k| {\ | | 555| 36.3k| rrc = ra;\ | | 556| 36.3k| goto RETURN_SWITCH;\ | | 557| 36.3k| } ------------------ | Branch (1375:13): [True: 36.7k, False: 10.8k] | Branch (1375:25): [True: 36.3k, False: 370] ------------------ 1376| 11.2k| Feptr++; ------------------ | | 177| 11.2k|#define Feptr F->eptr ------------------ 1377| 11.2k| } 1378| 386k| if (Lmin == Lmax) continue; ------------------ | | 1147| 386k|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 1148| 386k|#define Lmax F->temp_32[1] ------------------ | Branch (1378:11): [True: 262, False: 386k] ------------------ 1379| | 1380| 386k| if (reptype == REPTYPE_MIN) ------------------ | Branch (1380:11): [True: 27.5k, False: 359k] ------------------ 1381| 27.5k| { 1382| 27.5k| for (;;) 1383| 32.3k| { 1384| 32.3k| uint32_t cc; /* Faster than PCRE2_UCHAR */ 1385| 32.3k| RMATCH(Fecode, RM25); ------------------ | | 546| 32.3k| {\ | | 547| 32.3k| start_ecode = ra;\ | | 548| 32.3k| Freturn_id = rb;\ | | ------------------ | | | | 188| 32.3k|#define Freturn_id F->return_id | | ------------------ | | 549| 32.3k| goto MATCH_RECURSE;\ | | 550| 32.3k| L_##rb:;\ | | 551| 30.5k| } ------------------ 1386| 30.5k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 30.5k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.30k| {\ | | 555| 1.30k| rrc = ra;\ | | 556| 1.30k| goto RETURN_SWITCH;\ | | 557| 1.30k| } ------------------ | Branch (1386:15): [True: 1.30k, False: 29.2k] ------------------ 1387| 29.2k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1147| 29.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1148| 29.2k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.19k| {\ | | 555| 1.19k| rrc = ra;\ | | 556| 1.19k| goto RETURN_SWITCH;\ | | 557| 1.19k| } ------------------ | Branch (1387:15): [True: 1.19k, False: 28.0k] ------------------ 1388| 28.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 28.0k|#define Feptr F->eptr ------------------ | Branch (1388:15): [True: 5.27k, False: 22.8k] ------------------ 1389| 5.27k| { 1390| 5.27k| SCHECK_PARTIAL(); ------------------ | | 533| 5.27k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.14k, False: 3.12k] | | ------------------ | | 534| 5.27k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.14k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.65k, False: 497] | | | Branch (534:38): [True: 241, False: 256] | | ------------------ | | 535| 5.27k| { \ | | 536| 1.89k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.89k|#define TRUE 1 | | ------------------ | | 537| 1.89k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 5, False: 1.88k] | | ------------------ | | 538| 1.89k| } ------------------ 1391| 5.26k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.26k| {\ | | 555| 5.26k| rrc = ra;\ | | 556| 5.26k| goto RETURN_SWITCH;\ | | 557| 5.26k| } ------------------ 1392| 0| } 1393| 22.8k| cc = UCHAR21TEST(Feptr); ------------------ | | 244| 22.8k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 1394| 22.8k| if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH); ------------------ | | 1149| 22.8k|#define Lc F->temp_32[2] ------------------ if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH); ------------------ | | 1150| 18.4k|#define Loc F->temp_32[3] ------------------ if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 18.0k| {\ | | 555| 18.0k| rrc = ra;\ | | 556| 18.0k| goto RETURN_SWITCH;\ | | 557| 18.0k| } ------------------ | Branch (1394:15): [True: 18.4k, False: 4.38k] | Branch (1394:27): [True: 18.0k, False: 365] ------------------ 1395| 4.75k| Feptr++; ------------------ | | 177| 4.75k|#define Feptr F->eptr ------------------ 1396| 4.75k| } 1397| | /* Control never gets here */ 1398| 27.5k| } 1399| | 1400| 359k| else /* Maximize */ 1401| 359k| { 1402| 359k| Lstart_eptr = Feptr; ------------------ | | 1145| 359k|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; ------------------ | | 177| 359k|#define Feptr F->eptr ------------------ 1403| 372k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1147| 359k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1148| 372k|#define Lmax F->temp_32[1] ------------------ | Branch (1403:24): [True: 367k, False: 5.78k] ------------------ 1404| 367k| { 1405| 367k| uint32_t cc; /* Faster than PCRE2_UCHAR */ 1406| 367k| if (Feptr >= mb->end_subject) ------------------ | | 177| 367k|#define Feptr F->eptr ------------------ | Branch (1406:15): [True: 13.9k, False: 353k] ------------------ 1407| 13.9k| { 1408| 13.9k| SCHECK_PARTIAL(); ------------------ | | 533| 13.9k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 6.55k, False: 7.40k] | | ------------------ | | 534| 13.9k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 6.55k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 4.32k, False: 2.22k] | | | Branch (534:38): [True: 554, False: 1.67k] | | ------------------ | | 535| 13.9k| { \ | | 536| 4.88k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 4.88k|#define TRUE 1 | | ------------------ | | 537| 4.88k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 22|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 22, False: 4.85k] | | ------------------ | | 538| 4.88k| } ------------------ 1409| 13.9k| break; 1410| 13.9k| } 1411| 353k| cc = UCHAR21TEST(Feptr); ------------------ | | 244| 353k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 1412| 353k| if (Lc != cc && Loc != cc) break; ------------------ | | 1149| 353k|#define Lc F->temp_32[2] ------------------ if (Lc != cc && Loc != cc) break; ------------------ | | 1150| 339k|#define Loc F->temp_32[3] ------------------ | Branch (1412:15): [True: 339k, False: 13.5k] | Branch (1412:27): [True: 339k, False: 354] ------------------ 1413| 13.9k| Feptr++; ------------------ | | 177| 13.9k|#define Feptr F->eptr ------------------ 1414| 13.9k| } 1415| 359k| if (reptype != REPTYPE_POS) for (;;) ------------------ | Branch (1415:13): [True: 342k, False: 16.5k] ------------------ 1416| 353k| { 1417| 353k| if (Feptr == Lstart_eptr) break; ------------------ | | 177| 353k|#define Feptr F->eptr ------------------ if (Feptr == Lstart_eptr) break; ------------------ | | 1145| 353k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (1417:15): [True: 342k, False: 11.8k] ------------------ 1418| 11.8k| RMATCH(Fecode, RM26); ------------------ | | 546| 11.8k| {\ | | 547| 11.8k| start_ecode = ra;\ | | 548| 11.8k| Freturn_id = rb;\ | | ------------------ | | | | 188| 11.8k|#define Freturn_id F->return_id | | ------------------ | | 549| 11.8k| goto MATCH_RECURSE;\ | | 550| 11.8k| L_##rb:;\ | | 551| 11.7k| } ------------------ 1419| 11.7k| Feptr--; ------------------ | | 177| 11.7k|#define Feptr F->eptr ------------------ 1420| 11.7k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 11.7k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 230| {\ | | 555| 230| rrc = ra;\ | | 556| 230| goto RETURN_SWITCH;\ | | 557| 230| } ------------------ | Branch (1420:15): [True: 230, False: 11.5k] ------------------ 1421| 11.5k| } 1422| 359k| } 1423| 386k| } 1424| | 1425| | /* Caseful comparisons (includes all multi-byte characters) */ 1426| | 1427| 1.15M| else 1428| 1.15M| { 1429| 1.17M| for (i = 1; i <= Lmin; i++) ------------------ | | 1147| 1.17M|#define Lmin F->temp_32[0] ------------------ | Branch (1429:19): [True: 728k, False: 451k] ------------------ 1430| 728k| { 1431| 728k| if (Feptr >= mb->end_subject) ------------------ | | 177| 728k|#define Feptr F->eptr ------------------ | Branch (1431:13): [True: 15.4k, False: 712k] ------------------ 1432| 15.4k| { 1433| 15.4k| SCHECK_PARTIAL(); ------------------ | | 533| 15.4k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 4.84k, False: 10.6k] | | ------------------ | | 534| 15.4k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 4.84k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 2.54k, False: 2.30k] | | | Branch (534:38): [True: 889, False: 1.41k] | | ------------------ | | 535| 15.4k| { \ | | 536| 3.43k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 3.43k|#define TRUE 1 | | ------------------ | | 537| 3.43k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 44|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 44, False: 3.39k] | | ------------------ | | 538| 3.43k| } ------------------ 1434| 15.4k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 15.4k| {\ | | 555| 15.4k| rrc = ra;\ | | 556| 15.4k| goto RETURN_SWITCH;\ | | 557| 15.4k| } ------------------ 1435| 0| } 1436| 712k| if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 1149| 712k|#define Lc F->temp_32[2] ------------------ if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 246| 712k|#define UCHAR21INCTEST(eptr) (*(eptr)++) ------------------ if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 686k| {\ | | 555| 686k| rrc = ra;\ | | 556| 686k| goto RETURN_SWITCH;\ | | 557| 686k| } ------------------ | Branch (1436:13): [True: 686k, False: 26.3k] ------------------ 1437| 26.3k| } 1438| | 1439| 451k| if (Lmin == Lmax) continue; ------------------ | | 1147| 451k|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 1148| 451k|#define Lmax F->temp_32[1] ------------------ | Branch (1439:11): [True: 335, False: 450k] ------------------ 1440| | 1441| 450k| if (reptype == REPTYPE_MIN) ------------------ | Branch (1441:11): [True: 29.2k, False: 421k] ------------------ 1442| 29.2k| { 1443| 29.2k| for (;;) 1444| 33.7k| { 1445| 33.7k| RMATCH(Fecode, RM27); ------------------ | | 546| 33.7k| {\ | | 547| 33.7k| start_ecode = ra;\ | | 548| 33.7k| Freturn_id = rb;\ | | ------------------ | | | | 188| 33.7k|#define Freturn_id F->return_id | | ------------------ | | 549| 33.7k| goto MATCH_RECURSE;\ | | 550| 33.7k| L_##rb:;\ | | 551| 30.6k| } ------------------ 1446| 30.6k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 30.6k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.68k| {\ | | 555| 1.68k| rrc = ra;\ | | 556| 1.68k| goto RETURN_SWITCH;\ | | 557| 1.68k| } ------------------ | Branch (1446:15): [True: 1.68k, False: 28.9k] ------------------ 1447| 28.9k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1147| 28.9k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1148| 28.9k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.53k| {\ | | 555| 1.53k| rrc = ra;\ | | 556| 1.53k| goto RETURN_SWITCH;\ | | 557| 1.53k| } ------------------ | Branch (1447:15): [True: 1.53k, False: 27.4k] ------------------ 1448| 27.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 27.4k|#define Feptr F->eptr ------------------ | Branch (1448:15): [True: 4.12k, False: 23.3k] ------------------ 1449| 4.12k| { 1450| 4.12k| SCHECK_PARTIAL(); ------------------ | | 533| 4.12k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.43k, False: 2.69k] | | ------------------ | | 534| 4.12k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.43k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 924, False: 513] | | | Branch (534:38): [True: 234, False: 279] | | ------------------ | | 535| 4.12k| { \ | | 536| 1.15k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.15k|#define TRUE 1 | | ------------------ | | 537| 1.15k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 1.15k] | | ------------------ | | 538| 1.15k| } ------------------ 1451| 4.12k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.12k| {\ | | 555| 4.12k| rrc = ra;\ | | 556| 4.12k| goto RETURN_SWITCH;\ | | 557| 4.12k| } ------------------ 1452| 0| } 1453| 23.3k| if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 1149| 23.3k|#define Lc F->temp_32[2] ------------------ if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 246| 23.3k|#define UCHAR21INCTEST(eptr) (*(eptr)++) ------------------ if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 18.8k| {\ | | 555| 18.8k| rrc = ra;\ | | 556| 18.8k| goto RETURN_SWITCH;\ | | 557| 18.8k| } ------------------ | Branch (1453:15): [True: 18.8k, False: 4.48k] ------------------ 1454| 4.48k| } 1455| | /* Control never gets here */ 1456| 29.2k| } 1457| 421k| else /* Maximize */ 1458| 421k| { 1459| 421k| Lstart_eptr = Feptr; ------------------ | | 1145| 421k|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; ------------------ | | 177| 421k|#define Feptr F->eptr ------------------ 1460| 479k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1147| 421k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1148| 479k|#define Lmax F->temp_32[1] ------------------ | Branch (1460:24): [True: 440k, False: 39.0k] ------------------ 1461| 440k| { 1462| 440k| if (Feptr >= mb->end_subject) ------------------ | | 177| 440k|#define Feptr F->eptr ------------------ | Branch (1462:15): [True: 42.1k, False: 398k] ------------------ 1463| 42.1k| { 1464| 42.1k| SCHECK_PARTIAL(); ------------------ | | 533| 42.1k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 18.7k, False: 23.3k] | | ------------------ | | 534| 42.1k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 18.7k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 11.8k, False: 6.90k] | | | Branch (534:38): [True: 2.28k, False: 4.62k] | | ------------------ | | 535| 42.1k| { \ | | 536| 14.1k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 14.1k|#define TRUE 1 | | ------------------ | | 537| 14.1k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 65|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 65, False: 14.1k] | | ------------------ | | 538| 14.1k| } ------------------ 1465| 42.0k| break; 1466| 42.1k| } 1467| | 1468| 398k| if (Lc != UCHAR21TEST(Feptr)) break; ------------------ | | 1149| 398k|#define Lc F->temp_32[2] ------------------ if (Lc != UCHAR21TEST(Feptr)) break; ------------------ | | 244| 398k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ | Branch (1468:15): [True: 340k, False: 58.2k] ------------------ 1469| 58.2k| Feptr++; ------------------ | | 177| 58.2k|#define Feptr F->eptr ------------------ 1470| 58.2k| } 1471| | 1472| 421k| if (reptype != REPTYPE_POS) for (;;) ------------------ | Branch (1472:13): [True: 128k, False: 293k] ------------------ 1473| 142k| { 1474| 142k| if (Feptr <= Lstart_eptr) break; ------------------ | | 177| 142k|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; ------------------ | | 1145| 142k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (1474:15): [True: 126k, False: 15.6k] ------------------ 1475| 15.6k| RMATCH(Fecode, RM28); ------------------ | | 546| 15.6k| {\ | | 547| 15.6k| start_ecode = ra;\ | | 548| 15.6k| Freturn_id = rb;\ | | ------------------ | | | | 188| 15.6k|#define Freturn_id F->return_id | | ------------------ | | 549| 15.6k| goto MATCH_RECURSE;\ | | 550| 15.6k| L_##rb:;\ | | 551| 14.7k| } ------------------ 1476| 14.7k| Feptr--; ------------------ | | 177| 14.7k|#define Feptr F->eptr ------------------ 1477| 14.7k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 14.7k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 263| {\ | | 555| 263| rrc = ra;\ | | 556| 263| goto RETURN_SWITCH;\ | | 557| 263| } ------------------ | Branch (1477:15): [True: 263, False: 14.4k] ------------------ 1478| 14.4k| } 1479| 421k| } 1480| 450k| } 1481| 779k| break; 1482| | 1483| 779k|#undef Loclength 1484| 779k|#undef Lstart_eptr 1485| 779k|#undef Lcharptr 1486| 779k|#undef Lmin 1487| 779k|#undef Lmax 1488| 779k|#undef Lc 1489| 779k|#undef Loc 1490| | 1491| | 1492| | /* ===================================================================== */ 1493| | /* Match a negated single one-byte character repeatedly. This is almost a 1494| | repeat of the code for a repeated single character, but I haven't found a 1495| | nice way of commoning these up that doesn't require a test of the 1496| | positive/negative option for each character match. Maybe that wouldn't add 1497| | very much to the time taken, but character matching *is* what this is all 1498| | about... */ 1499| | 1500| 779k|#define Lstart_eptr F->temp_sptr[0] 1501| 779k|#define Lmin F->temp_32[0] 1502| 779k|#define Lmax F->temp_32[1] 1503| 779k|#define Lc F->temp_32[2] 1504| 779k|#define Loc F->temp_32[3] 1505| | 1506| 779k| case OP_NOTEXACT: ------------------ | Branch (1506:5): [True: 5.06k, False: 2.33G] ------------------ 1507| 9.48k| case OP_NOTEXACTI: ------------------ | Branch (1507:5): [True: 4.41k, False: 2.33G] ------------------ 1508| 9.48k| Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 1501| 9.48k|#define Lmin F->temp_32[0] ------------------ Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 1502| 9.48k|#define Lmax F->temp_32[1] ------------------ Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 194| 9.48k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1509| 9.48k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 9.48k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 9.48k|#define IMM2_SIZE 2 ------------------ 1510| 9.48k| goto REPEATNOTCHAR; 1511| | 1512| 1.42k| case OP_NOTUPTO: ------------------ | Branch (1512:5): [True: 1.42k, False: 2.33G] ------------------ 1513| 3.08k| case OP_NOTUPTOI: ------------------ | Branch (1513:5): [True: 1.66k, False: 2.33G] ------------------ 1514| 3.08k| Lmin = 0; ------------------ | | 1501| 3.08k|#define Lmin F->temp_32[0] ------------------ 1515| 3.08k| Lmax = GET2(Fecode, 1); ------------------ | | 1502| 3.08k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 3.08k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1516| 3.08k| reptype = REPTYPE_MAX; 1517| 3.08k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 3.08k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 3.08k|#define IMM2_SIZE 2 ------------------ 1518| 3.08k| goto REPEATNOTCHAR; 1519| | 1520| 410| case OP_NOTMINUPTO: ------------------ | Branch (1520:5): [True: 410, False: 2.33G] ------------------ 1521| 813| case OP_NOTMINUPTOI: ------------------ | Branch (1521:5): [True: 403, False: 2.33G] ------------------ 1522| 813| Lmin = 0; ------------------ | | 1501| 813|#define Lmin F->temp_32[0] ------------------ 1523| 813| Lmax = GET2(Fecode, 1); ------------------ | | 1502| 813|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 813|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1524| 813| reptype = REPTYPE_MIN; 1525| 813| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 813|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 813|#define IMM2_SIZE 2 ------------------ 1526| 813| goto REPEATNOTCHAR; 1527| | 1528| 13.9k| case OP_NOTPOSSTAR: ------------------ | Branch (1528:5): [True: 13.9k, False: 2.33G] ------------------ 1529| 30.2k| case OP_NOTPOSSTARI: ------------------ | Branch (1529:5): [True: 16.2k, False: 2.33G] ------------------ 1530| 30.2k| reptype = REPTYPE_POS; 1531| 30.2k| Lmin = 0; ------------------ | | 1501| 30.2k|#define Lmin F->temp_32[0] ------------------ 1532| 30.2k| Lmax = UINT32_MAX; ------------------ | | 1502| 30.2k|#define Lmax F->temp_32[1] ------------------ 1533| 30.2k| Fecode++; ------------------ | | 176| 30.2k|#define Fecode F->ecode ------------------ 1534| 30.2k| goto REPEATNOTCHAR; 1535| | 1536| 10.1k| case OP_NOTPOSPLUS: ------------------ | Branch (1536:5): [True: 10.1k, False: 2.33G] ------------------ 1537| 12.7k| case OP_NOTPOSPLUSI: ------------------ | Branch (1537:5): [True: 2.62k, False: 2.33G] ------------------ 1538| 12.7k| reptype = REPTYPE_POS; 1539| 12.7k| Lmin = 1; ------------------ | | 1501| 12.7k|#define Lmin F->temp_32[0] ------------------ 1540| 12.7k| Lmax = UINT32_MAX; ------------------ | | 1502| 12.7k|#define Lmax F->temp_32[1] ------------------ 1541| 12.7k| Fecode++; ------------------ | | 176| 12.7k|#define Fecode F->ecode ------------------ 1542| 12.7k| goto REPEATNOTCHAR; 1543| | 1544| 1.12k| case OP_NOTPOSQUERY: ------------------ | Branch (1544:5): [True: 1.12k, False: 2.33G] ------------------ 1545| 1.69k| case OP_NOTPOSQUERYI: ------------------ | Branch (1545:5): [True: 573, False: 2.33G] ------------------ 1546| 1.69k| reptype = REPTYPE_POS; 1547| 1.69k| Lmin = 0; ------------------ | | 1501| 1.69k|#define Lmin F->temp_32[0] ------------------ 1548| 1.69k| Lmax = 1; ------------------ | | 1502| 1.69k|#define Lmax F->temp_32[1] ------------------ 1549| 1.69k| Fecode++; ------------------ | | 176| 1.69k|#define Fecode F->ecode ------------------ 1550| 1.69k| goto REPEATNOTCHAR; 1551| | 1552| 2.19k| case OP_NOTPOSUPTO: ------------------ | Branch (1552:5): [True: 2.19k, False: 2.33G] ------------------ 1553| 5.23k| case OP_NOTPOSUPTOI: ------------------ | Branch (1553:5): [True: 3.04k, False: 2.33G] ------------------ 1554| 5.23k| reptype = REPTYPE_POS; 1555| 5.23k| Lmin = 0; ------------------ | | 1501| 5.23k|#define Lmin F->temp_32[0] ------------------ 1556| 5.23k| Lmax = GET2(Fecode, 1); ------------------ | | 1502| 5.23k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 5.23k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1557| 5.23k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 5.23k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 5.23k|#define IMM2_SIZE 2 ------------------ 1558| 5.23k| goto REPEATNOTCHAR; 1559| | 1560| 7.88k| case OP_NOTSTAR: ------------------ | Branch (1560:5): [True: 7.88k, False: 2.33G] ------------------ 1561| 11.1k| case OP_NOTSTARI: ------------------ | Branch (1561:5): [True: 3.21k, False: 2.33G] ------------------ 1562| 16.5k| case OP_NOTMINSTAR: ------------------ | Branch (1562:5): [True: 5.48k, False: 2.33G] ------------------ 1563| 22.9k| case OP_NOTMINSTARI: ------------------ | Branch (1563:5): [True: 6.32k, False: 2.33G] ------------------ 1564| 34.1k| case OP_NOTPLUS: ------------------ | Branch (1564:5): [True: 11.2k, False: 2.33G] ------------------ 1565| 40.5k| case OP_NOTPLUSI: ------------------ | Branch (1565:5): [True: 6.42k, False: 2.33G] ------------------ 1566| 46.8k| case OP_NOTMINPLUS: ------------------ | Branch (1566:5): [True: 6.27k, False: 2.33G] ------------------ 1567| 52.1k| case OP_NOTMINPLUSI: ------------------ | Branch (1567:5): [True: 5.29k, False: 2.33G] ------------------ 1568| 88.5k| case OP_NOTQUERY: ------------------ | Branch (1568:5): [True: 36.4k, False: 2.33G] ------------------ 1569| 90.6k| case OP_NOTQUERYI: ------------------ | Branch (1569:5): [True: 2.03k, False: 2.33G] ------------------ 1570| 93.7k| case OP_NOTMINQUERY: ------------------ | Branch (1570:5): [True: 3.15k, False: 2.33G] ------------------ 1571| 95.3k| case OP_NOTMINQUERYI: ------------------ | Branch (1571:5): [True: 1.60k, False: 2.33G] ------------------ 1572| 95.3k| fc = *Fecode++ - ((Fop >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR); ------------------ | | 176| 95.3k|#define Fecode F->ecode ------------------ fc = *Fecode++ - ((Fop >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR); ------------------ | | 186| 95.3k|#define Fop F->op ------------------ | Branch (1572:23): [True: 24.8k, False: 70.4k] ------------------ 1573| 95.3k| Lmin = rep_min[fc]; ------------------ | | 1501| 95.3k|#define Lmin F->temp_32[0] ------------------ 1574| 95.3k| Lmax = rep_max[fc]; ------------------ | | 1502| 95.3k|#define Lmax F->temp_32[1] ------------------ 1575| 95.3k| reptype = rep_typ[fc]; 1576| | 1577| | /* Common code for all repeated single-character non-matches. */ 1578| | 1579| 158k| REPEATNOTCHAR: 1580| 158k| GETCHARINCTEST(Lc, Fecode); ------------------ | | 323| 158k| c = *eptr++; \ | | 324| 158k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 3.88k| { \ | | | | 289| 3.88k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 2.05k, False: 1.82k] | | | | ------------------ | | | | 290| 3.88k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 3.88k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 943, False: 885] | | | | ------------------ | | | | 292| 1.82k| { \ | | | | 293| 943| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 943| eptr += 2; \ | | | | 295| 943| } \ | | | | 296| 1.82k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 885, False: 0] | | | | ------------------ | | | | 297| 885| { \ | | | | 298| 885| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 885| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 885| eptr += 3; \ | | | | 301| 885| } \ | | | | 302| 885| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 3.88k| } | | ------------------ | | | Branch (324:7): [True: 70.5k, False: 88.0k] | | | Branch (324:14): [True: 3.88k, False: 66.7k] | | ------------------ ------------------ 1581| | 1582| | /* The code is duplicated for the caseless and caseful cases, for speed, 1583| | since matching characters is likely to be quite common. First, ensure the 1584| | minimum number of matches are present. If Lmin = Lmax, we are done. 1585| | Otherwise, if minimizing, keep trying the rest of the expression and 1586| | advancing one matching character if failing, up to the maximum. 1587| | Alternatively, if maximizing, find the maximum number of characters and 1588| | work backwards. */ 1589| | 1590| 158k| if (Fop >= OP_NOTSTARI) /* Caseless */ ------------------ | | 186| 158k|#define Fop F->op ------------------ | Branch (1590:9): [True: 53.9k, False: 104k] ------------------ 1591| 53.9k| { 1592| 53.9k|#ifdef SUPPORT_UNICODE 1593| 53.9k| if ((utf || ucp) && Lc > 127) ------------------ | | 1503| 41.8k|#define Lc F->temp_32[2] ------------------ | Branch (1593:12): [True: 37.0k, False: 16.8k] | Branch (1593:19): [True: 4.79k, False: 12.0k] | Branch (1593:27): [True: 3.86k, False: 37.9k] ------------------ 1594| 3.86k| Loc = UCD_OTHERCASE(Lc); ------------------ | | 1504| 3.86k|#define Loc F->temp_32[3] ------------------ Loc = UCD_OTHERCASE(Lc); ------------------ | | 1862| 3.86k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 3.86k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 3.86k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 3.86k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 3.86k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 3.86k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 3.86k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 3.86k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 3.86k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 3.86k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 3.86k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1595| 50.0k| else 1596| 50.0k|#endif /* SUPPORT_UNICODE */ 1597| | 1598| 50.0k| Loc = TABLE_GET(Lc, mb->fcc, Lc); /* Other case from table */ ------------------ | | 1504| 50.0k|#define Loc F->temp_32[3] ------------------ Loc = TABLE_GET(Lc, mb->fcc, Lc); /* Other case from table */ ------------------ | | 214| 50.0k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 1599| | 1600| 53.9k|#ifdef SUPPORT_UNICODE 1601| 53.9k| if (utf) ------------------ | Branch (1601:11): [True: 37.0k, False: 16.8k] ------------------ 1602| 37.0k| { 1603| 37.0k| uint32_t d; 1604| 46.0k| for (i = 1; i <= Lmin; i++) ------------------ | | 1501| 46.0k|#define Lmin F->temp_32[0] ------------------ | Branch (1604:21): [True: 13.9k, False: 32.1k] ------------------ 1605| 13.9k| { 1606| 13.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 13.9k|#define Feptr F->eptr ------------------ | Branch (1606:15): [True: 3.09k, False: 10.8k] ------------------ 1607| 3.09k| { 1608| 3.09k| SCHECK_PARTIAL(); ------------------ | | 533| 3.09k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.06k, False: 2.02k] | | ------------------ | | 534| 3.09k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.06k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 572, False: 495] | | | Branch (534:38): [True: 240, False: 255] | | ------------------ | | 535| 3.09k| { \ | | 536| 812| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 812|#define TRUE 1 | | ------------------ | | 537| 812| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 23|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 23, False: 789] | | ------------------ | | 538| 812| } ------------------ 1609| 3.06k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.06k| {\ | | 555| 3.06k| rrc = ra;\ | | 556| 3.06k| goto RETURN_SWITCH;\ | | 557| 3.06k| } ------------------ 1610| 0| } 1611| 10.8k| GETCHARINC(d, Feptr); ------------------ | | 316| 10.8k| c = *eptr++; \ | | 317| 10.8k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.06k| { \ | | | | 289| 1.06k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 488, False: 573] | | | | ------------------ | | | | 290| 1.06k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.06k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 315, False: 258] | | | | ------------------ | | | | 292| 573| { \ | | | | 293| 315| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 315| eptr += 2; \ | | | | 295| 315| } \ | | | | 296| 573| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 258, False: 0] | | | | ------------------ | | | | 297| 258| { \ | | | | 298| 258| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 258| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 258| eptr += 3; \ | | | | 301| 258| } \ | | | | 302| 258| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.06k| } | | ------------------ | | | Branch (317:7): [True: 1.06k, False: 9.78k] | | ------------------ ------------------ 1612| 10.8k| if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 10.8k|#define Lc F->temp_32[2] ------------------ if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 1504| 9.23k|#define Loc F->temp_32[3] ------------------ if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.83k| {\ | | 555| 1.83k| rrc = ra;\ | | 556| 1.83k| goto RETURN_SWITCH;\ | | 557| 1.83k| } ------------------ | Branch (1612:15): [True: 1.61k, False: 9.23k] | Branch (1612:26): [True: 227, False: 9.00k] ------------------ 1613| 9.00k| } 1614| 37.0k| } 1615| 16.8k| else 1616| 16.8k|#endif /* SUPPORT_UNICODE */ 1617| | 1618| | /* Not UTF mode */ 1619| 16.8k| { 1620| 26.2k| for (i = 1; i <= Lmin; i++) ------------------ | | 1501| 26.2k|#define Lmin F->temp_32[0] ------------------ | Branch (1620:21): [True: 14.1k, False: 12.0k] ------------------ 1621| 14.1k| { 1622| 14.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 14.1k|#define Feptr F->eptr ------------------ | Branch (1622:15): [True: 3.27k, False: 10.8k] ------------------ 1623| 3.27k| { 1624| 3.27k| SCHECK_PARTIAL(); ------------------ | | 533| 3.27k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.12k, False: 2.15k] | | ------------------ | | 534| 3.27k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.12k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 624, False: 502] | | | Branch (534:38): [True: 240, False: 262] | | ------------------ | | 535| 3.27k| { \ | | 536| 864| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 864|#define TRUE 1 | | ------------------ | | 537| 864| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 13|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 13, False: 851] | | ------------------ | | 538| 864| } ------------------ 1625| 3.26k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.26k| {\ | | 555| 3.26k| rrc = ra;\ | | 556| 3.26k| goto RETURN_SWITCH;\ | | 557| 3.26k| } ------------------ 1626| 0| } 1627| 10.8k| if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 10.8k|#define Lc F->temp_32[2] ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 21.7k|#define Feptr F->eptr ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 1504| 9.61k|#define Loc F->temp_32[3] ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 9.61k|#define Feptr F->eptr ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.51k| {\ | | 555| 1.51k| rrc = ra;\ | | 556| 1.51k| goto RETURN_SWITCH;\ | | 557| 1.51k| } ------------------ | Branch (1627:15): [True: 1.28k, False: 9.61k] | Branch (1627:31): [True: 229, False: 9.38k] ------------------ 1628| 9.38k| Feptr++; ------------------ | | 177| 9.38k|#define Feptr F->eptr ------------------ 1629| 9.38k| } 1630| 16.8k| } 1631| | 1632| 44.2k| if (Lmin == Lmax) continue; /* Finished for exact count */ ------------------ | | 1501| 44.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; /* Finished for exact count */ ------------------ | | 1502| 44.2k|#define Lmax F->temp_32[1] ------------------ | Branch (1632:11): [True: 807, False: 43.3k] ------------------ 1633| | 1634| 43.3k| if (reptype == REPTYPE_MIN) ------------------ | Branch (1634:11): [True: 11.6k, False: 31.7k] ------------------ 1635| 11.6k| { 1636| 11.6k|#ifdef SUPPORT_UNICODE 1637| 11.6k| if (utf) ------------------ | Branch (1637:13): [True: 7.40k, False: 4.23k] ------------------ 1638| 7.40k| { 1639| 7.40k| uint32_t d; 1640| 7.40k| for (;;) 1641| 14.7k| { 1642| 14.7k| RMATCH(Fecode, RM204); ------------------ | | 546| 14.7k| {\ | | 547| 14.7k| start_ecode = ra;\ | | 548| 14.7k| Freturn_id = rb;\ | | ------------------ | | | | 188| 14.7k|#define Freturn_id F->return_id | | ------------------ | | 549| 14.7k| goto MATCH_RECURSE;\ | | 550| 14.7k| L_##rb:;\ | | 551| 14.5k| } ------------------ 1643| 14.5k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 14.5k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 243| {\ | | 555| 243| rrc = ra;\ | | 556| 243| goto RETURN_SWITCH;\ | | 557| 243| } ------------------ | Branch (1643:17): [True: 243, False: 14.2k] ------------------ 1644| 14.2k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1501| 14.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1502| 14.2k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 555| {\ | | 555| 555| rrc = ra;\ | | 556| 555| goto RETURN_SWITCH;\ | | 557| 555| } ------------------ | Branch (1644:17): [True: 555, False: 13.7k] ------------------ 1645| 13.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 13.7k|#define Feptr F->eptr ------------------ | Branch (1645:17): [True: 4.82k, False: 8.90k] ------------------ 1646| 4.82k| { 1647| 4.82k| SCHECK_PARTIAL(); ------------------ | | 533| 4.82k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.87k, False: 2.94k] | | ------------------ | | 534| 4.82k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.87k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 334, False: 1.54k] | | | Branch (534:38): [True: 1.31k, False: 235] | | ------------------ | | 535| 4.82k| { \ | | 536| 1.64k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.64k|#define TRUE 1 | | ------------------ | | 537| 1.64k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 1.63k] | | ------------------ | | 538| 1.64k| } ------------------ 1648| 4.81k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.81k| {\ | | 555| 4.81k| rrc = ra;\ | | 556| 4.81k| goto RETURN_SWITCH;\ | | 557| 4.81k| } ------------------ 1649| 0| } 1650| 8.90k| GETCHARINC(d, Feptr); ------------------ | | 316| 8.90k| c = *eptr++; \ | | 317| 8.90k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 852| { \ | | | | 289| 852| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 314, False: 538] | | | | ------------------ | | | | 290| 852| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 852| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 288, False: 250] | | | | ------------------ | | | | 292| 538| { \ | | | | 293| 288| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 288| eptr += 2; \ | | | | 295| 288| } \ | | | | 296| 538| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 250, False: 0] | | | | ------------------ | | | | 297| 250| { \ | | | | 298| 250| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 250| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 250| eptr += 3; \ | | | | 301| 250| } \ | | | | 302| 250| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 852| } | | ------------------ | | | Branch (317:7): [True: 852, False: 8.05k] | | ------------------ ------------------ 1651| 8.90k| if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 8.90k|#define Lc F->temp_32[2] ------------------ if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 1504| 7.56k|#define Loc F->temp_32[3] ------------------ if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.55k| {\ | | 555| 1.55k| rrc = ra;\ | | 556| 1.55k| goto RETURN_SWITCH;\ | | 557| 1.55k| } ------------------ | Branch (1651:17): [True: 1.34k, False: 7.56k] | Branch (1651:28): [True: 211, False: 7.35k] ------------------ 1652| 7.35k| } 1653| 7.40k| } 1654| 4.23k| else 1655| 4.23k|#endif /*SUPPORT_UNICODE */ 1656| | 1657| | /* Not UTF mode */ 1658| 4.23k| { 1659| 4.23k| for (;;) 1660| 8.78k| { 1661| 8.78k| RMATCH(Fecode, RM29); ------------------ | | 546| 8.78k| {\ | | 547| 8.78k| start_ecode = ra;\ | | 548| 8.78k| Freturn_id = rb;\ | | ------------------ | | | | 188| 8.78k|#define Freturn_id F->return_id | | ------------------ | | 549| 8.78k| goto MATCH_RECURSE;\ | | 550| 8.78k| L_##rb:;\ | | 551| 8.73k| } ------------------ 1662| 8.73k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 8.73k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 341| {\ | | 555| 341| rrc = ra;\ | | 556| 341| goto RETURN_SWITCH;\ | | 557| 341| } ------------------ | Branch (1662:17): [True: 341, False: 8.39k] ------------------ 1663| 8.39k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1501| 8.39k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1502| 8.39k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 652| {\ | | 555| 652| rrc = ra;\ | | 556| 652| goto RETURN_SWITCH;\ | | 557| 652| } ------------------ | Branch (1663:17): [True: 652, False: 7.74k] ------------------ 1664| 7.74k| if (Feptr >= mb->end_subject) ------------------ | | 177| 7.74k|#define Feptr F->eptr ------------------ | Branch (1664:17): [True: 2.01k, False: 5.72k] ------------------ 1665| 2.01k| { 1666| 2.01k| SCHECK_PARTIAL(); ------------------ | | 533| 2.01k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 721, False: 1.29k] | | ------------------ | | 534| 2.01k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 721|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 258, False: 463] | | | Branch (534:38): [True: 234, False: 229] | | ------------------ | | 535| 2.01k| { \ | | 536| 492| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 492|#define TRUE 1 | | ------------------ | | 537| 492| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 5, False: 487] | | ------------------ | | 538| 492| } ------------------ 1667| 2.00k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.00k| {\ | | 555| 2.00k| rrc = ra;\ | | 556| 2.00k| goto RETURN_SWITCH;\ | | 557| 2.00k| } ------------------ 1668| 0| } 1669| 5.72k| if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 5.72k|#define Lc F->temp_32[2] ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 11.4k|#define Feptr F->eptr ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 1504| 4.96k|#define Loc F->temp_32[3] ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 4.96k|#define Feptr F->eptr ------------------ if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.17k| {\ | | 555| 1.17k| rrc = ra;\ | | 556| 1.17k| goto RETURN_SWITCH;\ | | 557| 1.17k| } ------------------ | Branch (1669:17): [True: 767, False: 4.96k] | Branch (1669:33): [True: 410, False: 4.55k] ------------------ 1670| 4.55k| Feptr++; ------------------ | | 177| 4.55k|#define Feptr F->eptr ------------------ 1671| 4.55k| } 1672| 4.23k| } 1673| | /* Control never gets here */ 1674| 11.6k| } 1675| | 1676| | /* Maximize case */ 1677| | 1678| 31.7k| else 1679| 31.7k| { 1680| 31.7k| Lstart_eptr = Feptr; ------------------ | | 1500| 31.7k|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; ------------------ | | 177| 31.7k|#define Feptr F->eptr ------------------ 1681| | 1682| 31.7k|#ifdef SUPPORT_UNICODE 1683| 31.7k| if (utf) ------------------ | Branch (1683:13): [True: 24.4k, False: 7.31k] ------------------ 1684| 24.4k| { 1685| 24.4k| uint32_t d; 1686| 147k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1501| 24.4k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1502| 147k|#define Lmax F->temp_32[1] ------------------ | Branch (1686:26): [True: 146k, False: 1.24k] ------------------ 1687| 146k| { 1688| 146k| int len = 1; 1689| 146k| if (Feptr >= mb->end_subject) ------------------ | | 177| 146k|#define Feptr F->eptr ------------------ | Branch (1689:17): [True: 8.86k, False: 137k] ------------------ 1690| 8.86k| { 1691| 8.86k| SCHECK_PARTIAL(); ------------------ | | 533| 8.86k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 3.42k, False: 5.44k] | | ------------------ | | 534| 8.86k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 3.42k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 2.93k, False: 490] | | | Branch (534:38): [True: 239, False: 251] | | ------------------ | | 535| 8.86k| { \ | | 536| 3.17k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 3.17k|#define TRUE 1 | | ------------------ | | 537| 3.17k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 25|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 25, False: 3.14k] | | ------------------ | | 538| 3.17k| } ------------------ 1692| 8.84k| break; 1693| 8.86k| } 1694| 137k| GETCHARLEN(d, Feptr, len); ------------------ | | 330| 137k| c = *eptr; \ | | 331| 137k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 9.85k| { \ | | | | 323| 9.85k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 8.86k, False: 991] | | | | ------------------ | | | | 324| 9.85k| { \ | | | | 325| 8.86k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 8.86k| len++; \ | | | | 327| 8.86k| } \ | | | | 328| 9.85k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 705, False: 286] | | | | ------------------ | | | | 329| 991| { \ | | | | 330| 705| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 705| len += 2; \ | | | | 332| 705| } \ | | | | 333| 991| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 286, False: 0] | | | | ------------------ | | | | 334| 286| {\ | | | | 335| 286| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 286| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 286| len += 3; \ | | | | 338| 286| } \ | | | | 339| 286| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 9.85k| } | | ------------------ | | | Branch (331:7): [True: 9.85k, False: 127k] | | ------------------ ------------------ 1695| 137k| if (Lc == d || Loc == d) break; ------------------ | | 1503| 137k|#define Lc F->temp_32[2] ------------------ if (Lc == d || Loc == d) break; ------------------ | | 1504| 123k|#define Loc F->temp_32[3] ------------------ | Branch (1695:17): [True: 13.9k, False: 123k] | Branch (1695:28): [True: 396, False: 122k] ------------------ 1696| 122k| Feptr += len; ------------------ | | 177| 122k|#define Feptr F->eptr ------------------ 1697| 122k| } 1698| | 1699| | /* After \C in UTF mode, Lstart_eptr might be in the middle of a 1700| | Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't 1701| | go too far. */ 1702| | 1703| 24.4k| if (reptype != REPTYPE_POS) for(;;) ------------------ | Branch (1703:15): [True: 6.53k, False: 17.8k] ------------------ 1704| 14.0k| { 1705| 14.0k| if (Feptr <= Lstart_eptr) break; ------------------ | | 177| 14.0k|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; ------------------ | | 1500| 14.0k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (1705:17): [True: 6.21k, False: 7.85k] ------------------ 1706| 7.85k| RMATCH(Fecode, RM205); ------------------ | | 546| 7.85k| {\ | | 547| 7.85k| start_ecode = ra;\ | | 548| 7.85k| Freturn_id = rb;\ | | ------------------ | | | | 188| 7.85k|#define Freturn_id F->return_id | | ------------------ | | 549| 7.85k| goto MATCH_RECURSE;\ | | 550| 7.85k| L_##rb:;\ | | 551| 7.78k| } ------------------ 1707| 7.78k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 7.78k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 253| {\ | | 555| 253| rrc = ra;\ | | 556| 253| goto RETURN_SWITCH;\ | | 557| 253| } ------------------ | Branch (1707:17): [True: 253, False: 7.53k] ------------------ 1708| 7.53k| Feptr--; ------------------ | | 177| 7.53k|#define Feptr F->eptr ------------------ 1709| 7.53k| BACKCHAR(Feptr); ------------------ | | 345| 9.66k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 2.12k, False: 7.53k] | | ------------------ ------------------ 1710| 7.53k| } 1711| 24.4k| } 1712| 7.31k| else 1713| 7.31k|#endif /* SUPPORT_UNICODE */ 1714| | 1715| | /* Not UTF mode */ 1716| 7.31k| { 1717| 16.1k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1501| 7.31k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1502| 16.1k|#define Lmax F->temp_32[1] ------------------ | Branch (1717:26): [True: 13.1k, False: 2.99k] ------------------ 1718| 13.1k| { 1719| 13.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 13.1k|#define Feptr F->eptr ------------------ | Branch (1719:17): [True: 2.20k, False: 10.9k] ------------------ 1720| 2.20k| { 1721| 2.20k| SCHECK_PARTIAL(); ------------------ | | 533| 2.20k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 806, False: 1.39k] | | ------------------ | | 534| 2.20k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 806|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 296, False: 510] | | | Branch (534:38): [True: 253, False: 257] | | ------------------ | | 535| 2.20k| { \ | | 536| 549| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 549|#define TRUE 1 | | ------------------ | | 537| 549| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 13|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 13, False: 536] | | ------------------ | | 538| 549| } ------------------ 1722| 2.18k| break; 1723| 2.20k| } 1724| 10.9k| if (Lc == *Feptr || Loc == *Feptr) break; ------------------ | | 1503| 10.9k|#define Lc F->temp_32[2] ------------------ if (Lc == *Feptr || Loc == *Feptr) break; ------------------ | | 177| 21.8k|#define Feptr F->eptr ------------------ if (Lc == *Feptr || Loc == *Feptr) break; ------------------ | | 1504| 9.01k|#define Loc F->temp_32[3] ------------------ if (Lc == *Feptr || Loc == *Feptr) break; ------------------ | | 177| 9.01k|#define Feptr F->eptr ------------------ | Branch (1724:17): [True: 1.89k, False: 9.01k] | Branch (1724:33): [True: 218, False: 8.79k] ------------------ 1725| 8.79k| Feptr++; ------------------ | | 177| 8.79k|#define Feptr F->eptr ------------------ 1726| 8.79k| } 1727| 7.30k| if (reptype != REPTYPE_POS) for (;;) ------------------ | Branch (1727:15): [True: 3.56k, False: 3.74k] ------------------ 1728| 7.62k| { 1729| 7.62k| if (Feptr == Lstart_eptr) break; ------------------ | | 177| 7.62k|#define Feptr F->eptr ------------------ if (Feptr == Lstart_eptr) break; ------------------ | | 1500| 7.62k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (1729:17): [True: 3.20k, False: 4.42k] ------------------ 1730| 4.42k| RMATCH(Fecode, RM30); ------------------ | | 546| 4.42k| {\ | | 547| 4.42k| start_ecode = ra;\ | | 548| 4.42k| Freturn_id = rb;\ | | ------------------ | | | | 188| 4.42k|#define Freturn_id F->return_id | | ------------------ | | 549| 4.42k| goto MATCH_RECURSE;\ | | 550| 4.42k| L_##rb:;\ | | 551| 4.31k| } ------------------ 1731| 4.31k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 4.31k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 244| {\ | | 555| 244| rrc = ra;\ | | 556| 244| goto RETURN_SWITCH;\ | | 557| 244| } ------------------ | Branch (1731:17): [True: 244, False: 4.06k] ------------------ 1732| 4.06k| Feptr--; ------------------ | | 177| 4.06k|#define Feptr F->eptr ------------------ 1733| 4.06k| } 1734| 7.30k| } 1735| 31.7k| } 1736| 43.3k| } 1737| | 1738| | /* Caseful comparisons */ 1739| | 1740| 104k| else 1741| 104k| { 1742| 104k|#ifdef SUPPORT_UNICODE 1743| 104k| if (utf) ------------------ | Branch (1743:11): [True: 33.5k, False: 71.2k] ------------------ 1744| 33.5k| { 1745| 33.5k| uint32_t d; 1746| 41.2k| for (i = 1; i <= Lmin; i++) ------------------ | | 1501| 41.2k|#define Lmin F->temp_32[0] ------------------ | Branch (1746:21): [True: 11.7k, False: 29.4k] ------------------ 1747| 11.7k| { 1748| 11.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 11.7k|#define Feptr F->eptr ------------------ | Branch (1748:15): [True: 2.60k, False: 9.14k] ------------------ 1749| 2.60k| { 1750| 2.60k| SCHECK_PARTIAL(); ------------------ | | 533| 2.60k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 762, False: 1.84k] | | ------------------ | | 534| 2.60k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 762|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 266, False: 496] | | | Branch (534:38): [True: 241, False: 255] | | ------------------ | | 535| 2.60k| { \ | | 536| 507| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 507|#define TRUE 1 | | ------------------ | | 537| 507| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 4, False: 503] | | ------------------ | | 538| 507| } ------------------ 1751| 2.59k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.59k| {\ | | 555| 2.59k| rrc = ra;\ | | 556| 2.59k| goto RETURN_SWITCH;\ | | 557| 2.59k| } ------------------ 1752| 0| } 1753| 9.14k| GETCHARINC(d, Feptr); ------------------ | | 316| 9.14k| c = *eptr++; \ | | 317| 9.14k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 912| { \ | | | | 289| 912| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 290, False: 622] | | | | ------------------ | | | | 290| 912| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 912| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 270, False: 352] | | | | ------------------ | | | | 292| 622| { \ | | | | 293| 270| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 270| eptr += 2; \ | | | | 295| 270| } \ | | | | 296| 622| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 352, False: 0] | | | | ------------------ | | | | 297| 352| { \ | | | | 298| 352| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 352| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 352| eptr += 3; \ | | | | 301| 352| } \ | | | | 302| 352| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 912| } | | ------------------ | | | Branch (317:7): [True: 912, False: 8.23k] | | ------------------ ------------------ 1754| 9.14k| if (Lc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 9.14k|#define Lc F->temp_32[2] ------------------ if (Lc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.45k| {\ | | 555| 1.45k| rrc = ra;\ | | 556| 1.45k| goto RETURN_SWITCH;\ | | 557| 1.45k| } ------------------ | Branch (1754:15): [True: 1.45k, False: 7.68k] ------------------ 1755| 7.68k| } 1756| 33.5k| } 1757| 71.2k| else 1758| 71.2k|#endif 1759| | /* Not UTF mode */ 1760| 71.2k| { 1761| 91.9k| for (i = 1; i <= Lmin; i++) ------------------ | | 1501| 91.9k|#define Lmin F->temp_32[0] ------------------ | Branch (1761:21): [True: 30.4k, False: 61.5k] ------------------ 1762| 30.4k| { 1763| 30.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 30.4k|#define Feptr F->eptr ------------------ | Branch (1763:15): [True: 6.57k, False: 23.8k] ------------------ 1764| 6.57k| { 1765| 6.57k| SCHECK_PARTIAL(); ------------------ | | 533| 6.57k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.63k, False: 3.93k] | | ------------------ | | 534| 6.57k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.63k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.13k, False: 1.50k] | | | Branch (534:38): [True: 736, False: 765] | | ------------------ | | 535| 6.57k| { \ | | 536| 1.86k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.86k|#define TRUE 1 | | ------------------ | | 537| 1.86k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 59|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 59, False: 1.81k] | | ------------------ | | 538| 1.86k| } ------------------ 1766| 6.51k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.51k| {\ | | 555| 6.51k| rrc = ra;\ | | 556| 6.51k| goto RETURN_SWITCH;\ | | 557| 6.51k| } ------------------ 1767| 0| } 1768| 23.8k| if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 23.8k|#define Lc F->temp_32[2] ------------------ if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 23.8k|#define Feptr F->eptr ------------------ if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.14k| {\ | | 555| 3.14k| rrc = ra;\ | | 556| 3.14k| goto RETURN_SWITCH;\ | | 557| 3.14k| } ------------------ | Branch (1768:15): [True: 3.14k, False: 20.6k] ------------------ 1769| 20.6k| } 1770| 71.2k| } 1771| | 1772| 90.9k| if (Lmin == Lmax) continue; ------------------ | | 1501| 90.9k|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 1502| 90.9k|#define Lmax F->temp_32[1] ------------------ | Branch (1772:11): [True: 1.56k, False: 89.4k] ------------------ 1773| | 1774| 89.4k| if (reptype == REPTYPE_MIN) ------------------ | Branch (1774:11): [True: 13.5k, False: 75.8k] ------------------ 1775| 13.5k| { 1776| 13.5k|#ifdef SUPPORT_UNICODE 1777| 13.5k| if (utf) ------------------ | Branch (1777:13): [True: 6.97k, False: 6.54k] ------------------ 1778| 6.97k| { 1779| 6.97k| uint32_t d; 1780| 6.97k| for (;;) 1781| 18.8k| { 1782| 18.8k| RMATCH(Fecode, RM206); ------------------ | | 546| 18.8k| {\ | | 547| 18.8k| start_ecode = ra;\ | | 548| 18.8k| Freturn_id = rb;\ | | ------------------ | | | | 188| 18.8k|#define Freturn_id F->return_id | | ------------------ | | 549| 18.8k| goto MATCH_RECURSE;\ | | 550| 18.8k| L_##rb:;\ | | 551| 18.3k| } ------------------ 1783| 18.3k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 18.3k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.01k| {\ | | 555| 1.01k| rrc = ra;\ | | 556| 1.01k| goto RETURN_SWITCH;\ | | 557| 1.01k| } ------------------ | Branch (1783:17): [True: 1.01k, False: 17.3k] ------------------ 1784| 17.3k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1501| 17.3k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1502| 17.3k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 863| {\ | | 555| 863| rrc = ra;\ | | 556| 863| goto RETURN_SWITCH;\ | | 557| 863| } ------------------ | Branch (1784:17): [True: 863, False: 16.5k] ------------------ 1785| 16.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 16.5k|#define Feptr F->eptr ------------------ | Branch (1785:17): [True: 2.89k, False: 13.6k] ------------------ 1786| 2.89k| { 1787| 2.89k| SCHECK_PARTIAL(); ------------------ | | 533| 2.89k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 846, False: 2.04k] | | ------------------ | | 534| 2.89k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 846|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 399, False: 447] | | | Branch (534:38): [True: 225, False: 222] | | ------------------ | | 535| 2.89k| { \ | | 536| 624| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 624|#define TRUE 1 | | ------------------ | | 537| 624| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 4, False: 620] | | ------------------ | | 538| 624| } ------------------ 1788| 2.88k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.88k| {\ | | 555| 2.88k| rrc = ra;\ | | 556| 2.88k| goto RETURN_SWITCH;\ | | 557| 2.88k| } ------------------ 1789| 0| } 1790| 13.6k| GETCHARINC(d, Feptr); ------------------ | | 316| 13.6k| c = *eptr++; \ | | 317| 13.6k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 917| { \ | | | | 289| 917| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 404, False: 513] | | | | ------------------ | | | | 290| 917| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 917| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 223, False: 290] | | | | ------------------ | | | | 292| 513| { \ | | | | 293| 223| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 223| eptr += 2; \ | | | | 295| 223| } \ | | | | 296| 513| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 290, False: 0] | | | | ------------------ | | | | 297| 290| { \ | | | | 298| 290| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 290| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 290| eptr += 3; \ | | | | 301| 290| } \ | | | | 302| 290| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 917| } | | ------------------ | | | Branch (317:7): [True: 917, False: 12.7k] | | ------------------ ------------------ 1791| 13.6k| if (Lc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 13.6k|#define Lc F->temp_32[2] ------------------ if (Lc == d) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.72k| {\ | | 555| 1.72k| rrc = ra;\ | | 556| 1.72k| goto RETURN_SWITCH;\ | | 557| 1.72k| } ------------------ | Branch (1791:17): [True: 1.72k, False: 11.8k] ------------------ 1792| 11.8k| } 1793| 6.97k| } 1794| 6.54k| else 1795| 6.54k|#endif 1796| | /* Not UTF mode */ 1797| 6.54k| { 1798| 6.54k| for (;;) 1799| 18.4k| { 1800| 18.4k| RMATCH(Fecode, RM31); ------------------ | | 546| 18.4k| {\ | | 547| 18.4k| start_ecode = ra;\ | | 548| 18.4k| Freturn_id = rb;\ | | ------------------ | | | | 188| 18.4k|#define Freturn_id F->return_id | | ------------------ | | 549| 18.4k| goto MATCH_RECURSE;\ | | 550| 18.4k| L_##rb:;\ | | 551| 18.2k| } ------------------ 1801| 18.2k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 18.2k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 909| {\ | | 555| 909| rrc = ra;\ | | 556| 909| goto RETURN_SWITCH;\ | | 557| 909| } ------------------ | Branch (1801:17): [True: 909, False: 17.3k] ------------------ 1802| 17.3k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1501| 17.3k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1502| 17.3k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 922| {\ | | 555| 922| rrc = ra;\ | | 556| 922| goto RETURN_SWITCH;\ | | 557| 922| } ------------------ | Branch (1802:17): [True: 922, False: 16.3k] ------------------ 1803| 16.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 16.3k|#define Feptr F->eptr ------------------ | Branch (1803:17): [True: 3.47k, False: 12.9k] ------------------ 1804| 3.47k| { 1805| 3.47k| SCHECK_PARTIAL(); ------------------ | | 533| 3.47k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.64k, False: 1.82k] | | ------------------ | | 534| 3.47k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.64k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 870, False: 778] | | | Branch (534:38): [True: 480, False: 298] | | ------------------ | | 535| 3.47k| { \ | | 536| 1.35k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.35k|#define TRUE 1 | | ------------------ | | 537| 1.35k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 1.34k] | | ------------------ | | 538| 1.35k| } ------------------ 1806| 3.47k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.47k| {\ | | 555| 3.47k| rrc = ra;\ | | 556| 3.47k| goto RETURN_SWITCH;\ | | 557| 3.47k| } ------------------ 1807| 0| } 1808| 12.9k| if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 1503| 12.9k|#define Lc F->temp_32[2] ------------------ if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 12.9k|#define Feptr F->eptr ------------------ if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.01k| {\ | | 555| 1.01k| rrc = ra;\ | | 556| 1.01k| goto RETURN_SWITCH;\ | | 557| 1.01k| } ------------------ | Branch (1808:17): [True: 1.01k, False: 11.8k] ------------------ 1809| 11.8k| } 1810| 6.54k| } 1811| | /* Control never gets here */ 1812| 13.5k| } 1813| | 1814| | /* Maximize case */ 1815| | 1816| 75.8k| else 1817| 75.8k| { 1818| 75.8k| Lstart_eptr = Feptr; ------------------ | | 1500| 75.8k|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; ------------------ | | 177| 75.8k|#define Feptr F->eptr ------------------ 1819| | 1820| 75.8k|#ifdef SUPPORT_UNICODE 1821| 75.8k| if (utf) ------------------ | Branch (1821:13): [True: 22.2k, False: 53.6k] ------------------ 1822| 22.2k| { 1823| 22.2k| uint32_t d; 1824| 47.6k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1501| 22.2k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1502| 47.6k|#define Lmax F->temp_32[1] ------------------ | Branch (1824:26): [True: 32.4k, False: 15.1k] ------------------ 1825| 32.4k| { 1826| 32.4k| int len = 1; 1827| 32.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 32.4k|#define Feptr F->eptr ------------------ | Branch (1827:17): [True: 4.16k, False: 28.3k] ------------------ 1828| 4.16k| { 1829| 4.16k| SCHECK_PARTIAL(); ------------------ | | 533| 4.16k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 898, False: 3.27k] | | ------------------ | | 534| 4.16k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 898|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 417, False: 481] | | | Branch (534:38): [True: 246, False: 235] | | ------------------ | | 535| 4.16k| { \ | | 536| 663| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 663|#define TRUE 1 | | ------------------ | | 537| 663| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 657] | | ------------------ | | 538| 663| } ------------------ 1830| 4.16k| break; 1831| 4.16k| } 1832| 28.3k| GETCHARLEN(d, Feptr, len); ------------------ | | 330| 28.3k| c = *eptr; \ | | 331| 28.3k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.74k| { \ | | | | 323| 1.74k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 819, False: 921] | | | | ------------------ | | | | 324| 1.74k| { \ | | | | 325| 819| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 819| len++; \ | | | | 327| 819| } \ | | | | 328| 1.74k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 329, False: 592] | | | | ------------------ | | | | 329| 921| { \ | | | | 330| 329| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 329| len += 2; \ | | | | 332| 329| } \ | | | | 333| 921| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 592, False: 0] | | | | ------------------ | | | | 334| 592| {\ | | | | 335| 592| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 592| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 592| len += 3; \ | | | | 338| 592| } \ | | | | 339| 592| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.74k| } | | ------------------ | | | Branch (331:7): [True: 1.74k, False: 26.5k] | | ------------------ ------------------ 1833| 28.3k| if (Lc == d) break; ------------------ | | 1503| 28.3k|#define Lc F->temp_32[2] ------------------ | Branch (1833:17): [True: 2.94k, False: 25.3k] ------------------ 1834| 25.3k| Feptr += len; ------------------ | | 177| 25.3k|#define Feptr F->eptr ------------------ 1835| 25.3k| } 1836| | 1837| | /* After \C in UTF mode, Lstart_eptr might be in the middle of a 1838| | Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't 1839| | go too far. */ 1840| | 1841| 22.2k| if (reptype != REPTYPE_POS) for(;;) ------------------ | Branch (1841:15): [True: 19.2k, False: 3.03k] ------------------ 1842| 37.7k| { 1843| 37.7k| if (Feptr <= Lstart_eptr) break; ------------------ | | 177| 37.7k|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; ------------------ | | 1500| 37.7k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (1843:17): [True: 18.8k, False: 18.8k] ------------------ 1844| 18.8k| RMATCH(Fecode, RM207); ------------------ | | 546| 18.8k| {\ | | 547| 18.8k| start_ecode = ra;\ | | 548| 18.8k| Freturn_id = rb;\ | | ------------------ | | | | 188| 18.8k|#define Freturn_id F->return_id | | ------------------ | | 549| 18.8k| goto MATCH_RECURSE;\ | | 550| 18.8k| L_##rb:;\ | | 551| 18.8k| } ------------------ 1845| 18.8k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 18.8k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 277| {\ | | 555| 277| rrc = ra;\ | | 556| 277| goto RETURN_SWITCH;\ | | 557| 277| } ------------------ | Branch (1845:17): [True: 277, False: 18.5k] ------------------ 1846| 18.5k| Feptr--; ------------------ | | 177| 18.5k|#define Feptr F->eptr ------------------ 1847| 18.5k| BACKCHAR(Feptr); ------------------ | | 345| 18.9k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 398, False: 18.5k] | | ------------------ ------------------ 1848| 18.5k| } 1849| 22.2k| } 1850| 53.6k| else 1851| 53.6k|#endif 1852| | /* Not UTF mode */ 1853| 53.6k| { 1854| 220k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1501| 53.6k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1502| 220k|#define Lmax F->temp_32[1] ------------------ | Branch (1854:26): [True: 201k, False: 19.1k] ------------------ 1855| 201k| { 1856| 201k| if (Feptr >= mb->end_subject) ------------------ | | 177| 201k|#define Feptr F->eptr ------------------ | Branch (1856:17): [True: 17.7k, False: 183k] ------------------ 1857| 17.7k| { 1858| 17.7k| SCHECK_PARTIAL(); ------------------ | | 533| 17.7k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 5.62k, False: 12.1k] | | ------------------ | | 534| 17.7k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 5.62k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 3.78k, False: 1.83k] | | | Branch (534:38): [True: 978, False: 856] | | ------------------ | | 535| 17.7k| { \ | | 536| 4.76k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 4.76k|#define TRUE 1 | | ------------------ | | 537| 4.76k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 73|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 73, False: 4.69k] | | ------------------ | | 538| 4.76k| } ------------------ 1859| 17.7k| break; 1860| 17.7k| } 1861| 183k| if (Lc == *Feptr) break; ------------------ | | 1503| 183k|#define Lc F->temp_32[2] ------------------ if (Lc == *Feptr) break; ------------------ | | 177| 183k|#define Feptr F->eptr ------------------ | Branch (1861:17): [True: 16.6k, False: 166k] ------------------ 1862| 166k| Feptr++; ------------------ | | 177| 166k|#define Feptr F->eptr ------------------ 1863| 166k| } 1864| 53.5k| if (reptype != REPTYPE_POS) for (;;) ------------------ | Branch (1864:15): [True: 31.9k, False: 21.5k] ------------------ 1865| 82.3k| { 1866| 82.3k| if (Feptr == Lstart_eptr) break; ------------------ | | 177| 82.3k|#define Feptr F->eptr ------------------ if (Feptr == Lstart_eptr) break; ------------------ | | 1500| 82.3k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (1866:17): [True: 30.9k, False: 51.3k] ------------------ 1867| 51.3k| RMATCH(Fecode, RM32); ------------------ | | 546| 51.3k| {\ | | 547| 51.3k| start_ecode = ra;\ | | 548| 51.3k| Freturn_id = rb;\ | | ------------------ | | | | 188| 51.3k|#define Freturn_id F->return_id | | ------------------ | | 549| 51.3k| goto MATCH_RECURSE;\ | | 550| 51.3k| L_##rb:;\ | | 551| 51.1k| } ------------------ 1868| 51.1k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 51.1k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 772| {\ | | 555| 772| rrc = ra;\ | | 556| 772| goto RETURN_SWITCH;\ | | 557| 772| } ------------------ | Branch (1868:17): [True: 772, False: 50.3k] ------------------ 1869| 50.3k| Feptr--; ------------------ | | 177| 50.3k|#define Feptr F->eptr ------------------ 1870| 50.3k| } 1871| 53.5k| } 1872| 75.8k| } 1873| 89.4k| } 1874| 105k| break; 1875| | 1876| 105k|#undef Lstart_eptr 1877| 105k|#undef Lmin 1878| 105k|#undef Lmax 1879| 105k|#undef Lc 1880| 105k|#undef Loc 1881| | 1882| | 1883| | /* ===================================================================== */ 1884| | /* Match a bit-mapped character class, possibly repeatedly. These opcodes 1885| | are used when all the characters in the class have values in the range 1886| | 0-255, and either the matching is caseful, or the characters are in the 1887| | range 0-127 when UTF processing is enabled. The only difference between 1888| | OP_CLASS and OP_NCLASS occurs when a data character outside the range is 1889| | encountered. */ 1890| | 1891| 105k|#define Lmin F->temp_32[0] 1892| 105k|#define Lmax F->temp_32[1] 1893| 105k|#define Lstart_eptr F->temp_sptr[0] 1894| 105k|#define Lbyte_map_address F->temp_sptr[1] 1895| 105k|#define Lbyte_map ((unsigned char *)Lbyte_map_address) 1896| | 1897| 105k| case OP_NCLASS: ------------------ | Branch (1897:5): [True: 67.1k, False: 2.33G] ------------------ 1898| 269k| case OP_CLASS: ------------------ | Branch (1898:5): [True: 201k, False: 2.33G] ------------------ 1899| 269k| { 1900| 269k| Lbyte_map_address = Fecode + 1; /* Save for matching */ ------------------ | | 1894| 269k|#define Lbyte_map_address F->temp_sptr[1] ------------------ Lbyte_map_address = Fecode + 1; /* Save for matching */ ------------------ | | 176| 269k|#define Fecode F->ecode ------------------ 1901| 269k| Fecode += 1 + (32 / sizeof(PCRE2_UCHAR)); /* Advance past the item */ ------------------ | | 176| 269k|#define Fecode F->ecode ------------------ 1902| | 1903| | /* Look past the end of the item to see if there is repeat information 1904| | following. Then obey similar code to character type repeats. */ 1905| | 1906| 269k| switch (*Fecode) ------------------ | | 176| 269k|#define Fecode F->ecode ------------------ 1907| 269k| { 1908| 12.2k| case OP_CRSTAR: ------------------ | Branch (1908:9): [True: 12.2k, False: 256k] ------------------ 1909| 19.1k| case OP_CRMINSTAR: ------------------ | Branch (1909:9): [True: 6.85k, False: 262k] ------------------ 1910| 26.3k| case OP_CRPLUS: ------------------ | Branch (1910:9): [True: 7.26k, False: 261k] ------------------ 1911| 28.8k| case OP_CRMINPLUS: ------------------ | Branch (1911:9): [True: 2.44k, False: 266k] ------------------ 1912| 55.5k| case OP_CRQUERY: ------------------ | Branch (1912:9): [True: 26.7k, False: 242k] ------------------ 1913| 79.5k| case OP_CRMINQUERY: ------------------ | Branch (1913:9): [True: 23.9k, False: 245k] ------------------ 1914| 94.3k| case OP_CRPOSSTAR: ------------------ | Branch (1914:9): [True: 14.7k, False: 254k] ------------------ 1915| 100k| case OP_CRPOSPLUS: ------------------ | Branch (1915:9): [True: 6.17k, False: 262k] ------------------ 1916| 107k| case OP_CRPOSQUERY: ------------------ | Branch (1916:9): [True: 7.07k, False: 262k] ------------------ 1917| 107k| fc = *Fecode++ - OP_CRSTAR; ------------------ | | 176| 107k|#define Fecode F->ecode ------------------ 1918| 107k| Lmin = rep_min[fc]; ------------------ | | 1891| 107k|#define Lmin F->temp_32[0] ------------------ 1919| 107k| Lmax = rep_max[fc]; ------------------ | | 1892| 107k|#define Lmax F->temp_32[1] ------------------ 1920| 107k| reptype = rep_typ[fc]; 1921| 107k| break; 1922| | 1923| 6.43k| case OP_CRRANGE: ------------------ | Branch (1923:9): [True: 6.43k, False: 262k] ------------------ 1924| 10.6k| case OP_CRMINRANGE: ------------------ | Branch (1924:9): [True: 4.21k, False: 264k] ------------------ 1925| 15.1k| case OP_CRPOSRANGE: ------------------ | Branch (1925:9): [True: 4.54k, False: 264k] ------------------ 1926| 15.1k| Lmin = GET2(Fecode, 1); ------------------ | | 1891| 15.1k|#define Lmin F->temp_32[0] ------------------ Lmin = GET2(Fecode, 1); ------------------ | | 194| 15.1k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1927| 15.1k| Lmax = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 1892| 15.1k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 194| 15.1k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1928| 15.1k| if (Lmax == 0) Lmax = UINT32_MAX; /* Max 0 => infinity */ ------------------ | | 1892| 15.1k|#define Lmax F->temp_32[1] ------------------ if (Lmax == 0) Lmax = UINT32_MAX; /* Max 0 => infinity */ ------------------ | | 1892| 6.09k|#define Lmax F->temp_32[1] ------------------ | Branch (1928:13): [True: 6.09k, False: 9.10k] ------------------ 1929| 15.1k| reptype = rep_typ[*Fecode - OP_CRSTAR]; ------------------ | | 176| 15.1k|#define Fecode F->ecode ------------------ 1930| 15.1k| Fecode += 1 + 2 * IMM2_SIZE; ------------------ | | 176| 15.1k|#define Fecode F->ecode ------------------ Fecode += 1 + 2 * IMM2_SIZE; ------------------ | | 193| 15.1k|#define IMM2_SIZE 2 ------------------ 1931| 15.1k| break; 1932| | 1933| 146k| default: /* No repeat follows */ ------------------ | Branch (1933:9): [True: 146k, False: 122k] ------------------ 1934| 146k| Lmin = Lmax = 1; ------------------ | | 1891| 146k|#define Lmin F->temp_32[0] ------------------ Lmin = Lmax = 1; ------------------ | | 1892| 146k|#define Lmax F->temp_32[1] ------------------ 1935| 146k| break; 1936| 269k| } 1937| | 1938| | /* First, ensure the minimum number of matches are present. */ 1939| | 1940| 269k|#ifdef SUPPORT_UNICODE 1941| 269k| if (utf) ------------------ | Branch (1941:11): [True: 71.1k, False: 197k] ------------------ 1942| 71.1k| { 1943| 104k| for (i = 1; i <= Lmin; i++) ------------------ | | 1891| 104k|#define Lmin F->temp_32[0] ------------------ | Branch (1943:21): [True: 52.5k, False: 52.4k] ------------------ 1944| 52.5k| { 1945| 52.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 52.5k|#define Feptr F->eptr ------------------ | Branch (1945:15): [True: 3.30k, False: 49.2k] ------------------ 1946| 3.30k| { 1947| 3.30k| SCHECK_PARTIAL(); ------------------ | | 533| 3.30k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 851, False: 2.45k] | | ------------------ | | 534| 3.30k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 851|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 330, False: 521] | | | Branch (534:38): [True: 248, False: 273] | | ------------------ | | 535| 3.30k| { \ | | 536| 578| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 578|#define TRUE 1 | | ------------------ | | 537| 578| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 7|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 7, False: 571] | | ------------------ | | 538| 578| } ------------------ 1948| 3.30k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.30k| {\ | | 555| 3.30k| rrc = ra;\ | | 556| 3.30k| goto RETURN_SWITCH;\ | | 557| 3.30k| } ------------------ 1949| 0| } 1950| 49.2k| GETCHARINC(fc, Feptr); ------------------ | | 316| 49.2k| c = *eptr++; \ | | 317| 49.2k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.10k| { \ | | | | 289| 1.10k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 497, False: 612] | | | | ------------------ | | | | 290| 1.10k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.10k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 317, False: 295] | | | | ------------------ | | | | 292| 612| { \ | | | | 293| 317| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 317| eptr += 2; \ | | | | 295| 317| } \ | | | | 296| 612| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 295, False: 0] | | | | ------------------ | | | | 297| 295| { \ | | | | 298| 295| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 295| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 295| eptr += 3; \ | | | | 301| 295| } \ | | | | 302| 295| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.10k| } | | ------------------ | | | Branch (317:7): [True: 1.10k, False: 48.1k] | | ------------------ ------------------ 1951| 49.2k| if (fc > 255) ------------------ | Branch (1951:15): [True: 1.10k, False: 48.1k] ------------------ 1952| 1.10k| { 1953| 1.10k| if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH); ------------------ | | 186| 1.10k|#define Fop F->op ------------------ if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 551| {\ | | 555| 551| rrc = ra;\ | | 556| 551| goto RETURN_SWITCH;\ | | 557| 551| } ------------------ | Branch (1953:17): [True: 551, False: 551] ------------------ 1954| 551| } 1955| 48.1k| else 1956| 48.1k| if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 1895| 48.1k|#define Lbyte_map ((unsigned char *)Lbyte_map_address) | | ------------------ | | | | 1894| 48.1k|#define Lbyte_map_address F->temp_sptr[1] | | ------------------ ------------------ if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 14.9k| {\ | | 555| 14.9k| rrc = ra;\ | | 556| 14.9k| goto RETURN_SWITCH;\ | | 557| 14.9k| } ------------------ | Branch (1956:17): [True: 14.9k, False: 33.2k] ------------------ 1957| 33.7k| } 1958| 71.1k| } 1959| 197k| else 1960| 197k|#endif 1961| | /* Not UTF mode */ 1962| 197k| { 1963| 527k| for (i = 1; i <= Lmin; i++) ------------------ | | 1891| 527k|#define Lmin F->temp_32[0] ------------------ | Branch (1963:21): [True: 396k, False: 131k] ------------------ 1964| 396k| { 1965| 396k| if (Feptr >= mb->end_subject) ------------------ | | 177| 396k|#define Feptr F->eptr ------------------ | Branch (1965:15): [True: 10.8k, False: 385k] ------------------ 1966| 10.8k| { 1967| 10.8k| SCHECK_PARTIAL(); ------------------ | | 533| 10.8k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 3.00k, False: 7.88k] | | ------------------ | | 534| 10.8k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 3.00k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.46k, False: 1.54k] | | | Branch (534:38): [True: 812, False: 732] | | ------------------ | | 535| 10.8k| { \ | | 536| 2.27k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.27k|#define TRUE 1 | | ------------------ | | 537| 2.27k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 54|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 54, False: 2.22k] | | ------------------ | | 538| 2.27k| } ------------------ 1968| 10.8k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 10.8k| {\ | | 555| 10.8k| rrc = ra;\ | | 556| 10.8k| goto RETURN_SWITCH;\ | | 557| 10.8k| } ------------------ 1969| 0| } 1970| 385k| fc = *Feptr++; ------------------ | | 177| 385k|#define Feptr F->eptr ------------------ 1971| |#if PCRE2_CODE_UNIT_WIDTH != 8 1972| | if (fc > 255) 1973| | { 1974| | if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH); 1975| | } 1976| | else 1977| |#endif 1978| 385k| if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 1895| 385k|#define Lbyte_map ((unsigned char *)Lbyte_map_address) | | ------------------ | | | | 1894| 385k|#define Lbyte_map_address F->temp_sptr[1] | | ------------------ ------------------ if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 55.9k| {\ | | 555| 55.9k| rrc = ra;\ | | 556| 55.9k| goto RETURN_SWITCH;\ | | 557| 55.9k| } ------------------ | Branch (1978:15): [True: 55.9k, False: 329k] ------------------ 1979| 329k| } 1980| 197k| } 1981| | 1982| | /* If Lmax == Lmin we are done. Continue with main loop. */ 1983| | 1984| 183k| if (Lmin == Lmax) continue; ------------------ | | 1891| 183k|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 1892| 183k|#define Lmax F->temp_32[1] ------------------ | Branch (1984:11): [True: 78.5k, False: 104k] ------------------ 1985| | 1986| | /* If minimizing, keep testing the rest of the expression and advancing 1987| | the pointer while it matches the class. */ 1988| | 1989| 104k| if (reptype == REPTYPE_MIN) ------------------ | Branch (1989:11): [True: 32.6k, False: 72.2k] ------------------ 1990| 32.6k| { 1991| 32.6k|#ifdef SUPPORT_UNICODE 1992| 32.6k| if (utf) ------------------ | Branch (1992:13): [True: 15.9k, False: 16.7k] ------------------ 1993| 15.9k| { 1994| 15.9k| for (;;) 1995| 22.9k| { 1996| 22.9k| RMATCH(Fecode, RM200); ------------------ | | 546| 22.9k| {\ | | 547| 22.9k| start_ecode = ra;\ | | 548| 22.9k| Freturn_id = rb;\ | | ------------------ | | | | 188| 22.9k|#define Freturn_id F->return_id | | ------------------ | | 549| 22.9k| goto MATCH_RECURSE;\ | | 550| 22.9k| L_##rb:;\ | | 551| 21.8k| } ------------------ 1997| 21.8k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 21.8k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 376| {\ | | 555| 376| rrc = ra;\ | | 556| 376| goto RETURN_SWITCH;\ | | 557| 376| } ------------------ | Branch (1997:17): [True: 376, False: 21.4k] ------------------ 1998| 21.4k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1891| 21.4k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1892| 21.4k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.72k| {\ | | 555| 1.72k| rrc = ra;\ | | 556| 1.72k| goto RETURN_SWITCH;\ | | 557| 1.72k| } ------------------ | Branch (1998:17): [True: 1.72k, False: 19.7k] ------------------ 1999| 19.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 19.7k|#define Feptr F->eptr ------------------ | Branch (1999:17): [True: 2.34k, False: 17.4k] ------------------ 2000| 2.34k| { 2001| 2.34k| SCHECK_PARTIAL(); ------------------ | | 533| 2.34k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 718, False: 1.62k] | | ------------------ | | 534| 2.34k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 718|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 247, False: 471] | | | Branch (534:38): [True: 244, False: 227] | | ------------------ | | 535| 2.34k| { \ | | 536| 491| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 491|#define TRUE 1 | | ------------------ | | 537| 491| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 5, False: 486] | | ------------------ | | 538| 491| } ------------------ 2002| 2.34k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.34k| {\ | | 555| 2.34k| rrc = ra;\ | | 556| 2.34k| goto RETURN_SWITCH;\ | | 557| 2.34k| } ------------------ 2003| 0| } 2004| 17.4k| GETCHARINC(fc, Feptr); ------------------ | | 316| 17.4k| c = *eptr++; \ | | 317| 17.4k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 977| { \ | | | | 289| 977| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 421, False: 556] | | | | ------------------ | | | | 290| 977| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 977| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 318, False: 238] | | | | ------------------ | | | | 292| 556| { \ | | | | 293| 318| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 318| eptr += 2; \ | | | | 295| 318| } \ | | | | 296| 556| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 238, False: 0] | | | | ------------------ | | | | 297| 238| { \ | | | | 298| 238| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 238| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 238| eptr += 3; \ | | | | 301| 238| } \ | | | | 302| 238| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 977| } | | ------------------ | | | Branch (317:7): [True: 977, False: 16.4k] | | ------------------ ------------------ 2005| 17.4k| if (fc > 255) ------------------ | Branch (2005:17): [True: 732, False: 16.6k] ------------------ 2006| 732| { 2007| 732| if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH); ------------------ | | 186| 732|#define Fop F->op ------------------ if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 243| {\ | | 555| 243| rrc = ra;\ | | 556| 243| goto RETURN_SWITCH;\ | | 557| 243| } ------------------ | Branch (2007:19): [True: 243, False: 489] ------------------ 2008| 489| } 2009| 16.6k| else 2010| 16.6k| if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 1895| 16.6k|#define Lbyte_map ((unsigned char *)Lbyte_map_address) | | ------------------ | | | | 1894| 16.6k|#define Lbyte_map_address F->temp_sptr[1] | | ------------------ ------------------ if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 10.1k| {\ | | 555| 10.1k| rrc = ra;\ | | 556| 10.1k| goto RETURN_SWITCH;\ | | 557| 10.1k| } ------------------ | Branch (2010:19): [True: 10.1k, False: 6.53k] ------------------ 2011| 7.02k| } 2012| 15.9k| } 2013| 16.7k| else 2014| 16.7k|#endif 2015| | /* Not UTF mode */ 2016| 16.7k| { 2017| 16.7k| for (;;) 2018| 23.1k| { 2019| 23.1k| RMATCH(Fecode, RM23); ------------------ | | 546| 23.1k| {\ | | 547| 23.1k| start_ecode = ra;\ | | 548| 23.1k| Freturn_id = rb;\ | | ------------------ | | | | 188| 23.1k|#define Freturn_id F->return_id | | ------------------ | | 549| 23.1k| goto MATCH_RECURSE;\ | | 550| 23.1k| L_##rb:;\ | | 551| 22.4k| } ------------------ 2020| 22.4k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 22.4k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 406| {\ | | 555| 406| rrc = ra;\ | | 556| 406| goto RETURN_SWITCH;\ | | 557| 406| } ------------------ | Branch (2020:17): [True: 406, False: 21.9k] ------------------ 2021| 21.9k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1891| 21.9k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 1892| 21.9k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.62k| {\ | | 555| 1.62k| rrc = ra;\ | | 556| 1.62k| goto RETURN_SWITCH;\ | | 557| 1.62k| } ------------------ | Branch (2021:17): [True: 1.62k, False: 20.3k] ------------------ 2022| 20.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 20.3k|#define Feptr F->eptr ------------------ | Branch (2022:17): [True: 2.69k, False: 17.6k] ------------------ 2023| 2.69k| { 2024| 2.69k| SCHECK_PARTIAL(); ------------------ | | 533| 2.69k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.21k, False: 1.47k] | | ------------------ | | 534| 2.69k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.21k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 568, False: 647] | | | Branch (534:38): [True: 256, False: 391] | | ------------------ | | 535| 2.69k| { \ | | 536| 824| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 824|#define TRUE 1 | | ------------------ | | 537| 824| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 5, False: 819] | | ------------------ | | 538| 824| } ------------------ 2025| 2.68k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.68k| {\ | | 555| 2.68k| rrc = ra;\ | | 556| 2.68k| goto RETURN_SWITCH;\ | | 557| 2.68k| } ------------------ 2026| 0| } 2027| 17.6k| fc = *Feptr++; ------------------ | | 177| 17.6k|#define Feptr F->eptr ------------------ 2028| |#if PCRE2_CODE_UNIT_WIDTH != 8 2029| | if (fc > 255) 2030| | { 2031| | if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH); 2032| | } 2033| | else 2034| |#endif 2035| 17.6k| if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 1895| 17.6k|#define Lbyte_map ((unsigned char *)Lbyte_map_address) | | ------------------ | | | | 1894| 17.6k|#define Lbyte_map_address F->temp_sptr[1] | | ------------------ ------------------ if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 11.2k| {\ | | 555| 11.2k| rrc = ra;\ | | 556| 11.2k| goto RETURN_SWITCH;\ | | 557| 11.2k| } ------------------ | Branch (2035:17): [True: 11.2k, False: 6.44k] ------------------ 2036| 6.44k| } 2037| 16.7k| } 2038| | /* Control never gets here */ 2039| 32.6k| } 2040| | 2041| | /* If maximizing, find the longest possible run, then work backwards. */ 2042| | 2043| 72.2k| else 2044| 72.2k| { 2045| 72.2k| Lstart_eptr = Feptr; ------------------ | | 1893| 72.2k|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; ------------------ | | 177| 72.2k|#define Feptr F->eptr ------------------ 2046| | 2047| 72.2k|#ifdef SUPPORT_UNICODE 2048| 72.2k| if (utf) ------------------ | Branch (2048:13): [True: 25.2k, False: 46.9k] ------------------ 2049| 25.2k| { 2050| 33.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1891| 25.2k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1892| 33.5k|#define Lmax F->temp_32[1] ------------------ | Branch (2050:26): [True: 30.8k, False: 2.70k] ------------------ 2051| 30.8k| { 2052| 30.8k| int len = 1; 2053| 30.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 30.8k|#define Feptr F->eptr ------------------ | Branch (2053:17): [True: 3.09k, False: 27.7k] ------------------ 2054| 3.09k| { 2055| 3.09k| SCHECK_PARTIAL(); ------------------ | | 533| 3.09k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 821, False: 2.27k] | | ------------------ | | 534| 3.09k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 821|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 366, False: 455] | | | Branch (534:38): [True: 234, False: 221] | | ------------------ | | 535| 3.09k| { \ | | 536| 600| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 600|#define TRUE 1 | | ------------------ | | 537| 600| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 12|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 12, False: 588] | | ------------------ | | 538| 600| } ------------------ 2056| 3.08k| break; 2057| 3.09k| } 2058| 27.7k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 27.7k| c = *eptr; \ | | 331| 27.7k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 835| { \ | | | | 323| 835| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 335, False: 500] | | | | ------------------ | | | | 324| 835| { \ | | | | 325| 335| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 335| len++; \ | | | | 327| 335| } \ | | | | 328| 835| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 256, False: 244] | | | | ------------------ | | | | 329| 500| { \ | | | | 330| 256| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 256| len += 2; \ | | | | 332| 256| } \ | | | | 333| 500| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 244, False: 0] | | | | ------------------ | | | | 334| 244| {\ | | | | 335| 244| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 244| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 244| len += 3; \ | | | | 338| 244| } \ | | | | 339| 244| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 835| } | | ------------------ | | | Branch (331:7): [True: 835, False: 26.8k] | | ------------------ ------------------ 2059| 27.7k| if (fc > 255) ------------------ | Branch (2059:17): [True: 784, False: 26.9k] ------------------ 2060| 784| { 2061| 784| if (Fop == OP_CLASS) break; ------------------ | | 186| 784|#define Fop F->op ------------------ | Branch (2061:19): [True: 263, False: 521] ------------------ 2062| 784| } 2063| 26.9k| else 2064| 26.9k| if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) break; ------------------ | | 1895| 26.9k|#define Lbyte_map ((unsigned char *)Lbyte_map_address) | | ------------------ | | | | 1894| 26.9k|#define Lbyte_map_address F->temp_sptr[1] | | ------------------ ------------------ | Branch (2064:19): [True: 19.1k, False: 7.74k] ------------------ 2065| 8.27k| Feptr += len; ------------------ | | 177| 8.27k|#define Feptr F->eptr ------------------ 2066| 8.27k| } 2067| | 2068| 25.2k| if (reptype == REPTYPE_POS) continue; /* No backtracking */ ------------------ | Branch (2068:15): [True: 11.0k, False: 14.1k] ------------------ 2069| | 2070| | /* After \C in UTF mode, Lstart_eptr might be in the middle of a 2071| | Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't 2072| | go too far. */ 2073| | 2074| 14.1k| for (;;) 2075| 20.1k| { 2076| 20.1k| RMATCH(Fecode, RM201); ------------------ | | 546| 20.1k| {\ | | 547| 20.1k| start_ecode = ra;\ | | 548| 20.1k| Freturn_id = rb;\ | | ------------------ | | | | 188| 20.1k|#define Freturn_id F->return_id | | ------------------ | | 549| 20.1k| goto MATCH_RECURSE;\ | | 550| 20.1k| L_##rb:;\ | | 551| 19.7k| } ------------------ 2077| 19.7k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 19.7k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 269| {\ | | 555| 269| rrc = ra;\ | | 556| 269| goto RETURN_SWITCH;\ | | 557| 269| } ------------------ | Branch (2077:17): [True: 269, False: 19.4k] ------------------ 2078| 19.4k| if (Feptr-- <= Lstart_eptr) break; /* Tried at original position */ ------------------ | | 177| 19.4k|#define Feptr F->eptr ------------------ if (Feptr-- <= Lstart_eptr) break; /* Tried at original position */ ------------------ | | 1893| 19.4k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (2078:17): [True: 13.5k, False: 5.93k] ------------------ 2079| 5.93k| BACKCHAR(Feptr); ------------------ | | 345| 6.63k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 702, False: 5.93k] | | ------------------ ------------------ 2080| 5.93k| } 2081| 14.1k| } 2082| 46.9k| else 2083| 46.9k|#endif 2084| | /* Not UTF mode */ 2085| 46.9k| { 2086| 130k| for (i = Lmin; i < Lmax; i++) ------------------ | | 1891| 46.9k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 1892| 130k|#define Lmax F->temp_32[1] ------------------ | Branch (2086:26): [True: 124k, False: 6.18k] ------------------ 2087| 124k| { 2088| 124k| if (Feptr >= mb->end_subject) ------------------ | | 177| 124k|#define Feptr F->eptr ------------------ | Branch (2088:17): [True: 14.0k, False: 110k] ------------------ 2089| 14.0k| { 2090| 14.0k| SCHECK_PARTIAL(); ------------------ | | 533| 14.0k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.82k, False: 11.2k] | | ------------------ | | 534| 14.0k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.82k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.10k, False: 1.71k] | | | Branch (534:38): [True: 1.06k, False: 651] | | ------------------ | | 535| 14.0k| { \ | | 536| 2.17k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.17k|#define TRUE 1 | | ------------------ | | 537| 2.17k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 54|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 54, False: 2.11k] | | ------------------ | | 538| 2.17k| } ------------------ 2091| 14.0k| break; 2092| 14.0k| } 2093| 110k| fc = *Feptr; ------------------ | | 177| 110k|#define Feptr F->eptr ------------------ 2094| |#if PCRE2_CODE_UNIT_WIDTH != 8 2095| | if (fc > 255) 2096| | { 2097| | if (Fop == OP_CLASS) break; 2098| | } 2099| | else 2100| |#endif 2101| 110k| if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) break; ------------------ | | 1895| 110k|#define Lbyte_map ((unsigned char *)Lbyte_map_address) | | ------------------ | | | | 1894| 110k|#define Lbyte_map_address F->temp_sptr[1] | | ------------------ ------------------ | Branch (2101:17): [True: 26.7k, False: 83.4k] ------------------ 2102| 83.4k| Feptr++; ------------------ | | 177| 83.4k|#define Feptr F->eptr ------------------ 2103| 83.4k| } 2104| | 2105| 46.9k| if (reptype == REPTYPE_POS) continue; /* No backtracking */ ------------------ | Branch (2105:15): [True: 16.8k, False: 30.0k] ------------------ 2106| | 2107| 95.0k| while (Feptr >= Lstart_eptr) ------------------ | | 177| 95.0k|#define Feptr F->eptr ------------------ while (Feptr >= Lstart_eptr) ------------------ | | 1893| 95.0k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (2107:18): [True: 68.1k, False: 26.8k] ------------------ 2108| 68.1k| { 2109| 68.1k| RMATCH(Fecode, RM24); ------------------ | | 546| 68.1k| {\ | | 547| 68.1k| start_ecode = ra;\ | | 548| 68.1k| Freturn_id = rb;\ | | ------------------ | | | | 188| 68.1k|#define Freturn_id F->return_id | | ------------------ | | 549| 68.1k| goto MATCH_RECURSE;\ | | 550| 68.1k| L_##rb:;\ | | 551| 65.7k| } ------------------ 2110| 65.7k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 65.7k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 705| {\ | | 555| 705| rrc = ra;\ | | 556| 705| goto RETURN_SWITCH;\ | | 557| 705| } ------------------ | Branch (2110:17): [True: 705, False: 65.0k] ------------------ 2111| 65.0k| Feptr--; ------------------ | | 177| 65.0k|#define Feptr F->eptr ------------------ 2112| 65.0k| } 2113| 30.0k| } 2114| | 2115| 72.2k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 40.4k| {\ | | 555| 40.4k| rrc = ra;\ | | 556| 40.4k| goto RETURN_SWITCH;\ | | 557| 40.4k| } ------------------ 2116| 0| } 2117| 104k| } 2118| | /* Control never gets here */ 2119| | 2120| 0|#undef Lbyte_map_address 2121| 0|#undef Lbyte_map 2122| 0|#undef Lstart_eptr 2123| 0|#undef Lmin 2124| 0|#undef Lmax 2125| | 2126| | 2127| | /* ===================================================================== */ 2128| | /* Match an extended character class. In the 8-bit library, this opcode is 2129| | encountered only when UTF-8 mode mode is supported. In the 16-bit and 2130| | 32-bit libraries, codepoints greater than 255 may be encountered even when 2131| | UTF is not supported. */ 2132| | 2133| 0|#define Lstart_eptr F->temp_sptr[0] 2134| 0|#define Lxclass_data F->temp_sptr[1] 2135| 0|#define Lmin F->temp_32[0] 2136| 0|#define Lmax F->temp_32[1] 2137| | 2138| 0|#ifdef SUPPORT_WIDE_CHARS 2139| 102k| case OP_XCLASS: ------------------ | Branch (2139:5): [True: 102k, False: 2.33G] ------------------ 2140| 102k| { 2141| 102k| Lxclass_data = Fecode + 1 + LINK_SIZE; /* Save for matching */ ------------------ | | 2134| 102k|#define Lxclass_data F->temp_sptr[1] ------------------ Lxclass_data = Fecode + 1 + LINK_SIZE; /* Save for matching */ ------------------ | | 176| 102k|#define Fecode F->ecode ------------------ Lxclass_data = Fecode + 1 + LINK_SIZE; /* Save for matching */ ------------------ | | 165| 102k|#define LINK_SIZE 2 ------------------ 2142| 102k| Fecode += GET(Fecode, 1); /* Advance past the item */ ------------------ | | 176| 102k|#define Fecode F->ecode ------------------ Fecode += GET(Fecode, 1); /* Advance past the item */ ------------------ | | 109| 102k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2143| | 2144| 102k| switch (*Fecode) ------------------ | | 176| 102k|#define Fecode F->ecode ------------------ 2145| 102k| { 2146| 3.36k| case OP_CRSTAR: ------------------ | Branch (2146:9): [True: 3.36k, False: 99.4k] ------------------ 2147| 7.38k| case OP_CRMINSTAR: ------------------ | Branch (2147:9): [True: 4.02k, False: 98.8k] ------------------ 2148| 9.69k| case OP_CRPLUS: ------------------ | Branch (2148:9): [True: 2.30k, False: 100k] ------------------ 2149| 14.6k| case OP_CRMINPLUS: ------------------ | Branch (2149:9): [True: 4.91k, False: 97.9k] ------------------ 2150| 17.0k| case OP_CRQUERY: ------------------ | Branch (2150:9): [True: 2.40k, False: 100k] ------------------ 2151| 21.5k| case OP_CRMINQUERY: ------------------ | Branch (2151:9): [True: 4.57k, False: 98.2k] ------------------ 2152| 24.9k| case OP_CRPOSSTAR: ------------------ | Branch (2152:9): [True: 3.33k, False: 99.5k] ------------------ 2153| 28.9k| case OP_CRPOSPLUS: ------------------ | Branch (2153:9): [True: 4.02k, False: 98.8k] ------------------ 2154| 32.0k| case OP_CRPOSQUERY: ------------------ | Branch (2154:9): [True: 3.13k, False: 99.7k] ------------------ 2155| 32.0k| fc = *Fecode++ - OP_CRSTAR; ------------------ | | 176| 32.0k|#define Fecode F->ecode ------------------ 2156| 32.0k| Lmin = rep_min[fc]; ------------------ | | 2135| 32.0k|#define Lmin F->temp_32[0] ------------------ 2157| 32.0k| Lmax = rep_max[fc]; ------------------ | | 2136| 32.0k|#define Lmax F->temp_32[1] ------------------ 2158| 32.0k| reptype = rep_typ[fc]; 2159| 32.0k| break; 2160| | 2161| 1.62k| case OP_CRRANGE: ------------------ | Branch (2161:9): [True: 1.62k, False: 101k] ------------------ 2162| 3.19k| case OP_CRMINRANGE: ------------------ | Branch (2162:9): [True: 1.56k, False: 101k] ------------------ 2163| 3.75k| case OP_CRPOSRANGE: ------------------ | Branch (2163:9): [True: 563, False: 102k] ------------------ 2164| 3.75k| Lmin = GET2(Fecode, 1); ------------------ | | 2135| 3.75k|#define Lmin F->temp_32[0] ------------------ Lmin = GET2(Fecode, 1); ------------------ | | 194| 3.75k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2165| 3.75k| Lmax = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 2136| 3.75k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 194| 3.75k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2166| 3.75k| if (Lmax == 0) Lmax = UINT32_MAX; /* Max 0 => infinity */ ------------------ | | 2136| 3.75k|#define Lmax F->temp_32[1] ------------------ if (Lmax == 0) Lmax = UINT32_MAX; /* Max 0 => infinity */ ------------------ | | 2136| 2.18k|#define Lmax F->temp_32[1] ------------------ | Branch (2166:13): [True: 2.18k, False: 1.56k] ------------------ 2167| 3.75k| reptype = rep_typ[*Fecode - OP_CRSTAR]; ------------------ | | 176| 3.75k|#define Fecode F->ecode ------------------ 2168| 3.75k| Fecode += 1 + 2 * IMM2_SIZE; ------------------ | | 176| 3.75k|#define Fecode F->ecode ------------------ Fecode += 1 + 2 * IMM2_SIZE; ------------------ | | 193| 3.75k|#define IMM2_SIZE 2 ------------------ 2169| 3.75k| break; 2170| | 2171| 67.0k| default: /* No repeat follows */ ------------------ | Branch (2171:9): [True: 67.0k, False: 35.8k] ------------------ 2172| 67.0k| Lmin = Lmax = 1; ------------------ | | 2135| 67.0k|#define Lmin F->temp_32[0] ------------------ Lmin = Lmax = 1; ------------------ | | 2136| 67.0k|#define Lmax F->temp_32[1] ------------------ 2173| 67.0k| break; 2174| 102k| } 2175| | 2176| | /* First, ensure the minimum number of matches are present. */ 2177| | 2178| 538k| for (i = 1; i <= Lmin; i++) ------------------ | | 2135| 538k|#define Lmin F->temp_32[0] ------------------ | Branch (2178:19): [True: 482k, False: 56.8k] ------------------ 2179| 482k| { 2180| 482k| if (Feptr >= mb->end_subject) ------------------ | | 177| 482k|#define Feptr F->eptr ------------------ | Branch (2180:13): [True: 7.79k, False: 474k] ------------------ 2181| 7.79k| { 2182| 7.79k| SCHECK_PARTIAL(); ------------------ | | 533| 7.79k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.64k, False: 6.14k] | | ------------------ | | 534| 7.79k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.64k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.10k, False: 543] | | | Branch (534:38): [True: 233, False: 310] | | ------------------ | | 535| 7.79k| { \ | | 536| 1.33k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.33k|#define TRUE 1 | | ------------------ | | 537| 1.33k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 22|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 22, False: 1.31k] | | ------------------ | | 538| 1.33k| } ------------------ 2183| 7.77k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 7.77k| {\ | | 555| 7.77k| rrc = ra;\ | | 556| 7.77k| goto RETURN_SWITCH;\ | | 557| 7.77k| } ------------------ 2184| 0| } 2185| 474k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 474k| c = *eptr++; \ | | 324| 474k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 2.96k| { \ | | | | 289| 2.96k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 978, False: 1.98k] | | | | ------------------ | | | | 290| 2.96k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 2.96k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 1.51k, False: 467] | | | | ------------------ | | | | 292| 1.98k| { \ | | | | 293| 1.51k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 1.51k| eptr += 2; \ | | | | 295| 1.51k| } \ | | | | 296| 1.98k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 467, False: 0] | | | | ------------------ | | | | 297| 467| { \ | | | | 298| 467| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 467| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 467| eptr += 3; \ | | | | 301| 467| } \ | | | | 302| 467| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 2.96k| } | | ------------------ | | | Branch (324:7): [True: 47.1k, False: 427k] | | | Branch (324:14): [True: 2.96k, False: 44.1k] | | ------------------ ------------------ 2186| 474k| if (!PRIV(xclass)(fc, Lxclass_data, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 474k|#define PRIV(name) _pcre2_##name ------------------ if (!PRIV(xclass)(fc, Lxclass_data, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 2134| 474k|#define Lxclass_data F->temp_sptr[1] ------------------ if (!PRIV(xclass)(fc, Lxclass_data, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 38.2k| {\ | | 555| 38.2k| rrc = ra;\ | | 556| 38.2k| goto RETURN_SWITCH;\ | | 557| 38.2k| } ------------------ | Branch (2186:13): [True: 38.2k, False: 436k] ------------------ 2187| 436k| } 2188| | 2189| | /* If Lmax == Lmin we can just continue with the main loop. */ 2190| | 2191| 56.8k| if (Lmin == Lmax) continue; ------------------ | | 2135| 56.8k|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 2136| 56.8k|#define Lmax F->temp_32[1] ------------------ | Branch (2191:11): [True: 29.9k, False: 26.8k] ------------------ 2192| | 2193| | /* If minimizing, keep testing the rest of the expression and advancing 2194| | the pointer while it matches the class. */ 2195| | 2196| 26.8k| if (reptype == REPTYPE_MIN) ------------------ | Branch (2196:11): [True: 11.3k, False: 15.5k] ------------------ 2197| 11.3k| { 2198| 11.3k| for (;;) 2199| 33.9k| { 2200| 33.9k| RMATCH(Fecode, RM100); ------------------ | | 546| 33.9k| {\ | | 547| 33.9k| start_ecode = ra;\ | | 548| 33.9k| Freturn_id = rb;\ | | ------------------ | | | | 188| 33.9k|#define Freturn_id F->return_id | | ------------------ | | 549| 33.9k| goto MATCH_RECURSE;\ | | 550| 33.9k| L_##rb:;\ | | 551| 33.2k| } ------------------ 2201| 33.2k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 33.2k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 344| {\ | | 555| 344| rrc = ra;\ | | 556| 344| goto RETURN_SWITCH;\ | | 557| 344| } ------------------ | Branch (2201:15): [True: 344, False: 32.9k] ------------------ 2202| 32.9k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2135| 32.9k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2136| 32.9k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.09k| {\ | | 555| 1.09k| rrc = ra;\ | | 556| 1.09k| goto RETURN_SWITCH;\ | | 557| 1.09k| } ------------------ | Branch (2202:15): [True: 1.09k, False: 31.8k] ------------------ 2203| 31.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 31.8k|#define Feptr F->eptr ------------------ | Branch (2203:15): [True: 2.65k, False: 29.2k] ------------------ 2204| 2.65k| { 2205| 2.65k| SCHECK_PARTIAL(); ------------------ | | 533| 2.65k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 671, False: 1.98k] | | ------------------ | | 534| 2.65k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 671|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 211, False: 460] | | | Branch (534:38): [True: 235, False: 225] | | ------------------ | | 535| 2.65k| { \ | | 536| 446| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 446|#define TRUE 1 | | ------------------ | | 537| 446| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 5, False: 441] | | ------------------ | | 538| 446| } ------------------ 2206| 2.65k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.65k| {\ | | 555| 2.65k| rrc = ra;\ | | 556| 2.65k| goto RETURN_SWITCH;\ | | 557| 2.65k| } ------------------ 2207| 0| } 2208| 29.2k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 29.2k| c = *eptr++; \ | | 324| 29.2k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.96k| { \ | | | | 289| 1.96k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 615, False: 1.34k] | | | | ------------------ | | | | 290| 1.96k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.96k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 952, False: 397] | | | | ------------------ | | | | 292| 1.34k| { \ | | | | 293| 952| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 952| eptr += 2; \ | | | | 295| 952| } \ | | | | 296| 1.34k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 397, False: 0] | | | | ------------------ | | | | 297| 397| { \ | | | | 298| 397| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 397| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 397| eptr += 3; \ | | | | 301| 397| } \ | | | | 302| 397| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.96k| } | | ------------------ | | | Branch (324:7): [True: 17.3k, False: 11.8k] | | | Branch (324:14): [True: 1.96k, False: 15.3k] | | ------------------ ------------------ 2209| 29.2k| if (!PRIV(xclass)(fc, Lxclass_data, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 29.2k|#define PRIV(name) _pcre2_##name ------------------ if (!PRIV(xclass)(fc, Lxclass_data, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 2134| 29.2k|#define Lxclass_data F->temp_sptr[1] ------------------ if (!PRIV(xclass)(fc, Lxclass_data, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.61k| {\ | | 555| 6.61k| rrc = ra;\ | | 556| 6.61k| goto RETURN_SWITCH;\ | | 557| 6.61k| } ------------------ | Branch (2209:15): [True: 6.61k, False: 22.5k] ------------------ 2210| 22.5k| } 2211| | /* Control never gets here */ 2212| 11.3k| } 2213| | 2214| | /* If maximizing, find the longest possible run, then work backwards. */ 2215| | 2216| 15.5k| else 2217| 15.5k| { 2218| 15.5k| Lstart_eptr = Feptr; ------------------ | | 2133| 15.5k|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; ------------------ | | 177| 15.5k|#define Feptr F->eptr ------------------ 2219| 46.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2135| 15.5k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2136| 46.5k|#define Lmax F->temp_32[1] ------------------ | Branch (2219:24): [True: 44.4k, False: 2.06k] ------------------ 2220| 44.4k| { 2221| 44.4k| int len = 1; 2222| 44.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 44.4k|#define Feptr F->eptr ------------------ | Branch (2222:15): [True: 3.88k, False: 40.5k] ------------------ 2223| 3.88k| { 2224| 3.88k| SCHECK_PARTIAL(); ------------------ | | 533| 3.88k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 960, False: 2.92k] | | ------------------ | | 534| 3.88k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 960|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 263, False: 697] | | | Branch (534:38): [True: 470, False: 227] | | ------------------ | | 535| 3.88k| { \ | | 536| 733| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 733|#define TRUE 1 | | ------------------ | | 537| 733| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 27|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 27, False: 706] | | ------------------ | | 538| 733| } ------------------ 2225| 3.86k| break; 2226| 3.88k| } 2227| 40.5k|#ifdef SUPPORT_UNICODE 2228| 40.5k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 40.5k| c = *eptr; \ | | 339| 40.5k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 2.07k| { \ | | | | 323| 2.07k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 522, False: 1.55k] | | | | ------------------ | | | | 324| 2.07k| { \ | | | | 325| 522| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 522| len++; \ | | | | 327| 522| } \ | | | | 328| 2.07k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 1.21k, False: 342] | | | | ------------------ | | | | 329| 1.55k| { \ | | | | 330| 1.21k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 1.21k| len += 2; \ | | | | 332| 1.21k| } \ | | | | 333| 1.55k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 342, False: 0] | | | | ------------------ | | | | 334| 342| {\ | | | | 335| 342| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 342| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 342| len += 3; \ | | | | 338| 342| } \ | | | | 339| 342| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 2.07k| } | | ------------------ | | | Branch (339:7): [True: 27.7k, False: 12.8k] | | | Branch (339:14): [True: 2.07k, False: 25.6k] | | ------------------ ------------------ 2229| |#else 2230| | fc = *Feptr; 2231| |#endif 2232| 40.5k| if (!PRIV(xclass)(fc, Lxclass_data, utf)) break; ------------------ | | 177| 40.5k|#define PRIV(name) _pcre2_##name ------------------ if (!PRIV(xclass)(fc, Lxclass_data, utf)) break; ------------------ | | 2134| 40.5k|#define Lxclass_data F->temp_sptr[1] ------------------ | Branch (2232:15): [True: 9.57k, False: 30.9k] ------------------ 2233| 30.9k| Feptr += len; ------------------ | | 177| 30.9k|#define Feptr F->eptr ------------------ 2234| 30.9k| } 2235| | 2236| 15.5k| if (reptype == REPTYPE_POS) continue; /* No backtracking */ ------------------ | Branch (2236:13): [True: 8.44k, False: 7.05k] ------------------ 2237| | 2238| | /* After \C in UTF mode, Lstart_eptr might be in the middle of a 2239| | Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't 2240| | go too far. */ 2241| | 2242| 7.05k| for(;;) 2243| 21.2k| { 2244| 21.2k| RMATCH(Fecode, RM101); ------------------ | | 546| 21.2k| {\ | | 547| 21.2k| start_ecode = ra;\ | | 548| 21.2k| Freturn_id = rb;\ | | ------------------ | | | | 188| 21.2k|#define Freturn_id F->return_id | | ------------------ | | 549| 21.2k| goto MATCH_RECURSE;\ | | 550| 21.2k| L_##rb:;\ | | 551| 20.8k| } ------------------ 2245| 20.8k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 20.8k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 256| {\ | | 555| 256| rrc = ra;\ | | 556| 256| goto RETURN_SWITCH;\ | | 557| 256| } ------------------ | Branch (2245:15): [True: 256, False: 20.5k] ------------------ 2246| 20.5k| if (Feptr-- <= Lstart_eptr) break; /* Tried at original position */ ------------------ | | 177| 20.5k|#define Feptr F->eptr ------------------ if (Feptr-- <= Lstart_eptr) break; /* Tried at original position */ ------------------ | | 2133| 20.5k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (2246:15): [True: 6.40k, False: 14.1k] ------------------ 2247| 14.1k|#ifdef SUPPORT_UNICODE 2248| 14.1k| if (utf) BACKCHAR(Feptr); ------------------ | | 345| 11.0k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 923, False: 10.1k] | | ------------------ ------------------ | Branch (2248:15): [True: 10.1k, False: 4.05k] ------------------ 2249| 14.1k|#endif 2250| 14.1k| } 2251| 7.05k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.40k| {\ | | 555| 6.40k| rrc = ra;\ | | 556| 6.40k| goto RETURN_SWITCH;\ | | 557| 6.40k| } ------------------ 2252| 0| } 2253| | 2254| | /* Control never gets here */ 2255| 26.8k| } 2256| 0|#endif /* SUPPORT_WIDE_CHARS: end of XCLASS */ 2257| | 2258| 0|#undef Lstart_eptr 2259| 0|#undef Lxclass_data 2260| 0|#undef Lmin 2261| 0|#undef Lmax 2262| | 2263| | 2264| | /* ===================================================================== */ 2265| | /* Match various character types when PCRE2_UCP is not set. These opcodes 2266| | are not generated when PCRE2_UCP is set - instead appropriate property 2267| | tests are compiled. */ 2268| | 2269| 47.8k| case OP_NOT_DIGIT: ------------------ | Branch (2269:5): [True: 47.8k, False: 2.33G] ------------------ 2270| 47.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 47.8k|#define Feptr F->eptr ------------------ | Branch (2270:9): [True: 2.89k, False: 44.9k] ------------------ 2271| 2.89k| { 2272| 2.89k| SCHECK_PARTIAL(); ------------------ | | 533| 2.89k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 772, False: 2.11k] | | ------------------ | | 534| 2.89k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 772|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 319, False: 453] | | | Branch (534:38): [True: 217, False: 236] | | ------------------ | | 535| 2.89k| { \ | | 536| 536| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 536|#define TRUE 1 | | ------------------ | | 537| 536| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 12|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 12, False: 524] | | ------------------ | | 538| 536| } ------------------ 2273| 2.87k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.87k| {\ | | 555| 2.87k| rrc = ra;\ | | 556| 2.87k| goto RETURN_SWITCH;\ | | 557| 2.87k| } ------------------ 2274| 0| } 2275| 44.9k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 44.9k| c = *eptr++; \ | | 324| 44.9k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 753| { \ | | | | 289| 753| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 291, False: 462] | | | | ------------------ | | | | 290| 753| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 753| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 227, False: 235] | | | | ------------------ | | | | 292| 462| { \ | | | | 293| 227| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 227| eptr += 2; \ | | | | 295| 227| } \ | | | | 296| 462| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 235, False: 0] | | | | ------------------ | | | | 297| 235| { \ | | | | 298| 235| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 235| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 235| eptr += 3; \ | | | | 301| 235| } \ | | | | 302| 235| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 753| } | | ------------------ | | | Branch (324:7): [True: 5.23k, False: 39.6k] | | | Branch (324:14): [True: 753, False: 4.48k] | | ------------------ ------------------ 2276| 44.9k| if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_digit) != 0) ------------------ | | 217| 89.8k|#define CHMAX_255(c) ((c) <= 255u) | | ------------------ | | | Branch (217:22): [True: 44.1k, False: 753] | | ------------------ ------------------ if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_digit) != 0) ------------------ | | 582| 44.1k|#define ctype_digit 0x08 ------------------ | Branch (2276:26): [True: 1.40k, False: 42.7k] ------------------ 2277| 43.5k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.40k| {\ | | 555| 1.40k| rrc = ra;\ | | 556| 1.40k| goto RETURN_SWITCH;\ | | 557| 1.40k| } ------------------ 2278| 43.5k| Fecode++; ------------------ | | 176| 43.5k|#define Fecode F->ecode ------------------ 2279| 43.5k| break; 2280| | 2281| 22.6k| case OP_DIGIT: ------------------ | Branch (2281:5): [True: 22.6k, False: 2.33G] ------------------ 2282| 22.6k| if (Feptr >= mb->end_subject) ------------------ | | 177| 22.6k|#define Feptr F->eptr ------------------ | Branch (2282:9): [True: 3.82k, False: 18.8k] ------------------ 2283| 3.82k| { 2284| 3.82k| SCHECK_PARTIAL(); ------------------ | | 533| 3.82k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.10k, False: 2.72k] | | ------------------ | | 534| 3.82k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.10k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 620, False: 480] | | | Branch (534:38): [True: 210, False: 270] | | ------------------ | | 535| 3.82k| { \ | | 536| 830| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 830|#define TRUE 1 | | ------------------ | | 537| 830| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 814] | | ------------------ | | 538| 830| } ------------------ 2285| 3.80k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.80k| {\ | | 555| 3.80k| rrc = ra;\ | | 556| 3.80k| goto RETURN_SWITCH;\ | | 557| 3.80k| } ------------------ 2286| 0| } 2287| 18.8k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 18.8k| c = *eptr++; \ | | 324| 18.8k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 840| { \ | | | | 289| 840| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 366, False: 474] | | | | ------------------ | | | | 290| 840| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 840| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 261, False: 213] | | | | ------------------ | | | | 292| 474| { \ | | | | 293| 261| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 261| eptr += 2; \ | | | | 295| 261| } \ | | | | 296| 474| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 213, False: 0] | | | | ------------------ | | | | 297| 213| { \ | | | | 298| 213| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 213| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 213| eptr += 3; \ | | | | 301| 213| } \ | | | | 302| 213| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 840| } | | ------------------ | | | Branch (324:7): [True: 4.53k, False: 14.3k] | | | Branch (324:14): [True: 840, False: 3.69k] | | ------------------ ------------------ 2288| 18.8k| if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_digit) == 0) ------------------ | | 217| 37.6k|#define CHMAX_255(c) ((c) <= 255u) ------------------ if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_digit) == 0) ------------------ | | 582| 17.9k|#define ctype_digit 0x08 ------------------ | Branch (2288:9): [True: 840, False: 17.9k] | Branch (2288:27): [True: 16.4k, False: 1.50k] ------------------ 2289| 17.3k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 17.3k| {\ | | 555| 17.3k| rrc = ra;\ | | 556| 17.3k| goto RETURN_SWITCH;\ | | 557| 17.3k| } ------------------ 2290| 1.50k| Fecode++; ------------------ | | 176| 1.50k|#define Fecode F->ecode ------------------ 2291| 1.50k| break; 2292| | 2293| 47.1k| case OP_NOT_WHITESPACE: ------------------ | Branch (2293:5): [True: 47.1k, False: 2.33G] ------------------ 2294| 47.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 47.1k|#define Feptr F->eptr ------------------ | Branch (2294:9): [True: 6.76k, False: 40.4k] ------------------ 2295| 6.76k| { 2296| 6.76k| SCHECK_PARTIAL(); ------------------ | | 533| 6.76k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 798, False: 5.96k] | | ------------------ | | 534| 6.76k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 798|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 335, False: 463] | | | Branch (534:38): [True: 203, False: 260] | | ------------------ | | 535| 6.76k| { \ | | 536| 538| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 538|#define TRUE 1 | | ------------------ | | 537| 538| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 22|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 22, False: 516] | | ------------------ | | 538| 538| } ------------------ 2297| 6.74k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.74k| {\ | | 555| 6.74k| rrc = ra;\ | | 556| 6.74k| goto RETURN_SWITCH;\ | | 557| 6.74k| } ------------------ 2298| 0| } 2299| 40.4k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 40.4k| c = *eptr++; \ | | 324| 40.4k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 728| { \ | | | | 289| 728| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 300, False: 428] | | | | ------------------ | | | | 290| 728| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 728| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 206, False: 222] | | | | ------------------ | | | | 292| 428| { \ | | | | 293| 206| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 206| eptr += 2; \ | | | | 295| 206| } \ | | | | 296| 428| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 222, False: 0] | | | | ------------------ | | | | 297| 222| { \ | | | | 298| 222| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 222| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 222| eptr += 3; \ | | | | 301| 222| } \ | | | | 302| 222| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 728| } | | ------------------ | | | Branch (324:7): [True: 5.86k, False: 34.5k] | | | Branch (324:14): [True: 728, False: 5.13k] | | ------------------ ------------------ 2300| 40.4k| if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_space) != 0) ------------------ | | 217| 80.8k|#define CHMAX_255(c) ((c) <= 255u) | | ------------------ | | | Branch (217:22): [True: 39.6k, False: 728] | | ------------------ ------------------ if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_space) != 0) ------------------ | | 579| 39.6k|#define ctype_space 0x01 ------------------ | Branch (2300:26): [True: 1.47k, False: 38.2k] ------------------ 2301| 38.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.47k| {\ | | 555| 1.47k| rrc = ra;\ | | 556| 1.47k| goto RETURN_SWITCH;\ | | 557| 1.47k| } ------------------ 2302| 38.9k| Fecode++; ------------------ | | 176| 38.9k|#define Fecode F->ecode ------------------ 2303| 38.9k| break; 2304| | 2305| 53.4k| case OP_WHITESPACE: ------------------ | Branch (2305:5): [True: 53.4k, False: 2.33G] ------------------ 2306| 53.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 53.4k|#define Feptr F->eptr ------------------ | Branch (2306:9): [True: 7.92k, False: 45.5k] ------------------ 2307| 7.92k| { 2308| 7.92k| SCHECK_PARTIAL(); ------------------ | | 533| 7.92k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.47k, False: 6.44k] | | ------------------ | | 534| 7.92k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.47k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 547, False: 927] | | | Branch (534:38): [True: 227, False: 700] | | ------------------ | | 535| 7.92k| { \ | | 536| 774| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 774|#define TRUE 1 | | ------------------ | | 537| 774| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 21|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 21, False: 753] | | ------------------ | | 538| 774| } ------------------ 2309| 7.90k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 7.90k| {\ | | 555| 7.90k| rrc = ra;\ | | 556| 7.90k| goto RETURN_SWITCH;\ | | 557| 7.90k| } ------------------ 2310| 0| } 2311| 45.5k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 45.5k| c = *eptr++; \ | | 324| 45.5k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.00k| { \ | | | | 289| 1.00k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 502, False: 504] | | | | ------------------ | | | | 290| 1.00k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.00k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 258, False: 246] | | | | ------------------ | | | | 292| 504| { \ | | | | 293| 258| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 258| eptr += 2; \ | | | | 295| 258| } \ | | | | 296| 504| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 246, False: 0] | | | | ------------------ | | | | 297| 246| { \ | | | | 298| 246| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 246| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 246| eptr += 3; \ | | | | 301| 246| } \ | | | | 302| 246| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.00k| } | | ------------------ | | | Branch (324:7): [True: 5.50k, False: 40.0k] | | | Branch (324:14): [True: 1.00k, False: 4.49k] | | ------------------ ------------------ 2312| 45.5k| if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_space) == 0) ------------------ | | 217| 91.0k|#define CHMAX_255(c) ((c) <= 255u) ------------------ if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_space) == 0) ------------------ | | 579| 44.5k|#define ctype_space 0x01 ------------------ | Branch (2312:9): [True: 1.00k, False: 44.5k] | Branch (2312:27): [True: 43.1k, False: 1.37k] ------------------ 2313| 44.1k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 44.1k| {\ | | 555| 44.1k| rrc = ra;\ | | 556| 44.1k| goto RETURN_SWITCH;\ | | 557| 44.1k| } ------------------ 2314| 1.37k| Fecode++; ------------------ | | 176| 1.37k|#define Fecode F->ecode ------------------ 2315| 1.37k| break; 2316| | 2317| 28.4k| case OP_NOT_WORDCHAR: ------------------ | Branch (2317:5): [True: 28.4k, False: 2.33G] ------------------ 2318| 28.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 28.4k|#define Feptr F->eptr ------------------ | Branch (2318:9): [True: 3.37k, False: 25.1k] ------------------ 2319| 3.37k| { 2320| 3.37k| SCHECK_PARTIAL(); ------------------ | | 533| 3.37k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 969, False: 2.40k] | | ------------------ | | 534| 3.37k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 969|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 473, False: 496] | | | Branch (534:38): [True: 236, False: 260] | | ------------------ | | 535| 3.37k| { \ | | 536| 709| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 709|#define TRUE 1 | | ------------------ | | 537| 709| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 13|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 13, False: 696] | | ------------------ | | 538| 709| } ------------------ 2321| 3.35k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.35k| {\ | | 555| 3.35k| rrc = ra;\ | | 556| 3.35k| goto RETURN_SWITCH;\ | | 557| 3.35k| } ------------------ 2322| 0| } 2323| 25.1k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 25.1k| c = *eptr++; \ | | 324| 25.1k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 808| { \ | | | | 289| 808| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 362, False: 446] | | | | ------------------ | | | | 290| 808| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 808| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 203, False: 243] | | | | ------------------ | | | | 292| 446| { \ | | | | 293| 203| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 203| eptr += 2; \ | | | | 295| 203| } \ | | | | 296| 446| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 243, False: 0] | | | | ------------------ | | | | 297| 243| { \ | | | | 298| 243| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 243| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 243| eptr += 3; \ | | | | 301| 243| } \ | | | | 302| 243| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 808| } | | ------------------ | | | Branch (324:7): [True: 4.56k, False: 20.5k] | | | Branch (324:14): [True: 808, False: 3.75k] | | ------------------ ------------------ 2324| 25.1k| if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0) ------------------ | | 217| 50.2k|#define CHMAX_255(c) ((c) <= 255u) | | ------------------ | | | Branch (217:22): [True: 24.3k, False: 808] | | ------------------ ------------------ if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0) ------------------ | | 583| 24.3k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (2324:26): [True: 5.42k, False: 18.8k] ------------------ 2325| 19.7k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.42k| {\ | | 555| 5.42k| rrc = ra;\ | | 556| 5.42k| goto RETURN_SWITCH;\ | | 557| 5.42k| } ------------------ 2326| 19.7k| Fecode++; ------------------ | | 176| 19.7k|#define Fecode F->ecode ------------------ 2327| 19.7k| break; 2328| | 2329| 22.0k| case OP_WORDCHAR: ------------------ | Branch (2329:5): [True: 22.0k, False: 2.33G] ------------------ 2330| 22.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 22.0k|#define Feptr F->eptr ------------------ | Branch (2330:9): [True: 2.82k, False: 19.2k] ------------------ 2331| 2.82k| { 2332| 2.82k| SCHECK_PARTIAL(); ------------------ | | 533| 2.82k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 788, False: 2.03k] | | ------------------ | | 534| 2.82k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 788|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 263, False: 525] | | | Branch (534:38): [True: 258, False: 267] | | ------------------ | | 535| 2.82k| { \ | | 536| 521| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 521|#define TRUE 1 | | ------------------ | | 537| 521| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 12|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 12, False: 509] | | ------------------ | | 538| 521| } ------------------ 2333| 2.81k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.81k| {\ | | 555| 2.81k| rrc = ra;\ | | 556| 2.81k| goto RETURN_SWITCH;\ | | 557| 2.81k| } ------------------ 2334| 0| } 2335| 19.2k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 19.2k| c = *eptr++; \ | | 324| 19.2k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 767| { \ | | | | 289| 767| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 231, False: 536] | | | | ------------------ | | | | 290| 767| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 767| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 274, False: 262] | | | | ------------------ | | | | 292| 536| { \ | | | | 293| 274| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 274| eptr += 2; \ | | | | 295| 274| } \ | | | | 296| 536| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 262, False: 0] | | | | ------------------ | | | | 297| 262| { \ | | | | 298| 262| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 262| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 262| eptr += 3; \ | | | | 301| 262| } \ | | | | 302| 262| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 767| } | | ------------------ | | | Branch (324:7): [True: 4.70k, False: 14.5k] | | | Branch (324:14): [True: 767, False: 3.93k] | | ------------------ ------------------ 2336| 19.2k| if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_word) == 0) ------------------ | | 217| 38.4k|#define CHMAX_255(c) ((c) <= 255u) ------------------ if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_word) == 0) ------------------ | | 583| 18.4k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (2336:9): [True: 767, False: 18.4k] | Branch (2336:27): [True: 13.3k, False: 5.03k] ------------------ 2337| 14.1k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 14.1k| {\ | | 555| 14.1k| rrc = ra;\ | | 556| 14.1k| goto RETURN_SWITCH;\ | | 557| 14.1k| } ------------------ 2338| 5.03k| Fecode++; ------------------ | | 176| 5.03k|#define Fecode F->ecode ------------------ 2339| 5.03k| break; 2340| | 2341| 39.4k| case OP_ANYNL: ------------------ | Branch (2341:5): [True: 39.4k, False: 2.33G] ------------------ 2342| 39.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 39.4k|#define Feptr F->eptr ------------------ | Branch (2342:9): [True: 8.54k, False: 30.9k] ------------------ 2343| 8.54k| { 2344| 8.54k| SCHECK_PARTIAL(); ------------------ | | 533| 8.54k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 812, False: 7.73k] | | ------------------ | | 534| 8.54k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 812|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 324, False: 488] | | | Branch (534:38): [True: 219, False: 269] | | ------------------ | | 535| 8.54k| { \ | | 536| 543| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 543|#define TRUE 1 | | ------------------ | | 537| 543| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 10|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 10, False: 533] | | ------------------ | | 538| 543| } ------------------ 2345| 8.53k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 8.53k| {\ | | 555| 8.53k| rrc = ra;\ | | 556| 8.53k| goto RETURN_SWITCH;\ | | 557| 8.53k| } ------------------ 2346| 0| } 2347| 30.9k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 30.9k| c = *eptr++; \ | | 324| 30.9k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.93k| { \ | | | | 289| 1.93k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 264, False: 1.67k] | | | | ------------------ | | | | 290| 1.93k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.93k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 1.39k, False: 278] | | | | ------------------ | | | | 292| 1.67k| { \ | | | | 293| 1.39k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 1.39k| eptr += 2; \ | | | | 295| 1.39k| } \ | | | | 296| 1.67k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 278, False: 0] | | | | ------------------ | | | | 297| 278| { \ | | | | 298| 278| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 278| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 278| eptr += 3; \ | | | | 301| 278| } \ | | | | 302| 278| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.93k| } | | ------------------ | | | Branch (324:7): [True: 18.5k, False: 12.3k] | | | Branch (324:14): [True: 1.93k, False: 16.5k] | | ------------------ ------------------ 2348| 30.9k| switch(fc) 2349| 30.9k| { 2350| 24.8k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 24.8k| {\ | | 555| 24.8k| rrc = ra;\ | | 556| 24.8k| goto RETURN_SWITCH;\ | | 557| 24.8k| } ------------------ | Branch (2350:7): [True: 24.8k, False: 6.04k] ------------------ 2351| | 2352| 2.77k| case CHAR_CR: ------------------ | | 972| 2.77k|#define CHAR_CR '\015' ------------------ | Branch (2352:7): [True: 2.77k, False: 28.1k] ------------------ 2353| 2.77k| if (Feptr >= mb->end_subject) ------------------ | | 177| 2.77k|#define Feptr F->eptr ------------------ | Branch (2353:11): [True: 1.25k, False: 1.52k] ------------------ 2354| 1.25k| { 2355| 1.25k| SCHECK_PARTIAL(); ------------------ | | 533| 1.25k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 256, False: 997] | | ------------------ | | 534| 1.25k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 256|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 256, False: 0] | | | Branch (534:38): [True: 0, False: 0] | | ------------------ | | 535| 1.25k| { \ | | 536| 256| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 256|#define TRUE 1 | | ------------------ | | 537| 256| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 15|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 15, False: 241] | | ------------------ | | 538| 256| } ------------------ 2356| 1.23k| } 2357| 1.52k| else if (UCHAR21TEST(Feptr) == CHAR_LF) Feptr++; ------------------ | | 244| 1.52k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ else if (UCHAR21TEST(Feptr) == CHAR_LF) Feptr++; ------------------ | | 973| 1.52k|#define CHAR_LF '\012' ------------------ else if (UCHAR21TEST(Feptr) == CHAR_LF) Feptr++; ------------------ | | 177| 716|#define Feptr F->eptr ------------------ | Branch (2357:16): [True: 716, False: 805] ------------------ 2358| 2.75k| break; 2359| | 2360| 2.75k| case CHAR_LF: ------------------ | | 973| 1.10k|#define CHAR_LF '\012' ------------------ | Branch (2360:7): [True: 1.10k, False: 29.8k] ------------------ 2361| 1.10k| break; 2362| | 2363| 471| case CHAR_VT: ------------------ | | 970| 471|#define CHAR_VT '\013' ------------------ | Branch (2363:7): [True: 471, False: 30.4k] ------------------ 2364| 1.05k| case CHAR_FF: ------------------ | | 971| 1.05k|#define CHAR_FF '\014' ------------------ | Branch (2364:7): [True: 588, False: 30.3k] ------------------ 2365| 1.55k| case CHAR_NEL: ------------------ | | 975| 1.55k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (2365:7): [True: 494, False: 30.4k] ------------------ 2366| 1.55k|#ifndef EBCDIC 2367| 1.86k| case 0x2028: ------------------ | Branch (2367:7): [True: 308, False: 30.6k] ------------------ 2368| 2.16k| case 0x2029: ------------------ | Branch (2368:7): [True: 303, False: 30.6k] ------------------ 2369| 2.16k|#endif /* Not EBCDIC */ 2370| 2.16k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH); ------------------ | | 217| 2.16k|#define PCRE2_BSR_ANYCRLF 2 ------------------ if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ | Branch (2370:11): [True: 0, False: 2.16k] ------------------ 2371| 2.16k| break; 2372| 30.9k| } 2373| 6.02k| Fecode++; ------------------ | | 176| 6.02k|#define Fecode F->ecode ------------------ 2374| 6.02k| break; 2375| | 2376| 71.1k| case OP_NOT_HSPACE: ------------------ | Branch (2376:5): [True: 71.1k, False: 2.33G] ------------------ 2377| 71.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 71.1k|#define Feptr F->eptr ------------------ | Branch (2377:9): [True: 6.89k, False: 64.2k] ------------------ 2378| 6.89k| { 2379| 6.89k| SCHECK_PARTIAL(); ------------------ | | 533| 6.89k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 948, False: 5.94k] | | ------------------ | | 534| 6.89k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 948|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 220, False: 728] | | | Branch (534:38): [True: 286, False: 442] | | ------------------ | | 535| 6.89k| { \ | | 536| 506| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 506|#define TRUE 1 | | ------------------ | | 537| 506| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 490] | | ------------------ | | 538| 506| } ------------------ 2380| 6.87k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.87k| {\ | | 555| 6.87k| rrc = ra;\ | | 556| 6.87k| goto RETURN_SWITCH;\ | | 557| 6.87k| } ------------------ 2381| 0| } 2382| 64.2k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 64.2k| c = *eptr++; \ | | 324| 64.2k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 5.87k| { \ | | | | 289| 5.87k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 230, False: 5.64k] | | | | ------------------ | | | | 290| 5.87k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 5.87k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 5.37k, False: 270] | | | | ------------------ | | | | 292| 5.64k| { \ | | | | 293| 5.37k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 5.37k| eptr += 2; \ | | | | 295| 5.37k| } \ | | | | 296| 5.64k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 270, False: 0] | | | | ------------------ | | | | 297| 270| { \ | | | | 298| 270| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 270| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 270| eptr += 3; \ | | | | 301| 270| } \ | | | | 302| 270| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 5.87k| } | | ------------------ | | | Branch (324:7): [True: 33.2k, False: 31.0k] | | | Branch (324:14): [True: 5.87k, False: 27.3k] | | ------------------ ------------------ 2383| 64.2k| switch(fc) 2384| 64.2k| { 2385| 6.52k| HSPACE_CASES: RRETURN(MATCH_NOMATCH); /* Byte and multibyte cases */ ------------------ | | 412| 1.26k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 270| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 270|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 270, False: 64.0k] | | | | ------------------ | | | | 408| 628| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 628|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 358, False: 63.9k] | | | | ------------------ | | | | 409| 1.26k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.52k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.52k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 253, False: 64.0k] | | | | ------------------ | | | | 390| 1.78k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 264, False: 64.0k] | | | | ------------------ | | | | 391| 2.10k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 324, False: 63.9k] | | | | ------------------ | | | | 392| 2.41k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 308, False: 63.9k] | | | | ------------------ | | | | 393| 2.74k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 332, False: 63.9k] | | | | ------------------ | | | | 394| 3.02k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 280, False: 64.0k] | | | | ------------------ | | | | 395| 3.43k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 408, False: 63.8k] | | | | ------------------ | | | | 396| 3.75k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 322, False: 63.9k] | | | | ------------------ | | | | 397| 4.18k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 422, False: 63.8k] | | | | ------------------ | | | | 398| 4.52k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 348, False: 63.9k] | | | | ------------------ | | | | 399| 4.85k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 324, False: 63.9k] | | | | ------------------ | | | | 400| 5.15k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 298, False: 63.9k] | | | | ------------------ | | | | 401| 5.49k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 342, False: 63.9k] | | | | ------------------ | | | | 402| 5.82k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 332, False: 63.9k] | | | | ------------------ | | | | 403| 6.16k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 342, False: 63.9k] | | | | ------------------ | | | | 404| 6.52k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ HSPACE_CASES: RRETURN(MATCH_NOMATCH); /* Byte and multibyte cases */ ------------------ | | 554| 6.52k| {\ | | 555| 6.52k| rrc = ra;\ | | 556| 6.52k| goto RETURN_SWITCH;\ | | 557| 6.52k| } ------------------ 2386| 57.7k| default: break; ------------------ | Branch (2386:7): [True: 57.7k, False: 6.52k] ------------------ 2387| 64.2k| } 2388| 57.7k| Fecode++; ------------------ | | 176| 57.7k|#define Fecode F->ecode ------------------ 2389| 57.7k| break; 2390| | 2391| 98.5k| case OP_HSPACE: ------------------ | Branch (2391:5): [True: 98.5k, False: 2.33G] ------------------ 2392| 98.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 98.5k|#define Feptr F->eptr ------------------ | Branch (2392:9): [True: 18.0k, False: 80.4k] ------------------ 2393| 18.0k| { 2394| 18.0k| SCHECK_PARTIAL(); ------------------ | | 533| 18.0k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.94k, False: 16.1k] | | ------------------ | | 534| 18.0k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.94k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 678, False: 1.26k] | | | Branch (534:38): [True: 550, False: 716] | | ------------------ | | 535| 18.0k| { \ | | 536| 1.22k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.22k|#define TRUE 1 | | ------------------ | | 537| 1.22k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 28|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 28, False: 1.20k] | | ------------------ | | 538| 1.22k| } ------------------ 2395| 18.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 18.0k| {\ | | 555| 18.0k| rrc = ra;\ | | 556| 18.0k| goto RETURN_SWITCH;\ | | 557| 18.0k| } ------------------ 2396| 0| } 2397| 80.4k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 80.4k| c = *eptr++; \ | | 324| 80.4k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 9.58k| { \ | | | | 289| 9.58k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 284, False: 9.29k] | | | | ------------------ | | | | 290| 9.58k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 9.58k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 8.78k, False: 512] | | | | ------------------ | | | | 292| 9.29k| { \ | | | | 293| 8.78k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 8.78k| eptr += 2; \ | | | | 295| 8.78k| } \ | | | | 296| 9.29k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 512, False: 0] | | | | ------------------ | | | | 297| 512| { \ | | | | 298| 512| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 512| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 512| eptr += 3; \ | | | | 301| 512| } \ | | | | 302| 512| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 9.58k| } | | ------------------ | | | Branch (324:7): [True: 53.5k, False: 26.8k] | | | Branch (324:14): [True: 9.58k, False: 44.0k] | | ------------------ ------------------ 2398| 80.4k| switch(fc) 2399| 80.4k| { 2400| 11.3k| HSPACE_CASES: break; /* Byte and multibyte cases */ ------------------ | | 412| 2.83k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 716| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 716|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 716, False: 79.7k] | | | | ------------------ | | | | 408| 2.19k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 2.19k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 1.47k, False: 78.9k] | | | | ------------------ | | | | 409| 2.83k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 3.71k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 3.71k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 877, False: 79.5k] | | | | ------------------ | | | | 390| 4.18k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 468, False: 79.9k] | | | | ------------------ | | | | 391| 4.85k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 674, False: 79.7k] | | | | ------------------ | | | | 392| 5.32k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 468, False: 79.9k] | | | | ------------------ | | | | 393| 5.71k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 386, False: 80.0k] | | | | ------------------ | | | | 394| 6.02k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 308, False: 80.1k] | | | | ------------------ | | | | 395| 6.54k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 525, False: 79.9k] | | | | ------------------ | | | | 396| 7.36k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 820, False: 79.6k] | | | | ------------------ | | | | 397| 7.70k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 340, False: 80.1k] | | | | ------------------ | | | | 398| 8.10k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 400, False: 80.0k] | | | | ------------------ | | | | 399| 8.50k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 398, False: 80.0k] | | | | ------------------ | | | | 400| 8.80k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 302, False: 80.1k] | | | | ------------------ | | | | 401| 9.48k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 684, False: 79.7k] | | | | ------------------ | | | | 402| 10.0k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 567, False: 79.8k] | | | | ------------------ | | | | 403| 10.5k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 534, False: 79.9k] | | | | ------------------ | | | | 404| 11.3k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 2401| 69.1k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 69.1k| {\ | | 555| 69.1k| rrc = ra;\ | | 556| 69.1k| goto RETURN_SWITCH;\ | | 557| 69.1k| } ------------------ | Branch (2401:7): [True: 69.1k, False: 11.3k] ------------------ 2402| 80.4k| } 2403| 11.3k| Fecode++; ------------------ | | 176| 11.3k|#define Fecode F->ecode ------------------ 2404| 11.3k| break; 2405| | 2406| 39.2k| case OP_NOT_VSPACE: ------------------ | Branch (2406:5): [True: 39.2k, False: 2.33G] ------------------ 2407| 39.2k| if (Feptr >= mb->end_subject) ------------------ | | 177| 39.2k|#define Feptr F->eptr ------------------ | Branch (2407:9): [True: 3.48k, False: 35.8k] ------------------ 2408| 3.48k| { 2409| 3.48k| SCHECK_PARTIAL(); ------------------ | | 533| 3.48k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 689, False: 2.80k] | | ------------------ | | 534| 3.48k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 689|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 229, False: 460] | | | Branch (534:38): [True: 227, False: 233] | | ------------------ | | 535| 3.48k| { \ | | 536| 456| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 456|#define TRUE 1 | | ------------------ | | 537| 456| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 10|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 10, False: 446] | | ------------------ | | 538| 456| } ------------------ 2410| 3.47k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.47k| {\ | | 555| 3.47k| rrc = ra;\ | | 556| 3.47k| goto RETURN_SWITCH;\ | | 557| 3.47k| } ------------------ 2411| 0| } 2412| 35.8k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 35.8k| c = *eptr++; \ | | 324| 35.8k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.62k| { \ | | | | 289| 1.62k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 325, False: 1.29k] | | | | ------------------ | | | | 290| 1.62k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.62k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 1.05k, False: 243] | | | | ------------------ | | | | 292| 1.29k| { \ | | | | 293| 1.05k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 1.05k| eptr += 2; \ | | | | 295| 1.05k| } \ | | | | 296| 1.29k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 243, False: 0] | | | | ------------------ | | | | 297| 243| { \ | | | | 298| 243| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 243| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 243| eptr += 3; \ | | | | 301| 243| } \ | | | | 302| 243| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.62k| } | | ------------------ | | | Branch (324:7): [True: 18.5k, False: 17.2k] | | | Branch (324:14): [True: 1.62k, False: 16.9k] | | ------------------ ------------------ 2413| 35.8k| switch(fc) 2414| 35.8k| { 2415| 2.92k| VSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 430| 1.93k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 268| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 268|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 268, False: 35.5k] | | | | ------------------ | | | | 424| 687| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 687|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 419, False: 35.3k] | | | | ------------------ | | | | 425| 1.10k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.10k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 418, False: 35.3k] | | | | ------------------ | | | | 426| 1.46k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.46k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 362, False: 35.4k] | | | | ------------------ | | | | 427| 1.93k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 2.52k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 2.52k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 593, False: 35.2k] | | | | ------------------ | | | | 420| 2.92k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ VSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.92k| {\ | | 555| 2.92k| rrc = ra;\ | | 556| 2.92k| goto RETURN_SWITCH;\ | | 557| 2.92k| } ------------------ 2416| 32.8k| default: break; ------------------ | Branch (2416:7): [True: 32.8k, False: 2.92k] ------------------ 2417| 35.8k| } 2418| 32.8k| Fecode++; ------------------ | | 176| 32.8k|#define Fecode F->ecode ------------------ 2419| 32.8k| break; 2420| | 2421| 29.5k| case OP_VSPACE: ------------------ | Branch (2421:5): [True: 29.5k, False: 2.33G] ------------------ 2422| 29.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 29.5k|#define Feptr F->eptr ------------------ | Branch (2422:9): [True: 5.88k, False: 23.6k] ------------------ 2423| 5.88k| { 2424| 5.88k| SCHECK_PARTIAL(); ------------------ | | 533| 5.88k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 828, False: 5.05k] | | ------------------ | | 534| 5.88k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 828|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 305, False: 523] | | | Branch (534:38): [True: 219, False: 304] | | ------------------ | | 535| 5.88k| { \ | | 536| 524| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 524|#define TRUE 1 | | ------------------ | | 537| 524| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 12|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 12, False: 512] | | ------------------ | | 538| 524| } ------------------ 2425| 5.87k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.87k| {\ | | 555| 5.87k| rrc = ra;\ | | 556| 5.87k| goto RETURN_SWITCH;\ | | 557| 5.87k| } ------------------ 2426| 0| } 2427| 23.6k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 23.6k| c = *eptr++; \ | | 324| 23.6k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.85k| { \ | | | | 289| 1.85k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 416, False: 1.43k] | | | | ------------------ | | | | 290| 1.85k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.85k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 1.14k, False: 297] | | | | ------------------ | | | | 292| 1.43k| { \ | | | | 293| 1.14k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 1.14k| eptr += 2; \ | | | | 295| 1.14k| } \ | | | | 296| 1.43k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 297, False: 0] | | | | ------------------ | | | | 297| 297| { \ | | | | 298| 297| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 297| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 297| eptr += 3; \ | | | | 301| 297| } \ | | | | 302| 297| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.85k| } | | ------------------ | | | Branch (324:7): [True: 10.3k, False: 13.3k] | | | Branch (324:14): [True: 1.85k, False: 8.46k] | | ------------------ ------------------ 2428| 23.6k| switch(fc) 2429| 23.6k| { 2430| 3.32k| VSPACE_CASES: break; ------------------ | | 430| 2.46k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 351| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 351|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 351, False: 23.3k] | | | | ------------------ | | | | 424| 961| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 961|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 610, False: 23.0k] | | | | ------------------ | | | | 425| 1.33k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.33k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 372, False: 23.3k] | | | | ------------------ | | | | 426| 1.96k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.96k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 635, False: 23.0k] | | | | ------------------ | | | | 427| 2.46k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 2.87k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 2.87k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 411, False: 23.2k] | | | | ------------------ | | | | 420| 3.32k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 2431| 20.3k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 20.3k| {\ | | 555| 20.3k| rrc = ra;\ | | 556| 20.3k| goto RETURN_SWITCH;\ | | 557| 20.3k| } ------------------ | Branch (2431:7): [True: 20.3k, False: 3.32k] ------------------ 2432| 23.6k| } 2433| 3.32k| Fecode++; ------------------ | | 176| 3.32k|#define Fecode F->ecode ------------------ 2434| 3.32k| break; 2435| | 2436| | 2437| 0|#ifdef SUPPORT_UNICODE 2438| | 2439| | /* ===================================================================== */ 2440| | /* Check the next character by Unicode property. We will get here only 2441| | if the support is in the binary; otherwise a compile-time error occurs. */ 2442| | 2443| 146k| case OP_PROP: ------------------ | Branch (2443:5): [True: 146k, False: 2.33G] ------------------ 2444| 372k| case OP_NOTPROP: ------------------ | Branch (2444:5): [True: 225k, False: 2.33G] ------------------ 2445| 372k| if (Feptr >= mb->end_subject) ------------------ | | 177| 372k|#define Feptr F->eptr ------------------ | Branch (2445:9): [True: 20.5k, False: 351k] ------------------ 2446| 20.5k| { 2447| 20.5k| SCHECK_PARTIAL(); ------------------ | | 533| 20.5k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.62k, False: 17.9k] | | ------------------ | | 534| 20.5k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.62k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.47k, False: 1.15k] | | | Branch (534:38): [True: 385, False: 770] | | ------------------ | | 535| 20.5k| { \ | | 536| 1.85k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.85k|#define TRUE 1 | | ------------------ | | 537| 1.85k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 20|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 20, False: 1.83k] | | ------------------ | | 538| 1.85k| } ------------------ 2448| 20.5k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 20.5k| {\ | | 555| 20.5k| rrc = ra;\ | | 556| 20.5k| goto RETURN_SWITCH;\ | | 557| 20.5k| } ------------------ 2449| 0| } 2450| 351k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 351k| c = *eptr++; \ | | 324| 351k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 14.3k| { \ | | | | 289| 14.3k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 2.92k, False: 11.3k] | | | | ------------------ | | | | 290| 14.3k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 14.3k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 10.0k, False: 1.28k] | | | | ------------------ | | | | 292| 11.3k| { \ | | | | 293| 10.0k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 10.0k| eptr += 2; \ | | | | 295| 10.0k| } \ | | | | 296| 11.3k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 1.28k, False: 0] | | | | ------------------ | | | | 297| 1.28k| { \ | | | | 298| 1.28k| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 1.28k| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 1.28k| eptr += 3; \ | | | | 301| 1.28k| } \ | | | | 302| 1.28k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 14.3k| } | | ------------------ | | | Branch (324:7): [True: 239k, False: 112k] | | | Branch (324:14): [True: 14.3k, False: 224k] | | ------------------ ------------------ 2451| 351k| { 2452| 351k| const uint32_t *cp; 2453| 351k| const ucd_record *prop = GET_UCD(fc); ------------------ | | 1846| 351k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 351k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 351k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 351k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 351k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 351k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 351k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 351k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 351k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 351k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 2454| 351k| BOOL notmatch = Fop == OP_NOTPROP; ------------------ | | 186| 351k|#define Fop F->op ------------------ 2455| | 2456| 351k| switch(Fecode[1]) ------------------ | | 176| 351k|#define Fecode F->ecode ------------------ 2457| 351k| { 2458| 263| case PT_ANY: ------------------ | | 1275| 263|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (2458:9): [True: 263, False: 351k] ------------------ 2459| 263| if (notmatch) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 263| {\ | | 555| 263| rrc = ra;\ | | 556| 263| goto RETURN_SWITCH;\ | | 557| 263| } ------------------ | Branch (2459:13): [True: 263, False: 0] ------------------ 2460| 0| break; 2461| | 2462| 1.65k| case PT_LAMP: ------------------ | | 1276| 1.65k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (2462:9): [True: 1.65k, False: 350k] ------------------ 2463| 1.65k| if ((prop->chartype == ucp_Lu || ------------------ | Branch (2463:13): [True: 882, False: 771] | Branch (2463:14): [True: 349, False: 1.30k] ------------------ 2464| 1.65k| prop->chartype == ucp_Ll || ------------------ | Branch (2464:14): [True: 412, False: 892] ------------------ 2465| 1.65k| prop->chartype == ucp_Lt) == notmatch) ------------------ | Branch (2465:14): [True: 0, False: 892] ------------------ 2466| 882| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 882| {\ | | 555| 882| rrc = ra;\ | | 556| 882| goto RETURN_SWITCH;\ | | 557| 882| } ------------------ 2467| 771| break; 2468| | 2469| 13.9k| case PT_GC: ------------------ | | 1277| 13.9k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (2469:9): [True: 13.9k, False: 337k] ------------------ 2470| 13.9k| if ((Fecode[2] == PRIV(ucp_gentype)[prop->chartype]) == notmatch) ------------------ | | 176| 13.9k|#define Fecode F->ecode ------------------ if ((Fecode[2] == PRIV(ucp_gentype)[prop->chartype]) == notmatch) ------------------ | | 177| 13.9k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2470:13): [True: 4.56k, False: 9.42k] ------------------ 2471| 9.42k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.56k| {\ | | 555| 4.56k| rrc = ra;\ | | 556| 4.56k| goto RETURN_SWITCH;\ | | 557| 4.56k| } ------------------ 2472| 9.42k| break; 2473| | 2474| 58.7k| case PT_PC: ------------------ | | 1278| 58.7k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (2474:9): [True: 58.7k, False: 292k] ------------------ 2475| 58.7k| if ((Fecode[2] == prop->chartype) == notmatch) ------------------ | | 176| 58.7k|#define Fecode F->ecode ------------------ | Branch (2475:13): [True: 11.0k, False: 47.7k] ------------------ 2476| 47.7k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 11.0k| {\ | | 555| 11.0k| rrc = ra;\ | | 556| 11.0k| goto RETURN_SWITCH;\ | | 557| 11.0k| } ------------------ 2477| 47.7k| break; 2478| | 2479| 11.8k| case PT_SC: ------------------ | | 1279| 11.8k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (2479:9): [True: 11.8k, False: 339k] ------------------ 2480| 11.8k| if ((Fecode[2] == prop->script) == notmatch) ------------------ | | 176| 11.8k|#define Fecode F->ecode ------------------ | Branch (2480:13): [True: 1.29k, False: 10.5k] ------------------ 2481| 10.5k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.29k| {\ | | 555| 1.29k| rrc = ra;\ | | 556| 1.29k| goto RETURN_SWITCH;\ | | 557| 1.29k| } ------------------ 2482| 10.5k| break; 2483| | 2484| 1.64k| case PT_SCX: ------------------ | | 1280| 1.64k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (2484:9): [True: 1.64k, False: 350k] ------------------ 2485| 1.64k| { 2486| 1.64k| BOOL ok = (Fecode[2] == prop->script || ------------------ | | 176| 1.64k|#define Fecode F->ecode ------------------ | Branch (2486:22): [True: 226, False: 1.41k] ------------------ 2487| 1.64k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Fecode[2]) != 0); ------------------ | | 1871| 1.41k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (2487:22): [True: 0, False: 1.41k] ------------------ 2488| 1.64k| if (ok == notmatch) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 533| {\ | | 555| 533| rrc = ra;\ | | 556| 533| goto RETURN_SWITCH;\ | | 557| 533| } ------------------ | Branch (2488:15): [True: 533, False: 1.11k] ------------------ 2489| 1.11k| } 2490| 0| break; 2491| | 2492| | /* These are specials */ 2493| | 2494| 1.10k| case PT_ALNUM: ------------------ | | 1281| 1.10k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (2494:9): [True: 1.10k, False: 350k] ------------------ 2495| 1.10k| if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 1.10k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2495:13): [True: 581, False: 521] | Branch (2495:14): [True: 455, False: 647] ------------------ 2496| 1.10k| PRIV(ucp_gentype)[prop->chartype] == ucp_N) == notmatch) ------------------ | | 177| 647|#define PRIV(name) _pcre2_##name ------------------ | Branch (2496:14): [True: 39, False: 608] ------------------ 2497| 581| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 581| {\ | | 555| 581| rrc = ra;\ | | 556| 581| goto RETURN_SWITCH;\ | | 557| 581| } ------------------ 2498| 521| break; 2499| | 2500| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 2501| | which means that Perl space and POSIX space are now identical. PCRE 2502| | was changed at release 8.34. */ 2503| | 2504| 99.1k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 99.1k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (2504:9): [True: 99.1k, False: 252k] ------------------ 2505| 99.5k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 99.5k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (2505:9): [True: 391, False: 351k] ------------------ 2506| 99.5k| switch(fc) 2507| 99.5k| { 2508| 92.9k| HSPACE_CASES: ------------------ | | 412| 1.53k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 455| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 455|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 455, False: 99.1k] | | | | ------------------ | | | | 408| 1.20k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.20k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 752, False: 98.8k] | | | | ------------------ | | | | 409| 1.53k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 2.20k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 2.20k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 661, False: 98.9k] | | | | ------------------ | | | | 390| 2.57k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 378, False: 99.1k] | | | | ------------------ | | | | 391| 3.03k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 454, False: 99.1k] | | | | ------------------ | | | | 392| 3.41k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 378, False: 99.1k] | | | | ------------------ | | | | 393| 3.81k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 400, False: 99.1k] | | | | ------------------ | | | | 394| 4.29k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 481, False: 99.0k] | | | | ------------------ | | | | 395| 4.77k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 487, False: 99.0k] | | | | ------------------ | | | | 396| 5.29k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 516, False: 99.0k] | | | | ------------------ | | | | 397| 5.72k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 426, False: 99.1k] | | | | ------------------ | | | | 398| 6.16k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 444, False: 99.1k] | | | | ------------------ | | | | 399| 6.89k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 730, False: 98.8k] | | | | ------------------ | | | | 400| 7.37k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 484, False: 99.0k] | | | | ------------------ | | | | 401| 7.90k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 526, False: 99.0k] | | | | ------------------ | | | | 402| 8.27k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 366, False: 99.1k] | | | | ------------------ | | | | 403| 8.73k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 468, False: 99.0k] | | | | ------------------ | | | | 404| 9.26k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 2509| 92.9k| VSPACE_CASES: ------------------ | | 430| 11.9k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 9.75k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 9.75k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 482, False: 99.0k] | | | | ------------------ | | | | 424| 10.2k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 10.2k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 490, False: 99.0k] | | | | ------------------ | | | | 425| 10.8k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 10.8k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 571, False: 98.9k] | | | | ------------------ | | | | 426| 11.4k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 11.4k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 636, False: 98.9k] | | | | ------------------ | | | | 427| 11.9k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 9.26k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 12.2k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 12.2k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 342, False: 99.2k] | | | | ------------------ | | | | 420| 12.6k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 2510| 79.1k| if (notmatch) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.97k| {\ | | 555| 4.97k| rrc = ra;\ | | 556| 4.97k| goto RETURN_SWITCH;\ | | 557| 4.97k| } ------------------ | Branch (2510:15): [True: 4.97k, False: 7.71k] ------------------ 2511| 7.71k| break; 2512| | 2513| 86.8k| default: ------------------ | Branch (2513:11): [True: 86.8k, False: 12.6k] ------------------ 2514| 86.8k| if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == notmatch) ------------------ | | 177| 86.8k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2514:15): [True: 55.2k, False: 31.6k] ------------------ 2515| 55.2k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 55.2k| {\ | | 555| 55.2k| rrc = ra;\ | | 556| 55.2k| goto RETURN_SWITCH;\ | | 557| 55.2k| } ------------------ 2516| 31.6k| break; 2517| 99.5k| } 2518| 39.3k| break; 2519| | 2520| 39.3k| case PT_WORD: ------------------ | | 1284| 21.4k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (2520:9): [True: 21.4k, False: 330k] ------------------ 2521| 21.4k| if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 21.4k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2521:13): [True: 9.71k, False: 11.6k] | Branch (2521:14): [True: 5.13k, False: 16.2k] ------------------ 2522| 21.4k| PRIV(ucp_gentype)[prop->chartype] == ucp_N || ------------------ | | 177| 16.2k|#define PRIV(name) _pcre2_##name ------------------ | Branch (2522:14): [True: 1.07k, False: 15.2k] ------------------ 2523| 21.4k| fc == CHAR_UNDERSCORE) == notmatch) ------------------ | | 1045| 15.2k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (2523:14): [True: 10, False: 15.2k] ------------------ 2524| 11.6k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 9.71k| {\ | | 555| 9.71k| rrc = ra;\ | | 556| 9.71k| goto RETURN_SWITCH;\ | | 557| 9.71k| } ------------------ 2525| 11.6k| break; 2526| | 2527| 42.2k| case PT_CLIST: ------------------ | | 1285| 42.2k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (2527:9): [True: 42.2k, False: 309k] ------------------ 2528| 42.2k| cp = PRIV(ucd_caseless_sets) + Fecode[2]; ------------------ | | 177| 42.2k|#define PRIV(name) _pcre2_##name ------------------ cp = PRIV(ucd_caseless_sets) + Fecode[2]; ------------------ | | 176| 42.2k|#define Fecode F->ecode ------------------ 2529| 42.2k| for (;;) 2530| 67.7k| { 2531| 67.7k| if (fc < *cp) ------------------ | Branch (2531:15): [True: 24.1k, False: 43.6k] ------------------ 2532| 24.1k| { if (notmatch) break; else { RRETURN(MATCH_NOMATCH); } } ------------------ | | 554| 21.6k| {\ | | 555| 21.6k| rrc = ra;\ | | 556| 21.6k| goto RETURN_SWITCH;\ | | 557| 21.6k| } ------------------ | Branch (2532:19): [True: 2.53k, False: 21.6k] ------------------ 2533| 43.6k| if (fc == *cp++) ------------------ | Branch (2533:15): [True: 18.0k, False: 25.5k] ------------------ 2534| 18.0k| { if (notmatch) { RRETURN(MATCH_NOMATCH); } else break; } ------------------ | | 554| 986| {\ | | 555| 986| rrc = ra;\ | | 556| 986| goto RETURN_SWITCH;\ | | 557| 986| } ------------------ | Branch (2534:19): [True: 986, False: 17.1k] ------------------ 2535| 43.6k| } 2536| 19.6k| break; 2537| | 2538| 19.6k| case PT_UCNC: ------------------ | | 1286| 9.52k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (2538:9): [True: 9.52k, False: 342k] ------------------ 2539| 9.52k| if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 986| 19.0k|#define CHAR_DOLLAR_SIGN '\044' ------------------ if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 18.5k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (2539:13): [True: 4.02k, False: 5.50k] | Branch (2539:14): [True: 551, False: 8.97k] | Branch (2539:40): [True: 276, False: 8.69k] ------------------ 2540| 9.52k| fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) || ------------------ | | 1046| 18.2k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (2540:14): [True: 250, False: 8.44k] | Branch (2540:42): [True: 1.24k, False: 7.20k] | Branch (2540:56): [True: 979, False: 270] ------------------ 2541| 9.52k| fc >= 0xe000) == notmatch) ------------------ | Branch (2541:14): [True: 270, False: 7.20k] ------------------ 2542| 5.50k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.02k| {\ | | 555| 4.02k| rrc = ra;\ | | 556| 4.02k| goto RETURN_SWITCH;\ | | 557| 4.02k| } ------------------ 2543| 5.50k| break; 2544| | 2545| 2.50k| case PT_BIDICL: ------------------ | | 1287| 2.50k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (2545:9): [True: 2.50k, False: 349k] ------------------ 2546| 2.50k| if ((UCD_BIDICLASS_PROP(prop) == Fecode[2]) == notmatch) ------------------ | | 1854| 2.50k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | ------------------ | | | | 1850| 2.50k|#define UCD_BIDICLASS_SHIFT 11 | | ------------------ ------------------ if ((UCD_BIDICLASS_PROP(prop) == Fecode[2]) == notmatch) ------------------ | | 176| 2.50k|#define Fecode F->ecode ------------------ | Branch (2546:13): [True: 445, False: 2.05k] ------------------ 2547| 2.05k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 445| {\ | | 555| 445| rrc = ra;\ | | 556| 445| goto RETURN_SWITCH;\ | | 557| 445| } ------------------ 2548| 2.05k| break; 2549| | 2550| 87.2k| case PT_BOOL: ------------------ | | 1288| 87.2k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (2550:9): [True: 87.2k, False: 264k] ------------------ 2551| 87.2k| { 2552| 87.2k| BOOL ok = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 87.2k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 2553| 87.2k| UCD_BPROPS_PROP(prop), Fecode[2]) != 0; 2554| 87.2k| if (ok == notmatch) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 445| {\ | | 555| 445| rrc = ra;\ | | 556| 445| goto RETURN_SWITCH;\ | | 557| 445| } ------------------ | Branch (2554:15): [True: 445, False: 86.7k] ------------------ 2555| 86.7k| } 2556| 0| break; 2557| | 2558| | /* This should never occur */ 2559| | 2560| 0| default: ------------------ | Branch (2560:9): [True: 0, False: 351k] ------------------ 2561| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 2562| 351k| } 2563| | 2564| 235k| Fecode += 3; ------------------ | | 176| 235k|#define Fecode F->ecode ------------------ 2565| 235k| } 2566| 0| break; 2567| | 2568| | 2569| | /* ===================================================================== */ 2570| | /* Match an extended Unicode sequence. We will get here only if the support 2571| | is in the binary; otherwise a compile-time error occurs. */ 2572| | 2573| 22.1k| case OP_EXTUNI: ------------------ | Branch (2573:5): [True: 22.1k, False: 2.33G] ------------------ 2574| 22.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 22.1k|#define Feptr F->eptr ------------------ | Branch (2574:9): [True: 4.36k, False: 17.7k] ------------------ 2575| 4.36k| { 2576| 4.36k| SCHECK_PARTIAL(); ------------------ | | 533| 4.36k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.08k, False: 3.28k] | | ------------------ | | 534| 4.36k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.08k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 461, False: 619] | | | Branch (534:38): [True: 357, False: 262] | | ------------------ | | 535| 4.36k| { \ | | 536| 818| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 818|#define TRUE 1 | | ------------------ | | 537| 818| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 815] | | ------------------ | | 538| 818| } ------------------ 2577| 4.36k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.36k| {\ | | 555| 4.36k| rrc = ra;\ | | 556| 4.36k| goto RETURN_SWITCH;\ | | 557| 4.36k| } ------------------ 2578| 0| } 2579| 17.7k| else 2580| 17.7k| { 2581| 17.7k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 17.7k| c = *eptr++; \ | | 324| 17.7k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.73k| { \ | | | | 289| 1.73k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 325, False: 1.41k] | | | | ------------------ | | | | 290| 1.73k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.73k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 390, False: 1.02k] | | | | ------------------ | | | | 292| 1.41k| { \ | | | | 293| 390| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 390| eptr += 2; \ | | | | 295| 390| } \ | | | | 296| 1.41k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 1.02k, False: 0] | | | | ------------------ | | | | 297| 1.02k| { \ | | | | 298| 1.02k| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 1.02k| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 1.02k| eptr += 3; \ | | | | 301| 1.02k| } \ | | | | 302| 1.02k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.73k| } | | ------------------ | | | Branch (324:7): [True: 9.40k, False: 8.34k] | | | Branch (324:14): [True: 1.73k, False: 7.66k] | | ------------------ ------------------ 2582| 17.7k| Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, utf, ------------------ | | 177| 17.7k|#define Feptr F->eptr ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, utf, ------------------ | | 177| 17.7k|#define PRIV(name) _pcre2_##name ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, utf, ------------------ | | 177| 17.7k|#define Feptr F->eptr ------------------ 2583| 17.7k| NULL); 2584| 17.7k| } 2585| 17.7k| CHECK_PARTIAL(); ------------------ | | 527| 17.7k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 17.7k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 2.98k, False: 14.7k] | | ------------------ | | 528| 17.7k| { \ | | 529| 2.98k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 2.98k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 326, False: 2.65k] | | | | ------------------ | | | | 534| 2.98k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 326|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 326, False: 0] | | | | | Branch (534:38): [True: 0, False: 0] | | | | ------------------ | | | | 535| 2.98k| { \ | | | | 536| 326| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 326|#define TRUE 1 | | | | ------------------ | | | | 537| 326| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 25|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 25, False: 301] | | | | ------------------ | | | | 538| 326| } | | ------------------ | | 530| 2.95k| } ------------------ 2586| 17.7k| Fecode++; ------------------ | | 176| 17.7k|#define Fecode F->ecode ------------------ 2587| 17.7k| break; 2588| | 2589| 0|#endif /* SUPPORT_UNICODE */ 2590| | 2591| | 2592| | /* ===================================================================== */ 2593| | /* Match a single character type repeatedly. Note that the property type 2594| | does not need to be in a stack frame as it is not used within an RMATCH() 2595| | loop. */ 2596| | 2597| 0|#define Lstart_eptr F->temp_sptr[0] 2598| 0|#define Lmin F->temp_32[0] 2599| 0|#define Lmax F->temp_32[1] 2600| 0|#define Lctype F->temp_32[2] 2601| 0|#define Lpropvalue F->temp_32[3] 2602| | 2603| 195k| case OP_TYPEEXACT: ------------------ | Branch (2603:5): [True: 195k, False: 2.33G] ------------------ 2604| 195k| Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 2598| 195k|#define Lmin F->temp_32[0] ------------------ Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 2599| 195k|#define Lmax F->temp_32[1] ------------------ Lmin = Lmax = GET2(Fecode, 1); ------------------ | | 194| 195k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2605| 195k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 195k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 195k|#define IMM2_SIZE 2 ------------------ 2606| 195k| goto REPEATTYPE; 2607| | 2608| 9.93k| case OP_TYPEUPTO: ------------------ | Branch (2608:5): [True: 9.93k, False: 2.33G] ------------------ 2609| 14.7k| case OP_TYPEMINUPTO: ------------------ | Branch (2609:5): [True: 4.80k, False: 2.33G] ------------------ 2610| 14.7k| Lmin = 0; ------------------ | | 2598| 14.7k|#define Lmin F->temp_32[0] ------------------ 2611| 14.7k| Lmax = GET2(Fecode, 1); ------------------ | | 2599| 14.7k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 14.7k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2612| 14.7k| reptype = (*Fecode == OP_TYPEMINUPTO)? REPTYPE_MIN : REPTYPE_MAX; ------------------ | | 176| 14.7k|#define Fecode F->ecode ------------------ | Branch (2612:15): [True: 4.80k, False: 9.93k] ------------------ 2613| 14.7k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 14.7k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 14.7k|#define IMM2_SIZE 2 ------------------ 2614| 14.7k| goto REPEATTYPE; 2615| | 2616| 95.9k| case OP_TYPEPOSSTAR: ------------------ | Branch (2616:5): [True: 95.9k, False: 2.33G] ------------------ 2617| 95.9k| reptype = REPTYPE_POS; 2618| 95.9k| Lmin = 0; ------------------ | | 2598| 95.9k|#define Lmin F->temp_32[0] ------------------ 2619| 95.9k| Lmax = UINT32_MAX; ------------------ | | 2599| 95.9k|#define Lmax F->temp_32[1] ------------------ 2620| 95.9k| Fecode++; ------------------ | | 176| 95.9k|#define Fecode F->ecode ------------------ 2621| 95.9k| goto REPEATTYPE; 2622| | 2623| 292k| case OP_TYPEPOSPLUS: ------------------ | Branch (2623:5): [True: 292k, False: 2.33G] ------------------ 2624| 292k| reptype = REPTYPE_POS; 2625| 292k| Lmin = 1; ------------------ | | 2598| 292k|#define Lmin F->temp_32[0] ------------------ 2626| 292k| Lmax = UINT32_MAX; ------------------ | | 2599| 292k|#define Lmax F->temp_32[1] ------------------ 2627| 292k| Fecode++; ------------------ | | 176| 292k|#define Fecode F->ecode ------------------ 2628| 292k| goto REPEATTYPE; 2629| | 2630| 77.6k| case OP_TYPEPOSQUERY: ------------------ | Branch (2630:5): [True: 77.6k, False: 2.33G] ------------------ 2631| 77.6k| reptype = REPTYPE_POS; 2632| 77.6k| Lmin = 0; ------------------ | | 2598| 77.6k|#define Lmin F->temp_32[0] ------------------ 2633| 77.6k| Lmax = 1; ------------------ | | 2599| 77.6k|#define Lmax F->temp_32[1] ------------------ 2634| 77.6k| Fecode++; ------------------ | | 176| 77.6k|#define Fecode F->ecode ------------------ 2635| 77.6k| goto REPEATTYPE; 2636| | 2637| 5.90k| case OP_TYPEPOSUPTO: ------------------ | Branch (2637:5): [True: 5.90k, False: 2.33G] ------------------ 2638| 5.90k| reptype = REPTYPE_POS; 2639| 5.90k| Lmin = 0; ------------------ | | 2598| 5.90k|#define Lmin F->temp_32[0] ------------------ 2640| 5.90k| Lmax = GET2(Fecode, 1); ------------------ | | 2599| 5.90k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1); ------------------ | | 194| 5.90k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 2641| 5.90k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 5.90k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 5.90k|#define IMM2_SIZE 2 ------------------ 2642| 5.90k| goto REPEATTYPE; 2643| | 2644| 631k| case OP_TYPESTAR: ------------------ | Branch (2644:5): [True: 631k, False: 2.33G] ------------------ 2645| 748k| case OP_TYPEMINSTAR: ------------------ | Branch (2645:5): [True: 117k, False: 2.33G] ------------------ 2646| 1.22M| case OP_TYPEPLUS: ------------------ | Branch (2646:5): [True: 475k, False: 2.33G] ------------------ 2647| 1.35M| case OP_TYPEMINPLUS: ------------------ | Branch (2647:5): [True: 131k, False: 2.33G] ------------------ 2648| 2.96M| case OP_TYPEQUERY: ------------------ | Branch (2648:5): [True: 1.61M, False: 2.33G] ------------------ 2649| 3.22M| case OP_TYPEMINQUERY: ------------------ | Branch (2649:5): [True: 253k, False: 2.33G] ------------------ 2650| 3.22M| fc = *Fecode++ - OP_TYPESTAR; ------------------ | | 176| 3.22M|#define Fecode F->ecode ------------------ 2651| 3.22M| Lmin = rep_min[fc]; ------------------ | | 2598| 3.22M|#define Lmin F->temp_32[0] ------------------ 2652| 3.22M| Lmax = rep_max[fc]; ------------------ | | 2599| 3.22M|#define Lmax F->temp_32[1] ------------------ 2653| 3.22M| reptype = rep_typ[fc]; 2654| | 2655| | /* Common code for all repeated character type matches. */ 2656| | 2657| 3.90M| REPEATTYPE: 2658| 3.90M| Lctype = *Fecode++; /* Code for the character type */ ------------------ | | 2600| 3.90M|#define Lctype F->temp_32[2] ------------------ Lctype = *Fecode++; /* Code for the character type */ ------------------ | | 176| 3.90M|#define Fecode F->ecode ------------------ 2659| | 2660| 3.90M|#ifdef SUPPORT_UNICODE 2661| 3.90M| if (Lctype == OP_PROP || Lctype == OP_NOTPROP) ------------------ | | 2600| 3.90M|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_PROP || Lctype == OP_NOTPROP) ------------------ | | 2600| 3.28M|#define Lctype F->temp_32[2] ------------------ | Branch (2661:9): [True: 618k, False: 3.28M] | Branch (2661:30): [True: 947k, False: 2.33M] ------------------ 2662| 1.56M| { 2663| 1.56M| proptype = *Fecode++; ------------------ | | 176| 1.56M|#define Fecode F->ecode ------------------ 2664| 1.56M| Lpropvalue = *Fecode++; ------------------ | | 2601| 1.56M|#define Lpropvalue F->temp_32[3] ------------------ Lpropvalue = *Fecode++; ------------------ | | 176| 1.56M|#define Fecode F->ecode ------------------ 2665| 1.56M| } 2666| 2.33M| else proptype = -1; 2667| 3.90M|#endif 2668| | 2669| | /* First, ensure the minimum number of matches are present. Use inline 2670| | code for maximizing the speed, and do the type test once at the start 2671| | (i.e. keep it out of the loops). As there are no calls to RMATCH in the 2672| | loops, we can use an ordinary variable for "notmatch". The code for UTF 2673| | mode is separated out for tidiness, except for Unicode property tests. */ 2674| | 2675| 3.90M| if (Lmin > 0) ------------------ | | 2598| 3.90M|#define Lmin F->temp_32[0] ------------------ | Branch (2675:9): [True: 1.09M, False: 2.80M] ------------------ 2676| 1.09M| { 2677| 1.09M|#ifdef SUPPORT_UNICODE 2678| 1.09M| if (proptype >= 0) /* Property tests in all modes */ ------------------ | Branch (2678:11): [True: 384k, False: 710k] ------------------ 2679| 384k| { 2680| 384k| BOOL notmatch = Lctype == OP_NOTPROP; ------------------ | | 2600| 384k|#define Lctype F->temp_32[2] ------------------ 2681| 384k| switch(proptype) 2682| 384k| { 2683| 724| case PT_ANY: ------------------ | | 1275| 724|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (2683:11): [True: 724, False: 383k] ------------------ 2684| 724| if (notmatch) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 724| {\ | | 555| 724| rrc = ra;\ | | 556| 724| goto RETURN_SWITCH;\ | | 557| 724| } ------------------ | Branch (2684:15): [True: 724, False: 0] ------------------ 2685| 0| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 0|#define Lmin F->temp_32[0] ------------------ | Branch (2685:23): [True: 0, False: 0] ------------------ 2686| 0| { 2687| 0| if (Feptr >= mb->end_subject) ------------------ | | 177| 0|#define Feptr F->eptr ------------------ | Branch (2687:17): [True: 0, False: 0] ------------------ 2688| 0| { 2689| 0| SCHECK_PARTIAL(); ------------------ | | 533| 0| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 0, False: 0] | | ------------------ | | 534| 0| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 0|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 0, False: 0] | | | Branch (534:38): [True: 0, False: 0] | | ------------------ | | 535| 0| { \ | | 536| 0| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 0|#define TRUE 1 | | ------------------ | | 537| 0| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 0|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 0, False: 0] | | ------------------ | | 538| 0| } ------------------ 2690| 0| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ 2691| 0| } 2692| 0| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 0| c = *eptr++; \ | | 324| 0| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 0| { \ | | | | 289| 0| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 0, False: 0] | | | | ------------------ | | | | 290| 0| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 0| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 0, False: 0] | | | | ------------------ | | | | 292| 0| { \ | | | | 293| 0| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 0| eptr += 2; \ | | | | 295| 0| } \ | | | | 296| 0| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 0, False: 0] | | | | ------------------ | | | | 297| 0| { \ | | | | 298| 0| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 0| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 0| eptr += 3; \ | | | | 301| 0| } \ | | | | 302| 0| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 0| } | | ------------------ | | | Branch (324:7): [True: 0, False: 0] | | | Branch (324:14): [True: 0, False: 0] | | ------------------ ------------------ 2693| 0| } 2694| 0| break; 2695| | 2696| 17.7k| case PT_LAMP: ------------------ | | 1276| 17.7k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (2696:11): [True: 17.7k, False: 366k] ------------------ 2697| 30.6k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 30.6k|#define Lmin F->temp_32[0] ------------------ | Branch (2697:23): [True: 21.3k, False: 9.25k] ------------------ 2698| 21.3k| { 2699| 21.3k| int chartype; 2700| 21.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 21.3k|#define Feptr F->eptr ------------------ | Branch (2700:17): [True: 2.86k, False: 18.5k] ------------------ 2701| 2.86k| { 2702| 2.86k| SCHECK_PARTIAL(); ------------------ | | 533| 2.86k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 930, False: 1.93k] | | ------------------ | | 534| 2.86k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 930|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 381, False: 549] | | | Branch (534:38): [True: 233, False: 316] | | ------------------ | | 535| 2.86k| { \ | | 536| 614| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 614|#define TRUE 1 | | ------------------ | | 537| 614| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 7|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 7, False: 607] | | ------------------ | | 538| 614| } ------------------ 2703| 2.85k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.85k| {\ | | 555| 2.85k| rrc = ra;\ | | 556| 2.85k| goto RETURN_SWITCH;\ | | 557| 2.85k| } ------------------ 2704| 0| } 2705| 18.5k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 18.5k| c = *eptr++; \ | | 324| 18.5k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 964| { \ | | | | 289| 964| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 354, False: 610] | | | | ------------------ | | | | 290| 964| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 964| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 287, False: 323] | | | | ------------------ | | | | 292| 610| { \ | | | | 293| 287| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 287| eptr += 2; \ | | | | 295| 287| } \ | | | | 296| 610| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 323, False: 0] | | | | ------------------ | | | | 297| 323| { \ | | | | 298| 323| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 323| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 323| eptr += 3; \ | | | | 301| 323| } \ | | | | 302| 323| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 964| } | | ------------------ | | | Branch (324:7): [True: 5.86k, False: 12.6k] | | | Branch (324:14): [True: 964, False: 4.90k] | | ------------------ ------------------ 2706| 18.5k| chartype = UCD_CHARTYPE(fc); ------------------ | | 1857| 18.5k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 18.5k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 18.5k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 18.5k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 18.5k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 18.5k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 18.5k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 18.5k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 18.5k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 18.5k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 18.5k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2707| 18.5k| if ((chartype == ucp_Lu || ------------------ | Branch (2707:17): [True: 5.58k, False: 12.9k] | Branch (2707:18): [True: 2.59k, False: 15.9k] ------------------ 2708| 18.5k| chartype == ucp_Ll || ------------------ | Branch (2708:18): [True: 2.01k, False: 13.8k] ------------------ 2709| 18.5k| chartype == ucp_Lt) == notmatch) ------------------ | Branch (2709:18): [True: 0, False: 13.8k] ------------------ 2710| 12.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.58k| {\ | | 555| 5.58k| rrc = ra;\ | | 556| 5.58k| goto RETURN_SWITCH;\ | | 557| 5.58k| } ------------------ 2711| 12.9k| } 2712| 9.25k| break; 2713| | 2714| 16.3k| case PT_GC: ------------------ | | 1277| 16.3k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (2714:11): [True: 16.3k, False: 367k] ------------------ 2715| 28.2k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 28.2k|#define Lmin F->temp_32[0] ------------------ | Branch (2715:23): [True: 21.7k, False: 6.49k] ------------------ 2716| 21.7k| { 2717| 21.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 21.7k|#define Feptr F->eptr ------------------ | Branch (2717:17): [True: 3.90k, False: 17.8k] ------------------ 2718| 3.90k| { 2719| 3.90k| SCHECK_PARTIAL(); ------------------ | | 533| 3.90k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 869, False: 3.03k] | | ------------------ | | 534| 3.90k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 869|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 372, False: 497] | | | Branch (534:38): [True: 243, False: 254] | | ------------------ | | 535| 3.90k| { \ | | 536| 615| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 615|#define TRUE 1 | | ------------------ | | 537| 615| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 11|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 11, False: 604] | | ------------------ | | 538| 615| } ------------------ 2720| 3.89k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.89k| {\ | | 555| 3.89k| rrc = ra;\ | | 556| 3.89k| goto RETURN_SWITCH;\ | | 557| 3.89k| } ------------------ 2721| 0| } 2722| 17.8k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 17.8k| c = *eptr++; \ | | 324| 17.8k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 817| { \ | | | | 289| 817| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 272, False: 545] | | | | ------------------ | | | | 290| 817| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 817| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 284, False: 261] | | | | ------------------ | | | | 292| 545| { \ | | | | 293| 284| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 284| eptr += 2; \ | | | | 295| 284| } \ | | | | 296| 545| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 261, False: 0] | | | | ------------------ | | | | 297| 261| { \ | | | | 298| 261| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 261| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 261| eptr += 3; \ | | | | 301| 261| } \ | | | | 302| 261| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 817| } | | ------------------ | | | Branch (324:7): [True: 8.24k, False: 9.62k] | | | Branch (324:14): [True: 817, False: 7.43k] | | ------------------ ------------------ 2723| 17.8k| if ((UCD_CATEGORY(fc) == Lpropvalue) == notmatch) ------------------ | | 1859| 17.8k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 17.8k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 17.8k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 17.8k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 17.8k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 17.8k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 17.8k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 17.8k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 17.8k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 17.8k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 17.8k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 17.8k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 17.8k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_CATEGORY(fc) == Lpropvalue) == notmatch) ------------------ | | 2601| 17.8k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (2723:17): [True: 5.92k, False: 11.9k] ------------------ 2724| 11.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.92k| {\ | | 555| 5.92k| rrc = ra;\ | | 556| 5.92k| goto RETURN_SWITCH;\ | | 557| 5.92k| } ------------------ 2725| 11.9k| } 2726| 6.49k| break; 2727| | 2728| 12.5k| case PT_PC: ------------------ | | 1278| 12.5k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (2728:11): [True: 12.5k, False: 371k] ------------------ 2729| 18.4k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 18.4k|#define Lmin F->temp_32[0] ------------------ | Branch (2729:23): [True: 14.9k, False: 3.49k] ------------------ 2730| 14.9k| { 2731| 14.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 14.9k|#define Feptr F->eptr ------------------ | Branch (2731:17): [True: 3.17k, False: 11.7k] ------------------ 2732| 3.17k| { 2733| 3.17k| SCHECK_PARTIAL(); ------------------ | | 533| 3.17k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 762, False: 2.41k] | | ------------------ | | 534| 3.17k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 762|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 302, False: 460] | | | Branch (534:38): [True: 221, False: 239] | | ------------------ | | 535| 3.17k| { \ | | 536| 523| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 523|#define TRUE 1 | | ------------------ | | 537| 523| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 7|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 7, False: 516] | | ------------------ | | 538| 523| } ------------------ 2734| 3.16k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.16k| {\ | | 555| 3.16k| rrc = ra;\ | | 556| 3.16k| goto RETURN_SWITCH;\ | | 557| 3.16k| } ------------------ 2735| 0| } 2736| 11.7k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 11.7k| c = *eptr++; \ | | 324| 11.7k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 850| { \ | | | | 289| 850| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 210, False: 640] | | | | ------------------ | | | | 290| 850| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 850| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 325, False: 315] | | | | ------------------ | | | | 292| 640| { \ | | | | 293| 325| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 325| eptr += 2; \ | | | | 295| 325| } \ | | | | 296| 640| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 315, False: 0] | | | | ------------------ | | | | 297| 315| { \ | | | | 298| 315| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 315| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 315| eptr += 3; \ | | | | 301| 315| } \ | | | | 302| 315| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 850| } | | ------------------ | | | Branch (324:7): [True: 9.61k, False: 2.13k] | | | Branch (324:14): [True: 850, False: 8.76k] | | ------------------ ------------------ 2737| 11.7k| if ((UCD_CHARTYPE(fc) == Lpropvalue) == notmatch) ------------------ | | 1857| 11.7k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 11.7k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 11.7k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 11.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 11.7k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 11.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 11.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 11.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 11.7k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 11.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 11.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_CHARTYPE(fc) == Lpropvalue) == notmatch) ------------------ | | 2601| 11.7k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (2737:17): [True: 5.87k, False: 5.86k] ------------------ 2738| 5.87k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.87k| {\ | | 555| 5.87k| rrc = ra;\ | | 556| 5.87k| goto RETURN_SWITCH;\ | | 557| 5.87k| } ------------------ 2739| 5.86k| } 2740| 3.49k| break; 2741| | 2742| 17.1k| case PT_SC: ------------------ | | 1279| 17.1k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (2742:11): [True: 17.1k, False: 367k] ------------------ 2743| 29.4k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 29.4k|#define Lmin F->temp_32[0] ------------------ | Branch (2743:23): [True: 24.5k, False: 4.87k] ------------------ 2744| 24.5k| { 2745| 24.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 24.5k|#define Feptr F->eptr ------------------ | Branch (2745:17): [True: 2.49k, False: 22.0k] ------------------ 2746| 2.49k| { 2747| 2.49k| SCHECK_PARTIAL(); ------------------ | | 533| 2.49k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 790, False: 1.70k] | | ------------------ | | 534| 2.49k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 790|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 227, False: 563] | | | Branch (534:38): [True: 266, False: 297] | | ------------------ | | 535| 2.49k| { \ | | 536| 493| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 493|#define TRUE 1 | | ------------------ | | 537| 493| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 8|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 8, False: 485] | | ------------------ | | 538| 493| } ------------------ 2748| 2.49k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.49k| {\ | | 555| 2.49k| rrc = ra;\ | | 556| 2.49k| goto RETURN_SWITCH;\ | | 557| 2.49k| } ------------------ 2749| 0| } 2750| 22.0k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 22.0k| c = *eptr++; \ | | 324| 22.0k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 895| { \ | | | | 289| 895| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 344, False: 551] | | | | ------------------ | | | | 290| 895| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 895| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 282, False: 269] | | | | ------------------ | | | | 292| 551| { \ | | | | 293| 282| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 282| eptr += 2; \ | | | | 295| 282| } \ | | | | 296| 551| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 269, False: 0] | | | | ------------------ | | | | 297| 269| { \ | | | | 298| 269| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 269| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 269| eptr += 3; \ | | | | 301| 269| } \ | | | | 302| 269| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 895| } | | ------------------ | | | Branch (324:7): [True: 9.13k, False: 12.9k] | | | Branch (324:14): [True: 895, False: 8.23k] | | ------------------ ------------------ 2751| 22.0k| if ((UCD_SCRIPT(fc) == Lpropvalue) == notmatch) ------------------ | | 1858| 22.0k|#define UCD_SCRIPT(ch) GET_UCD(ch)->script | | ------------------ | | | | 1846| 22.0k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 22.0k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 22.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 22.0k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 22.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 22.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 22.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 22.0k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 22.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 22.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_SCRIPT(fc) == Lpropvalue) == notmatch) ------------------ | | 2601| 22.0k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (2751:17): [True: 9.75k, False: 12.2k] ------------------ 2752| 12.2k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 9.75k| {\ | | 555| 9.75k| rrc = ra;\ | | 556| 9.75k| goto RETURN_SWITCH;\ | | 557| 9.75k| } ------------------ 2753| 12.2k| } 2754| 4.87k| break; 2755| | 2756| 11.5k| case PT_SCX: ------------------ | | 1280| 11.5k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (2756:11): [True: 11.5k, False: 372k] ------------------ 2757| 26.8k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 26.8k|#define Lmin F->temp_32[0] ------------------ | Branch (2757:23): [True: 21.3k, False: 5.43k] ------------------ 2758| 21.3k| { 2759| 21.3k| BOOL ok; 2760| 21.3k| const ucd_record *prop; 2761| 21.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 21.3k|#define Feptr F->eptr ------------------ | Branch (2761:17): [True: 3.41k, False: 17.9k] ------------------ 2762| 3.41k| { 2763| 3.41k| SCHECK_PARTIAL(); ------------------ | | 533| 3.41k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 859, False: 2.55k] | | ------------------ | | 534| 3.41k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 859|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 351, False: 508] | | | Branch (534:38): [True: 287, False: 221] | | ------------------ | | 535| 3.41k| { \ | | 536| 638| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 638|#define TRUE 1 | | ------------------ | | 537| 638| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 632] | | ------------------ | | 538| 638| } ------------------ 2764| 3.40k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.40k| {\ | | 555| 3.40k| rrc = ra;\ | | 556| 3.40k| goto RETURN_SWITCH;\ | | 557| 3.40k| } ------------------ 2765| 0| } 2766| 17.9k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 17.9k| c = *eptr++; \ | | 324| 17.9k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 924| { \ | | | | 289| 924| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 291, False: 633] | | | | ------------------ | | | | 290| 924| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 924| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 375, False: 258] | | | | ------------------ | | | | 292| 633| { \ | | | | 293| 375| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 375| eptr += 2; \ | | | | 295| 375| } \ | | | | 296| 633| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 258, False: 0] | | | | ------------------ | | | | 297| 258| { \ | | | | 298| 258| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 258| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 258| eptr += 3; \ | | | | 301| 258| } \ | | | | 302| 258| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 924| } | | ------------------ | | | Branch (324:7): [True: 5.64k, False: 12.3k] | | | Branch (324:14): [True: 924, False: 4.71k] | | ------------------ ------------------ 2767| 17.9k| prop = GET_UCD(fc); ------------------ | | 1846| 17.9k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 17.9k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 17.9k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 17.9k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 17.9k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 17.9k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 17.9k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 17.9k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 17.9k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 17.9k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 2768| 17.9k| ok = (prop->script == Lpropvalue || ------------------ | | 2601| 35.9k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (2768:19): [True: 553, False: 17.4k] ------------------ 2769| 17.9k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Lpropvalue) != 0); ------------------ | | 1871| 17.4k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (2769:19): [True: 0, False: 17.4k] ------------------ 2770| 17.9k| if (ok == notmatch) ------------------ | Branch (2770:17): [True: 2.73k, False: 15.2k] ------------------ 2771| 15.2k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.73k| {\ | | 555| 2.73k| rrc = ra;\ | | 556| 2.73k| goto RETURN_SWITCH;\ | | 557| 2.73k| } ------------------ 2772| 15.2k| } 2773| 5.43k| break; 2774| | 2775| 18.9k| case PT_ALNUM: ------------------ | | 1281| 18.9k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (2775:11): [True: 18.9k, False: 365k] ------------------ 2776| 30.0k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 30.0k|#define Lmin F->temp_32[0] ------------------ | Branch (2776:23): [True: 22.1k, False: 7.83k] ------------------ 2777| 22.1k| { 2778| 22.1k| int category; 2779| 22.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 22.1k|#define Feptr F->eptr ------------------ | Branch (2779:17): [True: 3.03k, False: 19.1k] ------------------ 2780| 3.03k| { 2781| 3.03k| SCHECK_PARTIAL(); ------------------ | | 533| 3.03k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 733, False: 2.30k] | | ------------------ | | 534| 3.03k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 733|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 291, False: 442] | | | Branch (534:38): [True: 207, False: 235] | | ------------------ | | 535| 3.03k| { \ | | 536| 498| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 498|#define TRUE 1 | | ------------------ | | 537| 498| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 10|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 10, False: 488] | | ------------------ | | 538| 498| } ------------------ 2782| 3.02k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.02k| {\ | | 555| 3.02k| rrc = ra;\ | | 556| 3.02k| goto RETURN_SWITCH;\ | | 557| 3.02k| } ------------------ 2783| 0| } 2784| 19.1k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 19.1k| c = *eptr++; \ | | 324| 19.1k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.08k| { \ | | | | 289| 1.08k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 441, False: 647] | | | | ------------------ | | | | 290| 1.08k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.08k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 373, False: 274] | | | | ------------------ | | | | 292| 647| { \ | | | | 293| 373| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 373| eptr += 2; \ | | | | 295| 373| } \ | | | | 296| 647| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 274, False: 0] | | | | ------------------ | | | | 297| 274| { \ | | | | 298| 274| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 274| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 274| eptr += 3; \ | | | | 301| 274| } \ | | | | 302| 274| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.08k| } | | ------------------ | | | Branch (324:7): [True: 8.01k, False: 11.1k] | | | Branch (324:14): [True: 1.08k, False: 6.92k] | | ------------------ ------------------ 2785| 19.1k| category = UCD_CATEGORY(fc); ------------------ | | 1859| 19.1k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 19.1k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 19.1k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 19.1k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 19.1k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 19.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 19.1k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 19.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 19.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 19.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 19.1k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 19.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 19.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2786| 19.1k| if ((category == ucp_L || category == ucp_N) == notmatch) ------------------ | Branch (2786:17): [True: 8.09k, False: 11.0k] | Branch (2786:18): [True: 6.67k, False: 12.4k] | Branch (2786:39): [True: 983, False: 11.4k] ------------------ 2787| 11.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 8.09k| {\ | | 555| 8.09k| rrc = ra;\ | | 556| 8.09k| goto RETURN_SWITCH;\ | | 557| 8.09k| } ------------------ 2788| 11.0k| } 2789| 7.83k| break; 2790| | 2791| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 2792| | which means that Perl space and POSIX space are now identical. PCRE 2793| | was changed at release 8.34. */ 2794| | 2795| 156k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 156k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (2795:11): [True: 156k, False: 227k] ------------------ 2796| 157k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 157k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (2796:11): [True: 454, False: 383k] ------------------ 2797| 194k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 194k|#define Lmin F->temp_32[0] ------------------ | Branch (2797:23): [True: 181k, False: 12.8k] ------------------ 2798| 181k| { 2799| 181k| if (Feptr >= mb->end_subject) ------------------ | | 177| 181k|#define Feptr F->eptr ------------------ | Branch (2799:17): [True: 12.5k, False: 169k] ------------------ 2800| 12.5k| { 2801| 12.5k| SCHECK_PARTIAL(); ------------------ | | 533| 12.5k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 3.14k, False: 9.36k] | | ------------------ | | 534| 12.5k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 3.14k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 347, False: 2.80k] | | | Branch (534:38): [True: 320, False: 2.48k] | | ------------------ | | 535| 12.5k| { \ | | 536| 667| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 667|#define TRUE 1 | | ------------------ | | 537| 667| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 34|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 34, False: 633] | | ------------------ | | 538| 667| } ------------------ 2802| 12.4k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 12.4k| {\ | | 555| 12.4k| rrc = ra;\ | | 556| 12.4k| goto RETURN_SWITCH;\ | | 557| 12.4k| } ------------------ 2803| 0| } 2804| 169k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 169k| c = *eptr++; \ | | 324| 169k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 9.64k| { \ | | | | 289| 9.64k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 475, False: 9.16k] | | | | ------------------ | | | | 290| 9.64k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 9.64k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 8.86k, False: 304] | | | | ------------------ | | | | 292| 9.16k| { \ | | | | 293| 8.86k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 8.86k| eptr += 2; \ | | | | 295| 8.86k| } \ | | | | 296| 9.16k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 304, False: 0] | | | | ------------------ | | | | 297| 304| { \ | | | | 298| 304| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 304| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 304| eptr += 3; \ | | | | 301| 304| } \ | | | | 302| 304| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 9.64k| } | | ------------------ | | | Branch (324:7): [True: 63.5k, False: 105k] | | | Branch (324:14): [True: 9.64k, False: 53.9k] | | ------------------ ------------------ 2805| 169k| switch(fc) 2806| 169k| { 2807| 94.5k| HSPACE_CASES: ------------------ | | 412| 1.42k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 492| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 492|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 492, False: 168k] | | | | ------------------ | | | | 408| 1.00k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.00k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 509, False: 168k] | | | | ------------------ | | | | 409| 1.42k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 2.05k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 2.05k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 630, False: 168k] | | | | ------------------ | | | | 390| 2.56k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 510, False: 168k] | | | | ------------------ | | | | 391| 3.03k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 479, False: 168k] | | | | ------------------ | | | | 392| 3.49k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 456, False: 168k] | | | | ------------------ | | | | 393| 3.94k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 446, False: 168k] | | | | ------------------ | | | | 394| 4.49k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 554, False: 168k] | | | | ------------------ | | | | 395| 4.99k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 500, False: 168k] | | | | ------------------ | | | | 396| 5.42k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 432, False: 168k] | | | | ------------------ | | | | 397| 6.00k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 574, False: 168k] | | | | ------------------ | | | | 398| 6.57k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 572, False: 168k] | | | | ------------------ | | | | 399| 7.08k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 509, False: 168k] | | | | ------------------ | | | | 400| 7.59k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 510, False: 168k] | | | | ------------------ | | | | 401| 8.03k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 439, False: 168k] | | | | ------------------ | | | | 402| 8.38k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 358, False: 168k] | | | | ------------------ | | | | 403| 8.68k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 297, False: 168k] | | | | ------------------ | | | | 404| 9.25k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 2808| 94.5k| VSPACE_CASES: ------------------ | | 430| 11.4k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 9.63k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 9.63k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 377, False: 168k] | | | | ------------------ | | | | 424| 10.1k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 10.1k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 470, False: 168k] | | | | ------------------ | | | | 425| 10.4k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 10.4k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 352, False: 168k] | | | | ------------------ | | | | 426| 11.0k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 11.0k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 596, False: 168k] | | | | ------------------ | | | | 427| 11.4k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 9.25k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 11.9k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 11.9k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 511, False: 168k] | | | | ------------------ | | | | 420| 12.2k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 2809| 76.8k| if (notmatch) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 8.37k| {\ | | 555| 8.37k| rrc = ra;\ | | 556| 8.37k| goto RETURN_SWITCH;\ | | 557| 8.37k| } ------------------ | Branch (2809:19): [True: 8.37k, False: 3.87k] ------------------ 2810| 3.87k| break; 2811| | 2812| 157k| default: ------------------ | Branch (2812:15): [True: 157k, False: 12.2k] ------------------ 2813| 157k| if ((UCD_CATEGORY(fc) == ucp_Z) == notmatch) ------------------ | | 1859| 157k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 157k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 157k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 157k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 157k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 157k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 157k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 157k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 157k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 157k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 157k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 157k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 157k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2813:19): [True: 123k, False: 33.3k] ------------------ 2814| 123k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 123k| {\ | | 555| 123k| rrc = ra;\ | | 556| 123k| goto RETURN_SWITCH;\ | | 557| 123k| } ------------------ 2815| 33.3k| break; 2816| 169k| } 2817| 169k| } 2818| 12.8k| break; 2819| | 2820| 32.1k| case PT_WORD: ------------------ | | 1284| 32.1k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (2820:11): [True: 32.1k, False: 352k] ------------------ 2821| 47.1k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 47.1k|#define Lmin F->temp_32[0] ------------------ | Branch (2821:23): [True: 39.7k, False: 7.43k] ------------------ 2822| 39.7k| { 2823| 39.7k| int category; 2824| 39.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 39.7k|#define Feptr F->eptr ------------------ | Branch (2824:17): [True: 3.88k, False: 35.8k] ------------------ 2825| 3.88k| { 2826| 3.88k| SCHECK_PARTIAL(); ------------------ | | 533| 3.88k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 893, False: 2.98k] | | ------------------ | | 534| 3.88k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 893|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 409, False: 484] | | | Branch (534:38): [True: 240, False: 244] | | ------------------ | | 535| 3.88k| { \ | | 536| 649| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 649|#define TRUE 1 | | ------------------ | | 537| 649| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 20|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 20, False: 629] | | ------------------ | | 538| 649| } ------------------ 2827| 3.86k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.86k| {\ | | 555| 3.86k| rrc = ra;\ | | 556| 3.86k| goto RETURN_SWITCH;\ | | 557| 3.86k| } ------------------ 2828| 0| } 2829| 35.8k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 35.8k| c = *eptr++; \ | | 324| 35.8k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.72k| { \ | | | | 289| 1.72k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 233, False: 1.48k] | | | | ------------------ | | | | 290| 1.72k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.72k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 940, False: 549] | | | | ------------------ | | | | 292| 1.48k| { \ | | | | 293| 940| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 940| eptr += 2; \ | | | | 295| 940| } \ | | | | 296| 1.48k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 549, False: 0] | | | | ------------------ | | | | 297| 549| { \ | | | | 298| 549| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 549| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 549| eptr += 3; \ | | | | 301| 549| } \ | | | | 302| 549| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.72k| } | | ------------------ | | | Branch (324:7): [True: 25.0k, False: 10.8k] | | | Branch (324:14): [True: 1.72k, False: 23.3k] | | ------------------ ------------------ 2830| 35.8k| category = UCD_CATEGORY(fc); ------------------ | | 1859| 35.8k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 35.8k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 35.8k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 35.8k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 35.8k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 35.8k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 35.8k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 35.8k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 35.8k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 35.8k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 35.8k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 35.8k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 35.8k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2831| 35.8k| if ((category == ucp_L || category == ucp_N || ------------------ | Branch (2831:17): [True: 20.8k, False: 15.0k] | Branch (2831:18): [True: 9.95k, False: 25.9k] | Branch (2831:39): [True: 2.43k, False: 23.4k] ------------------ 2832| 35.8k| fc == CHAR_UNDERSCORE) == notmatch) ------------------ | | 1045| 23.4k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (2832:17): [True: 152, False: 23.3k] ------------------ 2833| 20.8k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 20.8k| {\ | | 555| 20.8k| rrc = ra;\ | | 556| 20.8k| goto RETURN_SWITCH;\ | | 557| 20.8k| } ------------------ 2834| 15.0k| } 2835| 7.43k| break; 2836| | 2837| 23.9k| case PT_CLIST: ------------------ | | 1285| 23.9k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (2837:11): [True: 23.9k, False: 360k] ------------------ 2838| 28.4k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 28.4k|#define Lmin F->temp_32[0] ------------------ | Branch (2838:23): [True: 24.2k, False: 4.13k] ------------------ 2839| 24.2k| { 2840| 24.2k| const uint32_t *cp; 2841| 24.2k| if (Feptr >= mb->end_subject) ------------------ | | 177| 24.2k|#define Feptr F->eptr ------------------ | Branch (2841:17): [True: 2.44k, False: 21.8k] ------------------ 2842| 2.44k| { 2843| 2.44k| SCHECK_PARTIAL(); ------------------ | | 533| 2.44k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 780, False: 1.66k] | | ------------------ | | 534| 2.44k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 780|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 248, False: 532] | | | Branch (534:38): [True: 234, False: 298] | | ------------------ | | 535| 2.44k| { \ | | 536| 482| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 482|#define TRUE 1 | | ------------------ | | 537| 482| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 466] | | ------------------ | | 538| 482| } ------------------ 2844| 2.42k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.42k| {\ | | 555| 2.42k| rrc = ra;\ | | 556| 2.42k| goto RETURN_SWITCH;\ | | 557| 2.42k| } ------------------ 2845| 0| } 2846| 21.8k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 21.8k| c = *eptr++; \ | | 324| 21.8k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.17k| { \ | | | | 289| 1.17k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 594, False: 580] | | | | ------------------ | | | | 290| 1.17k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.17k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 322, False: 258] | | | | ------------------ | | | | 292| 580| { \ | | | | 293| 322| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 322| eptr += 2; \ | | | | 295| 322| } \ | | | | 296| 580| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 258, False: 0] | | | | ------------------ | | | | 297| 258| { \ | | | | 298| 258| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 258| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 258| eptr += 3; \ | | | | 301| 258| } \ | | | | 302| 258| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.17k| } | | ------------------ | | | Branch (324:7): [True: 19.6k, False: 2.24k] | | | Branch (324:14): [True: 1.17k, False: 18.4k] | | ------------------ ------------------ 2847| 21.8k| cp = PRIV(ucd_caseless_sets) + Lpropvalue; ------------------ | | 177| 21.8k|#define PRIV(name) _pcre2_##name ------------------ cp = PRIV(ucd_caseless_sets) + Lpropvalue; ------------------ | | 2601| 21.8k|#define Lpropvalue F->temp_32[3] ------------------ 2848| 21.8k| for (;;) 2849| 33.9k| { 2850| 33.9k| if (fc < *cp) ------------------ | Branch (2850:19): [True: 17.9k, False: 16.0k] ------------------ 2851| 17.9k| { 2852| 17.9k| if (notmatch) break; ------------------ | Branch (2852:21): [True: 859, False: 17.0k] ------------------ 2853| 17.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 17.0k| {\ | | 555| 17.0k| rrc = ra;\ | | 556| 17.0k| goto RETURN_SWITCH;\ | | 557| 17.0k| } ------------------ 2854| 0| } 2855| 16.0k| if (fc == *cp++) ------------------ | Branch (2855:19): [True: 3.92k, False: 12.1k] ------------------ 2856| 3.92k| { 2857| 3.92k| if (notmatch) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 255| {\ | | 555| 255| rrc = ra;\ | | 556| 255| goto RETURN_SWITCH;\ | | 557| 255| } ------------------ | Branch (2857:21): [True: 255, False: 3.66k] ------------------ 2858| 3.66k| break; 2859| 3.92k| } 2860| 16.0k| } 2861| 21.8k| } 2862| 4.13k| break; 2863| | 2864| 44.3k| case PT_UCNC: ------------------ | | 1286| 44.3k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (2864:11): [True: 44.3k, False: 339k] ------------------ 2865| 115k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 115k|#define Lmin F->temp_32[0] ------------------ | Branch (2865:23): [True: 89.4k, False: 25.9k] ------------------ 2866| 89.4k| { 2867| 89.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 89.4k|#define Feptr F->eptr ------------------ | Branch (2867:17): [True: 3.37k, False: 86.0k] ------------------ 2868| 3.37k| { 2869| 3.37k| SCHECK_PARTIAL(); ------------------ | | 533| 3.37k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.74k, False: 1.63k] | | ------------------ | | 534| 3.37k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.74k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.19k, False: 553] | | | Branch (534:38): [True: 238, False: 315] | | ------------------ | | 535| 3.37k| { \ | | 536| 1.43k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.43k|#define TRUE 1 | | ------------------ | | 537| 1.43k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 10|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 10, False: 1.42k] | | ------------------ | | 538| 1.43k| } ------------------ 2870| 3.36k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.36k| {\ | | 555| 3.36k| rrc = ra;\ | | 556| 3.36k| goto RETURN_SWITCH;\ | | 557| 3.36k| } ------------------ 2871| 0| } 2872| 86.0k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 86.0k| c = *eptr++; \ | | 324| 86.0k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.11k| { \ | | | | 289| 1.11k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 410, False: 706] | | | | ------------------ | | | | 290| 1.11k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.11k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 343, False: 363] | | | | ------------------ | | | | 292| 706| { \ | | | | 293| 343| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 343| eptr += 2; \ | | | | 295| 343| } \ | | | | 296| 706| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 363, False: 0] | | | | ------------------ | | | | 297| 363| { \ | | | | 298| 363| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 363| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 363| eptr += 3; \ | | | | 301| 363| } \ | | | | 302| 363| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.11k| } | | ------------------ | | | Branch (324:7): [True: 8.50k, False: 77.5k] | | | Branch (324:14): [True: 1.11k, False: 7.38k] | | ------------------ ------------------ 2873| 86.0k| if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 986| 172k|#define CHAR_DOLLAR_SIGN '\044' ------------------ if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 170k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (2873:17): [True: 14.9k, False: 71.0k] | Branch (2873:18): [True: 1.72k, False: 84.3k] | Branch (2873:44): [True: 788, False: 83.5k] ------------------ 2874| 86.0k| fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) || ------------------ | | 1046| 169k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (2874:18): [True: 702, False: 82.8k] | Branch (2874:46): [True: 5.89k, False: 76.9k] | Branch (2874:60): [True: 5.52k, False: 365] ------------------ 2875| 86.0k| fc >= 0xe000) == notmatch) ------------------ | Branch (2875:18): [True: 365, False: 76.9k] ------------------ 2876| 71.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 14.9k| {\ | | 555| 14.9k| rrc = ra;\ | | 556| 14.9k| goto RETURN_SWITCH;\ | | 557| 14.9k| } ------------------ 2877| 71.0k| } 2878| 25.9k| break; 2879| | 2880| 25.9k| case PT_BIDICL: ------------------ | | 1287| 18.7k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (2880:11): [True: 18.7k, False: 365k] ------------------ 2881| 34.0k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 34.0k|#define Lmin F->temp_32[0] ------------------ | Branch (2881:23): [True: 24.3k, False: 9.72k] ------------------ 2882| 24.3k| { 2883| 24.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 24.3k|#define Feptr F->eptr ------------------ | Branch (2883:17): [True: 2.72k, False: 21.6k] ------------------ 2884| 2.72k| { 2885| 2.72k| SCHECK_PARTIAL(); ------------------ | | 533| 2.72k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.00k, False: 1.72k] | | ------------------ | | 534| 2.72k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.00k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 419, False: 587] | | | Branch (534:38): [True: 328, False: 259] | | ------------------ | | 535| 2.72k| { \ | | 536| 747| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 747|#define TRUE 1 | | ------------------ | | 537| 747| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 13|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 13, False: 734] | | ------------------ | | 538| 747| } ------------------ 2886| 2.71k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.71k| {\ | | 555| 2.71k| rrc = ra;\ | | 556| 2.71k| goto RETURN_SWITCH;\ | | 557| 2.71k| } ------------------ 2887| 0| } 2888| 21.6k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 21.6k| c = *eptr++; \ | | 324| 21.6k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 744| { \ | | | | 289| 744| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 255, False: 489] | | | | ------------------ | | | | 290| 744| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 744| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 222, False: 267] | | | | ------------------ | | | | 292| 489| { \ | | | | 293| 222| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 222| eptr += 2; \ | | | | 295| 222| } \ | | | | 296| 489| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 267, False: 0] | | | | ------------------ | | | | 297| 267| { \ | | | | 298| 267| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 267| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 267| eptr += 3; \ | | | | 301| 267| } \ | | | | 302| 267| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 744| } | | ------------------ | | | Branch (324:7): [True: 8.37k, False: 13.2k] | | | Branch (324:14): [True: 744, False: 7.63k] | | ------------------ ------------------ 2889| 21.6k| if ((UCD_BIDICLASS(fc) == Lpropvalue) == notmatch) ------------------ | | 1865| 21.6k|#define UCD_BIDICLASS(ch) UCD_BIDICLASS_PROP(GET_UCD(ch)) | | ------------------ | | | | 1854| 21.6k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | | | ------------------ | | | | | | 1850| 21.6k|#define UCD_BIDICLASS_SHIFT 11 | | | | ------------------ | | ------------------ ------------------ if ((UCD_BIDICLASS(fc) == Lpropvalue) == notmatch) ------------------ | | 2601| 21.6k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (2889:17): [True: 6.34k, False: 15.2k] ------------------ 2890| 15.2k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.34k| {\ | | 555| 6.34k| rrc = ra;\ | | 556| 6.34k| goto RETURN_SWITCH;\ | | 557| 6.34k| } ------------------ 2891| 15.2k| } 2892| 9.72k| break; 2893| | 2894| 12.8k| case PT_BOOL: ------------------ | | 1288| 12.8k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (2894:11): [True: 12.8k, False: 371k] ------------------ 2895| 29.6k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 29.6k|#define Lmin F->temp_32[0] ------------------ | Branch (2895:23): [True: 23.0k, False: 6.61k] ------------------ 2896| 23.0k| { 2897| 23.0k| BOOL ok; 2898| 23.0k| const ucd_record *prop; 2899| 23.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 23.0k|#define Feptr F->eptr ------------------ | Branch (2899:17): [True: 4.08k, False: 18.9k] ------------------ 2900| 4.08k| { 2901| 4.08k| SCHECK_PARTIAL(); ------------------ | | 533| 4.08k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.21k, False: 2.86k] | | ------------------ | | 534| 4.08k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.21k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 716, False: 501] | | | Branch (534:38): [True: 265, False: 236] | | ------------------ | | 535| 4.08k| { \ | | 536| 981| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 981|#define TRUE 1 | | ------------------ | | 537| 981| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 5, False: 976] | | ------------------ | | 538| 981| } ------------------ 2902| 4.07k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.07k| {\ | | 555| 4.07k| rrc = ra;\ | | 556| 4.07k| goto RETURN_SWITCH;\ | | 557| 4.07k| } ------------------ 2903| 0| } 2904| 18.9k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 18.9k| c = *eptr++; \ | | 324| 18.9k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 866| { \ | | | | 289| 866| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 301, False: 565] | | | | ------------------ | | | | 290| 866| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 866| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 287, False: 278] | | | | ------------------ | | | | 292| 565| { \ | | | | 293| 287| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 287| eptr += 2; \ | | | | 295| 287| } \ | | | | 296| 565| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 278, False: 0] | | | | ------------------ | | | | 297| 278| { \ | | | | 298| 278| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 278| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 278| eptr += 3; \ | | | | 301| 278| } \ | | | | 302| 278| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 866| } | | ------------------ | | | Branch (324:7): [True: 7.34k, False: 11.5k] | | | Branch (324:14): [True: 866, False: 6.48k] | | ------------------ ------------------ 2905| 18.9k| prop = GET_UCD(fc); ------------------ | | 1846| 18.9k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 18.9k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 18.9k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 18.9k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 18.9k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 18.9k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 18.9k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 18.9k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 18.9k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 18.9k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 2906| 18.9k| ok = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 18.9k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 2907| 18.9k| UCD_BPROPS_PROP(prop), Lpropvalue) != 0; 2908| 18.9k| if (ok == notmatch) ------------------ | Branch (2908:17): [True: 2.16k, False: 16.7k] ------------------ 2909| 16.7k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.16k| {\ | | 555| 2.16k| rrc = ra;\ | | 556| 2.16k| goto RETURN_SWITCH;\ | | 557| 2.16k| } ------------------ 2910| 16.7k| } 2911| 6.61k| break; 2912| | 2913| | /* This should not occur */ 2914| | 2915| 6.61k| default: ------------------ | Branch (2915:11): [True: 0, False: 384k] ------------------ 2916| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 2917| 384k| } 2918| 384k| } 2919| | 2920| | /* Match extended Unicode sequences. We will get here only if the 2921| | support is in the binary; otherwise a compile-time error occurs. */ 2922| | 2923| 710k| else if (Lctype == OP_EXTUNI) ------------------ | | 2600| 710k|#define Lctype F->temp_32[2] ------------------ | Branch (2923:16): [True: 13.0k, False: 697k] ------------------ 2924| 13.0k| { 2925| 28.1k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 28.1k|#define Lmin F->temp_32[0] ------------------ | Branch (2925:21): [True: 19.3k, False: 8.83k] ------------------ 2926| 19.3k| { 2927| 19.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 19.3k|#define Feptr F->eptr ------------------ | Branch (2927:15): [True: 4.13k, False: 15.2k] ------------------ 2928| 4.13k| { 2929| 4.13k| SCHECK_PARTIAL(); ------------------ | | 533| 4.13k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 878, False: 3.25k] | | ------------------ | | 534| 4.13k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 878|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 383, False: 495] | | | Branch (534:38): [True: 216, False: 279] | | ------------------ | | 535| 4.13k| { \ | | 536| 599| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 599|#define TRUE 1 | | ------------------ | | 537| 599| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 596] | | ------------------ | | 538| 599| } ------------------ 2930| 4.13k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.13k| {\ | | 555| 4.13k| rrc = ra;\ | | 556| 4.13k| goto RETURN_SWITCH;\ | | 557| 4.13k| } ------------------ 2931| 0| } 2932| 15.2k| else 2933| 15.2k| { 2934| 15.2k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 15.2k| c = *eptr++; \ | | 324| 15.2k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 809| { \ | | | | 289| 809| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 223, False: 586] | | | | ------------------ | | | | 290| 809| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 809| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 274, False: 312] | | | | ------------------ | | | | 292| 586| { \ | | | | 293| 274| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 274| eptr += 2; \ | | | | 295| 274| } \ | | | | 296| 586| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 312, False: 0] | | | | ------------------ | | | | 297| 312| { \ | | | | 298| 312| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 312| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 312| eptr += 3; \ | | | | 301| 312| } \ | | | | 302| 312| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 809| } | | ------------------ | | | Branch (324:7): [True: 6.30k, False: 8.92k] | | | Branch (324:14): [True: 809, False: 5.49k] | | ------------------ ------------------ 2935| 15.2k| Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, ------------------ | | 177| 15.2k|#define Feptr F->eptr ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, ------------------ | | 177| 15.2k|#define PRIV(name) _pcre2_##name ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, ------------------ | | 177| 15.2k|#define Feptr F->eptr ------------------ 2936| 15.2k| mb->end_subject, utf, NULL); 2937| 15.2k| } 2938| 15.2k| CHECK_PARTIAL(); ------------------ | | 527| 15.2k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 15.2k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 3.01k, False: 12.2k] | | ------------------ | | 528| 15.2k| { \ | | 529| 3.01k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 3.01k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 423, False: 2.59k] | | | | ------------------ | | | | 534| 3.01k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 423|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 423, False: 0] | | | | | Branch (534:38): [True: 0, False: 0] | | | | ------------------ | | | | 535| 3.01k| { \ | | | | 536| 423| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 423|#define TRUE 1 | | | | ------------------ | | | | 537| 423| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 42|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 42, False: 381] | | | | ------------------ | | | | 538| 423| } | | ------------------ | | 530| 2.97k| } ------------------ 2939| 15.1k| } 2940| 13.0k| } 2941| 697k| else 2942| 697k|#endif /* SUPPORT_UNICODE */ 2943| | 2944| |/* Handle all other cases in UTF mode */ 2945| | 2946| 697k|#ifdef SUPPORT_UNICODE 2947| 697k| if (utf) switch(Lctype) ------------------ | | 2600| 299k|#define Lctype F->temp_32[2] ------------------ | Branch (2947:11): [True: 299k, False: 398k] ------------------ 2948| 299k| { 2949| 53.3k| case OP_ANY: ------------------ | Branch (2949:9): [True: 53.3k, False: 245k] ------------------ 2950| 123k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 123k|#define Lmin F->temp_32[0] ------------------ | Branch (2950:21): [True: 80.8k, False: 42.6k] ------------------ 2951| 80.8k| { 2952| 80.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 80.8k|#define Feptr F->eptr ------------------ | Branch (2952:15): [True: 9.07k, False: 71.7k] ------------------ 2953| 9.07k| { 2954| 9.07k| SCHECK_PARTIAL(); ------------------ | | 533| 9.07k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.75k, False: 6.32k] | | ------------------ | | 534| 9.07k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.75k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 2.03k, False: 720] | | | Branch (534:38): [True: 226, False: 494] | | ------------------ | | 535| 9.07k| { \ | | 536| 2.25k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.25k|#define TRUE 1 | | ------------------ | | 537| 2.25k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 2.25k] | | ------------------ | | 538| 2.25k| } ------------------ 2955| 9.07k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 9.07k| {\ | | 555| 9.07k| rrc = ra;\ | | 556| 9.07k| goto RETURN_SWITCH;\ | | 557| 9.07k| } ------------------ 2956| 0| } 2957| 71.7k| if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 479| 71.7k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 71.7k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 71.7k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 1.61k, False: 70.1k] | | | Branch (479:4): [True: 8.66k, False: 63.1k] | | ------------------ | | 480| 71.7k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 8.66k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 17.3k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 8.66k, False: 0] | | ------------------ | | 481| 8.66k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 8.66k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 8.66k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 8.66k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 8.66k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 312, False: 8.34k] | | ------------------ | | 482| 8.66k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 8.66k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 71.7k| : \ | | 484| 71.7k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 63.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 63.1k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 63.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 60.8k, False: 2.26k] | | ------------------ | | 485| 63.1k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 60.8k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 60.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.73k, False: 59.1k] | | ------------------ | | 486| 63.1k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.73k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 771|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 771|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 964, False: 771] | | | Branch (486:30): [True: 340, False: 431] | | ------------------ | | 487| 63.1k| ) \ | | 488| 71.7k| ) ------------------ if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.61k| {\ | | 555| 1.61k| rrc = ra;\ | | 556| 1.61k| goto RETURN_SWITCH;\ | | 557| 1.61k| } ------------------ 2958| 70.1k| if (mb->partial != 0 && ------------------ | Branch (2958:15): [True: 16.5k, False: 53.6k] ------------------ 2959| 70.1k| Feptr + 1 >= mb->end_subject && ------------------ | | 177| 16.5k|#define Feptr F->eptr ------------------ | Branch (2959:15): [True: 1.96k, False: 14.5k] ------------------ 2960| 70.1k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 1.96k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 72.1k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (2960:15): [True: 1.67k, False: 286] ------------------ 2961| 70.1k| NLBLOCK->nllen == 2 && ------------------ | | 59| 1.67k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (2961:15): [True: 792, False: 885] ------------------ 2962| 70.1k| UCHAR21(Feptr) == NLBLOCK->nl[0]) ------------------ | | 243| 792|#define UCHAR21(eptr) (*(eptr)) ------------------ UCHAR21(Feptr) == NLBLOCK->nl[0]) ------------------ | | 59| 792|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (2962:15): [True: 487, False: 305] ------------------ 2963| 487| { 2964| 487| mb->hitend = TRUE; ------------------ | | 70| 487|#define TRUE 1 ------------------ 2965| 487| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (2965:17): [True: 3, False: 484] ------------------ 2966| 487| } 2967| 70.1k| Feptr++; ------------------ | | 177| 70.1k|#define Feptr F->eptr ------------------ 2968| 70.1k| ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++); ------------------ | | 353| 73.6k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 66.1k, False: 7.52k] | | | Branch (353:24): [True: 3.50k, False: 62.6k] | | ------------------ ------------------ 2969| 70.1k| } 2970| 42.6k| break; 2971| | 2972| 42.6k| case OP_ALLANY: ------------------ | Branch (2972:9): [True: 22.5k, False: 276k] ------------------ 2973| 44.9k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 44.9k|#define Lmin F->temp_32[0] ------------------ | Branch (2973:21): [True: 26.5k, False: 18.3k] ------------------ 2974| 26.5k| { 2975| 26.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 26.5k|#define Feptr F->eptr ------------------ | Branch (2975:15): [True: 4.16k, False: 22.4k] ------------------ 2976| 4.16k| { 2977| 4.16k| SCHECK_PARTIAL(); ------------------ | | 533| 4.16k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 762, False: 3.40k] | | ------------------ | | 534| 4.16k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 762|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 261, False: 501] | | | Branch (534:38): [True: 244, False: 257] | | ------------------ | | 535| 4.16k| { \ | | 536| 505| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 505|#define TRUE 1 | | ------------------ | | 537| 505| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 31|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 31, False: 474] | | ------------------ | | 538| 505| } ------------------ 2978| 4.13k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.13k| {\ | | 555| 4.13k| rrc = ra;\ | | 556| 4.13k| goto RETURN_SWITCH;\ | | 557| 4.13k| } ------------------ 2979| 0| } 2980| 22.4k| Feptr++; ------------------ | | 177| 22.4k|#define Feptr F->eptr ------------------ 2981| 22.4k| ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++); ------------------ | | 353| 24.7k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 21.9k, False: 2.82k] | | | Branch (353:24): [True: 2.33k, False: 19.5k] | | ------------------ ------------------ 2982| 22.4k| } 2983| 18.3k| break; 2984| | 2985| 18.3k| case OP_ANYBYTE: ------------------ | Branch (2985:9): [True: 0, False: 299k] ------------------ 2986| 0| if (Feptr > mb->end_subject - Lmin) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 0|#define Feptr F->eptr ------------------ if (Feptr > mb->end_subject - Lmin) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 0|#define Lmin F->temp_32[0] ------------------ if (Feptr > mb->end_subject - Lmin) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ | Branch (2986:13): [True: 0, False: 0] ------------------ 2987| 0| Feptr += Lmin; ------------------ | | 177| 0|#define Feptr F->eptr ------------------ Feptr += Lmin; ------------------ | | 2598| 0|#define Lmin F->temp_32[0] ------------------ 2988| 0| break; 2989| | 2990| 40.0k| case OP_ANYNL: ------------------ | Branch (2990:9): [True: 40.0k, False: 259k] ------------------ 2991| 47.7k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 47.7k|#define Lmin F->temp_32[0] ------------------ | Branch (2991:21): [True: 42.2k, False: 5.49k] ------------------ 2992| 42.2k| { 2993| 42.2k| if (Feptr >= mb->end_subject) ------------------ | | 177| 42.2k|#define Feptr F->eptr ------------------ | Branch (2993:15): [True: 5.80k, False: 36.4k] ------------------ 2994| 5.80k| { 2995| 5.80k| SCHECK_PARTIAL(); ------------------ | | 533| 5.80k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 730, False: 5.07k] | | ------------------ | | 534| 5.80k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 730|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 232, False: 498] | | | Branch (534:38): [True: 223, False: 275] | | ------------------ | | 535| 5.80k| { \ | | 536| 455| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 455|#define TRUE 1 | | ------------------ | | 537| 455| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 23|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 23, False: 432] | | ------------------ | | 538| 455| } ------------------ 2996| 5.78k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.78k| {\ | | 555| 5.78k| rrc = ra;\ | | 556| 5.78k| goto RETURN_SWITCH;\ | | 557| 5.78k| } ------------------ 2997| 0| } 2998| 36.4k| GETCHARINC(fc, Feptr); ------------------ | | 316| 36.4k| c = *eptr++; \ | | 317| 36.4k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 2.14k| { \ | | | | 289| 2.14k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 711, False: 1.43k] | | | | ------------------ | | | | 290| 2.14k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 2.14k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 1.12k, False: 306] | | | | ------------------ | | | | 292| 1.43k| { \ | | | | 293| 1.12k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 1.12k| eptr += 2; \ | | | | 295| 1.12k| } \ | | | | 296| 1.43k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 306, False: 0] | | | | ------------------ | | | | 297| 306| { \ | | | | 298| 306| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 306| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 306| eptr += 3; \ | | | | 301| 306| } \ | | | | 302| 306| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 2.14k| } | | ------------------ | | | Branch (317:7): [True: 2.14k, False: 34.2k] | | ------------------ ------------------ 2999| 36.4k| switch(fc) 3000| 36.4k| { 3001| 28.7k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 28.7k| {\ | | 555| 28.7k| rrc = ra;\ | | 556| 28.7k| goto RETURN_SWITCH;\ | | 557| 28.7k| } ------------------ | Branch (3001:13): [True: 28.7k, False: 7.64k] ------------------ 3002| | 3003| 2.59k| case CHAR_CR: ------------------ | | 972| 2.59k|#define CHAR_CR '\015' ------------------ | Branch (3003:13): [True: 2.59k, False: 33.8k] ------------------ 3004| 2.59k| if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 177| 2.59k|#define Feptr F->eptr ------------------ if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 243| 1.60k|#define UCHAR21(eptr) (*(eptr)) ------------------ if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 973| 1.60k|#define CHAR_LF '\012' ------------------ if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 177| 483|#define Feptr F->eptr ------------------ | Branch (3004:17): [True: 1.60k, False: 993] | Branch (3004:44): [True: 483, False: 1.12k] ------------------ 3005| 2.59k| break; 3006| | 3007| 1.09k| case CHAR_LF: ------------------ | | 973| 1.09k|#define CHAR_LF '\012' ------------------ | Branch (3007:13): [True: 1.09k, False: 35.3k] ------------------ 3008| 1.09k| break; 3009| | 3010| 1.93k| case CHAR_VT: ------------------ | | 970| 1.93k|#define CHAR_VT '\013' ------------------ | Branch (3010:13): [True: 1.93k, False: 34.4k] ------------------ 3011| 2.67k| case CHAR_FF: ------------------ | | 971| 2.67k|#define CHAR_FF '\014' ------------------ | Branch (3011:13): [True: 735, False: 35.6k] ------------------ 3012| 2.91k| case CHAR_NEL: ------------------ | | 975| 2.91k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (3012:13): [True: 247, False: 36.1k] ------------------ 3013| 2.91k|#ifndef EBCDIC 3014| 3.41k| case 0x2028: ------------------ | Branch (3014:13): [True: 495, False: 35.9k] ------------------ 3015| 3.95k| case 0x2029: ------------------ | Branch (3015:13): [True: 536, False: 35.8k] ------------------ 3016| 3.95k|#endif /* Not EBCDIC */ 3017| 3.95k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH); ------------------ | | 217| 3.95k|#define PCRE2_BSR_ANYCRLF 2 ------------------ if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ | Branch (3017:17): [True: 0, False: 3.95k] ------------------ 3018| 3.95k| break; 3019| 36.4k| } 3020| 36.4k| } 3021| 5.49k| break; 3022| | 3023| 17.3k| case OP_NOT_HSPACE: ------------------ | Branch (3023:9): [True: 17.3k, False: 281k] ------------------ 3024| 41.7k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 41.7k|#define Lmin F->temp_32[0] ------------------ | Branch (3024:21): [True: 33.9k, False: 7.80k] ------------------ 3025| 33.9k| { 3026| 33.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 33.9k|#define Feptr F->eptr ------------------ | Branch (3026:15): [True: 3.53k, False: 30.4k] ------------------ 3027| 3.53k| { 3028| 3.53k| SCHECK_PARTIAL(); ------------------ | | 533| 3.53k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 771, False: 2.76k] | | ------------------ | | 534| 3.53k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 771|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 252, False: 519] | | | Branch (534:38): [True: 229, False: 290] | | ------------------ | | 535| 3.53k| { \ | | 536| 481| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 481|#define TRUE 1 | | ------------------ | | 537| 481| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 23|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 23, False: 458] | | ------------------ | | 538| 481| } ------------------ 3029| 3.51k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.51k| {\ | | 555| 3.51k| rrc = ra;\ | | 556| 3.51k| goto RETURN_SWITCH;\ | | 557| 3.51k| } ------------------ 3030| 0| } 3031| 30.4k| GETCHARINC(fc, Feptr); ------------------ | | 316| 30.4k| c = *eptr++; \ | | 317| 30.4k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 5.95k| { \ | | | | 289| 5.95k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 545, False: 5.40k] | | | | ------------------ | | | | 290| 5.95k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 5.95k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 5.10k, False: 298] | | | | ------------------ | | | | 292| 5.40k| { \ | | | | 293| 5.10k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 5.10k| eptr += 2; \ | | | | 295| 5.10k| } \ | | | | 296| 5.40k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 298, False: 0] | | | | ------------------ | | | | 297| 298| { \ | | | | 298| 298| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 298| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 298| eptr += 3; \ | | | | 301| 298| } \ | | | | 302| 298| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 5.95k| } | | ------------------ | | | Branch (317:7): [True: 5.95k, False: 24.4k] | | ------------------ ------------------ 3032| 30.4k| switch(fc) 3033| 30.4k| { 3034| 5.97k| HSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 412| 1.06k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 283| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 283|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 283, False: 30.1k] | | | | ------------------ | | | | 408| 740| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 740|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 457, False: 29.9k] | | | | ------------------ | | | | 409| 1.06k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.37k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.37k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 308, False: 30.1k] | | | | ------------------ | | | | 390| 1.67k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 301, False: 30.1k] | | | | ------------------ | | | | 391| 1.91k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 243, False: 30.1k] | | | | ------------------ | | | | 392| 2.21k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 300, False: 30.1k] | | | | ------------------ | | | | 393| 2.65k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 439, False: 29.9k] | | | | ------------------ | | | | 394| 2.95k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 298, False: 30.1k] | | | | ------------------ | | | | 395| 3.26k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 311, False: 30.1k] | | | | ------------------ | | | | 396| 3.54k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 275, False: 30.1k] | | | | ------------------ | | | | 397| 3.83k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 296, False: 30.1k] | | | | ------------------ | | | | 398| 4.12k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 290, False: 30.1k] | | | | ------------------ | | | | 399| 4.55k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 432, False: 30.0k] | | | | ------------------ | | | | 400| 4.86k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 309, False: 30.1k] | | | | ------------------ | | | | 401| 5.18k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 312, False: 30.1k] | | | | ------------------ | | | | 402| 5.44k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 263, False: 30.1k] | | | | ------------------ | | | | 403| 5.68k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 245, False: 30.1k] | | | | ------------------ | | | | 404| 5.97k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ HSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.97k| {\ | | 555| 5.97k| rrc = ra;\ | | 556| 5.97k| goto RETURN_SWITCH;\ | | 557| 5.97k| } ------------------ 3035| 24.4k| default: break; ------------------ | Branch (3035:13): [True: 24.4k, False: 5.97k] ------------------ 3036| 30.4k| } 3037| 30.4k| } 3038| 7.80k| break; 3039| | 3040| 50.7k| case OP_HSPACE: ------------------ | Branch (3040:9): [True: 50.7k, False: 248k] ------------------ 3041| 56.1k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 56.1k|#define Lmin F->temp_32[0] ------------------ | Branch (3041:21): [True: 51.0k, False: 5.01k] ------------------ 3042| 51.0k| { 3043| 51.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 51.0k|#define Feptr F->eptr ------------------ | Branch (3043:15): [True: 6.17k, False: 44.9k] ------------------ 3044| 6.17k| { 3045| 6.17k| SCHECK_PARTIAL(); ------------------ | | 533| 6.17k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 812, False: 5.36k] | | ------------------ | | 534| 6.17k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 812|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 288, False: 524] | | | Branch (534:38): [True: 237, False: 287] | | ------------------ | | 535| 6.17k| { \ | | 536| 525| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 525|#define TRUE 1 | | ------------------ | | 537| 525| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 14|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 14, False: 511] | | ------------------ | | 538| 525| } ------------------ 3046| 6.15k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.15k| {\ | | 555| 6.15k| rrc = ra;\ | | 556| 6.15k| goto RETURN_SWITCH;\ | | 557| 6.15k| } ------------------ 3047| 0| } 3048| 44.9k| GETCHARINC(fc, Feptr); ------------------ | | 316| 44.9k| c = *eptr++; \ | | 317| 44.9k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 4.80k| { \ | | | | 289| 4.80k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 410, False: 4.39k] | | | | ------------------ | | | | 290| 4.80k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 4.80k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 4.16k, False: 228] | | | | ------------------ | | | | 292| 4.39k| { \ | | | | 293| 4.16k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 4.16k| eptr += 2; \ | | | | 295| 4.16k| } \ | | | | 296| 4.39k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 228, False: 0] | | | | ------------------ | | | | 297| 228| { \ | | | | 298| 228| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 228| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 228| eptr += 3; \ | | | | 301| 228| } \ | | | | 302| 228| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 4.80k| } | | ------------------ | | | Branch (317:7): [True: 4.80k, False: 40.1k] | | ------------------ ------------------ 3049| 44.9k| switch(fc) 3050| 44.9k| { 3051| 5.34k| HSPACE_CASES: break; ------------------ | | 412| 1.35k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 570| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 570|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 570, False: 44.3k] | | | | ------------------ | | | | 408| 1.00k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.00k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 438, False: 44.4k] | | | | ------------------ | | | | 409| 1.35k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.61k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.61k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 260, False: 44.6k] | | | | ------------------ | | | | 390| 1.82k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 209, False: 44.7k] | | | | ------------------ | | | | 391| 2.07k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 250, False: 44.6k] | | | | ------------------ | | | | 392| 2.28k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 204, False: 44.7k] | | | | ------------------ | | | | 393| 2.48k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 205, False: 44.7k] | | | | ------------------ | | | | 394| 2.68k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 203, False: 44.7k] | | | | ------------------ | | | | 395| 2.93k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 251, False: 44.6k] | | | | ------------------ | | | | 396| 3.20k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 263, False: 44.6k] | | | | ------------------ | | | | 397| 3.42k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 222, False: 44.7k] | | | | ------------------ | | | | 398| 3.68k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 260, False: 44.6k] | | | | ------------------ | | | | 399| 3.92k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 238, False: 44.6k] | | | | ------------------ | | | | 400| 4.16k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 244, False: 44.6k] | | | | ------------------ | | | | 401| 4.40k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 242, False: 44.6k] | | | | ------------------ | | | | 402| 4.67k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 268, False: 44.6k] | | | | ------------------ | | | | 403| 5.05k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 374, False: 44.5k] | | | | ------------------ | | | | 404| 5.34k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 3052| 39.5k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 39.5k| {\ | | 555| 39.5k| rrc = ra;\ | | 556| 39.5k| goto RETURN_SWITCH;\ | | 557| 39.5k| } ------------------ | Branch (3052:13): [True: 39.5k, False: 5.34k] ------------------ 3053| 44.9k| } 3054| 44.9k| } 3055| 5.01k| break; 3056| | 3057| 14.9k| case OP_NOT_VSPACE: ------------------ | Branch (3057:9): [True: 14.9k, False: 284k] ------------------ 3058| 29.8k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 29.8k|#define Lmin F->temp_32[0] ------------------ | Branch (3058:21): [True: 21.8k, False: 7.92k] ------------------ 3059| 21.8k| { 3060| 21.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 21.8k|#define Feptr F->eptr ------------------ | Branch (3060:15): [True: 3.85k, False: 18.0k] ------------------ 3061| 3.85k| { 3062| 3.85k| SCHECK_PARTIAL(); ------------------ | | 533| 3.85k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 852, False: 3.00k] | | ------------------ | | 534| 3.85k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 852|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 363, False: 489] | | | Branch (534:38): [True: 230, False: 259] | | ------------------ | | 535| 3.85k| { \ | | 536| 593| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 593|#define TRUE 1 | | ------------------ | | 537| 593| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 11|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 11, False: 582] | | ------------------ | | 538| 593| } ------------------ 3063| 3.84k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.84k| {\ | | 555| 3.84k| rrc = ra;\ | | 556| 3.84k| goto RETURN_SWITCH;\ | | 557| 3.84k| } ------------------ 3064| 0| } 3065| 18.0k| GETCHARINC(fc, Feptr); ------------------ | | 316| 18.0k| c = *eptr++; \ | | 317| 18.0k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.74k| { \ | | | | 289| 1.74k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 560, False: 1.18k] | | | | ------------------ | | | | 290| 1.74k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.74k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 911, False: 274] | | | | ------------------ | | | | 292| 1.18k| { \ | | | | 293| 911| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 911| eptr += 2; \ | | | | 295| 911| } \ | | | | 296| 1.18k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 274, False: 0] | | | | ------------------ | | | | 297| 274| { \ | | | | 298| 274| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 274| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 274| eptr += 3; \ | | | | 301| 274| } \ | | | | 302| 274| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.74k| } | | ------------------ | | | Branch (317:7): [True: 1.74k, False: 16.2k] | | ------------------ ------------------ 3066| 18.0k| switch(fc) 3067| 18.0k| { 3068| 3.14k| VSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 430| 2.29k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 441| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 441|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 441, False: 17.5k] | | | | ------------------ | | | | 424| 807| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 807|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 366, False: 17.6k] | | | | ------------------ | | | | 425| 1.53k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.53k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 730, False: 17.2k] | | | | ------------------ | | | | 426| 2.04k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 2.04k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 512, False: 17.5k] | | | | ------------------ | | | | 427| 2.29k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 2.85k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 2.85k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 564, False: 17.4k] | | | | ------------------ | | | | 420| 3.14k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ VSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.14k| {\ | | 555| 3.14k| rrc = ra;\ | | 556| 3.14k| goto RETURN_SWITCH;\ | | 557| 3.14k| } ------------------ 3069| 14.8k| default: break; ------------------ | Branch (3069:13): [True: 14.8k, False: 3.14k] ------------------ 3070| 18.0k| } 3071| 18.0k| } 3072| 7.92k| break; 3073| | 3074| 31.1k| case OP_VSPACE: ------------------ | Branch (3074:9): [True: 31.1k, False: 268k] ------------------ 3075| 34.4k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 34.4k|#define Lmin F->temp_32[0] ------------------ | Branch (3075:21): [True: 31.3k, False: 3.08k] ------------------ 3076| 31.3k| { 3077| 31.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 31.3k|#define Feptr F->eptr ------------------ | Branch (3077:15): [True: 4.00k, False: 27.3k] ------------------ 3078| 4.00k| { 3079| 4.00k| SCHECK_PARTIAL(); ------------------ | | 533| 4.00k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 806, False: 3.19k] | | ------------------ | | 534| 4.00k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 806|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 302, False: 504] | | | Branch (534:38): [True: 225, False: 279] | | ------------------ | | 535| 4.00k| { \ | | 536| 527| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 527|#define TRUE 1 | | ------------------ | | 537| 527| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 9|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 9, False: 518] | | ------------------ | | 538| 527| } ------------------ 3080| 3.99k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.99k| {\ | | 555| 3.99k| rrc = ra;\ | | 556| 3.99k| goto RETURN_SWITCH;\ | | 557| 3.99k| } ------------------ 3081| 0| } 3082| 27.3k| GETCHARINC(fc, Feptr); ------------------ | | 316| 27.3k| c = *eptr++; \ | | 317| 27.3k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.22k| { \ | | | | 289| 1.22k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 371, False: 851] | | | | ------------------ | | | | 290| 1.22k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.22k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 597, False: 254] | | | | ------------------ | | | | 292| 851| { \ | | | | 293| 597| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 597| eptr += 2; \ | | | | 295| 597| } \ | | | | 296| 851| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 254, False: 0] | | | | ------------------ | | | | 297| 254| { \ | | | | 298| 254| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 254| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 254| eptr += 3; \ | | | | 301| 254| } \ | | | | 302| 254| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.22k| } | | ------------------ | | | Branch (317:7): [True: 1.22k, False: 26.1k] | | ------------------ ------------------ 3083| 27.3k| switch(fc) 3084| 27.3k| { 3085| 3.33k| VSPACE_CASES: break; ------------------ | | 430| 2.90k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 535| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 535|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 535, False: 26.8k] | | | | ------------------ | | | | 424| 1.47k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 1.47k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 944, False: 26.4k] | | | | ------------------ | | | | 425| 2.17k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 2.17k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 692, False: 26.6k] | | | | ------------------ | | | | 426| 2.62k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 2.62k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 454, False: 26.9k] | | | | ------------------ | | | | 427| 2.90k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 3.11k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 3.11k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 207, False: 27.1k] | | | | ------------------ | | | | 420| 3.33k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 3086| 24.0k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 24.0k| {\ | | 555| 24.0k| rrc = ra;\ | | 556| 24.0k| goto RETURN_SWITCH;\ | | 557| 24.0k| } ------------------ | Branch (3086:13): [True: 24.0k, False: 3.33k] ------------------ 3087| 27.3k| } 3088| 27.3k| } 3089| 3.08k| break; 3090| | 3091| 5.34k| case OP_NOT_DIGIT: ------------------ | Branch (3091:9): [True: 5.34k, False: 293k] ------------------ 3092| 10.4k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 10.4k|#define Lmin F->temp_32[0] ------------------ | Branch (3092:21): [True: 8.31k, False: 2.17k] ------------------ 3093| 8.31k| { 3094| 8.31k| if (Feptr >= mb->end_subject) ------------------ | | 177| 8.31k|#define Feptr F->eptr ------------------ | Branch (3094:15): [True: 2.33k, False: 5.98k] ------------------ 3095| 2.33k| { 3096| 2.33k| SCHECK_PARTIAL(); ------------------ | | 533| 2.33k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 767, False: 1.56k] | | ------------------ | | 534| 2.33k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 767|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 269, False: 498] | | | Branch (534:38): [True: 243, False: 255] | | ------------------ | | 535| 2.33k| { \ | | 536| 512| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 512|#define TRUE 1 | | ------------------ | | 537| 512| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 11|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 11, False: 501] | | ------------------ | | 538| 512| } ------------------ 3097| 2.32k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.32k| {\ | | 555| 2.32k| rrc = ra;\ | | 556| 2.32k| goto RETURN_SWITCH;\ | | 557| 2.32k| } ------------------ 3098| 0| } 3099| 5.98k| GETCHARINC(fc, Feptr); ------------------ | | 316| 5.98k| c = *eptr++; \ | | 317| 5.98k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 931| { \ | | | | 289| 931| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 317, False: 614] | | | | ------------------ | | | | 290| 931| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 931| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 346, False: 268] | | | | ------------------ | | | | 292| 614| { \ | | | | 293| 346| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 346| eptr += 2; \ | | | | 295| 346| } \ | | | | 296| 614| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 268, False: 0] | | | | ------------------ | | | | 297| 268| { \ | | | | 298| 268| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 268| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 268| eptr += 3; \ | | | | 301| 268| } \ | | | | 302| 268| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 931| } | | ------------------ | | | Branch (317:7): [True: 931, False: 5.05k] | | ------------------ ------------------ 3100| 5.98k| if (fc < 128 && (mb->ctypes[fc] & ctype_digit) != 0) ------------------ | | 582| 5.05k|#define ctype_digit 0x08 ------------------ | Branch (3100:15): [True: 5.05k, False: 931] | Branch (3100:27): [True: 840, False: 4.21k] ------------------ 3101| 5.14k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 840| {\ | | 555| 840| rrc = ra;\ | | 556| 840| goto RETURN_SWITCH;\ | | 557| 840| } ------------------ 3102| 5.14k| } 3103| 2.17k| break; 3104| | 3105| 21.1k| case OP_DIGIT: ------------------ | Branch (3105:9): [True: 21.1k, False: 277k] ------------------ 3106| 23.3k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 23.3k|#define Lmin F->temp_32[0] ------------------ | Branch (3106:21): [True: 21.7k, False: 1.57k] ------------------ 3107| 21.7k| { 3108| 21.7k| uint32_t cc; 3109| 21.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 21.7k|#define Feptr F->eptr ------------------ | Branch (3109:15): [True: 2.02k, False: 19.7k] ------------------ 3110| 2.02k| { 3111| 2.02k| SCHECK_PARTIAL(); ------------------ | | 533| 2.02k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 830, False: 1.19k] | | ------------------ | | 534| 2.02k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 830|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 322, False: 508] | | | Branch (534:38): [True: 236, False: 272] | | ------------------ | | 535| 2.02k| { \ | | 536| 558| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 558|#define TRUE 1 | | ------------------ | | 537| 558| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 552] | | ------------------ | | 538| 558| } ------------------ 3112| 2.01k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.01k| {\ | | 555| 2.01k| rrc = ra;\ | | 556| 2.01k| goto RETURN_SWITCH;\ | | 557| 2.01k| } ------------------ 3113| 0| } 3114| 19.7k| cc = UCHAR21(Feptr); ------------------ | | 243| 19.7k|#define UCHAR21(eptr) (*(eptr)) ------------------ 3115| 19.7k| if (cc >= 128 || (mb->ctypes[cc] & ctype_digit) == 0) ------------------ | | 582| 19.1k|#define ctype_digit 0x08 ------------------ | Branch (3115:15): [True: 636, False: 19.1k] | Branch (3115:28): [True: 16.9k, False: 2.18k] ------------------ 3116| 17.5k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 17.5k| {\ | | 555| 17.5k| rrc = ra;\ | | 556| 17.5k| goto RETURN_SWITCH;\ | | 557| 17.5k| } ------------------ 3117| 2.18k| Feptr++; ------------------ | | 177| 2.18k|#define Feptr F->eptr ------------------ 3118| | /* No need to skip more code units - we know it has only one. */ 3119| 2.18k| } 3120| 1.57k| break; 3121| | 3122| 3.84k| case OP_NOT_WHITESPACE: ------------------ | Branch (3122:9): [True: 3.84k, False: 295k] ------------------ 3123| 8.38k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 8.38k|#define Lmin F->temp_32[0] ------------------ | Branch (3123:21): [True: 6.81k, False: 1.57k] ------------------ 3124| 6.81k| { 3125| 6.81k| uint32_t cc; 3126| 6.81k| if (Feptr >= mb->end_subject) ------------------ | | 177| 6.81k|#define Feptr F->eptr ------------------ | Branch (3126:15): [True: 1.91k, False: 4.90k] ------------------ 3127| 1.91k| { 3128| 1.91k| SCHECK_PARTIAL(); ------------------ | | 533| 1.91k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 726, False: 1.18k] | | ------------------ | | 534| 1.91k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 726|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 233, False: 493] | | | Branch (534:38): [True: 252, False: 241] | | ------------------ | | 535| 1.91k| { \ | | 536| 485| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 485|#define TRUE 1 | | ------------------ | | 537| 485| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 20|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 20, False: 465] | | ------------------ | | 538| 485| } ------------------ 3129| 1.89k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.89k| {\ | | 555| 1.89k| rrc = ra;\ | | 556| 1.89k| goto RETURN_SWITCH;\ | | 557| 1.89k| } ------------------ 3130| 0| } 3131| 4.90k| cc = UCHAR21(Feptr); ------------------ | | 243| 4.90k|#define UCHAR21(eptr) (*(eptr)) ------------------ 3132| 4.90k| if (cc < 128 && (mb->ctypes[cc] & ctype_space) != 0) ------------------ | | 579| 4.43k|#define ctype_space 0x01 ------------------ | Branch (3132:15): [True: 4.43k, False: 470] | Branch (3132:27): [True: 359, False: 4.07k] ------------------ 3133| 4.54k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 359| {\ | | 555| 359| rrc = ra;\ | | 556| 359| goto RETURN_SWITCH;\ | | 557| 359| } ------------------ 3134| 4.54k| Feptr++; ------------------ | | 177| 4.54k|#define Feptr F->eptr ------------------ 3135| 4.54k| ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++); ------------------ | | 353| 5.31k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 4.49k, False: 821] | | | Branch (353:24): [True: 773, False: 3.72k] | | ------------------ ------------------ 3136| 4.54k| } 3137| 1.57k| break; 3138| | 3139| 20.0k| case OP_WHITESPACE: ------------------ | Branch (3139:9): [True: 20.0k, False: 279k] ------------------ 3140| 20.9k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 20.9k|#define Lmin F->temp_32[0] ------------------ | Branch (3140:21): [True: 20.5k, False: 406] ------------------ 3141| 20.5k| { 3142| 20.5k| uint32_t cc; 3143| 20.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 20.5k|#define Feptr F->eptr ------------------ | Branch (3143:15): [True: 2.02k, False: 18.5k] ------------------ 3144| 2.02k| { 3145| 2.02k| SCHECK_PARTIAL(); ------------------ | | 533| 2.02k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 856, False: 1.17k] | | ------------------ | | 534| 2.02k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 856|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 296, False: 560] | | | Branch (534:38): [True: 234, False: 326] | | ------------------ | | 535| 2.02k| { \ | | 536| 530| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 530|#define TRUE 1 | | ------------------ | | 537| 530| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 8|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 8, False: 522] | | ------------------ | | 538| 530| } ------------------ 3146| 2.02k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.02k| {\ | | 555| 2.02k| rrc = ra;\ | | 556| 2.02k| goto RETURN_SWITCH;\ | | 557| 2.02k| } ------------------ 3147| 0| } 3148| 18.5k| cc = UCHAR21(Feptr); ------------------ | | 243| 18.5k|#define UCHAR21(eptr) (*(eptr)) ------------------ 3149| 18.5k| if (cc >= 128 || (mb->ctypes[cc] & ctype_space) == 0) ------------------ | | 579| 18.0k|#define ctype_space 0x01 ------------------ | Branch (3149:15): [True: 451, False: 18.0k] | Branch (3149:28): [True: 17.1k, False: 872] ------------------ 3150| 17.6k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 17.6k| {\ | | 555| 17.6k| rrc = ra;\ | | 556| 17.6k| goto RETURN_SWITCH;\ | | 557| 17.6k| } ------------------ 3151| 872| Feptr++; ------------------ | | 177| 872|#define Feptr F->eptr ------------------ 3152| | /* No need to skip more code units - we know it has only one. */ 3153| 872| } 3154| 406| break; 3155| | 3156| 4.35k| case OP_NOT_WORDCHAR: ------------------ | Branch (3156:9): [True: 4.35k, False: 294k] ------------------ 3157| 7.05k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 7.05k|#define Lmin F->temp_32[0] ------------------ | Branch (3157:21): [True: 5.11k, False: 1.93k] ------------------ 3158| 5.11k| { 3159| 5.11k| uint32_t cc; 3160| 5.11k| if (Feptr >= mb->end_subject) ------------------ | | 177| 5.11k|#define Feptr F->eptr ------------------ | Branch (3160:15): [True: 1.73k, False: 3.38k] ------------------ 3161| 1.73k| { 3162| 1.73k| SCHECK_PARTIAL(); ------------------ | | 533| 1.73k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 836, False: 900] | | ------------------ | | 534| 1.73k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 836|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 343, False: 493] | | | Branch (534:38): [True: 250, False: 243] | | ------------------ | | 535| 1.73k| { \ | | 536| 593| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 593|#define TRUE 1 | | ------------------ | | 537| 593| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 10|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 10, False: 583] | | ------------------ | | 538| 593| } ------------------ 3163| 1.72k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.72k| {\ | | 555| 1.72k| rrc = ra;\ | | 556| 1.72k| goto RETURN_SWITCH;\ | | 557| 1.72k| } ------------------ 3164| 0| } 3165| 3.38k| cc = UCHAR21(Feptr); ------------------ | | 243| 3.38k|#define UCHAR21(eptr) (*(eptr)) ------------------ 3166| 3.38k| if (cc < 128 && (mb->ctypes[cc] & ctype_word) != 0) ------------------ | | 583| 2.91k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (3166:15): [True: 2.91k, False: 464] | Branch (3166:27): [True: 686, False: 2.23k] ------------------ 3167| 2.69k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 686| {\ | | 555| 686| rrc = ra;\ | | 556| 686| goto RETURN_SWITCH;\ | | 557| 686| } ------------------ 3168| 2.69k| Feptr++; ------------------ | | 177| 2.69k|#define Feptr F->eptr ------------------ 3169| 2.69k| ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++); ------------------ | | 353| 3.45k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 2.79k, False: 654] | | | Branch (353:24): [True: 753, False: 2.04k] | | ------------------ ------------------ 3170| 2.69k| } 3171| 1.93k| break; 3172| | 3173| 14.2k| case OP_WORDCHAR: ------------------ | Branch (3173:9): [True: 14.2k, False: 284k] ------------------ 3174| 19.4k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 19.4k|#define Lmin F->temp_32[0] ------------------ | Branch (3174:21): [True: 14.8k, False: 4.61k] ------------------ 3175| 14.8k| { 3176| 14.8k| uint32_t cc; 3177| 14.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 14.8k|#define Feptr F->eptr ------------------ | Branch (3177:15): [True: 2.15k, False: 12.7k] ------------------ 3178| 2.15k| { 3179| 2.15k| SCHECK_PARTIAL(); ------------------ | | 533| 2.15k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 870, False: 1.28k] | | ------------------ | | 534| 2.15k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 870|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 310, False: 560] | | | Branch (534:38): [True: 236, False: 324] | | ------------------ | | 535| 2.15k| { \ | | 536| 546| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 546|#define TRUE 1 | | ------------------ | | 537| 546| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 5, False: 541] | | ------------------ | | 538| 546| } ------------------ 3180| 2.14k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.14k| {\ | | 555| 2.14k| rrc = ra;\ | | 556| 2.14k| goto RETURN_SWITCH;\ | | 557| 2.14k| } ------------------ 3181| 0| } 3182| 12.7k| cc = UCHAR21(Feptr); ------------------ | | 243| 12.7k|#define UCHAR21(eptr) (*(eptr)) ------------------ 3183| 12.7k| if (cc >= 128 || (mb->ctypes[cc] & ctype_word) == 0) ------------------ | | 583| 12.1k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (3183:15): [True: 588, False: 12.1k] | Branch (3183:28): [True: 6.89k, False: 5.21k] ------------------ 3184| 7.48k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 7.48k| {\ | | 555| 7.48k| rrc = ra;\ | | 556| 7.48k| goto RETURN_SWITCH;\ | | 557| 7.48k| } ------------------ 3185| 5.21k| Feptr++; ------------------ | | 177| 5.21k|#define Feptr F->eptr ------------------ 3186| | /* No need to skip more code units - we know it has only one. */ 3187| 5.21k| } 3188| 4.61k| break; 3189| | 3190| 4.61k| default: ------------------ | Branch (3190:9): [True: 0, False: 299k] ------------------ 3191| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 3192| 299k| } /* End switch(Lctype) */ 3193| | 3194| 398k| else 3195| 398k|#endif /* SUPPORT_UNICODE */ 3196| | 3197| | /* Code for the non-UTF case for minimum matching of operators other 3198| | than OP_PROP and OP_NOTPROP. */ 3199| | 3200| 398k| switch(Lctype) ------------------ | | 2600| 398k|#define Lctype F->temp_32[2] ------------------ 3201| 398k| { 3202| 108k| case OP_ANY: ------------------ | Branch (3202:9): [True: 108k, False: 290k] ------------------ 3203| 241k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 241k|#define Lmin F->temp_32[0] ------------------ | Branch (3203:21): [True: 152k, False: 89.3k] ------------------ 3204| 152k| { 3205| 152k| if (Feptr >= mb->end_subject) ------------------ | | 177| 152k|#define Feptr F->eptr ------------------ | Branch (3205:15): [True: 16.4k, False: 136k] ------------------ 3206| 16.4k| { 3207| 16.4k| SCHECK_PARTIAL(); ------------------ | | 533| 16.4k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 4.95k, False: 11.4k] | | ------------------ | | 534| 16.4k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 4.95k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 3.42k, False: 1.53k] | | | Branch (534:38): [True: 545, False: 988] | | ------------------ | | 535| 16.4k| { \ | | 536| 3.97k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 3.97k|#define TRUE 1 | | ------------------ | | 537| 3.97k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 45|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 45, False: 3.92k] | | ------------------ | | 538| 3.97k| } ------------------ 3208| 16.3k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 16.3k| {\ | | 555| 16.3k| rrc = ra;\ | | 556| 16.3k| goto RETURN_SWITCH;\ | | 557| 16.3k| } ------------------ 3209| 0| } 3210| 136k| if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 479| 136k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 136k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 136k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 2.65k, False: 133k] | | | Branch (479:4): [True: 16.9k, False: 119k] | | ------------------ | | 480| 136k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 16.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 33.9k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 16.9k, False: 0] | | ------------------ | | 481| 16.9k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 16.9k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 16.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 16.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 16.9k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 885, False: 16.0k] | | ------------------ | | 482| 16.9k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 16.9k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 136k| : \ | | 484| 136k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 119k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 119k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 119k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 116k, False: 2.91k] | | ------------------ | | 485| 119k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 116k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 116k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 2.59k, False: 113k] | | ------------------ | | 486| 119k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 2.59k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.35k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.35k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.24k, False: 1.35k] | | | Branch (486:30): [True: 525, False: 831] | | ------------------ | | 487| 119k| ) \ | | 488| 136k| ) ------------------ if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.65k| {\ | | 555| 2.65k| rrc = ra;\ | | 556| 2.65k| goto RETURN_SWITCH;\ | | 557| 2.65k| } ------------------ 3211| 133k| if (mb->partial != 0 && ------------------ | Branch (3211:15): [True: 32.3k, False: 101k] ------------------ 3212| 133k| Feptr + 1 >= mb->end_subject && ------------------ | | 177| 32.3k|#define Feptr F->eptr ------------------ | Branch (3212:15): [True: 3.43k, False: 28.9k] ------------------ 3213| 133k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 3.43k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 136k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (3213:15): [True: 2.97k, False: 463] ------------------ 3214| 133k| NLBLOCK->nllen == 2 && ------------------ | | 59| 2.97k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (3214:15): [True: 937, False: 2.03k] ------------------ 3215| 133k| *Feptr == NLBLOCK->nl[0]) ------------------ | | 177| 937|#define Feptr F->eptr ------------------ *Feptr == NLBLOCK->nl[0]) ------------------ | | 59| 937|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (3215:15): [True: 538, False: 399] ------------------ 3216| 538| { 3217| 538| mb->hitend = TRUE; ------------------ | | 70| 538|#define TRUE 1 ------------------ 3218| 538| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (3218:17): [True: 5, False: 533] ------------------ 3219| 538| } 3220| 133k| Feptr++; ------------------ | | 177| 133k|#define Feptr F->eptr ------------------ 3221| 133k| } 3222| 89.3k| break; 3223| | 3224| 89.3k| case OP_ALLANY: ------------------ | Branch (3224:9): [True: 6.23k, False: 392k] ------------------ 3225| 6.23k| if (Feptr > mb->end_subject - Lmin) ------------------ | | 177| 6.23k|#define Feptr F->eptr ------------------ if (Feptr > mb->end_subject - Lmin) ------------------ | | 2598| 6.23k|#define Lmin F->temp_32[0] ------------------ | Branch (3225:13): [True: 2.11k, False: 4.11k] ------------------ 3226| 2.11k| { 3227| 2.11k| SCHECK_PARTIAL(); ------------------ | | 533| 2.11k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 786, False: 1.33k] | | ------------------ | | 534| 2.11k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 786|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 264, False: 522] | | | Branch (534:38): [True: 250, False: 272] | | ------------------ | | 535| 2.11k| { \ | | 536| 514| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 514|#define TRUE 1 | | ------------------ | | 537| 514| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 498] | | ------------------ | | 538| 514| } ------------------ 3228| 2.10k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.10k| {\ | | 555| 2.10k| rrc = ra;\ | | 556| 2.10k| goto RETURN_SWITCH;\ | | 557| 2.10k| } ------------------ 3229| 0| } 3230| 4.11k| Feptr += Lmin; ------------------ | | 177| 4.11k|#define Feptr F->eptr ------------------ Feptr += Lmin; ------------------ | | 2598| 4.11k|#define Lmin F->temp_32[0] ------------------ 3231| 4.11k| break; 3232| | 3233| | /* This OP_ANYBYTE case will never be reached because \C gets turned 3234| | into OP_ALLANY in non-UTF mode. Cut out the code so that coverage 3235| | reports don't complain about it's never being used. */ 3236| | 3237| |/* case OP_ANYBYTE: 3238| |* if (Feptr > mb->end_subject - Lmin) 3239| |* { 3240| |* SCHECK_PARTIAL(); 3241| |* RRETURN(MATCH_NOMATCH); 3242| |* } 3243| |* Feptr += Lmin; 3244| |* break; 3245| |*/ 3246| 38.8k| case OP_ANYNL: ------------------ | Branch (3246:9): [True: 38.8k, False: 359k] ------------------ 3247| 44.1k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 44.1k|#define Lmin F->temp_32[0] ------------------ | Branch (3247:21): [True: 40.0k, False: 4.09k] ------------------ 3248| 40.0k| { 3249| 40.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 40.0k|#define Feptr F->eptr ------------------ | Branch (3249:15): [True: 6.03k, False: 33.9k] ------------------ 3250| 6.03k| { 3251| 6.03k| SCHECK_PARTIAL(); ------------------ | | 533| 6.03k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.43k, False: 4.59k] | | ------------------ | | 534| 6.03k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.43k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 447, False: 991] | | | Branch (534:38): [True: 479, False: 512] | | ------------------ | | 535| 6.03k| { \ | | 536| 926| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 926|#define TRUE 1 | | ------------------ | | 537| 926| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 48|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 48, False: 878] | | ------------------ | | 538| 926| } ------------------ 3252| 5.98k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.98k| {\ | | 555| 5.98k| rrc = ra;\ | | 556| 5.98k| goto RETURN_SWITCH;\ | | 557| 5.98k| } ------------------ 3253| 0| } 3254| 33.9k| switch(*Feptr++) ------------------ | | 177| 33.9k|#define Feptr F->eptr ------------------ 3255| 33.9k| { 3256| 28.7k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 28.7k| {\ | | 555| 28.7k| rrc = ra;\ | | 556| 28.7k| goto RETURN_SWITCH;\ | | 557| 28.7k| } ------------------ | Branch (3256:13): [True: 28.7k, False: 5.26k] ------------------ 3257| | 3258| 1.47k| case CHAR_CR: ------------------ | | 972| 1.47k|#define CHAR_CR '\015' ------------------ | Branch (3258:13): [True: 1.47k, False: 32.5k] ------------------ 3259| 1.47k| if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 1.47k|#define Feptr F->eptr ------------------ if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 883|#define Feptr F->eptr ------------------ if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 973| 883|#define CHAR_LF '\012' ------------------ if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 321|#define Feptr F->eptr ------------------ | Branch (3259:17): [True: 883, False: 587] | Branch (3259:44): [True: 321, False: 562] ------------------ 3260| 1.47k| break; 3261| | 3262| 1.33k| case CHAR_LF: ------------------ | | 973| 1.33k|#define CHAR_LF '\012' ------------------ | Branch (3262:13): [True: 1.33k, False: 32.6k] ------------------ 3263| 1.33k| break; 3264| | 3265| 1.40k| case CHAR_VT: ------------------ | | 970| 1.40k|#define CHAR_VT '\013' ------------------ | Branch (3265:13): [True: 1.40k, False: 32.5k] ------------------ 3266| 1.89k| case CHAR_FF: ------------------ | | 971| 1.89k|#define CHAR_FF '\014' ------------------ | Branch (3266:13): [True: 487, False: 33.5k] ------------------ 3267| 2.45k| case CHAR_NEL: ------------------ | | 975| 2.45k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (3267:13): [True: 564, False: 33.4k] ------------------ 3268| |#if PCRE2_CODE_UNIT_WIDTH != 8 3269| | case 0x2028: 3270| | case 0x2029: 3271| |#endif 3272| 2.45k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH); ------------------ | | 217| 2.45k|#define PCRE2_BSR_ANYCRLF 2 ------------------ if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ | Branch (3272:17): [True: 0, False: 2.45k] ------------------ 3273| 2.45k| break; 3274| 33.9k| } 3275| 33.9k| } 3276| 4.09k| break; 3277| | 3278| 14.7k| case OP_NOT_HSPACE: ------------------ | Branch (3278:9): [True: 14.7k, False: 384k] ------------------ 3279| 38.5k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 38.5k|#define Lmin F->temp_32[0] ------------------ | Branch (3279:21): [True: 31.4k, False: 7.07k] ------------------ 3280| 31.4k| { 3281| 31.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 31.4k|#define Feptr F->eptr ------------------ | Branch (3281:15): [True: 6.03k, False: 25.3k] ------------------ 3282| 6.03k| { 3283| 6.03k| SCHECK_PARTIAL(); ------------------ | | 533| 6.03k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.23k, False: 4.80k] | | ------------------ | | 534| 6.03k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.23k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 381, False: 855] | | | Branch (534:38): [True: 466, False: 389] | | ------------------ | | 535| 6.03k| { \ | | 536| 847| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 847|#define TRUE 1 | | ------------------ | | 537| 847| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 52|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 52, False: 795] | | ------------------ | | 538| 847| } ------------------ 3284| 5.98k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.98k| {\ | | 555| 5.98k| rrc = ra;\ | | 556| 5.98k| goto RETURN_SWITCH;\ | | 557| 5.98k| } ------------------ 3285| 0| } 3286| 25.3k| switch(*Feptr++) ------------------ | | 177| 25.3k|#define Feptr F->eptr ------------------ 3287| 25.3k| { 3288| 23.8k| default: break; ------------------ | Branch (3288:13): [True: 23.8k, False: 1.59k] ------------------ 3289| 23.8k| HSPACE_BYTE_CASES: ------------------ | | 407| 464| case CHAR_HT: \ | | ------------------ | | | | 969| 464|#define CHAR_HT '\011' | | ------------------ | | | Branch (407:3): [True: 464, False: 24.9k] | | ------------------ | | 408| 862| case CHAR_SPACE: \ | | ------------------ | | | | 982| 862|#define CHAR_SPACE '\040' | | ------------------ | | | Branch (408:3): [True: 398, False: 24.9k] | | ------------------ | | 409| 23.8k| case CHAR_NBSP | | ------------------ | | | | 1077| 23.8k|#define CHAR_NBSP ((unsigned char)'\xa0') | | ------------------ ------------------ 3290| |#if PCRE2_CODE_UNIT_WIDTH != 8 3291| | HSPACE_MULTIBYTE_CASES: 3292| |#endif 3293| 1.59k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.59k| {\ | | 555| 1.59k| rrc = ra;\ | | 556| 1.59k| goto RETURN_SWITCH;\ | | 557| 1.59k| } ------------------ 3294| 25.3k| } 3295| 25.3k| } 3296| 7.07k| break; 3297| | 3298| 34.8k| case OP_HSPACE: ------------------ | Branch (3298:9): [True: 34.8k, False: 363k] ------------------ 3299| 36.8k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 36.8k|#define Lmin F->temp_32[0] ------------------ | Branch (3299:21): [True: 35.3k, False: 1.53k] ------------------ 3300| 35.3k| { 3301| 35.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 35.3k|#define Feptr F->eptr ------------------ | Branch (3301:15): [True: 5.82k, False: 29.4k] ------------------ 3302| 5.82k| { 3303| 5.82k| SCHECK_PARTIAL(); ------------------ | | 533| 5.82k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.25k, False: 4.56k] | | ------------------ | | 534| 5.82k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.25k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 314, False: 940] | | | Branch (534:38): [True: 446, False: 494] | | ------------------ | | 535| 5.82k| { \ | | 536| 760| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 760|#define TRUE 1 | | ------------------ | | 537| 760| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 21|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 21, False: 739] | | ------------------ | | 538| 760| } ------------------ 3304| 5.79k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.79k| {\ | | 555| 5.79k| rrc = ra;\ | | 556| 5.79k| goto RETURN_SWITCH;\ | | 557| 5.79k| } ------------------ 3305| 0| } 3306| 29.4k| switch(*Feptr++) ------------------ | | 177| 29.4k|#define Feptr F->eptr ------------------ 3307| 29.4k| { 3308| 27.4k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 27.4k| {\ | | 555| 27.4k| rrc = ra;\ | | 556| 27.4k| goto RETURN_SWITCH;\ | | 557| 27.4k| } ------------------ | Branch (3308:13): [True: 27.4k, False: 2.00k] ------------------ 3309| 3.87k| HSPACE_BYTE_CASES: ------------------ | | 407| 700| case CHAR_HT: \ | | ------------------ | | | | 969| 700|#define CHAR_HT '\011' | | ------------------ | | | Branch (407:3): [True: 700, False: 28.7k] | | ------------------ | | 408| 1.17k| case CHAR_SPACE: \ | | ------------------ | | | | 982| 1.17k|#define CHAR_SPACE '\040' | | ------------------ | | | Branch (408:3): [True: 477, False: 29.0k] | | ------------------ | | 409| 2.00k| case CHAR_NBSP | | ------------------ | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | ------------------ ------------------ 3310| |#if PCRE2_CODE_UNIT_WIDTH != 8 3311| | HSPACE_MULTIBYTE_CASES: 3312| |#endif 3313| 3.87k| break; 3314| 29.4k| } 3315| 29.4k| } 3316| 1.53k| break; 3317| | 3318| 11.1k| case OP_NOT_VSPACE: ------------------ | Branch (3318:9): [True: 11.1k, False: 387k] ------------------ 3319| 22.9k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 22.9k|#define Lmin F->temp_32[0] ------------------ | Branch (3319:21): [True: 17.5k, False: 5.36k] ------------------ 3320| 17.5k| { 3321| 17.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 17.5k|#define Feptr F->eptr ------------------ | Branch (3321:15): [True: 3.72k, False: 13.8k] ------------------ 3322| 3.72k| { 3323| 3.72k| SCHECK_PARTIAL(); ------------------ | | 533| 3.72k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.49k, False: 2.23k] | | ------------------ | | 534| 3.72k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.49k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 496, False: 998] | | | Branch (534:38): [True: 516, False: 482] | | ------------------ | | 535| 3.72k| { \ | | 536| 1.01k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.01k|#define TRUE 1 | | ------------------ | | 537| 1.01k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 996] | | ------------------ | | 538| 1.01k| } ------------------ 3324| 3.71k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.71k| {\ | | 555| 3.71k| rrc = ra;\ | | 556| 3.71k| goto RETURN_SWITCH;\ | | 557| 3.71k| } ------------------ 3325| 0| } 3326| 13.8k| switch(*Feptr++) ------------------ | | 177| 13.8k|#define Feptr F->eptr ------------------ 3327| 13.8k| { 3328| 2.07k| VSPACE_BYTE_CASES: ------------------ | | 423| 395| case CHAR_LF: \ | | ------------------ | | | | 973| 395|#define CHAR_LF '\012' | | ------------------ | | | Branch (423:3): [True: 395, False: 13.4k] | | ------------------ | | 424| 664| case CHAR_VT: \ | | ------------------ | | | | 970| 664|#define CHAR_VT '\013' | | ------------------ | | | Branch (424:3): [True: 269, False: 13.5k] | | ------------------ | | 425| 1.13k| case CHAR_FF: \ | | ------------------ | | | | 971| 1.13k|#define CHAR_FF '\014' | | ------------------ | | | Branch (425:3): [True: 472, False: 13.3k] | | ------------------ | | 426| 1.70k| case CHAR_CR: \ | | ------------------ | | | | 972| 1.70k|#define CHAR_CR '\015' | | ------------------ | | | Branch (426:3): [True: 570, False: 13.2k] | | ------------------ | | 427| 2.07k| case CHAR_NEL | | ------------------ | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | ------------------ ------------------ 3329| |#if PCRE2_CODE_UNIT_WIDTH != 8 3330| | VSPACE_MULTIBYTE_CASES: 3331| |#endif 3332| 2.07k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.07k| {\ | | 555| 2.07k| rrc = ra;\ | | 556| 2.07k| goto RETURN_SWITCH;\ | | 557| 2.07k| } ------------------ 3333| 11.7k| default: break; ------------------ | Branch (3333:13): [True: 11.7k, False: 2.07k] ------------------ 3334| 13.8k| } 3335| 13.8k| } 3336| 5.36k| break; 3337| | 3338| 33.9k| case OP_VSPACE: ------------------ | Branch (3338:9): [True: 33.9k, False: 364k] ------------------ 3339| 36.6k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 36.6k|#define Lmin F->temp_32[0] ------------------ | Branch (3339:21): [True: 34.5k, False: 2.12k] ------------------ 3340| 34.5k| { 3341| 34.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 34.5k|#define Feptr F->eptr ------------------ | Branch (3341:15): [True: 4.52k, False: 30.0k] ------------------ 3342| 4.52k| { 3343| 4.52k| SCHECK_PARTIAL(); ------------------ | | 533| 4.52k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.41k, False: 3.10k] | | ------------------ | | 534| 4.52k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.41k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 449, False: 966] | | | Branch (534:38): [True: 486, False: 480] | | ------------------ | | 535| 4.52k| { \ | | 536| 935| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 935|#define TRUE 1 | | ------------------ | | 537| 935| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 13|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 13, False: 922] | | ------------------ | | 538| 935| } ------------------ 3344| 4.50k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.50k| {\ | | 555| 4.50k| rrc = ra;\ | | 556| 4.50k| goto RETURN_SWITCH;\ | | 557| 4.50k| } ------------------ 3345| 0| } 3346| 30.0k| switch(*Feptr++) ------------------ | | 177| 30.0k|#define Feptr F->eptr ------------------ 3347| 30.0k| { 3348| 27.3k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 27.3k| {\ | | 555| 27.3k| rrc = ra;\ | | 556| 27.3k| goto RETURN_SWITCH;\ | | 557| 27.3k| } ------------------ | Branch (3348:13): [True: 27.3k, False: 2.72k] ------------------ 3349| 8.99k| VSPACE_BYTE_CASES: ------------------ | | 423| 826| case CHAR_LF: \ | | ------------------ | | | | 973| 826|#define CHAR_LF '\012' | | ------------------ | | | Branch (423:3): [True: 826, False: 29.2k] | | ------------------ | | 424| 1.33k| case CHAR_VT: \ | | ------------------ | | | | 970| 1.33k|#define CHAR_VT '\013' | | ------------------ | | | Branch (424:3): [True: 508, False: 29.5k] | | ------------------ | | 425| 1.82k| case CHAR_FF: \ | | ------------------ | | | | 971| 1.82k|#define CHAR_FF '\014' | | ------------------ | | | Branch (425:3): [True: 491, False: 29.5k] | | ------------------ | | 426| 2.28k| case CHAR_CR: \ | | ------------------ | | | | 972| 2.28k|#define CHAR_CR '\015' | | ------------------ | | | Branch (426:3): [True: 460, False: 29.5k] | | ------------------ | | 427| 2.72k| case CHAR_NEL | | ------------------ | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | ------------------ ------------------ 3350| |#if PCRE2_CODE_UNIT_WIDTH != 8 3351| | VSPACE_MULTIBYTE_CASES: 3352| |#endif 3353| 8.99k| break; 3354| 30.0k| } 3355| 30.0k| } 3356| 2.12k| break; 3357| | 3358| 8.84k| case OP_NOT_DIGIT: ------------------ | Branch (3358:9): [True: 8.84k, False: 389k] ------------------ 3359| 16.4k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 16.4k|#define Lmin F->temp_32[0] ------------------ | Branch (3359:21): [True: 11.5k, False: 4.86k] ------------------ 3360| 11.5k| { 3361| 11.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 11.5k|#define Feptr F->eptr ------------------ | Branch (3361:15): [True: 3.02k, False: 8.53k] ------------------ 3362| 3.02k| { 3363| 3.02k| SCHECK_PARTIAL(); ------------------ | | 533| 3.02k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.29k, False: 1.72k] | | ------------------ | | 534| 3.02k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.29k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 528, False: 770] | | | Branch (534:38): [True: 345, False: 425] | | ------------------ | | 535| 3.02k| { \ | | 536| 873| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 873|#define TRUE 1 | | ------------------ | | 537| 873| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 14|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 14, False: 859] | | ------------------ | | 538| 873| } ------------------ 3364| 3.01k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.01k| {\ | | 555| 3.01k| rrc = ra;\ | | 556| 3.01k| goto RETURN_SWITCH;\ | | 557| 3.01k| } ------------------ 3365| 0| } 3366| 8.53k| if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0) ------------------ | | 212| 8.53k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 17.0k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0) ------------------ | | 177| 8.53k|#define Feptr F->eptr ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0) ------------------ | | 582| 8.53k|#define ctype_digit 0x08 ------------------ | Branch (3366:34): [True: 954, False: 7.57k] ------------------ 3367| 7.57k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 954| {\ | | 555| 954| rrc = ra;\ | | 556| 954| goto RETURN_SWITCH;\ | | 557| 954| } ------------------ 3368| 7.57k| Feptr++; ------------------ | | 177| 7.57k|#define Feptr F->eptr ------------------ 3369| 7.57k| } 3370| 4.86k| break; 3371| | 3372| 26.9k| case OP_DIGIT: ------------------ | Branch (3372:9): [True: 26.9k, False: 371k] ------------------ 3373| 29.9k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 29.9k|#define Lmin F->temp_32[0] ------------------ | Branch (3373:21): [True: 27.6k, False: 2.27k] ------------------ 3374| 27.6k| { 3375| 27.6k| if (Feptr >= mb->end_subject) ------------------ | | 177| 27.6k|#define Feptr F->eptr ------------------ | Branch (3375:15): [True: 3.26k, False: 24.4k] ------------------ 3376| 3.26k| { 3377| 3.26k| SCHECK_PARTIAL(); ------------------ | | 533| 3.26k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.36k, False: 1.89k] | | ------------------ | | 534| 3.26k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.36k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 360, False: 1.00k] | | | Branch (534:38): [True: 450, False: 558] | | ------------------ | | 535| 3.26k| { \ | | 536| 810| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 810|#define TRUE 1 | | ------------------ | | 537| 810| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 10|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 10, False: 800] | | ------------------ | | 538| 810| } ------------------ 3378| 3.25k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.25k| {\ | | 555| 3.25k| rrc = ra;\ | | 556| 3.25k| goto RETURN_SWITCH;\ | | 557| 3.25k| } ------------------ 3379| 0| } 3380| 24.4k| if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0) ------------------ | | 212| 24.4k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 48.8k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0) ------------------ | | 177| 24.4k|#define Feptr F->eptr ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0) ------------------ | | 582| 24.4k|#define ctype_digit 0x08 ------------------ | Branch (3380:15): [Folded - Ignored] | Branch (3380:35): [True: 21.4k, False: 3.00k] ------------------ 3381| 21.4k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 21.4k| {\ | | 555| 21.4k| rrc = ra;\ | | 556| 21.4k| goto RETURN_SWITCH;\ | | 557| 21.4k| } ------------------ 3382| 3.00k| Feptr++; ------------------ | | 177| 3.00k|#define Feptr F->eptr ------------------ 3383| 3.00k| } 3384| 2.27k| break; 3385| | 3386| 22.3k| case OP_NOT_WHITESPACE: ------------------ | Branch (3386:9): [True: 22.3k, False: 376k] ------------------ 3387| 64.1k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 64.1k|#define Lmin F->temp_32[0] ------------------ | Branch (3387:21): [True: 52.7k, False: 11.3k] ------------------ 3388| 52.7k| { 3389| 52.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 52.7k|#define Feptr F->eptr ------------------ | Branch (3389:15): [True: 9.01k, False: 43.7k] ------------------ 3390| 9.01k| { 3391| 9.01k| SCHECK_PARTIAL(); ------------------ | | 533| 9.01k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.43k, False: 7.57k] | | ------------------ | | 534| 9.01k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.43k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 542, False: 893] | | | Branch (534:38): [True: 467, False: 426] | | ------------------ | | 535| 9.01k| { \ | | 536| 1.00k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.00k|#define TRUE 1 | | ------------------ | | 537| 1.00k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 70|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 70, False: 939] | | ------------------ | | 538| 1.00k| } ------------------ 3392| 8.94k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 8.94k| {\ | | 555| 8.94k| rrc = ra;\ | | 556| 8.94k| goto RETURN_SWITCH;\ | | 557| 8.94k| } ------------------ 3393| 0| } 3394| 43.7k| if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0) ------------------ | | 212| 43.7k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 87.4k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0) ------------------ | | 177| 43.7k|#define Feptr F->eptr ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0) ------------------ | | 579| 43.7k|#define ctype_space 0x01 ------------------ | Branch (3394:34): [True: 1.97k, False: 41.7k] ------------------ 3395| 41.7k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.97k| {\ | | 555| 1.97k| rrc = ra;\ | | 556| 1.97k| goto RETURN_SWITCH;\ | | 557| 1.97k| } ------------------ 3396| 41.7k| Feptr++; ------------------ | | 177| 41.7k|#define Feptr F->eptr ------------------ 3397| 41.7k| } 3398| 11.3k| break; 3399| | 3400| 40.8k| case OP_WHITESPACE: ------------------ | Branch (3400:9): [True: 40.8k, False: 357k] ------------------ 3401| 42.1k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 42.1k|#define Lmin F->temp_32[0] ------------------ | Branch (3401:21): [True: 41.3k, False: 809] ------------------ 3402| 41.3k| { 3403| 41.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 41.3k|#define Feptr F->eptr ------------------ | Branch (3403:15): [True: 5.10k, False: 36.2k] ------------------ 3404| 5.10k| { 3405| 5.10k| SCHECK_PARTIAL(); ------------------ | | 533| 5.10k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.83k, False: 3.27k] | | ------------------ | | 534| 5.10k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.83k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 329, False: 1.50k] | | | Branch (534:38): [True: 777, False: 724] | | ------------------ | | 535| 5.10k| { \ | | 536| 1.10k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.10k|#define TRUE 1 | | ------------------ | | 537| 1.10k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 20|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 20, False: 1.08k] | | ------------------ | | 538| 1.10k| } ------------------ 3406| 5.08k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.08k| {\ | | 555| 5.08k| rrc = ra;\ | | 556| 5.08k| goto RETURN_SWITCH;\ | | 557| 5.08k| } ------------------ 3407| 0| } 3408| 36.2k| if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0) ------------------ | | 212| 36.2k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 72.4k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0) ------------------ | | 177| 36.2k|#define Feptr F->eptr ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0) ------------------ | | 579| 36.2k|#define ctype_space 0x01 ------------------ | Branch (3408:15): [Folded - Ignored] | Branch (3408:35): [True: 34.9k, False: 1.23k] ------------------ 3409| 34.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 34.9k| {\ | | 555| 34.9k| rrc = ra;\ | | 556| 34.9k| goto RETURN_SWITCH;\ | | 557| 34.9k| } ------------------ 3410| 1.23k| Feptr++; ------------------ | | 177| 1.23k|#define Feptr F->eptr ------------------ 3411| 1.23k| } 3412| 809| break; 3413| | 3414| 11.3k| case OP_NOT_WORDCHAR: ------------------ | Branch (3414:9): [True: 11.3k, False: 387k] ------------------ 3415| 19.1k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 19.1k|#define Lmin F->temp_32[0] ------------------ | Branch (3415:21): [True: 13.7k, False: 5.44k] ------------------ 3416| 13.7k| { 3417| 13.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 13.7k|#define Feptr F->eptr ------------------ | Branch (3417:15): [True: 3.48k, False: 10.2k] ------------------ 3418| 3.48k| { 3419| 3.48k| SCHECK_PARTIAL(); ------------------ | | 533| 3.48k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.50k, False: 1.98k] | | ------------------ | | 534| 3.48k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.50k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 615, False: 889] | | | Branch (534:38): [True: 460, False: 429] | | ------------------ | | 535| 3.48k| { \ | | 536| 1.07k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.07k|#define TRUE 1 | | ------------------ | | 537| 1.07k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 19|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 19, False: 1.05k] | | ------------------ | | 538| 1.07k| } ------------------ 3420| 3.47k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.47k| {\ | | 555| 3.47k| rrc = ra;\ | | 556| 3.47k| goto RETURN_SWITCH;\ | | 557| 3.47k| } ------------------ 3421| 0| } 3422| 10.2k| if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0) ------------------ | | 212| 10.2k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 20.4k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0) ------------------ | | 177| 10.2k|#define Feptr F->eptr ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0) ------------------ | | 583| 10.2k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (3422:34): [True: 2.38k, False: 7.84k] ------------------ 3423| 7.84k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.38k| {\ | | 555| 2.38k| rrc = ra;\ | | 556| 2.38k| goto RETURN_SWITCH;\ | | 557| 2.38k| } ------------------ 3424| 7.84k| Feptr++; ------------------ | | 177| 7.84k|#define Feptr F->eptr ------------------ 3425| 7.84k| } 3426| 5.44k| break; 3427| | 3428| 40.2k| case OP_WORDCHAR: ------------------ | Branch (3428:9): [True: 40.2k, False: 358k] ------------------ 3429| 54.6k| for (i = 1; i <= Lmin; i++) ------------------ | | 2598| 54.6k|#define Lmin F->temp_32[0] ------------------ | Branch (3429:21): [True: 47.1k, False: 7.48k] ------------------ 3430| 47.1k| { 3431| 47.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 47.1k|#define Feptr F->eptr ------------------ | Branch (3431:15): [True: 4.93k, False: 42.2k] ------------------ 3432| 4.93k| { 3433| 4.93k| SCHECK_PARTIAL(); ------------------ | | 533| 4.93k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.98k, False: 2.95k] | | ------------------ | | 534| 4.93k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.98k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 680, False: 1.30k] | | | Branch (534:38): [True: 634, False: 666] | | ------------------ | | 535| 4.93k| { \ | | 536| 1.31k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.31k|#define TRUE 1 | | ------------------ | | 537| 1.31k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 14|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 14, False: 1.30k] | | ------------------ | | 538| 1.31k| } ------------------ 3434| 4.92k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.92k| {\ | | 555| 4.92k| rrc = ra;\ | | 556| 4.92k| goto RETURN_SWITCH;\ | | 557| 4.92k| } ------------------ 3435| 0| } 3436| 42.2k| if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0) ------------------ | | 212| 42.2k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 84.4k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0) ------------------ | | 177| 42.2k|#define Feptr F->eptr ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0) ------------------ | | 583| 42.2k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (3436:15): [Folded - Ignored] | Branch (3436:35): [True: 27.8k, False: 14.3k] ------------------ 3437| 27.8k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 27.8k| {\ | | 555| 27.8k| rrc = ra;\ | | 556| 27.8k| goto RETURN_SWITCH;\ | | 557| 27.8k| } ------------------ 3438| 14.3k| Feptr++; ------------------ | | 177| 14.3k|#define Feptr F->eptr ------------------ 3439| 14.3k| } 3440| 7.48k| break; 3441| | 3442| 7.48k| default: ------------------ | Branch (3442:9): [True: 0, False: 398k] ------------------ 3443| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 3444| 398k| } 3445| 1.09M| } 3446| | 3447| | /* If Lmin = Lmax we are done. Continue with the main loop. */ 3448| | 3449| 3.17M| if (Lmin == Lmax) continue; ------------------ | | 2598| 3.17M|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 2599| 3.17M|#define Lmax F->temp_32[1] ------------------ | Branch (3449:9): [True: 44.4k, False: 3.12M] ------------------ 3450| | 3451| | /* If minimizing, we have to test the rest of the pattern before each 3452| | subsequent match. This means we cannot use a local "notmatch" variable as 3453| | in the other cases. As all 4 temporary 32-bit values in the frame are 3454| | already in use, just test the type each time. */ 3455| | 3456| 3.12M| if (reptype == REPTYPE_MIN) ------------------ | Branch (3456:9): [True: 435k, False: 2.69M] ------------------ 3457| 435k| { 3458| 435k|#ifdef SUPPORT_UNICODE 3459| 435k| if (proptype >= 0) ------------------ | Branch (3459:11): [True: 260k, False: 175k] ------------------ 3460| 260k| { 3461| 260k| switch(proptype) 3462| 260k| { 3463| 34.2k| case PT_ANY: ------------------ | | 1275| 34.2k|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (3463:11): [True: 34.2k, False: 225k] ------------------ 3464| 34.2k| for (;;) 3465| 34.2k| { 3466| 34.2k| RMATCH(Fecode, RM208); ------------------ | | 546| 34.2k| {\ | | 547| 34.2k| start_ecode = ra;\ | | 548| 34.2k| Freturn_id = rb;\ | | ------------------ | | | | 188| 34.2k|#define Freturn_id F->return_id | | ------------------ | | 549| 34.2k| goto MATCH_RECURSE;\ | | 550| 34.2k| L_##rb:;\ | | 551| 34.1k| } ------------------ 3467| 34.1k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 34.1k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 4.82k| {\ | | 555| 4.82k| rrc = ra;\ | | 556| 4.82k| goto RETURN_SWITCH;\ | | 557| 4.82k| } ------------------ | Branch (3467:17): [True: 4.82k, False: 29.2k] ------------------ 3468| 29.2k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 29.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 29.2k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ | Branch (3468:17): [True: 0, False: 29.2k] ------------------ 3469| 29.2k| if (Feptr >= mb->end_subject) ------------------ | | 177| 29.2k|#define Feptr F->eptr ------------------ | Branch (3469:17): [True: 2.84k, False: 26.4k] ------------------ 3470| 2.84k| { 3471| 2.84k| SCHECK_PARTIAL(); ------------------ | | 533| 2.84k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.26k, False: 1.58k] | | ------------------ | | 534| 2.84k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.26k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 838, False: 425] | | | Branch (534:38): [True: 211, False: 214] | | ------------------ | | 535| 2.84k| { \ | | 536| 1.04k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.04k|#define TRUE 1 | | ------------------ | | 537| 1.04k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 1.04k] | | ------------------ | | 538| 1.04k| } ------------------ 3472| 2.84k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.84k| {\ | | 555| 2.84k| rrc = ra;\ | | 556| 2.84k| goto RETURN_SWITCH;\ | | 557| 2.84k| } ------------------ 3473| 0| } 3474| 26.4k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 26.4k| c = *eptr++; \ | | 324| 26.4k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 632| { \ | | | | 289| 632| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 218, False: 414] | | | | ------------------ | | | | 290| 632| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 632| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 208, False: 206] | | | | ------------------ | | | | 292| 414| { \ | | | | 293| 208| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 208| eptr += 2; \ | | | | 295| 208| } \ | | | | 296| 414| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 206, False: 0] | | | | ------------------ | | | | 297| 206| { \ | | | | 298| 206| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 206| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 206| eptr += 3; \ | | | | 301| 206| } \ | | | | 302| 206| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 632| } | | ------------------ | | | Branch (324:7): [True: 4.30k, False: 22.1k] | | | Branch (324:14): [True: 632, False: 3.67k] | | ------------------ ------------------ 3475| 26.4k| if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH); ------------------ | | 2600| 26.4k|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 26.4k| {\ | | 555| 26.4k| rrc = ra;\ | | 556| 26.4k| goto RETURN_SWITCH;\ | | 557| 26.4k| } ------------------ | Branch (3475:17): [True: 26.4k, False: 0] ------------------ 3476| 0| } 3477| | /* Control never gets here */ 3478| | 3479| 30.9k| case PT_LAMP: ------------------ | | 1276| 30.9k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (3479:11): [True: 30.9k, False: 229k] ------------------ 3480| 30.9k| for (;;) 3481| 58.1k| { 3482| 58.1k| int chartype; 3483| 58.1k| RMATCH(Fecode, RM209); ------------------ | | 546| 58.1k| {\ | | 547| 58.1k| start_ecode = ra;\ | | 548| 58.1k| Freturn_id = rb;\ | | ------------------ | | | | 188| 58.1k|#define Freturn_id F->return_id | | ------------------ | | 549| 58.1k| goto MATCH_RECURSE;\ | | 550| 58.1k| L_##rb:;\ | | 551| 57.9k| } ------------------ 3484| 57.9k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 57.9k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 407| {\ | | 555| 407| rrc = ra;\ | | 556| 407| goto RETURN_SWITCH;\ | | 557| 407| } ------------------ | Branch (3484:17): [True: 407, False: 57.5k] ------------------ 3485| 57.5k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 57.5k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 57.5k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 19.0k| {\ | | 555| 19.0k| rrc = ra;\ | | 556| 19.0k| goto RETURN_SWITCH;\ | | 557| 19.0k| } ------------------ | Branch (3485:17): [True: 19.0k, False: 38.5k] ------------------ 3486| 38.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 38.5k|#define Feptr F->eptr ------------------ | Branch (3486:17): [True: 2.23k, False: 36.3k] ------------------ 3487| 2.23k| { 3488| 2.23k| SCHECK_PARTIAL(); ------------------ | | 533| 2.23k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 801, False: 1.43k] | | ------------------ | | 534| 2.23k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 801|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 310, False: 491] | | | Branch (534:38): [True: 246, False: 245] | | ------------------ | | 535| 2.23k| { \ | | 536| 556| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 556|#define TRUE 1 | | ------------------ | | 537| 556| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 553] | | ------------------ | | 538| 556| } ------------------ 3489| 2.23k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.23k| {\ | | 555| 2.23k| rrc = ra;\ | | 556| 2.23k| goto RETURN_SWITCH;\ | | 557| 2.23k| } ------------------ 3490| 0| } 3491| 36.3k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 36.3k| c = *eptr++; \ | | 324| 36.3k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 890| { \ | | | | 289| 890| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 360, False: 530] | | | | ------------------ | | | | 290| 890| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 890| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 286, False: 244] | | | | ------------------ | | | | 292| 530| { \ | | | | 293| 286| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 286| eptr += 2; \ | | | | 295| 286| } \ | | | | 296| 530| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 244, False: 0] | | | | ------------------ | | | | 297| 244| { \ | | | | 298| 244| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 244| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 244| eptr += 3; \ | | | | 301| 244| } \ | | | | 302| 244| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 890| } | | ------------------ | | | Branch (324:7): [True: 4.51k, False: 31.7k] | | | Branch (324:14): [True: 890, False: 3.62k] | | ------------------ ------------------ 3492| 36.3k| chartype = UCD_CHARTYPE(fc); ------------------ | | 1857| 36.3k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 36.3k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 36.3k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 36.3k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 36.3k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 36.3k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 36.3k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 36.3k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 36.3k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 36.3k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 36.3k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3493| 36.3k| if ((chartype == ucp_Lu || ------------------ | Branch (3493:17): [True: 9.09k, False: 27.2k] | Branch (3493:18): [True: 6.96k, False: 29.3k] ------------------ 3494| 36.3k| chartype == ucp_Ll || ------------------ | Branch (3494:18): [True: 1.84k, False: 27.4k] ------------------ 3495| 36.3k| chartype == ucp_Lt) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 36.3k|#define Lctype F->temp_32[2] ------------------ | Branch (3495:18): [True: 0, False: 27.4k] ------------------ 3496| 27.2k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 9.09k| {\ | | 555| 9.09k| rrc = ra;\ | | 556| 9.09k| goto RETURN_SWITCH;\ | | 557| 9.09k| } ------------------ 3497| 27.2k| } 3498| | /* Control never gets here */ 3499| | 3500| 24.6k| case PT_GC: ------------------ | | 1277| 24.6k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (3500:11): [True: 24.6k, False: 235k] ------------------ 3501| 24.6k| for (;;) 3502| 51.4k| { 3503| 51.4k| RMATCH(Fecode, RM210); ------------------ | | 546| 51.4k| {\ | | 547| 51.4k| start_ecode = ra;\ | | 548| 51.4k| Freturn_id = rb;\ | | ------------------ | | | | 188| 51.4k|#define Freturn_id F->return_id | | ------------------ | | 549| 51.4k| goto MATCH_RECURSE;\ | | 550| 51.4k| L_##rb:;\ | | 551| 50.7k| } ------------------ 3504| 50.7k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 50.7k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 231| {\ | | 555| 231| rrc = ra;\ | | 556| 231| goto RETURN_SWITCH;\ | | 557| 231| } ------------------ | Branch (3504:17): [True: 231, False: 50.5k] ------------------ 3505| 50.5k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 50.5k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 50.5k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 18.4k| {\ | | 555| 18.4k| rrc = ra;\ | | 556| 18.4k| goto RETURN_SWITCH;\ | | 557| 18.4k| } ------------------ | Branch (3505:17): [True: 18.4k, False: 32.0k] ------------------ 3506| 32.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 32.0k|#define Feptr F->eptr ------------------ | Branch (3506:17): [True: 2.53k, False: 29.5k] ------------------ 3507| 2.53k| { 3508| 2.53k| SCHECK_PARTIAL(); ------------------ | | 533| 2.53k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 818, False: 1.71k] | | ------------------ | | 534| 2.53k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 818|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 305, False: 513] | | | Branch (534:38): [True: 252, False: 261] | | ------------------ | | 535| 2.53k| { \ | | 536| 557| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 557|#define TRUE 1 | | ------------------ | | 537| 557| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 554] | | ------------------ | | 538| 557| } ------------------ 3509| 2.52k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.52k| {\ | | 555| 2.52k| rrc = ra;\ | | 556| 2.52k| goto RETURN_SWITCH;\ | | 557| 2.52k| } ------------------ 3510| 0| } 3511| 29.5k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 29.5k| c = *eptr++; \ | | 324| 29.5k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 768| { \ | | | | 289| 768| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 290, False: 478] | | | | ------------------ | | | | 290| 768| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 768| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 216, False: 262] | | | | ------------------ | | | | 292| 478| { \ | | | | 293| 216| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 216| eptr += 2; \ | | | | 295| 216| } \ | | | | 296| 478| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 262, False: 0] | | | | ------------------ | | | | 297| 262| { \ | | | | 298| 262| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 262| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 262| eptr += 3; \ | | | | 301| 262| } \ | | | | 302| 262| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 768| } | | ------------------ | | | Branch (324:7): [True: 5.16k, False: 24.3k] | | | Branch (324:14): [True: 768, False: 4.40k] | | ------------------ ------------------ 3512| 29.5k| if ((UCD_CATEGORY(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 1859| 29.5k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 29.5k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 29.5k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 29.5k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 29.5k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 29.5k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 29.5k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 29.5k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 29.5k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 29.5k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 29.5k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 29.5k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 29.5k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_CATEGORY(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2601| 29.5k|#define Lpropvalue F->temp_32[3] ------------------ if ((UCD_CATEGORY(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 29.5k|#define Lctype F->temp_32[2] ------------------ | Branch (3512:17): [True: 2.68k, False: 26.8k] ------------------ 3513| 26.8k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.68k| {\ | | 555| 2.68k| rrc = ra;\ | | 556| 2.68k| goto RETURN_SWITCH;\ | | 557| 2.68k| } ------------------ 3514| 26.8k| } 3515| | /* Control never gets here */ 3516| | 3517| 12.0k| case PT_PC: ------------------ | | 1278| 12.0k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (3517:11): [True: 12.0k, False: 248k] ------------------ 3518| 12.0k| for (;;) 3519| 33.8k| { 3520| 33.8k| RMATCH(Fecode, RM211); ------------------ | | 546| 33.8k| {\ | | 547| 33.8k| start_ecode = ra;\ | | 548| 33.8k| Freturn_id = rb;\ | | ------------------ | | | | 188| 33.8k|#define Freturn_id F->return_id | | ------------------ | | 549| 33.8k| goto MATCH_RECURSE;\ | | 550| 33.8k| L_##rb:;\ | | 551| 33.5k| } ------------------ 3521| 33.5k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 33.5k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 655| {\ | | 555| 655| rrc = ra;\ | | 556| 655| goto RETURN_SWITCH;\ | | 557| 655| } ------------------ | Branch (3521:17): [True: 655, False: 32.9k] ------------------ 3522| 32.9k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 32.9k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 32.9k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.46k| {\ | | 555| 6.46k| rrc = ra;\ | | 556| 6.46k| goto RETURN_SWITCH;\ | | 557| 6.46k| } ------------------ | Branch (3522:17): [True: 6.46k, False: 26.4k] ------------------ 3523| 26.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 26.4k|#define Feptr F->eptr ------------------ | Branch (3523:17): [True: 2.82k, False: 23.6k] ------------------ 3524| 2.82k| { 3525| 2.82k| SCHECK_PARTIAL(); ------------------ | | 533| 2.82k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 705, False: 2.12k] | | ------------------ | | 534| 2.82k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 705|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 241, False: 464] | | | Branch (534:38): [True: 228, False: 236] | | ------------------ | | 535| 2.82k| { \ | | 536| 469| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 469|#define TRUE 1 | | ------------------ | | 537| 469| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 4, False: 465] | | ------------------ | | 538| 469| } ------------------ 3526| 2.82k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.82k| {\ | | 555| 2.82k| rrc = ra;\ | | 556| 2.82k| goto RETURN_SWITCH;\ | | 557| 2.82k| } ------------------ 3527| 0| } 3528| 23.6k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 23.6k| c = *eptr++; \ | | 324| 23.6k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 866| { \ | | | | 289| 866| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 268, False: 598] | | | | ------------------ | | | | 290| 866| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 866| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 310, False: 288] | | | | ------------------ | | | | 292| 598| { \ | | | | 293| 310| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 310| eptr += 2; \ | | | | 295| 310| } \ | | | | 296| 598| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 288, False: 0] | | | | ------------------ | | | | 297| 288| { \ | | | | 298| 288| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 288| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 288| eptr += 3; \ | | | | 301| 288| } \ | | | | 302| 288| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 866| } | | ------------------ | | | Branch (324:7): [True: 9.40k, False: 14.2k] | | | Branch (324:14): [True: 866, False: 8.54k] | | ------------------ ------------------ 3529| 23.6k| if ((UCD_CHARTYPE(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 1857| 23.6k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 23.6k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 23.6k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 23.6k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 23.6k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 23.6k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 23.6k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 23.6k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 23.6k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 23.6k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 23.6k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_CHARTYPE(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2601| 23.6k|#define Lpropvalue F->temp_32[3] ------------------ if ((UCD_CHARTYPE(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 23.6k|#define Lctype F->temp_32[2] ------------------ | Branch (3529:17): [True: 1.81k, False: 21.8k] ------------------ 3530| 21.8k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.81k| {\ | | 555| 1.81k| rrc = ra;\ | | 556| 1.81k| goto RETURN_SWITCH;\ | | 557| 1.81k| } ------------------ 3531| 21.8k| } 3532| | /* Control never gets here */ 3533| | 3534| 26.6k| case PT_SC: ------------------ | | 1279| 26.6k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (3534:11): [True: 26.6k, False: 233k] ------------------ 3535| 26.6k| for (;;) 3536| 61.5k| { 3537| 61.5k| RMATCH(Fecode, RM212); ------------------ | | 546| 61.5k| {\ | | 547| 61.5k| start_ecode = ra;\ | | 548| 61.5k| Freturn_id = rb;\ | | ------------------ | | | | 188| 61.5k|#define Freturn_id F->return_id | | ------------------ | | 549| 61.5k| goto MATCH_RECURSE;\ | | 550| 61.5k| L_##rb:;\ | | 551| 61.4k| } ------------------ 3538| 61.4k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 61.4k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 343| {\ | | 555| 343| rrc = ra;\ | | 556| 343| goto RETURN_SWITCH;\ | | 557| 343| } ------------------ | Branch (3538:17): [True: 343, False: 61.1k] ------------------ 3539| 61.1k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 61.1k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 61.1k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 22.6k| {\ | | 555| 22.6k| rrc = ra;\ | | 556| 22.6k| goto RETURN_SWITCH;\ | | 557| 22.6k| } ------------------ | Branch (3539:17): [True: 22.6k, False: 38.4k] ------------------ 3540| 38.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 38.4k|#define Feptr F->eptr ------------------ | Branch (3540:17): [True: 1.96k, False: 36.4k] ------------------ 3541| 1.96k| { 3542| 1.96k| SCHECK_PARTIAL(); ------------------ | | 533| 1.96k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 747, False: 1.21k] | | ------------------ | | 534| 1.96k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 747|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 291, False: 456] | | | Branch (534:38): [True: 229, False: 227] | | ------------------ | | 535| 1.96k| { \ | | 536| 520| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 520|#define TRUE 1 | | ------------------ | | 537| 520| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 4, False: 516] | | ------------------ | | 538| 520| } ------------------ 3543| 1.95k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.95k| {\ | | 555| 1.95k| rrc = ra;\ | | 556| 1.95k| goto RETURN_SWITCH;\ | | 557| 1.95k| } ------------------ 3544| 0| } 3545| 36.4k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 36.4k| c = *eptr++; \ | | 324| 36.4k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 824| { \ | | | | 289| 824| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 350, False: 474] | | | | ------------------ | | | | 290| 824| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 824| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 243, False: 231] | | | | ------------------ | | | | 292| 474| { \ | | | | 293| 243| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 243| eptr += 2; \ | | | | 295| 243| } \ | | | | 296| 474| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 231, False: 0] | | | | ------------------ | | | | 297| 231| { \ | | | | 298| 231| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 231| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 231| eptr += 3; \ | | | | 301| 231| } \ | | | | 302| 231| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 824| } | | ------------------ | | | Branch (324:7): [True: 6.33k, False: 30.1k] | | | Branch (324:14): [True: 824, False: 5.51k] | | ------------------ ------------------ 3546| 36.4k| if ((UCD_SCRIPT(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 1858| 36.4k|#define UCD_SCRIPT(ch) GET_UCD(ch)->script | | ------------------ | | | | 1846| 36.4k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 36.4k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 36.4k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 36.4k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 36.4k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 36.4k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 36.4k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 36.4k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 36.4k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 36.4k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_SCRIPT(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2601| 36.4k|#define Lpropvalue F->temp_32[3] ------------------ if ((UCD_SCRIPT(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 36.4k|#define Lctype F->temp_32[2] ------------------ | Branch (3546:17): [True: 1.56k, False: 34.9k] ------------------ 3547| 34.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.56k| {\ | | 555| 1.56k| rrc = ra;\ | | 556| 1.56k| goto RETURN_SWITCH;\ | | 557| 1.56k| } ------------------ 3548| 34.9k| } 3549| | /* Control never gets here */ 3550| | 3551| 29.0k| case PT_SCX: ------------------ | | 1280| 29.0k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (3551:11): [True: 29.0k, False: 231k] ------------------ 3552| 29.0k| for (;;) 3553| 67.7k| { 3554| 67.7k| BOOL ok; 3555| 67.7k| const ucd_record *prop; 3556| 67.7k| RMATCH(Fecode, RM225); ------------------ | | 546| 67.7k| {\ | | 547| 67.7k| start_ecode = ra;\ | | 548| 67.7k| Freturn_id = rb;\ | | ------------------ | | | | 188| 67.7k|#define Freturn_id F->return_id | | ------------------ | | 549| 67.7k| goto MATCH_RECURSE;\ | | 550| 67.7k| L_##rb:;\ | | 551| 67.6k| } ------------------ 3557| 67.6k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 67.6k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 314| {\ | | 555| 314| rrc = ra;\ | | 556| 314| goto RETURN_SWITCH;\ | | 557| 314| } ------------------ | Branch (3557:17): [True: 314, False: 67.2k] ------------------ 3558| 67.2k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 67.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 67.2k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 23.3k| {\ | | 555| 23.3k| rrc = ra;\ | | 556| 23.3k| goto RETURN_SWITCH;\ | | 557| 23.3k| } ------------------ | Branch (3558:17): [True: 23.3k, False: 43.9k] ------------------ 3559| 43.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 43.9k|#define Feptr F->eptr ------------------ | Branch (3559:17): [True: 4.35k, False: 39.5k] ------------------ 3560| 4.35k| { 3561| 4.35k| SCHECK_PARTIAL(); ------------------ | | 533| 4.35k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.97k, False: 2.37k] | | ------------------ | | 534| 4.35k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.97k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.51k, False: 463] | | | Branch (534:38): [True: 233, False: 230] | | ------------------ | | 535| 4.35k| { \ | | 536| 1.74k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.74k|#define TRUE 1 | | ------------------ | | 537| 1.74k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 4, False: 1.74k] | | ------------------ | | 538| 1.74k| } ------------------ 3562| 4.35k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.35k| {\ | | 555| 4.35k| rrc = ra;\ | | 556| 4.35k| goto RETURN_SWITCH;\ | | 557| 4.35k| } ------------------ 3563| 0| } 3564| 39.5k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 39.5k| c = *eptr++; \ | | 324| 39.5k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 722| { \ | | | | 289| 722| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 218, False: 504] | | | | ------------------ | | | | 290| 722| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 722| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 291, False: 213] | | | | ------------------ | | | | 292| 504| { \ | | | | 293| 291| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 291| eptr += 2; \ | | | | 295| 291| } \ | | | | 296| 504| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 213, False: 0] | | | | ------------------ | | | | 297| 213| { \ | | | | 298| 213| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 213| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 213| eptr += 3; \ | | | | 301| 213| } \ | | | | 302| 213| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 722| } | | ------------------ | | | Branch (324:7): [True: 3.41k, False: 36.1k] | | | Branch (324:14): [True: 722, False: 2.69k] | | ------------------ ------------------ 3565| 39.5k| prop = GET_UCD(fc); ------------------ | | 1846| 39.5k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 39.5k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 39.5k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 39.5k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 39.5k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 39.5k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 39.5k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 39.5k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 39.5k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 39.5k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 3566| 39.5k| ok = (prop->script == Lpropvalue ------------------ | | 2601| 79.1k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (3566:19): [True: 321, False: 39.2k] ------------------ 3567| 39.5k| || MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Lpropvalue) != 0); ------------------ | | 1871| 39.2k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (3567:22): [True: 0, False: 39.2k] ------------------ 3568| 39.5k| if (ok == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 39.5k|#define Lctype F->temp_32[2] ------------------ | Branch (3568:17): [True: 864, False: 38.7k] ------------------ 3569| 38.7k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 864| {\ | | 555| 864| rrc = ra;\ | | 556| 864| goto RETURN_SWITCH;\ | | 557| 864| } ------------------ 3570| 38.7k| } 3571| | /* Control never gets here */ 3572| | 3573| 6.34k| case PT_ALNUM: ------------------ | | 1281| 6.34k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (3573:11): [True: 6.34k, False: 253k] ------------------ 3574| 6.34k| for (;;) 3575| 13.5k| { 3576| 13.5k| int category; 3577| 13.5k| RMATCH(Fecode, RM213); ------------------ | | 546| 13.5k| {\ | | 547| 13.5k| start_ecode = ra;\ | | 548| 13.5k| Freturn_id = rb;\ | | ------------------ | | | | 188| 13.5k|#define Freturn_id F->return_id | | ------------------ | | 549| 13.5k| goto MATCH_RECURSE;\ | | 550| 13.5k| L_##rb:;\ | | 551| 13.4k| } ------------------ 3578| 13.4k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 13.4k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 217| {\ | | 555| 217| rrc = ra;\ | | 556| 217| goto RETURN_SWITCH;\ | | 557| 217| } ------------------ | Branch (3578:17): [True: 217, False: 13.2k] ------------------ 3579| 13.2k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 13.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 13.2k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.03k| {\ | | 555| 1.03k| rrc = ra;\ | | 556| 1.03k| goto RETURN_SWITCH;\ | | 557| 1.03k| } ------------------ | Branch (3579:17): [True: 1.03k, False: 12.2k] ------------------ 3580| 12.2k| if (Feptr >= mb->end_subject) ------------------ | | 177| 12.2k|#define Feptr F->eptr ------------------ | Branch (3580:17): [True: 1.62k, False: 10.5k] ------------------ 3581| 1.62k| { 3582| 1.62k| SCHECK_PARTIAL(); ------------------ | | 533| 1.62k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 704, False: 924] | | ------------------ | | 534| 1.62k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 704|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 259, False: 445] | | | Branch (534:38): [True: 221, False: 224] | | ------------------ | | 535| 1.62k| { \ | | 536| 480| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 480|#define TRUE 1 | | ------------------ | | 537| 480| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 4, False: 476] | | ------------------ | | 538| 480| } ------------------ 3583| 1.62k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.62k| {\ | | 555| 1.62k| rrc = ra;\ | | 556| 1.62k| goto RETURN_SWITCH;\ | | 557| 1.62k| } ------------------ 3584| 0| } 3585| 10.5k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 10.5k| c = *eptr++; \ | | 324| 10.5k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 757| { \ | | | | 289| 757| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 219, False: 538] | | | | ------------------ | | | | 290| 757| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 757| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 280, False: 258] | | | | ------------------ | | | | 292| 538| { \ | | | | 293| 280| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 280| eptr += 2; \ | | | | 295| 280| } \ | | | | 296| 538| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 258, False: 0] | | | | ------------------ | | | | 297| 258| { \ | | | | 298| 258| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 258| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 258| eptr += 3; \ | | | | 301| 258| } \ | | | | 302| 258| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 757| } | | ------------------ | | | Branch (324:7): [True: 4.71k, False: 5.87k] | | | Branch (324:14): [True: 757, False: 3.95k] | | ------------------ ------------------ 3586| 10.5k| category = UCD_CATEGORY(fc); ------------------ | | 1859| 10.5k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 10.5k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 10.5k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 10.5k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 10.5k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 10.5k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 10.5k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 10.5k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 10.5k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 10.5k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 10.5k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 10.5k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 10.5k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3587| 10.5k| if ((category == ucp_L || category == ucp_N) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 10.5k|#define Lctype F->temp_32[2] ------------------ | Branch (3587:17): [True: 3.40k, False: 7.18k] | Branch (3587:18): [True: 3.32k, False: 7.26k] | Branch (3587:39): [True: 135, False: 7.13k] ------------------ 3588| 7.18k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.40k| {\ | | 555| 3.40k| rrc = ra;\ | | 556| 3.40k| goto RETURN_SWITCH;\ | | 557| 3.40k| } ------------------ 3589| 7.18k| } 3590| | /* Control never gets here */ 3591| | 3592| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 3593| | which means that Perl space and POSIX space are now identical. PCRE 3594| | was changed at release 8.34. */ 3595| | 3596| 13.5k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 13.5k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (3596:11): [True: 13.5k, False: 246k] ------------------ 3597| 13.8k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 13.8k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (3597:11): [True: 320, False: 259k] ------------------ 3598| 13.8k| for (;;) 3599| 44.7k| { 3600| 44.7k| RMATCH(Fecode, RM214); ------------------ | | 546| 44.7k| {\ | | 547| 44.7k| start_ecode = ra;\ | | 548| 44.7k| Freturn_id = rb;\ | | ------------------ | | | | 188| 44.7k|#define Freturn_id F->return_id | | ------------------ | | 549| 44.7k| goto MATCH_RECURSE;\ | | 550| 44.7k| L_##rb:;\ | | 551| 44.1k| } ------------------ 3601| 44.1k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 44.1k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 262| {\ | | 555| 262| rrc = ra;\ | | 556| 262| goto RETURN_SWITCH;\ | | 557| 262| } ------------------ | Branch (3601:17): [True: 262, False: 43.8k] ------------------ 3602| 43.8k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 43.8k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 43.8k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 899| {\ | | 555| 899| rrc = ra;\ | | 556| 899| goto RETURN_SWITCH;\ | | 557| 899| } ------------------ | Branch (3602:17): [True: 899, False: 42.9k] ------------------ 3603| 42.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 42.9k|#define Feptr F->eptr ------------------ | Branch (3603:17): [True: 3.48k, False: 39.5k] ------------------ 3604| 3.48k| { 3605| 3.48k| SCHECK_PARTIAL(); ------------------ | | 533| 3.48k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 829, False: 2.65k] | | ------------------ | | 534| 3.48k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 829|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 344, False: 485] | | | Branch (534:38): [True: 227, False: 258] | | ------------------ | | 535| 3.48k| { \ | | 536| 571| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 571|#define TRUE 1 | | ------------------ | | 537| 571| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 568] | | ------------------ | | 538| 571| } ------------------ 3606| 3.47k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.47k| {\ | | 555| 3.47k| rrc = ra;\ | | 556| 3.47k| goto RETURN_SWITCH;\ | | 557| 3.47k| } ------------------ 3607| 0| } 3608| 39.5k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 39.5k| c = *eptr++; \ | | 324| 39.5k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 5.86k| { \ | | | | 289| 5.86k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 732, False: 5.13k] | | | | ------------------ | | | | 290| 5.86k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 5.86k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 4.86k, False: 273] | | | | ------------------ | | | | 292| 5.13k| { \ | | | | 293| 4.86k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 4.86k| eptr += 2; \ | | | | 295| 4.86k| } \ | | | | 296| 5.13k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 273, False: 0] | | | | ------------------ | | | | 297| 273| { \ | | | | 298| 273| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 273| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 273| eptr += 3; \ | | | | 301| 273| } \ | | | | 302| 273| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 5.86k| } | | ------------------ | | | Branch (324:7): [True: 30.1k, False: 9.34k] | | | Branch (324:14): [True: 5.86k, False: 24.2k] | | ------------------ ------------------ 3609| 39.5k| switch(fc) 3610| 39.5k| { 3611| 55.0k| HSPACE_CASES: ------------------ | | 412| 1.01k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 256| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 256|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 256, False: 39.2k] | | | | ------------------ | | | | 408| 703| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 703|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 447, False: 39.0k] | | | | ------------------ | | | | 409| 1.01k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.46k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.46k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 450, False: 39.0k] | | | | ------------------ | | | | 390| 1.69k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 230, False: 39.2k] | | | | ------------------ | | | | 391| 1.92k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 228, False: 39.2k] | | | | ------------------ | | | | 392| 2.20k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 280, False: 39.2k] | | | | ------------------ | | | | 393| 2.43k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 228, False: 39.2k] | | | | ------------------ | | | | 394| 2.66k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 226, False: 39.2k] | | | | ------------------ | | | | 395| 2.96k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 302, False: 39.2k] | | | | ------------------ | | | | 396| 3.22k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 258, False: 39.2k] | | | | ------------------ | | | | 397| 3.44k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 226, False: 39.2k] | | | | ------------------ | | | | 398| 3.71k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 264, False: 39.2k] | | | | ------------------ | | | | 399| 3.93k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 226, False: 39.2k] | | | | ------------------ | | | | 400| 4.16k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 228, False: 39.2k] | | | | ------------------ | | | | 401| 4.43k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 274, False: 39.2k] | | | | ------------------ | | | | 402| 4.68k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 242, False: 39.2k] | | | | ------------------ | | | | 403| 4.94k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 268, False: 39.2k] | | | | ------------------ | | | | 404| 5.16k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 3612| 55.0k| VSPACE_CASES: ------------------ | | 430| 6.67k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 5.59k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 5.59k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 426, False: 39.0k] | | | | ------------------ | | | | 424| 5.93k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 5.93k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 341, False: 39.1k] | | | | ------------------ | | | | 425| 6.15k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 6.15k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 222, False: 39.2k] | | | | ------------------ | | | | 426| 6.41k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 6.41k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 263, False: 39.2k] | | | | ------------------ | | | | 427| 6.67k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 5.16k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 7.01k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 7.01k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 344, False: 39.1k] | | | | ------------------ | | | | 420| 7.27k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 3613| 45.0k| if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH); ------------------ | | 2600| 7.27k|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.70k| {\ | | 555| 6.70k| rrc = ra;\ | | 556| 6.70k| goto RETURN_SWITCH;\ | | 557| 6.70k| } ------------------ | Branch (3613:19): [True: 6.70k, False: 573] ------------------ 3614| 573| break; 3615| | 3616| 32.2k| default: ------------------ | Branch (3616:15): [True: 32.2k, False: 7.27k] ------------------ 3617| 32.2k| if ((UCD_CATEGORY(fc) == ucp_Z) == (Lctype == OP_NOTPROP)) ------------------ | | 1859| 32.2k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 32.2k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 32.2k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 32.2k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 32.2k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 32.2k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 32.2k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 32.2k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 32.2k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 32.2k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 32.2k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 32.2k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 32.2k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_CATEGORY(fc) == ucp_Z) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 32.2k|#define Lctype F->temp_32[2] ------------------ | Branch (3617:19): [True: 1.87k, False: 30.3k] ------------------ 3618| 30.3k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.87k| {\ | | 555| 1.87k| rrc = ra;\ | | 556| 1.87k| goto RETURN_SWITCH;\ | | 557| 1.87k| } ------------------ 3619| 30.3k| break; 3620| 39.5k| } 3621| 39.5k| } 3622| | /* Control never gets here */ 3623| | 3624| 5.61k| case PT_WORD: ------------------ | | 1284| 5.61k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (3624:11): [True: 5.61k, False: 254k] ------------------ 3625| 5.61k| for (;;) 3626| 13.2k| { 3627| 13.2k| int category; 3628| 13.2k| RMATCH(Fecode, RM215); ------------------ | | 546| 13.2k| {\ | | 547| 13.2k| start_ecode = ra;\ | | 548| 13.2k| Freturn_id = rb;\ | | ------------------ | | | | 188| 13.2k|#define Freturn_id F->return_id | | ------------------ | | 549| 13.2k| goto MATCH_RECURSE;\ | | 550| 13.2k| L_##rb:;\ | | 551| 13.1k| } ------------------ 3629| 13.1k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 13.1k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 395| {\ | | 555| 395| rrc = ra;\ | | 556| 395| goto RETURN_SWITCH;\ | | 557| 395| } ------------------ | Branch (3629:17): [True: 395, False: 12.7k] ------------------ 3630| 12.7k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 12.7k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 12.7k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 304| {\ | | 555| 304| rrc = ra;\ | | 556| 304| goto RETURN_SWITCH;\ | | 557| 304| } ------------------ | Branch (3630:17): [True: 304, False: 12.4k] ------------------ 3631| 12.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 12.4k|#define Feptr F->eptr ------------------ | Branch (3631:17): [True: 2.27k, False: 10.1k] ------------------ 3632| 2.27k| { 3633| 2.27k| SCHECK_PARTIAL(); ------------------ | | 533| 2.27k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 698, False: 1.57k] | | ------------------ | | 534| 2.27k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 698|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 224, False: 474] | | | Branch (534:38): [True: 223, False: 251] | | ------------------ | | 535| 2.27k| { \ | | 536| 447| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 447|#define TRUE 1 | | ------------------ | | 537| 447| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 2|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 2, False: 445] | | ------------------ | | 538| 447| } ------------------ 3634| 2.26k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.26k| {\ | | 555| 2.26k| rrc = ra;\ | | 556| 2.26k| goto RETURN_SWITCH;\ | | 557| 2.26k| } ------------------ 3635| 0| } 3636| 10.1k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 10.1k| c = *eptr++; \ | | 324| 10.1k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 868| { \ | | | | 289| 868| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 228, False: 640] | | | | ------------------ | | | | 290| 868| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 868| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 250, False: 390] | | | | ------------------ | | | | 292| 640| { \ | | | | 293| 250| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 250| eptr += 2; \ | | | | 295| 250| } \ | | | | 296| 640| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 390, False: 0] | | | | ------------------ | | | | 297| 390| { \ | | | | 298| 390| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 390| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 390| eptr += 3; \ | | | | 301| 390| } \ | | | | 302| 390| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 868| } | | ------------------ | | | Branch (324:7): [True: 6.40k, False: 3.73k] | | | Branch (324:14): [True: 868, False: 5.53k] | | ------------------ ------------------ 3637| 10.1k| category = UCD_CATEGORY(fc); ------------------ | | 1859| 10.1k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 10.1k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 10.1k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 10.1k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 10.1k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 10.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 10.1k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 10.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 10.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 10.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 10.1k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 10.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 10.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3638| 10.1k| if ((category == ucp_L || ------------------ | Branch (3638:17): [True: 2.51k, False: 7.62k] | Branch (3638:18): [True: 1.44k, False: 8.68k] ------------------ 3639| 10.1k| category == ucp_N || ------------------ | Branch (3639:18): [True: 679, False: 8.00k] ------------------ 3640| 10.1k| fc == CHAR_UNDERSCORE) == (Lctype == OP_NOTPROP)) ------------------ | | 1045| 8.00k|#define CHAR_UNDERSCORE '\137' ------------------ fc == CHAR_UNDERSCORE) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 10.1k|#define Lctype F->temp_32[2] ------------------ | Branch (3640:18): [True: 0, False: 8.00k] ------------------ 3641| 7.62k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.51k| {\ | | 555| 2.51k| rrc = ra;\ | | 556| 2.51k| goto RETURN_SWITCH;\ | | 557| 2.51k| } ------------------ 3642| 7.62k| } 3643| | /* Control never gets here */ 3644| | 3645| 18.6k| case PT_CLIST: ------------------ | | 1285| 18.6k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (3645:11): [True: 18.6k, False: 241k] ------------------ 3646| 18.6k| for (;;) 3647| 23.5k| { 3648| 23.5k| const uint32_t *cp; 3649| 23.5k| RMATCH(Fecode, RM216); ------------------ | | 546| 23.5k| {\ | | 547| 23.5k| start_ecode = ra;\ | | 548| 23.5k| Freturn_id = rb;\ | | ------------------ | | | | 188| 23.5k|#define Freturn_id F->return_id | | ------------------ | | 549| 23.5k| goto MATCH_RECURSE;\ | | 550| 23.5k| L_##rb:;\ | | 551| 23.2k| } ------------------ 3650| 23.2k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 23.2k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 247| {\ | | 555| 247| rrc = ra;\ | | 556| 247| goto RETURN_SWITCH;\ | | 557| 247| } ------------------ | Branch (3650:17): [True: 247, False: 23.0k] ------------------ 3651| 23.0k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 23.0k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 23.0k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 515| {\ | | 555| 515| rrc = ra;\ | | 556| 515| goto RETURN_SWITCH;\ | | 557| 515| } ------------------ | Branch (3651:17): [True: 515, False: 22.5k] ------------------ 3652| 22.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 22.5k|#define Feptr F->eptr ------------------ | Branch (3652:17): [True: 4.21k, False: 18.3k] ------------------ 3653| 4.21k| { 3654| 4.21k| SCHECK_PARTIAL(); ------------------ | | 533| 4.21k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.83k, False: 2.37k] | | ------------------ | | 534| 4.21k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.83k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.35k, False: 477] | | | Branch (534:38): [True: 237, False: 240] | | ------------------ | | 535| 4.21k| { \ | | 536| 1.59k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.59k|#define TRUE 1 | | ------------------ | | 537| 1.59k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 1.59k] | | ------------------ | | 538| 1.59k| } ------------------ 3655| 4.21k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.21k| {\ | | 555| 4.21k| rrc = ra;\ | | 556| 4.21k| goto RETURN_SWITCH;\ | | 557| 4.21k| } ------------------ 3656| 0| } 3657| 18.3k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 18.3k| c = *eptr++; \ | | 324| 18.3k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 963| { \ | | | | 289| 963| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 448, False: 515] | | | | ------------------ | | | | 290| 963| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 963| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 297, False: 218] | | | | ------------------ | | | | 292| 515| { \ | | | | 293| 297| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 297| eptr += 2; \ | | | | 295| 297| } \ | | | | 296| 515| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 218, False: 0] | | | | ------------------ | | | | 297| 218| { \ | | | | 298| 218| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 218| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 218| eptr += 3; \ | | | | 301| 218| } \ | | | | 302| 218| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 963| } | | ------------------ | | | Branch (324:7): [True: 14.4k, False: 3.87k] | | | Branch (324:14): [True: 963, False: 13.4k] | | ------------------ ------------------ 3658| 18.3k| cp = PRIV(ucd_caseless_sets) + Lpropvalue; ------------------ | | 177| 18.3k|#define PRIV(name) _pcre2_##name ------------------ cp = PRIV(ucd_caseless_sets) + Lpropvalue; ------------------ | | 2601| 18.3k|#define Lpropvalue F->temp_32[3] ------------------ 3659| 18.3k| for (;;) 3660| 25.7k| { 3661| 25.7k| if (fc < *cp) ------------------ | Branch (3661:19): [True: 16.0k, False: 9.64k] ------------------ 3662| 16.0k| { 3663| 16.0k| if (Lctype == OP_NOTPROP) break; ------------------ | | 2600| 16.0k|#define Lctype F->temp_32[2] ------------------ | Branch (3663:21): [True: 3.14k, False: 12.9k] ------------------ 3664| 16.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 12.9k| {\ | | 555| 12.9k| rrc = ra;\ | | 556| 12.9k| goto RETURN_SWITCH;\ | | 557| 12.9k| } ------------------ 3665| 0| } 3666| 9.64k| if (fc == *cp++) ------------------ | Branch (3666:19): [True: 2.24k, False: 7.39k] ------------------ 3667| 2.24k| { 3668| 2.24k| if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH); ------------------ | | 2600| 2.24k|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 456| {\ | | 555| 456| rrc = ra;\ | | 556| 456| goto RETURN_SWITCH;\ | | 557| 456| } ------------------ | Branch (3668:21): [True: 456, False: 1.79k] ------------------ 3669| 1.79k| break; 3670| 2.24k| } 3671| 9.64k| } 3672| 18.3k| } 3673| | /* Control never gets here */ 3674| | 3675| 26.3k| case PT_UCNC: ------------------ | | 1286| 26.3k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (3675:11): [True: 26.3k, False: 233k] ------------------ 3676| 26.3k| for (;;) 3677| 61.0k| { 3678| 61.0k| RMATCH(Fecode, RM217); ------------------ | | 546| 61.0k| {\ | | 547| 61.0k| start_ecode = ra;\ | | 548| 61.0k| Freturn_id = rb;\ | | ------------------ | | | | 188| 61.0k|#define Freturn_id F->return_id | | ------------------ | | 549| 61.0k| goto MATCH_RECURSE;\ | | 550| 61.0k| L_##rb:;\ | | 551| 60.8k| } ------------------ 3679| 60.8k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 60.8k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 324| {\ | | 555| 324| rrc = ra;\ | | 556| 324| goto RETURN_SWITCH;\ | | 557| 324| } ------------------ | Branch (3679:17): [True: 324, False: 60.5k] ------------------ 3680| 60.5k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 60.5k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 60.5k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 20.3k| {\ | | 555| 20.3k| rrc = ra;\ | | 556| 20.3k| goto RETURN_SWITCH;\ | | 557| 20.3k| } ------------------ | Branch (3680:17): [True: 20.3k, False: 40.1k] ------------------ 3681| 40.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 40.1k|#define Feptr F->eptr ------------------ | Branch (3681:17): [True: 1.69k, False: 38.4k] ------------------ 3682| 1.69k| { 3683| 1.69k| SCHECK_PARTIAL(); ------------------ | | 533| 1.69k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 820, False: 876] | | ------------------ | | 534| 1.69k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 820|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 342, False: 478] | | | Branch (534:38): [True: 229, False: 249] | | ------------------ | | 535| 1.69k| { \ | | 536| 571| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 571|#define TRUE 1 | | ------------------ | | 537| 571| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 568] | | ------------------ | | 538| 571| } ------------------ 3684| 1.69k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.69k| {\ | | 555| 1.69k| rrc = ra;\ | | 556| 1.69k| goto RETURN_SWITCH;\ | | 557| 1.69k| } ------------------ 3685| 0| } 3686| 38.4k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 38.4k| c = *eptr++; \ | | 324| 38.4k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.02k| { \ | | | | 289| 1.02k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 204, False: 822] | | | | ------------------ | | | | 290| 1.02k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.02k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 350, False: 472] | | | | ------------------ | | | | 292| 822| { \ | | | | 293| 350| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 350| eptr += 2; \ | | | | 295| 350| } \ | | | | 296| 822| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 472, False: 0] | | | | ------------------ | | | | 297| 472| { \ | | | | 298| 472| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 472| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 472| eptr += 3; \ | | | | 301| 472| } \ | | | | 302| 472| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.02k| } | | ------------------ | | | Branch (324:7): [True: 5.61k, False: 32.8k] | | | Branch (324:14): [True: 1.02k, False: 4.59k] | | ------------------ ------------------ 3687| 38.4k| if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 986| 76.9k|#define CHAR_DOLLAR_SIGN '\044' ------------------ if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 75.9k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (3687:17): [True: 3.80k, False: 34.6k] | Branch (3687:18): [True: 935, False: 37.5k] | Branch (3687:44): [True: 652, False: 36.8k] ------------------ 3688| 38.4k| fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) || ------------------ | | 1046| 75.3k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (3688:18): [True: 261, False: 36.6k] | Branch (3688:46): [True: 3.38k, False: 33.2k] | Branch (3688:60): [True: 2.91k, False: 474] ------------------ 3689| 38.4k| fc >= 0xe000) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 38.4k|#define Lctype F->temp_32[2] ------------------ | Branch (3689:18): [True: 474, False: 33.2k] ------------------ 3690| 34.6k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.80k| {\ | | 555| 3.80k| rrc = ra;\ | | 556| 3.80k| goto RETURN_SWITCH;\ | | 557| 3.80k| } ------------------ 3691| 34.6k| } 3692| | /* Control never gets here */ 3693| | 3694| 26.9k| case PT_BIDICL: ------------------ | | 1287| 26.9k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (3694:11): [True: 26.9k, False: 233k] ------------------ 3695| 26.9k| for (;;) 3696| 51.0k| { 3697| 51.0k| RMATCH(Fecode, RM224); ------------------ | | 546| 51.0k| {\ | | 547| 51.0k| start_ecode = ra;\ | | 548| 51.0k| Freturn_id = rb;\ | | ------------------ | | | | 188| 51.0k|#define Freturn_id F->return_id | | ------------------ | | 549| 51.0k| goto MATCH_RECURSE;\ | | 550| 51.0k| L_##rb:;\ | | 551| 50.9k| } ------------------ 3698| 50.9k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 50.9k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 304| {\ | | 555| 304| rrc = ra;\ | | 556| 304| goto RETURN_SWITCH;\ | | 557| 304| } ------------------ | Branch (3698:17): [True: 304, False: 50.6k] ------------------ 3699| 50.6k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 50.6k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 50.6k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 15.1k| {\ | | 555| 15.1k| rrc = ra;\ | | 556| 15.1k| goto RETURN_SWITCH;\ | | 557| 15.1k| } ------------------ | Branch (3699:17): [True: 15.1k, False: 35.5k] ------------------ 3700| 35.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 35.5k|#define Feptr F->eptr ------------------ | Branch (3700:17): [True: 2.12k, False: 33.4k] ------------------ 3701| 2.12k| { 3702| 2.12k| SCHECK_PARTIAL(); ------------------ | | 533| 2.12k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 801, False: 1.32k] | | ------------------ | | 534| 2.12k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 801|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 290, False: 511] | | | Branch (534:38): [True: 272, False: 239] | | ------------------ | | 535| 2.12k| { \ | | 536| 562| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 562|#define TRUE 1 | | ------------------ | | 537| 562| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 556] | | ------------------ | | 538| 562| } ------------------ 3703| 2.11k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.11k| {\ | | 555| 2.11k| rrc = ra;\ | | 556| 2.11k| goto RETURN_SWITCH;\ | | 557| 2.11k| } ------------------ 3704| 0| } 3705| 33.4k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 33.4k| c = *eptr++; \ | | 324| 33.4k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 887| { \ | | | | 289| 887| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 276, False: 611] | | | | ------------------ | | | | 290| 887| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 887| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 319, False: 292] | | | | ------------------ | | | | 292| 611| { \ | | | | 293| 319| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 319| eptr += 2; \ | | | | 295| 319| } \ | | | | 296| 611| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 292, False: 0] | | | | ------------------ | | | | 297| 292| { \ | | | | 298| 292| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 292| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 292| eptr += 3; \ | | | | 301| 292| } \ | | | | 302| 292| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 887| } | | ------------------ | | | Branch (324:7): [True: 5.53k, False: 27.9k] | | | Branch (324:14): [True: 887, False: 4.65k] | | ------------------ ------------------ 3706| 33.4k| if ((UCD_BIDICLASS(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 1865| 33.4k|#define UCD_BIDICLASS(ch) UCD_BIDICLASS_PROP(GET_UCD(ch)) | | ------------------ | | | | 1854| 33.4k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | | | ------------------ | | | | | | 1850| 33.4k|#define UCD_BIDICLASS_SHIFT 11 | | | | ------------------ | | ------------------ ------------------ if ((UCD_BIDICLASS(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2601| 33.4k|#define Lpropvalue F->temp_32[3] ------------------ if ((UCD_BIDICLASS(fc) == Lpropvalue) == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 33.4k|#define Lctype F->temp_32[2] ------------------ | Branch (3706:17): [True: 9.34k, False: 24.0k] ------------------ 3707| 24.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 9.34k| {\ | | 555| 9.34k| rrc = ra;\ | | 556| 9.34k| goto RETURN_SWITCH;\ | | 557| 9.34k| } ------------------ 3708| 24.0k| } 3709| | /* Control never gets here */ 3710| | 3711| 4.96k| case PT_BOOL: ------------------ | | 1288| 4.96k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (3711:11): [True: 4.96k, False: 255k] ------------------ 3712| 4.96k| for (;;) 3713| 14.8k| { 3714| 14.8k| BOOL ok; 3715| 14.8k| const ucd_record *prop; 3716| 14.8k| RMATCH(Fecode, RM223); ------------------ | | 546| 14.8k| {\ | | 547| 14.8k| start_ecode = ra;\ | | 548| 14.8k| Freturn_id = rb;\ | | ------------------ | | | | 188| 14.8k|#define Freturn_id F->return_id | | ------------------ | | 549| 14.8k| goto MATCH_RECURSE;\ | | 550| 14.8k| L_##rb:;\ | | 551| 14.7k| } ------------------ 3717| 14.7k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 14.7k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 294| {\ | | 555| 294| rrc = ra;\ | | 556| 294| goto RETURN_SWITCH;\ | | 557| 294| } ------------------ | Branch (3717:17): [True: 294, False: 14.5k] ------------------ 3718| 14.5k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 14.5k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 14.5k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 462| {\ | | 555| 462| rrc = ra;\ | | 556| 462| goto RETURN_SWITCH;\ | | 557| 462| } ------------------ | Branch (3718:17): [True: 462, False: 14.0k] ------------------ 3719| 14.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 14.0k|#define Feptr F->eptr ------------------ | Branch (3719:17): [True: 2.35k, False: 11.6k] ------------------ 3720| 2.35k| { 3721| 2.35k| SCHECK_PARTIAL(); ------------------ | | 533| 2.35k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 892, False: 1.46k] | | ------------------ | | 534| 2.35k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 892|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 469, False: 423] | | | Branch (534:38): [True: 222, False: 201] | | ------------------ | | 535| 2.35k| { \ | | 536| 691| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 691|#define TRUE 1 | | ------------------ | | 537| 691| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 7|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 7, False: 684] | | ------------------ | | 538| 691| } ------------------ 3722| 2.35k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.35k| {\ | | 555| 2.35k| rrc = ra;\ | | 556| 2.35k| goto RETURN_SWITCH;\ | | 557| 2.35k| } ------------------ 3723| 0| } 3724| 11.6k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 11.6k| c = *eptr++; \ | | 324| 11.6k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 914| { \ | | | | 289| 914| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 260, False: 654] | | | | ------------------ | | | | 290| 914| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 914| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 430, False: 224] | | | | ------------------ | | | | 292| 654| { \ | | | | 293| 430| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 430| eptr += 2; \ | | | | 295| 430| } \ | | | | 296| 654| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 224, False: 0] | | | | ------------------ | | | | 297| 224| { \ | | | | 298| 224| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 224| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 224| eptr += 3; \ | | | | 301| 224| } \ | | | | 302| 224| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 914| } | | ------------------ | | | Branch (324:7): [True: 4.24k, False: 7.43k] | | | Branch (324:14): [True: 914, False: 3.33k] | | ------------------ ------------------ 3725| 11.6k| prop = GET_UCD(fc); ------------------ | | 1846| 11.6k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 11.6k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 11.6k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 11.6k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 11.6k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 11.6k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 11.6k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 11.6k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 11.6k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 11.6k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 3726| 11.6k| ok = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 11.6k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 3727| 11.6k| UCD_BPROPS_PROP(prop), Lpropvalue) != 0; 3728| 11.6k| if (ok == (Lctype == OP_NOTPROP)) ------------------ | | 2600| 11.6k|#define Lctype F->temp_32[2] ------------------ | Branch (3728:17): [True: 1.77k, False: 9.90k] ------------------ 3729| 9.90k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.77k| {\ | | 555| 1.77k| rrc = ra;\ | | 556| 1.77k| goto RETURN_SWITCH;\ | | 557| 1.77k| } ------------------ 3730| 9.90k| } 3731| | /* Control never gets here */ 3732| | 3733| | /* This should never occur */ 3734| 0| default: ------------------ | Branch (3734:11): [True: 0, False: 260k] ------------------ 3735| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 3736| 260k| } 3737| 260k| } 3738| | 3739| | /* Match extended Unicode sequences. We will get here only if the 3740| | support is in the binary; otherwise a compile-time error occurs. */ 3741| | 3742| 175k| else if (Lctype == OP_EXTUNI) ------------------ | | 2600| 175k|#define Lctype F->temp_32[2] ------------------ | Branch (3742:16): [True: 19.0k, False: 156k] ------------------ 3743| 19.0k| { 3744| 19.0k| for (;;) 3745| 49.7k| { 3746| 49.7k| RMATCH(Fecode, RM218); ------------------ | | 546| 49.7k| {\ | | 547| 49.7k| start_ecode = ra;\ | | 548| 49.7k| Freturn_id = rb;\ | | ------------------ | | | | 188| 49.7k|#define Freturn_id F->return_id | | ------------------ | | 549| 49.7k| goto MATCH_RECURSE;\ | | 550| 49.7k| L_##rb:;\ | | 551| 49.6k| } ------------------ 3747| 49.6k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 49.6k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 342| {\ | | 555| 342| rrc = ra;\ | | 556| 342| goto RETURN_SWITCH;\ | | 557| 342| } ------------------ | Branch (3747:15): [True: 342, False: 49.2k] ------------------ 3748| 49.2k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 49.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 49.2k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 15.1k| {\ | | 555| 15.1k| rrc = ra;\ | | 556| 15.1k| goto RETURN_SWITCH;\ | | 557| 15.1k| } ------------------ | Branch (3748:15): [True: 15.1k, False: 34.1k] ------------------ 3749| 34.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 34.1k|#define Feptr F->eptr ------------------ | Branch (3749:15): [True: 3.38k, False: 30.7k] ------------------ 3750| 3.38k| { 3751| 3.38k| SCHECK_PARTIAL(); ------------------ | | 533| 3.38k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.11k, False: 2.27k] | | ------------------ | | 534| 3.38k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.11k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 644, False: 472] | | | Branch (534:38): [True: 222, False: 250] | | ------------------ | | 535| 3.38k| { \ | | 536| 866| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 866|#define TRUE 1 | | ------------------ | | 537| 866| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 3, False: 863] | | ------------------ | | 538| 866| } ------------------ 3752| 3.38k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.38k| {\ | | 555| 3.38k| rrc = ra;\ | | 556| 3.38k| goto RETURN_SWITCH;\ | | 557| 3.38k| } ------------------ 3753| 0| } 3754| 30.7k| else 3755| 30.7k| { 3756| 30.7k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 30.7k| c = *eptr++; \ | | 324| 30.7k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 1.30k| { \ | | | | 289| 1.30k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 451, False: 854] | | | | ------------------ | | | | 290| 1.30k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 1.30k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 306, False: 548] | | | | ------------------ | | | | 292| 854| { \ | | | | 293| 306| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 306| eptr += 2; \ | | | | 295| 306| } \ | | | | 296| 854| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 548, False: 0] | | | | ------------------ | | | | 297| 548| { \ | | | | 298| 548| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 548| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 548| eptr += 3; \ | | | | 301| 548| } \ | | | | 302| 548| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 1.30k| } | | ------------------ | | | Branch (324:7): [True: 8.51k, False: 22.2k] | | | Branch (324:14): [True: 1.30k, False: 7.21k] | | ------------------ ------------------ 3757| 30.7k| Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, ------------------ | | 177| 30.7k|#define Feptr F->eptr ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, ------------------ | | 177| 30.7k|#define PRIV(name) _pcre2_##name ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, ------------------ | | 177| 30.7k|#define Feptr F->eptr ------------------ 3758| 30.7k| utf, NULL); 3759| 30.7k| } 3760| 30.7k| CHECK_PARTIAL(); ------------------ | | 527| 30.7k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 30.7k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 2.89k, False: 27.8k] | | ------------------ | | 528| 30.7k| { \ | | 529| 2.89k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 2.89k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 887, False: 2.01k] | | | | ------------------ | | | | 534| 2.89k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 887|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 887, False: 0] | | | | | Branch (534:38): [True: 0, False: 0] | | | | ------------------ | | | | 535| 2.89k| { \ | | | | 536| 887| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 887|#define TRUE 1 | | | | ------------------ | | | | 537| 887| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 13|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 13, False: 874] | | | | ------------------ | | | | 538| 887| } | | ------------------ | | 530| 2.88k| } ------------------ 3761| 30.7k| } 3762| 19.0k| } 3763| 156k| else 3764| 156k|#endif /* SUPPORT_UNICODE */ 3765| | 3766| | /* UTF mode for non-property testing character types. */ 3767| | 3768| 156k|#ifdef SUPPORT_UNICODE 3769| 156k| if (utf) ------------------ | Branch (3769:11): [True: 100k, False: 55.6k] ------------------ 3770| 100k| { 3771| 100k| for (;;) 3772| 307k| { 3773| 307k| RMATCH(Fecode, RM219); ------------------ | | 546| 307k| {\ | | 547| 307k| start_ecode = ra;\ | | 548| 307k| Freturn_id = rb;\ | | ------------------ | | | | 188| 307k|#define Freturn_id F->return_id | | ------------------ | | 549| 307k| goto MATCH_RECURSE;\ | | 550| 307k| L_##rb:;\ | | 551| 299k| } ------------------ 3774| 299k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 299k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 2.00k| {\ | | 555| 2.00k| rrc = ra;\ | | 556| 2.00k| goto RETURN_SWITCH;\ | | 557| 2.00k| } ------------------ | Branch (3774:15): [True: 2.00k, False: 297k] ------------------ 3775| 297k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 297k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 297k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 12.8k| {\ | | 555| 12.8k| rrc = ra;\ | | 556| 12.8k| goto RETURN_SWITCH;\ | | 557| 12.8k| } ------------------ | Branch (3775:15): [True: 12.8k, False: 284k] ------------------ 3776| 284k| if (Feptr >= mb->end_subject) ------------------ | | 177| 284k|#define Feptr F->eptr ------------------ | Branch (3776:15): [True: 39.1k, False: 245k] ------------------ 3777| 39.1k| { 3778| 39.1k| SCHECK_PARTIAL(); ------------------ | | 533| 39.1k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.52k, False: 36.5k] | | ------------------ | | 534| 39.1k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.52k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.99k, False: 529] | | | Branch (534:38): [True: 234, False: 295] | | ------------------ | | 535| 39.1k| { \ | | 536| 2.23k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.23k|#define TRUE 1 | | ------------------ | | 537| 2.23k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 48|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 48, False: 2.18k] | | ------------------ | | 538| 2.23k| } ------------------ 3779| 39.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 39.0k| {\ | | 555| 39.0k| rrc = ra;\ | | 556| 39.0k| goto RETURN_SWITCH;\ | | 557| 39.0k| } ------------------ 3780| 0| } 3781| 245k| if (Lctype == OP_ANY && IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 2600| 245k|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_ANY && IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 479| 81.3k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 81.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 81.3k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 2.74k, False: 78.6k] | | | Branch (479:4): [True: 9.58k, False: 71.7k] | | ------------------ | | 480| 81.3k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 9.58k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 19.1k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 9.58k, False: 0] | | ------------------ | | 481| 9.58k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 9.58k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 9.58k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 9.58k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 9.58k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 697, False: 8.89k] | | ------------------ | | 482| 9.58k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 9.58k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 81.3k| : \ | | 484| 81.3k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 71.7k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 71.7k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 71.7k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 70.0k, False: 1.71k] | | ------------------ | | 485| 71.7k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 70.0k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 70.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 2.74k, False: 67.3k] | | ------------------ | | 486| 71.7k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 2.74k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.43k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.43k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.31k, False: 1.43k] | | | Branch (486:30): [True: 736, False: 695] | | ------------------ | | 487| 71.7k| ) \ | | 488| 81.3k| ) ------------------ if (Lctype == OP_ANY && IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.74k| {\ | | 555| 2.74k| rrc = ra;\ | | 556| 2.74k| goto RETURN_SWITCH;\ | | 557| 2.74k| } ------------------ | Branch (3781:15): [True: 81.3k, False: 164k] ------------------ 3782| 243k| GETCHARINC(fc, Feptr); ------------------ | | 316| 243k| c = *eptr++; \ | | 317| 243k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 31.3k| { \ | | | | 289| 31.3k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 10.5k, False: 20.8k] | | | | ------------------ | | | | 290| 31.3k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 31.3k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 17.9k, False: 2.96k] | | | | ------------------ | | | | 292| 20.8k| { \ | | | | 293| 17.9k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 17.9k| eptr += 2; \ | | | | 295| 17.9k| } \ | | | | 296| 20.8k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 2.96k, False: 0] | | | | ------------------ | | | | 297| 2.96k| { \ | | | | 298| 2.96k| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 2.96k| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 2.96k| eptr += 3; \ | | | | 301| 2.96k| } \ | | | | 302| 2.96k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 31.3k| } | | ------------------ | | | Branch (317:7): [True: 31.3k, False: 211k] | | ------------------ ------------------ 3783| 243k| switch(Lctype) ------------------ | | 2600| 243k|#define Lctype F->temp_32[2] ------------------ 3784| 243k| { 3785| 78.6k| case OP_ANY: /* This is the non-NL case */ ------------------ | Branch (3785:13): [True: 78.6k, False: 164k] ------------------ 3786| 78.6k| if (mb->partial != 0 && /* Take care with CRLF partial */ ------------------ | Branch (3786:17): [True: 8.61k, False: 70.0k] ------------------ 3787| 78.6k| Feptr >= mb->end_subject && ------------------ | | 177| 8.61k|#define Feptr F->eptr ------------------ | Branch (3787:17): [True: 1.56k, False: 7.04k] ------------------ 3788| 78.6k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 1.56k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 80.2k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (3788:17): [True: 1.30k, False: 262] ------------------ 3789| 78.6k| NLBLOCK->nllen == 2 && ------------------ | | 59| 1.30k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (3789:17): [True: 534, False: 770] ------------------ 3790| 78.6k| fc == NLBLOCK->nl[0]) ------------------ | | 59| 534|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (3790:17): [True: 203, False: 331] ------------------ 3791| 203| { 3792| 203| mb->hitend = TRUE; ------------------ | | 70| 203|#define TRUE 1 ------------------ 3793| 203| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (3793:19): [True: 3, False: 200] ------------------ 3794| 203| } 3795| 78.6k| break; 3796| | 3797| 78.6k| case OP_ALLANY: ------------------ | Branch (3797:13): [True: 58.2k, False: 184k] ------------------ 3798| 58.2k| case OP_ANYBYTE: ------------------ | Branch (3798:13): [True: 0, False: 243k] ------------------ 3799| 58.2k| break; 3800| | 3801| 7.70k| case OP_ANYNL: ------------------ | Branch (3801:13): [True: 7.70k, False: 235k] ------------------ 3802| 7.70k| switch(fc) 3803| 7.70k| { 3804| 4.75k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.75k| {\ | | 555| 4.75k| rrc = ra;\ | | 556| 4.75k| goto RETURN_SWITCH;\ | | 557| 4.75k| } ------------------ | Branch (3804:15): [True: 4.75k, False: 2.94k] ------------------ 3805| | 3806| 929| case CHAR_CR: ------------------ | | 972| 929|#define CHAR_CR '\015' ------------------ | Branch (3806:15): [True: 929, False: 6.77k] ------------------ 3807| 929| if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 177| 929|#define Feptr F->eptr ------------------ if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 243| 598|#define UCHAR21(eptr) (*(eptr)) ------------------ if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 973| 598|#define CHAR_LF '\012' ------------------ if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 177| 218|#define Feptr F->eptr ------------------ | Branch (3807:19): [True: 598, False: 331] | Branch (3807:46): [True: 218, False: 380] ------------------ 3808| 929| break; 3809| | 3810| 529| case CHAR_LF: ------------------ | | 973| 529|#define CHAR_LF '\012' ------------------ | Branch (3810:15): [True: 529, False: 7.17k] ------------------ 3811| 529| break; 3812| | 3813| 482| case CHAR_VT: ------------------ | | 970| 482|#define CHAR_VT '\013' ------------------ | Branch (3813:15): [True: 482, False: 7.22k] ------------------ 3814| 788| case CHAR_FF: ------------------ | | 971| 788|#define CHAR_FF '\014' ------------------ | Branch (3814:15): [True: 306, False: 7.40k] ------------------ 3815| 1.02k| case CHAR_NEL: ------------------ | | 975| 1.02k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (3815:15): [True: 238, False: 7.47k] ------------------ 3816| 1.02k|#ifndef EBCDIC 3817| 1.28k| case 0x2028: ------------------ | Branch (3817:15): [True: 256, False: 7.45k] ------------------ 3818| 1.49k| case 0x2029: ------------------ | Branch (3818:15): [True: 209, False: 7.49k] ------------------ 3819| 1.49k|#endif /* Not EBCDIC */ 3820| 1.49k| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) ------------------ | | 217| 1.49k|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (3820:19): [True: 0, False: 1.49k] ------------------ 3821| 1.49k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ 3822| 1.49k| break; 3823| 7.70k| } 3824| 2.94k| break; 3825| | 3826| 29.8k| case OP_NOT_HSPACE: ------------------ | Branch (3826:13): [True: 29.8k, False: 213k] ------------------ 3827| 29.8k| switch(fc) 3828| 29.8k| { 3829| 5.37k| HSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 412| 1.39k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 327| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 327|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 327, False: 29.5k] | | | | ------------------ | | | | 408| 1.12k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.12k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 795, False: 29.0k] | | | | ------------------ | | | | 409| 1.39k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.60k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.60k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 208, False: 29.6k] | | | | ------------------ | | | | 390| 1.82k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 222, False: 29.6k] | | | | ------------------ | | | | 391| 2.05k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 230, False: 29.6k] | | | | ------------------ | | | | 392| 2.33k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 275, False: 29.5k] | | | | ------------------ | | | | 393| 2.58k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 254, False: 29.5k] | | | | ------------------ | | | | 394| 2.86k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 282, False: 29.5k] | | | | ------------------ | | | | 395| 3.16k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 292, False: 29.5k] | | | | ------------------ | | | | 396| 3.40k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 244, False: 29.5k] | | | | ------------------ | | | | 397| 3.62k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 218, False: 29.6k] | | | | ------------------ | | | | 398| 3.93k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 312, False: 29.5k] | | | | ------------------ | | | | 399| 4.17k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 238, False: 29.6k] | | | | ------------------ | | | | 400| 4.45k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 282, False: 29.5k] | | | | ------------------ | | | | 401| 4.68k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 230, False: 29.6k] | | | | ------------------ | | | | 402| 4.90k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 224, False: 29.6k] | | | | ------------------ | | | | 403| 5.11k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 206, False: 29.6k] | | | | ------------------ | | | | 404| 5.37k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ HSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 5.37k| {\ | | 555| 5.37k| rrc = ra;\ | | 556| 5.37k| goto RETURN_SWITCH;\ | | 557| 5.37k| } ------------------ 3830| 24.4k| default: break; ------------------ | Branch (3830:15): [True: 24.4k, False: 5.37k] ------------------ 3831| 29.8k| } 3832| 24.4k| break; 3833| | 3834| 24.4k| case OP_HSPACE: ------------------ | Branch (3834:13): [True: 16.8k, False: 226k] ------------------ 3835| 16.8k| switch(fc) 3836| 16.8k| { 3837| 5.43k| HSPACE_CASES: break; ------------------ | | 412| 1.43k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 469| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 469|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 469, False: 16.4k] | | | | ------------------ | | | | 408| 1.22k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.22k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 752, False: 16.1k] | | | | ------------------ | | | | 409| 1.43k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 1.72k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 1.72k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 292, False: 16.5k] | | | | ------------------ | | | | 390| 1.93k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 208, False: 16.6k] | | | | ------------------ | | | | 391| 2.22k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 284, False: 16.5k] | | | | ------------------ | | | | 392| 2.43k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 218, False: 16.6k] | | | | ------------------ | | | | 393| 2.70k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 270, False: 16.6k] | | | | ------------------ | | | | 394| 3.01k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 302, False: 16.5k] | | | | ------------------ | | | | 395| 3.22k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 216, False: 16.6k] | | | | ------------------ | | | | 396| 3.69k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 464, False: 16.4k] | | | | ------------------ | | | | 397| 3.89k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 204, False: 16.6k] | | | | ------------------ | | | | 398| 4.10k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 208, False: 16.6k] | | | | ------------------ | | | | 399| 4.32k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 222, False: 16.6k] | | | | ------------------ | | | | 400| 4.55k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 230, False: 16.6k] | | | | ------------------ | | | | 401| 4.76k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 206, False: 16.6k] | | | | ------------------ | | | | 402| 4.96k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 204, False: 16.6k] | | | | ------------------ | | | | 403| 5.17k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 214, False: 16.6k] | | | | ------------------ | | | | 404| 5.43k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 3838| 11.4k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 11.4k| {\ | | 555| 11.4k| rrc = ra;\ | | 556| 11.4k| goto RETURN_SWITCH;\ | | 557| 11.4k| } ------------------ | Branch (3838:15): [True: 11.4k, False: 5.43k] ------------------ 3839| 16.8k| } 3840| 5.43k| break; 3841| | 3842| 20.5k| case OP_NOT_VSPACE: ------------------ | Branch (3842:13): [True: 20.5k, False: 222k] ------------------ 3843| 20.5k| switch(fc) 3844| 20.5k| { 3845| 3.43k| VSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 430| 2.51k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 411| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 411|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 411, False: 20.1k] | | | | ------------------ | | | | 424| 987| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 987|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 576, False: 19.9k] | | | | ------------------ | | | | 425| 1.50k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.50k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 522, False: 19.9k] | | | | ------------------ | | | | 426| 1.91k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.91k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 406, False: 20.1k] | | | | ------------------ | | | | 427| 2.51k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 2.92k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 2.92k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 408, False: 20.1k] | | | | ------------------ | | | | 420| 3.43k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ VSPACE_CASES: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.43k| {\ | | 555| 3.43k| rrc = ra;\ | | 556| 3.43k| goto RETURN_SWITCH;\ | | 557| 3.43k| } ------------------ 3846| 17.0k| default: break; ------------------ | Branch (3846:15): [True: 17.0k, False: 3.43k] ------------------ 3847| 20.5k| } 3848| 17.0k| break; 3849| | 3850| 17.0k| case OP_VSPACE: ------------------ | Branch (3850:13): [True: 6.47k, False: 236k] ------------------ 3851| 6.47k| switch(fc) 3852| 6.47k| { 3853| 2.31k| VSPACE_CASES: break; ------------------ | | 430| 1.63k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 242| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 242|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 242, False: 6.23k] | | | | ------------------ | | | | 424| 642| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 642|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 400, False: 6.07k] | | | | ------------------ | | | | 425| 1.08k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 1.08k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 438, False: 6.04k] | | | | ------------------ | | | | 426| 1.41k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 1.41k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 338, False: 6.14k] | | | | ------------------ | | | | 427| 1.63k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 1.83k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 1.83k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 204, False: 6.27k] | | | | ------------------ | | | | 420| 2.31k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 3854| 4.16k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.16k| {\ | | 555| 4.16k| rrc = ra;\ | | 556| 4.16k| goto RETURN_SWITCH;\ | | 557| 4.16k| } ------------------ | Branch (3854:15): [True: 4.16k, False: 2.31k] ------------------ 3855| 6.47k| } 3856| 2.31k| break; 3857| | 3858| 11.9k| case OP_NOT_DIGIT: ------------------ | Branch (3858:13): [True: 11.9k, False: 231k] ------------------ 3859| 11.9k| if (fc < 256 && (mb->ctypes[fc] & ctype_digit) != 0) ------------------ | | 582| 11.3k|#define ctype_digit 0x08 ------------------ | Branch (3859:17): [True: 11.3k, False: 623] | Branch (3859:29): [True: 1.09k, False: 10.2k] ------------------ 3860| 10.8k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.09k| {\ | | 555| 1.09k| rrc = ra;\ | | 556| 1.09k| goto RETURN_SWITCH;\ | | 557| 1.09k| } ------------------ 3861| 10.8k| break; 3862| | 3863| 1.49k| case OP_DIGIT: ------------------ | Branch (3863:13): [True: 1.49k, False: 241k] ------------------ 3864| 1.49k| if (fc >= 256 || (mb->ctypes[fc] & ctype_digit) == 0) ------------------ | | 582| 1.14k|#define ctype_digit 0x08 ------------------ | Branch (3864:17): [True: 347, False: 1.14k] | Branch (3864:30): [True: 726, False: 421] ------------------ 3865| 1.07k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.07k| {\ | | 555| 1.07k| rrc = ra;\ | | 556| 1.07k| goto RETURN_SWITCH;\ | | 557| 1.07k| } ------------------ 3866| 421| break; 3867| | 3868| 4.28k| case OP_NOT_WHITESPACE: ------------------ | Branch (3868:13): [True: 4.28k, False: 238k] ------------------ 3869| 4.28k| if (fc < 256 && (mb->ctypes[fc] & ctype_space) != 0) ------------------ | | 579| 3.74k|#define ctype_space 0x01 ------------------ | Branch (3869:17): [True: 3.74k, False: 541] | Branch (3869:29): [True: 281, False: 3.46k] ------------------ 3870| 4.00k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 281| {\ | | 555| 281| rrc = ra;\ | | 556| 281| goto RETURN_SWITCH;\ | | 557| 281| } ------------------ 3871| 4.00k| break; 3872| | 3873| 2.03k| case OP_WHITESPACE: ------------------ | Branch (3873:13): [True: 2.03k, False: 241k] ------------------ 3874| 2.03k| if (fc >= 256 || (mb->ctypes[fc] & ctype_space) == 0) ------------------ | | 579| 1.58k|#define ctype_space 0x01 ------------------ | Branch (3874:17): [True: 447, False: 1.58k] | Branch (3874:30): [True: 1.14k, False: 441] ------------------ 3875| 1.59k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.59k| {\ | | 555| 1.59k| rrc = ra;\ | | 556| 1.59k| goto RETURN_SWITCH;\ | | 557| 1.59k| } ------------------ 3876| 441| break; 3877| | 3878| 2.20k| case OP_NOT_WORDCHAR: ------------------ | Branch (3878:13): [True: 2.20k, False: 240k] ------------------ 3879| 2.20k| if (fc < 256 && (mb->ctypes[fc] & ctype_word) != 0) ------------------ | | 583| 1.77k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (3879:17): [True: 1.77k, False: 435] | Branch (3879:29): [True: 464, False: 1.30k] ------------------ 3880| 1.74k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 464| {\ | | 555| 464| rrc = ra;\ | | 556| 464| goto RETURN_SWITCH;\ | | 557| 464| } ------------------ 3881| 1.74k| break; 3882| | 3883| 2.76k| case OP_WORDCHAR: ------------------ | Branch (3883:13): [True: 2.76k, False: 240k] ------------------ 3884| 2.76k| if (fc >= 256 || (mb->ctypes[fc] & ctype_word) == 0) ------------------ | | 583| 2.18k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (3884:17): [True: 579, False: 2.18k] | Branch (3884:30): [True: 1.44k, False: 740] ------------------ 3885| 2.02k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.02k| {\ | | 555| 2.02k| rrc = ra;\ | | 556| 2.02k| goto RETURN_SWITCH;\ | | 557| 2.02k| } ------------------ 3886| 740| break; 3887| | 3888| 0| default: ------------------ | Branch (3888:13): [True: 0, False: 243k] ------------------ 3889| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 3890| 243k| } 3891| 243k| } 3892| 100k| } 3893| 55.6k| else 3894| 55.6k|#endif /* SUPPORT_UNICODE */ 3895| | 3896| | /* Not UTF mode */ 3897| 55.6k| { 3898| 55.6k| for (;;) 3899| 167k| { 3900| 167k| RMATCH(Fecode, RM33); ------------------ | | 546| 167k| {\ | | 547| 167k| start_ecode = ra;\ | | 548| 167k| Freturn_id = rb;\ | | ------------------ | | | | 188| 167k|#define Freturn_id F->return_id | | ------------------ | | 549| 167k| goto MATCH_RECURSE;\ | | 550| 167k| L_##rb:;\ | | 551| 163k| } ------------------ 3901| 163k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 163k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 2.57k| {\ | | 555| 2.57k| rrc = ra;\ | | 556| 2.57k| goto RETURN_SWITCH;\ | | 557| 2.57k| } ------------------ | Branch (3901:15): [True: 2.57k, False: 161k] ------------------ 3902| 161k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2598| 161k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 2599| 161k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 15.6k| {\ | | 555| 15.6k| rrc = ra;\ | | 556| 15.6k| goto RETURN_SWITCH;\ | | 557| 15.6k| } ------------------ | Branch (3902:15): [True: 15.6k, False: 145k] ------------------ 3903| 145k| if (Feptr >= mb->end_subject) ------------------ | | 177| 145k|#define Feptr F->eptr ------------------ | Branch (3903:15): [True: 19.9k, False: 125k] ------------------ 3904| 19.9k| { 3905| 19.9k| SCHECK_PARTIAL(); ------------------ | | 533| 19.9k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 4.46k, False: 15.5k] | | ------------------ | | 534| 19.9k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 4.46k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 2.94k, False: 1.52k] | | | Branch (534:38): [True: 774, False: 748] | | ------------------ | | 535| 19.9k| { \ | | 536| 3.71k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 3.71k|#define TRUE 1 | | ------------------ | | 537| 3.71k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 20|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 20, False: 3.69k] | | ------------------ | | 538| 3.71k| } ------------------ 3906| 19.9k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 19.9k| {\ | | 555| 19.9k| rrc = ra;\ | | 556| 19.9k| goto RETURN_SWITCH;\ | | 557| 19.9k| } ------------------ 3907| 0| } 3908| 125k| if (Lctype == OP_ANY && IS_NEWLINE(Feptr)) ------------------ | | 2600| 125k|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_ANY && IS_NEWLINE(Feptr)) ------------------ | | 479| 60.0k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 60.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 60.0k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 1.24k, False: 58.7k] | | | Branch (479:4): [True: 5.93k, False: 54.0k] | | ------------------ | | 480| 60.0k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 5.93k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 11.8k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 5.93k, False: 0] | | ------------------ | | 481| 5.93k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 5.93k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 5.93k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 5.93k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 5.93k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 402, False: 5.53k] | | ------------------ | | 482| 5.93k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 5.93k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 60.0k| : \ | | 484| 60.0k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 54.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 54.0k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 54.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 52.0k, False: 1.98k] | | ------------------ | | 485| 54.0k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 52.0k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 52.0k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 1.30k, False: 50.7k] | | ------------------ | | 486| 54.0k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.30k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 729|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 729|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 576, False: 729] | | | Branch (486:30): [True: 264, False: 465] | | ------------------ | | 487| 54.0k| ) \ | | 488| 60.0k| ) ------------------ | Branch (3908:15): [True: 60.0k, False: 65.6k] ------------------ 3909| 124k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.24k| {\ | | 555| 1.24k| rrc = ra;\ | | 556| 1.24k| goto RETURN_SWITCH;\ | | 557| 1.24k| } ------------------ 3910| 124k| fc = *Feptr++; ------------------ | | 177| 124k|#define Feptr F->eptr ------------------ 3911| 124k| switch(Lctype) ------------------ | | 2600| 124k|#define Lctype F->temp_32[2] ------------------ 3912| 124k| { 3913| 58.7k| case OP_ANY: /* This is the non-NL case */ ------------------ | Branch (3913:13): [True: 58.7k, False: 65.6k] ------------------ 3914| 58.7k| if (mb->partial != 0 && /* Take care with CRLF partial */ ------------------ | Branch (3914:17): [True: 16.1k, False: 42.5k] ------------------ 3915| 58.7k| Feptr >= mb->end_subject && ------------------ | | 177| 16.1k|#define Feptr F->eptr ------------------ | Branch (3915:17): [True: 2.41k, False: 13.7k] ------------------ 3916| 58.7k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 2.41k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 61.1k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (3916:17): [True: 2.17k, False: 247] ------------------ 3917| 58.7k| NLBLOCK->nllen == 2 && ------------------ | | 59| 2.17k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (3917:17): [True: 854, False: 1.31k] ------------------ 3918| 58.7k| fc == NLBLOCK->nl[0]) ------------------ | | 59| 854|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (3918:17): [True: 364, False: 490] ------------------ 3919| 364| { 3920| 364| mb->hitend = TRUE; ------------------ | | 70| 364|#define TRUE 1 ------------------ 3921| 364| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (3921:19): [True: 3, False: 361] ------------------ 3922| 364| } 3923| 58.7k| break; 3924| | 3925| 58.7k| case OP_ALLANY: ------------------ | Branch (3925:13): [True: 16.1k, False: 108k] ------------------ 3926| 16.1k| case OP_ANYBYTE: ------------------ | Branch (3926:13): [True: 0, False: 124k] ------------------ 3927| 16.1k| break; 3928| | 3929| 4.68k| case OP_ANYNL: ------------------ | Branch (3929:13): [True: 4.68k, False: 119k] ------------------ 3930| 4.68k| switch(fc) 3931| 4.68k| { 3932| 2.19k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.19k| {\ | | 555| 2.19k| rrc = ra;\ | | 556| 2.19k| goto RETURN_SWITCH;\ | | 557| 2.19k| } ------------------ | Branch (3932:15): [True: 2.19k, False: 2.48k] ------------------ 3933| | 3934| 1.04k| case CHAR_CR: ------------------ | | 972| 1.04k|#define CHAR_CR '\015' ------------------ | Branch (3934:15): [True: 1.04k, False: 3.63k] ------------------ 3935| 1.04k| if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 1.04k|#define Feptr F->eptr ------------------ if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 684|#define Feptr F->eptr ------------------ if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 973| 684|#define CHAR_LF '\012' ------------------ if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 216|#define Feptr F->eptr ------------------ | Branch (3935:19): [True: 684, False: 364] | Branch (3935:46): [True: 216, False: 468] ------------------ 3936| 1.04k| break; 3937| | 3938| 586| case CHAR_LF: ------------------ | | 973| 586|#define CHAR_LF '\012' ------------------ | Branch (3938:15): [True: 586, False: 4.09k] ------------------ 3939| 586| break; 3940| | 3941| 354| case CHAR_VT: ------------------ | | 970| 354|#define CHAR_VT '\013' ------------------ | Branch (3941:15): [True: 354, False: 4.32k] ------------------ 3942| 597| case CHAR_FF: ------------------ | | 971| 597|#define CHAR_FF '\014' ------------------ | Branch (3942:15): [True: 243, False: 4.43k] ------------------ 3943| 850| case CHAR_NEL: ------------------ | | 975| 850|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (3943:15): [True: 253, False: 4.42k] ------------------ 3944| |#if PCRE2_CODE_UNIT_WIDTH != 8 3945| | case 0x2028: 3946| | case 0x2029: 3947| |#endif 3948| 850| if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) ------------------ | | 217| 850|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (3948:19): [True: 0, False: 850] ------------------ 3949| 850| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ 3950| 850| break; 3951| 4.68k| } 3952| 2.48k| break; 3953| | 3954| 6.45k| case OP_NOT_HSPACE: ------------------ | Branch (3954:13): [True: 6.45k, False: 117k] ------------------ 3955| 6.45k| switch(fc) 3956| 6.45k| { 3957| 5.52k| default: break; ------------------ | Branch (3957:15): [True: 5.52k, False: 930] ------------------ 3958| 5.52k| HSPACE_BYTE_CASES: ------------------ | | 407| 254| case CHAR_HT: \ | | ------------------ | | | | 969| 254|#define CHAR_HT '\011' | | ------------------ | | | Branch (407:3): [True: 254, False: 6.19k] | | ------------------ | | 408| 486| case CHAR_SPACE: \ | | ------------------ | | | | 982| 486|#define CHAR_SPACE '\040' | | ------------------ | | | Branch (408:3): [True: 232, False: 6.21k] | | ------------------ | | 409| 5.52k| case CHAR_NBSP | | ------------------ | | | | 1077| 5.52k|#define CHAR_NBSP ((unsigned char)'\xa0') | | ------------------ ------------------ 3959| |#if PCRE2_CODE_UNIT_WIDTH != 8 3960| | HSPACE_MULTIBYTE_CASES: 3961| |#endif 3962| 930| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 930| {\ | | 555| 930| rrc = ra;\ | | 556| 930| goto RETURN_SWITCH;\ | | 557| 930| } ------------------ 3963| 6.45k| } 3964| 5.52k| break; 3965| | 3966| 5.52k| case OP_HSPACE: ------------------ | Branch (3966:13): [True: 3.35k, False: 121k] ------------------ 3967| 3.35k| switch(fc) 3968| 3.35k| { 3969| 2.47k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.47k| {\ | | 555| 2.47k| rrc = ra;\ | | 556| 2.47k| goto RETURN_SWITCH;\ | | 557| 2.47k| } ------------------ | Branch (3969:15): [True: 2.47k, False: 876] ------------------ 3970| 1.80k| HSPACE_BYTE_CASES: ------------------ | | 407| 282| case CHAR_HT: \ | | ------------------ | | | | 969| 282|#define CHAR_HT '\011' | | ------------------ | | | Branch (407:3): [True: 282, False: 3.06k] | | ------------------ | | 408| 644| case CHAR_SPACE: \ | | ------------------ | | | | 982| 644|#define CHAR_SPACE '\040' | | ------------------ | | | Branch (408:3): [True: 362, False: 2.98k] | | ------------------ | | 409| 876| case CHAR_NBSP | | ------------------ | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | ------------------ ------------------ 3971| |#if PCRE2_CODE_UNIT_WIDTH != 8 3972| | HSPACE_MULTIBYTE_CASES: 3973| |#endif 3974| 1.80k| break; 3975| 3.35k| } 3976| 876| break; 3977| | 3978| 6.37k| case OP_NOT_VSPACE: ------------------ | Branch (3978:13): [True: 6.37k, False: 118k] ------------------ 3979| 6.37k| switch(fc) 3980| 6.37k| { 3981| 5.13k| default: break; ------------------ | Branch (3981:15): [True: 5.13k, False: 1.23k] ------------------ 3982| 5.13k| VSPACE_BYTE_CASES: ------------------ | | 423| 234| case CHAR_LF: \ | | ------------------ | | | | 973| 234|#define CHAR_LF '\012' | | ------------------ | | | Branch (423:3): [True: 234, False: 6.13k] | | ------------------ | | 424| 438| case CHAR_VT: \ | | ------------------ | | | | 970| 438|#define CHAR_VT '\013' | | ------------------ | | | Branch (424:3): [True: 204, False: 6.16k] | | ------------------ | | 425| 665| case CHAR_FF: \ | | ------------------ | | | | 971| 665|#define CHAR_FF '\014' | | ------------------ | | | Branch (425:3): [True: 227, False: 6.14k] | | ------------------ | | 426| 964| case CHAR_CR: \ | | ------------------ | | | | 972| 964|#define CHAR_CR '\015' | | ------------------ | | | Branch (426:3): [True: 299, False: 6.07k] | | ------------------ | | 427| 5.13k| case CHAR_NEL | | ------------------ | | | | 975| 5.13k|#define CHAR_NEL ((unsigned char)'\x85') | | ------------------ ------------------ 3983| |#if PCRE2_CODE_UNIT_WIDTH != 8 3984| | VSPACE_MULTIBYTE_CASES: 3985| |#endif 3986| 1.23k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.23k| {\ | | 555| 1.23k| rrc = ra;\ | | 556| 1.23k| goto RETURN_SWITCH;\ | | 557| 1.23k| } ------------------ 3987| 6.37k| } 3988| 5.13k| break; 3989| | 3990| 5.13k| case OP_VSPACE: ------------------ | Branch (3990:13): [True: 3.25k, False: 121k] ------------------ 3991| 3.25k| switch(fc) 3992| 3.25k| { 3993| 1.75k| default: RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.75k| {\ | | 555| 1.75k| rrc = ra;\ | | 556| 1.75k| goto RETURN_SWITCH;\ | | 557| 1.75k| } ------------------ | Branch (3993:15): [True: 1.75k, False: 1.50k] ------------------ 3994| 4.09k| VSPACE_BYTE_CASES: ------------------ | | 423| 229| case CHAR_LF: \ | | ------------------ | | | | 973| 229|#define CHAR_LF '\012' | | ------------------ | | | Branch (423:3): [True: 229, False: 3.02k] | | ------------------ | | 424| 516| case CHAR_VT: \ | | ------------------ | | | | 970| 516|#define CHAR_VT '\013' | | ------------------ | | | Branch (424:3): [True: 287, False: 2.97k] | | ------------------ | | 425| 778| case CHAR_FF: \ | | ------------------ | | | | 971| 778|#define CHAR_FF '\014' | | ------------------ | | | Branch (425:3): [True: 262, False: 2.99k] | | ------------------ | | 426| 1.06k| case CHAR_CR: \ | | ------------------ | | | | 972| 1.06k|#define CHAR_CR '\015' | | ------------------ | | | Branch (426:3): [True: 282, False: 2.97k] | | ------------------ | | 427| 1.50k| case CHAR_NEL | | ------------------ | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | ------------------ ------------------ 3995| |#if PCRE2_CODE_UNIT_WIDTH != 8 3996| | VSPACE_MULTIBYTE_CASES: 3997| |#endif 3998| 4.09k| break; 3999| 3.25k| } 4000| 1.50k| break; 4001| | 4002| 16.5k| case OP_NOT_DIGIT: ------------------ | Branch (4002:13): [True: 16.5k, False: 107k] ------------------ 4003| 16.5k| if (MAX_255(fc) && (mb->ctypes[fc] & ctype_digit) != 0) ------------------ | | 212| 16.5k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 33.0k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(fc) && (mb->ctypes[fc] & ctype_digit) != 0) ------------------ | | 582| 16.5k|#define ctype_digit 0x08 ------------------ | Branch (4003:32): [True: 1.18k, False: 15.3k] ------------------ 4004| 15.3k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.18k| {\ | | 555| 1.18k| rrc = ra;\ | | 556| 1.18k| goto RETURN_SWITCH;\ | | 557| 1.18k| } ------------------ 4005| 15.3k| break; 4006| | 4007| 620| case OP_DIGIT: ------------------ | Branch (4007:13): [True: 620, False: 123k] ------------------ 4008| 620| if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_digit) == 0) ------------------ | | 212| 620|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 1.24k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_digit) == 0) ------------------ | | 582| 620|#define ctype_digit 0x08 ------------------ | Branch (4008:17): [Folded - Ignored] | Branch (4008:33): [True: 381, False: 239] ------------------ 4009| 381| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 381| {\ | | 555| 381| rrc = ra;\ | | 556| 381| goto RETURN_SWITCH;\ | | 557| 381| } ------------------ 4010| 239| break; 4011| | 4012| 4.47k| case OP_NOT_WHITESPACE: ------------------ | Branch (4012:13): [True: 4.47k, False: 119k] ------------------ 4013| 4.47k| if (MAX_255(fc) && (mb->ctypes[fc] & ctype_space) != 0) ------------------ | | 212| 4.47k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 8.95k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(fc) && (mb->ctypes[fc] & ctype_space) != 0) ------------------ | | 579| 4.47k|#define ctype_space 0x01 ------------------ | Branch (4013:32): [True: 332, False: 4.14k] ------------------ 4014| 4.14k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 332| {\ | | 555| 332| rrc = ra;\ | | 556| 332| goto RETURN_SWITCH;\ | | 557| 332| } ------------------ 4015| 4.14k| break; 4016| | 4017| 935| case OP_WHITESPACE: ------------------ | Branch (4017:13): [True: 935, False: 123k] ------------------ 4018| 935| if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_space) == 0) ------------------ | | 212| 935|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 1.87k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_space) == 0) ------------------ | | 579| 935|#define ctype_space 0x01 ------------------ | Branch (4018:17): [Folded - Ignored] | Branch (4018:33): [True: 591, False: 344] ------------------ 4019| 591| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 591| {\ | | 555| 591| rrc = ra;\ | | 556| 591| goto RETURN_SWITCH;\ | | 557| 591| } ------------------ 4020| 344| break; 4021| | 4022| 2.11k| case OP_NOT_WORDCHAR: ------------------ | Branch (4022:13): [True: 2.11k, False: 122k] ------------------ 4023| 2.11k| if (MAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0) ------------------ | | 212| 2.11k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 4.22k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0) ------------------ | | 583| 2.11k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (4023:32): [True: 542, False: 1.56k] ------------------ 4024| 1.56k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 542| {\ | | 555| 542| rrc = ra;\ | | 556| 542| goto RETURN_SWITCH;\ | | 557| 542| } ------------------ 4025| 1.56k| break; 4026| | 4027| 658| case OP_WORDCHAR: ------------------ | Branch (4027:13): [True: 658, False: 123k] ------------------ 4028| 658| if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_word) == 0) ------------------ | | 212| 658|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 1.31k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_word) == 0) ------------------ | | 583| 658|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (4028:17): [Folded - Ignored] | Branch (4028:33): [True: 409, False: 249] ------------------ 4029| 409| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 409| {\ | | 555| 409| rrc = ra;\ | | 556| 409| goto RETURN_SWITCH;\ | | 557| 409| } ------------------ 4030| 249| break; 4031| | 4032| 0| default: ------------------ | Branch (4032:13): [True: 0, False: 124k] ------------------ 4033| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 4034| 124k| } 4035| 124k| } 4036| 55.6k| } 4037| | /* Control never gets here */ 4038| 435k| } 4039| | 4040| | /* If maximizing, it is worth using inline code for speed, doing the type 4041| | test once at the start (i.e. keep it out of the loops). Once again, 4042| | "notmatch" can be an ordinary local variable because the loops do not call 4043| | RMATCH. */ 4044| | 4045| 2.69M| else 4046| 2.69M| { 4047| 2.69M| Lstart_eptr = Feptr; /* Remember where we started */ ------------------ | | 2597| 2.69M|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; /* Remember where we started */ ------------------ | | 177| 2.69M|#define Feptr F->eptr ------------------ 4048| | 4049| 2.69M|#ifdef SUPPORT_UNICODE 4050| 2.69M| if (proptype >= 0) ------------------ | Branch (4050:11): [True: 998k, False: 1.69M] ------------------ 4051| 998k| { 4052| 998k| BOOL notmatch = Lctype == OP_NOTPROP; ------------------ | | 2600| 998k|#define Lctype F->temp_32[2] ------------------ 4053| 998k| switch(proptype) 4054| 998k| { 4055| 111k| case PT_ANY: ------------------ | | 1275| 111k|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (4055:11): [True: 111k, False: 886k] ------------------ 4056| 111k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 111k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 111k|#define Lmax F->temp_32[1] ------------------ | Branch (4056:26): [True: 111k, False: 0] ------------------ 4057| 111k| { 4058| 111k| int len = 1; 4059| 111k| if (Feptr >= mb->end_subject) ------------------ | | 177| 111k|#define Feptr F->eptr ------------------ | Branch (4059:17): [True: 4.77k, False: 106k] ------------------ 4060| 4.77k| { 4061| 4.77k| SCHECK_PARTIAL(); ------------------ | | 533| 4.77k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.48k, False: 2.28k] | | ------------------ | | 534| 4.77k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.48k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 746, False: 1.74k] | | | Branch (534:38): [True: 259, False: 1.48k] | | ------------------ | | 535| 4.77k| { \ | | 536| 1.00k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.00k|#define TRUE 1 | | ------------------ | | 537| 1.00k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 999] | | ------------------ | | 538| 1.00k| } ------------------ 4062| 4.77k| break; 4063| 4.77k| } 4064| 106k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 106k| c = *eptr; \ | | 339| 106k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 654| { \ | | | | 323| 654| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 244, False: 410] | | | | ------------------ | | | | 324| 654| { \ | | | | 325| 244| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 244| len++; \ | | | | 327| 244| } \ | | | | 328| 654| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 202, False: 208] | | | | ------------------ | | | | 329| 410| { \ | | | | 330| 202| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 202| len += 2; \ | | | | 332| 202| } \ | | | | 333| 410| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 208, False: 0] | | | | ------------------ | | | | 334| 208| {\ | | | | 335| 208| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 208| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 208| len += 3; \ | | | | 338| 208| } \ | | | | 339| 208| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 654| } | | ------------------ | | | Branch (339:7): [True: 3.75k, False: 102k] | | | Branch (339:14): [True: 654, False: 3.10k] | | ------------------ ------------------ 4065| 106k| if (notmatch) break; ------------------ | Branch (4065:17): [True: 106k, False: 0] ------------------ 4066| 0| Feptr+= len; ------------------ | | 177| 0|#define Feptr F->eptr ------------------ 4067| 0| } 4068| 111k| break; 4069| | 4070| 111k| case PT_LAMP: ------------------ | | 1276| 36.0k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (4070:11): [True: 36.0k, False: 962k] ------------------ 4071| 70.8k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 36.0k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 70.8k|#define Lmax F->temp_32[1] ------------------ | Branch (4071:26): [True: 51.3k, False: 19.4k] ------------------ 4072| 51.3k| { 4073| 51.3k| int chartype; 4074| 51.3k| int len = 1; 4075| 51.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 51.3k|#define Feptr F->eptr ------------------ | Branch (4075:17): [True: 4.30k, False: 47.0k] ------------------ 4076| 4.30k| { 4077| 4.30k| SCHECK_PARTIAL(); ------------------ | | 533| 4.30k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.29k, False: 3.01k] | | ------------------ | | 534| 4.30k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.29k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 693, False: 602] | | | Branch (534:38): [True: 316, False: 286] | | ------------------ | | 535| 4.30k| { \ | | 536| 1.00k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.00k|#define TRUE 1 | | ------------------ | | 537| 1.00k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 14|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 14, False: 995] | | ------------------ | | 538| 1.00k| } ------------------ 4078| 4.29k| break; 4079| 4.30k| } 4080| 47.0k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 47.0k| c = *eptr; \ | | 339| 47.0k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.03k| { \ | | | | 323| 1.03k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 294, False: 741] | | | | ------------------ | | | | 324| 1.03k| { \ | | | | 325| 294| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 294| len++; \ | | | | 327| 294| } \ | | | | 328| 1.03k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 515, False: 226] | | | | ------------------ | | | | 329| 741| { \ | | | | 330| 515| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 515| len += 2; \ | | | | 332| 515| } \ | | | | 333| 741| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 226, False: 0] | | | | ------------------ | | | | 334| 226| {\ | | | | 335| 226| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 226| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 226| len += 3; \ | | | | 338| 226| } \ | | | | 339| 226| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.03k| } | | ------------------ | | | Branch (339:7): [True: 5.51k, False: 41.5k] | | | Branch (339:14): [True: 1.03k, False: 4.48k] | | ------------------ ------------------ 4081| 47.0k| chartype = UCD_CHARTYPE(fc); ------------------ | | 1857| 47.0k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 47.0k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 47.0k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 47.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 47.0k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 47.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 47.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 47.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 47.0k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 47.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 47.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4082| 47.0k| if ((chartype == ucp_Lu || ------------------ | Branch (4082:17): [True: 12.3k, False: 34.7k] | Branch (4082:18): [True: 8.49k, False: 38.5k] ------------------ 4083| 47.0k| chartype == ucp_Ll || ------------------ | Branch (4083:18): [True: 2.55k, False: 35.9k] ------------------ 4084| 47.0k| chartype == ucp_Lt) == notmatch) ------------------ | Branch (4084:18): [True: 0, False: 35.9k] ------------------ 4085| 12.3k| break; 4086| 34.7k| Feptr+= len; ------------------ | | 177| 34.7k|#define Feptr F->eptr ------------------ 4087| 34.7k| } 4088| 36.0k| break; 4089| | 4090| 36.0k| case PT_GC: ------------------ | | 1277| 34.6k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (4090:11): [True: 34.6k, False: 963k] ------------------ 4091| 70.7k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 34.6k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 70.7k|#define Lmax F->temp_32[1] ------------------ | Branch (4091:26): [True: 51.7k, False: 18.9k] ------------------ 4092| 51.7k| { 4093| 51.7k| int len = 1; 4094| 51.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 51.7k|#define Feptr F->eptr ------------------ | Branch (4094:17): [True: 4.49k, False: 47.2k] ------------------ 4095| 4.49k| { 4096| 4.49k| SCHECK_PARTIAL(); ------------------ | | 533| 4.49k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.38k, False: 3.11k] | | ------------------ | | 534| 4.49k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.38k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 482, False: 901] | | | Branch (534:38): [True: 445, False: 456] | | ------------------ | | 535| 4.49k| { \ | | 536| 927| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 927|#define TRUE 1 | | ------------------ | | 537| 927| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 50|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 50, False: 877] | | ------------------ | | 538| 927| } ------------------ 4097| 4.44k| break; 4098| 4.49k| } 4099| 47.2k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 47.2k| c = *eptr; \ | | 339| 47.2k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 827| { \ | | | | 323| 827| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 208, False: 619] | | | | ------------------ | | | | 324| 827| { \ | | | | 325| 208| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 208| len++; \ | | | | 327| 208| } \ | | | | 328| 827| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 226, False: 393] | | | | ------------------ | | | | 329| 619| { \ | | | | 330| 226| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 226| len += 2; \ | | | | 332| 226| } \ | | | | 333| 619| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 393, False: 0] | | | | ------------------ | | | | 334| 393| {\ | | | | 335| 393| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 393| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 393| len += 3; \ | | | | 338| 393| } \ | | | | 339| 393| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 827| } | | ------------------ | | | Branch (339:7): [True: 8.97k, False: 38.2k] | | | Branch (339:14): [True: 827, False: 8.14k] | | ------------------ ------------------ 4100| 47.2k| if ((UCD_CATEGORY(fc) == Lpropvalue) == notmatch) break; ------------------ | | 1859| 47.2k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 47.2k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 47.2k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 47.2k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 47.2k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 47.2k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 47.2k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 47.2k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 47.2k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 47.2k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 47.2k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 47.2k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 47.2k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_CATEGORY(fc) == Lpropvalue) == notmatch) break; ------------------ | | 2601| 47.2k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (4100:17): [True: 11.1k, False: 36.0k] ------------------ 4101| 36.0k| Feptr+= len; ------------------ | | 177| 36.0k|#define Feptr F->eptr ------------------ 4102| 36.0k| } 4103| 34.6k| break; 4104| | 4105| 34.6k| case PT_PC: ------------------ | | 1278| 17.8k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (4105:11): [True: 17.8k, False: 980k] ------------------ 4106| 44.6k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 17.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 44.6k|#define Lmax F->temp_32[1] ------------------ | Branch (4106:26): [True: 37.8k, False: 6.71k] ------------------ 4107| 37.8k| { 4108| 37.8k| int len = 1; 4109| 37.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 37.8k|#define Feptr F->eptr ------------------ | Branch (4109:17): [True: 7.14k, False: 30.7k] ------------------ 4110| 7.14k| { 4111| 7.14k| SCHECK_PARTIAL(); ------------------ | | 533| 7.14k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 962, False: 6.17k] | | ------------------ | | 534| 7.14k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 962|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 477, False: 485] | | | Branch (534:38): [True: 234, False: 251] | | ------------------ | | 535| 7.14k| { \ | | 536| 711| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 711|#define TRUE 1 | | ------------------ | | 537| 711| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 29|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 29, False: 682] | | ------------------ | | 538| 711| } ------------------ 4112| 7.11k| break; 4113| 7.14k| } 4114| 30.7k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 30.7k| c = *eptr; \ | | 339| 30.7k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.93k| { \ | | | | 323| 1.93k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 470, False: 1.46k] | | | | ------------------ | | | | 324| 1.93k| { \ | | | | 325| 470| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 470| len++; \ | | | | 327| 470| } \ | | | | 328| 1.93k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 1.01k, False: 450] | | | | ------------------ | | | | 329| 1.46k| { \ | | | | 330| 1.01k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 1.01k| len += 2; \ | | | | 332| 1.01k| } \ | | | | 333| 1.46k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 450, False: 0] | | | | ------------------ | | | | 334| 450| {\ | | | | 335| 450| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 450| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 450| len += 3; \ | | | | 338| 450| } \ | | | | 339| 450| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.93k| } | | ------------------ | | | Branch (339:7): [True: 21.6k, False: 9.08k] | | | Branch (339:14): [True: 1.93k, False: 19.7k] | | ------------------ ------------------ 4115| 30.7k| if ((UCD_CHARTYPE(fc) == Lpropvalue) == notmatch) break; ------------------ | | 1857| 30.7k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | ------------------ | | | | 1846| 30.7k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 30.7k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 30.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 30.7k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 30.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 30.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 30.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 30.7k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 30.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 30.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_CHARTYPE(fc) == Lpropvalue) == notmatch) break; ------------------ | | 2601| 30.7k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (4115:17): [True: 4.00k, False: 26.7k] ------------------ 4116| 26.7k| Feptr+= len; ------------------ | | 177| 26.7k|#define Feptr F->eptr ------------------ 4117| 26.7k| } 4118| 17.8k| break; 4119| | 4120| 36.6k| case PT_SC: ------------------ | | 1279| 36.6k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (4120:11): [True: 36.6k, False: 961k] ------------------ 4121| 89.0k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 36.6k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 89.0k|#define Lmax F->temp_32[1] ------------------ | Branch (4121:26): [True: 59.0k, False: 29.9k] ------------------ 4122| 59.0k| { 4123| 59.0k| int len = 1; 4124| 59.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 59.0k|#define Feptr F->eptr ------------------ | Branch (4124:17): [True: 4.30k, False: 54.7k] ------------------ 4125| 4.30k| { 4126| 4.30k| SCHECK_PARTIAL(); ------------------ | | 533| 4.30k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.41k, False: 2.89k] | | ------------------ | | 534| 4.30k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.41k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 556, False: 857] | | | Branch (534:38): [True: 399, False: 458] | | ------------------ | | 535| 4.30k| { \ | | 536| 955| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 955|#define TRUE 1 | | ------------------ | | 537| 955| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 41|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 41, False: 914] | | ------------------ | | 538| 955| } ------------------ 4127| 4.26k| break; 4128| 4.30k| } 4129| 54.7k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 54.7k| c = *eptr; \ | | 339| 54.7k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.00k| { \ | | | | 323| 1.00k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 235, False: 774] | | | | ------------------ | | | | 324| 1.00k| { \ | | | | 325| 235| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 235| len++; \ | | | | 327| 235| } \ | | | | 328| 1.00k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 276, False: 498] | | | | ------------------ | | | | 329| 774| { \ | | | | 330| 276| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 276| len += 2; \ | | | | 332| 276| } \ | | | | 333| 774| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 498, False: 0] | | | | ------------------ | | | | 334| 498| {\ | | | | 335| 498| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 498| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 498| len += 3; \ | | | | 338| 498| } \ | | | | 339| 498| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.00k| } | | ------------------ | | | Branch (339:7): [True: 6.18k, False: 48.5k] | | | Branch (339:14): [True: 1.00k, False: 5.17k] | | ------------------ ------------------ 4130| 54.7k| if ((UCD_SCRIPT(fc) == Lpropvalue) == notmatch) break; ------------------ | | 1858| 54.7k|#define UCD_SCRIPT(ch) GET_UCD(ch)->script | | ------------------ | | | | 1846| 54.7k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 54.7k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 54.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 54.7k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 54.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 54.7k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 54.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 54.7k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 54.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 54.7k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((UCD_SCRIPT(fc) == Lpropvalue) == notmatch) break; ------------------ | | 2601| 54.7k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (4130:17): [True: 2.33k, False: 52.4k] ------------------ 4131| 52.4k| Feptr+= len; ------------------ | | 177| 52.4k|#define Feptr F->eptr ------------------ 4132| 52.4k| } 4133| 36.5k| break; 4134| | 4135| 312k| case PT_SCX: ------------------ | | 1280| 312k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (4135:11): [True: 312k, False: 685k] ------------------ 4136| 644k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 312k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 644k|#define Lmax F->temp_32[1] ------------------ | Branch (4136:26): [True: 340k, False: 304k] ------------------ 4137| 340k| { 4138| 340k| BOOL ok; 4139| 340k| const ucd_record *prop; 4140| 340k| int len = 1; 4141| 340k| if (Feptr >= mb->end_subject) ------------------ | | 177| 340k|#define Feptr F->eptr ------------------ | Branch (4141:17): [True: 6.64k, False: 333k] ------------------ 4142| 6.64k| { 4143| 6.64k| SCHECK_PARTIAL(); ------------------ | | 533| 6.64k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.42k, False: 4.22k] | | ------------------ | | 534| 6.64k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.42k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.95k, False: 476] | | | Branch (534:38): [True: 241, False: 235] | | ------------------ | | 535| 6.64k| { \ | | 536| 2.19k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.19k|#define TRUE 1 | | ------------------ | | 537| 2.19k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 32|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 32, False: 2.15k] | | ------------------ | | 538| 2.19k| } ------------------ 4144| 6.61k| break; 4145| 6.64k| } 4146| 333k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 333k| c = *eptr; \ | | 339| 333k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 811| { \ | | | | 323| 811| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 221, False: 590] | | | | ------------------ | | | | 324| 811| { \ | | | | 325| 221| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 221| len++; \ | | | | 327| 221| } \ | | | | 328| 811| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 250, False: 340] | | | | ------------------ | | | | 329| 590| { \ | | | | 330| 250| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 250| len += 2; \ | | | | 332| 250| } \ | | | | 333| 590| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 340, False: 0] | | | | ------------------ | | | | 334| 340| {\ | | | | 335| 340| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 340| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 340| len += 3; \ | | | | 338| 340| } \ | | | | 339| 340| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 811| } | | ------------------ | | | Branch (339:7): [True: 3.95k, False: 329k] | | | Branch (339:14): [True: 811, False: 3.14k] | | ------------------ ------------------ 4147| 333k| prop = GET_UCD(fc); ------------------ | | 1846| 333k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 333k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 333k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 333k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 333k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 333k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 333k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 333k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 333k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 333k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 4148| 333k| ok = (prop->script == Lpropvalue || ------------------ | | 2601| 667k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (4148:19): [True: 730, False: 332k] ------------------ 4149| 333k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Lpropvalue) != 0); ------------------ | | 1871| 332k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (4149:19): [True: 0, False: 332k] ------------------ 4150| 333k| if (ok == notmatch) break; ------------------ | Branch (4150:17): [True: 1.83k, False: 331k] ------------------ 4151| 331k| Feptr+= len; ------------------ | | 177| 331k|#define Feptr F->eptr ------------------ 4152| 331k| } 4153| 312k| break; 4154| | 4155| 312k| case PT_ALNUM: ------------------ | | 1281| 12.8k|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (4155:11): [True: 12.8k, False: 985k] ------------------ 4156| 24.3k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 12.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 24.3k|#define Lmax F->temp_32[1] ------------------ | Branch (4156:26): [True: 22.3k, False: 2.00k] ------------------ 4157| 22.3k| { 4158| 22.3k| int category; 4159| 22.3k| int len = 1; 4160| 22.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 22.3k|#define Feptr F->eptr ------------------ | Branch (4160:17): [True: 3.66k, False: 18.6k] ------------------ 4161| 3.66k| { 4162| 3.66k| SCHECK_PARTIAL(); ------------------ | | 533| 3.66k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.28k, False: 2.37k] | | ------------------ | | 534| 3.66k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.28k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 446, False: 841] | | | Branch (534:38): [True: 409, False: 432] | | ------------------ | | 535| 3.66k| { \ | | 536| 855| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 855|#define TRUE 1 | | ------------------ | | 537| 855| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 15|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 15, False: 840] | | ------------------ | | 538| 855| } ------------------ 4163| 3.65k| break; 4164| 3.66k| } 4165| 18.6k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 18.6k| c = *eptr; \ | | 339| 18.6k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 825| { \ | | | | 323| 825| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 343, False: 482] | | | | ------------------ | | | | 324| 825| { \ | | | | 325| 343| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 343| len++; \ | | | | 327| 343| } \ | | | | 328| 825| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 254, False: 228] | | | | ------------------ | | | | 329| 482| { \ | | | | 330| 254| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 254| len += 2; \ | | | | 332| 254| } \ | | | | 333| 482| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 228, False: 0] | | | | ------------------ | | | | 334| 228| {\ | | | | 335| 228| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 228| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 228| len += 3; \ | | | | 338| 228| } \ | | | | 339| 228| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 825| } | | ------------------ | | | Branch (339:7): [True: 5.16k, False: 13.5k] | | | Branch (339:14): [True: 825, False: 4.33k] | | ------------------ ------------------ 4166| 18.6k| category = UCD_CATEGORY(fc); ------------------ | | 1859| 18.6k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 18.6k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 18.6k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 18.6k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 18.6k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 18.6k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 18.6k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 18.6k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 18.6k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 18.6k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 18.6k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 18.6k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 18.6k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4167| 18.6k| if ((category == ucp_L || category == ucp_N) == notmatch) ------------------ | Branch (4167:17): [True: 7.16k, False: 11.5k] | Branch (4167:18): [True: 5.94k, False: 12.7k] | Branch (4167:39): [True: 403, False: 12.3k] ------------------ 4168| 7.16k| break; 4169| 11.5k| Feptr+= len; ------------------ | | 177| 11.5k|#define Feptr F->eptr ------------------ 4170| 11.5k| } 4171| 12.8k| break; 4172| | 4173| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 4174| | which means that Perl space and POSIX space are now identical. PCRE 4175| | was changed at release 8.34. */ 4176| | 4177| 36.3k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 36.3k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (4177:11): [True: 36.3k, False: 961k] ------------------ 4178| 36.8k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 36.8k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (4178:11): [True: 497, False: 997k] ------------------ 4179| 92.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 36.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 92.5k|#define Lmax F->temp_32[1] ------------------ | Branch (4179:26): [True: 91.1k, False: 1.44k] ------------------ 4180| 91.1k| { 4181| 91.1k| int len = 1; 4182| 91.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 91.1k|#define Feptr F->eptr ------------------ | Branch (4182:17): [True: 9.96k, False: 81.1k] ------------------ 4183| 9.96k| { 4184| 9.96k| SCHECK_PARTIAL(); ------------------ | | 533| 9.96k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.16k, False: 8.80k] | | ------------------ | | 534| 9.96k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.16k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 616, False: 548] | | | Branch (534:38): [True: 236, False: 312] | | ------------------ | | 535| 9.96k| { \ | | 536| 852| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 852|#define TRUE 1 | | ------------------ | | 537| 852| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 89|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 89, False: 763] | | ------------------ | | 538| 852| } ------------------ 4185| 9.87k| break; 4186| 9.96k| } 4187| 81.1k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 81.1k| c = *eptr; \ | | 339| 81.1k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 11.7k| { \ | | | | 323| 11.7k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 874, False: 10.8k] | | | | ------------------ | | | | 324| 11.7k| { \ | | | | 325| 874| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 874| len++; \ | | | | 327| 874| } \ | | | | 328| 11.7k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 10.4k, False: 410] | | | | ------------------ | | | | 329| 10.8k| { \ | | | | 330| 10.4k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 10.4k| len += 2; \ | | | | 332| 10.4k| } \ | | | | 333| 10.8k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 410, False: 0] | | | | ------------------ | | | | 334| 410| {\ | | | | 335| 410| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 410| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 410| len += 3; \ | | | | 338| 410| } \ | | | | 339| 410| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 11.7k| } | | ------------------ | | | Branch (339:7): [True: 61.8k, False: 19.2k] | | | Branch (339:14): [True: 11.7k, False: 50.1k] | | ------------------ ------------------ 4188| 81.1k| switch(fc) 4189| 81.1k| { 4190| 113k| HSPACE_CASES: ------------------ | | 412| 1.81k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 521| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 521|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 521, False: 80.6k] | | | | ------------------ | | | | 408| 1.24k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.24k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 724, False: 80.4k] | | | | ------------------ | | | | 409| 1.81k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 2.69k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 2.69k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 879, False: 80.2k] | | | | ------------------ | | | | 390| 3.33k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 637, False: 80.5k] | | | | ------------------ | | | | 391| 3.99k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 658, False: 80.4k] | | | | ------------------ | | | | 392| 4.33k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 346, False: 80.8k] | | | | ------------------ | | | | 393| 5.30k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 962, False: 80.1k] | | | | ------------------ | | | | 394| 5.68k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 387, False: 80.7k] | | | | ------------------ | | | | 395| 6.01k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 332, False: 80.8k] | | | | ------------------ | | | | 396| 6.62k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 610, False: 80.5k] | | | | ------------------ | | | | 397| 7.15k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 526, False: 80.6k] | | | | ------------------ | | | | 398| 7.68k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 534, False: 80.6k] | | | | ------------------ | | | | 399| 8.28k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 596, False: 80.5k] | | | | ------------------ | | | | 400| 8.73k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 454, False: 80.6k] | | | | ------------------ | | | | 401| 9.22k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 486, False: 80.6k] | | | | ------------------ | | | | 402| 9.90k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 682, False: 80.4k] | | | | ------------------ | | | | 403| 10.2k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 348, False: 80.8k] | | | | ------------------ | | | | 404| 10.8k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 4191| 113k| VSPACE_CASES: ------------------ | | 430| 14.0k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 11.3k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 11.3k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 472, False: 80.6k] | | | | ------------------ | | | | 424| 12.1k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 12.1k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 806, False: 80.3k] | | | | ------------------ | | | | 425| 12.5k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 12.5k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 451, False: 80.7k] | | | | ------------------ | | | | 426| 13.5k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 13.5k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 982, False: 80.1k] | | | | ------------------ | | | | 427| 14.0k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 10.8k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 14.5k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 14.5k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 466, False: 80.6k] | | | | ------------------ | | | | 420| 14.9k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 4192| 93.0k| if (notmatch) goto ENDLOOP99; /* Break the loop */ ------------------ | Branch (4192:19): [True: 13.9k, False: 1.02k] ------------------ 4193| 1.02k| break; 4194| | 4195| 66.1k| default: ------------------ | Branch (4195:15): [True: 66.1k, False: 14.9k] ------------------ 4196| 66.1k| if ((UCD_CATEGORY(fc) == ucp_Z) == notmatch) ------------------ | | 1859| 66.1k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 66.1k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 66.1k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 66.1k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 66.1k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 66.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 66.1k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 66.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 66.1k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 66.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 66.1k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 66.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 66.1k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (4196:19): [True: 11.4k, False: 54.7k] ------------------ 4197| 11.4k| goto ENDLOOP99; /* Break the loop */ 4198| 54.7k| break; 4199| 81.1k| } 4200| 55.7k| Feptr+= len; ------------------ | | 177| 55.7k|#define Feptr F->eptr ------------------ 4201| 55.7k| } 4202| 36.7k| ENDLOOP99: 4203| 36.7k| break; 4204| | 4205| 13.5k| case PT_WORD: ------------------ | | 1284| 13.5k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (4205:11): [True: 13.5k, False: 984k] ------------------ 4206| 19.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 13.5k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 19.5k|#define Lmax F->temp_32[1] ------------------ | Branch (4206:26): [True: 17.8k, False: 1.72k] ------------------ 4207| 17.8k| { 4208| 17.8k| int category; 4209| 17.8k| int len = 1; 4210| 17.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 17.8k|#define Feptr F->eptr ------------------ | Branch (4210:17): [True: 4.13k, False: 13.7k] ------------------ 4211| 4.13k| { 4212| 4.13k| SCHECK_PARTIAL(); ------------------ | | 533| 4.13k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 832, False: 3.29k] | | ------------------ | | 534| 4.13k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 832|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 368, False: 464] | | | Branch (534:38): [True: 235, False: 229] | | ------------------ | | 535| 4.13k| { \ | | 536| 603| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 603|#define TRUE 1 | | ------------------ | | 537| 603| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 18|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 18, False: 585] | | ------------------ | | 538| 603| } ------------------ 4213| 4.11k| break; 4214| 4.13k| } 4215| 13.7k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 13.7k| c = *eptr; \ | | 339| 13.7k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 997| { \ | | | | 323| 997| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 318, False: 679] | | | | ------------------ | | | | 324| 997| { \ | | | | 325| 318| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 318| len++; \ | | | | 327| 318| } \ | | | | 328| 997| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 354, False: 325] | | | | ------------------ | | | | 329| 679| { \ | | | | 330| 354| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 354| len += 2; \ | | | | 332| 354| } \ | | | | 333| 679| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 325, False: 0] | | | | ------------------ | | | | 334| 325| {\ | | | | 335| 325| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 325| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 325| len += 3; \ | | | | 338| 325| } \ | | | | 339| 325| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 997| } | | ------------------ | | | Branch (339:7): [True: 11.2k, False: 2.52k] | | | Branch (339:14): [True: 997, False: 10.2k] | | ------------------ ------------------ 4216| 13.7k| category = UCD_CATEGORY(fc); ------------------ | | 1859| 13.7k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 13.7k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 13.7k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 13.7k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 13.7k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 13.7k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 13.7k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 13.7k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 13.7k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 13.7k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 13.7k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 13.7k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 13.7k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4217| 13.7k| if ((category == ucp_L || category == ucp_N || ------------------ | Branch (4217:17): [True: 7.67k, False: 6.06k] | Branch (4217:18): [True: 3.24k, False: 10.4k] | Branch (4217:39): [True: 780, False: 9.71k] ------------------ 4218| 13.7k| fc == CHAR_UNDERSCORE) == notmatch) ------------------ | | 1045| 9.71k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (4218:18): [True: 0, False: 9.71k] ------------------ 4219| 7.67k| break; 4220| 6.06k| Feptr+= len; ------------------ | | 177| 6.06k|#define Feptr F->eptr ------------------ 4221| 6.06k| } 4222| 13.5k| break; 4223| | 4224| 294k| case PT_CLIST: ------------------ | | 1285| 294k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (4224:11): [True: 294k, False: 703k] ------------------ 4225| 299k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 294k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 299k|#define Lmax F->temp_32[1] ------------------ | Branch (4225:26): [True: 297k, False: 1.30k] ------------------ 4226| 297k| { 4227| 297k| const uint32_t *cp; 4228| 297k| int len = 1; 4229| 297k| if (Feptr >= mb->end_subject) ------------------ | | 177| 297k|#define Feptr F->eptr ------------------ | Branch (4229:17): [True: 3.35k, False: 294k] ------------------ 4230| 3.35k| { 4231| 3.35k| SCHECK_PARTIAL(); ------------------ | | 533| 3.35k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.52k, False: 1.83k] | | ------------------ | | 534| 3.35k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.52k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 515, False: 1.00k] | | | Branch (534:38): [True: 238, False: 767] | | ------------------ | | 535| 3.35k| { \ | | 536| 753| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 753|#define TRUE 1 | | ------------------ | | 537| 753| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 6|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 6, False: 747] | | ------------------ | | 538| 753| } ------------------ 4232| 3.34k| break; 4233| 3.35k| } 4234| 294k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 294k| c = *eptr; \ | | 339| 294k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.03k| { \ | | | | 323| 1.03k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 554, False: 484] | | | | ------------------ | | | | 324| 1.03k| { \ | | | | 325| 554| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 554| len++; \ | | | | 327| 554| } \ | | | | 328| 1.03k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 276, False: 208] | | | | ------------------ | | | | 329| 484| { \ | | | | 330| 276| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 276| len += 2; \ | | | | 332| 276| } \ | | | | 333| 484| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 208, False: 0] | | | | ------------------ | | | | 334| 208| {\ | | | | 335| 208| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 208| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 208| len += 3; \ | | | | 338| 208| } \ | | | | 339| 208| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.03k| } | | ------------------ | | | Branch (339:7): [True: 291k, False: 2.76k] | | | Branch (339:14): [True: 1.03k, False: 290k] | | ------------------ ------------------ 4235| 294k| cp = PRIV(ucd_caseless_sets) + Lpropvalue; ------------------ | | 177| 294k|#define PRIV(name) _pcre2_##name ------------------ cp = PRIV(ucd_caseless_sets) + Lpropvalue; ------------------ | | 2601| 294k|#define Lpropvalue F->temp_32[3] ------------------ 4236| 294k| for (;;) 4237| 310k| { 4238| 310k| if (fc < *cp) ------------------ | Branch (4238:19): [True: 291k, False: 18.9k] ------------------ 4239| 291k| { if (notmatch) break; else goto GOT_MAX; } ------------------ | Branch (4239:23): [True: 1.45k, False: 289k] ------------------ 4240| 18.9k| if (fc == *cp++) ------------------ | Branch (4240:19): [True: 3.28k, False: 15.7k] ------------------ 4241| 3.28k| { if (notmatch) goto GOT_MAX; else break; } ------------------ | Branch (4241:23): [True: 464, False: 2.82k] ------------------ 4242| 18.9k| } 4243| 4.27k| Feptr += len; ------------------ | | 177| 4.27k|#define Feptr F->eptr ------------------ 4244| 4.27k| } 4245| 294k| GOT_MAX: 4246| 294k| break; 4247| | 4248| 31.3k| case PT_UCNC: ------------------ | | 1286| 31.3k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (4248:11): [True: 31.3k, False: 966k] ------------------ 4249| 59.6k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 31.3k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 59.6k|#define Lmax F->temp_32[1] ------------------ | Branch (4249:26): [True: 49.6k, False: 10.0k] ------------------ 4250| 49.6k| { 4251| 49.6k| int len = 1; 4252| 49.6k| if (Feptr >= mb->end_subject) ------------------ | | 177| 49.6k|#define Feptr F->eptr ------------------ | Branch (4252:17): [True: 2.88k, False: 46.7k] ------------------ 4253| 2.88k| { 4254| 2.88k| SCHECK_PARTIAL(); ------------------ | | 533| 2.88k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.31k, False: 1.56k] | | ------------------ | | 534| 2.88k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.31k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 624, False: 694] | | | Branch (534:38): [True: 261, False: 433] | | ------------------ | | 535| 2.88k| { \ | | 536| 885| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 885|#define TRUE 1 | | ------------------ | | 537| 885| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 869] | | ------------------ | | 538| 885| } ------------------ 4255| 2.86k| break; 4256| 2.88k| } 4257| 46.7k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 46.7k| c = *eptr; \ | | 339| 46.7k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 839| { \ | | | | 323| 839| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 311, False: 528] | | | | ------------------ | | | | 324| 839| { \ | | | | 325| 311| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 311| len++; \ | | | | 327| 311| } \ | | | | 328| 839| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 218, False: 310] | | | | ------------------ | | | | 329| 528| { \ | | | | 330| 218| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 218| len += 2; \ | | | | 332| 218| } \ | | | | 333| 528| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 310, False: 0] | | | | ------------------ | | | | 334| 310| {\ | | | | 335| 310| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 310| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 310| len += 3; \ | | | | 338| 310| } \ | | | | 339| 310| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 839| } | | ------------------ | | | Branch (339:7): [True: 8.28k, False: 38.4k] | | | Branch (339:14): [True: 839, False: 7.44k] | | ------------------ ------------------ 4258| 46.7k| if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 986| 93.4k|#define CHAR_DOLLAR_SIGN '\044' ------------------ if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 92.6k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (4258:17): [True: 18.4k, False: 28.3k] | Branch (4258:18): [True: 768, False: 45.9k] | Branch (4258:44): [True: 1.11k, False: 44.8k] ------------------ 4259| 46.7k| fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) || ------------------ | | 1046| 91.5k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (4259:18): [True: 779, False: 44.0k] | Branch (4259:46): [True: 4.30k, False: 39.7k] | Branch (4259:60): [True: 3.99k, False: 310] ------------------ 4260| 46.7k| fc >= 0xe000) == notmatch) ------------------ | Branch (4260:18): [True: 310, False: 39.7k] ------------------ 4261| 18.4k| break; 4262| 28.3k| Feptr += len; ------------------ | | 177| 28.3k|#define Feptr F->eptr ------------------ 4263| 28.3k| } 4264| 31.3k| break; 4265| | 4266| 49.8k| case PT_BIDICL: ------------------ | | 1287| 49.8k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (4266:11): [True: 49.8k, False: 948k] ------------------ 4267| 98.1k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 49.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 98.1k|#define Lmax F->temp_32[1] ------------------ | Branch (4267:26): [True: 70.5k, False: 27.5k] ------------------ 4268| 70.5k| { 4269| 70.5k| int len = 1; 4270| 70.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 70.5k|#define Feptr F->eptr ------------------ | Branch (4270:17): [True: 5.56k, False: 64.9k] ------------------ 4271| 5.56k| { 4272| 5.56k| SCHECK_PARTIAL(); ------------------ | | 533| 5.56k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.35k, False: 4.20k] | | ------------------ | | 534| 5.56k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.35k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 469, False: 887] | | | Branch (534:38): [True: 604, False: 283] | | ------------------ | | 535| 5.56k| { \ | | 536| 1.07k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.07k|#define TRUE 1 | | ------------------ | | 537| 1.07k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 42|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 42, False: 1.03k] | | ------------------ | | 538| 1.07k| } ------------------ 4273| 5.52k| break; 4274| 5.56k| } 4275| 64.9k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 64.9k| c = *eptr; \ | | 339| 64.9k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 2.09k| { \ | | | | 323| 2.09k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 486, False: 1.60k] | | | | ------------------ | | | | 324| 2.09k| { \ | | | | 325| 486| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 486| len++; \ | | | | 327| 486| } \ | | | | 328| 2.09k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 1.29k, False: 315] | | | | ------------------ | | | | 329| 1.60k| { \ | | | | 330| 1.29k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 1.29k| len += 2; \ | | | | 332| 1.29k| } \ | | | | 333| 1.60k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 315, False: 0] | | | | ------------------ | | | | 334| 315| {\ | | | | 335| 315| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 315| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 315| len += 3; \ | | | | 338| 315| } \ | | | | 339| 315| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 2.09k| } | | ------------------ | | | Branch (339:7): [True: 8.28k, False: 56.6k] | | | Branch (339:14): [True: 2.09k, False: 6.19k] | | ------------------ ------------------ 4276| 64.9k| if ((UCD_BIDICLASS(fc) == Lpropvalue) == notmatch) break; ------------------ | | 1865| 64.9k|#define UCD_BIDICLASS(ch) UCD_BIDICLASS_PROP(GET_UCD(ch)) | | ------------------ | | | | 1854| 64.9k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | | | ------------------ | | | | | | 1850| 64.9k|#define UCD_BIDICLASS_SHIFT 11 | | | | ------------------ | | ------------------ ------------------ if ((UCD_BIDICLASS(fc) == Lpropvalue) == notmatch) break; ------------------ | | 2601| 64.9k|#define Lpropvalue F->temp_32[3] ------------------ | Branch (4276:17): [True: 16.6k, False: 48.3k] ------------------ 4277| 48.3k| Feptr+= len; ------------------ | | 177| 48.3k|#define Feptr F->eptr ------------------ 4278| 48.3k| } 4279| 49.7k| break; 4280| | 4281| 49.7k| case PT_BOOL: ------------------ | | 1288| 9.21k|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (4281:11): [True: 9.21k, False: 989k] ------------------ 4282| 35.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 9.21k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 35.5k|#define Lmax F->temp_32[1] ------------------ | Branch (4282:26): [True: 34.7k, False: 803] ------------------ 4283| 34.7k| { 4284| 34.7k| BOOL ok; 4285| 34.7k| const ucd_record *prop; 4286| 34.7k| int len = 1; 4287| 34.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 34.7k|#define Feptr F->eptr ------------------ | Branch (4287:17): [True: 6.10k, False: 28.6k] ------------------ 4288| 6.10k| { 4289| 6.10k| SCHECK_PARTIAL(); ------------------ | | 533| 6.10k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.75k, False: 4.35k] | | ------------------ | | 534| 6.10k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.75k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 875, False: 880] | | | Branch (534:38): [True: 461, False: 419] | | ------------------ | | 535| 6.10k| { \ | | 536| 1.33k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.33k|#define TRUE 1 | | ------------------ | | 537| 1.33k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 21|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 21, False: 1.31k] | | ------------------ | | 538| 1.33k| } ------------------ 4290| 6.08k| break; 4291| 6.10k| } 4292| 28.6k| GETCHARLENTEST(fc, Feptr, len); ------------------ | | 338| 28.6k| c = *eptr; \ | | 339| 28.6k| if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 917| { \ | | | | 323| 917| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 446, False: 471] | | | | ------------------ | | | | 324| 917| { \ | | | | 325| 446| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 446| len++; \ | | | | 327| 446| } \ | | | | 328| 917| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 250, False: 221] | | | | ------------------ | | | | 329| 471| { \ | | | | 330| 250| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 250| len += 2; \ | | | | 332| 250| } \ | | | | 333| 471| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 221, False: 0] | | | | ------------------ | | | | 334| 221| {\ | | | | 335| 221| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 221| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 221| len += 3; \ | | | | 338| 221| } \ | | | | 339| 221| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 917| } | | ------------------ | | | Branch (339:7): [True: 4.83k, False: 23.7k] | | | Branch (339:14): [True: 917, False: 3.91k] | | ------------------ ------------------ 4293| 28.6k| prop = GET_UCD(fc); ------------------ | | 1846| 28.6k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 28.6k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 28.6k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 28.6k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 28.6k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 28.6k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 28.6k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 28.6k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 28.6k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 28.6k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 4294| 28.6k| ok = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 28.6k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 4295| 28.6k| UCD_BPROPS_PROP(prop), Lpropvalue) != 0; 4296| 28.6k| if (ok == notmatch) break; ------------------ | Branch (4296:17): [True: 2.30k, False: 26.2k] ------------------ 4297| 26.2k| Feptr+= len; ------------------ | | 177| 26.2k|#define Feptr F->eptr ------------------ 4298| 26.2k| } 4299| 9.19k| break; 4300| | 4301| 9.19k| default: ------------------ | Branch (4301:11): [True: 0, False: 998k] ------------------ 4302| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 4303| 998k| } 4304| | 4305| | /* Feptr is now past the end of the maximum run */ 4306| | 4307| 997k| if (reptype == REPTYPE_POS) continue; /* No backtracking */ ------------------ | Branch (4307:13): [True: 43.7k, False: 954k] ------------------ 4308| | 4309| | /* After \C in UTF mode, Lstart_eptr might be in the middle of a 4310| | Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't 4311| | go too far. */ 4312| | 4313| 954k| for(;;) 4314| 1.54M| { 4315| 1.54M| if (Feptr <= Lstart_eptr) break; ------------------ | | 177| 1.54M|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; ------------------ | | 2597| 1.54M|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (4315:15): [True: 951k, False: 594k] ------------------ 4316| 594k| RMATCH(Fecode, RM222); ------------------ | | 546| 594k| {\ | | 547| 594k| start_ecode = ra;\ | | 548| 594k| Freturn_id = rb;\ | | ------------------ | | | | 188| 594k|#define Freturn_id F->return_id | | ------------------ | | 549| 594k| goto MATCH_RECURSE;\ | | 550| 594k| L_##rb:;\ | | 551| 593k| } ------------------ 4317| 593k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 593k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 781| {\ | | 555| 781| rrc = ra;\ | | 556| 781| goto RETURN_SWITCH;\ | | 557| 781| } ------------------ | Branch (4317:15): [True: 781, False: 592k] ------------------ 4318| 592k| Feptr--; ------------------ | | 177| 592k|#define Feptr F->eptr ------------------ 4319| 592k| if (utf) BACKCHAR(Feptr); ------------------ | | 345| 103k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 14.7k, False: 88.6k] | | ------------------ ------------------ | Branch (4319:15): [True: 88.6k, False: 503k] ------------------ 4320| 592k| } 4321| 954k| } 4322| | 4323| | /* Match extended Unicode grapheme clusters. We will get here only if the 4324| | support is in the binary; otherwise a compile-time error occurs. */ 4325| | 4326| 1.69M| else if (Lctype == OP_EXTUNI) ------------------ | | 2600| 1.69M|#define Lctype F->temp_32[2] ------------------ | Branch (4326:16): [True: 16.3k, False: 1.67M] ------------------ 4327| 16.3k| { 4328| 101k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 16.3k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 101k|#define Lmax F->temp_32[1] ------------------ | Branch (4328:24): [True: 99.5k, False: 1.91k] ------------------ 4329| 99.5k| { 4330| 99.5k| if (Feptr >= mb->end_subject) ------------------ | | 177| 99.5k|#define Feptr F->eptr ------------------ | Branch (4330:15): [True: 14.3k, False: 85.2k] ------------------ 4331| 14.3k| { 4332| 14.3k| SCHECK_PARTIAL(); ------------------ | | 533| 14.3k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.42k, False: 11.9k] | | ------------------ | | 534| 14.3k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.42k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.77k, False: 649] | | | Branch (534:38): [True: 323, False: 326] | | ------------------ | | 535| 14.3k| { \ | | 536| 2.10k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.10k|#define TRUE 1 | | ------------------ | | 537| 2.10k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 4, False: 2.09k] | | ------------------ | | 538| 2.10k| } ------------------ 4333| 14.3k| break; 4334| 14.3k| } 4335| 85.2k| else 4336| 85.2k| { 4337| 85.2k| GETCHARINCTEST(fc, Feptr); ------------------ | | 323| 85.2k| c = *eptr++; \ | | 324| 85.2k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 2.26k| { \ | | | | 289| 2.26k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 567, False: 1.70k] | | | | ------------------ | | | | 290| 2.26k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 2.26k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 702, False: 998] | | | | ------------------ | | | | 292| 1.70k| { \ | | | | 293| 702| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 702| eptr += 2; \ | | | | 295| 702| } \ | | | | 296| 1.70k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 998, False: 0] | | | | ------------------ | | | | 297| 998| { \ | | | | 298| 998| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 998| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 998| eptr += 3; \ | | | | 301| 998| } \ | | | | 302| 998| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 2.26k| } | | ------------------ | | | Branch (324:7): [True: 23.4k, False: 61.7k] | | | Branch (324:14): [True: 2.26k, False: 21.1k] | | ------------------ ------------------ 4338| 85.2k| Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, ------------------ | | 177| 85.2k|#define Feptr F->eptr ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, ------------------ | | 177| 85.2k|#define PRIV(name) _pcre2_##name ------------------ Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, ------------------ | | 177| 85.2k|#define Feptr F->eptr ------------------ 4339| 85.2k| utf, NULL); 4340| 85.2k| } 4341| 85.2k| CHECK_PARTIAL(); ------------------ | | 527| 85.2k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 85.2k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 10.9k, False: 74.2k] | | ------------------ | | 528| 85.2k| { \ | | 529| 10.9k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 10.9k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 1.38k, False: 9.57k] | | | | ------------------ | | | | 534| 10.9k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 1.38k|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 1.38k, False: 0] | | | | | Branch (534:38): [True: 0, False: 0] | | | | ------------------ | | | | 535| 10.9k| { \ | | | | 536| 1.38k| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 1.38k|#define TRUE 1 | | | | ------------------ | | | | 537| 1.38k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 82|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 82, False: 1.30k] | | | | ------------------ | | | | 538| 1.38k| } | | ------------------ | | 530| 10.8k| } ------------------ 4342| 85.1k| } 4343| | 4344| | /* Feptr is now past the end of the maximum run */ 4345| | 4346| 16.2k| if (reptype == REPTYPE_POS) continue; /* No backtracking */ ------------------ | Branch (4346:13): [True: 1.29k, False: 14.9k] ------------------ 4347| | 4348| | /* We use <= Lstart_eptr rather than == Lstart_eptr to detect the start 4349| | of the run while backtracking because the use of \C in UTF mode can 4350| | cause BACKCHAR to move back past Lstart_eptr. This is just palliative; 4351| | the use of \C in UTF mode is fraught with danger. */ 4352| | 4353| 14.9k| for(;;) 4354| 79.7k| { 4355| 79.7k| int lgb, rgb; 4356| 79.7k| PCRE2_SPTR fptr; ------------------ | | 814| 79.7k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 79.7k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 79.7k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 79.7k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4357| | 4358| 79.7k| if (Feptr <= Lstart_eptr) break; /* At start of char run */ ------------------ | | 177| 79.7k|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; /* At start of char run */ ------------------ | | 2597| 79.7k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (4358:15): [True: 13.2k, False: 66.5k] ------------------ 4359| 66.5k| RMATCH(Fecode, RM220); ------------------ | | 546| 66.5k| {\ | | 547| 66.5k| start_ecode = ra;\ | | 548| 66.5k| Freturn_id = rb;\ | | ------------------ | | | | 188| 66.5k|#define Freturn_id F->return_id | | ------------------ | | 549| 66.5k| goto MATCH_RECURSE;\ | | 550| 66.5k| L_##rb:;\ | | 551| 66.1k| } ------------------ 4360| 66.1k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 66.1k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.30k| {\ | | 555| 1.30k| rrc = ra;\ | | 556| 1.30k| goto RETURN_SWITCH;\ | | 557| 1.30k| } ------------------ | Branch (4360:15): [True: 1.30k, False: 64.8k] ------------------ 4361| | 4362| | /* Backtracking over an extended grapheme cluster involves inspecting 4363| | the previous two characters (if present) to see if a break is 4364| | permitted between them. */ 4365| | 4366| 64.8k| Feptr--; ------------------ | | 177| 64.8k|#define Feptr F->eptr ------------------ 4367| 64.8k| if (!utf) fc = *Feptr; else ------------------ | | 177| 42.5k|#define Feptr F->eptr ------------------ | Branch (4367:15): [True: 42.5k, False: 22.2k] ------------------ 4368| 22.2k| { 4369| 22.2k| BACKCHAR(Feptr); ------------------ | | 345| 27.5k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 5.29k, False: 22.2k] | | ------------------ ------------------ 4370| 22.2k| GETCHAR(fc, Feptr); ------------------ | | 302| 22.2k| c = *eptr; \ | | 303| 22.2k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 2.58k| { \ | | | | 267| 2.58k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 833, False: 1.75k] | | | | ------------------ | | | | 268| 2.58k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 2.58k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 790, False: 960] | | | | ------------------ | | | | 270| 1.75k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 1.75k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 960, False: 0] | | | | ------------------ | | | | 272| 960| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 960| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 960| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 2.58k| } | | ------------------ | | | Branch (303:7): [True: 2.58k, False: 19.6k] | | ------------------ ------------------ 4371| 22.2k| } 4372| 64.8k| rgb = UCD_GRAPHBREAK(fc); ------------------ | | 1860| 64.8k|#define UCD_GRAPHBREAK(ch) GET_UCD(ch)->gbprop | | ------------------ | | | | 1846| 64.8k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 64.8k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 64.8k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 64.8k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 64.8k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 64.8k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 64.8k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 64.8k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 64.8k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 64.8k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4373| | 4374| 64.8k| for (;;) 4375| 66.5k| { 4376| 66.5k| if (Feptr <= Lstart_eptr) break; /* At start of char run */ ------------------ | | 177| 66.5k|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; /* At start of char run */ ------------------ | | 2597| 66.5k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (4376:17): [True: 9.52k, False: 57.0k] ------------------ 4377| 57.0k| fptr = Feptr - 1; ------------------ | | 177| 57.0k|#define Feptr F->eptr ------------------ 4378| 57.0k| if (!utf) fc = *fptr; else ------------------ | Branch (4378:17): [True: 38.0k, False: 18.9k] ------------------ 4379| 18.9k| { 4380| 18.9k| BACKCHAR(fptr); ------------------ | | 345| 21.9k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 3.03k, False: 18.9k] | | ------------------ ------------------ 4381| 18.9k| GETCHAR(fc, fptr); ------------------ | | 302| 18.9k| c = *eptr; \ | | 303| 18.9k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 1.47k| { \ | | | | 267| 1.47k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 550, False: 929] | | | | ------------------ | | | | 268| 1.47k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 1.47k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 307, False: 622] | | | | ------------------ | | | | 270| 929| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 929| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 622, False: 0] | | | | ------------------ | | | | 272| 622| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 622| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 622| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 1.47k| } | | ------------------ | | | Branch (303:7): [True: 1.47k, False: 17.4k] | | ------------------ ------------------ 4382| 18.9k| } 4383| 57.0k| lgb = UCD_GRAPHBREAK(fc); ------------------ | | 1860| 57.0k|#define UCD_GRAPHBREAK(ch) GET_UCD(ch)->gbprop | | ------------------ | | | | 1846| 57.0k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 57.0k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 57.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 57.0k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 57.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 57.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 57.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 57.0k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 57.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 57.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4384| 57.0k| if ((PRIV(ucp_gbtable)[lgb] & (1u << rgb)) == 0) break; ------------------ | | 177| 57.0k|#define PRIV(name) _pcre2_##name ------------------ | Branch (4384:17): [True: 55.2k, False: 1.71k] ------------------ 4385| 1.71k| Feptr = fptr; ------------------ | | 177| 1.71k|#define Feptr F->eptr ------------------ 4386| 1.71k| rgb = lgb; 4387| 1.71k| } 4388| 64.8k| } 4389| 14.9k| } 4390| | 4391| 1.67M| else 4392| 1.67M|#endif /* SUPPORT_UNICODE */ 4393| | 4394| 1.67M|#ifdef SUPPORT_UNICODE 4395| 1.67M| if (utf) ------------------ | Branch (4395:11): [True: 1.23M, False: 439k] ------------------ 4396| 1.23M| { 4397| 1.23M| switch(Lctype) ------------------ | | 2600| 1.23M|#define Lctype F->temp_32[2] ------------------ 4398| 1.23M| { 4399| 96.0k| case OP_ANY: ------------------ | Branch (4399:11): [True: 96.0k, False: 1.14M] ------------------ 4400| 428k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 96.0k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 428k|#define Lmax F->temp_32[1] ------------------ | Branch (4400:26): [True: 421k, False: 7.84k] ------------------ 4401| 421k| { 4402| 421k| if (Feptr >= mb->end_subject) ------------------ | | 177| 421k|#define Feptr F->eptr ------------------ | Branch (4402:17): [True: 65.6k, False: 355k] ------------------ 4403| 65.6k| { 4404| 65.6k| SCHECK_PARTIAL(); ------------------ | | 533| 65.6k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 14.2k, False: 51.3k] | | ------------------ | | 534| 65.6k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 14.2k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 12.8k, False: 1.42k] | | | Branch (534:38): [True: 256, False: 1.17k] | | ------------------ | | 535| 65.6k| { \ | | 536| 13.1k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 13.1k|#define TRUE 1 | | ------------------ | | 537| 13.1k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 19|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 19, False: 13.0k] | | ------------------ | | 538| 13.1k| } ------------------ 4405| 65.5k| break; 4406| 65.6k| } 4407| 355k| if (IS_NEWLINE(Feptr)) break; ------------------ | | 479| 355k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 355k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 355k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 22.5k, False: 332k] | | | Branch (479:4): [True: 19.8k, False: 335k] | | ------------------ | | 480| 355k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 19.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 39.7k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 19.8k, False: 0] | | ------------------ | | 481| 19.8k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 19.8k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 19.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 19.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 19.8k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 1.40k, False: 18.4k] | | ------------------ | | 482| 19.8k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 19.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 355k| : \ | | 484| 355k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 335k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 335k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 335k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 331k, False: 4.02k] | | ------------------ | | 485| 335k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 331k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 331k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 22.1k, False: 309k] | | ------------------ | | 486| 335k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 22.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.34k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.34k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 20.8k, False: 1.34k] | | | Branch (486:30): [True: 340, False: 1.00k] | | ------------------ | | 487| 335k| ) \ | | 488| 355k| ) ------------------ 4408| 332k| if (mb->partial != 0 && /* Take care with CRLF partial */ ------------------ | Branch (4408:17): [True: 86.5k, False: 246k] ------------------ 4409| 332k| Feptr + 1 >= mb->end_subject && ------------------ | | 177| 86.5k|#define Feptr F->eptr ------------------ | Branch (4409:17): [True: 10.2k, False: 76.3k] ------------------ 4410| 332k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 10.2k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 343k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (4410:17): [True: 9.69k, False: 552] ------------------ 4411| 332k| NLBLOCK->nllen == 2 && ------------------ | | 59| 9.69k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (4411:17): [True: 1.63k, False: 8.06k] ------------------ 4412| 332k| UCHAR21(Feptr) == NLBLOCK->nl[0]) ------------------ | | 243| 1.63k|#define UCHAR21(eptr) (*(eptr)) ------------------ UCHAR21(Feptr) == NLBLOCK->nl[0]) ------------------ | | 59| 1.63k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (4412:17): [True: 571, False: 1.06k] ------------------ 4413| 571| { 4414| 571| mb->hitend = TRUE; ------------------ | | 70| 571|#define TRUE 1 ------------------ 4415| 571| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 5|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (4415:19): [True: 5, False: 566] ------------------ 4416| 571| } 4417| 332k| Feptr++; ------------------ | | 177| 332k|#define Feptr F->eptr ------------------ 4418| 332k| ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++); ------------------ | | 353| 376k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 321k, False: 55.2k] | | | Branch (353:24): [True: 44.1k, False: 277k] | | ------------------ ------------------ 4419| 332k| } 4420| 96.0k| break; 4421| | 4422| 96.0k| case OP_ALLANY: ------------------ | Branch (4422:11): [True: 48.9k, False: 1.18M] ------------------ 4423| 48.9k| if (Lmax < UINT32_MAX) ------------------ | | 2599| 48.9k|#define Lmax F->temp_32[1] ------------------ | Branch (4423:15): [True: 27.0k, False: 21.9k] ------------------ 4424| 27.0k| { 4425| 51.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 27.0k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 51.5k|#define Lmax F->temp_32[1] ------------------ | Branch (4425:28): [True: 28.3k, False: 23.1k] ------------------ 4426| 28.3k| { 4427| 28.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 28.3k|#define Feptr F->eptr ------------------ | Branch (4427:19): [True: 3.82k, False: 24.5k] ------------------ 4428| 3.82k| { 4429| 3.82k| SCHECK_PARTIAL(); ------------------ | | 533| 3.82k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 805, False: 3.02k] | | ------------------ | | 534| 3.82k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 805|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 321, False: 484] | | | Branch (534:38): [True: 246, False: 238] | | ------------------ | | 535| 3.82k| { \ | | 536| 567| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 567|#define TRUE 1 | | ------------------ | | 537| 567| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 41|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 41, False: 526] | | ------------------ | | 538| 567| } ------------------ 4430| 3.78k| break; 4431| 3.82k| } 4432| 24.5k| Feptr++; ------------------ | | 177| 24.5k|#define Feptr F->eptr ------------------ 4433| 24.5k| ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++); ------------------ | | 353| 25.2k| while((condition) && ((*eptr) & 0xc0u) == 0x80u) action | | ------------------ | | | Branch (353:9): [True: 22.8k, False: 2.45k] | | | Branch (353:24): [True: 707, False: 22.0k] | | ------------------ ------------------ 4434| 24.5k| } 4435| 27.0k| } 4436| 21.9k| else 4437| 21.9k| { 4438| 21.9k| Feptr = mb->end_subject; /* Unlimited UTF-8 repeat */ ------------------ | | 177| 21.9k|#define Feptr F->eptr ------------------ 4439| 21.9k| SCHECK_PARTIAL(); ------------------ | | 533| 21.9k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.37k, False: 20.5k] | | ------------------ | | 534| 21.9k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.37k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 864, False: 512] | | | Branch (534:38): [True: 250, False: 262] | | ------------------ | | 535| 21.9k| { \ | | 536| 1.11k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.11k|#define TRUE 1 | | ------------------ | | 537| 1.11k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 370|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 370, False: 744] | | ------------------ | | 538| 1.11k| } ------------------ 4440| 21.6k| } 4441| 48.5k| break; 4442| | 4443| | /* The "byte" (i.e. "code unit") case is the same as non-UTF */ 4444| | 4445| 48.5k| case OP_ANYBYTE: ------------------ | Branch (4445:11): [True: 0, False: 1.23M] ------------------ 4446| 0| fc = Lmax - Lmin; ------------------ | | 2599| 0|#define Lmax F->temp_32[1] ------------------ fc = Lmax - Lmin; ------------------ | | 2598| 0|#define Lmin F->temp_32[0] ------------------ 4447| 0| if (fc > (uint32_t)(mb->end_subject - Feptr)) ------------------ | | 177| 0|#define Feptr F->eptr ------------------ | Branch (4447:15): [True: 0, False: 0] ------------------ 4448| 0| { 4449| 0| Feptr = mb->end_subject; ------------------ | | 177| 0|#define Feptr F->eptr ------------------ 4450| 0| SCHECK_PARTIAL(); ------------------ | | 533| 0| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 0, False: 0] | | ------------------ | | 534| 0| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 0|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 0, False: 0] | | | Branch (534:38): [True: 0, False: 0] | | ------------------ | | 535| 0| { \ | | 536| 0| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 0|#define TRUE 1 | | ------------------ | | 537| 0| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 0|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 0, False: 0] | | ------------------ | | 538| 0| } ------------------ 4451| 0| } 4452| 0| else Feptr += fc; ------------------ | | 177| 0|#define Feptr F->eptr ------------------ 4453| 0| break; 4454| | 4455| 24.6k| case OP_ANYNL: ------------------ | Branch (4455:11): [True: 24.6k, False: 1.21M] ------------------ 4456| 30.3k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 24.6k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 30.3k|#define Lmax F->temp_32[1] ------------------ | Branch (4456:26): [True: 28.7k, False: 1.64k] ------------------ 4457| 28.7k| { 4458| 28.7k| int len = 1; 4459| 28.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 28.7k|#define Feptr F->eptr ------------------ | Branch (4459:17): [True: 8.58k, False: 20.1k] ------------------ 4460| 8.58k| { 4461| 8.58k| SCHECK_PARTIAL(); ------------------ | | 533| 8.58k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.30k, False: 7.27k] | | ------------------ | | 534| 8.58k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.30k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 299, False: 1.00k] | | | Branch (534:38): [True: 235, False: 770] | | ------------------ | | 535| 8.58k| { \ | | 536| 534| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 534|#define TRUE 1 | | ------------------ | | 537| 534| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 518] | | ------------------ | | 538| 534| } ------------------ 4462| 8.56k| break; 4463| 8.58k| } 4464| 20.1k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 20.1k| c = *eptr; \ | | 331| 20.1k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.61k| { \ | | | | 323| 1.61k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 407, False: 1.21k] | | | | ------------------ | | | | 324| 1.61k| { \ | | | | 325| 407| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 407| len++; \ | | | | 327| 407| } \ | | | | 328| 1.61k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 808, False: 404] | | | | ------------------ | | | | 329| 1.21k| { \ | | | | 330| 808| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 808| len += 2; \ | | | | 332| 808| } \ | | | | 333| 1.21k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 404, False: 0] | | | | ------------------ | | | | 334| 404| {\ | | | | 335| 404| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 404| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 404| len += 3; \ | | | | 338| 404| } \ | | | | 339| 404| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.61k| } | | ------------------ | | | Branch (331:7): [True: 1.61k, False: 18.5k] | | ------------------ ------------------ 4465| 20.1k| if (fc == CHAR_CR) ------------------ | | 972| 20.1k|#define CHAR_CR '\015' ------------------ | Branch (4465:17): [True: 2.16k, False: 17.9k] ------------------ 4466| 2.16k| { 4467| 2.16k| if (++Feptr >= mb->end_subject) break; ------------------ | | 177| 2.16k|#define Feptr F->eptr ------------------ | Branch (4467:19): [True: 726, False: 1.43k] ------------------ 4468| 1.43k| if (UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 243| 1.43k|#define UCHAR21(eptr) (*(eptr)) ------------------ if (UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 973| 1.43k|#define CHAR_LF '\012' ------------------ if (UCHAR21(Feptr) == CHAR_LF) Feptr++; ------------------ | | 177| 648|#define Feptr F->eptr ------------------ | Branch (4468:19): [True: 648, False: 789] ------------------ 4469| 1.43k| } 4470| 17.9k| else 4471| 17.9k| { 4472| 17.9k| if (fc != CHAR_LF && ------------------ | | 973| 35.9k|#define CHAR_LF '\012' ------------------ | Branch (4472:19): [True: 16.9k, False: 1.01k] ------------------ 4473| 17.9k| (mb->bsr_convention == PCRE2_BSR_ANYCRLF || ------------------ | | 217| 33.9k|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (4473:20): [True: 0, False: 16.9k] ------------------ 4474| 16.9k| (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL ------------------ | | 970| 33.9k|#define CHAR_VT '\013' ------------------ (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL ------------------ | | 971| 32.4k|#define CHAR_FF '\014' ------------------ (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL ------------------ | | 975| 31.6k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (4474:21): [True: 15.4k, False: 1.51k] | Branch (4474:38): [True: 14.6k, False: 803] | Branch (4474:55): [True: 14.4k, False: 218] ------------------ 4475| 16.9k|#ifndef EBCDIC 4476| 16.9k| && fc != 0x2028 && fc != 0x2029 ------------------ | Branch (4476:24): [True: 14.1k, False: 306] | Branch (4476:40): [True: 13.7k, False: 412] ------------------ 4477| 16.9k|#endif /* Not EBCDIC */ 4478| 16.9k| ))) 4479| 13.7k| break; 4480| 4.26k| Feptr += len; ------------------ | | 177| 4.26k|#define Feptr F->eptr ------------------ 4481| 4.26k| } 4482| 20.1k| } 4483| 24.6k| break; 4484| | 4485| 24.6k| case OP_NOT_HSPACE: ------------------ | Branch (4485:11): [True: 17.5k, False: 1.22M] ------------------ 4486| 27.5k| case OP_HSPACE: ------------------ | Branch (4486:11): [True: 10.0k, False: 1.22M] ------------------ 4487| 78.7k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 27.5k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 78.7k|#define Lmax F->temp_32[1] ------------------ | Branch (4487:26): [True: 76.9k, False: 1.76k] ------------------ 4488| 76.9k| { 4489| 76.9k| BOOL gotspace; 4490| 76.9k| int len = 1; 4491| 76.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 76.9k|#define Feptr F->eptr ------------------ | Branch (4491:17): [True: 11.7k, False: 65.1k] ------------------ 4492| 11.7k| { 4493| 11.7k| SCHECK_PARTIAL(); ------------------ | | 533| 11.7k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.50k, False: 9.27k] | | ------------------ | | 534| 11.7k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.50k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 796, False: 1.70k] | | | Branch (534:38): [True: 266, False: 1.44k] | | ------------------ | | 535| 11.7k| { \ | | 536| 1.06k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.06k|#define TRUE 1 | | ------------------ | | 537| 1.06k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 58|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 58, False: 1.00k] | | ------------------ | | 538| 1.06k| } ------------------ 4494| 11.7k| break; 4495| 11.7k| } 4496| 65.1k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 65.1k| c = *eptr; \ | | 331| 65.1k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 11.5k| { \ | | | | 323| 11.5k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 1.08k, False: 10.4k] | | | | ------------------ | | | | 324| 11.5k| { \ | | | | 325| 1.08k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 1.08k| len++; \ | | | | 327| 1.08k| } \ | | | | 328| 11.5k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 9.95k, False: 462] | | | | ------------------ | | | | 329| 10.4k| { \ | | | | 330| 9.95k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 9.95k| len += 2; \ | | | | 332| 9.95k| } \ | | | | 333| 10.4k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 462, False: 0] | | | | ------------------ | | | | 334| 462| {\ | | | | 335| 462| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 462| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 462| len += 3; \ | | | | 338| 462| } \ | | | | 339| 462| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 11.5k| } | | ------------------ | | | Branch (331:7): [True: 11.5k, False: 53.6k] | | ------------------ ------------------ 4497| 65.1k| switch(fc) 4498| 65.1k| { 4499| 11.9k| HSPACE_CASES: gotspace = TRUE; break; ------------------ | | 412| 2.54k| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 989| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 989|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 989, False: 64.2k] | | | | ------------------ | | | | 408| 1.80k| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 1.80k|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 813, False: 64.3k] | | | | ------------------ | | | | 409| 2.54k| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 3.60k| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 3.60k| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 1.05k, False: 64.1k] | | | | ------------------ | | | | 390| 4.37k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 774, False: 64.4k] | | | | ------------------ | | | | 391| 4.72k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 348, False: 64.8k] | | | | ------------------ | | | | 392| 5.24k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 522, False: 64.6k] | | | | ------------------ | | | | 393| 5.73k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 485, False: 64.7k] | | | | ------------------ | | | | 394| 6.26k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 536, False: 64.6k] | | | | ------------------ | | | | 395| 6.81k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 547, False: 64.6k] | | | | ------------------ | | | | 396| 7.73k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 916, False: 64.2k] | | | | ------------------ | | | | 397| 8.21k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 486, False: 64.7k] | | | | ------------------ | | | | 398| 8.57k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 354, False: 64.8k] | | | | ------------------ | | | | 399| 9.11k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 548, False: 64.6k] | | | | ------------------ | | | | 400| 9.70k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 590, False: 64.5k] | | | | ------------------ | | | | 401| 10.2k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 508, False: 64.6k] | | | | ------------------ | | | | 402| 10.6k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 466, False: 64.7k] | | | | ------------------ | | | | 403| 11.5k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 891, False: 64.2k] | | | | ------------------ | | | | 404| 11.9k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ HSPACE_CASES: gotspace = TRUE; break; ------------------ | | 70| 11.9k|#define TRUE 1 ------------------ 4500| 53.2k| default: gotspace = FALSE; break; ------------------ | | 69| 53.2k|#define FALSE 0 ------------------ | Branch (4500:15): [True: 53.2k, False: 11.9k] ------------------ 4501| 65.1k| } 4502| 65.1k| if (gotspace == (Lctype == OP_NOT_HSPACE)) break; ------------------ | | 2600| 65.1k|#define Lctype F->temp_32[2] ------------------ | Branch (4502:17): [True: 14.0k, False: 51.1k] ------------------ 4503| 51.1k| Feptr += len; ------------------ | | 177| 51.1k|#define Feptr F->eptr ------------------ 4504| 51.1k| } 4505| 27.5k| break; 4506| | 4507| 27.5k| case OP_NOT_VSPACE: ------------------ | Branch (4507:11): [True: 12.7k, False: 1.22M] ------------------ 4508| 26.0k| case OP_VSPACE: ------------------ | Branch (4508:11): [True: 13.3k, False: 1.22M] ------------------ 4509| 60.8k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 26.0k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 60.8k|#define Lmax F->temp_32[1] ------------------ | Branch (4509:26): [True: 59.4k, False: 1.43k] ------------------ 4510| 59.4k| { 4511| 59.4k| BOOL gotspace; 4512| 59.4k| int len = 1; 4513| 59.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 59.4k|#define Feptr F->eptr ------------------ | Branch (4513:17): [True: 9.67k, False: 49.7k] ------------------ 4514| 9.67k| { 4515| 9.67k| SCHECK_PARTIAL(); ------------------ | | 533| 9.67k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.65k, False: 8.02k] | | ------------------ | | 534| 9.67k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.65k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 665, False: 989] | | | Branch (534:38): [True: 235, False: 754] | | ------------------ | | 535| 9.67k| { \ | | 536| 900| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 900|#define TRUE 1 | | ------------------ | | 537| 900| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 35|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 35, False: 865] | | ------------------ | | 538| 900| } ------------------ 4516| 9.64k| break; 4517| 9.67k| } 4518| 49.7k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 49.7k| c = *eptr; \ | | 331| 49.7k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 5.23k| { \ | | | | 323| 5.23k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 1.58k, False: 3.65k] | | | | ------------------ | | | | 324| 5.23k| { \ | | | | 325| 1.58k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 1.58k| len++; \ | | | | 327| 1.58k| } \ | | | | 328| 5.23k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 2.81k, False: 845] | | | | ------------------ | | | | 329| 3.65k| { \ | | | | 330| 2.81k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 2.81k| len += 2; \ | | | | 332| 2.81k| } \ | | | | 333| 3.65k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 845, False: 0] | | | | ------------------ | | | | 334| 845| {\ | | | | 335| 845| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 845| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 845| len += 3; \ | | | | 338| 845| } \ | | | | 339| 845| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 5.23k| } | | ------------------ | | | Branch (331:7): [True: 5.23k, False: 44.5k] | | ------------------ ------------------ 4519| 49.7k| switch(fc) 4520| 49.7k| { 4521| 6.62k| VSPACE_CASES: gotspace = TRUE; break; ------------------ | | 430| 4.67k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 580| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 580|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 580, False: 49.1k] | | | | ------------------ | | | | 424| 1.50k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 1.50k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 929, False: 48.8k] | | | | ------------------ | | | | 425| 2.89k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 2.89k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 1.38k, False: 48.3k] | | | | ------------------ | | | | 426| 4.17k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 4.17k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 1.27k, False: 48.4k] | | | | ------------------ | | | | 427| 4.67k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 0|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 5.42k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 5.42k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 752, False: 48.9k] | | | | ------------------ | | | | 420| 6.62k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ VSPACE_CASES: gotspace = TRUE; break; ------------------ | | 70| 6.62k|#define TRUE 1 ------------------ 4522| 43.1k| default: gotspace = FALSE; break; ------------------ | | 69| 43.1k|#define FALSE 0 ------------------ | Branch (4522:15): [True: 43.1k, False: 6.62k] ------------------ 4523| 49.7k| } 4524| 49.7k| if (gotspace == (Lctype == OP_NOT_VSPACE)) break; ------------------ | | 2600| 49.7k|#define Lctype F->temp_32[2] ------------------ | Branch (4524:17): [True: 14.9k, False: 34.7k] ------------------ 4525| 34.7k| Feptr += len; ------------------ | | 177| 34.7k|#define Feptr F->eptr ------------------ 4526| 34.7k| } 4527| 26.0k| break; 4528| | 4529| 26.0k| case OP_NOT_DIGIT: ------------------ | Branch (4529:11): [True: 23.8k, False: 1.21M] ------------------ 4530| 35.7k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 23.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 35.7k|#define Lmax F->temp_32[1] ------------------ | Branch (4530:26): [True: 35.3k, False: 350] ------------------ 4531| 35.3k| { 4532| 35.3k| int len = 1; 4533| 35.3k| if (Feptr >= mb->end_subject) ------------------ | | 177| 35.3k|#define Feptr F->eptr ------------------ | Branch (4533:17): [True: 3.67k, False: 31.6k] ------------------ 4534| 3.67k| { 4535| 3.67k| SCHECK_PARTIAL(); ------------------ | | 533| 3.67k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.92k, False: 1.75k] | | ------------------ | | 534| 3.67k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.92k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 656, False: 1.26k] | | | Branch (534:38): [True: 268, False: 1.00k] | | ------------------ | | 535| 3.67k| { \ | | 536| 924| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 924|#define TRUE 1 | | ------------------ | | 537| 924| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 16|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 16, False: 908] | | ------------------ | | 538| 924| } ------------------ 4536| 3.65k| break; 4537| 3.67k| } 4538| 31.6k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 31.6k| c = *eptr; \ | | 331| 31.6k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.33k| { \ | | | | 323| 1.33k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 575, False: 761] | | | | ------------------ | | | | 324| 1.33k| { \ | | | | 325| 575| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 575| len++; \ | | | | 327| 575| } \ | | | | 328| 1.33k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 349, False: 412] | | | | ------------------ | | | | 329| 761| { \ | | | | 330| 349| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 349| len += 2; \ | | | | 332| 349| } \ | | | | 333| 761| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 412, False: 0] | | | | ------------------ | | | | 334| 412| {\ | | | | 335| 412| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 412| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 412| len += 3; \ | | | | 338| 412| } \ | | | | 339| 412| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.33k| } | | ------------------ | | | Branch (331:7): [True: 1.33k, False: 30.3k] | | ------------------ ------------------ 4539| 31.6k| if (fc < 256 && (mb->ctypes[fc] & ctype_digit) != 0) break; ------------------ | | 582| 30.3k|#define ctype_digit 0x08 ------------------ | Branch (4539:17): [True: 30.3k, False: 1.33k] | Branch (4539:29): [True: 19.8k, False: 10.5k] ------------------ 4540| 11.8k| Feptr+= len; ------------------ | | 177| 11.8k|#define Feptr F->eptr ------------------ 4541| 11.8k| } 4542| 23.8k| break; 4543| | 4544| 426k| case OP_DIGIT: ------------------ | Branch (4544:11): [True: 426k, False: 810k] ------------------ 4545| 430k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 426k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 430k|#define Lmax F->temp_32[1] ------------------ | Branch (4545:26): [True: 429k, False: 883] ------------------ 4546| 429k| { 4547| 429k| int len = 1; 4548| 429k| if (Feptr >= mb->end_subject) ------------------ | | 177| 429k|#define Feptr F->eptr ------------------ | Branch (4548:17): [True: 2.06k, False: 427k] ------------------ 4549| 2.06k| { 4550| 2.06k| SCHECK_PARTIAL(); ------------------ | | 533| 2.06k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 776, False: 1.29k] | | ------------------ | | 534| 2.06k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 776|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 272, False: 504] | | | Branch (534:38): [True: 237, False: 267] | | ------------------ | | 535| 2.06k| { \ | | 536| 509| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 509|#define TRUE 1 | | ------------------ | | 537| 509| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 7|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 7, False: 502] | | ------------------ | | 538| 509| } ------------------ 4551| 2.06k| break; 4552| 2.06k| } 4553| 427k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 427k| c = *eptr; \ | | 331| 427k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 1.35k| { \ | | | | 323| 1.35k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 884, False: 467] | | | | ------------------ | | | | 324| 1.35k| { \ | | | | 325| 884| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 884| len++; \ | | | | 327| 884| } \ | | | | 328| 1.35k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 214, False: 253] | | | | ------------------ | | | | 329| 467| { \ | | | | 330| 214| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 214| len += 2; \ | | | | 332| 214| } \ | | | | 333| 467| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 253, False: 0] | | | | ------------------ | | | | 334| 253| {\ | | | | 335| 253| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 253| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 253| len += 3; \ | | | | 338| 253| } \ | | | | 339| 253| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 1.35k| } | | ------------------ | | | Branch (331:7): [True: 1.35k, False: 425k] | | ------------------ ------------------ 4554| 427k| if (fc >= 256 ||(mb->ctypes[fc] & ctype_digit) == 0) break; ------------------ | | 582| 425k|#define ctype_digit 0x08 ------------------ | Branch (4554:17): [True: 1.33k, False: 425k] | Branch (4554:29): [True: 422k, False: 3.28k] ------------------ 4555| 3.28k| Feptr+= len; ------------------ | | 177| 3.28k|#define Feptr F->eptr ------------------ 4556| 3.28k| } 4557| 426k| break; 4558| | 4559| 426k| case OP_NOT_WHITESPACE: ------------------ | Branch (4559:11): [True: 135k, False: 1.10M] ------------------ 4560| 154k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 135k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 154k|#define Lmax F->temp_32[1] ------------------ | Branch (4560:26): [True: 145k, False: 8.73k] ------------------ 4561| 145k| { 4562| 145k| int len = 1; 4563| 145k| if (Feptr >= mb->end_subject) ------------------ | | 177| 145k|#define Feptr F->eptr ------------------ | Branch (4563:17): [True: 3.75k, False: 141k] ------------------ 4564| 3.75k| { 4565| 3.75k| SCHECK_PARTIAL(); ------------------ | | 533| 3.75k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.70k, False: 2.04k] | | ------------------ | | 534| 3.75k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.70k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 686, False: 1.01k] | | | Branch (534:38): [True: 236, False: 783] | | ------------------ | | 535| 3.75k| { \ | | 536| 922| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 922|#define TRUE 1 | | ------------------ | | 537| 922| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 26|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 26, False: 896] | | ------------------ | | 538| 922| } ------------------ 4566| 3.72k| break; 4567| 3.75k| } 4568| 141k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 141k| c = *eptr; \ | | 331| 141k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 983| { \ | | | | 323| 983| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 503, False: 480] | | | | ------------------ | | | | 324| 983| { \ | | | | 325| 503| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 503| len++; \ | | | | 327| 503| } \ | | | | 328| 983| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 227, False: 253] | | | | ------------------ | | | | 329| 480| { \ | | | | 330| 227| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 227| len += 2; \ | | | | 332| 227| } \ | | | | 333| 480| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 253, False: 0] | | | | ------------------ | | | | 334| 253| {\ | | | | 335| 253| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 253| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 253| len += 3; \ | | | | 338| 253| } \ | | | | 339| 253| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 983| } | | ------------------ | | | Branch (331:7): [True: 983, False: 140k] | | ------------------ ------------------ 4569| 141k| if (fc < 256 && (mb->ctypes[fc] & ctype_space) != 0) break; ------------------ | | 579| 140k|#define ctype_space 0x01 ------------------ | Branch (4569:17): [True: 140k, False: 973] | Branch (4569:29): [True: 123k, False: 17.2k] ------------------ 4570| 18.1k| Feptr+= len; ------------------ | | 177| 18.1k|#define Feptr F->eptr ------------------ 4571| 18.1k| } 4572| 135k| break; 4573| | 4574| 135k| case OP_WHITESPACE: ------------------ | Branch (4574:11): [True: 25.1k, False: 1.21M] ------------------ 4575| 26.0k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 25.1k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 26.0k|#define Lmax F->temp_32[1] ------------------ | Branch (4575:26): [True: 25.7k, False: 220] ------------------ 4576| 25.7k| { 4577| 25.7k| int len = 1; 4578| 25.7k| if (Feptr >= mb->end_subject) ------------------ | | 177| 25.7k|#define Feptr F->eptr ------------------ | Branch (4578:17): [True: 3.33k, False: 22.4k] ------------------ 4579| 3.33k| { 4580| 3.33k| SCHECK_PARTIAL(); ------------------ | | 533| 3.33k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.04k, False: 1.29k] | | ------------------ | | 534| 3.33k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.04k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 326, False: 1.71k] | | | Branch (534:38): [True: 246, False: 1.46k] | | ------------------ | | 535| 3.33k| { \ | | 536| 572| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 572|#define TRUE 1 | | ------------------ | | 537| 572| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 8|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 8, False: 564] | | ------------------ | | 538| 572| } ------------------ 4581| 3.33k| break; 4582| 3.33k| } 4583| 22.4k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 22.4k| c = *eptr; \ | | 331| 22.4k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 3.42k| { \ | | | | 323| 3.42k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 2.80k, False: 621] | | | | ------------------ | | | | 324| 3.42k| { \ | | | | 325| 2.80k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 2.80k| len++; \ | | | | 327| 2.80k| } \ | | | | 328| 3.42k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 364, False: 257] | | | | ------------------ | | | | 329| 621| { \ | | | | 330| 364| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 364| len += 2; \ | | | | 332| 364| } \ | | | | 333| 621| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 257, False: 0] | | | | ------------------ | | | | 334| 257| {\ | | | | 335| 257| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 257| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 257| len += 3; \ | | | | 338| 257| } \ | | | | 339| 257| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 3.42k| } | | ------------------ | | | Branch (331:7): [True: 3.42k, False: 19.0k] | | ------------------ ------------------ 4584| 22.4k| if (fc >= 256 ||(mb->ctypes[fc] & ctype_space) == 0) break; ------------------ | | 579| 19.0k|#define ctype_space 0x01 ------------------ | Branch (4584:17): [True: 3.41k, False: 19.0k] | Branch (4584:29): [True: 18.1k, False: 879] ------------------ 4585| 879| Feptr+= len; ------------------ | | 177| 879|#define Feptr F->eptr ------------------ 4586| 879| } 4587| 25.1k| break; 4588| | 4589| 139k| case OP_NOT_WORDCHAR: ------------------ | Branch (4589:11): [True: 139k, False: 1.09M] ------------------ 4590| 144k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 139k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 144k|#define Lmax F->temp_32[1] ------------------ | Branch (4590:26): [True: 143k, False: 963] ------------------ 4591| 143k| { 4592| 143k| int len = 1; 4593| 143k| if (Feptr >= mb->end_subject) ------------------ | | 177| 143k|#define Feptr F->eptr ------------------ | Branch (4593:17): [True: 3.30k, False: 140k] ------------------ 4594| 3.30k| { 4595| 3.30k| SCHECK_PARTIAL(); ------------------ | | 533| 3.30k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.72k, False: 1.57k] | | ------------------ | | 534| 3.30k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.72k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 664, False: 1.06k] | | | Branch (534:38): [True: 303, False: 761] | | ------------------ | | 535| 3.30k| { \ | | 536| 967| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 967|#define TRUE 1 | | ------------------ | | 537| 967| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 11|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 11, False: 956] | | ------------------ | | 538| 967| } ------------------ 4596| 3.29k| break; 4597| 3.30k| } 4598| 140k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 140k| c = *eptr; \ | | 331| 140k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 766| { \ | | | | 323| 766| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 267, False: 499] | | | | ------------------ | | | | 324| 766| { \ | | | | 325| 267| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 267| len++; \ | | | | 327| 267| } \ | | | | 328| 766| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 222, False: 277] | | | | ------------------ | | | | 329| 499| { \ | | | | 330| 222| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 222| len += 2; \ | | | | 332| 222| } \ | | | | 333| 499| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 277, False: 0] | | | | ------------------ | | | | 334| 277| {\ | | | | 335| 277| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 277| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 277| len += 3; \ | | | | 338| 277| } \ | | | | 339| 277| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 766| } | | ------------------ | | | Branch (331:7): [True: 766, False: 139k] | | ------------------ ------------------ 4599| 140k| if (fc < 256 && (mb->ctypes[fc] & ctype_word) != 0) break; ------------------ | | 583| 139k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (4599:17): [True: 139k, False: 764] | Branch (4599:29): [True: 135k, False: 3.94k] ------------------ 4600| 4.71k| Feptr+= len; ------------------ | | 177| 4.71k|#define Feptr F->eptr ------------------ 4601| 4.71k| } 4602| 139k| break; 4603| | 4604| 262k| case OP_WORDCHAR: ------------------ | Branch (4604:11): [True: 262k, False: 975k] ------------------ 4605| 270k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 262k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 270k|#define Lmax F->temp_32[1] ------------------ | Branch (4605:26): [True: 267k, False: 3.59k] ------------------ 4606| 267k| { 4607| 267k| int len = 1; 4608| 267k| if (Feptr >= mb->end_subject) ------------------ | | 177| 267k|#define Feptr F->eptr ------------------ | Branch (4608:17): [True: 2.48k, False: 264k] ------------------ 4609| 2.48k| { 4610| 2.48k| SCHECK_PARTIAL(); ------------------ | | 533| 2.48k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.37k, False: 1.10k] | | ------------------ | | 534| 2.48k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.37k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 387, False: 991] | | | Branch (534:38): [True: 232, False: 759] | | ------------------ | | 535| 2.48k| { \ | | 536| 619| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 619|#define TRUE 1 | | ------------------ | | 537| 619| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 8|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 8, False: 611] | | ------------------ | | 538| 619| } ------------------ 4611| 2.47k| break; 4612| 2.48k| } 4613| 264k| GETCHARLEN(fc, Feptr, len); ------------------ | | 330| 264k| c = *eptr; \ | | 331| 264k| if (c >= 0xc0u) GETUTF8LEN(c, eptr, len); | | ------------------ | | | | 322| 987| { \ | | | | 323| 987| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (323:9): [True: 446, False: 541] | | | | ------------------ | | | | 324| 987| { \ | | | | 325| 446| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 326| 446| len++; \ | | | | 327| 446| } \ | | | | 328| 987| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (328:14): [True: 328, False: 213] | | | | ------------------ | | | | 329| 541| { \ | | | | 330| 328| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 331| 328| len += 2; \ | | | | 332| 328| } \ | | | | 333| 541| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (333:14): [True: 213, False: 0] | | | | ------------------ | | | | 334| 213| {\ | | | | 335| 213| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 336| 213| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 337| 213| len += 3; \ | | | | 338| 213| } \ | | | | 339| 213| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (339:14): [True: 0, False: 0] | | | | ------------------ | | | | 340| 0| { \ | | | | 341| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 342| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 343| 0| (eptr[4] & 0x3fu); \ | | | | 344| 0| len += 4; \ | | | | 345| 0| } \ | | | | 346| 0| else \ | | | | 347| 0| {\ | | | | 348| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 349| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 350| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 351| 0| len += 5; \ | | | | 352| 0| } \ | | | | 353| 987| } | | ------------------ | | | Branch (331:7): [True: 987, False: 263k] | | ------------------ ------------------ 4614| 264k| if (fc >= 256 || (mb->ctypes[fc] & ctype_word) == 0) break; ------------------ | | 583| 263k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (4614:17): [True: 987, False: 263k] | Branch (4614:30): [True: 255k, False: 8.41k] ------------------ 4615| 8.41k| Feptr+= len; ------------------ | | 177| 8.41k|#define Feptr F->eptr ------------------ 4616| 8.41k| } 4617| 262k| break; 4618| | 4619| 262k| default: ------------------ | Branch (4619:11): [True: 0, False: 1.23M] ------------------ 4620| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 4621| 1.23M| } 4622| | 4623| 1.23M| if (reptype == REPTYPE_POS) continue; /* No backtracking */ ------------------ | Branch (4623:13): [True: 41.6k, False: 1.19M] ------------------ 4624| | 4625| | /* After \C in UTF mode, Lstart_eptr might be in the middle of a 4626| | Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't go 4627| | too far. */ 4628| | 4629| 1.19M| for(;;) 4630| 1.65M| { 4631| 1.65M| if (Feptr <= Lstart_eptr) break; ------------------ | | 177| 1.65M|#define Feptr F->eptr ------------------ if (Feptr <= Lstart_eptr) break; ------------------ | | 2597| 1.65M|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (4631:15): [True: 1.18M, False: 461k] ------------------ 4632| 461k| RMATCH(Fecode, RM221); ------------------ | | 546| 461k| {\ | | 547| 461k| start_ecode = ra;\ | | 548| 461k| Freturn_id = rb;\ | | ------------------ | | | | 188| 461k|#define Freturn_id F->return_id | | ------------------ | | 549| 461k| goto MATCH_RECURSE;\ | | 550| 461k| L_##rb:;\ | | 551| 458k| } ------------------ 4633| 458k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 458k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 4.01k| {\ | | 555| 4.01k| rrc = ra;\ | | 556| 4.01k| goto RETURN_SWITCH;\ | | 557| 4.01k| } ------------------ | Branch (4633:15): [True: 4.01k, False: 454k] ------------------ 4634| 454k| Feptr--; ------------------ | | 177| 454k|#define Feptr F->eptr ------------------ 4635| 454k| BACKCHAR(Feptr); ------------------ | | 345| 531k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 76.2k, False: 454k] | | ------------------ ------------------ 4636| 454k| if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && ------------------ | | 2600| 454k|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && ------------------ | | 177| 5.41k|#define Feptr F->eptr ------------------ if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && ------------------ | | 2597| 460k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (4636:15): [True: 5.41k, False: 449k] | Branch (4636:37): [True: 1.73k, False: 3.68k] ------------------ 4637| 454k| UCHAR21(Feptr) == CHAR_NL && UCHAR21(Feptr - 1) == CHAR_CR) ------------------ | | 243| 1.73k|#define UCHAR21(eptr) (*(eptr)) ------------------ UCHAR21(Feptr) == CHAR_NL && UCHAR21(Feptr - 1) == CHAR_CR) ------------------ | | 974| 1.73k|#define CHAR_NL CHAR_LF | | ------------------ | | | | 973| 456k|#define CHAR_LF '\012' | | ------------------ ------------------ UCHAR21(Feptr) == CHAR_NL && UCHAR21(Feptr - 1) == CHAR_CR) ------------------ | | 243| 1.03k|#define UCHAR21(eptr) (*(eptr)) ------------------ UCHAR21(Feptr) == CHAR_NL && UCHAR21(Feptr - 1) == CHAR_CR) ------------------ | | 972| 1.03k|#define CHAR_CR '\015' ------------------ | Branch (4637:15): [True: 1.03k, False: 705] | Branch (4637:44): [True: 644, False: 388] ------------------ 4638| 644| Feptr--; ------------------ | | 177| 644|#define Feptr F->eptr ------------------ 4639| 454k| } 4640| 1.19M| } 4641| 439k| else 4642| 439k|#endif /* SUPPORT_UNICODE */ 4643| | 4644| | /* Not UTF mode */ 4645| 439k| { 4646| 439k| switch(Lctype) ------------------ | | 2600| 439k|#define Lctype F->temp_32[2] ------------------ 4647| 439k| { 4648| 159k| case OP_ANY: ------------------ | Branch (4648:11): [True: 159k, False: 279k] ------------------ 4649| 1.10M| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 159k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 1.10M|#define Lmax F->temp_32[1] ------------------ | Branch (4649:26): [True: 1.07M, False: 24.0k] ------------------ 4650| 1.07M| { 4651| 1.07M| if (Feptr >= mb->end_subject) ------------------ | | 177| 1.07M|#define Feptr F->eptr ------------------ | Branch (4651:17): [True: 120k, False: 956k] ------------------ 4652| 120k| { 4653| 120k| SCHECK_PARTIAL(); ------------------ | | 533| 120k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 24.8k, False: 95.6k] | | ------------------ | | 534| 120k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 24.8k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 23.3k, False: 1.47k] | | | Branch (534:38): [True: 577, False: 896] | | ------------------ | | 535| 120k| { \ | | 536| 23.9k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 23.9k|#define TRUE 1 | | ------------------ | | 537| 23.9k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 856|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 856, False: 23.1k] | | ------------------ | | 538| 23.9k| } ------------------ 4654| 119k| break; 4655| 120k| } 4656| 956k| if (IS_NEWLINE(Feptr)) break; ------------------ | | 479| 956k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 956k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 956k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:3): [True: 15.2k, False: 941k] | | | Branch (479:4): [True: 48.5k, False: 908k] | | ------------------ | | 480| 956k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 48.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 97.0k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 48.5k, False: 0] | | ------------------ | | 481| 48.5k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 48.5k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 48.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 48.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 48.5k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 3.89k, False: 44.6k] | | ------------------ | | 482| 48.5k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 48.5k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 956k| : \ | | 484| 956k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 908k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 908k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 908k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 900k, False: 7.69k] | | ------------------ | | 485| 908k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 900k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 900k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 13.8k, False: 886k] | | ------------------ | | 486| 908k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 13.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 4.13k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 4.13k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 9.69k, False: 4.13k] | | | Branch (486:30): [True: 1.61k, False: 2.52k] | | ------------------ | | 487| 908k| ) \ | | 488| 956k| ) ------------------ 4657| 941k| if (mb->partial != 0 && /* Take care with CRLF partial */ ------------------ | Branch (4657:17): [True: 175k, False: 765k] ------------------ 4658| 941k| Feptr + 1 >= mb->end_subject && ------------------ | | 177| 175k|#define Feptr F->eptr ------------------ | Branch (4658:17): [True: 20.4k, False: 155k] ------------------ 4659| 941k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 20.4k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 961k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (4659:17): [True: 19.2k, False: 1.21k] ------------------ 4660| 941k| NLBLOCK->nllen == 2 && ------------------ | | 59| 19.2k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (4660:17): [True: 2.34k, False: 16.8k] ------------------ 4661| 941k| *Feptr == NLBLOCK->nl[0]) ------------------ | | 177| 2.34k|#define Feptr F->eptr ------------------ *Feptr == NLBLOCK->nl[0]) ------------------ | | 59| 2.34k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (4661:17): [True: 932, False: 1.40k] ------------------ 4662| 932| { 4663| 932| mb->hitend = TRUE; ------------------ | | 70| 932|#define TRUE 1 ------------------ 4664| 932| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 60|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (4664:19): [True: 60, False: 872] ------------------ 4665| 932| } 4666| 941k| Feptr++; ------------------ | | 177| 941k|#define Feptr F->eptr ------------------ 4667| 941k| } 4668| 158k| break; 4669| | 4670| 158k| case OP_ALLANY: ------------------ | Branch (4670:11): [True: 13.2k, False: 425k] ------------------ 4671| 13.2k| case OP_ANYBYTE: ------------------ | Branch (4671:11): [True: 0, False: 439k] ------------------ 4672| 13.2k| fc = Lmax - Lmin; ------------------ | | 2599| 13.2k|#define Lmax F->temp_32[1] ------------------ fc = Lmax - Lmin; ------------------ | | 2598| 13.2k|#define Lmin F->temp_32[0] ------------------ 4673| 13.2k| if (fc > (uint32_t)(mb->end_subject - Feptr)) ------------------ | | 177| 13.2k|#define Feptr F->eptr ------------------ | Branch (4673:15): [True: 5.63k, False: 7.61k] ------------------ 4674| 5.63k| { 4675| 5.63k| Feptr = mb->end_subject; ------------------ | | 177| 5.63k|#define Feptr F->eptr ------------------ 4676| 5.63k| SCHECK_PARTIAL(); ------------------ | | 533| 5.63k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 901, False: 4.73k] | | ------------------ | | 534| 5.63k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 901|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 411, False: 490] | | | Branch (534:38): [True: 250, False: 240] | | ------------------ | | 535| 5.63k| { \ | | 536| 661| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 661|#define TRUE 1 | | ------------------ | | 537| 661| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 157|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 157, False: 504] | | ------------------ | | 538| 661| } ------------------ 4677| 5.47k| } 4678| 7.61k| else Feptr += fc; ------------------ | | 177| 7.61k|#define Feptr F->eptr ------------------ 4679| 13.0k| break; 4680| | 4681| 21.5k| case OP_ANYNL: ------------------ | Branch (4681:11): [True: 21.5k, False: 417k] ------------------ 4682| 27.9k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 21.5k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 27.9k|#define Lmax F->temp_32[1] ------------------ | Branch (4682:26): [True: 27.0k, False: 883] ------------------ 4683| 27.0k| { 4684| 27.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 27.0k|#define Feptr F->eptr ------------------ | Branch (4684:17): [True: 7.68k, False: 19.4k] ------------------ 4685| 7.68k| { 4686| 7.68k| SCHECK_PARTIAL(); ------------------ | | 533| 7.68k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.13k, False: 6.54k] | | ------------------ | | 534| 7.68k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.13k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 360, False: 773] | | | Branch (534:38): [True: 393, False: 380] | | ------------------ | | 535| 7.68k| { \ | | 536| 753| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 753|#define TRUE 1 | | ------------------ | | 537| 753| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 37|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 37, False: 716] | | ------------------ | | 538| 753| } ------------------ 4687| 7.64k| break; 4688| 7.68k| } 4689| 19.4k| fc = *Feptr; ------------------ | | 177| 19.4k|#define Feptr F->eptr ------------------ 4690| 19.4k| if (fc == CHAR_CR) ------------------ | | 972| 19.4k|#define CHAR_CR '\015' ------------------ | Branch (4690:17): [True: 2.42k, False: 16.9k] ------------------ 4691| 2.42k| { 4692| 2.42k| if (++Feptr >= mb->end_subject) break; ------------------ | | 177| 2.42k|#define Feptr F->eptr ------------------ | Branch (4692:19): [True: 697, False: 1.73k] ------------------ 4693| 1.73k| if (*Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 1.73k|#define Feptr F->eptr ------------------ if (*Feptr == CHAR_LF) Feptr++; ------------------ | | 973| 1.73k|#define CHAR_LF '\012' ------------------ if (*Feptr == CHAR_LF) Feptr++; ------------------ | | 177| 711|#define Feptr F->eptr ------------------ | Branch (4693:19): [True: 711, False: 1.02k] ------------------ 4694| 1.73k| } 4695| 16.9k| else 4696| 16.9k| { 4697| 16.9k| if (fc != CHAR_LF && (mb->bsr_convention == PCRE2_BSR_ANYCRLF || ------------------ | | 973| 33.9k|#define CHAR_LF '\012' ------------------ if (fc != CHAR_LF && (mb->bsr_convention == PCRE2_BSR_ANYCRLF || ------------------ | | 217| 30.5k|#define PCRE2_BSR_ANYCRLF 2 ------------------ | Branch (4697:19): [True: 15.2k, False: 1.71k] | Branch (4697:37): [True: 0, False: 15.2k] ------------------ 4698| 15.2k| (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL ------------------ | | 970| 30.5k|#define CHAR_VT '\013' ------------------ (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL ------------------ | | 971| 29.2k|#define CHAR_FF '\014' ------------------ (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL ------------------ | | 975| 13.3k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (4698:19): [True: 13.9k, False: 1.31k] | Branch (4698:36): [True: 13.3k, False: 630] | Branch (4698:53): [True: 12.3k, False: 1.02k] ------------------ 4699| |#if PCRE2_CODE_UNIT_WIDTH != 8 4700| | && fc != 0x2028 && fc != 0x2029 4701| |#endif 4702| 15.2k| ))) break; 4703| 4.67k| Feptr++; ------------------ | | 177| 4.67k|#define Feptr F->eptr ------------------ 4704| 4.67k| } 4705| 19.4k| } 4706| 21.5k| break; 4707| | 4708| 22.7k| case OP_NOT_HSPACE: ------------------ | Branch (4708:11): [True: 22.7k, False: 416k] ------------------ 4709| 111k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 22.7k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 111k|#define Lmax F->temp_32[1] ------------------ | Branch (4709:26): [True: 109k, False: 1.83k] ------------------ 4710| 109k| { 4711| 109k| if (Feptr >= mb->end_subject) ------------------ | | 177| 109k|#define Feptr F->eptr ------------------ | Branch (4711:17): [True: 17.0k, False: 92.4k] ------------------ 4712| 17.0k| { 4713| 17.0k| SCHECK_PARTIAL(); ------------------ | | 533| 17.0k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.50k, False: 15.5k] | | ------------------ | | 534| 17.0k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.50k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 925, False: 584] | | | Branch (534:38): [True: 281, False: 303] | | ------------------ | | 535| 17.0k| { \ | | 536| 1.20k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.20k|#define TRUE 1 | | ------------------ | | 537| 1.20k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 87|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 87, False: 1.11k] | | ------------------ | | 538| 1.20k| } ------------------ 4714| 16.9k| break; 4715| 17.0k| } 4716| 92.4k| switch(*Feptr) ------------------ | | 177| 92.4k|#define Feptr F->eptr ------------------ 4717| 92.4k| { 4718| 88.6k| default: Feptr++; break; ------------------ | | 177| 88.6k|#define Feptr F->eptr ------------------ | Branch (4718:15): [True: 88.6k, False: 3.80k] ------------------ 4719| 6.76k| HSPACE_BYTE_CASES: ------------------ | | 407| 1.08k| case CHAR_HT: \ | | ------------------ | | | | 969| 1.08k|#define CHAR_HT '\011' | | ------------------ | | | Branch (407:3): [True: 1.08k, False: 91.3k] | | ------------------ | | 408| 1.87k| case CHAR_SPACE: \ | | ------------------ | | | | 982| 1.87k|#define CHAR_SPACE '\040' | | ------------------ | | | Branch (408:3): [True: 786, False: 91.6k] | | ------------------ | | 409| 88.6k| case CHAR_NBSP | | ------------------ | | | | 1077| 88.6k|#define CHAR_NBSP ((unsigned char)'\xa0') | | ------------------ ------------------ 4720| |#if PCRE2_CODE_UNIT_WIDTH != 8 4721| | HSPACE_MULTIBYTE_CASES: 4722| |#endif 4723| 6.76k| goto ENDLOOP00; 4724| 92.4k| } 4725| 92.4k| } 4726| 22.6k| ENDLOOP00: 4727| 22.6k| break; 4728| | 4729| 18.8k| case OP_HSPACE: ------------------ | Branch (4729:11): [True: 15.8k, False: 423k] ------------------ 4730| 17.3k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 15.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 17.3k|#define Lmax F->temp_32[1] ------------------ | Branch (4730:26): [True: 16.9k, False: 418] ------------------ 4731| 16.9k| { 4732| 16.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 16.9k|#define Feptr F->eptr ------------------ | Branch (4732:17): [True: 5.09k, False: 11.8k] ------------------ 4733| 5.09k| { 4734| 5.09k| SCHECK_PARTIAL(); ------------------ | | 533| 5.09k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.09k, False: 3.99k] | | ------------------ | | 534| 5.09k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.09k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 297, False: 799] | | | Branch (534:38): [True: 400, False: 399] | | ------------------ | | 535| 5.09k| { \ | | 536| 697| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 697|#define TRUE 1 | | ------------------ | | 537| 697| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 13|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 13, False: 684] | | ------------------ | | 538| 697| } ------------------ 4735| 5.08k| break; 4736| 5.09k| } 4737| 11.8k| switch(*Feptr) ------------------ | | 177| 11.8k|#define Feptr F->eptr ------------------ 4738| 11.8k| { 4739| 10.3k| default: goto ENDLOOP01; ------------------ | Branch (4739:15): [True: 10.3k, False: 1.54k] ------------------ 4740| 10.3k| HSPACE_BYTE_CASES: ------------------ | | 407| 436| case CHAR_HT: \ | | ------------------ | | | | 969| 436|#define CHAR_HT '\011' | | ------------------ | | | Branch (407:3): [True: 436, False: 11.4k] | | ------------------ | | 408| 1.03k| case CHAR_SPACE: \ | | ------------------ | | | | 982| 1.03k|#define CHAR_SPACE '\040' | | ------------------ | | | Branch (408:3): [True: 603, False: 11.2k] | | ------------------ | | 409| 10.3k| case CHAR_NBSP | | ------------------ | | | | 1077| 10.3k|#define CHAR_NBSP ((unsigned char)'\xa0') | | ------------------ ------------------ 4741| |#if PCRE2_CODE_UNIT_WIDTH != 8 4742| | HSPACE_MULTIBYTE_CASES: 4743| |#endif 4744| 3.02k| Feptr++; break; ------------------ | | 177| 1.54k|#define Feptr F->eptr ------------------ 4745| 11.8k| } 4746| 11.8k| } 4747| 15.8k| ENDLOOP01: 4748| 15.8k| break; 4749| | 4750| 14.6k| case OP_NOT_VSPACE: ------------------ | Branch (4750:11): [True: 14.6k, False: 424k] ------------------ 4751| 64.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 14.6k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 64.5k|#define Lmax F->temp_32[1] ------------------ | Branch (4751:26): [True: 63.4k, False: 1.08k] ------------------ 4752| 63.4k| { 4753| 63.4k| if (Feptr >= mb->end_subject) ------------------ | | 177| 63.4k|#define Feptr F->eptr ------------------ | Branch (4753:17): [True: 8.68k, False: 54.7k] ------------------ 4754| 8.68k| { 4755| 8.68k| SCHECK_PARTIAL(); ------------------ | | 533| 8.68k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.20k, False: 7.47k] | | ------------------ | | 534| 8.68k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.20k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 726, False: 483] | | | Branch (534:38): [True: 239, False: 244] | | ------------------ | | 535| 8.68k| { \ | | 536| 965| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 965|#define TRUE 1 | | ------------------ | | 537| 965| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 57|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 57, False: 908] | | ------------------ | | 538| 965| } ------------------ 4756| 8.62k| break; 4757| 8.68k| } 4758| 54.7k| switch(*Feptr) ------------------ | | 177| 54.7k|#define Feptr F->eptr ------------------ 4759| 54.7k| { 4760| 49.8k| default: Feptr++; break; ------------------ | | 177| 49.8k|#define Feptr F->eptr ------------------ | Branch (4760:15): [True: 49.8k, False: 4.87k] ------------------ 4761| 13.0k| VSPACE_BYTE_CASES: ------------------ | | 423| 529| case CHAR_LF: \ | | ------------------ | | | | 973| 529|#define CHAR_LF '\012' | | ------------------ | | | Branch (423:3): [True: 529, False: 54.2k] | | ------------------ | | 424| 1.31k| case CHAR_VT: \ | | ------------------ | | | | 970| 1.31k|#define CHAR_VT '\013' | | ------------------ | | | Branch (424:3): [True: 783, False: 53.9k] | | ------------------ | | 425| 2.40k| case CHAR_FF: \ | | ------------------ | | | | 971| 2.40k|#define CHAR_FF '\014' | | ------------------ | | | Branch (425:3): [True: 1.09k, False: 53.6k] | | ------------------ | | 426| 3.96k| case CHAR_CR: \ | | ------------------ | | | | 972| 3.96k|#define CHAR_CR '\015' | | ------------------ | | | Branch (426:3): [True: 1.56k, False: 53.2k] | | ------------------ | | 427| 49.8k| case CHAR_NEL | | ------------------ | | | | 975| 49.8k|#define CHAR_NEL ((unsigned char)'\x85') | | ------------------ ------------------ 4762| |#if PCRE2_CODE_UNIT_WIDTH != 8 4763| | VSPACE_MULTIBYTE_CASES: 4764| |#endif 4765| 13.0k| goto ENDLOOP02; 4766| 54.7k| } 4767| 54.7k| } 4768| 14.5k| ENDLOOP02: 4769| 14.5k| break; 4770| | 4771| 21.1k| case OP_VSPACE: ------------------ | Branch (4771:11): [True: 21.1k, False: 418k] ------------------ 4772| 23.5k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 21.1k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 23.5k|#define Lmax F->temp_32[1] ------------------ | Branch (4772:26): [True: 23.2k, False: 328] ------------------ 4773| 23.2k| { 4774| 23.2k| if (Feptr >= mb->end_subject) ------------------ | | 177| 23.2k|#define Feptr F->eptr ------------------ | Branch (4774:17): [True: 4.88k, False: 18.3k] ------------------ 4775| 4.88k| { 4776| 4.88k| SCHECK_PARTIAL(); ------------------ | | 533| 4.88k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.24k, False: 3.64k] | | ------------------ | | 534| 4.88k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.24k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 336, False: 904] | | | Branch (534:38): [True: 429, False: 475] | | ------------------ | | 535| 4.88k| { \ | | 536| 765| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 765|#define TRUE 1 | | ------------------ | | 537| 765| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 31|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 31, False: 734] | | ------------------ | | 538| 765| } ------------------ 4777| 4.85k| break; 4778| 4.88k| } 4779| 18.3k| switch(*Feptr) ------------------ | | 177| 18.3k|#define Feptr F->eptr ------------------ 4780| 18.3k| { 4781| 15.8k| default: goto ENDLOOP03; ------------------ | Branch (4781:15): [True: 15.8k, False: 2.46k] ------------------ 4782| 15.8k| VSPACE_BYTE_CASES: ------------------ | | 423| 354| case CHAR_LF: \ | | ------------------ | | | | 973| 354|#define CHAR_LF '\012' | | ------------------ | | | Branch (423:3): [True: 354, False: 18.0k] | | ------------------ | | 424| 891| case CHAR_VT: \ | | ------------------ | | | | 970| 891|#define CHAR_VT '\013' | | ------------------ | | | Branch (424:3): [True: 537, False: 17.8k] | | ------------------ | | 425| 1.29k| case CHAR_FF: \ | | ------------------ | | | | 971| 1.29k|#define CHAR_FF '\014' | | ------------------ | | | Branch (425:3): [True: 400, False: 17.9k] | | ------------------ | | 426| 1.87k| case CHAR_CR: \ | | ------------------ | | | | 972| 1.87k|#define CHAR_CR '\015' | | ------------------ | | | Branch (426:3): [True: 583, False: 17.7k] | | ------------------ | | 427| 15.8k| case CHAR_NEL | | ------------------ | | | | 975| 15.8k|#define CHAR_NEL ((unsigned char)'\x85') | | ------------------ ------------------ 4783| |#if PCRE2_CODE_UNIT_WIDTH != 8 4784| | VSPACE_MULTIBYTE_CASES: 4785| |#endif 4786| 6.87k| Feptr++; break; ------------------ | | 177| 2.46k|#define Feptr F->eptr ------------------ 4787| 18.3k| } 4788| 18.3k| } 4789| 21.0k| ENDLOOP03: 4790| 21.0k| break; 4791| | 4792| 23.5k| case OP_NOT_DIGIT: ------------------ | Branch (4792:11): [True: 23.5k, False: 415k] ------------------ 4793| 83.0k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 23.5k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 83.0k|#define Lmax F->temp_32[1] ------------------ | Branch (4793:26): [True: 76.2k, False: 6.85k] ------------------ 4794| 76.2k| { 4795| 76.2k| if (Feptr >= mb->end_subject) ------------------ | | 177| 76.2k|#define Feptr F->eptr ------------------ | Branch (4795:17): [True: 11.4k, False: 64.7k] ------------------ 4796| 11.4k| { 4797| 11.4k| SCHECK_PARTIAL(); ------------------ | | 533| 11.4k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.85k, False: 8.62k] | | ------------------ | | 534| 11.4k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.85k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.70k, False: 1.14k] | | | Branch (534:38): [True: 645, False: 502] | | ------------------ | | 535| 11.4k| { \ | | 536| 2.35k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.35k|#define TRUE 1 | | ------------------ | | 537| 2.35k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 52|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 52, False: 2.29k] | | ------------------ | | 538| 2.35k| } ------------------ 4798| 11.4k| break; 4799| 11.4k| } 4800| 64.7k| if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0) ------------------ | | 212| 64.7k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 129k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0) ------------------ | | 177| 64.7k|#define Feptr F->eptr ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0) ------------------ | | 582| 64.7k|#define ctype_digit 0x08 ------------------ | Branch (4800:36): [True: 5.22k, False: 59.5k] ------------------ 4801| 5.22k| break; 4802| 59.5k| Feptr++; ------------------ | | 177| 59.5k|#define Feptr F->eptr ------------------ 4803| 59.5k| } 4804| 23.5k| break; 4805| | 4806| 32.8k| case OP_DIGIT: ------------------ | Branch (4806:11): [True: 32.8k, False: 406k] ------------------ 4807| 36.6k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 32.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 36.6k|#define Lmax F->temp_32[1] ------------------ | Branch (4807:26): [True: 35.9k, False: 678] ------------------ 4808| 35.9k| { 4809| 35.9k| if (Feptr >= mb->end_subject) ------------------ | | 177| 35.9k|#define Feptr F->eptr ------------------ | Branch (4809:17): [True: 3.48k, False: 32.4k] ------------------ 4810| 3.48k| { 4811| 3.48k| SCHECK_PARTIAL(); ------------------ | | 533| 3.48k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.36k, False: 2.11k] | | ------------------ | | 534| 3.48k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.36k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 333, False: 1.03k] | | | Branch (534:38): [True: 472, False: 564] | | ------------------ | | 535| 3.48k| { \ | | 536| 805| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 805|#define TRUE 1 | | ------------------ | | 537| 805| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 19|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 19, False: 786] | | ------------------ | | 538| 805| } ------------------ 4812| 3.46k| break; 4813| 3.48k| } 4814| 32.4k| if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0) ------------------ | | 212| 32.4k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 64.9k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0) ------------------ | | 177| 32.4k|#define Feptr F->eptr ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0) ------------------ | | 582| 32.4k|#define ctype_digit 0x08 ------------------ | Branch (4814:17): [Folded - Ignored] | Branch (4814:37): [True: 28.6k, False: 3.79k] ------------------ 4815| 28.6k| break; 4816| 3.79k| Feptr++; ------------------ | | 177| 3.79k|#define Feptr F->eptr ------------------ 4817| 3.79k| } 4818| 32.8k| break; 4819| | 4820| 43.4k| case OP_NOT_WHITESPACE: ------------------ | Branch (4820:11): [True: 43.4k, False: 395k] ------------------ 4821| 200k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 43.4k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 200k|#define Lmax F->temp_32[1] ------------------ | Branch (4821:26): [True: 191k, False: 9.37k] ------------------ 4822| 191k| { 4823| 191k| if (Feptr >= mb->end_subject) ------------------ | | 177| 191k|#define Feptr F->eptr ------------------ | Branch (4823:17): [True: 26.2k, False: 165k] ------------------ 4824| 26.2k| { 4825| 26.2k| SCHECK_PARTIAL(); ------------------ | | 533| 26.2k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 3.18k, False: 23.0k] | | ------------------ | | 534| 26.2k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 3.18k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 2.19k, False: 983] | | | Branch (534:38): [True: 589, False: 394] | | ------------------ | | 535| 26.2k| { \ | | 536| 2.78k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 2.78k|#define TRUE 1 | | ------------------ | | 537| 2.78k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 186|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 186, False: 2.60k] | | ------------------ | | 538| 2.78k| } ------------------ 4826| 26.0k| break; 4827| 26.2k| } 4828| 165k| if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0) ------------------ | | 212| 165k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 330k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0) ------------------ | | 177| 165k|#define Feptr F->eptr ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0) ------------------ | | 579| 165k|#define ctype_space 0x01 ------------------ | Branch (4828:36): [True: 7.79k, False: 157k] ------------------ 4829| 7.79k| break; 4830| 157k| Feptr++; ------------------ | | 177| 157k|#define Feptr F->eptr ------------------ 4831| 157k| } 4832| 43.2k| break; 4833| | 4834| 43.2k| case OP_WHITESPACE: ------------------ | Branch (4834:11): [True: 27.8k, False: 411k] ------------------ 4835| 29.2k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 27.8k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 29.2k|#define Lmax F->temp_32[1] ------------------ | Branch (4835:26): [True: 28.8k, False: 384] ------------------ 4836| 28.8k| { 4837| 28.8k| if (Feptr >= mb->end_subject) ------------------ | | 177| 28.8k|#define Feptr F->eptr ------------------ | Branch (4837:17): [True: 3.96k, False: 24.8k] ------------------ 4838| 3.96k| { 4839| 3.96k| SCHECK_PARTIAL(); ------------------ | | 533| 3.96k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.73k, False: 2.23k] | | ------------------ | | 534| 3.96k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.73k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 472, False: 1.25k] | | | Branch (534:38): [True: 593, False: 666] | | ------------------ | | 535| 3.96k| { \ | | 536| 1.06k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.06k|#define TRUE 1 | | ------------------ | | 537| 1.06k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 22|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 22, False: 1.04k] | | ------------------ | | 538| 1.06k| } ------------------ 4840| 3.94k| break; 4841| 3.96k| } 4842| 24.8k| if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0) ------------------ | | 212| 24.8k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 49.7k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0) ------------------ | | 177| 24.8k|#define Feptr F->eptr ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0) ------------------ | | 579| 24.8k|#define ctype_space 0x01 ------------------ | Branch (4842:17): [Folded - Ignored] | Branch (4842:37): [True: 23.4k, False: 1.40k] ------------------ 4843| 23.4k| break; 4844| 1.40k| Feptr++; ------------------ | | 177| 1.40k|#define Feptr F->eptr ------------------ 4845| 1.40k| } 4846| 27.8k| break; 4847| | 4848| 27.8k| case OP_NOT_WORDCHAR: ------------------ | Branch (4848:11): [True: 16.4k, False: 422k] ------------------ 4849| 34.8k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 16.4k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 34.8k|#define Lmax F->temp_32[1] ------------------ | Branch (4849:26): [True: 33.0k, False: 1.80k] ------------------ 4850| 33.0k| { 4851| 33.0k| if (Feptr >= mb->end_subject) ------------------ | | 177| 33.0k|#define Feptr F->eptr ------------------ | Branch (4851:17): [True: 6.55k, False: 26.4k] ------------------ 4852| 6.55k| { 4853| 6.55k| SCHECK_PARTIAL(); ------------------ | | 533| 6.55k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 2.26k, False: 4.28k] | | ------------------ | | 534| 6.55k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 2.26k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 1.28k, False: 986] | | | Branch (534:38): [True: 656, False: 330] | | ------------------ | | 535| 6.55k| { \ | | 536| 1.93k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.93k|#define TRUE 1 | | ------------------ | | 537| 1.93k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 44|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 44, False: 1.89k] | | ------------------ | | 538| 1.93k| } ------------------ 4854| 6.51k| break; 4855| 6.55k| } 4856| 26.4k| if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0) ------------------ | | 212| 26.4k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 52.9k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0) ------------------ | | 177| 26.4k|#define Feptr F->eptr ------------------ if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0) ------------------ | | 583| 26.4k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (4856:36): [True: 8.09k, False: 18.3k] ------------------ 4857| 8.09k| break; 4858| 18.3k| Feptr++; ------------------ | | 177| 18.3k|#define Feptr F->eptr ------------------ 4859| 18.3k| } 4860| 16.4k| break; 4861| | 4862| 26.2k| case OP_WORDCHAR: ------------------ | Branch (4862:11): [True: 26.2k, False: 413k] ------------------ 4863| 34.8k| for (i = Lmin; i < Lmax; i++) ------------------ | | 2598| 26.2k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 2599| 34.8k|#define Lmax F->temp_32[1] ------------------ | Branch (4863:26): [True: 31.1k, False: 3.77k] ------------------ 4864| 31.1k| { 4865| 31.1k| if (Feptr >= mb->end_subject) ------------------ | | 177| 31.1k|#define Feptr F->eptr ------------------ | Branch (4865:17): [True: 3.97k, False: 27.1k] ------------------ 4866| 3.97k| { 4867| 3.97k| SCHECK_PARTIAL(); ------------------ | | 533| 3.97k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 1.72k, False: 2.24k] | | ------------------ | | 534| 3.97k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 1.72k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 645, False: 1.08k] | | | Branch (534:38): [True: 620, False: 461] | | ------------------ | | 535| 3.97k| { \ | | 536| 1.26k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 1.26k|#define TRUE 1 | | ------------------ | | 537| 1.26k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 24|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 24, False: 1.24k] | | ------------------ | | 538| 1.26k| } ------------------ 4868| 3.94k| break; 4869| 3.97k| } 4870| 27.1k| if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0) ------------------ | | 212| 27.1k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 54.2k|#define TRUE 1 | | ------------------ ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0) ------------------ | | 177| 27.1k|#define Feptr F->eptr ------------------ if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0) ------------------ | | 583| 27.1k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (4870:17): [Folded - Ignored] | Branch (4870:37): [True: 18.4k, False: 8.66k] ------------------ 4871| 18.4k| break; 4872| 8.66k| Feptr++; ------------------ | | 177| 8.66k|#define Feptr F->eptr ------------------ 4873| 8.66k| } 4874| 26.2k| break; 4875| | 4876| 26.2k| default: ------------------ | Branch (4876:11): [True: 0, False: 439k] ------------------ 4877| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 4878| 439k| } 4879| | 4880| 437k| if (reptype == REPTYPE_POS) continue; /* No backtracking */ ------------------ | Branch (4880:13): [True: 141k, False: 296k] ------------------ 4881| | 4882| 296k| for (;;) 4883| 1.14M| { 4884| 1.14M| if (Feptr == Lstart_eptr) break; ------------------ | | 177| 1.14M|#define Feptr F->eptr ------------------ if (Feptr == Lstart_eptr) break; ------------------ | | 2597| 1.14M|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (4884:15): [True: 281k, False: 859k] ------------------ 4885| 859k| RMATCH(Fecode, RM34); ------------------ | | 546| 859k| {\ | | 547| 859k| start_ecode = ra;\ | | 548| 859k| Freturn_id = rb;\ | | ------------------ | | | | 188| 859k|#define Freturn_id F->return_id | | ------------------ | | 549| 859k| goto MATCH_RECURSE;\ | | 550| 859k| L_##rb:;\ | | 551| 850k| } ------------------ 4886| 850k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 850k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 6.76k| {\ | | 555| 6.76k| rrc = ra;\ | | 556| 6.76k| goto RETURN_SWITCH;\ | | 557| 6.76k| } ------------------ | Branch (4886:15): [True: 6.76k, False: 844k] ------------------ 4887| 844k| Feptr--; ------------------ | | 177| 844k|#define Feptr F->eptr ------------------ 4888| 844k| if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && *Feptr == CHAR_LF && ------------------ | | 2600| 844k|#define Lctype F->temp_32[2] ------------------ if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && *Feptr == CHAR_LF && ------------------ | | 177| 4.96k|#define Feptr F->eptr ------------------ if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && *Feptr == CHAR_LF && ------------------ | | 2597| 849k|#define Lstart_eptr F->temp_sptr[0] ------------------ if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && *Feptr == CHAR_LF && ------------------ | | 177| 2.15k|#define Feptr F->eptr ------------------ if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && *Feptr == CHAR_LF && ------------------ | | 973| 846k|#define CHAR_LF '\012' ------------------ | Branch (4888:15): [True: 4.96k, False: 839k] | Branch (4888:37): [True: 2.15k, False: 2.80k] | Branch (4888:60): [True: 1.38k, False: 779] ------------------ 4889| 844k| Feptr[-1] == CHAR_CR) Feptr--; ------------------ | | 177| 1.38k|#define Feptr F->eptr ------------------ Feptr[-1] == CHAR_CR) Feptr--; ------------------ | | 972| 1.38k|#define CHAR_CR '\015' ------------------ Feptr[-1] == CHAR_CR) Feptr--; ------------------ | | 177| 689|#define Feptr F->eptr ------------------ | Branch (4889:15): [True: 689, False: 691] ------------------ 4890| 844k| } 4891| 296k| } 4892| 2.69M| } 4893| 2.43M| break; /* End of repeat character type processing */ 4894| | 4895| 2.43M|#undef Lstart_eptr 4896| 2.43M|#undef Lmin 4897| 2.43M|#undef Lmax 4898| 2.43M|#undef Lctype 4899| 2.43M|#undef Lpropvalue 4900| | 4901| | 4902| | /* ===================================================================== */ 4903| | /* Match a back reference, possibly repeatedly. Look past the end of the 4904| | item to see if there is repeat information following. The OP_REF and 4905| | OP_REFI opcodes are used for a reference to a numbered group or to a 4906| | non-duplicated named group. For a duplicated named group, OP_DNREF and 4907| | OP_DNREFI are used. In this case we must scan the list of groups to which 4908| | the name refers, and use the first one that is set. */ 4909| | 4910| 2.43M|#define Lmin F->temp_32[0] 4911| 2.43M|#define Lmax F->temp_32[1] 4912| 2.43M|#define Lcaseless F->temp_32[2] 4913| 2.43M|#define Lstart F->temp_sptr[0] 4914| 2.43M|#define Loffset F->temp_size 4915| | 4916| 2.43M| case OP_DNREF: ------------------ | Branch (4916:5): [True: 10.0k, False: 2.33G] ------------------ 4917| 12.2k| case OP_DNREFI: ------------------ | Branch (4917:5): [True: 2.14k, False: 2.33G] ------------------ 4918| 12.2k| Lcaseless = (Fop == OP_DNREFI); ------------------ | | 4912| 12.2k|#define Lcaseless F->temp_32[2] ------------------ Lcaseless = (Fop == OP_DNREFI); ------------------ | | 186| 12.2k|#define Fop F->op ------------------ 4919| 12.2k| { 4920| 12.2k| int count = GET2(Fecode, 1+IMM2_SIZE); ------------------ | | 194| 12.2k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 4921| 12.2k| PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size; ------------------ | | 814| 12.2k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 12.2k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 12.2k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 12.2k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size; ------------------ | | 194| 12.2k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 4922| 12.2k| Fecode += 1 + 2*IMM2_SIZE; ------------------ | | 176| 12.2k|#define Fecode F->ecode ------------------ Fecode += 1 + 2*IMM2_SIZE; ------------------ | | 193| 12.2k|#define IMM2_SIZE 2 ------------------ 4923| | 4924| 24.4k| while (count-- > 0) ------------------ | Branch (4924:14): [True: 20.0k, False: 4.43k] ------------------ 4925| 20.0k| { 4926| 20.0k| Loffset = (GET2(slot, 0) << 1) - 2; ------------------ | | 4914| 20.0k|#define Loffset F->temp_size ------------------ Loffset = (GET2(slot, 0) << 1) - 2; ------------------ | | 194| 20.0k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 4927| 20.0k| if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) break; ------------------ | | 4914| 20.0k|#define Loffset F->temp_size ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) break; ------------------ | | 184| 40.0k|#define Foffset_top F->offset_top ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) break; ------------------ | | 187| 8.95k|#define Fovector F->ovector ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) break; ------------------ | | 4914| 8.95k|#define Loffset F->temp_size ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) break; ------------------ | | 480| 8.95k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (4927:13): [True: 8.95k, False: 11.0k] | Branch (4927:38): [True: 7.80k, False: 1.15k] ------------------ 4928| 12.2k| slot += mb->name_entry_size; 4929| 12.2k| } 4930| 12.2k| } 4931| 12.2k| goto REF_REPEAT; 4932| | 4933| 137k| case OP_REF: ------------------ | Branch (4933:5): [True: 137k, False: 2.33G] ------------------ 4934| 160k| case OP_REFI: ------------------ | Branch (4934:5): [True: 22.5k, False: 2.33G] ------------------ 4935| 160k| Lcaseless = (Fop == OP_REFI); ------------------ | | 4912| 160k|#define Lcaseless F->temp_32[2] ------------------ Lcaseless = (Fop == OP_REFI); ------------------ | | 186| 160k|#define Fop F->op ------------------ 4936| 160k| Loffset = (GET2(Fecode, 1) << 1) - 2; ------------------ | | 4914| 160k|#define Loffset F->temp_size ------------------ Loffset = (GET2(Fecode, 1) << 1) - 2; ------------------ | | 194| 160k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 4937| 160k| Fecode += 1 + IMM2_SIZE; ------------------ | | 176| 160k|#define Fecode F->ecode ------------------ Fecode += 1 + IMM2_SIZE; ------------------ | | 193| 160k|#define IMM2_SIZE 2 ------------------ 4938| | 4939| | /* Set up for repetition, or handle the non-repeated case. The maximum and 4940| | minimum must be in the heap frame, but as they are short-term values, we 4941| | use temporary fields. */ 4942| | 4943| 172k| REF_REPEAT: 4944| 172k| switch (*Fecode) ------------------ | | 176| 172k|#define Fecode F->ecode ------------------ 4945| 172k| { 4946| 10.8k| case OP_CRSTAR: ------------------ | Branch (4946:7): [True: 10.8k, False: 161k] ------------------ 4947| 14.5k| case OP_CRMINSTAR: ------------------ | Branch (4947:7): [True: 3.72k, False: 168k] ------------------ 4948| 44.2k| case OP_CRPLUS: ------------------ | Branch (4948:7): [True: 29.6k, False: 142k] ------------------ 4949| 45.3k| case OP_CRMINPLUS: ------------------ | Branch (4949:7): [True: 1.13k, False: 171k] ------------------ 4950| 70.3k| case OP_CRQUERY: ------------------ | Branch (4950:7): [True: 25.0k, False: 147k] ------------------ 4951| 72.0k| case OP_CRMINQUERY: ------------------ | Branch (4951:7): [True: 1.65k, False: 170k] ------------------ 4952| 72.0k| fc = *Fecode++ - OP_CRSTAR; ------------------ | | 176| 72.0k|#define Fecode F->ecode ------------------ 4953| 72.0k| Lmin = rep_min[fc]; ------------------ | | 4910| 72.0k|#define Lmin F->temp_32[0] ------------------ 4954| 72.0k| Lmax = rep_max[fc]; ------------------ | | 4911| 72.0k|#define Lmax F->temp_32[1] ------------------ 4955| 72.0k| reptype = rep_typ[fc]; 4956| 72.0k| break; 4957| | 4958| 5.61k| case OP_CRRANGE: ------------------ | Branch (4958:7): [True: 5.61k, False: 167k] ------------------ 4959| 6.14k| case OP_CRMINRANGE: ------------------ | Branch (4959:7): [True: 532, False: 172k] ------------------ 4960| 6.14k| Lmin = GET2(Fecode, 1); ------------------ | | 4910| 6.14k|#define Lmin F->temp_32[0] ------------------ Lmin = GET2(Fecode, 1); ------------------ | | 194| 6.14k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 4961| 6.14k| Lmax = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 4911| 6.14k|#define Lmax F->temp_32[1] ------------------ Lmax = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 194| 6.14k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 4962| 6.14k| reptype = rep_typ[*Fecode - OP_CRSTAR]; ------------------ | | 176| 6.14k|#define Fecode F->ecode ------------------ 4963| 6.14k| if (Lmax == 0) Lmax = UINT32_MAX; /* Max 0 => infinity */ ------------------ | | 4911| 6.14k|#define Lmax F->temp_32[1] ------------------ if (Lmax == 0) Lmax = UINT32_MAX; /* Max 0 => infinity */ ------------------ | | 4911| 233|#define Lmax F->temp_32[1] ------------------ | Branch (4963:11): [True: 233, False: 5.91k] ------------------ 4964| 6.14k| Fecode += 1 + 2 * IMM2_SIZE; ------------------ | | 176| 6.14k|#define Fecode F->ecode ------------------ Fecode += 1 + 2 * IMM2_SIZE; ------------------ | | 193| 6.14k|#define IMM2_SIZE 2 ------------------ 4965| 6.14k| break; 4966| | 4967| 94.4k| default: /* No repeat follows */ ------------------ | Branch (4967:7): [True: 94.4k, False: 78.1k] ------------------ 4968| 94.4k| { 4969| 94.4k| rrc = match_ref(Loffset, Lcaseless, F, mb, &length); ------------------ | | 4914| 94.4k|#define Loffset F->temp_size ------------------ rrc = match_ref(Loffset, Lcaseless, F, mb, &length); ------------------ | | 4912| 94.4k|#define Lcaseless F->temp_32[2] ------------------ 4970| 94.4k| if (rrc != 0) ------------------ | Branch (4970:13): [True: 79.5k, False: 14.9k] ------------------ 4971| 79.5k| { 4972| 79.5k| if (rrc > 0) Feptr = mb->end_subject; /* Partial match */ ------------------ | | 177| 12.0k|#define Feptr F->eptr ------------------ | Branch (4972:15): [True: 12.0k, False: 67.5k] ------------------ 4973| 79.5k| CHECK_PARTIAL(); ------------------ | | 527| 79.5k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 79.5k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 13.6k, False: 65.9k] | | ------------------ | | 528| 79.5k| { \ | | 529| 13.6k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 13.6k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 1.56k, False: 12.0k] | | | | ------------------ | | | | 534| 13.6k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 1.56k|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 1.06k, False: 497] | | | | | Branch (534:38): [True: 230, False: 267] | | | | ------------------ | | | | 535| 13.6k| { \ | | | | 536| 1.29k| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 1.29k|#define TRUE 1 | | | | ------------------ | | | | 537| 1.29k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 18|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 18, False: 1.27k] | | | | ------------------ | | | | 538| 1.29k| } | | ------------------ | | 530| 13.6k| } ------------------ 4974| 79.5k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 79.5k| {\ | | 555| 79.5k| rrc = ra;\ | | 556| 79.5k| goto RETURN_SWITCH;\ | | 557| 79.5k| } ------------------ 4975| 0| } 4976| 94.4k| } 4977| 14.9k| Feptr += length; ------------------ | | 177| 14.9k|#define Feptr F->eptr ------------------ 4978| 14.9k| continue; /* With the main loop */ 4979| 172k| } 4980| | 4981| | /* Handle repeated back references. If a set group has length zero, just 4982| | continue with the main loop, because it matches however many times. For an 4983| | unset reference, if the minimum is zero, we can also just continue. We can 4984| | also continue if PCRE2_MATCH_UNSET_BACKREF is set, because this makes unset 4985| | group behave as a zero-length group. For any other unset cases, carrying 4986| | on will result in NOMATCH. */ 4987| | 4988| 78.1k| if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) ------------------ | | 4914| 78.1k|#define Loffset F->temp_size ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) ------------------ | | 184| 156k|#define Foffset_top F->offset_top ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) ------------------ | | 187| 70.0k|#define Fovector F->ovector ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) ------------------ | | 4914| 70.0k|#define Loffset F->temp_size ------------------ if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) ------------------ | | 480| 70.0k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (4988:9): [True: 70.0k, False: 8.17k] | Branch (4988:34): [True: 31.7k, False: 38.2k] ------------------ 4989| 31.7k| { 4990| 31.7k| if (Fovector[Loffset] == Fovector[Loffset + 1]) continue; ------------------ | | 187| 31.7k|#define Fovector F->ovector ------------------ if (Fovector[Loffset] == Fovector[Loffset + 1]) continue; ------------------ | | 4914| 31.7k|#define Loffset F->temp_size ------------------ if (Fovector[Loffset] == Fovector[Loffset + 1]) continue; ------------------ | | 187| 31.7k|#define Fovector F->ovector ------------------ if (Fovector[Loffset] == Fovector[Loffset + 1]) continue; ------------------ | | 4914| 31.7k|#define Loffset F->temp_size ------------------ | Branch (4990:11): [True: 10.3k, False: 21.3k] ------------------ 4991| 31.7k| } 4992| 46.4k| else /* Group is not set */ 4993| 46.4k| { 4994| 46.4k| if (Lmin == 0 || (mb->poptions & PCRE2_MATCH_UNSET_BACKREF) != 0) ------------------ | | 4910| 46.4k|#define Lmin F->temp_32[0] ------------------ if (Lmin == 0 || (mb->poptions & PCRE2_MATCH_UNSET_BACKREF) != 0) ------------------ | | 128| 26.8k|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ ------------------ | Branch (4994:11): [True: 19.5k, False: 26.8k] | Branch (4994:24): [True: 661, False: 26.2k] ------------------ 4995| 20.2k| continue; 4996| 46.4k| } 4997| | 4998| | /* First, ensure the minimum number of matches are present. */ 4999| | 5000| 49.7k| for (i = 1; i <= Lmin; i++) ------------------ | | 4910| 49.7k|#define Lmin F->temp_32[0] ------------------ | Branch (5000:17): [True: 34.5k, False: 15.2k] ------------------ 5001| 34.5k| { 5002| 34.5k| PCRE2_SIZE slength; ------------------ | | 477| 34.5k|#define PCRE2_SIZE size_t ------------------ 5003| 34.5k| rrc = match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4914| 34.5k|#define Loffset F->temp_size ------------------ rrc = match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4912| 34.5k|#define Lcaseless F->temp_32[2] ------------------ 5004| 34.5k| if (rrc != 0) ------------------ | Branch (5004:11): [True: 32.4k, False: 2.16k] ------------------ 5005| 32.4k| { 5006| 32.4k| if (rrc > 0) Feptr = mb->end_subject; /* Partial match */ ------------------ | | 177| 2.28k|#define Feptr F->eptr ------------------ | Branch (5006:13): [True: 2.28k, False: 30.1k] ------------------ 5007| 32.4k| CHECK_PARTIAL(); ------------------ | | 527| 32.4k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 32.4k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 3.51k, False: 28.9k] | | ------------------ | | 528| 32.4k| { \ | | 529| 3.51k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 3.51k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 978, False: 2.53k] | | | | ------------------ | | | | 534| 3.51k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 978|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 486, False: 492] | | | | | Branch (534:38): [True: 238, False: 254] | | | | ------------------ | | | | 535| 3.51k| { \ | | | | 536| 724| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 724|#define TRUE 1 | | | | ------------------ | | | | 537| 724| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 8|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 8, False: 716] | | | | ------------------ | | | | 538| 724| } | | ------------------ | | 530| 3.50k| } ------------------ 5008| 32.4k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 32.4k| {\ | | 555| 32.4k| rrc = ra;\ | | 556| 32.4k| goto RETURN_SWITCH;\ | | 557| 32.4k| } ------------------ 5009| 0| } 5010| 2.16k| Feptr += slength; ------------------ | | 177| 2.16k|#define Feptr F->eptr ------------------ 5011| 2.16k| } 5012| | 5013| | /* If min = max, we are done. They are not both allowed to be zero. */ 5014| | 5015| 15.2k| if (Lmin == Lmax) continue; ------------------ | | 4910| 15.2k|#define Lmin F->temp_32[0] ------------------ if (Lmin == Lmax) continue; ------------------ | | 4911| 15.2k|#define Lmax F->temp_32[1] ------------------ | Branch (5015:9): [True: 289, False: 14.9k] ------------------ 5016| | 5017| | /* If minimizing, keep trying and advancing the pointer. */ 5018| | 5019| 14.9k| if (reptype == REPTYPE_MIN) ------------------ | Branch (5019:9): [True: 4.57k, False: 10.3k] ------------------ 5020| 4.57k| { 5021| 4.57k| for (;;) 5022| 4.98k| { 5023| 4.98k| PCRE2_SIZE slength; ------------------ | | 477| 4.98k|#define PCRE2_SIZE size_t ------------------ 5024| 4.98k| RMATCH(Fecode, RM20); ------------------ | | 546| 4.98k| {\ | | 547| 4.98k| start_ecode = ra;\ | | 548| 4.98k| Freturn_id = rb;\ | | ------------------ | | | | 188| 4.98k|#define Freturn_id F->return_id | | ------------------ | | 549| 4.98k| goto MATCH_RECURSE;\ | | 550| 4.98k| L_##rb:;\ | | 551| 4.93k| } ------------------ 5025| 4.93k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 4.93k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 262| {\ | | 555| 262| rrc = ra;\ | | 556| 262| goto RETURN_SWITCH;\ | | 557| 262| } ------------------ | Branch (5025:13): [True: 262, False: 4.67k] ------------------ 5026| 4.67k| if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 4910| 4.67k|#define Lmin F->temp_32[0] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 4911| 4.67k|#define Lmax F->temp_32[1] ------------------ if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 238| {\ | | 555| 238| rrc = ra;\ | | 556| 238| goto RETURN_SWITCH;\ | | 557| 238| } ------------------ | Branch (5026:13): [True: 238, False: 4.43k] ------------------ 5027| 4.43k| rrc = match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4914| 4.43k|#define Loffset F->temp_size ------------------ rrc = match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4912| 4.43k|#define Lcaseless F->temp_32[2] ------------------ 5028| 4.43k| if (rrc != 0) ------------------ | Branch (5028:13): [True: 4.02k, False: 412] ------------------ 5029| 4.02k| { 5030| 4.02k| if (rrc > 0) Feptr = mb->end_subject; /* Partial match */ ------------------ | | 177| 1.11k|#define Feptr F->eptr ------------------ | Branch (5030:15): [True: 1.11k, False: 2.91k] ------------------ 5031| 4.02k| CHECK_PARTIAL(); ------------------ | | 527| 4.02k| if (Feptr >= mb->end_subject) \ | | ------------------ | | | | 177| 4.02k|#define Feptr F->eptr | | ------------------ | | | Branch (527:7): [True: 1.11k, False: 2.91k] | | ------------------ | | 528| 4.02k| { \ | | 529| 1.11k| SCHECK_PARTIAL(); \ | | ------------------ | | | | 533| 1.11k| if (mb->partial != 0 && \ | | | | ------------------ | | | | | Branch (533:7): [True: 204, False: 911] | | | | ------------------ | | | | 534| 1.11k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | | | ------------------ | | | | | | 177| 204|#define Feptr F->eptr | | | | ------------------ | | | | | Branch (534:8): [True: 204, False: 0] | | | | | Branch (534:38): [True: 0, False: 0] | | | | ------------------ | | | | 535| 1.11k| { \ | | | | 536| 204| mb->hitend = TRUE; \ | | | | ------------------ | | | | | | 70| 204|#define TRUE 1 | | | | ------------------ | | | | 537| 204| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | | | ------------------ | | | | | | 327| 3|#define PCRE2_ERROR_PARTIAL (-2) | | | | ------------------ | | | | | Branch (537:9): [True: 3, False: 201] | | | | ------------------ | | | | 538| 204| } | | ------------------ | | 530| 1.11k| } ------------------ 5032| 4.02k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 4.02k| {\ | | 555| 4.02k| rrc = ra;\ | | 556| 4.02k| goto RETURN_SWITCH;\ | | 557| 4.02k| } ------------------ 5033| 0| } 5034| 412| Feptr += slength; ------------------ | | 177| 412|#define Feptr F->eptr ------------------ 5035| 412| } 5036| | /* Control never gets here */ 5037| 4.57k| } 5038| | 5039| | /* If maximizing, find the longest string and work backwards, as long as 5040| | the matched lengths for each iteration are the same. */ 5041| | 5042| 10.3k| else 5043| 10.3k| { 5044| 10.3k| BOOL samelengths = TRUE; ------------------ | | 70| 10.3k|#define TRUE 1 ------------------ 5045| 10.3k| Lstart = Feptr; /* Starting position */ ------------------ | | 4913| 10.3k|#define Lstart F->temp_sptr[0] ------------------ Lstart = Feptr; /* Starting position */ ------------------ | | 177| 10.3k|#define Feptr F->eptr ------------------ 5046| 10.3k| Flength = Fovector[Loffset+1] - Fovector[Loffset]; ------------------ | | 180| 10.3k|#define Flength F->length ------------------ Flength = Fovector[Loffset+1] - Fovector[Loffset]; ------------------ | | 187| 10.3k|#define Fovector F->ovector ------------------ Flength = Fovector[Loffset+1] - Fovector[Loffset]; ------------------ | | 4914| 10.3k|#define Loffset F->temp_size ------------------ Flength = Fovector[Loffset+1] - Fovector[Loffset]; ------------------ | | 187| 10.3k|#define Fovector F->ovector ------------------ Flength = Fovector[Loffset+1] - Fovector[Loffset]; ------------------ | | 4914| 10.3k|#define Loffset F->temp_size ------------------ 5047| | 5048| 16.8k| for (i = Lmin; i < Lmax; i++) ------------------ | | 4910| 10.3k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 4911| 16.8k|#define Lmax F->temp_32[1] ------------------ | Branch (5048:22): [True: 16.6k, False: 202] ------------------ 5049| 16.6k| { 5050| 16.6k| PCRE2_SIZE slength; ------------------ | | 477| 16.6k|#define PCRE2_SIZE size_t ------------------ 5051| 16.6k| rrc = match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4914| 16.6k|#define Loffset F->temp_size ------------------ rrc = match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4912| 16.6k|#define Lcaseless F->temp_32[2] ------------------ 5052| 16.6k| if (rrc != 0) ------------------ | Branch (5052:13): [True: 10.1k, False: 6.49k] ------------------ 5053| 10.1k| { 5054| | /* Can't use CHECK_PARTIAL because we don't want to update Feptr in 5055| | the soft partial matching case. */ 5056| | 5057| 10.1k| if (rrc > 0 && mb->partial != 0 && ------------------ | Branch (5057:15): [True: 6.08k, False: 4.05k] | Branch (5057:26): [True: 2.18k, False: 3.89k] ------------------ 5058| 10.1k| mb->end_subject > mb->start_used_ptr) ------------------ | Branch (5058:15): [True: 2.18k, False: 0] ------------------ 5059| 2.18k| { 5060| 2.18k| mb->hitend = TRUE; ------------------ | | 70| 2.18k|#define TRUE 1 ------------------ 5061| 2.18k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 4|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (5061:17): [True: 4, False: 2.18k] ------------------ 5062| 2.18k| } 5063| 10.1k| break; 5064| 10.1k| } 5065| | 5066| 6.49k| if (slength != Flength) samelengths = FALSE; ------------------ | | 180| 6.49k|#define Flength F->length ------------------ if (slength != Flength) samelengths = FALSE; ------------------ | | 69| 2.56k|#define FALSE 0 ------------------ | Branch (5066:13): [True: 2.56k, False: 3.93k] ------------------ 5067| 6.49k| Feptr += slength; ------------------ | | 177| 6.49k|#define Feptr F->eptr ------------------ 5068| 6.49k| } 5069| | 5070| | /* If the length matched for each repetition is the same as the length of 5071| | the captured group, we can easily work backwards. This is the normal 5072| | case. However, in caseless UTF-8 mode there are pairs of case-equivalent 5073| | characters whose lengths (in terms of code units) differ. However, this 5074| | is very rare, so we handle it by re-matching fewer and fewer times. */ 5075| | 5076| 10.3k| if (samelengths) ------------------ | Branch (5076:11): [True: 7.82k, False: 2.52k] ------------------ 5077| 7.82k| { 5078| 16.3k| while (Feptr >= Lstart) ------------------ | | 177| 16.3k|#define Feptr F->eptr ------------------ while (Feptr >= Lstart) ------------------ | | 4913| 16.3k|#define Lstart F->temp_sptr[0] ------------------ | Branch (5078:16): [True: 9.36k, False: 7.01k] ------------------ 5079| 9.36k| { 5080| 9.36k| RMATCH(Fecode, RM21); ------------------ | | 546| 9.36k| {\ | | 547| 9.36k| start_ecode = ra;\ | | 548| 9.36k| Freturn_id = rb;\ | | ------------------ | | | | 188| 9.36k|#define Freturn_id F->return_id | | ------------------ | | 549| 9.36k| goto MATCH_RECURSE;\ | | 550| 9.36k| L_##rb:;\ | | 551| 9.21k| } ------------------ 5081| 9.21k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 9.21k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 657| {\ | | 555| 657| rrc = ra;\ | | 556| 657| goto RETURN_SWITCH;\ | | 557| 657| } ------------------ | Branch (5081:15): [True: 657, False: 8.55k] ------------------ 5082| 8.55k| Feptr -= Flength; ------------------ | | 177| 8.55k|#define Feptr F->eptr ------------------ Feptr -= Flength; ------------------ | | 180| 8.55k|#define Flength F->length ------------------ 5083| 8.55k| } 5084| 7.82k| } 5085| | 5086| | /* The rare case of non-matching lengths. Re-scan the repetition for each 5087| | iteration. We know that match_ref() will succeed every time. */ 5088| | 5089| 2.52k| else 5090| 2.52k| { 5091| 2.52k| Lmax = i; ------------------ | | 4911| 2.52k|#define Lmax F->temp_32[1] ------------------ 5092| 2.52k| for (;;) 5093| 6.53k| { 5094| 6.53k| RMATCH(Fecode, RM22); ------------------ | | 546| 6.53k| {\ | | 547| 6.53k| start_ecode = ra;\ | | 548| 6.53k| Freturn_id = rb;\ | | ------------------ | | | | 188| 6.53k|#define Freturn_id F->return_id | | ------------------ | | 549| 6.53k| goto MATCH_RECURSE;\ | | 550| 6.53k| L_##rb:;\ | | 551| 6.53k| } ------------------ 5095| 6.53k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 6.53k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 748| {\ | | 555| 748| rrc = ra;\ | | 556| 748| goto RETURN_SWITCH;\ | | 557| 748| } ------------------ | Branch (5095:15): [True: 748, False: 5.78k] ------------------ 5096| 5.78k| if (Feptr == Lstart) break; /* Failed after minimal repetition */ ------------------ | | 177| 5.78k|#define Feptr F->eptr ------------------ if (Feptr == Lstart) break; /* Failed after minimal repetition */ ------------------ | | 4913| 5.78k|#define Lstart F->temp_sptr[0] ------------------ | Branch (5096:15): [True: 1.77k, False: 4.01k] ------------------ 5097| 4.01k| Feptr = Lstart; ------------------ | | 177| 4.01k|#define Feptr F->eptr ------------------ Feptr = Lstart; ------------------ | | 4913| 4.01k|#define Lstart F->temp_sptr[0] ------------------ 5098| 4.01k| Lmax--; ------------------ | | 4911| 4.01k|#define Lmax F->temp_32[1] ------------------ 5099| 6.93k| for (i = Lmin; i < Lmax; i++) ------------------ | | 4910| 4.01k|#define Lmin F->temp_32[0] ------------------ for (i = Lmin; i < Lmax; i++) ------------------ | | 4911| 6.93k|#define Lmax F->temp_32[1] ------------------ | Branch (5099:26): [True: 2.92k, False: 4.01k] ------------------ 5100| 2.92k| { 5101| 2.92k| PCRE2_SIZE slength; ------------------ | | 477| 2.92k|#define PCRE2_SIZE size_t ------------------ 5102| 2.92k| (void)match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4914| 2.92k|#define Loffset F->temp_size ------------------ (void)match_ref(Loffset, Lcaseless, F, mb, &slength); ------------------ | | 4912| 2.92k|#define Lcaseless F->temp_32[2] ------------------ 5103| 2.92k| Feptr += slength; ------------------ | | 177| 2.92k|#define Feptr F->eptr ------------------ 5104| 2.92k| } 5105| 4.01k| } 5106| 2.52k| } 5107| | 5108| 10.3k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 8.78k| {\ | | 555| 8.78k| rrc = ra;\ | | 556| 8.78k| goto RETURN_SWITCH;\ | | 557| 8.78k| } ------------------ 5109| 0| } 5110| | /* Control never gets here */ 5111| | 5112| 0|#undef Lcaseless 5113| 0|#undef Lmin 5114| 0|#undef Lmax 5115| 0|#undef Lstart 5116| 0|#undef Loffset 5117| | 5118| | 5119| | 5120| |/* ========================================================================= */ 5121| |/* Opcodes for the start of various parenthesized items */ 5122| |/* ========================================================================= */ 5123| | 5124| | /* In all cases, if the result of RMATCH() is MATCH_THEN, check whether the 5125| | (*THEN) is within the current branch by comparing the address of OP_THEN 5126| | that is passed back with the end of the branch. If (*THEN) is within the 5127| | current branch, and the branch is one of two or more alternatives (it 5128| | either starts or ends with OP_ALT), we have reached the limit of THEN's 5129| | action, so convert the return code to NOMATCH, which will cause normal 5130| | backtracking to happen from now on. Otherwise, THEN is passed back to an 5131| | outer alternative. This implements Perl's treatment of parenthesized 5132| | groups, where a group not containing | does not affect the current 5133| | alternative, that is, (X) is NOT the same as (X|(*F)). */ 5134| | 5135| | 5136| | /* ===================================================================== */ 5137| | /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a non-possessive 5138| | bracket group, indicating that it may occur zero times. It may repeat 5139| | infinitely, or not at all - i.e. it could be ()* or ()? or even (){0} in 5140| | the pattern. Brackets with fixed upper repeat limits are compiled as a 5141| | number of copies, with the optional ones preceded by BRAZERO or BRAMINZERO. 5142| | Possessive groups with possible zero repeats are preceded by BRAPOSZERO. */ 5143| | 5144| 0|#define Lnext_ecode F->temp_sptr[0] 5145| | 5146| 55.8k| case OP_BRAZERO: ------------------ | Branch (5146:5): [True: 55.8k, False: 2.33G] ------------------ 5147| 55.8k| Lnext_ecode = Fecode + 1; ------------------ | | 5144| 55.8k|#define Lnext_ecode F->temp_sptr[0] ------------------ Lnext_ecode = Fecode + 1; ------------------ | | 176| 55.8k|#define Fecode F->ecode ------------------ 5148| 55.8k| RMATCH(Lnext_ecode, RM9); ------------------ | | 546| 55.8k| {\ | | 547| 55.8k| start_ecode = ra;\ | | 548| 55.8k| Freturn_id = rb;\ | | ------------------ | | | | 188| 55.8k|#define Freturn_id F->return_id | | ------------------ | | 549| 55.8k| goto MATCH_RECURSE;\ | | 550| 55.8k| L_##rb:;\ | | 551| 34.6k| } ------------------ 5149| 34.6k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 34.6k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 11.2k| {\ | | 555| 11.2k| rrc = ra;\ | | 556| 11.2k| goto RETURN_SWITCH;\ | | 557| 11.2k| } ------------------ | Branch (5149:9): [True: 11.2k, False: 23.3k] ------------------ 5150| 25.4k| do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT); ------------------ | | 5144| 25.4k|#define Lnext_ecode F->temp_sptr[0] ------------------ do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT); ------------------ | | 109| 25.4k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT); ------------------ | | 5144| 25.4k|#define Lnext_ecode F->temp_sptr[0] ------------------ | Branch (5150:51): [True: 2.04k, False: 23.3k] ------------------ 5151| 23.3k| Fecode = Lnext_ecode + 1 + LINK_SIZE; ------------------ | | 176| 23.3k|#define Fecode F->ecode ------------------ Fecode = Lnext_ecode + 1 + LINK_SIZE; ------------------ | | 5144| 23.3k|#define Lnext_ecode F->temp_sptr[0] ------------------ Fecode = Lnext_ecode + 1 + LINK_SIZE; ------------------ | | 165| 23.3k|#define LINK_SIZE 2 ------------------ 5152| 23.3k| break; 5153| | 5154| 10.6k| case OP_BRAMINZERO: ------------------ | Branch (5154:5): [True: 10.6k, False: 2.33G] ------------------ 5155| 10.6k| Lnext_ecode = Fecode + 1; ------------------ | | 5144| 10.6k|#define Lnext_ecode F->temp_sptr[0] ------------------ Lnext_ecode = Fecode + 1; ------------------ | | 176| 10.6k|#define Fecode F->ecode ------------------ 5156| 11.8k| do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT); ------------------ | | 5144| 11.8k|#define Lnext_ecode F->temp_sptr[0] ------------------ do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT); ------------------ | | 109| 11.8k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT); ------------------ | | 5144| 11.8k|#define Lnext_ecode F->temp_sptr[0] ------------------ | Branch (5156:51): [True: 1.21k, False: 10.6k] ------------------ 5157| 10.6k| RMATCH(Lnext_ecode + 1 + LINK_SIZE, RM10); ------------------ | | 546| 10.6k| {\ | | 547| 10.6k| start_ecode = ra;\ | | 548| 10.6k| Freturn_id = rb;\ | | ------------------ | | | | 188| 10.6k|#define Freturn_id F->return_id | | ------------------ | | 549| 10.6k| goto MATCH_RECURSE;\ | | 550| 10.6k| L_##rb:;\ | | 551| 9.35k| } ------------------ 5158| 9.35k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 9.35k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 3.30k| {\ | | 555| 3.30k| rrc = ra;\ | | 556| 3.30k| goto RETURN_SWITCH;\ | | 557| 3.30k| } ------------------ | Branch (5158:9): [True: 3.30k, False: 6.05k] ------------------ 5159| 6.05k| Fecode++; ------------------ | | 176| 6.05k|#define Fecode F->ecode ------------------ 5160| 6.05k| break; 5161| | 5162| 0|#undef Lnext_ecode 5163| | 5164| 8.32k| case OP_SKIPZERO: ------------------ | Branch (5164:5): [True: 8.32k, False: 2.33G] ------------------ 5165| 8.32k| Fecode++; ------------------ | | 176| 8.32k|#define Fecode F->ecode ------------------ 5166| 15.9k| do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT); ------------------ | | 176| 15.9k|#define Fecode F->ecode ------------------ do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT); ------------------ | | 109| 15.9k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT); ------------------ | | 176| 15.9k|#define Fecode F->ecode ------------------ | Branch (5166:40): [True: 7.59k, False: 8.32k] ------------------ 5167| 8.32k| Fecode += 1 + LINK_SIZE; ------------------ | | 176| 8.32k|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; ------------------ | | 165| 8.32k|#define LINK_SIZE 2 ------------------ 5168| 8.32k| break; 5169| | 5170| | 5171| | /* ===================================================================== */ 5172| | /* Handle possessive brackets with an unlimited repeat. The end of these 5173| | brackets will always be OP_KETRPOS, which returns MATCH_KETRPOS without 5174| | going further in the pattern. */ 5175| | 5176| 0|#define Lframe_type F->temp_32[0] 5177| 0|#define Lmatched_once F->temp_32[1] 5178| 0|#define Lzero_allowed F->temp_32[2] 5179| 0|#define Lstart_eptr F->temp_sptr[0] 5180| 0|#define Lstart_group F->temp_sptr[1] 5181| | 5182| 9.36k| case OP_BRAPOSZERO: ------------------ | Branch (5182:5): [True: 9.36k, False: 2.33G] ------------------ 5183| 9.36k| Lzero_allowed = TRUE; /* Zero repeat is allowed */ ------------------ | | 5178| 9.36k|#define Lzero_allowed F->temp_32[2] ------------------ Lzero_allowed = TRUE; /* Zero repeat is allowed */ ------------------ | | 70| 9.36k|#define TRUE 1 ------------------ 5184| 9.36k| Fecode += 1; ------------------ | | 176| 9.36k|#define Fecode F->ecode ------------------ 5185| 9.36k| if (*Fecode == OP_CBRAPOS || *Fecode == OP_SCBRAPOS) ------------------ | | 176| 9.36k|#define Fecode F->ecode ------------------ if (*Fecode == OP_CBRAPOS || *Fecode == OP_SCBRAPOS) ------------------ | | 176| 5.25k|#define Fecode F->ecode ------------------ | Branch (5185:9): [True: 4.11k, False: 5.25k] | Branch (5185:34): [True: 2.04k, False: 3.20k] ------------------ 5186| 6.15k| goto POSSESSIVE_CAPTURE; 5187| 3.20k| goto POSSESSIVE_NON_CAPTURE; 5188| | 5189| 5.09k| case OP_BRAPOS: ------------------ | Branch (5189:5): [True: 5.09k, False: 2.33G] ------------------ 5190| 25.8k| case OP_SBRAPOS: ------------------ | Branch (5190:5): [True: 20.7k, False: 2.33G] ------------------ 5191| 25.8k| Lzero_allowed = FALSE; /* Zero repeat not allowed */ ------------------ | | 5178| 25.8k|#define Lzero_allowed F->temp_32[2] ------------------ Lzero_allowed = FALSE; /* Zero repeat not allowed */ ------------------ | | 69| 25.8k|#define FALSE 0 ------------------ 5192| | 5193| 29.0k| POSSESSIVE_NON_CAPTURE: 5194| 29.0k| Lframe_type = GF_NOCAPTURE; /* Remembered frame type */ ------------------ | | 5176| 29.0k|#define Lframe_type F->temp_32[0] ------------------ Lframe_type = GF_NOCAPTURE; /* Remembered frame type */ ------------------ | | 107| 29.0k|#define GF_NOCAPTURE 0x00020000u ------------------ 5195| 29.0k| goto POSSESSIVE_GROUP; 5196| | 5197| 16.6k| case OP_CBRAPOS: ------------------ | Branch (5197:5): [True: 16.6k, False: 2.33G] ------------------ 5198| 45.0k| case OP_SCBRAPOS: ------------------ | Branch (5198:5): [True: 28.4k, False: 2.33G] ------------------ 5199| 45.0k| Lzero_allowed = FALSE; /* Zero repeat not allowed */ ------------------ | | 5178| 45.0k|#define Lzero_allowed F->temp_32[2] ------------------ Lzero_allowed = FALSE; /* Zero repeat not allowed */ ------------------ | | 69| 45.0k|#define FALSE 0 ------------------ 5200| | 5201| 51.2k| POSSESSIVE_CAPTURE: 5202| 51.2k| number = GET2(Fecode, 1+LINK_SIZE); ------------------ | | 194| 51.2k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5203| 51.2k| Lframe_type = GF_CAPTURE | number; /* Remembered frame type */ ------------------ | | 5176| 51.2k|#define Lframe_type F->temp_32[0] ------------------ Lframe_type = GF_CAPTURE | number; /* Remembered frame type */ ------------------ | | 106| 51.2k|#define GF_CAPTURE 0x00010000u ------------------ 5204| | 5205| 80.2k| POSSESSIVE_GROUP: 5206| 80.2k| Lmatched_once = FALSE; /* Never matched */ ------------------ | | 5177| 80.2k|#define Lmatched_once F->temp_32[1] ------------------ Lmatched_once = FALSE; /* Never matched */ ------------------ | | 69| 80.2k|#define FALSE 0 ------------------ 5207| 80.2k| Lstart_group = Fecode; /* Start of this group */ ------------------ | | 5180| 80.2k|#define Lstart_group F->temp_sptr[1] ------------------ Lstart_group = Fecode; /* Start of this group */ ------------------ | | 176| 80.2k|#define Fecode F->ecode ------------------ 5208| | 5209| 80.2k| for (;;) 5210| 100k| { 5211| 100k| Lstart_eptr = Feptr; /* Position at group start */ ------------------ | | 5179| 100k|#define Lstart_eptr F->temp_sptr[0] ------------------ Lstart_eptr = Feptr; /* Position at group start */ ------------------ | | 177| 100k|#define Feptr F->eptr ------------------ 5212| 100k| group_frame_type = Lframe_type; ------------------ | | 5176| 100k|#define Lframe_type F->temp_32[0] ------------------ 5213| 100k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM8); ------------------ | | 546| 100k| {\ | | 547| 100k| start_ecode = ra;\ | | 548| 100k| Freturn_id = rb;\ | | ------------------ | | | | 188| 100k|#define Freturn_id F->return_id | | ------------------ | | 549| 100k| goto MATCH_RECURSE;\ | | 550| 100k| L_##rb:;\ | | 551| 98.9k| } ------------------ 5214| 98.9k| if (rrc == MATCH_KETRPOS) ------------------ | | 89| 98.9k|#define MATCH_KETRPOS (-998) ------------------ | Branch (5214:11): [True: 45.9k, False: 53.0k] ------------------ 5215| 45.9k| { 5216| 45.9k| Lmatched_once = TRUE; /* Matched at least once */ ------------------ | | 5177| 45.9k|#define Lmatched_once F->temp_32[1] ------------------ Lmatched_once = TRUE; /* Matched at least once */ ------------------ | | 70| 45.9k|#define TRUE 1 ------------------ 5217| 45.9k| if (Feptr == Lstart_eptr) /* Empty match; skip to end */ ------------------ | | 177| 45.9k|#define Feptr F->eptr ------------------ if (Feptr == Lstart_eptr) /* Empty match; skip to end */ ------------------ | | 5179| 45.9k|#define Lstart_eptr F->temp_sptr[0] ------------------ | Branch (5217:13): [True: 27.2k, False: 18.6k] ------------------ 5218| 27.2k| { 5219| 28.0k| do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 28.0k|#define Fecode F->ecode ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 109| 28.0k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 28.0k|#define Fecode F->ecode ------------------ | Branch (5219:47): [True: 820, False: 27.2k] ------------------ 5220| 27.2k| break; 5221| 27.2k| } 5222| | 5223| 18.6k| Fecode = Lstart_group; ------------------ | | 176| 18.6k|#define Fecode F->ecode ------------------ Fecode = Lstart_group; ------------------ | | 5180| 18.6k|#define Lstart_group F->temp_sptr[1] ------------------ 5224| 18.6k| continue; 5225| 45.9k| } 5226| | 5227| | /* See comment above about handling THEN. */ 5228| | 5229| 53.0k| if (rrc == MATCH_THEN) ------------------ | | 96| 53.0k|#define MATCH_THEN (-993) ------------------ | Branch (5229:11): [True: 834, False: 52.1k] ------------------ 5230| 834| { 5231| 834| PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1); ------------------ | | 814| 834|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 834|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 834|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 834|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1); ------------------ | | 176| 834|#define Fecode F->ecode ------------------ PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1); ------------------ | | 109| 834| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5232| 834| if (mb->verb_ecode_ptr < next_ecode && ------------------ | Branch (5232:13): [True: 834, False: 0] ------------------ 5233| 834| (*Fecode == OP_ALT || *next_ecode == OP_ALT)) ------------------ | | 176| 834|#define Fecode F->ecode ------------------ | Branch (5233:14): [True: 308, False: 526] | Branch (5233:35): [True: 274, False: 252] ------------------ 5234| 582| rrc = MATCH_NOMATCH; ------------------ | | 83| 582|#define MATCH_NOMATCH 0 ------------------ 5235| 834| } 5236| | 5237| 53.0k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 53.0k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 758| {\ | | 555| 758| rrc = ra;\ | | 556| 758| goto RETURN_SWITCH;\ | | 557| 758| } ------------------ | Branch (5237:11): [True: 758, False: 52.2k] ------------------ 5238| 52.2k| Fecode += GET(Fecode, 1); ------------------ | | 176| 52.2k|#define Fecode F->ecode ------------------ Fecode += GET(Fecode, 1); ------------------ | | 109| 52.2k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5239| 52.2k| if (*Fecode != OP_ALT) break; ------------------ | | 176| 52.2k|#define Fecode F->ecode ------------------ | Branch (5239:11): [True: 50.7k, False: 1.48k] ------------------ 5240| 52.2k| } 5241| | 5242| | /* Success if matched something or zero repeat allowed */ 5243| | 5244| 78.0k| if (Lmatched_once || Lzero_allowed) ------------------ | | 5177| 156k|#define Lmatched_once F->temp_32[1] | | ------------------ | | | Branch (5177:24): [True: 31.9k, False: 46.1k] | | ------------------ ------------------ if (Lmatched_once || Lzero_allowed) ------------------ | | 5178| 46.1k|#define Lzero_allowed F->temp_32[2] | | ------------------ | | | Branch (5178:24): [True: 2.88k, False: 43.2k] | | ------------------ ------------------ 5245| 34.7k| { 5246| 34.7k| Fecode += 1 + LINK_SIZE; ------------------ | | 176| 34.7k|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; ------------------ | | 165| 34.7k|#define LINK_SIZE 2 ------------------ 5247| 34.7k| break; 5248| 34.7k| } 5249| | 5250| 78.0k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 43.2k| {\ | | 555| 43.2k| rrc = ra;\ | | 556| 43.2k| goto RETURN_SWITCH;\ | | 557| 43.2k| } ------------------ 5251| | 5252| 0|#undef Lmatched_once 5253| 0|#undef Lzero_allowed 5254| 0|#undef Lframe_type 5255| 0|#undef Lstart_eptr 5256| 0|#undef Lstart_group 5257| | 5258| | 5259| | /* ===================================================================== */ 5260| | /* Handle non-capturing brackets that cannot match an empty string. When we 5261| | get to the final alternative within the brackets, as long as there are no 5262| | THEN's in the pattern, we can optimize by not recording a new backtracking 5263| | point. (Ideally we should test for a THEN within this group, but we don't 5264| | have that information.) Don't do this if we are at the very top level, 5265| | however, because that would make handling assertions and once-only brackets 5266| | messier when there is nothing to go back to. */ 5267| | 5268| 0|#define Lframe_type F->temp_32[0] /* Set for all that use GROUPLOOP */ 5269| 0|#define Lnext_branch F->temp_sptr[0] /* Used only in OP_BRA handling */ 5270| | 5271| 1.15G| case OP_BRA: ------------------ | Branch (5271:5): [True: 1.15G, False: 1.18G] ------------------ 5272| 1.15G| if (mb->hasthen || Frdepth == 0) ------------------ | | 182| 1.15G|#define Frdepth F->rdepth ------------------ | Branch (5272:9): [True: 12.0k, False: 1.15G] | Branch (5272:24): [True: 1.02M, False: 1.14G] ------------------ 5273| 1.03M| { 5274| 1.03M| Lframe_type = 0; ------------------ | | 5268| 1.03M|#define Lframe_type F->temp_32[0] /* Set for all that use GROUPLOOP */ ------------------ 5275| 1.03M| goto GROUPLOOP; 5276| 1.03M| } 5277| | 5278| 1.14G| for (;;) 5279| 1.15G| { 5280| 1.15G| Lnext_branch = Fecode + GET(Fecode, 1); ------------------ | | 5269| 1.15G|#define Lnext_branch F->temp_sptr[0] /* Used only in OP_BRA handling */ ------------------ Lnext_branch = Fecode + GET(Fecode, 1); ------------------ | | 176| 1.15G|#define Fecode F->ecode ------------------ Lnext_branch = Fecode + GET(Fecode, 1); ------------------ | | 109| 1.15G| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5281| 1.15G| if (*Lnext_branch != OP_ALT) break; ------------------ | | 5269| 1.15G|#define Lnext_branch F->temp_sptr[0] /* Used only in OP_BRA handling */ ------------------ | Branch (5281:11): [True: 1.14G, False: 1.27M] ------------------ 5282| | 5283| | /* This is never the final branch. We do not need to test for MATCH_THEN 5284| | here because this code is not used when there is a THEN in the pattern. */ 5285| | 5286| 1.27M| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM1); ------------------ | | 546| 1.27M| {\ | | 547| 1.27M| start_ecode = ra;\ | | 548| 1.27M| Freturn_id = rb;\ | | ------------------ | | | | 188| 1.27M|#define Freturn_id F->return_id | | ------------------ | | 549| 1.27M| goto MATCH_RECURSE;\ | | 550| 1.27M| L_##rb:;\ | | 551| 1.26M| } ------------------ 5287| 1.26M| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 1.26M|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 136k| {\ | | 555| 136k| rrc = ra;\ | | 556| 136k| goto RETURN_SWITCH;\ | | 557| 136k| } ------------------ | Branch (5287:11): [True: 136k, False: 1.13M] ------------------ 5288| 1.13M| Fecode = Lnext_branch; ------------------ | | 176| 1.13M|#define Fecode F->ecode ------------------ Fecode = Lnext_branch; ------------------ | | 5269| 1.13M|#define Lnext_branch F->temp_sptr[0] /* Used only in OP_BRA handling */ ------------------ 5289| 1.13M| } 5290| | 5291| | /* Hit the start of the final branch. Continue at this level. */ 5292| | 5293| 1.14G| Fecode += PRIV(OP_lengths)[*Fecode]; ------------------ | | 176| 1.14G|#define Fecode F->ecode ------------------ Fecode += PRIV(OP_lengths)[*Fecode]; ------------------ | | 177| 1.14G|#define PRIV(name) _pcre2_##name ------------------ Fecode += PRIV(OP_lengths)[*Fecode]; ------------------ | | 176| 1.14G|#define Fecode F->ecode ------------------ 5294| 1.14G| break; 5295| | 5296| 0|#undef Lnext_branch 5297| | 5298| | 5299| | /* ===================================================================== */ 5300| | /* Handle a capturing bracket, other than those that are possessive with an 5301| | unlimited repeat. */ 5302| | 5303| 3.59M| case OP_CBRA: ------------------ | Branch (5303:5): [True: 3.59M, False: 2.33G] ------------------ 5304| 3.60M| case OP_SCBRA: ------------------ | Branch (5304:5): [True: 16.4k, False: 2.33G] ------------------ 5305| 3.60M| Lframe_type = GF_CAPTURE | GET2(Fecode, 1+LINK_SIZE); ------------------ | | 5268| 3.60M|#define Lframe_type F->temp_32[0] /* Set for all that use GROUPLOOP */ ------------------ Lframe_type = GF_CAPTURE | GET2(Fecode, 1+LINK_SIZE); ------------------ | | 106| 3.60M|#define GF_CAPTURE 0x00010000u ------------------ Lframe_type = GF_CAPTURE | GET2(Fecode, 1+LINK_SIZE); ------------------ | | 194| 3.60M|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5306| 3.60M| goto GROUPLOOP; 5307| | 5308| | 5309| | /* ===================================================================== */ 5310| | /* Atomic groups and non-capturing brackets that can match an empty string 5311| | must record a backtracking point and also set up a chained frame. */ 5312| | 5313| 57.3k| case OP_ONCE: ------------------ | Branch (5313:5): [True: 57.3k, False: 2.33G] ------------------ 5314| 68.5k| case OP_SCRIPT_RUN: ------------------ | Branch (5314:5): [True: 11.1k, False: 2.33G] ------------------ 5315| 133k| case OP_SBRA: ------------------ | Branch (5315:5): [True: 64.9k, False: 2.33G] ------------------ 5316| 133k| Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 5268| 133k|#define Lframe_type F->temp_32[0] /* Set for all that use GROUPLOOP */ ------------------ Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 107| 133k|#define GF_NOCAPTURE 0x00020000u ------------------ Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 186| 133k|#define Fop F->op ------------------ 5317| | 5318| 4.77M| GROUPLOOP: 5319| 4.77M| for (;;) 5320| 7.25M| { 5321| 7.25M| group_frame_type = Lframe_type; ------------------ | | 5268| 7.25M|#define Lframe_type F->temp_32[0] /* Set for all that use GROUPLOOP */ ------------------ 5322| 7.25M| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM2); ------------------ | | 546| 7.25M| {\ | | 547| 7.25M| start_ecode = ra;\ | | 548| 7.25M| Freturn_id = rb;\ | | ------------------ | | | | 188| 7.25M|#define Freturn_id F->return_id | | ------------------ | | 549| 7.25M| goto MATCH_RECURSE;\ | | 550| 7.25M| L_##rb:;\ | | 551| 6.98M| } ------------------ 5323| 6.98M| if (rrc == MATCH_THEN) ------------------ | | 96| 6.98M|#define MATCH_THEN (-993) ------------------ | Branch (5323:11): [True: 6.79k, False: 6.97M] ------------------ 5324| 6.79k| { 5325| 6.79k| PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1); ------------------ | | 814| 6.79k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 6.79k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 6.79k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 6.79k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1); ------------------ | | 176| 6.79k|#define Fecode F->ecode ------------------ PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1); ------------------ | | 109| 6.79k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5326| 6.79k| if (mb->verb_ecode_ptr < next_ecode && ------------------ | Branch (5326:13): [True: 6.19k, False: 596] ------------------ 5327| 6.79k| (*Fecode == OP_ALT || *next_ecode == OP_ALT)) ------------------ | | 176| 6.19k|#define Fecode F->ecode ------------------ | Branch (5327:14): [True: 376, False: 5.82k] | Branch (5327:35): [True: 342, False: 5.48k] ------------------ 5328| 718| rrc = MATCH_NOMATCH; ------------------ | | 83| 718|#define MATCH_NOMATCH 0 ------------------ 5329| 6.79k| } 5330| 6.98M| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 6.98M|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.24M| {\ | | 555| 1.24M| rrc = ra;\ | | 556| 1.24M| goto RETURN_SWITCH;\ | | 557| 1.24M| } ------------------ | Branch (5330:11): [True: 1.24M, False: 5.73M] ------------------ 5331| 5.73M| Fecode += GET(Fecode, 1); ------------------ | | 176| 5.73M|#define Fecode F->ecode ------------------ Fecode += GET(Fecode, 1); ------------------ | | 109| 5.73M| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5332| 5.73M| if (*Fecode != OP_ALT) RRETURN(MATCH_NOMATCH); ------------------ | | 176| 5.73M|#define Fecode F->ecode ------------------ if (*Fecode != OP_ALT) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.25M| {\ | | 555| 3.25M| rrc = ra;\ | | 556| 3.25M| goto RETURN_SWITCH;\ | | 557| 3.25M| } ------------------ | Branch (5332:11): [True: 3.25M, False: 2.47M] ------------------ 5333| 2.47M| } 5334| | /* Control never reaches here. */ 5335| | 5336| 0|#undef Lframe_type 5337| | 5338| | 5339| | /* ===================================================================== */ 5340| | /* Recursion either matches the current regex, or some subexpression. The 5341| | offset data is the offset to the starting bracket from the start of the 5342| | whole pattern. (This is so that it works from duplicated subpatterns.) */ 5343| | 5344| 0|#define Lframe_type F->temp_32[0] 5345| 0|#define Lstart_branch F->temp_sptr[0] 5346| | 5347| 197k| case OP_RECURSE: ------------------ | Branch (5347:5): [True: 197k, False: 2.33G] ------------------ 5348| 197k| bracode = mb->start_code + GET(Fecode, 1); ------------------ | | 109| 197k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5349| 197k| number = (bracode == mb->start_code)? 0 : GET2(bracode, 1 + LINK_SIZE); ------------------ | | 194| 322k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (5349:14): [True: 72.6k, False: 124k] ------------------ 5350| | 5351| | /* If we are already in a recursion, check for repeating the same one 5352| | without advancing the subject pointer. This should catch convoluted mutual 5353| | recursions. (Some simple cases are caught at compile time.) */ 5354| | 5355| 197k| if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 175| 197k|#define Fcurrent_recurse F->current_recurse ------------------ if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 65| 197k|#define RECURSE_UNSET 0xffffffffu /* Bigger than max group number */ ------------------ | Branch (5355:9): [True: 142k, False: 55.4k] ------------------ 5356| 142k| { 5357| 142k| offset = Flast_group_offset; ------------------ | | 179| 142k|#define Flast_group_offset F->last_group_offset ------------------ 5358| 450k| while (offset != PCRE2_UNSET) ------------------ | | 480| 450k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (5358:14): [True: 376k, False: 74.0k] ------------------ 5359| 376k| { 5360| 376k| N = (heapframe *)((char *)match_data->heapframes + offset); 5361| 376k| P = (heapframe *)((char *)N - frame_size); 5362| 376k| if (N->group_frame_type == (GF_RECURSE | number)) ------------------ | | 109| 376k|#define GF_RECURSE 0x00040000u ------------------ | Branch (5362:13): [True: 67.9k, False: 308k] ------------------ 5363| 67.9k| { 5364| 67.9k| if (Feptr == P->eptr) return PCRE2_ERROR_RECURSELOOP; ------------------ | | 177| 67.9k|#define Feptr F->eptr ------------------ if (Feptr == P->eptr) return PCRE2_ERROR_RECURSELOOP; ------------------ | | 392| 1.00k|#define PCRE2_ERROR_RECURSELOOP (-52) ------------------ | Branch (5364:15): [True: 1.00k, False: 66.9k] ------------------ 5365| 66.9k| break; 5366| 67.9k| } 5367| 308k| offset = P->last_group_offset; 5368| 308k| } 5369| 142k| } 5370| | 5371| | /* Now run the recursion, branch by branch. */ 5372| | 5373| 196k| Lstart_branch = bracode; ------------------ | | 5345| 196k|#define Lstart_branch F->temp_sptr[0] ------------------ 5374| 196k| Lframe_type = GF_RECURSE | number; ------------------ | | 5344| 196k|#define Lframe_type F->temp_32[0] ------------------ Lframe_type = GF_RECURSE | number; ------------------ | | 109| 196k|#define GF_RECURSE 0x00040000u ------------------ 5375| | 5376| 196k| for (;;) 5377| 210k| { 5378| 210k| PCRE2_SPTR next_ecode; ------------------ | | 814| 210k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 210k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 210k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 210k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5379| | 5380| 210k| group_frame_type = Lframe_type; ------------------ | | 5344| 210k|#define Lframe_type F->temp_32[0] ------------------ 5381| 210k| RMATCH(Lstart_branch + PRIV(OP_lengths)[*Lstart_branch], RM11); ------------------ | | 546| 210k| {\ | | 547| 210k| start_ecode = ra;\ | | 548| 210k| Freturn_id = rb;\ | | ------------------ | | | | 188| 210k|#define Freturn_id F->return_id | | ------------------ | | 549| 210k| goto MATCH_RECURSE;\ | | 550| 210k| L_##rb:;\ | | 551| 182k| } ------------------ 5382| 182k| next_ecode = Lstart_branch + GET(Lstart_branch,1); ------------------ | | 5345| 182k|#define Lstart_branch F->temp_sptr[0] ------------------ next_ecode = Lstart_branch + GET(Lstart_branch,1); ------------------ | | 109| 182k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5383| | 5384| | /* Handle backtracking verbs, which are defined in a range that can 5385| | easily be tested for. PCRE does not allow THEN, SKIP, PRUNE or COMMIT to 5386| | escape beyond a recursion; they cause a NOMATCH for the entire recursion. 5387| | 5388| | When one of these verbs triggers, the current recursion group number is 5389| | recorded. If it matches the recursion we are processing, the verb 5390| | happened within the recursion and we must deal with it. Otherwise it must 5391| | have happened after the recursion completed, and so has to be passed 5392| | back. See comment above about handling THEN. */ 5393| | 5394| 182k| if (rrc >= MATCH_BACKTRACK_MIN && rrc <= MATCH_BACKTRACK_MAX && ------------------ | | 98| 182k|#define MATCH_BACKTRACK_MIN MATCH_COMMIT | | ------------------ | | | | 92| 364k|#define MATCH_COMMIT (-997) | | ------------------ ------------------ if (rrc >= MATCH_BACKTRACK_MIN && rrc <= MATCH_BACKTRACK_MAX && ------------------ | | 97| 181k|#define MATCH_BACKTRACK_MAX MATCH_THEN | | ------------------ | | | | 96| 363k|#define MATCH_THEN (-993) | | ------------------ ------------------ | Branch (5394:11): [True: 181k, False: 510] | Branch (5394:41): [True: 4.63k, False: 176k] ------------------ 5395| 182k| mb->verb_current_recurse == (Lframe_type ^ GF_RECURSE)) ------------------ | | 5344| 4.63k|#define Lframe_type F->temp_32[0] ------------------ mb->verb_current_recurse == (Lframe_type ^ GF_RECURSE)) ------------------ | | 109| 4.63k|#define GF_RECURSE 0x00040000u ------------------ | Branch (5395:11): [True: 3.17k, False: 1.46k] ------------------ 5396| 3.17k| { 5397| 3.17k| if (rrc == MATCH_THEN && mb->verb_ecode_ptr < next_ecode && ------------------ | | 96| 6.35k|#define MATCH_THEN (-993) ------------------ | Branch (5397:13): [True: 1.33k, False: 1.84k] | Branch (5397:34): [True: 1.12k, False: 211] ------------------ 5398| 3.17k| (*Lstart_branch == OP_ALT || *next_ecode == OP_ALT)) ------------------ | | 5345| 1.12k|#define Lstart_branch F->temp_sptr[0] ------------------ | Branch (5398:14): [True: 273, False: 850] | Branch (5398:42): [True: 291, False: 559] ------------------ 5399| 564| rrc = MATCH_NOMATCH; ------------------ | | 83| 564|#define MATCH_NOMATCH 0 ------------------ 5400| 2.61k| else RRETURN(MATCH_NOMATCH); ------------------ | | 554| 2.61k| {\ | | 555| 2.61k| rrc = ra;\ | | 556| 2.61k| goto RETURN_SWITCH;\ | | 557| 2.61k| } ------------------ 5401| 564| } 5402| | 5403| | /* Note that carrying on after (*ACCEPT) in a recursion is handled in the 5404| | OP_ACCEPT code. Nothing needs to be done here. */ 5405| | 5406| 179k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 179k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 80.0k| {\ | | 555| 80.0k| rrc = ra;\ | | 556| 80.0k| goto RETURN_SWITCH;\ | | 557| 80.0k| } ------------------ | Branch (5406:11): [True: 80.0k, False: 99.3k] ------------------ 5407| 99.3k| Lstart_branch = next_ecode; ------------------ | | 5345| 99.3k|#define Lstart_branch F->temp_sptr[0] ------------------ 5408| 99.3k| if (*Lstart_branch != OP_ALT) RRETURN(MATCH_NOMATCH); ------------------ | | 5345| 99.3k|#define Lstart_branch F->temp_sptr[0] ------------------ if (*Lstart_branch != OP_ALT) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 85.7k| {\ | | 555| 85.7k| rrc = ra;\ | | 556| 85.7k| goto RETURN_SWITCH;\ | | 557| 85.7k| } ------------------ | Branch (5408:11): [True: 85.7k, False: 13.5k] ------------------ 5409| 13.5k| } 5410| | /* Control never reaches here. */ 5411| | 5412| 0|#undef Lframe_type 5413| 0|#undef Lstart_branch 5414| | 5415| | 5416| | /* ===================================================================== */ 5417| | /* Positive assertions are like other groups except that PCRE doesn't allow 5418| | the effect of (*THEN) to escape beyond an assertion; it is therefore 5419| | treated as NOMATCH. (*ACCEPT) is treated as successful assertion, with its 5420| | captures and mark retained. Any other return is an error. */ 5421| | 5422| 0|#define Lframe_type F->temp_32[0] 5423| | 5424| 56.2k| case OP_ASSERT: ------------------ | Branch (5424:5): [True: 56.2k, False: 2.33G] ------------------ 5425| 74.8k| case OP_ASSERTBACK: ------------------ | Branch (5425:5): [True: 18.5k, False: 2.33G] ------------------ 5426| 105k| case OP_ASSERT_NA: ------------------ | Branch (5426:5): [True: 31.0k, False: 2.33G] ------------------ 5427| 137k| case OP_ASSERTBACK_NA: ------------------ | Branch (5427:5): [True: 31.7k, False: 2.33G] ------------------ 5428| 137k| Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 5422| 137k|#define Lframe_type F->temp_32[0] ------------------ Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 107| 137k|#define GF_NOCAPTURE 0x00020000u ------------------ Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 186| 137k|#define Fop F->op ------------------ 5429| 137k| for (;;) 5430| 159k| { 5431| 159k| group_frame_type = Lframe_type; ------------------ | | 5422| 159k|#define Lframe_type F->temp_32[0] ------------------ 5432| 159k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM3); ------------------ | | 546| 159k| {\ | | 547| 159k| start_ecode = ra;\ | | 548| 159k| Freturn_id = rb;\ | | ------------------ | | | | 188| 159k|#define Freturn_id F->return_id | | ------------------ | | 549| 159k| goto MATCH_RECURSE;\ | | 550| 159k| L_##rb:;\ | | 551| 138k| } ------------------ 5433| 138k| if (rrc == MATCH_ACCEPT) ------------------ | | 88| 138k|#define MATCH_ACCEPT (-999) ------------------ | Branch (5433:11): [True: 2.89k, False: 135k] ------------------ 5434| 2.89k| { 5435| 2.89k| memcpy(Fovector, ------------------ | | 187| 2.89k|#define Fovector F->ovector ------------------ 5436| 2.89k| (char *)assert_accept_frame + offsetof(heapframe, ovector), 5437| 2.89k| assert_accept_frame->offset_top * sizeof(PCRE2_SIZE)); 5438| 2.89k| Foffset_top = assert_accept_frame->offset_top; ------------------ | | 184| 2.89k|#define Foffset_top F->offset_top ------------------ 5439| 2.89k| Fmark = assert_accept_frame->mark; ------------------ | | 181| 2.89k|#define Fmark F->mark ------------------ 5440| 2.89k| break; 5441| 2.89k| } 5442| 135k| if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); ------------------ | | 83| 270k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); ------------------ | | 96| 33.0k|#define MATCH_THEN (-993) ------------------ if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); ------------------ | | 554| 32.7k| {\ | | 555| 32.7k| rrc = ra;\ | | 556| 32.7k| goto RETURN_SWITCH;\ | | 557| 32.7k| } ------------------ | Branch (5442:11): [True: 33.0k, False: 102k] | Branch (5442:35): [True: 32.7k, False: 303] ------------------ 5443| 102k| Fecode += GET(Fecode, 1); ------------------ | | 176| 102k|#define Fecode F->ecode ------------------ Fecode += GET(Fecode, 1); ------------------ | | 109| 102k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5444| 102k| if (*Fecode != OP_ALT) RRETURN(MATCH_NOMATCH); ------------------ | | 176| 102k|#define Fecode F->ecode ------------------ if (*Fecode != OP_ALT) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 81.0k| {\ | | 555| 81.0k| rrc = ra;\ | | 556| 81.0k| goto RETURN_SWITCH;\ | | 557| 81.0k| } ------------------ | Branch (5444:11): [True: 81.0k, False: 21.5k] ------------------ 5445| 21.5k| } 5446| | 5447| 3.15k| do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 3.15k|#define Fecode F->ecode ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 109| 3.15k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 3.15k|#define Fecode F->ecode ------------------ | Branch (5447:41): [True: 258, False: 2.89k] ------------------ 5448| 2.89k| Fecode += 1 + LINK_SIZE; ------------------ | | 176| 2.89k|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; ------------------ | | 165| 2.89k|#define LINK_SIZE 2 ------------------ 5449| 2.89k| break; 5450| | 5451| 0|#undef Lframe_type 5452| | 5453| | 5454| | /* ===================================================================== */ 5455| | /* Handle negative assertions. Loop for each non-matching branch as for 5456| | positive assertions. */ 5457| | 5458| 0|#define Lframe_type F->temp_32[0] 5459| | 5460| 121k| case OP_ASSERT_NOT: ------------------ | Branch (5460:5): [True: 121k, False: 2.33G] ------------------ 5461| 158k| case OP_ASSERTBACK_NOT: ------------------ | Branch (5461:5): [True: 36.7k, False: 2.33G] ------------------ 5462| 158k| Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 5458| 158k|#define Lframe_type F->temp_32[0] ------------------ Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 107| 158k|#define GF_NOCAPTURE 0x00020000u ------------------ Lframe_type = GF_NOCAPTURE | Fop; ------------------ | | 186| 158k|#define Fop F->op ------------------ 5463| | 5464| 158k| for (;;) 5465| 160k| { 5466| 160k| group_frame_type = Lframe_type; ------------------ | | 5458| 160k|#define Lframe_type F->temp_32[0] ------------------ 5467| 160k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM4); ------------------ | | 546| 160k| {\ | | 547| 160k| start_ecode = ra;\ | | 548| 160k| Freturn_id = rb;\ | | ------------------ | | | | 188| 160k|#define Freturn_id F->return_id | | ------------------ | | 549| 160k| goto MATCH_RECURSE;\ | | 550| 160k| L_##rb:;\ | | 551| 159k| } ------------------ 5468| 159k| switch(rrc) 5469| 159k| { 5470| 1.29k| case MATCH_ACCEPT: /* Assertion matched, therefore it fails. */ ------------------ | | 88| 1.29k|#define MATCH_ACCEPT (-999) ------------------ | Branch (5470:9): [True: 1.29k, False: 158k] ------------------ 5471| 27.0k| case MATCH_MATCH: ------------------ | | 82| 27.0k|#define MATCH_MATCH 1 ------------------ | Branch (5471:9): [True: 25.7k, False: 134k] ------------------ 5472| 27.0k| RRETURN (MATCH_NOMATCH); ------------------ | | 554| 27.0k| {\ | | 555| 27.0k| rrc = ra;\ | | 556| 27.0k| goto RETURN_SWITCH;\ | | 557| 27.0k| } ------------------ 5473| | 5474| 127k| case MATCH_NOMATCH: /* Branch failed, try next if present. */ ------------------ | | 83| 127k|#define MATCH_NOMATCH 0 ------------------ | Branch (5474:9): [True: 127k, False: 32.0k] ------------------ 5475| 128k| case MATCH_THEN: ------------------ | | 96| 128k|#define MATCH_THEN (-993) ------------------ | Branch (5475:9): [True: 325, False: 159k] ------------------ 5476| 128k| Fecode += GET(Fecode, 1); ------------------ | | 176| 128k|#define Fecode F->ecode ------------------ Fecode += GET(Fecode, 1); ------------------ | | 109| 128k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5477| 128k| if (*Fecode != OP_ALT) goto ASSERT_NOT_FAILED; ------------------ | | 176| 128k|#define Fecode F->ecode ------------------ | Branch (5477:13): [True: 126k, False: 1.60k] ------------------ 5478| 1.60k| break; 5479| | 5480| 1.71k| case MATCH_COMMIT: /* Assertion forced to fail, therefore continue. */ ------------------ | | 92| 1.71k|#define MATCH_COMMIT (-997) ------------------ | Branch (5480:9): [True: 1.71k, False: 158k] ------------------ 5481| 2.33k| case MATCH_SKIP: ------------------ | | 94| 2.33k|#define MATCH_SKIP (-995) ------------------ | Branch (5481:9): [True: 617, False: 159k] ------------------ 5482| 3.46k| case MATCH_PRUNE: ------------------ | | 93| 3.46k|#define MATCH_PRUNE (-996) ------------------ | Branch (5482:9): [True: 1.12k, False: 158k] ------------------ 5483| 3.78k| do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 3.78k|#define Fecode F->ecode ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 109| 3.78k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 3.78k|#define Fecode F->ecode ------------------ | Branch (5483:45): [True: 322, False: 3.46k] ------------------ 5484| 3.46k| goto ASSERT_NOT_FAILED; 5485| | 5486| 1.20k| default: /* Pass back any other return */ ------------------ | Branch (5486:9): [True: 1.20k, False: 158k] ------------------ 5487| 1.20k| RRETURN(rrc); ------------------ | | 554| 1.20k| {\ | | 555| 1.20k| rrc = ra;\ | | 556| 1.20k| goto RETURN_SWITCH;\ | | 557| 1.20k| } ------------------ 5488| 159k| } 5489| 159k| } 5490| | 5491| | /* None of the branches have matched or there was a backtrack to (*COMMIT), 5492| | (*SKIP), (*PRUNE), or (*THEN) in the last branch. This is success for a 5493| | negative assertion, so carry on. */ 5494| | 5495| 130k| ASSERT_NOT_FAILED: 5496| 130k| Fecode += 1 + LINK_SIZE; ------------------ | | 176| 130k|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; ------------------ | | 165| 130k|#define LINK_SIZE 2 ------------------ 5497| 130k| break; 5498| | 5499| 0|#undef Lframe_type 5500| | 5501| | 5502| | /* ===================================================================== */ 5503| | /* The callout item calls an external function, if one is provided, passing 5504| | details of the match so far. This is mainly for debugging, though the 5505| | function is able to force a failure. */ 5506| | 5507| 609k| case OP_CALLOUT: ------------------ | Branch (5507:5): [True: 609k, False: 2.33G] ------------------ 5508| 616k| case OP_CALLOUT_STR: ------------------ | Branch (5508:5): [True: 7.31k, False: 2.33G] ------------------ 5509| 616k| rrc = do_callout(F, mb, &length); 5510| 616k| if (rrc > 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ | Branch (5510:9): [True: 0, False: 616k] ------------------ 5511| 616k| if (rrc < 0) RRETURN(rrc); ------------------ | | 554| 2.22k| {\ | | 555| 2.22k| rrc = ra;\ | | 556| 2.22k| goto RETURN_SWITCH;\ | | 557| 2.22k| } ------------------ | Branch (5511:9): [True: 2.22k, False: 614k] ------------------ 5512| 614k| Fecode += length; ------------------ | | 176| 614k|#define Fecode F->ecode ------------------ 5513| 614k| break; 5514| | 5515| | 5516| | /* ===================================================================== */ 5517| | /* Conditional group: compilation checked that there are no more than two 5518| | branches. If the condition is false, skipping the first branch takes us 5519| | past the end of the item if there is only one branch, but that's exactly 5520| | what we want. */ 5521| | 5522| 312k| case OP_COND: ------------------ | Branch (5522:5): [True: 312k, False: 2.33G] ------------------ 5523| 314k| case OP_SCOND: ------------------ | Branch (5523:5): [True: 2.06k, False: 2.33G] ------------------ 5524| | 5525| | /* The variable Flength will be added to Fecode when the condition is 5526| | false, to get to the second branch. Setting it to the offset to the ALT or 5527| | KET, then incrementing Fecode achieves this effect. However, if the second 5528| | branch is non-existent, we must point to the KET so that the end of the 5529| | group is correctly processed. We now have Fecode pointing to the condition 5530| | or callout. */ 5531| | 5532| 314k| Flength = GET(Fecode, 1); /* Offset to the second branch */ ------------------ | | 180| 314k|#define Flength F->length ------------------ Flength = GET(Fecode, 1); /* Offset to the second branch */ ------------------ | | 109| 314k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5533| 314k| if (Fecode[Flength] != OP_ALT) Flength -= 1 + LINK_SIZE; ------------------ | | 176| 314k|#define Fecode F->ecode ------------------ if (Fecode[Flength] != OP_ALT) Flength -= 1 + LINK_SIZE; ------------------ | | 180| 314k|#define Flength F->length ------------------ if (Fecode[Flength] != OP_ALT) Flength -= 1 + LINK_SIZE; ------------------ | | 180| 250k|#define Flength F->length ------------------ if (Fecode[Flength] != OP_ALT) Flength -= 1 + LINK_SIZE; ------------------ | | 165| 250k|#define LINK_SIZE 2 ------------------ | Branch (5533:9): [True: 250k, False: 64.2k] ------------------ 5534| 314k| Fecode += 1 + LINK_SIZE; /* From this opcode */ ------------------ | | 176| 314k|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; /* From this opcode */ ------------------ | | 165| 314k|#define LINK_SIZE 2 ------------------ 5535| | 5536| | /* Because of the way auto-callout works during compile, a callout item is 5537| | inserted between OP_COND and an assertion condition. Such a callout can 5538| | also be inserted manually. */ 5539| | 5540| 314k| if (*Fecode == OP_CALLOUT || *Fecode == OP_CALLOUT_STR) ------------------ | | 176| 314k|#define Fecode F->ecode ------------------ if (*Fecode == OP_CALLOUT || *Fecode == OP_CALLOUT_STR) ------------------ | | 176| 311k|#define Fecode F->ecode ------------------ | Branch (5540:9): [True: 2.69k, False: 311k] | Branch (5540:34): [True: 1.65k, False: 310k] ------------------ 5541| 4.34k| { 5542| 4.34k| rrc = do_callout(F, mb, &length); 5543| 4.34k| if (rrc > 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 0| {\ | | 555| 0| rrc = ra;\ | | 556| 0| goto RETURN_SWITCH;\ | | 557| 0| } ------------------ | Branch (5543:11): [True: 0, False: 4.34k] ------------------ 5544| 4.34k| if (rrc < 0) RRETURN(rrc); ------------------ | | 554| 30| {\ | | 555| 30| rrc = ra;\ | | 556| 30| goto RETURN_SWITCH;\ | | 557| 30| } ------------------ | Branch (5544:11): [True: 30, False: 4.31k] ------------------ 5545| | 5546| | /* Advance Fecode past the callout, so it now points to the condition. We 5547| | must adjust Flength so that the value of Fecode+Flength is unchanged. */ 5548| | 5549| 4.31k| Fecode += length; ------------------ | | 176| 4.31k|#define Fecode F->ecode ------------------ 5550| 4.31k| Flength -= length; ------------------ | | 180| 4.31k|#define Flength F->length ------------------ 5551| 4.31k| } 5552| | 5553| | /* Test the various possible conditions */ 5554| | 5555| 314k| condition = FALSE; ------------------ | | 69| 314k|#define FALSE 0 ------------------ 5556| 314k| switch(*Fecode) ------------------ | | 176| 314k|#define Fecode F->ecode ------------------ 5557| 314k| { 5558| 38.1k| case OP_RREF: /* Group recursion test */ ------------------ | Branch (5558:7): [True: 38.1k, False: 276k] ------------------ 5559| 38.1k| if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 175| 38.1k|#define Fcurrent_recurse F->current_recurse ------------------ if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 65| 38.1k|#define RECURSE_UNSET 0xffffffffu /* Bigger than max group number */ ------------------ | Branch (5559:11): [True: 8.55k, False: 29.6k] ------------------ 5560| 8.55k| { 5561| 8.55k| number = GET2(Fecode, 1); ------------------ | | 194| 8.55k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5562| 8.55k| condition = (number == RREF_ANY || number == Fcurrent_recurse); ------------------ | | 1789| 17.1k|#define RREF_ANY 0xffff ------------------ condition = (number == RREF_ANY || number == Fcurrent_recurse); ------------------ | | 175| 4.74k|#define Fcurrent_recurse F->current_recurse ------------------ | Branch (5562:22): [True: 3.81k, False: 4.74k] | Branch (5562:44): [True: 25, False: 4.72k] ------------------ 5563| 8.55k| } 5564| 38.1k| break; 5565| | 5566| 6.70k| case OP_DNRREF: /* Duplicate named group recursion test */ ------------------ | Branch (5566:7): [True: 6.70k, False: 307k] ------------------ 5567| 6.70k| if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 175| 6.70k|#define Fcurrent_recurse F->current_recurse ------------------ if (Fcurrent_recurse != RECURSE_UNSET) ------------------ | | 65| 6.70k|#define RECURSE_UNSET 0xffffffffu /* Bigger than max group number */ ------------------ | Branch (5567:11): [True: 4.28k, False: 2.41k] ------------------ 5568| 4.28k| { 5569| 4.28k| int count = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 194| 4.28k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5570| 4.28k| PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size; ------------------ | | 814| 4.28k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 4.28k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 4.28k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 4.28k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size; ------------------ | | 194| 4.28k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5571| 9.19k| while (count-- > 0) ------------------ | Branch (5571:16): [True: 6.74k, False: 2.45k] ------------------ 5572| 6.74k| { 5573| 6.74k| number = GET2(slot, 0); ------------------ | | 194| 6.74k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5574| 6.74k| condition = number == Fcurrent_recurse; ------------------ | | 175| 6.74k|#define Fcurrent_recurse F->current_recurse ------------------ 5575| 6.74k| if (condition) break; ------------------ | Branch (5575:15): [True: 1.83k, False: 4.90k] ------------------ 5576| 4.90k| slot += mb->name_entry_size; 5577| 4.90k| } 5578| 4.28k| } 5579| 6.70k| break; 5580| | 5581| 19.5k| case OP_CREF: /* Numbered group used test */ ------------------ | Branch (5581:7): [True: 19.5k, False: 294k] ------------------ 5582| 19.5k| offset = (GET2(Fecode, 1) << 1) - 2; /* Doubled ref number */ ------------------ | | 194| 19.5k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5583| 19.5k| condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET; ------------------ | | 184| 39.1k|#define Foffset_top F->offset_top ------------------ condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET; ------------------ | | 187| 3.84k|#define Fovector F->ovector ------------------ condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET; ------------------ | | 480| 23.4k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (5583:19): [True: 3.84k, False: 15.7k] | Branch (5583:43): [True: 2.98k, False: 866] ------------------ 5584| 19.5k| break; 5585| | 5586| 76.5k| case OP_DNCREF: /* Duplicate named group used test */ ------------------ | Branch (5586:7): [True: 76.5k, False: 237k] ------------------ 5587| 76.5k| { 5588| 76.5k| int count = GET2(Fecode, 1 + IMM2_SIZE); ------------------ | | 194| 76.5k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5589| 76.5k| PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size; ------------------ | | 814| 76.5k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 76.5k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 76.5k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 76.5k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size; ------------------ | | 194| 76.5k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5590| 356k| while (count-- > 0) ------------------ | Branch (5590:16): [True: 303k, False: 52.7k] ------------------ 5591| 303k| { 5592| 303k| offset = (GET2(slot, 0) << 1) - 2; ------------------ | | 194| 303k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5593| 303k| condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET; ------------------ | | 184| 607k|#define Foffset_top F->offset_top ------------------ condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET; ------------------ | | 187| 23.9k|#define Fovector F->ovector ------------------ condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET; ------------------ | | 480| 327k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (5593:23): [True: 23.9k, False: 279k] | Branch (5593:47): [True: 23.8k, False: 93] ------------------ 5594| 303k| if (condition) break; ------------------ | Branch (5594:15): [True: 23.8k, False: 279k] ------------------ 5595| 279k| slot += mb->name_entry_size; 5596| 279k| } 5597| 76.5k| } 5598| 76.5k| break; 5599| | 5600| 96.5k| case OP_FALSE: ------------------ | Branch (5600:7): [True: 96.5k, False: 217k] ------------------ 5601| 98.9k| case OP_FAIL: /* The assertion (?!) becomes OP_FAIL */ ------------------ | Branch (5601:7): [True: 2.36k, False: 312k] ------------------ 5602| 98.9k| break; 5603| | 5604| 28.6k| case OP_TRUE: ------------------ | Branch (5604:7): [True: 28.6k, False: 285k] ------------------ 5605| 28.6k| condition = TRUE; ------------------ | | 70| 28.6k|#define TRUE 1 ------------------ 5606| 28.6k| break; 5607| | 5608| | /* The condition is an assertion. Run code similar to the assertion code 5609| | above. */ 5610| | 5611| 0|#define Lpositive F->temp_32[0] 5612| 0|#define Lstart_branch F->temp_sptr[0] 5613| | 5614| 45.8k| default: ------------------ | Branch (5614:7): [True: 45.8k, False: 268k] ------------------ 5615| 45.8k| Lpositive = (*Fecode == OP_ASSERT || *Fecode == OP_ASSERTBACK); ------------------ | | 5611| 45.8k|#define Lpositive F->temp_32[0] ------------------ Lpositive = (*Fecode == OP_ASSERT || *Fecode == OP_ASSERTBACK); ------------------ | | 176| 45.8k|#define Fecode F->ecode ------------------ Lpositive = (*Fecode == OP_ASSERT || *Fecode == OP_ASSERTBACK); ------------------ | | 176| 4.28k|#define Fecode F->ecode ------------------ | Branch (5615:20): [True: 41.5k, False: 4.28k] | Branch (5615:44): [True: 676, False: 3.60k] ------------------ 5616| 45.8k| Lstart_branch = Fecode; ------------------ | | 5612| 45.8k|#define Lstart_branch F->temp_sptr[0] ------------------ Lstart_branch = Fecode; ------------------ | | 176| 45.8k|#define Fecode F->ecode ------------------ 5617| | 5618| 45.8k| for (;;) 5619| 60.3k| { 5620| 60.3k| group_frame_type = GF_CONDASSERT | *Fecode; ------------------ | | 108| 60.3k|#define GF_CONDASSERT 0x00030000u ------------------ group_frame_type = GF_CONDASSERT | *Fecode; ------------------ | | 176| 60.3k|#define Fecode F->ecode ------------------ 5621| 60.3k| RMATCH(Lstart_branch + PRIV(OP_lengths)[*Lstart_branch], RM5); ------------------ | | 546| 60.3k| {\ | | 547| 60.3k| start_ecode = ra;\ | | 548| 60.3k| Freturn_id = rb;\ | | ------------------ | | | | 188| 60.3k|#define Freturn_id F->return_id | | ------------------ | | 549| 60.3k| goto MATCH_RECURSE;\ | | 550| 60.3k| L_##rb:;\ | | 551| 59.8k| } ------------------ 5622| | 5623| 59.8k| switch(rrc) 5624| 59.8k| { 5625| 678| case MATCH_ACCEPT: /* Save captures */ ------------------ | | 88| 678|#define MATCH_ACCEPT (-999) ------------------ | Branch (5625:11): [True: 678, False: 59.2k] ------------------ 5626| 678| memcpy(Fovector, ------------------ | | 187| 678|#define Fovector F->ovector ------------------ 5627| 678| (char *)assert_accept_frame + offsetof(heapframe, ovector), 5628| 678| assert_accept_frame->offset_top * sizeof(PCRE2_SIZE)); 5629| 678| Foffset_top = assert_accept_frame->offset_top; ------------------ | | 184| 678|#define Foffset_top F->offset_top ------------------ 5630| | 5631| | /* Fall through */ 5632| | /* In the case of a match, the captures have already been put into 5633| | the current frame. */ 5634| | 5635| 26.3k| case MATCH_MATCH: ------------------ | | 82| 26.3k|#define MATCH_MATCH 1 ------------------ | Branch (5635:11): [True: 25.6k, False: 34.2k] ------------------ 5636| 26.3k| condition = Lpositive; /* TRUE for positive assertion */ ------------------ | | 5611| 26.3k|#define Lpositive F->temp_32[0] ------------------ 5637| 26.3k| break; 5638| | 5639| | /* PCRE doesn't allow the effect of (*THEN) to escape beyond an 5640| | assertion; it is therefore always treated as NOMATCH. */ 5641| | 5642| 32.0k| case MATCH_NOMATCH: ------------------ | | 83| 32.0k|#define MATCH_NOMATCH 0 ------------------ | Branch (5642:11): [True: 32.0k, False: 27.8k] ------------------ 5643| 32.3k| case MATCH_THEN: ------------------ | | 96| 32.3k|#define MATCH_THEN (-993) ------------------ | Branch (5643:11): [True: 288, False: 59.5k] ------------------ 5644| 32.3k| Lstart_branch += GET(Lstart_branch, 1); ------------------ | | 5612| 32.3k|#define Lstart_branch F->temp_sptr[0] ------------------ Lstart_branch += GET(Lstart_branch, 1); ------------------ | | 109| 32.3k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5645| 32.3k| if (*Lstart_branch == OP_ALT) continue; /* Try next branch */ ------------------ | | 5612| 32.3k|#define Lstart_branch F->temp_sptr[0] ------------------ | Branch (5645:15): [True: 14.4k, False: 17.8k] ------------------ 5646| 17.8k| condition = !Lpositive; /* TRUE for negative assertion */ ------------------ | | 5611| 17.8k|#define Lpositive F->temp_32[0] ------------------ 5647| 17.8k| break; 5648| | 5649| | /* These force no match without checking other branches. */ 5650| | 5651| 317| case MATCH_COMMIT: ------------------ | | 92| 317|#define MATCH_COMMIT (-997) ------------------ | Branch (5651:11): [True: 317, False: 59.5k] ------------------ 5652| 558| case MATCH_SKIP: ------------------ | | 94| 558|#define MATCH_SKIP (-995) ------------------ | Branch (5652:11): [True: 241, False: 59.6k] ------------------ 5653| 896| case MATCH_PRUNE: ------------------ | | 93| 896|#define MATCH_PRUNE (-996) ------------------ | Branch (5653:11): [True: 338, False: 59.5k] ------------------ 5654| 896| condition = !Lpositive; ------------------ | | 5611| 896|#define Lpositive F->temp_32[0] ------------------ 5655| 896| break; 5656| | 5657| 342| default: ------------------ | Branch (5657:11): [True: 342, False: 59.5k] ------------------ 5658| 342| RRETURN(rrc); ------------------ | | 554| 342| {\ | | 555| 342| rrc = ra;\ | | 556| 342| goto RETURN_SWITCH;\ | | 557| 342| } ------------------ 5659| 59.8k| } 5660| 45.0k| break; /* Out of the branch loop */ 5661| 59.8k| } 5662| | 5663| | /* If the condition is true, find the end of the assertion so that 5664| | advancing past it gets us to the start of the first branch. */ 5665| | 5666| 45.0k| if (condition) ------------------ | Branch (5666:11): [True: 26.8k, False: 18.2k] ------------------ 5667| 26.8k| { 5668| 33.1k| do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 33.1k|#define Fecode F->ecode ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 109| 33.1k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT); ------------------ | | 176| 33.1k|#define Fecode F->ecode ------------------ | Branch (5668:45): [True: 6.31k, False: 26.8k] ------------------ 5669| 26.8k| } 5670| 45.0k| break; /* End of assertion condition */ 5671| 314k| } 5672| | 5673| 313k|#undef Lpositive 5674| 313k|#undef Lstart_branch 5675| | 5676| | /* Choose branch according to the condition. */ 5677| | 5678| 313k| Fecode += condition? PRIV(OP_lengths)[*Fecode] : Flength; ------------------ | | 176| 313k|#define Fecode F->ecode ------------------ Fecode += condition? PRIV(OP_lengths)[*Fecode] : Flength; ------------------ | | 177| 87.8k|#define PRIV(name) _pcre2_##name ------------------ Fecode += condition? PRIV(OP_lengths)[*Fecode] : Flength; ------------------ | | 176| 87.8k|#define Fecode F->ecode ------------------ Fecode += condition? PRIV(OP_lengths)[*Fecode] : Flength; ------------------ | | 180| 539k|#define Flength F->length ------------------ | Branch (5678:15): [True: 87.8k, False: 225k] ------------------ 5679| | 5680| | /* If the opcode is OP_SCOND it means we are at a repeated conditional 5681| | group that might match an empty string. We must therefore descend a level 5682| | so that the start is remembered for checking. For OP_COND we can just 5683| | continue at this level. */ 5684| | 5685| 313k| if (Fop == OP_SCOND) ------------------ | | 186| 313k|#define Fop F->op ------------------ | Branch (5685:9): [True: 2.06k, False: 311k] ------------------ 5686| 2.06k| { 5687| 2.06k| group_frame_type = GF_NOCAPTURE | Fop; ------------------ | | 107| 2.06k|#define GF_NOCAPTURE 0x00020000u ------------------ group_frame_type = GF_NOCAPTURE | Fop; ------------------ | | 186| 2.06k|#define Fop F->op ------------------ 5688| 2.06k| RMATCH(Fecode, RM35); ------------------ | | 546| 2.06k| {\ | | 547| 2.06k| start_ecode = ra;\ | | 548| 2.06k| Freturn_id = rb;\ | | ------------------ | | | | 188| 2.06k|#define Freturn_id F->return_id | | ------------------ | | 549| 2.06k| goto MATCH_RECURSE;\ | | 550| 2.06k| L_##rb:;\ | | 551| 1.91k| } ------------------ 5689| 1.91k| RRETURN(rrc); ------------------ | | 554| 1.91k| {\ | | 555| 1.91k| rrc = ra;\ | | 556| 1.91k| goto RETURN_SWITCH;\ | | 557| 1.91k| } ------------------ 5690| 0| } 5691| 311k| break; 5692| | 5693| | 5694| | 5695| |/* ========================================================================= */ 5696| |/* End of start of parenthesis opcodes */ 5697| |/* ========================================================================= */ 5698| | 5699| | 5700| | /* ===================================================================== */ 5701| | /* Move the subject pointer back. This occurs only at the start of each 5702| | branch of a lookbehind assertion. If we are too close to the start to move 5703| | back, fail. When working with UTF-8 we move back a number of characters, 5704| | not bytes. */ 5705| | 5706| 311k| case OP_REVERSE: ------------------ | Branch (5706:5): [True: 27.8k, False: 2.33G] ------------------ 5707| 27.8k| number = GET(Fecode, 1); ------------------ | | 109| 27.8k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5708| 27.8k|#ifdef SUPPORT_UNICODE 5709| 27.8k| if (utf) ------------------ | Branch (5709:9): [True: 11.5k, False: 16.3k] ------------------ 5710| 11.5k| { 5711| 369k| while (number-- > 0) ------------------ | Branch (5711:14): [True: 362k, False: 7.57k] ------------------ 5712| 362k| { 5713| 362k| if (Feptr <= mb->check_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 362k|#define Feptr F->eptr ------------------ if (Feptr <= mb->check_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 3.97k| {\ | | 555| 3.97k| rrc = ra;\ | | 556| 3.97k| goto RETURN_SWITCH;\ | | 557| 3.97k| } ------------------ | Branch (5713:13): [True: 3.97k, False: 358k] ------------------ 5714| 358k| Feptr--; ------------------ | | 177| 358k|#define Feptr F->eptr ------------------ 5715| 358k| BACKCHAR(Feptr); ------------------ | | 345| 358k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 676, False: 358k] | | ------------------ ------------------ 5716| 358k| } 5717| 11.5k| } 5718| 16.3k| else 5719| 16.3k|#endif 5720| | 5721| | /* No UTF-8 support, or not in UTF-8 mode: count is code unit count */ 5722| | 5723| 16.3k| { 5724| 16.3k| if ((ptrdiff_t)number > Feptr - mb->start_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 16.3k|#define Feptr F->eptr ------------------ if ((ptrdiff_t)number > Feptr - mb->start_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 6.73k| {\ | | 555| 6.73k| rrc = ra;\ | | 556| 6.73k| goto RETURN_SWITCH;\ | | 557| 6.73k| } ------------------ | Branch (5724:11): [True: 6.73k, False: 9.60k] ------------------ 5725| 9.60k| Feptr -= number; ------------------ | | 177| 9.60k|#define Feptr F->eptr ------------------ 5726| 9.60k| } 5727| | 5728| | /* Save the earliest consulted character, then skip to next opcode */ 5729| | 5730| 17.1k| if (Feptr < mb->start_used_ptr) mb->start_used_ptr = Feptr; ------------------ | | 177| 17.1k|#define Feptr F->eptr ------------------ if (Feptr < mb->start_used_ptr) mb->start_used_ptr = Feptr; ------------------ | | 177| 10.4k|#define Feptr F->eptr ------------------ | Branch (5730:9): [True: 10.4k, False: 6.71k] ------------------ 5731| 17.1k| Fecode += 1 + LINK_SIZE; ------------------ | | 176| 17.1k|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; ------------------ | | 165| 17.1k|#define LINK_SIZE 2 ------------------ 5732| 17.1k| break; 5733| | 5734| | 5735| | /* ===================================================================== */ 5736| | /* An alternation is the end of a branch; scan along to find the end of the 5737| | bracketed group. */ 5738| | 5739| 3.80M| case OP_ALT: ------------------ | Branch (5739:5): [True: 3.80M, False: 2.33G] ------------------ 5740| 8.02M| do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT); ------------------ | | 176| 8.02M|#define Fecode F->ecode ------------------ do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT); ------------------ | | 109| 8.02M| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT); ------------------ | | 176| 8.02M|#define Fecode F->ecode ------------------ | Branch (5740:40): [True: 4.21M, False: 3.80M] ------------------ 5741| 3.80M| break; 5742| | 5743| | 5744| | /* ===================================================================== */ 5745| | /* The end of a parenthesized group. For all but OP_BRA and OP_COND, the 5746| | starting frame was added to the chained frames in order to remember the 5747| | starting subject position for the group. */ 5748| | 5749| 1.15G| case OP_KET: ------------------ | Branch (5749:5): [True: 1.15G, False: 1.17G] ------------------ 5750| 1.15G| case OP_KETRMIN: ------------------ | Branch (5750:5): [True: 11.2k, False: 2.33G] ------------------ 5751| 1.15G| case OP_KETRMAX: ------------------ | Branch (5751:5): [True: 153k, False: 2.33G] ------------------ 5752| 1.15G| case OP_KETRPOS: ------------------ | Branch (5752:5): [True: 45.9k, False: 2.33G] ------------------ 5753| | 5754| 1.15G| bracode = Fecode - GET(Fecode, 1); ------------------ | | 176| 1.15G|#define Fecode F->ecode ------------------ bracode = Fecode - GET(Fecode, 1); ------------------ | | 109| 1.15G| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5755| | 5756| | /* Point N to the frame at the start of the most recent group. 5757| | Remember the subject pointer at the start of the group. */ 5758| | 5759| 1.15G| if (*bracode != OP_BRA && *bracode != OP_COND) ------------------ | Branch (5759:9): [True: 5.91M, False: 1.15G] | Branch (5759:31): [True: 5.64M, False: 272k] ------------------ 5760| 5.64M| { 5761| 5.64M| N = (heapframe *)((char *)match_data->heapframes + Flast_group_offset); ------------------ | | 179| 5.64M|#define Flast_group_offset F->last_group_offset ------------------ 5762| 5.64M| P = (heapframe *)((char *)N - frame_size); 5763| 5.64M| Flast_group_offset = P->last_group_offset; ------------------ | | 179| 5.64M|#define Flast_group_offset F->last_group_offset ------------------ 5764| | 5765| |#ifdef DEBUG_SHOW_RMATCH 5766| | fprintf(stderr, "++ KET for frame=%d type=%x prev char offset=%lu\n", 5767| | N->rdepth, N->group_frame_type, 5768| | (char *)P->eptr - (char *)mb->start_subject); 5769| |#endif 5770| | 5771| | /* If we are at the end of an assertion that is a condition, return a 5772| | match, discarding any intermediate backtracking points. Copy back the 5773| | mark setting and the captures into the frame before N so that they are 5774| | set on return. Doing this for all assertions, both positive and negative, 5775| | seems to match what Perl does. */ 5776| | 5777| 5.64M| if (GF_IDMASK(N->group_frame_type) == GF_CONDASSERT) ------------------ | | 113| 5.64M|#define GF_IDMASK(a) ((a) & 0xffff0000u) ------------------ if (GF_IDMASK(N->group_frame_type) == GF_CONDASSERT) ------------------ | | 108| 5.64M|#define GF_CONDASSERT 0x00030000u ------------------ | Branch (5777:11): [True: 25.6k, False: 5.62M] ------------------ 5778| 25.6k| { 5779| 25.6k| memcpy((char *)P + offsetof(heapframe, ovector), Fovector, ------------------ | | 187| 25.6k|#define Fovector F->ovector ------------------ 5780| 25.6k| Foffset_top * sizeof(PCRE2_SIZE)); ------------------ | | 184| 25.6k|#define Foffset_top F->offset_top ------------------ 5781| 25.6k| P->offset_top = Foffset_top; ------------------ | | 184| 25.6k|#define Foffset_top F->offset_top ------------------ 5782| 25.6k| P->mark = Fmark; ------------------ | | 181| 25.6k|#define Fmark F->mark ------------------ 5783| 25.6k| Fback_frame = (char *)F - (char *)P; ------------------ | | 173| 25.6k|#define Fback_frame F->back_frame ------------------ 5784| 25.6k| RRETURN(MATCH_MATCH); ------------------ | | 554| 25.6k| {\ | | 555| 25.6k| rrc = ra;\ | | 556| 25.6k| goto RETURN_SWITCH;\ | | 557| 25.6k| } ------------------ 5785| 0| } 5786| 5.64M| } 5787| 1.15G| else P = NULL; /* Indicates starting frame not recorded */ 5788| | 5789| | /* The group was not a conditional assertion. */ 5790| | 5791| 1.15G| switch (*bracode) ------------------ | Branch (5791:13): [True: 132k, False: 1.15G] ------------------ 5792| 1.15G| { 5793| 1.15G| case OP_BRA: /* No need to do anything for these */ ------------------ | Branch (5793:7): [True: 1.15G, False: 5.89M] ------------------ 5794| 1.15G| case OP_COND: ------------------ | Branch (5794:7): [True: 272k, False: 1.15G] ------------------ 5795| 1.15G| case OP_SCOND: ------------------ | Branch (5795:7): [True: 1.74k, False: 1.15G] ------------------ 5796| 1.15G| break; 5797| | 5798| | /* Non-atomic positive assertions are like OP_BRA, except that the 5799| | subject pointer must be put back to where it was at the start of the 5800| | assertion. */ 5801| | 5802| 14.4k| case OP_ASSERT_NA: ------------------ | Branch (5802:7): [True: 14.4k, False: 1.15G] ------------------ 5803| 43.7k| case OP_ASSERTBACK_NA: ------------------ | Branch (5803:7): [True: 29.3k, False: 1.15G] ------------------ 5804| 43.7k| if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 43.7k|#define Feptr F->eptr ------------------ if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 632|#define Feptr F->eptr ------------------ | Branch (5804:11): [True: 632, False: 43.1k] ------------------ 5805| 43.7k| Feptr = P->eptr; ------------------ | | 177| 43.7k|#define Feptr F->eptr ------------------ 5806| 43.7k| break; 5807| | 5808| | /* Atomic positive assertions are like OP_ONCE, except that in addition 5809| | the subject pointer must be put back to where it was at the start of the 5810| | assertion. */ 5811| | 5812| 44.4k| case OP_ASSERT: ------------------ | Branch (5812:7): [True: 44.4k, False: 1.15G] ------------------ 5813| 54.3k| case OP_ASSERTBACK: ------------------ | Branch (5813:7): [True: 9.84k, False: 1.15G] ------------------ 5814| 54.3k| if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 54.3k|#define Feptr F->eptr ------------------ if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 3.52k|#define Feptr F->eptr ------------------ | Branch (5814:11): [True: 3.52k, False: 50.8k] ------------------ 5815| 54.3k| Feptr = P->eptr; ------------------ | | 177| 54.3k|#define Feptr F->eptr ------------------ 5816| | /* Fall through */ 5817| | 5818| | /* For an atomic group, discard internal backtracking points. We must 5819| | also ensure that any remaining branches within the top-level of the group 5820| | are not tried. Do this by adjusting the code pointer within the backtrack 5821| | frame so that it points to the final branch. */ 5822| | 5823| 96.0k| case OP_ONCE: ------------------ | Branch (5823:7): [True: 41.7k, False: 1.15G] ------------------ 5824| 96.0k| Fback_frame = ((char *)F - (char *)P); ------------------ | | 173| 96.0k|#define Fback_frame F->back_frame ------------------ 5825| 96.0k| for (;;) 5826| 253k| { 5827| 253k| uint32_t y = GET(P->ecode,1); ------------------ | | 109| 253k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5828| 253k| if ((P->ecode)[y] != OP_ALT) break; ------------------ | Branch (5828:13): [True: 96.0k, False: 157k] ------------------ 5829| 157k| P->ecode += y; 5830| 157k| } 5831| 96.0k| break; 5832| | 5833| | /* A matching negative assertion returns MATCH, which is turned into 5834| | NOMATCH at the assertion level. */ 5835| | 5836| 8.24k| case OP_ASSERT_NOT: ------------------ | Branch (5836:7): [True: 8.24k, False: 1.15G] ------------------ 5837| 25.7k| case OP_ASSERTBACK_NOT: ------------------ | Branch (5837:7): [True: 17.4k, False: 1.15G] ------------------ 5838| 25.7k| RRETURN(MATCH_MATCH); ------------------ | | 554| 25.7k| {\ | | 555| 25.7k| rrc = ra;\ | | 556| 25.7k| goto RETURN_SWITCH;\ | | 557| 25.7k| } ------------------ 5839| | 5840| | /* At the end of a script run, apply the script-checking rules. This code 5841| | will never by exercised if Unicode support it not compiled, because in 5842| | that environment script runs cause an error at compile time. */ 5843| | 5844| 23.8k| case OP_SCRIPT_RUN: ------------------ | Branch (5844:7): [True: 23.8k, False: 1.15G] ------------------ 5845| 23.8k| if (!PRIV(script_run)(P->eptr, Feptr, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 23.8k|#define PRIV(name) _pcre2_##name ------------------ if (!PRIV(script_run)(P->eptr, Feptr, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 23.8k|#define Feptr F->eptr ------------------ if (!PRIV(script_run)(P->eptr, Feptr, utf)) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 10.2k| {\ | | 555| 10.2k| rrc = ra;\ | | 556| 10.2k| goto RETURN_SWITCH;\ | | 557| 10.2k| } ------------------ | Branch (5845:11): [True: 10.2k, False: 13.5k] ------------------ 5846| 13.5k| break; 5847| | 5848| | /* Whole-pattern recursion is coded as a recurse into group 0, so it 5849| | won't be picked up here. Instead, we catch it when the OP_END is reached. 5850| | Other recursion is handled here. */ 5851| | 5852| 5.24M| case OP_CBRA: ------------------ | Branch (5852:7): [True: 5.24M, False: 1.15G] ------------------ 5853| 5.25M| case OP_CBRAPOS: ------------------ | Branch (5853:7): [True: 10.9k, False: 1.15G] ------------------ 5854| 5.27M| case OP_SCBRA: ------------------ | Branch (5854:7): [True: 20.4k, False: 1.15G] ------------------ 5855| 5.29M| case OP_SCBRAPOS: ------------------ | Branch (5855:7): [True: 18.6k, False: 1.15G] ------------------ 5856| 5.29M| number = GET2(bracode, 1+LINK_SIZE); ------------------ | | 194| 5.29M|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5857| | 5858| | /* Handle a recursively called group. We reinstate the previous set of 5859| | captures and then carry on after the recursion call. */ 5860| | 5861| 5.29M| if (Fcurrent_recurse == number) ------------------ | | 175| 5.29M|#define Fcurrent_recurse F->current_recurse ------------------ | Branch (5861:11): [True: 104k, False: 5.19M] ------------------ 5862| 104k| { 5863| 104k| P = (heapframe *)((char *)N - frame_size); 5864| 104k| memcpy((char *)F + offsetof(heapframe, ovector), P->ovector, 5865| 104k| P->offset_top * sizeof(PCRE2_SIZE)); 5866| 104k| Foffset_top = P->offset_top; ------------------ | | 184| 104k|#define Foffset_top F->offset_top ------------------ 5867| 104k| Fcapture_last = P->capture_last; ------------------ | | 174| 104k|#define Fcapture_last F->capture_last ------------------ 5868| 104k| Fcurrent_recurse = P->current_recurse; ------------------ | | 175| 104k|#define Fcurrent_recurse F->current_recurse ------------------ 5869| 104k| Fecode = P->ecode + 1 + LINK_SIZE; ------------------ | | 176| 104k|#define Fecode F->ecode ------------------ Fecode = P->ecode + 1 + LINK_SIZE; ------------------ | | 165| 104k|#define LINK_SIZE 2 ------------------ 5870| 104k| continue; /* With next opcode */ 5871| 104k| } 5872| | 5873| | /* Deal with actual capturing. */ 5874| | 5875| 5.19M| offset = (number << 1) - 2; 5876| 5.19M| Fcapture_last = number; ------------------ | | 174| 5.19M|#define Fcapture_last F->capture_last ------------------ 5877| 5.19M| Fovector[offset] = P->eptr - mb->start_subject; ------------------ | | 187| 5.19M|#define Fovector F->ovector ------------------ 5878| 5.19M| Fovector[offset+1] = Feptr - mb->start_subject; ------------------ | | 187| 5.19M|#define Fovector F->ovector ------------------ Fovector[offset+1] = Feptr - mb->start_subject; ------------------ | | 177| 5.19M|#define Feptr F->eptr ------------------ 5879| 5.19M| if (offset >= Foffset_top) Foffset_top = offset + 2; ------------------ | | 184| 5.19M|#define Foffset_top F->offset_top ------------------ if (offset >= Foffset_top) Foffset_top = offset + 2; ------------------ | | 184| 1.22M|#define Foffset_top F->offset_top ------------------ | Branch (5879:11): [True: 1.22M, False: 3.96M] ------------------ 5880| 5.19M| break; 5881| 1.15G| } /* End actions relating to the starting opcode */ 5882| | 5883| | /* OP_KETRPOS is a possessive repeating ket. Remember the current position, 5884| | and return the MATCH_KETRPOS. This makes it possible to do the repeats one 5885| | at a time from the outer level. This must precede the empty string test - 5886| | in this case that test is done at the outer level. */ 5887| | 5888| 1.15G| if (*Fecode == OP_KETRPOS) ------------------ | | 176| 1.15G|#define Fecode F->ecode ------------------ | Branch (5888:9): [True: 45.9k, False: 1.15G] ------------------ 5889| 45.9k| { 5890| 45.9k| memcpy((char *)P + offsetof(heapframe, eptr), 5891| 45.9k| (char *)F + offsetof(heapframe, eptr), 5892| 45.9k| frame_copy_size); 5893| 45.9k| RRETURN(MATCH_KETRPOS); ------------------ | | 554| 45.9k| {\ | | 555| 45.9k| rrc = ra;\ | | 556| 45.9k| goto RETURN_SWITCH;\ | | 557| 45.9k| } ------------------ 5894| 0| } 5895| | 5896| | /* Handle the different kinds of closing brackets. A non-repeating ket 5897| | needs no special action, just continuing at this level. This also happens 5898| | for the repeating kets if the group matched no characters, in order to 5899| | forcibly break infinite loops. Otherwise, the repeating kets try the rest 5900| | of the pattern or restart from the preceding bracket, in the appropriate 5901| | order. */ 5902| | 5903| 1.15G| if (Fop != OP_KET && (P == NULL || Feptr != P->eptr)) ------------------ | | 186| 1.15G|#define Fop F->op ------------------ if (Fop != OP_KET && (P == NULL || Feptr != P->eptr)) ------------------ | | 177| 159k|#define Feptr F->eptr ------------------ | Branch (5903:9): [True: 162k, False: 1.15G] | Branch (5903:27): [True: 3.03k, False: 159k] | Branch (5903:40): [True: 24.1k, False: 135k] ------------------ 5904| 27.1k| { 5905| 27.1k| if (Fop == OP_KETRMIN) ------------------ | | 186| 27.1k|#define Fop F->op ------------------ | Branch (5905:11): [True: 4.91k, False: 22.2k] ------------------ 5906| 4.91k| { 5907| 4.91k| RMATCH(Fecode + 1 + LINK_SIZE, RM6); ------------------ | | 546| 4.91k| {\ | | 547| 4.91k| start_ecode = ra;\ | | 548| 4.91k| Freturn_id = rb;\ | | ------------------ | | | | 188| 4.91k|#define Freturn_id F->return_id | | ------------------ | | 549| 4.91k| goto MATCH_RECURSE;\ | | 550| 4.91k| L_##rb:;\ | | 551| 4.70k| } ------------------ 5908| 4.70k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 4.70k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 420| {\ | | 555| 420| rrc = ra;\ | | 556| 420| goto RETURN_SWITCH;\ | | 557| 420| } ------------------ | Branch (5908:13): [True: 420, False: 4.28k] ------------------ 5909| 4.28k| Fecode -= GET(Fecode, 1); ------------------ | | 176| 4.28k|#define Fecode F->ecode ------------------ Fecode -= GET(Fecode, 1); ------------------ | | 109| 4.28k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 5910| 4.28k| break; /* End of ket processing */ 5911| 4.70k| } 5912| | 5913| | /* Repeat the maximum number of times (KETRMAX) */ 5914| | 5915| 22.2k| RMATCH(bracode, RM7); ------------------ | | 546| 22.2k| {\ | | 547| 22.2k| start_ecode = ra;\ | | 548| 22.2k| Freturn_id = rb;\ | | ------------------ | | | | 188| 22.2k|#define Freturn_id F->return_id | | ------------------ | | 549| 22.2k| goto MATCH_RECURSE;\ | | 550| 22.2k| L_##rb:;\ | | 551| 20.2k| } ------------------ 5916| 20.2k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 20.2k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.01k| {\ | | 555| 1.01k| rrc = ra;\ | | 556| 1.01k| goto RETURN_SWITCH;\ | | 557| 1.01k| } ------------------ | Branch (5916:11): [True: 1.01k, False: 19.2k] ------------------ 5917| 19.2k| } 5918| | 5919| | /* Carry on at this level for a non-repeating ket, or after matching an 5920| | empty string, or after repeating for a maximum number of times. */ 5921| | 5922| 1.15G| Fecode += 1 + LINK_SIZE; ------------------ | | 176| 1.15G|#define Fecode F->ecode ------------------ Fecode += 1 + LINK_SIZE; ------------------ | | 165| 1.15G|#define LINK_SIZE 2 ------------------ 5923| 1.15G| break; 5924| | 5925| | 5926| | /* ===================================================================== */ 5927| | /* Start and end of line assertions, not multiline mode. */ 5928| | 5929| 312k| case OP_CIRC: /* Start of line, unless PCRE2_NOTBOL is set. */ ------------------ | Branch (5929:5): [True: 312k, False: 2.33G] ------------------ 5930| 312k| if (Feptr != mb->start_subject || (mb->moptions & PCRE2_NOTBOL) != 0) ------------------ | | 177| 312k|#define Feptr F->eptr ------------------ if (Feptr != mb->start_subject || (mb->moptions & PCRE2_NOTBOL) != 0) ------------------ | | 176| 9.80k|#define PCRE2_NOTBOL 0x00000001u ------------------ | Branch (5930:9): [True: 302k, False: 9.80k] | Branch (5930:39): [True: 1.88k, False: 7.92k] ------------------ 5931| 304k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 304k| {\ | | 555| 304k| rrc = ra;\ | | 556| 304k| goto RETURN_SWITCH;\ | | 557| 304k| } ------------------ 5932| 7.92k| Fecode++; ------------------ | | 176| 7.92k|#define Fecode F->ecode ------------------ 5933| 7.92k| break; 5934| | 5935| 176k| case OP_SOD: /* Unconditional start of subject */ ------------------ | Branch (5935:5): [True: 176k, False: 2.33G] ------------------ 5936| 176k| if (Feptr != mb->start_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 176k|#define Feptr F->eptr ------------------ if (Feptr != mb->start_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 174k| {\ | | 555| 174k| rrc = ra;\ | | 556| 174k| goto RETURN_SWITCH;\ | | 557| 174k| } ------------------ | Branch (5936:9): [True: 174k, False: 1.82k] ------------------ 5937| 1.82k| Fecode++; ------------------ | | 176| 1.82k|#define Fecode F->ecode ------------------ 5938| 1.82k| break; 5939| | 5940| | /* When PCRE2_NOTEOL is unset, assert before the subject end, or a 5941| | terminating newline unless PCRE2_DOLLAR_ENDONLY is set. */ 5942| | 5943| 1.10M| case OP_DOLL: ------------------ | Branch (5943:5): [True: 1.10M, False: 2.33G] ------------------ 5944| 1.10M| if ((mb->moptions & PCRE2_NOTEOL) != 0) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 1.10M|#define PCRE2_NOTEOL 0x00000002u ------------------ if ((mb->moptions & PCRE2_NOTEOL) != 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 53.5k| {\ | | 555| 53.5k| rrc = ra;\ | | 556| 53.5k| goto RETURN_SWITCH;\ | | 557| 53.5k| } ------------------ | Branch (5944:9): [True: 53.5k, False: 1.04M] ------------------ 5945| 1.04M| if ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0) goto ASSERT_NL_OR_EOS; ------------------ | | 123| 1.04M|#define PCRE2_DOLLAR_ENDONLY 0x00000010u /* J M D */ ------------------ | Branch (5945:9): [True: 626k, False: 420k] ------------------ 5946| | 5947| | /* Fall through */ 5948| | /* Unconditional end of subject assertion (\z) */ 5949| | 5950| 437k| case OP_EOD: ------------------ | Branch (5950:5): [True: 17.2k, False: 2.33G] ------------------ 5951| 437k| if (Feptr < mb->end_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 437k|#define Feptr F->eptr ------------------ if (Feptr < mb->end_subject) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 411k| {\ | | 555| 411k| rrc = ra;\ | | 556| 411k| goto RETURN_SWITCH;\ | | 557| 411k| } ------------------ | Branch (5951:9): [True: 411k, False: 26.4k] ------------------ 5952| 26.4k| if (mb->partial != 0) ------------------ | Branch (5952:9): [True: 15.3k, False: 11.1k] ------------------ 5953| 15.3k| { 5954| 15.3k| mb->hitend = TRUE; ------------------ | | 70| 15.3k|#define TRUE 1 ------------------ 5955| 15.3k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 14|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (5955:11): [True: 14, False: 15.3k] ------------------ 5956| 15.3k| } 5957| 26.4k| Fecode++; ------------------ | | 176| 26.4k|#define Fecode F->ecode ------------------ 5958| 26.4k| break; 5959| | 5960| | /* End of subject or ending \n assertion (\Z) */ 5961| | 5962| 58.0k| case OP_EODN: ------------------ | Branch (5962:5): [True: 58.0k, False: 2.33G] ------------------ 5963| 684k| ASSERT_NL_OR_EOS: 5964| 684k| if (Feptr < mb->end_subject && ------------------ | | 177| 684k|#define Feptr F->eptr ------------------ | Branch (5964:9): [True: 633k, False: 50.9k] ------------------ 5965| 684k| (!IS_NEWLINE(Feptr) || Feptr != mb->end_subject - mb->nllen)) ------------------ | | 479| 1.26M| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 633k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 633k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 14.8k, False: 619k] | | ------------------ | | 480| 1.26M| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 29.6k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 14.8k, False: 0] | | ------------------ | | 481| 14.8k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 14.8k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 14.8k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 1.30k, False: 13.5k] | | ------------------ | | 482| 14.8k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 1.26M| : \ | | 484| 1.26M| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 619k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 619k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 619k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 615k, False: 3.67k] | | ------------------ | | 485| 619k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 615k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 615k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 11.3k, False: 603k] | | ------------------ | | 486| 619k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 11.3k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 2.12k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 2.12k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 9.26k, False: 2.12k] | | | Branch (486:30): [True: 832, False: 1.29k] | | ------------------ | | 487| 619k| ) \ | | 488| 1.26M| ) ------------------ (!IS_NEWLINE(Feptr) || Feptr != mb->end_subject - mb->nllen)) ------------------ | | 177| 11.4k|#define Feptr F->eptr ------------------ | Branch (5965:10): [True: 622k, False: 11.4k] | Branch (5965:32): [True: 7.44k, False: 3.95k] ------------------ 5966| 629k| { 5967| 629k| if (mb->partial != 0 && ------------------ | Branch (5967:11): [True: 273k, False: 356k] ------------------ 5968| 629k| Feptr + 1 >= mb->end_subject && ------------------ | | 177| 273k|#define Feptr F->eptr ------------------ | Branch (5968:11): [True: 12.9k, False: 260k] ------------------ 5969| 629k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 12.9k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 642k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (5969:11): [True: 12.5k, False: 393] ------------------ 5970| 629k| NLBLOCK->nllen == 2 && ------------------ | | 59| 12.5k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (5970:11): [True: 989, False: 11.5k] ------------------ 5971| 629k| UCHAR21TEST(Feptr) == NLBLOCK->nl[0]) ------------------ | | 244| 989|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ UCHAR21TEST(Feptr) == NLBLOCK->nl[0]) ------------------ | | 59| 989|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (5971:11): [True: 497, False: 492] ------------------ 5972| 497| { 5973| 497| mb->hitend = TRUE; ------------------ | | 70| 497|#define TRUE 1 ------------------ 5974| 497| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 10|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (5974:13): [True: 10, False: 487] ------------------ 5975| 497| } 5976| 629k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 629k| {\ | | 555| 629k| rrc = ra;\ | | 556| 629k| goto RETURN_SWITCH;\ | | 557| 629k| } ------------------ 5977| 0| } 5978| | 5979| | /* Either at end of string or \n before end. */ 5980| | 5981| 54.9k| if (mb->partial != 0) ------------------ | Branch (5981:9): [True: 24.0k, False: 30.8k] ------------------ 5982| 24.0k| { 5983| 24.0k| mb->hitend = TRUE; ------------------ | | 70| 24.0k|#define TRUE 1 ------------------ 5984| 24.0k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 216|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (5984:11): [True: 216, False: 23.8k] ------------------ 5985| 24.0k| } 5986| 54.6k| Fecode++; ------------------ | | 176| 54.6k|#define Fecode F->ecode ------------------ 5987| 54.6k| break; 5988| | 5989| | 5990| | /* ===================================================================== */ 5991| | /* Start and end of line assertions, multiline mode. */ 5992| | 5993| | /* Start of subject unless notbol, or after any newline except for one at 5994| | the very end, unless PCRE2_ALT_CIRCUMFLEX is set. */ 5995| | 5996| 87.8k| case OP_CIRCM: ------------------ | Branch (5996:5): [True: 87.8k, False: 2.33G] ------------------ 5997| 87.8k| if ((mb->moptions & PCRE2_NOTBOL) != 0 && Feptr == mb->start_subject) ------------------ | | 176| 87.8k|#define PCRE2_NOTBOL 0x00000001u ------------------ if ((mb->moptions & PCRE2_NOTBOL) != 0 && Feptr == mb->start_subject) ------------------ | | 177| 9.81k|#define Feptr F->eptr ------------------ | Branch (5997:9): [True: 9.81k, False: 77.9k] | Branch (5997:47): [True: 685, False: 9.13k] ------------------ 5998| 87.1k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 685| {\ | | 555| 685| rrc = ra;\ | | 556| 685| goto RETURN_SWITCH;\ | | 557| 685| } ------------------ 5999| 87.1k| if (Feptr != mb->start_subject && ------------------ | | 177| 87.1k|#define Feptr F->eptr ------------------ | Branch (5999:9): [True: 78.7k, False: 8.39k] ------------------ 6000| 87.1k| ((Feptr == mb->end_subject && ------------------ | | 177| 78.7k|#define Feptr F->eptr ------------------ | Branch (6000:11): [True: 7.71k, False: 71.0k] ------------------ 6001| 78.7k| (mb->poptions & PCRE2_ALT_CIRCUMFLEX) == 0) || ------------------ | | 140| 7.71k|#define PCRE2_ALT_CIRCUMFLEX 0x00200000u /* J M D */ ------------------ | Branch (6001:12): [True: 3.31k, False: 4.40k] ------------------ 6002| 78.7k| !WAS_NEWLINE(Feptr))) ------------------ | | 493| 75.4k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 75.4k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 75.4k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (493:4): [True: 8.29k, False: 67.1k] | | ------------------ | | 494| 75.4k| ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 59| 8.29k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) > NLBLOCK->PSSTART && \ | | ------------------ | | | | 60| 16.5k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (494:6): [True: 8.29k, False: 0] | | ------------------ | | 495| 8.29k| PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 177| 8.29k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 59| 8.29k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 59| 8.29k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \ | | ------------------ | | | | 60| 8.29k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | | Branch (495:6): [True: 1.80k, False: 6.48k] | | ------------------ | | 496| 8.29k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 8.29k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 497| 75.4k| : \ | | 498| 75.4k| ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 59| 67.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 60| 67.1k|#define PSSTART start_subject /* Field containing processed string start */ | | ------------------ | | ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \ | | ------------------ | | | | 59| 67.1k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (498:6): [True: 66.8k, False: 228] | | ------------------ | | 499| 67.1k| UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 66.8k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 66.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (499:6): [True: 1.42k, False: 65.4k] | | ------------------ | | 500| 67.1k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.42k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 547|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 547|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (500:7): [True: 878, False: 547] | | | Branch (500:30): [True: 217, False: 330] | | ------------------ | | 501| 67.1k| ) \ | | 502| 75.4k| ) ------------------ | Branch (6002:10): [True: 72.5k, False: 2.90k] ------------------ 6003| 75.8k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 75.8k| {\ | | 555| 75.8k| rrc = ra;\ | | 556| 75.8k| goto RETURN_SWITCH;\ | | 557| 75.8k| } ------------------ 6004| 11.2k| Fecode++; ------------------ | | 176| 11.2k|#define Fecode F->ecode ------------------ 6005| 11.2k| break; 6006| | 6007| | /* Assert before any newline, or before end of subject unless noteol is 6008| | set. */ 6009| | 6010| 309k| case OP_DOLLM: ------------------ | Branch (6010:5): [True: 309k, False: 2.33G] ------------------ 6011| 309k| if (Feptr < mb->end_subject) ------------------ | | 177| 309k|#define Feptr F->eptr ------------------ | Branch (6011:9): [True: 282k, False: 26.5k] ------------------ 6012| 282k| { 6013| 282k| if (!IS_NEWLINE(Feptr)) ------------------ | | 479| 282k| ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 59| 282k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((NLBLOCK->nltype != NLTYPE_FIXED)? \ | | ------------------ | | | | 472| 282k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ | | ------------------ | | | Branch (479:4): [True: 14.8k, False: 267k] | | ------------------ | | 480| 282k| ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) < NLBLOCK->PSEND && \ | | ------------------ | | | | 61| 29.6k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (480:6): [True: 14.8k, False: 0] | | ------------------ | | 481| 14.8k| PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 177| 14.8k|#define PRIV(name) _pcre2_##name | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \ | | ------------------ | | | | 61| 14.8k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | | Branch (481:6): [True: 1.12k, False: 13.7k] | | ------------------ | | 482| 14.8k| &(NLBLOCK->nllen), utf)) \ | | ------------------ | | | | 59| 14.8k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | 483| 282k| : \ | | 484| 282k| ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 267k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 61| 267k|#define PSEND end_subject /* Field containing processed string end */ | | ------------------ | | ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \ | | ------------------ | | | | 59| 267k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (484:6): [True: 265k, False: 2.02k] | | ------------------ | | 485| 267k| UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 244| 265k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | UCHAR21TEST(p) == NLBLOCK->nl[0] && \ | | ------------------ | | | | 59| 265k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (485:6): [True: 3.40k, False: 262k] | | ------------------ | | 486| 267k| (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 3.40k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 244| 1.48k|#define UCHAR21TEST(eptr) (*(eptr)) | | ------------------ | | (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ | | ------------------ | | | | 59| 1.48k|#define NLBLOCK mb /* Block containing newline information */ | | ------------------ | | | Branch (486:7): [True: 1.92k, False: 1.48k] | | | Branch (486:30): [True: 811, False: 670] | | ------------------ | | 487| 267k| ) \ | | 488| 282k| ) ------------------ | Branch (6013:11): [True: 278k, False: 3.85k] ------------------ 6014| 278k| { 6015| 278k| if (mb->partial != 0 && ------------------ | Branch (6015:13): [True: 129k, False: 149k] ------------------ 6016| 278k| Feptr + 1 >= mb->end_subject && ------------------ | | 177| 129k|#define Feptr F->eptr ------------------ | Branch (6016:13): [True: 6.46k, False: 123k] ------------------ 6017| 278k| NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 59| 6.46k|#define NLBLOCK mb /* Block containing newline information */ ------------------ NLBLOCK->nltype == NLTYPE_FIXED && ------------------ | | 472| 285k|#define NLTYPE_FIXED 0 /* Newline is a fixed length string */ ------------------ | Branch (6017:13): [True: 6.11k, False: 350] ------------------ 6018| 278k| NLBLOCK->nllen == 2 && ------------------ | | 59| 6.11k|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (6018:13): [True: 867, False: 5.24k] ------------------ 6019| 278k| UCHAR21TEST(Feptr) == NLBLOCK->nl[0]) ------------------ | | 244| 867|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ UCHAR21TEST(Feptr) == NLBLOCK->nl[0]) ------------------ | | 59| 867|#define NLBLOCK mb /* Block containing newline information */ ------------------ | Branch (6019:13): [True: 479, False: 388] ------------------ 6020| 479| { 6021| 479| mb->hitend = TRUE; ------------------ | | 70| 479|#define TRUE 1 ------------------ 6022| 479| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; ------------------ | | 327| 7|#define PCRE2_ERROR_PARTIAL (-2) ------------------ | Branch (6022:15): [True: 7, False: 472] ------------------ 6023| 479| } 6024| 278k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 278k| {\ | | 555| 278k| rrc = ra;\ | | 556| 278k| goto RETURN_SWITCH;\ | | 557| 278k| } ------------------ 6025| 0| } 6026| 282k| } 6027| 26.5k| else 6028| 26.5k| { 6029| 26.5k| if ((mb->moptions & PCRE2_NOTEOL) != 0) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 26.5k|#define PCRE2_NOTEOL 0x00000002u ------------------ if ((mb->moptions & PCRE2_NOTEOL) != 0) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 1.02k| {\ | | 555| 1.02k| rrc = ra;\ | | 556| 1.02k| goto RETURN_SWITCH;\ | | 557| 1.02k| } ------------------ | Branch (6029:11): [True: 1.02k, False: 25.5k] ------------------ 6030| 25.5k| SCHECK_PARTIAL(); ------------------ | | 533| 25.5k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 14.2k, False: 11.3k] | | ------------------ | | 534| 25.5k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 14.2k|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 2.34k, False: 11.8k] | | | Branch (534:38): [True: 4.83k, False: 7.02k] | | ------------------ | | 535| 25.5k| { \ | | 536| 7.17k| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 7.17k|#define TRUE 1 | | ------------------ | | 537| 7.17k| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 21|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 21, False: 7.15k] | | ------------------ | | 538| 7.17k| } ------------------ 6031| 25.4k| } 6032| 29.3k| Fecode++; ------------------ | | 176| 29.3k|#define Fecode F->ecode ------------------ 6033| 29.3k| break; 6034| | 6035| | 6036| | /* ===================================================================== */ 6037| | /* Start of match assertion */ 6038| | 6039| 1.31k| case OP_SOM: ------------------ | Branch (6039:5): [True: 1.31k, False: 2.33G] ------------------ 6040| 1.31k| if (Feptr != mb->start_subject + mb->start_offset) RRETURN(MATCH_NOMATCH); ------------------ | | 177| 1.31k|#define Feptr F->eptr ------------------ if (Feptr != mb->start_subject + mb->start_offset) RRETURN(MATCH_NOMATCH); ------------------ | | 554| 579| {\ | | 555| 579| rrc = ra;\ | | 556| 579| goto RETURN_SWITCH;\ | | 557| 579| } ------------------ | Branch (6040:9): [True: 579, False: 731] ------------------ 6041| 731| Fecode++; ------------------ | | 176| 731|#define Fecode F->ecode ------------------ 6042| 731| break; 6043| | 6044| | 6045| | /* ===================================================================== */ 6046| | /* Reset the start of match point */ 6047| | 6048| 2.83k| case OP_SET_SOM: ------------------ | Branch (6048:5): [True: 2.83k, False: 2.33G] ------------------ 6049| 2.83k| Fstart_match = Feptr; ------------------ | | 183| 2.83k|#define Fstart_match F->start_match ------------------ Fstart_match = Feptr; ------------------ | | 177| 2.83k|#define Feptr F->eptr ------------------ 6050| 2.83k| Fecode++; ------------------ | | 176| 2.83k|#define Fecode F->ecode ------------------ 6051| 2.83k| break; 6052| | 6053| | 6054| | /* ===================================================================== */ 6055| | /* Word boundary assertions. Find out if the previous and current 6056| | characters are "word" characters. It takes a bit more work in UTF mode. 6057| | Characters > 255 are assumed to be "non-word" characters when PCRE2_UCP is 6058| | not set. When it is set, use Unicode properties if available, even when not 6059| | in UTF mode. Remember the earliest and latest consulted characters. */ 6060| | 6061| 36.7k| case OP_NOT_WORD_BOUNDARY: ------------------ | Branch (6061:5): [True: 36.7k, False: 2.33G] ------------------ 6062| 165k| case OP_WORD_BOUNDARY: ------------------ | Branch (6062:5): [True: 128k, False: 2.33G] ------------------ 6063| 271k| case OP_NOT_UCP_WORD_BOUNDARY: ------------------ | Branch (6063:5): [True: 106k, False: 2.33G] ------------------ 6064| 446k| case OP_UCP_WORD_BOUNDARY: ------------------ | Branch (6064:5): [True: 175k, False: 2.33G] ------------------ 6065| 446k| if (Feptr == mb->check_subject) prev_is_word = FALSE; else ------------------ | | 177| 446k|#define Feptr F->eptr ------------------ if (Feptr == mb->check_subject) prev_is_word = FALSE; else ------------------ | | 69| 40.5k|#define FALSE 0 ------------------ | Branch (6065:9): [True: 40.5k, False: 406k] ------------------ 6066| 406k| { 6067| 406k| PCRE2_SPTR lastptr = Feptr - 1; ------------------ | | 814| 406k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 406k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 406k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 406k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR lastptr = Feptr - 1; ------------------ | | 177| 406k|#define Feptr F->eptr ------------------ 6068| 406k|#ifdef SUPPORT_UNICODE 6069| 406k| if (utf) ------------------ | Branch (6069:11): [True: 263k, False: 143k] ------------------ 6070| 263k| { 6071| 263k| BACKCHAR(lastptr); ------------------ | | 345| 269k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 6.32k, False: 263k] | | ------------------ ------------------ 6072| 263k| GETCHAR(fc, lastptr); ------------------ | | 302| 263k| c = *eptr; \ | | 303| 263k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 3.01k| { \ | | | | 267| 3.01k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 899, False: 2.11k] | | | | ------------------ | | | | 268| 3.01k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 3.01k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 921, False: 1.19k] | | | | ------------------ | | | | 270| 2.11k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 2.11k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 1.19k, False: 0] | | | | ------------------ | | | | 272| 1.19k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 1.19k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 1.19k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 3.01k| } | | ------------------ | | | Branch (303:7): [True: 3.01k, False: 260k] | | ------------------ ------------------ 6073| 263k| } 6074| 143k| else 6075| 143k|#endif /* SUPPORT_UNICODE */ 6076| 143k| fc = *lastptr; 6077| 406k| if (lastptr < mb->start_used_ptr) mb->start_used_ptr = lastptr; ------------------ | Branch (6077:11): [True: 13.7k, False: 392k] ------------------ 6078| 406k|#ifdef SUPPORT_UNICODE 6079| 406k| if (Fop == OP_UCP_WORD_BOUNDARY || Fop == OP_NOT_UCP_WORD_BOUNDARY) ------------------ | | 186| 406k|#define Fop F->op ------------------ if (Fop == OP_UCP_WORD_BOUNDARY || Fop == OP_NOT_UCP_WORD_BOUNDARY) ------------------ | | 186| 247k|#define Fop F->op ------------------ | Branch (6079:11): [True: 158k, False: 247k] | Branch (6079:42): [True: 93.9k, False: 153k] ------------------ 6080| 252k| { 6081| 252k| if (fc == '_') prev_is_word = TRUE; else ------------------ | | 70| 708|#define TRUE 1 ------------------ | Branch (6081:13): [True: 708, False: 251k] ------------------ 6082| 251k| { 6083| 251k| int cat = UCD_CATEGORY(fc); ------------------ | | 1859| 251k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 251k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 251k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 251k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 251k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 251k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 251k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 251k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 251k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 251k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 251k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 251k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 251k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6084| 251k| prev_is_word = (cat == ucp_L || cat == ucp_N); ------------------ | Branch (6084:27): [True: 81.2k, False: 170k] | Branch (6084:43): [True: 35.3k, False: 135k] ------------------ 6085| 251k| } 6086| 252k| } 6087| 153k| else 6088| 153k|#endif /* SUPPORT_UNICODE */ 6089| 153k| prev_is_word = CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0; ------------------ | | 217| 307k|#define CHMAX_255(c) ((c) <= 255u) | | ------------------ | | | Branch (217:22): [True: 153k, False: 670] | | ------------------ ------------------ prev_is_word = CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0; ------------------ | | 583| 153k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (6089:39): [True: 73.9k, False: 79.3k] ------------------ 6090| 406k| } 6091| | 6092| | /* Get status of next character */ 6093| | 6094| 446k| if (Feptr >= mb->end_subject) ------------------ | | 177| 446k|#define Feptr F->eptr ------------------ | Branch (6094:9): [True: 26.1k, False: 420k] ------------------ 6095| 26.1k| { 6096| 26.1k| SCHECK_PARTIAL(); ------------------ | | 533| 26.1k| if (mb->partial != 0 && \ | | ------------------ | | | Branch (533:7): [True: 687, False: 25.4k] | | ------------------ | | 534| 26.1k| (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \ | | ------------------ | | | | 177| 687|#define Feptr F->eptr | | ------------------ | | | Branch (534:8): [True: 687, False: 0] | | | Branch (534:38): [True: 0, False: 0] | | ------------------ | | 535| 26.1k| { \ | | 536| 687| mb->hitend = TRUE; \ | | ------------------ | | | | 70| 687|#define TRUE 1 | | ------------------ | | 537| 687| if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \ | | ------------------ | | | | 327| 137|#define PCRE2_ERROR_PARTIAL (-2) | | ------------------ | | | Branch (537:9): [True: 137, False: 550] | | ------------------ | | 538| 687| } ------------------ 6097| 25.9k| cur_is_word = FALSE; ------------------ | | 69| 25.9k|#define FALSE 0 ------------------ 6098| 25.9k| } 6099| 420k| else 6100| 420k| { 6101| 420k| PCRE2_SPTR nextptr = Feptr + 1; ------------------ | | 814| 420k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 420k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 420k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 420k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR nextptr = Feptr + 1; ------------------ | | 177| 420k|#define Feptr F->eptr ------------------ 6102| 420k|#ifdef SUPPORT_UNICODE 6103| 420k| if (utf) ------------------ | Branch (6103:11): [True: 269k, False: 150k] ------------------ 6104| 269k| { 6105| 269k| FORWARDCHARTEST(nextptr, mb->end_subject); ------------------ | | 349| 275k|#define FORWARDCHARTEST(eptr,end) while(eptr < end && (*eptr & 0xc0u) == 0x80u) eptr++ | | ------------------ | | | Branch (349:41): [True: 261k, False: 13.9k] | | | Branch (349:55): [True: 5.78k, False: 255k] | | ------------------ ------------------ 6106| 269k| GETCHAR(fc, Feptr); ------------------ | | 302| 269k| c = *eptr; \ | | 303| 269k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 2.77k| { \ | | | | 267| 2.77k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 780, False: 1.99k] | | | | ------------------ | | | | 268| 2.77k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 2.77k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 989, False: 1.00k] | | | | ------------------ | | | | 270| 1.99k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 1.99k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 1.00k, False: 0] | | | | ------------------ | | | | 272| 1.00k| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 1.00k| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 1.00k| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 2.77k| } | | ------------------ | | | Branch (303:7): [True: 2.77k, False: 267k] | | ------------------ ------------------ 6107| 269k| } 6108| 150k| else 6109| 150k|#endif /* SUPPORT_UNICODE */ 6110| 150k| fc = *Feptr; ------------------ | | 177| 150k|#define Feptr F->eptr ------------------ 6111| 420k| if (nextptr > mb->last_used_ptr) mb->last_used_ptr = nextptr; ------------------ | Branch (6111:11): [True: 19.6k, False: 401k] ------------------ 6112| 420k|#ifdef SUPPORT_UNICODE 6113| 420k| if (Fop == OP_UCP_WORD_BOUNDARY || Fop == OP_NOT_UCP_WORD_BOUNDARY) ------------------ | | 186| 420k|#define Fop F->op ------------------ if (Fop == OP_UCP_WORD_BOUNDARY || Fop == OP_NOT_UCP_WORD_BOUNDARY) ------------------ | | 186| 253k|#define Fop F->op ------------------ | Branch (6113:11): [True: 167k, False: 253k] | Branch (6113:42): [True: 92.2k, False: 160k] ------------------ 6114| 259k| { 6115| 259k| if (fc == '_') cur_is_word = TRUE; else ------------------ | | 70| 546|#define TRUE 1 ------------------ | Branch (6115:13): [True: 546, False: 259k] ------------------ 6116| 259k| { 6117| 259k| int cat = UCD_CATEGORY(fc); ------------------ | | 1859| 259k|#define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 177| 259k|#define PRIV(name) _pcre2_##name | | ------------------ | | #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)] | | ------------------ | | | | 1857| 259k|#define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype | | | | ------------------ | | | | | | 1846| 259k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | | | ------------------ | | | | | | | | 1838| 259k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | | | ------------------ | | | | | | | | | | 177| 259k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | 1839| 259k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 259k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 177| 259k|#define PRIV(name) _pcre2_##name | | | | | | | | ------------------ | | | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | | | ------------------ | | | | | | | | | | 1837| 259k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | 1840| 259k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 259k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | | | ------------------ | | | | | | | | | | 1837| 259k|#define UCD_BLOCK_SIZE 128 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6118| 259k| cur_is_word = (cat == ucp_L || cat == ucp_N); ------------------ | Branch (6118:26): [True: 77.1k, False: 182k] | Branch (6118:42): [True: 34.4k, False: 147k] ------------------ 6119| 259k| } 6120| 259k| } 6121| 160k| else 6122| 160k|#endif /* SUPPORT_UNICODE */ 6123| 160k| cur_is_word = CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0; ------------------ | | 217| 321k|#define CHMAX_255(c) ((c) <= 255u) | | ------------------ | | | Branch (217:22): [True: 160k, False: 654] | | ------------------ ------------------ cur_is_word = CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0; ------------------ | | 583| 160k|#define ctype_word 0x10 /* alphanumeric or '_' */ ------------------ | Branch (6123:38): [True: 68.2k, False: 92.0k] ------------------ 6124| 420k| } 6125| | 6126| | /* Now see if the situation is what we want */ 6127| | 6128| 446k| if ((*Fecode++ == OP_WORD_BOUNDARY || Fop == OP_UCP_WORD_BOUNDARY)? ------------------ | | 176| 446k|#define Fecode F->ecode ------------------ if ((*Fecode++ == OP_WORD_BOUNDARY || Fop == OP_UCP_WORD_BOUNDARY)? ------------------ | | 186| 317k|#define Fop F->op ------------------ | Branch (6128:9): [True: 84.8k, False: 361k] | Branch (6128:10): [True: 128k, False: 317k] | Branch (6128:43): [True: 175k, False: 142k] ------------------ 6129| 304k| cur_is_word == prev_is_word : cur_is_word != prev_is_word) 6130| 361k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 84.8k| {\ | | 555| 84.8k| rrc = ra;\ | | 556| 84.8k| goto RETURN_SWITCH;\ | | 557| 84.8k| } ------------------ 6131| 361k| break; 6132| | 6133| | 6134| | /* ===================================================================== */ 6135| | /* Backtracking (*VERB)s, with and without arguments. Note that if the 6136| | pattern is successfully matched, we do not come back from RMATCH. */ 6137| | 6138| 14.3k| case OP_MARK: ------------------ | Branch (6138:5): [True: 14.3k, False: 2.33G] ------------------ 6139| 14.3k| Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 181| 14.3k|#define Fmark F->mark ------------------ Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 176| 14.3k|#define Fecode F->ecode ------------------ 6140| 14.3k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM12); ------------------ | | 546| 14.3k| {\ | | 547| 14.3k| start_ecode = ra;\ | | 548| 14.3k| Freturn_id = rb;\ | | ------------------ | | | | 188| 14.3k|#define Freturn_id F->return_id | | ------------------ | | 549| 14.3k| goto MATCH_RECURSE;\ | | 550| 14.3k| L_##rb:;\ | | 551| 12.6k| } ------------------ 6141| | 6142| | /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an 6143| | argument, and we must check whether that argument matches this MARK's 6144| | argument. It is passed back in mb->verb_skip_ptr. If it does match, we 6145| | return MATCH_SKIP with mb->verb_skip_ptr now pointing to the subject 6146| | position that corresponds to this mark. Otherwise, pass back the return 6147| | code unaltered. */ 6148| | 6149| 12.6k| if (rrc == MATCH_SKIP_ARG && ------------------ | | 95| 25.3k|#define MATCH_SKIP_ARG (-994) ------------------ | Branch (6149:9): [True: 1.32k, False: 11.3k] ------------------ 6150| 12.6k| PRIV(strcmp)(Fecode + 2, mb->verb_skip_ptr) == 0) ------------------ | | 177| 1.32k|#define PRIV(name) _pcre2_##name ------------------ PRIV(strcmp)(Fecode + 2, mb->verb_skip_ptr) == 0) ------------------ | | 176| 1.32k|#define Fecode F->ecode ------------------ | Branch (6150:14): [True: 249, False: 1.07k] ------------------ 6151| 249| { 6152| 249| mb->verb_skip_ptr = Feptr; /* Pass back current position */ ------------------ | | 177| 249|#define Feptr F->eptr ------------------ 6153| 249| RRETURN(MATCH_SKIP); ------------------ | | 554| 249| {\ | | 555| 249| rrc = ra;\ | | 556| 249| goto RETURN_SWITCH;\ | | 557| 249| } ------------------ 6154| 0| } 6155| 12.6k| RRETURN(rrc); ------------------ | | 554| 12.4k| {\ | | 555| 12.4k| rrc = ra;\ | | 556| 12.4k| goto RETURN_SWITCH;\ | | 557| 12.4k| } ------------------ 6156| | 6157| 17.1k| case OP_FAIL: ------------------ | Branch (6157:5): [True: 17.1k, False: 2.33G] ------------------ 6158| 17.1k| RRETURN(MATCH_NOMATCH); ------------------ | | 554| 17.1k| {\ | | 555| 17.1k| rrc = ra;\ | | 556| 17.1k| goto RETURN_SWITCH;\ | | 557| 17.1k| } ------------------ 6159| | 6160| | /* Record the current recursing group number in mb->verb_current_recurse 6161| | when a backtracking return such as MATCH_COMMIT is given. This enables the 6162| | recurse processing to catch verbs from within the recursion. */ 6163| | 6164| 5.70k| case OP_COMMIT: ------------------ | Branch (6164:5): [True: 5.70k, False: 2.33G] ------------------ 6165| 5.70k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM13); ------------------ | | 546| 5.70k| {\ | | 547| 5.70k| start_ecode = ra;\ | | 548| 5.70k| Freturn_id = rb;\ | | ------------------ | | | | 188| 5.70k|#define Freturn_id F->return_id | | ------------------ | | 549| 5.70k| goto MATCH_RECURSE;\ | | 550| 5.70k| L_##rb:;\ | | 551| 4.23k| } ------------------ 6166| 4.23k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 4.23k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.79k| {\ | | 555| 1.79k| rrc = ra;\ | | 556| 1.79k| goto RETURN_SWITCH;\ | | 557| 1.79k| } ------------------ | Branch (6166:9): [True: 1.79k, False: 2.44k] ------------------ 6167| 2.44k| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 2.44k|#define Fcurrent_recurse F->current_recurse ------------------ 6168| 2.44k| RRETURN(MATCH_COMMIT); ------------------ | | 554| 2.44k| {\ | | 555| 2.44k| rrc = ra;\ | | 556| 2.44k| goto RETURN_SWITCH;\ | | 557| 2.44k| } ------------------ 6169| | 6170| 4.45k| case OP_COMMIT_ARG: ------------------ | Branch (6170:5): [True: 4.45k, False: 2.33G] ------------------ 6171| 4.45k| Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 181| 4.45k|#define Fmark F->mark ------------------ Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 176| 4.45k|#define Fecode F->ecode ------------------ 6172| 4.45k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM36); ------------------ | | 546| 4.45k| {\ | | 547| 4.45k| start_ecode = ra;\ | | 548| 4.45k| Freturn_id = rb;\ | | ------------------ | | | | 188| 4.45k|#define Freturn_id F->return_id | | ------------------ | | 549| 4.45k| goto MATCH_RECURSE;\ | | 550| 4.45k| L_##rb:;\ | | 551| 2.94k| } ------------------ 6173| 2.94k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 2.94k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 2.04k| {\ | | 555| 2.04k| rrc = ra;\ | | 556| 2.04k| goto RETURN_SWITCH;\ | | 557| 2.04k| } ------------------ | Branch (6173:9): [True: 2.04k, False: 906] ------------------ 6174| 906| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 906|#define Fcurrent_recurse F->current_recurse ------------------ 6175| 906| RRETURN(MATCH_COMMIT); ------------------ | | 554| 906| {\ | | 555| 906| rrc = ra;\ | | 556| 906| goto RETURN_SWITCH;\ | | 557| 906| } ------------------ 6176| | 6177| 3.58k| case OP_PRUNE: ------------------ | Branch (6177:5): [True: 3.58k, False: 2.33G] ------------------ 6178| 3.58k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM14); ------------------ | | 546| 3.58k| {\ | | 547| 3.58k| start_ecode = ra;\ | | 548| 3.58k| Freturn_id = rb;\ | | ------------------ | | | | 188| 3.58k|#define Freturn_id F->return_id | | ------------------ | | 549| 3.58k| goto MATCH_RECURSE;\ | | 550| 3.58k| L_##rb:;\ | | 551| 3.40k| } ------------------ 6179| 3.40k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 3.40k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.01k| {\ | | 555| 1.01k| rrc = ra;\ | | 556| 1.01k| goto RETURN_SWITCH;\ | | 557| 1.01k| } ------------------ | Branch (6179:9): [True: 1.01k, False: 2.39k] ------------------ 6180| 2.39k| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 2.39k|#define Fcurrent_recurse F->current_recurse ------------------ 6181| 2.39k| RRETURN(MATCH_PRUNE); ------------------ | | 554| 2.39k| {\ | | 555| 2.39k| rrc = ra;\ | | 556| 2.39k| goto RETURN_SWITCH;\ | | 557| 2.39k| } ------------------ 6182| | 6183| 7.16k| case OP_PRUNE_ARG: ------------------ | Branch (6183:5): [True: 7.16k, False: 2.33G] ------------------ 6184| 7.16k| Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 181| 7.16k|#define Fmark F->mark ------------------ Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 176| 7.16k|#define Fecode F->ecode ------------------ 6185| 7.16k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM15); ------------------ | | 546| 7.16k| {\ | | 547| 7.16k| start_ecode = ra;\ | | 548| 7.16k| Freturn_id = rb;\ | | ------------------ | | | | 188| 7.16k|#define Freturn_id F->return_id | | ------------------ | | 549| 7.16k| goto MATCH_RECURSE;\ | | 550| 7.16k| L_##rb:;\ | | 551| 6.20k| } ------------------ 6186| 6.20k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 6.20k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 5.63k| {\ | | 555| 5.63k| rrc = ra;\ | | 556| 5.63k| goto RETURN_SWITCH;\ | | 557| 5.63k| } ------------------ | Branch (6186:9): [True: 5.63k, False: 572] ------------------ 6187| 572| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 572|#define Fcurrent_recurse F->current_recurse ------------------ 6188| 572| RRETURN(MATCH_PRUNE); ------------------ | | 554| 572| {\ | | 555| 572| rrc = ra;\ | | 556| 572| goto RETURN_SWITCH;\ | | 557| 572| } ------------------ 6189| | 6190| 4.72k| case OP_SKIP: ------------------ | Branch (6190:5): [True: 4.72k, False: 2.33G] ------------------ 6191| 4.72k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM16); ------------------ | | 546| 4.72k| {\ | | 547| 4.72k| start_ecode = ra;\ | | 548| 4.72k| Freturn_id = rb;\ | | ------------------ | | | | 188| 4.72k|#define Freturn_id F->return_id | | ------------------ | | 549| 4.72k| goto MATCH_RECURSE;\ | | 550| 4.72k| L_##rb:;\ | | 551| 4.38k| } ------------------ 6192| 4.38k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 4.38k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.98k| {\ | | 555| 1.98k| rrc = ra;\ | | 556| 1.98k| goto RETURN_SWITCH;\ | | 557| 1.98k| } ------------------ | Branch (6192:9): [True: 1.98k, False: 2.40k] ------------------ 6193| 2.40k| mb->verb_skip_ptr = Feptr; /* Pass back current position */ ------------------ | | 177| 2.40k|#define Feptr F->eptr ------------------ 6194| 2.40k| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 2.40k|#define Fcurrent_recurse F->current_recurse ------------------ 6195| 2.40k| RRETURN(MATCH_SKIP); ------------------ | | 554| 2.40k| {\ | | 555| 2.40k| rrc = ra;\ | | 556| 2.40k| goto RETURN_SWITCH;\ | | 557| 2.40k| } ------------------ 6196| | 6197| | /* Note that, for Perl compatibility, SKIP with an argument does NOT set 6198| | nomatch_mark. When a pattern match ends with a SKIP_ARG for which there was 6199| | not a matching mark, we have to re-run the match, ignoring the SKIP_ARG 6200| | that failed and any that precede it (either they also failed, or were not 6201| | triggered). To do this, we maintain a count of executed SKIP_ARGs. If a 6202| | SKIP_ARG gets to top level, the match is re-run with mb->ignore_skip_arg 6203| | set to the count of the one that failed. */ 6204| | 6205| 3.16M| case OP_SKIP_ARG: ------------------ | Branch (6205:5): [True: 3.16M, False: 2.33G] ------------------ 6206| 3.16M| mb->skip_arg_count++; 6207| 3.16M| if (mb->skip_arg_count <= mb->ignore_skip_arg) ------------------ | Branch (6207:9): [True: 2.88M, False: 279k] ------------------ 6208| 2.88M| { 6209| 2.88M| Fecode += PRIV(OP_lengths)[*Fecode] + Fecode[1]; ------------------ | | 176| 2.88M|#define Fecode F->ecode ------------------ Fecode += PRIV(OP_lengths)[*Fecode] + Fecode[1]; ------------------ | | 177| 2.88M|#define PRIV(name) _pcre2_##name ------------------ Fecode += PRIV(OP_lengths)[*Fecode] + Fecode[1]; ------------------ | | 176| 2.88M|#define Fecode F->ecode ------------------ Fecode += PRIV(OP_lengths)[*Fecode] + Fecode[1]; ------------------ | | 176| 2.88M|#define Fecode F->ecode ------------------ 6210| 2.88M| break; 6211| 2.88M| } 6212| 279k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM17); ------------------ | | 546| 279k| {\ | | 547| 279k| start_ecode = ra;\ | | 548| 279k| Freturn_id = rb;\ | | ------------------ | | | | 188| 279k|#define Freturn_id F->return_id | | ------------------ | | 549| 279k| goto MATCH_RECURSE;\ | | 550| 279k| L_##rb:;\ | | 551| 277k| } ------------------ 6213| 277k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 277k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 7.08k| {\ | | 555| 7.08k| rrc = ra;\ | | 556| 7.08k| goto RETURN_SWITCH;\ | | 557| 7.08k| } ------------------ | Branch (6213:9): [True: 7.08k, False: 270k] ------------------ 6214| | 6215| | /* Pass back the current skip name and return the special MATCH_SKIP_ARG 6216| | return code. This will either be caught by a matching MARK, or get to the 6217| | top, where it causes a rematch with mb->ignore_skip_arg set to the value of 6218| | mb->skip_arg_count. */ 6219| | 6220| 270k| mb->verb_skip_ptr = Fecode + 2; ------------------ | | 176| 270k|#define Fecode F->ecode ------------------ 6221| 270k| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 270k|#define Fcurrent_recurse F->current_recurse ------------------ 6222| 270k| RRETURN(MATCH_SKIP_ARG); ------------------ | | 554| 270k| {\ | | 555| 270k| rrc = ra;\ | | 556| 270k| goto RETURN_SWITCH;\ | | 557| 270k| } ------------------ 6223| | 6224| | /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that 6225| | the branch in which it occurs can be determined. */ 6226| | 6227| 7.14k| case OP_THEN: ------------------ | Branch (6227:5): [True: 7.14k, False: 2.33G] ------------------ 6228| 7.14k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM18); ------------------ | | 546| 7.14k| {\ | | 547| 7.14k| start_ecode = ra;\ | | 548| 7.14k| Freturn_id = rb;\ | | ------------------ | | | | 188| 7.14k|#define Freturn_id F->return_id | | ------------------ | | 549| 7.14k| goto MATCH_RECURSE;\ | | 550| 7.14k| L_##rb:;\ | | 551| 6.67k| } ------------------ 6229| 6.67k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 6.67k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 1.59k| {\ | | 555| 1.59k| rrc = ra;\ | | 556| 1.59k| goto RETURN_SWITCH;\ | | 557| 1.59k| } ------------------ | Branch (6229:9): [True: 1.59k, False: 5.07k] ------------------ 6230| 5.07k| mb->verb_ecode_ptr = Fecode; ------------------ | | 176| 5.07k|#define Fecode F->ecode ------------------ 6231| 5.07k| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 5.07k|#define Fcurrent_recurse F->current_recurse ------------------ 6232| 5.07k| RRETURN(MATCH_THEN); ------------------ | | 554| 5.07k| {\ | | 555| 5.07k| rrc = ra;\ | | 556| 5.07k| goto RETURN_SWITCH;\ | | 557| 5.07k| } ------------------ 6233| | 6234| 7.94k| case OP_THEN_ARG: ------------------ | Branch (6234:5): [True: 7.94k, False: 2.33G] ------------------ 6235| 7.94k| Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 181| 7.94k|#define Fmark F->mark ------------------ Fmark = mb->nomatch_mark = Fecode + 2; ------------------ | | 176| 7.94k|#define Fecode F->ecode ------------------ 6236| 7.94k| RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM19); ------------------ | | 546| 7.94k| {\ | | 547| 7.94k| start_ecode = ra;\ | | 548| 7.94k| Freturn_id = rb;\ | | ------------------ | | | | 188| 7.94k|#define Freturn_id F->return_id | | ------------------ | | 549| 7.94k| goto MATCH_RECURSE;\ | | 550| 7.94k| L_##rb:;\ | | 551| 4.73k| } ------------------ 6237| 4.73k| if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 83| 4.73k|#define MATCH_NOMATCH 0 ------------------ if (rrc != MATCH_NOMATCH) RRETURN(rrc); ------------------ | | 554| 3.59k| {\ | | 555| 3.59k| rrc = ra;\ | | 556| 3.59k| goto RETURN_SWITCH;\ | | 557| 3.59k| } ------------------ | Branch (6237:9): [True: 3.59k, False: 1.13k] ------------------ 6238| 1.13k| mb->verb_ecode_ptr = Fecode; ------------------ | | 176| 1.13k|#define Fecode F->ecode ------------------ 6239| 1.13k| mb->verb_current_recurse = Fcurrent_recurse; ------------------ | | 175| 1.13k|#define Fcurrent_recurse F->current_recurse ------------------ 6240| 1.13k| RRETURN(MATCH_THEN); ------------------ | | 554| 1.13k| {\ | | 555| 1.13k| rrc = ra;\ | | 556| 1.13k| goto RETURN_SWITCH;\ | | 557| 1.13k| } ------------------ 6241| | 6242| | 6243| | /* ===================================================================== */ 6244| | /* There's been some horrible disaster. Arrival here can only mean there is 6245| | something seriously wrong in the code above or the OP_xxx definitions. */ 6246| | 6247| 0| default: ------------------ | Branch (6247:5): [True: 0, False: 2.33G] ------------------ 6248| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 6249| 2.33G| } 6250| | 6251| | /* Do not insert any code in here without much thought; it is assumed 6252| | that "continue" in the code above comes out to here to repeat the main 6253| | loop. */ 6254| | 6255| 2.33G| } /* End of main loop */ 6256| |/* Control never reaches here */ 6257| | 6258| | 6259| |/* ========================================================================= */ 6260| |/* The RRETURN() macro jumps here. The number that is saved in Freturn_id 6261| |indicates which label we actually want to return to. The value in Frdepth is 6262| |the index number of the frame in the vector. The return value has been placed 6263| |in rrc. */ 6264| | 6265| 0|#define LBL(val) case val: goto L_RM##val; 6266| | 6267| 13.7M|RETURN_SWITCH: 6268| 13.7M|if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 13.7M|#define Feptr F->eptr ------------------ if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr; ------------------ | | 177| 934k|#define Feptr F->eptr ------------------ | Branch (6268:5): [True: 934k, False: 12.7M] ------------------ 6269| 13.7M|if (Frdepth == 0) return rrc; /* Exit from the top level */ ------------------ | | 182| 13.7M|#define Frdepth F->rdepth ------------------ | Branch (6269:5): [True: 971k, False: 12.7M] ------------------ 6270| 12.7M|F = (heapframe *)((char *)F - Fback_frame); /* Backtrack */ ------------------ | | 173| 12.7M|#define Fback_frame F->back_frame ------------------ 6271| 12.7M|mb->cb->callout_flags |= PCRE2_CALLOUT_BACKTRACK; /* Note for callouts */ ------------------ | | 519| 12.7M|#define PCRE2_CALLOUT_BACKTRACK 0x00000002u /* Set after a backtrack */ ------------------ 6272| | 6273| |#ifdef DEBUG_SHOW_RMATCH 6274| |fprintf(stderr, "++ RETURN %d to %d\n", rrc, Freturn_id); 6275| |#endif 6276| | 6277| 12.7M|switch (Freturn_id) ------------------ | | 188| 12.7M|#define Freturn_id F->return_id ------------------ 6278| 12.7M| { 6279| 6.98M| LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 1.26M|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 1.26M, False: 11.4M] | | ------------------ ------------------ LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 6.98M|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 6.98M, False: 5.78M] | | ------------------ ------------------ LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 138k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 138k, False: 12.6M] | | ------------------ ------------------ LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 159k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 159k, False: 12.6M] | | ------------------ ------------------ LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 59.8k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 59.8k, False: 12.7M] | | ------------------ ------------------ LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 4.70k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 4.70k, False: 12.7M] | | ------------------ ------------------ LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 20.2k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 20.2k, False: 12.7M] | | ------------------ ------------------ LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8) ------------------ | | 6265| 98.9k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 98.9k, False: 12.6M] | | ------------------ ------------------ 6280| 182k| LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 34.6k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 34.6k, False: 12.7M] | | ------------------ ------------------ LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 9.35k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 9.35k, False: 12.7M] | | ------------------ ------------------ LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 182k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 182k, False: 12.5M] | | ------------------ ------------------ LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 12.6k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 12.6k, False: 12.7M] | | ------------------ ------------------ LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 4.23k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 4.23k, False: 12.7M] | | ------------------ ------------------ LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 3.40k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 3.40k, False: 12.7M] | | ------------------ ------------------ LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 6.20k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 6.20k, False: 12.7M] | | ------------------ ------------------ LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16) ------------------ | | 6265| 4.38k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 4.38k, False: 12.7M] | | ------------------ ------------------ 6281| 277k| LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 277k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 277k, False: 12.4M] | | ------------------ ------------------ LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 6.67k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 6.67k, False: 12.7M] | | ------------------ ------------------ LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 4.73k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 4.73k, False: 12.7M] | | ------------------ ------------------ LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 4.93k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 4.93k, False: 12.7M] | | ------------------ ------------------ LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 9.21k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 9.21k, False: 12.7M] | | ------------------ ------------------ LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 6.53k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 6.53k, False: 12.7M] | | ------------------ ------------------ LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 22.4k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 22.4k, False: 12.7M] | | ------------------ ------------------ LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24) ------------------ | | 6265| 65.7k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 65.7k, False: 12.6M] | | ------------------ ------------------ 6282| 51.1k| LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 30.5k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 30.5k, False: 12.7M] | | ------------------ ------------------ LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 11.7k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 11.7k, False: 12.7M] | | ------------------ ------------------ LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 30.6k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 30.6k, False: 12.7M] | | ------------------ ------------------ LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 14.7k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 14.7k, False: 12.7M] | | ------------------ ------------------ LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 8.73k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 8.73k, False: 12.7M] | | ------------------ ------------------ LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 4.31k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 4.31k, False: 12.7M] | | ------------------ ------------------ LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 18.2k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 18.2k, False: 12.7M] | | ------------------ ------------------ LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32) ------------------ | | 6265| 51.1k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 51.1k, False: 12.7M] | | ------------------ ------------------ 6283| 850k| LBL(33) LBL(34) LBL(35) LBL(36) ------------------ | | 6265| 163k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 163k, False: 12.5M] | | ------------------ ------------------ LBL(33) LBL(34) LBL(35) LBL(36) ------------------ | | 6265| 850k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 850k, False: 11.9M] | | ------------------ ------------------ LBL(33) LBL(34) LBL(35) LBL(36) ------------------ | | 6265| 1.91k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 1.91k, False: 12.7M] | | ------------------ ------------------ LBL(33) LBL(34) LBL(35) LBL(36) ------------------ | | 6265| 2.94k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 2.94k, False: 12.7M] | | ------------------ ------------------ 6284| | 6285| 0|#ifdef SUPPORT_WIDE_CHARS 6286| 33.2k| LBL(100) LBL(101) ------------------ | | 6265| 33.2k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 33.2k, False: 12.7M] | | ------------------ ------------------ LBL(100) LBL(101) ------------------ | | 6265| 20.8k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 20.8k, False: 12.7M] | | ------------------ ------------------ 6287| 0|#endif 6288| | 6289| 0|#ifdef SUPPORT_UNICODE 6290| 37.2k| LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206) ------------------ | | 6265| 21.8k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 21.8k, False: 12.7M] | | ------------------ ------------------ LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206) ------------------ | | 6265| 19.7k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 19.7k, False: 12.7M] | | ------------------ ------------------ LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206) ------------------ | | 6265| 37.2k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 37.2k, False: 12.7M] | | ------------------ ------------------ LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206) ------------------ | | 6265| 2.39k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 2.39k, False: 12.7M] | | ------------------ ------------------ LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206) ------------------ | | 6265| 14.5k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 14.5k, False: 12.7M] | | ------------------ ------------------ LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206) ------------------ | | 6265| 7.78k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 7.78k, False: 12.7M] | | ------------------ ------------------ LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206) ------------------ | | 6265| 18.3k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 18.3k, False: 12.7M] | | ------------------ ------------------ 6291| 61.4k| LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213) ------------------ | | 6265| 18.8k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 18.8k, False: 12.7M] | | ------------------ ------------------ LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213) ------------------ | | 6265| 34.1k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 34.1k, False: 12.7M] | | ------------------ ------------------ LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213) ------------------ | | 6265| 57.9k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 57.9k, False: 12.7M] | | ------------------ ------------------ LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213) ------------------ | | 6265| 50.7k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 50.7k, False: 12.7M] | | ------------------ ------------------ LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213) ------------------ | | 6265| 33.5k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 33.5k, False: 12.7M] | | ------------------ ------------------ LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213) ------------------ | | 6265| 61.4k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 61.4k, False: 12.7M] | | ------------------ ------------------ LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213) ------------------ | | 6265| 13.4k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 13.4k, False: 12.7M] | | ------------------ ------------------ 6292| 299k| LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220) ------------------ | | 6265| 44.1k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 44.1k, False: 12.7M] | | ------------------ ------------------ LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220) ------------------ | | 6265| 13.1k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 13.1k, False: 12.7M] | | ------------------ ------------------ LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220) ------------------ | | 6265| 23.2k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 23.2k, False: 12.7M] | | ------------------ ------------------ LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220) ------------------ | | 6265| 60.8k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 60.8k, False: 12.7M] | | ------------------ ------------------ LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220) ------------------ | | 6265| 49.6k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 49.6k, False: 12.7M] | | ------------------ ------------------ LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220) ------------------ | | 6265| 299k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 299k, False: 12.4M] | | ------------------ ------------------ LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220) ------------------ | | 6265| 66.1k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 66.1k, False: 12.6M] | | ------------------ ------------------ 6293| 593k| LBL(221) LBL(222) LBL(223) LBL(224) LBL(225) ------------------ | | 6265| 458k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 458k, False: 12.3M] | | ------------------ ------------------ LBL(221) LBL(222) LBL(223) LBL(224) LBL(225) ------------------ | | 6265| 593k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 593k, False: 12.1M] | | ------------------ ------------------ LBL(221) LBL(222) LBL(223) LBL(224) LBL(225) ------------------ | | 6265| 14.7k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 14.7k, False: 12.7M] | | ------------------ ------------------ LBL(221) LBL(222) LBL(223) LBL(224) LBL(225) ------------------ | | 6265| 50.9k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 50.9k, False: 12.7M] | | ------------------ ------------------ LBL(221) LBL(222) LBL(223) LBL(224) LBL(225) ------------------ | | 6265| 67.6k|#define LBL(val) case val: goto L_RM##val; | | ------------------ | | | Branch (6265:18): [True: 67.6k, False: 12.6M] | | ------------------ ------------------ 6294| 0|#endif 6295| | 6296| 0| default: ------------------ | Branch (6296:3): [True: 0, False: 12.7M] ------------------ 6297| 0| return PCRE2_ERROR_INTERNAL; ------------------ | | 384| 0|#define PCRE2_ERROR_INTERNAL (-44) ------------------ 6298| 12.7M| } 6299| 12.7M|#undef LBL 6300| 12.7M|} pcre2_match.c:match_ref: 358| 153k|{ 359| 153k|PCRE2_SPTR p; ------------------ | | 814| 153k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 153k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 153k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 153k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 360| 153k|PCRE2_SIZE length; ------------------ | | 477| 153k|#define PCRE2_SIZE size_t ------------------ 361| 153k|PCRE2_SPTR eptr; ------------------ | | 814| 153k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 153k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 153k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 153k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 362| 153k|PCRE2_SPTR eptr_start; ------------------ | | 814| 153k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 153k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 153k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 153k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 363| | 364| |/* Deal with an unset group. The default is no match, but there is an option to 365| |match an empty string. */ 366| | 367| 153k|if (offset >= Foffset_top || Fovector[offset] == PCRE2_UNSET) ------------------ | | 184| 306k|#define Foffset_top F->offset_top ------------------ if (offset >= Foffset_top || Fovector[offset] == PCRE2_UNSET) ------------------ | | 187| 130k|#define Fovector F->ovector ------------------ if (offset >= Foffset_top || Fovector[offset] == PCRE2_UNSET) ------------------ | | 480| 130k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ | Branch (367:5): [True: 22.3k, False: 130k] | Branch (367:30): [True: 50.4k, False: 80.2k] ------------------ 368| 72.7k| { 369| 72.7k| if ((mb->poptions & PCRE2_MATCH_UNSET_BACKREF) != 0) ------------------ | | 128| 72.7k|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ ------------------ | Branch (369:7): [True: 1.19k, False: 71.5k] ------------------ 370| 1.19k| { 371| 1.19k| *lengthptr = 0; 372| 1.19k| return 0; /* Match */ 373| 1.19k| } 374| 71.5k| else return -1; /* No match */ 375| 72.7k| } 376| | 377| |/* Separate the caseless and UTF cases for speed. */ 378| | 379| 80.2k|eptr = eptr_start = Feptr; ------------------ | | 177| 80.2k|#define Feptr F->eptr ------------------ 380| 80.2k|p = mb->start_subject + Fovector[offset]; ------------------ | | 187| 80.2k|#define Fovector F->ovector ------------------ 381| 80.2k|length = Fovector[offset+1] - Fovector[offset]; ------------------ | | 187| 80.2k|#define Fovector F->ovector ------------------ length = Fovector[offset+1] - Fovector[offset]; ------------------ | | 187| 80.2k|#define Fovector F->ovector ------------------ 382| | 383| 80.2k|if (caseless) ------------------ | Branch (383:5): [True: 29.2k, False: 51.0k] ------------------ 384| 29.2k| { 385| 29.2k|#if defined SUPPORT_UNICODE 386| 29.2k| BOOL utf = (mb->poptions & PCRE2_UTF) != 0; ------------------ | | 138| 29.2k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 387| | 388| 29.2k| if (utf || (mb->poptions & PCRE2_UCP) != 0) ------------------ | | 136| 5.98k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ | Branch (388:7): [True: 23.2k, False: 5.98k] | Branch (388:14): [True: 2.88k, False: 3.09k] ------------------ 389| 26.1k| { 390| 26.1k| PCRE2_SPTR endptr = p + length; ------------------ | | 814| 26.1k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 26.1k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 26.1k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 26.1k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 391| | 392| | /* Match characters up to the end of the reference. NOTE: the number of 393| | code units matched may differ, because in UTF-8 there are some characters 394| | whose upper and lower case codes have different numbers of bytes. For 395| | example, U+023A (2 bytes in UTF-8) is the upper case version of U+2C65 (3 396| | bytes in UTF-8); a sequence of 3 of the former uses 6 bytes, as does a 397| | sequence of two of the latter. It is important, therefore, to check the 398| | length along the reference, not along the subject (earlier code did this 399| | wrong). UCP without uses Unicode properties but without UTF encoding. */ 400| | 401| 35.6k| while (p < endptr) ------------------ | Branch (401:12): [True: 25.0k, False: 10.6k] ------------------ 402| 25.0k| { 403| 25.0k| uint32_t c, d; 404| 25.0k| const ucd_record *ur; 405| 25.0k| if (eptr >= mb->end_subject) return 1; /* Partial match */ ------------------ | Branch (405:11): [True: 5.19k, False: 19.8k] ------------------ 406| | 407| 19.8k| if (utf) ------------------ | Branch (407:11): [True: 16.7k, False: 3.09k] ------------------ 408| 16.7k| { 409| 16.7k| GETCHARINC(c, eptr); ------------------ | | 316| 16.7k| c = *eptr++; \ | | 317| 16.7k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 3.38k| { \ | | | | 289| 3.38k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 2.78k, False: 597] | | | | ------------------ | | | | 290| 3.38k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 3.38k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 224, False: 373] | | | | ------------------ | | | | 292| 597| { \ | | | | 293| 224| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 224| eptr += 2; \ | | | | 295| 224| } \ | | | | 296| 597| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 373, False: 0] | | | | ------------------ | | | | 297| 373| { \ | | | | 298| 373| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 373| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 373| eptr += 3; \ | | | | 301| 373| } \ | | | | 302| 373| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 3.38k| } | | ------------------ | | | Branch (317:7): [True: 3.38k, False: 13.3k] | | ------------------ ------------------ 410| 16.7k| GETCHARINC(d, p); ------------------ | | 316| 16.7k| c = *eptr++; \ | | 317| 16.7k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 849| { \ | | | | 289| 849| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 389, False: 460] | | | | ------------------ | | | | 290| 849| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 849| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 230, False: 230] | | | | ------------------ | | | | 292| 460| { \ | | | | 293| 230| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 230| eptr += 2; \ | | | | 295| 230| } \ | | | | 296| 460| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 230, False: 0] | | | | ------------------ | | | | 297| 230| { \ | | | | 298| 230| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 230| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 230| eptr += 3; \ | | | | 301| 230| } \ | | | | 302| 230| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 849| } | | ------------------ | | | Branch (317:7): [True: 849, False: 15.9k] | | ------------------ ------------------ 411| 16.7k| } 412| 3.09k| else 413| 3.09k| { 414| 3.09k| c = *eptr++; 415| 3.09k| d = *p++; 416| 3.09k| } 417| | 418| 19.8k| ur = GET_UCD(d); ------------------ | | 1846| 19.8k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 19.8k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 19.8k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 19.8k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 19.8k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 19.8k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 19.8k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 19.8k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 19.8k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 19.8k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 419| 19.8k| if (c != d && c != (uint32_t)((int)d + ur->other_case)) ------------------ | Branch (419:11): [True: 13.9k, False: 5.91k] | Branch (419:21): [True: 12.9k, False: 952] ------------------ 420| 12.9k| { 421| 12.9k| const uint32_t *pp = PRIV(ucd_caseless_sets) + ur->caseset; ------------------ | | 177| 12.9k|#define PRIV(name) _pcre2_##name ------------------ 422| 12.9k| for (;;) 423| 18.5k| { 424| 18.5k| if (c < *pp) return -1; /* No match */ ------------------ | Branch (424:15): [True: 10.3k, False: 8.19k] ------------------ 425| 8.19k| if (c == *pp++) break; ------------------ | Branch (425:15): [True: 2.68k, False: 5.51k] ------------------ 426| 8.19k| } 427| 12.9k| } 428| 19.8k| } 429| 26.1k| } 430| 3.09k| else 431| 3.09k|#endif 432| | 433| | /* Not in UTF or UCP mode */ 434| 3.09k| { 435| 4.09k| for (; length > 0; length--) ------------------ | Branch (435:12): [True: 2.97k, False: 1.12k] ------------------ 436| 2.97k| { 437| 2.97k| uint32_t cc, cp; 438| 2.97k| if (eptr >= mb->end_subject) return 1; /* Partial match */ ------------------ | Branch (438:11): [True: 568, False: 2.40k] ------------------ 439| 2.40k| cc = UCHAR21TEST(eptr); ------------------ | | 244| 2.40k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 440| 2.40k| cp = UCHAR21TEST(p); ------------------ | | 244| 2.40k|#define UCHAR21TEST(eptr) (*(eptr)) ------------------ 441| 2.40k| if (TABLE_GET(cp, mb->lcc, cp) != TABLE_GET(cc, mb->lcc, cc)) ------------------ | | 214| 2.40k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ if (TABLE_GET(cp, mb->lcc, cp) != TABLE_GET(cc, mb->lcc, cc)) ------------------ | | 214| 2.40k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ | Branch (441:11): [True: 1.40k, False: 998] ------------------ 442| 1.40k| return -1; /* No match */ 443| 998| p++; 444| 998| eptr++; 445| 998| } 446| 3.09k| } 447| 29.2k| } 448| | 449| |/* In the caseful case, we can just compare the code units, whether or not we 450| |are in UTF and/or UCP mode. When partial matching, we have to do this unit by 451| |unit. */ 452| | 453| 51.0k|else 454| 51.0k| { 455| 51.0k| if (mb->partial != 0) ------------------ | Branch (455:7): [True: 9.17k, False: 41.8k] ------------------ 456| 9.17k| { 457| 11.5k| for (; length > 0; length--) ------------------ | Branch (457:12): [True: 8.82k, False: 2.68k] ------------------ 458| 8.82k| { 459| 8.82k| if (eptr >= mb->end_subject) return 1; /* Partial match */ ------------------ | Branch (459:11): [True: 1.27k, False: 7.54k] ------------------ 460| 7.54k| if (UCHAR21INCTEST(p) != UCHAR21INCTEST(eptr)) return -1; /* No match */ ------------------ | | 246| 7.54k|#define UCHAR21INCTEST(eptr) (*(eptr)++) ------------------ if (UCHAR21INCTEST(p) != UCHAR21INCTEST(eptr)) return -1; /* No match */ ------------------ | | 246| 7.54k|#define UCHAR21INCTEST(eptr) (*(eptr)++) ------------------ | Branch (460:11): [True: 5.21k, False: 2.32k] ------------------ 461| 7.54k| } 462| 9.17k| } 463| | 464| | /* Not partial matching */ 465| | 466| 41.8k| else 467| 41.8k| { 468| 41.8k| if ((PCRE2_SIZE)(mb->end_subject - eptr) < length) return 1; /* Partial */ ------------------ | Branch (468:9): [True: 14.4k, False: 27.3k] ------------------ 469| 27.3k| if (memcmp(p, eptr, CU2BYTES(length)) != 0) return -1; /* No match */ ------------------ | | 545| 27.3k|#define CU2BYTES(x) ((x)*((PCRE2_CODE_UNIT_WIDTH/8))) ------------------ | Branch (469:9): [True: 16.1k, False: 11.2k] ------------------ 470| 11.2k| eptr += length; 471| 11.2k| } 472| 51.0k| } 473| | 474| 25.6k|*lengthptr = eptr - eptr_start; 475| 25.6k|return 0; /* Match */ 476| 80.2k|} pcre2_match.c:do_callout: 269| 621k|{ 270| 621k|int rc; 271| 621k|PCRE2_SIZE save0, save1; ------------------ | | 477| 621k|#define PCRE2_SIZE size_t ------------------ 272| 621k|PCRE2_SIZE *callout_ovector; ------------------ | | 477| 621k|#define PCRE2_SIZE size_t ------------------ 273| 621k|pcre2_callout_block *cb; ------------------ | | 831| 621k|#define pcre2_callout_block PCRE2_SUFFIX(pcre2_callout_block_) | | ------------------ | | | | 986| 621k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 621k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 621k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 274| | 275| 621k|*lengthptr = (*Fecode == OP_CALLOUT)? ------------------ | | 176| 621k|#define Fecode F->ecode ------------------ | Branch (275:14): [True: 612k, False: 8.97k] ------------------ 276| 612k| PRIV(OP_lengths)[OP_CALLOUT] : GET(Fecode, 1 + 2*LINK_SIZE); ------------------ | | 177| 612k|#define PRIV(name) _pcre2_##name ------------------ PRIV(OP_lengths)[OP_CALLOUT] : GET(Fecode, 1 + 2*LINK_SIZE); ------------------ | | 109| 630k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 277| | 278| 621k|if (mb->callout == NULL) return 0; /* No callout function provided */ ------------------ | Branch (278:5): [True: 0, False: 621k] ------------------ 279| | 280| |/* The original matching code (pre 10.30) worked directly with the ovector 281| |passed by the user, and this was passed to callouts. Now that the working 282| |ovector is in the backtracking frame, it no longer needs to reserve space for 283| |the overall match offsets (which would waste space in the frame). For backward 284| |compatibility, however, we pass capture_top and offset_vector to the callout as 285| |if for the extended ovector, and we ensure that the first two slots are unset 286| |by preserving and restoring their current contents. Picky compilers complain if 287| |references such as Fovector[-2] are use directly, so we set up a separate 288| |pointer. */ 289| | 290| 621k|callout_ovector = (PCRE2_SIZE *)(Fovector) - 2; ------------------ | | 187| 621k|#define Fovector F->ovector ------------------ 291| | 292| |/* The cb->version, cb->subject, cb->subject_length, and cb->start_match fields 293| |are set externally. The first 3 never change; the last is updated for each 294| |bumpalong. */ 295| | 296| 621k|cb = mb->cb; 297| 621k|cb->capture_top = (uint32_t)Foffset_top/2 + 1; ------------------ | | 184| 621k|#define Foffset_top F->offset_top ------------------ 298| 621k|cb->capture_last = Fcapture_last; ------------------ | | 174| 621k|#define Fcapture_last F->capture_last ------------------ 299| 621k|cb->offset_vector = callout_ovector; 300| 621k|cb->mark = mb->nomatch_mark; 301| 621k|cb->current_position = (PCRE2_SIZE)(Feptr - mb->start_subject); ------------------ | | 177| 621k|#define Feptr F->eptr ------------------ 302| 621k|cb->pattern_position = GET(Fecode, 1); ------------------ | | 109| 621k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 303| 621k|cb->next_item_length = GET(Fecode, 1 + LINK_SIZE); ------------------ | | 109| 621k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 304| | 305| 621k|if (*Fecode == OP_CALLOUT) /* Numerical callout */ ------------------ | | 176| 621k|#define Fecode F->ecode ------------------ | Branch (305:5): [True: 612k, False: 8.97k] ------------------ 306| 612k| { 307| 612k| cb->callout_number = Fecode[1 + 2*LINK_SIZE]; ------------------ | | 176| 612k|#define Fecode F->ecode ------------------ cb->callout_number = Fecode[1 + 2*LINK_SIZE]; ------------------ | | 165| 612k|#define LINK_SIZE 2 ------------------ 308| 612k| cb->callout_string_offset = 0; 309| 612k| cb->callout_string = NULL; 310| 612k| cb->callout_string_length = 0; 311| 612k| } 312| 8.97k|else /* String callout */ 313| 8.97k| { 314| 8.97k| cb->callout_number = 0; 315| 8.97k| cb->callout_string_offset = GET(Fecode, 1 + 3*LINK_SIZE); ------------------ | | 109| 8.97k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 316| 8.97k| cb->callout_string = Fecode + (1 + 4*LINK_SIZE) + 1; ------------------ | | 176| 8.97k|#define Fecode F->ecode ------------------ cb->callout_string = Fecode + (1 + 4*LINK_SIZE) + 1; ------------------ | | 165| 8.97k|#define LINK_SIZE 2 ------------------ 317| 8.97k| cb->callout_string_length = 318| 8.97k| *lengthptr - (1 + 4*LINK_SIZE) - 2; ------------------ | | 165| 8.97k|#define LINK_SIZE 2 ------------------ 319| 8.97k| } 320| | 321| 621k|save0 = callout_ovector[0]; 322| 621k|save1 = callout_ovector[1]; 323| 621k|callout_ovector[0] = callout_ovector[1] = PCRE2_UNSET; ------------------ | | 480| 621k|#define PCRE2_UNSET (~(PCRE2_SIZE)0) ------------------ 324| 621k|rc = mb->callout(cb, mb->callout_data); 325| 621k|callout_ovector[0] = save0; 326| 621k|callout_ovector[1] = save1; 327| 621k|cb->callout_flags = 0; 328| 621k|return rc; 329| 621k|} pcre2_match_data_create_8: 59| 34.0k|{ 60| 34.0k|pcre2_match_data *yield; ------------------ | | 838| 34.0k|#define pcre2_match_data PCRE2_SUFFIX(pcre2_match_data_) | | ------------------ | | | | 986| 34.0k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 34.0k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 34.0k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 61| 34.0k|if (oveccount < 1) oveccount = 1; ------------------ | Branch (61:5): [True: 0, False: 34.0k] ------------------ 62| 34.0k|if (oveccount > UINT16_MAX) oveccount = UINT16_MAX; ------------------ | Branch (62:5): [True: 0, False: 34.0k] ------------------ 63| 34.0k|yield = PRIV(memctl_malloc)( ------------------ | | 177| 34.0k|#define PRIV(name) _pcre2_##name ------------------ 64| 34.0k| offsetof(pcre2_match_data, ovector) + 2*oveccount*sizeof(PCRE2_SIZE), 65| 34.0k| (pcre2_memctl *)gcontext); 66| 34.0k|if (yield == NULL) return NULL; ------------------ | Branch (66:5): [True: 0, False: 34.0k] ------------------ 67| 34.0k|yield->oveccount = oveccount; 68| 34.0k|yield->flags = 0; 69| 34.0k|yield->heapframes = NULL; 70| 34.0k|yield->heapframes_size = 0; 71| 34.0k|return yield; 72| 34.0k|} pcre2_match_data_free_8: 99| 34.0k|{ 100| 34.0k|if (match_data != NULL) ------------------ | Branch (100:5): [True: 34.0k, False: 0] ------------------ 101| 34.0k| { 102| 34.0k| if (match_data->heapframes != NULL) ------------------ | Branch (102:7): [True: 34.0k, False: 5] ------------------ 103| 34.0k| match_data->memctl.free(match_data->heapframes, 104| 34.0k| match_data->memctl.memory_data); 105| 34.0k| if ((match_data->flags & PCRE2_MD_COPIED_SUBJECT) != 0) ------------------ | | 542| 34.0k|#define PCRE2_MD_COPIED_SUBJECT 0x01u ------------------ | Branch (105:7): [True: 0, False: 34.0k] ------------------ 106| 0| match_data->memctl.free((void *)match_data->subject, 107| 0| match_data->memctl.memory_data); 108| 34.0k| match_data->memctl.free(match_data, match_data->memctl.memory_data); 109| 34.0k| } 110| 34.0k|} _pcre2_is_newline_8: 81| 457k|{ 82| 457k|uint32_t c; 83| | 84| 457k|#ifdef SUPPORT_UNICODE 85| 457k|if (utf) { GETCHAR(c, ptr); } else c = *ptr; ------------------ | | 302| 125k| c = *eptr; \ | | 303| 125k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 3.29k| { \ | | | | 267| 3.29k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 1.05k, False: 2.23k] | | | | ------------------ | | | | 268| 3.29k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 3.29k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 1.47k, False: 766] | | | | ------------------ | | | | 270| 2.23k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 2.23k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 766, False: 0] | | | | ------------------ | | | | 272| 766| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 766| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 766| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 3.29k| } | | ------------------ | | | Branch (303:7): [True: 3.29k, False: 122k] | | ------------------ ------------------ | Branch (85:5): [True: 125k, False: 331k] ------------------ 86| |#else 87| |(void)utf; 88| |c = *ptr; 89| |#endif /* SUPPORT_UNICODE */ 90| | 91| 457k|if (type == NLTYPE_ANYCRLF) switch(c) ------------------ | | 474| 457k|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ | Branch (91:5): [True: 14.8k, False: 442k] ------------------ 92| 14.8k| { 93| 435| case CHAR_LF: ------------------ | | 973| 435|#define CHAR_LF '\012' ------------------ | Branch (93:3): [True: 435, False: 14.4k] ------------------ 94| 435| *lenptr = 1; 95| 435| return TRUE; ------------------ | | 70| 435|#define TRUE 1 ------------------ 96| | 97| 1.16k| case CHAR_CR: ------------------ | | 972| 1.16k|#define CHAR_CR '\015' ------------------ | Branch (97:3): [True: 1.16k, False: 13.6k] ------------------ 98| 1.16k| *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1; ------------------ | | 973| 954|#define CHAR_LF '\012' ------------------ | Branch (98:14): [True: 954, False: 208] | Branch (98:34): [True: 90, False: 864] ------------------ 99| 1.16k| return TRUE; ------------------ | | 70| 1.16k|#define TRUE 1 ------------------ 100| | 101| 13.2k| default: ------------------ | Branch (101:3): [True: 13.2k, False: 1.59k] ------------------ 102| 13.2k| return FALSE; ------------------ | | 69| 13.2k|#define FALSE 0 ------------------ 103| 14.8k| } 104| | 105| |/* NLTYPE_ANY */ 106| | 107| 442k|else switch(c) 108| 442k| { 109| |#ifdef EBCDIC 110| | case CHAR_NEL: 111| |#endif 112| 9.13k| case CHAR_LF: ------------------ | | 973| 9.13k|#define CHAR_LF '\012' ------------------ | Branch (112:3): [True: 9.13k, False: 433k] ------------------ 113| 10.7k| case CHAR_VT: ------------------ | | 970| 10.7k|#define CHAR_VT '\013' ------------------ | Branch (113:3): [True: 1.61k, False: 441k] ------------------ 114| 13.3k| case CHAR_FF: ------------------ | | 971| 13.3k|#define CHAR_FF '\014' ------------------ | Branch (114:3): [True: 2.58k, False: 440k] ------------------ 115| 13.3k| *lenptr = 1; 116| 13.3k| return TRUE; ------------------ | | 70| 13.3k|#define TRUE 1 ------------------ 117| | 118| 5.85k| case CHAR_CR: ------------------ | | 972| 5.85k|#define CHAR_CR '\015' ------------------ | Branch (118:3): [True: 5.85k, False: 436k] ------------------ 119| 5.85k| *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1; ------------------ | | 973| 3.16k|#define CHAR_LF '\012' ------------------ | Branch (119:14): [True: 3.16k, False: 2.69k] | Branch (119:34): [True: 776, False: 2.38k] ------------------ 120| 5.85k| return TRUE; ------------------ | | 70| 5.85k|#define TRUE 1 ------------------ 121| | 122| 0|#ifndef EBCDIC 123| 0|#if PCRE2_CODE_UNIT_WIDTH == 8 124| 1.57k| case CHAR_NEL: ------------------ | | 975| 1.57k|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (124:3): [True: 1.57k, False: 441k] ------------------ 125| 1.57k| *lenptr = utf? 2 : 1; ------------------ | Branch (125:13): [True: 23, False: 1.55k] ------------------ 126| 1.57k| return TRUE; ------------------ | | 70| 1.57k|#define TRUE 1 ------------------ 127| | 128| 391| case 0x2028: /* LS */ ------------------ | Branch (128:3): [True: 391, False: 442k] ------------------ 129| 904| case 0x2029: /* PS */ ------------------ | Branch (129:3): [True: 513, False: 442k] ------------------ 130| 904| *lenptr = 3; 131| 904| return TRUE; ------------------ | | 70| 904|#define TRUE 1 ------------------ 132| | 133| |#else /* 16-bit or 32-bit code units */ 134| | case CHAR_NEL: 135| | case 0x2028: /* LS */ 136| | case 0x2029: /* PS */ 137| | *lenptr = 1; 138| | return TRUE; 139| |#endif 140| 0|#endif /* Not EBCDIC */ 141| | 142| 421k| default: ------------------ | Branch (142:3): [True: 421k, False: 21.6k] ------------------ 143| 421k| return FALSE; ------------------ | | 69| 421k|#define FALSE 0 ------------------ 144| 442k| } 145| 457k|} _pcre2_was_newline_8: 171| 28.4k|{ 172| 28.4k|uint32_t c; 173| 28.4k|ptr--; 174| | 175| 28.4k|#ifdef SUPPORT_UNICODE 176| 28.4k|if (utf) ------------------ | Branch (176:5): [True: 13.7k, False: 14.7k] ------------------ 177| 13.7k| { 178| 13.7k| BACKCHAR(ptr); ------------------ | | 345| 16.5k|#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr-- | | ------------------ | | | Branch (345:30): [True: 2.80k, False: 13.7k] | | ------------------ ------------------ 179| 13.7k| GETCHAR(c, ptr); ------------------ | | 302| 13.7k| c = *eptr; \ | | 303| 13.7k| if (c >= 0xc0u) GETUTF8(c, eptr); | | ------------------ | | | | 266| 1.43k| { \ | | | | 267| 1.43k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (267:9): [True: 331, False: 1.10k] | | | | ------------------ | | | | 268| 1.43k| c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 269| 1.43k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (269:14): [True: 842, False: 262] | | | | ------------------ | | | | 270| 1.10k| c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 271| 1.10k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (271:14): [True: 262, False: 0] | | | | ------------------ | | | | 272| 262| c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \ | | | | 273| 262| ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \ | | | | 274| 262| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (274:14): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \ | | | | 276| 0| ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \ | | | | 277| 0| (eptr[4] & 0x3fu); \ | | | | 278| 0| else \ | | | | 279| 0| c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \ | | | | 280| 0| ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \ | | | | 281| 0| ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \ | | | | 282| 1.43k| } | | ------------------ | | | Branch (303:7): [True: 1.43k, False: 12.3k] | | ------------------ ------------------ 180| 13.7k| } 181| 14.7k|else c = *ptr; 182| |#else 183| |(void)utf; 184| |c = *ptr; 185| |#endif /* SUPPORT_UNICODE */ 186| | 187| 28.4k|if (type == NLTYPE_ANYCRLF) switch(c) ------------------ | | 474| 28.4k|#define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */ ------------------ | Branch (187:5): [True: 5.27k, False: 23.1k] ------------------ 188| 5.27k| { 189| 454| case CHAR_LF: ------------------ | | 973| 454|#define CHAR_LF '\012' ------------------ | Branch (189:3): [True: 454, False: 4.81k] ------------------ 190| 454| *lenptr = (ptr > startptr && ptr[-1] == CHAR_CR)? 2 : 1; ------------------ | | 972| 454|#define CHAR_CR '\015' ------------------ | Branch (190:14): [True: 454, False: 0] | Branch (190:32): [True: 292, False: 162] ------------------ 191| 454| return TRUE; ------------------ | | 70| 454|#define TRUE 1 ------------------ 192| | 193| 604| case CHAR_CR: ------------------ | | 972| 604|#define CHAR_CR '\015' ------------------ | Branch (193:3): [True: 604, False: 4.66k] ------------------ 194| 604| *lenptr = 1; 195| 604| return TRUE; ------------------ | | 70| 604|#define TRUE 1 ------------------ 196| | 197| 4.21k| default: ------------------ | Branch (197:3): [True: 4.21k, False: 1.05k] ------------------ 198| 4.21k| return FALSE; ------------------ | | 69| 4.21k|#define FALSE 0 ------------------ 199| 5.27k| } 200| | 201| |/* NLTYPE_ANY */ 202| | 203| 23.1k|else switch(c) 204| 23.1k| { 205| 619| case CHAR_LF: ------------------ | | 973| 619|#define CHAR_LF '\012' ------------------ | Branch (205:3): [True: 619, False: 22.5k] ------------------ 206| 619| *lenptr = (ptr > startptr && ptr[-1] == CHAR_CR)? 2 : 1; ------------------ | | 972| 619|#define CHAR_CR '\015' ------------------ | Branch (206:14): [True: 619, False: 0] | Branch (206:32): [True: 15, False: 604] ------------------ 207| 619| return TRUE; ------------------ | | 70| 619|#define TRUE 1 ------------------ 208| | 209| |#ifdef EBCDIC 210| | case CHAR_NEL: 211| |#endif 212| 274| case CHAR_VT: ------------------ | | 970| 274|#define CHAR_VT '\013' ------------------ | Branch (212:3): [True: 274, False: 22.9k] ------------------ 213| 586| case CHAR_FF: ------------------ | | 971| 586|#define CHAR_FF '\014' ------------------ | Branch (213:3): [True: 312, False: 22.8k] ------------------ 214| 2.66k| case CHAR_CR: ------------------ | | 972| 2.66k|#define CHAR_CR '\015' ------------------ | Branch (214:3): [True: 2.07k, False: 21.1k] ------------------ 215| 2.66k| *lenptr = 1; 216| 2.66k| return TRUE; ------------------ | | 70| 2.66k|#define TRUE 1 ------------------ 217| | 218| 0|#ifndef EBCDIC 219| 0|#if PCRE2_CODE_UNIT_WIDTH == 8 220| 204| case CHAR_NEL: ------------------ | | 975| 204|#define CHAR_NEL ((unsigned char)'\x85') ------------------ | Branch (220:3): [True: 204, False: 22.9k] ------------------ 221| 204| *lenptr = utf? 2 : 1; ------------------ | Branch (221:13): [True: 0, False: 204] ------------------ 222| 204| return TRUE; ------------------ | | 70| 204|#define TRUE 1 ------------------ 223| | 224| 232| case 0x2028: /* LS */ ------------------ | Branch (224:3): [True: 232, False: 22.9k] ------------------ 225| 484| case 0x2029: /* PS */ ------------------ | Branch (225:3): [True: 252, False: 22.9k] ------------------ 226| 484| *lenptr = 3; 227| 484| return TRUE; ------------------ | | 70| 484|#define TRUE 1 ------------------ 228| | 229| |#else /* 16-bit or 32-bit code units */ 230| | case CHAR_NEL: 231| | case 0x2028: /* LS */ 232| | case 0x2029: /* PS */ 233| | *lenptr = 1; 234| | return TRUE; 235| |#endif 236| 0|#endif /* Not EBCDIC */ 237| | 238| 19.2k| default: ------------------ | Branch (238:3): [True: 19.2k, False: 3.96k] ------------------ 239| 19.2k| return FALSE; ------------------ | | 69| 19.2k|#define FALSE 0 ------------------ 240| 23.1k| } 241| 28.4k|} _pcre2_ord2utf_8: 82| 185k|{ 83| |/* Convert to UTF-8 */ 84| | 85| 185k|#if PCRE2_CODE_UNIT_WIDTH == 8 86| 185k|int i, j; 87| 314k|for (i = 0; i < PRIV(utf8_table1_size); i++) ------------------ | | 177| 314k|#define PRIV(name) _pcre2_##name ------------------ | Branch (87:13): [True: 314k, False: 0] ------------------ 88| 314k| if ((int)cvalue <= PRIV(utf8_table1)[i]) break; ------------------ | | 177| 314k|#define PRIV(name) _pcre2_##name ------------------ | Branch (88:7): [True: 185k, False: 129k] ------------------ 89| 185k|buffer += i; 90| 314k|for (j = i; j > 0; j--) ------------------ | Branch (90:13): [True: 129k, False: 185k] ------------------ 91| 129k| { 92| 129k| *buffer-- = 0x80 | (cvalue & 0x3f); 93| 129k| cvalue >>= 6; 94| 129k| } 95| 185k|*buffer = PRIV(utf8_table2)[i] | cvalue; ------------------ | | 177| 185k|#define PRIV(name) _pcre2_##name ------------------ 96| 185k|return i + 1; 97| | 98| |/* Convert to UTF-16 */ 99| | 100| |#elif PCRE2_CODE_UNIT_WIDTH == 16 101| |if (cvalue <= 0xffff) 102| | { 103| | *buffer = (PCRE2_UCHAR)cvalue; 104| | return 1; 105| | } 106| |cvalue -= 0x10000; 107| |*buffer++ = 0xd800 | (cvalue >> 10); 108| |*buffer = 0xdc00 | (cvalue & 0x3ff); 109| |return 2; 110| | 111| |/* Convert to UTF-32 */ 112| | 113| |#else 114| |*buffer = (PCRE2_UCHAR)cvalue; 115| |return 1; 116| |#endif 117| 185k|} _pcre2_script_run_8: 86| 23.8k|{ 87| 23.8k|#ifdef SUPPORT_UNICODE 88| 23.8k|uint32_t require_state = SCRIPT_UNSET; 89| 23.8k|uint32_t require_map[FULL_MAPSIZE]; 90| 23.8k|uint32_t map[FULL_MAPSIZE]; 91| 23.8k|uint32_t require_digitset = 0; 92| 23.8k|uint32_t c; 93| | 94| |#if PCRE2_CODE_UNIT_WIDTH == 32 95| |(void)utf; /* Avoid compiler warning */ 96| |#endif 97| | 98| |/* Any string containing fewer than 2 characters is a valid script run. */ 99| | 100| 23.8k|if (ptr >= endptr) return TRUE; ------------------ | | 70| 3.65k|#define TRUE 1 ------------------ | Branch (100:5): [True: 3.65k, False: 20.1k] ------------------ 101| 20.1k|GETCHARINCTEST(c, ptr); ------------------ | | 323| 20.1k| c = *eptr++; \ | | 324| 20.1k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 4.88k| { \ | | | | 289| 4.88k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 817, False: 4.06k] | | | | ------------------ | | | | 290| 4.88k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 4.88k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 3.81k, False: 248] | | | | ------------------ | | | | 292| 4.06k| { \ | | | | 293| 3.81k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 3.81k| eptr += 2; \ | | | | 295| 3.81k| } \ | | | | 296| 4.06k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 248, False: 0] | | | | ------------------ | | | | 297| 248| { \ | | | | 298| 248| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 248| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 248| eptr += 3; \ | | | | 301| 248| } \ | | | | 302| 248| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 4.88k| } | | ------------------ | | | Branch (324:7): [True: 15.8k, False: 4.30k] | | | Branch (324:14): [True: 4.88k, False: 11.0k] | | ------------------ ------------------ 102| 20.1k|if (ptr >= endptr) return TRUE; ------------------ | | 70| 1.67k|#define TRUE 1 ------------------ | Branch (102:5): [True: 1.67k, False: 18.5k] ------------------ 103| | 104| |/* Initialize the require map. This is a full-size bitmap that has a bit for 105| |every script, as opposed to the maps in ucd_script_sets, which only have bits 106| |for scripts less than ucp_Unknown - those that appear in script extension 107| |lists. */ 108| | 109| 129k|for (int i = 0; i < FULL_MAPSIZE; i++) require_map[i] = 0; ------------------ | | 82| 129k|#define FULL_MAPSIZE (ucp_Script_Count/32 + 1) ------------------ | Branch (109:17): [True: 111k, False: 18.5k] ------------------ 110| | 111| |/* Scan strings of two or more characters, checking the Unicode characteristics 112| |of each code point. There is special code for scripts that can be combined with 113| |characters from the Han Chinese script. This may be used in conjunction with 114| |four other scripts in these combinations: 115| | 116| |. Han with Hiragana and Katakana is allowed (for Japanese). 117| |. Han with Bopomofo is allowed (for Taiwanese Mandarin). 118| |. Han with Hangul is allowed (for Korean). 119| | 120| |If the first significant character's script is one of the four, the required 121| |script type is immediately known. However, if the first significant 122| |character's script is Han, we have to keep checking for a non-Han character. 123| |Hence the SCRIPT_HANPENDING state. */ 124| | 125| 18.5k|for (;;) 126| 108k| { 127| 108k| const ucd_record *ucd = GET_UCD(c); ------------------ | | 1846| 108k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 108k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 108k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 108k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 108k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 108k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 108k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 108k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 108k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 108k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 128| 108k| uint32_t script = ucd->script; 129| | 130| | /* If the script is Unknown, the string is not a valid script run. Such 131| | characters can only form script runs of length one (see test above). */ 132| | 133| 108k| if (script == ucp_Unknown) return FALSE; ------------------ | | 69| 1.23k|#define FALSE 0 ------------------ | Branch (133:7): [True: 1.23k, False: 107k] ------------------ 134| | 135| | /* A character without any script extensions whose script is Inherited or 136| | Common is always accepted with any script. If there are extensions, the 137| | following processing happens for all scripts. */ 138| | 139| 107k| if (UCD_SCRIPTX_PROP(ucd) != 0 || (script != ucp_Inherited && script != ucp_Common)) ------------------ | | 1853| 107k|#define UCD_SCRIPTX_PROP(prop) ((prop)->scriptx_bidiclass & UCD_SCRIPTX_MASK) | | ------------------ | | | | 1849| 107k|#define UCD_SCRIPTX_MASK 0x3ff | | ------------------ ------------------ | Branch (139:7): [True: 2.43k, False: 104k] | Branch (139:38): [True: 104k, False: 284] | Branch (139:65): [True: 43.3k, False: 60.9k] ------------------ 140| 45.7k| { 141| 45.7k| BOOL OK; 142| | 143| | /* Set up a full-sized map for this character that can include bits for all 144| | scripts. Copy the scriptx map for this character (which covers those 145| | scripts that appear in script extension lists), set the remaining values to 146| | zero, and then, except for Common or Inherited, add this script's bit to 147| | the map. */ 148| | 149| 45.7k| memcpy(map, PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(ucd), UCD_MAPSIZE * sizeof(uint32_t)); ------------------ | | 177| 45.7k|#define PRIV(name) _pcre2_##name ------------------ memcpy(map, PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(ucd), UCD_MAPSIZE * sizeof(uint32_t)); ------------------ | | 1853| 45.7k|#define UCD_SCRIPTX_PROP(prop) ((prop)->scriptx_bidiclass & UCD_SCRIPTX_MASK) | | ------------------ | | | | 1849| 45.7k|#define UCD_SCRIPTX_MASK 0x3ff | | ------------------ ------------------ memcpy(map, PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(ucd), UCD_MAPSIZE * sizeof(uint32_t)); ------------------ | | 81| 45.7k|#define UCD_MAPSIZE (ucp_Unknown/32 + 1) ------------------ 150| 45.7k| memset(map + UCD_MAPSIZE, 0, (FULL_MAPSIZE - UCD_MAPSIZE) * sizeof(uint32_t)); ------------------ | | 81| 45.7k|#define UCD_MAPSIZE (ucp_Unknown/32 + 1) ------------------ memset(map + UCD_MAPSIZE, 0, (FULL_MAPSIZE - UCD_MAPSIZE) * sizeof(uint32_t)); ------------------ | | 82| 45.7k|#define FULL_MAPSIZE (ucp_Script_Count/32 + 1) ------------------ memset(map + UCD_MAPSIZE, 0, (FULL_MAPSIZE - UCD_MAPSIZE) * sizeof(uint32_t)); ------------------ | | 81| 45.7k|#define UCD_MAPSIZE (ucp_Unknown/32 + 1) ------------------ 151| 45.7k| if (script != ucp_Common && script != ucp_Inherited) MAPSET(map, script); ------------------ | | 1872| 43.3k|#define MAPSET(map,n) ((map)[(n)/32]|=(1u<<((n)%32))) ------------------ | Branch (151:9): [True: 43.5k, False: 2.16k] | Branch (151:33): [True: 43.3k, False: 247] ------------------ 152| | 153| | /* Handle the different checking states */ 154| | 155| 45.7k| switch(require_state) ------------------ | Branch (155:12): [True: 0, False: 45.7k] ------------------ 156| 45.7k| { 157| | /* First significant character - it might follow Common or Inherited 158| | characters that do not have any script extensions. */ 159| | 160| 16.9k| case SCRIPT_UNSET: ------------------ | Branch (160:7): [True: 16.9k, False: 28.8k] ------------------ 161| 16.9k| switch(script) 162| 16.9k| { 163| 1.47k| case ucp_Han: ------------------ | Branch (163:9): [True: 1.47k, False: 15.4k] ------------------ 164| 1.47k| require_state = SCRIPT_HANPENDING; 165| 1.47k| break; 166| | 167| 281| case ucp_Hiragana: ------------------ | Branch (167:9): [True: 281, False: 16.6k] ------------------ 168| 726| case ucp_Katakana: ------------------ | Branch (168:9): [True: 445, False: 16.4k] ------------------ 169| 726| require_state = SCRIPT_HANHIRAKATA; 170| 726| break; 171| | 172| 599| case ucp_Bopomofo: ------------------ | Branch (172:9): [True: 599, False: 16.3k] ------------------ 173| 599| require_state = SCRIPT_HANBOPOMOFO; 174| 599| break; 175| | 176| 554| case ucp_Hangul: ------------------ | Branch (176:9): [True: 554, False: 16.3k] ------------------ 177| 554| require_state = SCRIPT_HANHANGUL; 178| 554| break; 179| | 180| 13.5k| default: ------------------ | Branch (180:9): [True: 13.5k, False: 3.35k] ------------------ 181| 13.5k| memcpy(require_map, map, FULL_MAPSIZE * sizeof(uint32_t)); ------------------ | | 82| 13.5k|#define FULL_MAPSIZE (ucp_Script_Count/32 + 1) ------------------ 182| 13.5k| require_state = SCRIPT_MAP; 183| 13.5k| break; 184| 16.9k| } 185| 16.9k| break; 186| | 187| | /* The first significant character was Han. An inspection of the Unicode 188| | 11.0.0 files shows that there are the following types of Script Extension 189| | list that involve the Han, Bopomofo, Hiragana, Katakana, and Hangul 190| | scripts: 191| | 192| | . Bopomofo + Han 193| | . Han + Hiragana + Katakana 194| | . Hiragana + Katakana 195| | . Bopopmofo + Hangul + Han + Hiragana + Katakana 196| | 197| | The following code tries to make sense of this. */ 198| | 199| 16.9k|#define FOUND_BOPOMOFO 1 200| 16.9k|#define FOUND_HIRAGANA 2 201| 16.9k|#define FOUND_KATAKANA 4 202| 16.9k|#define FOUND_HANGUL 8 203| | 204| 16.9k| case SCRIPT_HANPENDING: ------------------ | Branch (204:7): [True: 2.02k, False: 43.7k] ------------------ 205| 2.02k| if (script != ucp_Han) /* Another Han does nothing */ ------------------ | Branch (205:11): [True: 1.82k, False: 198] ------------------ 206| 1.82k| { 207| 1.82k| uint32_t chspecial = 0; 208| | 209| 1.82k| if (MAPBIT(map, ucp_Bopomofo) != 0) chspecial |= FOUND_BOPOMOFO; ------------------ | | 1871| 1.82k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Bopomofo) != 0) chspecial |= FOUND_BOPOMOFO; ------------------ | | 199| 246|#define FOUND_BOPOMOFO 1 ------------------ | Branch (209:13): [True: 246, False: 1.58k] ------------------ 210| 1.82k| if (MAPBIT(map, ucp_Hiragana) != 0) chspecial |= FOUND_HIRAGANA; ------------------ | | 1871| 1.82k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Hiragana) != 0) chspecial |= FOUND_HIRAGANA; ------------------ | | 200| 390|#define FOUND_HIRAGANA 2 ------------------ | Branch (210:13): [True: 390, False: 1.43k] ------------------ 211| 1.82k| if (MAPBIT(map, ucp_Katakana) != 0) chspecial |= FOUND_KATAKANA; ------------------ | | 1871| 1.82k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Katakana) != 0) chspecial |= FOUND_KATAKANA; ------------------ | | 201| 390|#define FOUND_KATAKANA 4 ------------------ | Branch (211:13): [True: 390, False: 1.43k] ------------------ 212| 1.82k| if (MAPBIT(map, ucp_Hangul) != 0) chspecial |= FOUND_HANGUL; ------------------ | | 1871| 1.82k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Hangul) != 0) chspecial |= FOUND_HANGUL; ------------------ | | 202| 202|#define FOUND_HANGUL 8 ------------------ | Branch (212:13): [True: 202, False: 1.62k] ------------------ 213| | 214| 1.82k| if (chspecial == 0) return FALSE; /* Not allowed with Han */ ------------------ | | 69| 957|#define FALSE 0 ------------------ | Branch (214:13): [True: 957, False: 870] ------------------ 215| | 216| 870| if (chspecial == FOUND_BOPOMOFO) ------------------ | | 199| 870|#define FOUND_BOPOMOFO 1 ------------------ | Branch (216:13): [True: 198, False: 672] ------------------ 217| 198| require_state = SCRIPT_HANBOPOMOFO; 218| 672| else if (chspecial == (FOUND_HIRAGANA|FOUND_KATAKANA)) ------------------ | | 200| 672|#define FOUND_HIRAGANA 2 ------------------ else if (chspecial == (FOUND_HIRAGANA|FOUND_KATAKANA)) ------------------ | | 201| 672|#define FOUND_KATAKANA 4 ------------------ | Branch (218:18): [True: 214, False: 458] ------------------ 219| 214| require_state = SCRIPT_HANHIRAKATA; 220| | 221| | /* Otherwise this character must be allowed with all of them, so remain 222| | in the pending state. */ 223| 870| } 224| 1.06k| break; 225| | 226| | /* Previously encountered one of the "with Han" scripts. Check that 227| | this character is appropriate. */ 228| | 229| 1.33k| case SCRIPT_HANHIRAKATA: ------------------ | Branch (229:7): [True: 1.33k, False: 44.4k] ------------------ 230| 1.33k| if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Hiragana) + ------------------ | | 1871| 1.33k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Hiragana) + ------------------ | | 1871| 1.33k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (230:11): [True: 1.12k, False: 208] ------------------ 231| 1.33k| MAPBIT(map, ucp_Katakana) == 0) return FALSE; ------------------ | | 1871| 1.33k|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ MAPBIT(map, ucp_Katakana) == 0) return FALSE; ------------------ | | 69| 1.12k|#define FALSE 0 ------------------ 232| 208| break; 233| | 234| 985| case SCRIPT_HANBOPOMOFO: ------------------ | Branch (234:7): [True: 985, False: 44.7k] ------------------ 235| 985| if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Bopomofo) == 0) return FALSE; ------------------ | | 1871| 985|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Bopomofo) == 0) return FALSE; ------------------ | | 1871| 985|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Bopomofo) == 0) return FALSE; ------------------ | | 69| 765|#define FALSE 0 ------------------ | Branch (235:11): [True: 765, False: 220] ------------------ 236| 220| break; 237| | 238| 772| case SCRIPT_HANHANGUL: ------------------ | Branch (238:7): [True: 772, False: 44.9k] ------------------ 239| 772| if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Hangul) == 0) return FALSE; ------------------ | | 1871| 772|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Hangul) == 0) return FALSE; ------------------ | | 1871| 772|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Hangul) == 0) return FALSE; ------------------ | | 69| 564|#define FALSE 0 ------------------ | Branch (239:11): [True: 564, False: 208] ------------------ 240| 208| break; 241| | 242| | /* Previously encountered one or more characters that are allowed with a 243| | list of scripts. */ 244| | 245| 23.7k| case SCRIPT_MAP: ------------------ | Branch (245:7): [True: 23.7k, False: 22.0k] ------------------ 246| 23.7k| OK = FALSE; ------------------ | | 69| 23.7k|#define FALSE 0 ------------------ 247| | 248| 55.8k| for (int i = 0; i < FULL_MAPSIZE; i++) ------------------ | | 82| 55.8k|#define FULL_MAPSIZE (ucp_Script_Count/32 + 1) ------------------ | Branch (248:23): [True: 50.5k, False: 5.30k] ------------------ 249| 50.5k| { 250| 50.5k| if ((require_map[i] & map[i]) != 0) ------------------ | Branch (250:13): [True: 18.4k, False: 32.1k] ------------------ 251| 18.4k| { 252| 18.4k| OK = TRUE; ------------------ | | 70| 18.4k|#define TRUE 1 ------------------ 253| 18.4k| break; 254| 18.4k| } 255| 50.5k| } 256| | 257| 23.7k| if (!OK) return FALSE; ------------------ | | 69| 5.30k|#define FALSE 0 ------------------ | Branch (257:11): [True: 5.30k, False: 18.4k] ------------------ 258| | 259| | /* The rest of the string must be in this script, but we have to 260| | allow for the Han complications. */ 261| | 262| 18.4k| switch(script) 263| 18.4k| { 264| 214| case ucp_Han: ------------------ | Branch (264:9): [True: 214, False: 18.2k] ------------------ 265| 214| require_state = SCRIPT_HANPENDING; 266| 214| break; 267| | 268| 245| case ucp_Hiragana: ------------------ | Branch (268:9): [True: 245, False: 18.1k] ------------------ 269| 461| case ucp_Katakana: ------------------ | Branch (269:9): [True: 216, False: 18.2k] ------------------ 270| 461| require_state = SCRIPT_HANHIRAKATA; 271| 461| break; 272| | 273| 230| case ucp_Bopomofo: ------------------ | Branch (273:9): [True: 230, False: 18.1k] ------------------ 274| 230| require_state = SCRIPT_HANBOPOMOFO; 275| 230| break; 276| | 277| 206| case ucp_Hangul: ------------------ | Branch (277:9): [True: 206, False: 18.2k] ------------------ 278| 206| require_state = SCRIPT_HANHANGUL; 279| 206| break; 280| | 281| | /* Compute the intersection of the required list of scripts and the 282| | allowed scripts for this character. */ 283| | 284| 17.3k| default: ------------------ | Branch (284:9): [True: 17.3k, False: 1.11k] ------------------ 285| 121k| for (int i = 0; i < FULL_MAPSIZE; i++) require_map[i] &= map[i]; ------------------ | | 82| 121k|#define FULL_MAPSIZE (ucp_Script_Count/32 + 1) ------------------ | Branch (285:25): [True: 103k, False: 17.3k] ------------------ 286| 17.3k| break; 287| 18.4k| } 288| | 289| 18.4k| break; 290| 45.7k| } 291| 45.7k| } /* End checking character's script and extensions. */ 292| | 293| | /* The character is in an acceptable script. We must now ensure that all 294| | decimal digits in the string come from the same set. Some scripts (e.g. 295| | Common, Arabic) have more than one set of decimal digits. This code does 296| | not allow mixing sets, even within the same script. The vector called 297| | PRIV(ucd_digit_sets)[] contains, in its first element, the number of 298| | following elements, and then, in ascending order, the code points of the 299| | '9' characters in every set of 10 digits. Each set is identified by the 300| | offset in the vector of its '9' character. An initial check of the first 301| | value picks up ASCII digits quickly. Otherwise, a binary chop is used. */ 302| | 303| 98.3k| if (ucd->chartype == ucp_Nd) ------------------ | Branch (303:7): [True: 4.04k, False: 94.2k] ------------------ 304| 4.04k| { 305| 4.04k| uint32_t digitset; 306| | 307| 4.04k| if (c <= PRIV(ucd_digit_sets)[1]) digitset = 1; else ------------------ | | 177| 4.04k|#define PRIV(name) _pcre2_##name ------------------ | Branch (307:9): [True: 2.80k, False: 1.24k] ------------------ 308| 1.24k| { 309| 1.24k| int mid; 310| 1.24k| int bot = 1; 311| 1.24k| int top = PRIV(ucd_digit_sets)[0]; ------------------ | | 177| 1.24k|#define PRIV(name) _pcre2_##name ------------------ 312| 1.24k| for (;;) 313| 8.68k| { 314| 8.68k| if (top <= bot + 1) /* <= rather than == is paranoia */ ------------------ | Branch (314:13): [True: 1.24k, False: 7.44k] ------------------ 315| 1.24k| { 316| 1.24k| digitset = top; 317| 1.24k| break; 318| 1.24k| } 319| 7.44k| mid = (top + bot) / 2; 320| 7.44k| if (c <= PRIV(ucd_digit_sets)[mid]) top = mid; else bot = mid; ------------------ | | 177| 7.44k|#define PRIV(name) _pcre2_##name ------------------ | Branch (320:13): [True: 6.14k, False: 1.30k] ------------------ 321| 7.44k| } 322| 1.24k| } 323| | 324| | /* A required value of 0 means "unset". */ 325| | 326| 4.04k| if (require_digitset == 0) require_digitset = digitset; ------------------ | Branch (326:9): [True: 2.85k, False: 1.18k] ------------------ 327| 1.18k| else if (digitset != require_digitset) return FALSE; ------------------ | | 69| 332|#define FALSE 0 ------------------ | Branch (327:16): [True: 332, False: 856] ------------------ 328| 4.04k| } /* End digit handling */ 329| | 330| | /* If we haven't yet got to the end, pick up the next character. */ 331| | 332| 97.9k| if (ptr >= endptr) return TRUE; ------------------ | | 70| 8.22k|#define TRUE 1 ------------------ | Branch (332:7): [True: 8.22k, False: 89.7k] ------------------ 333| 89.7k| GETCHARINCTEST(c, ptr); ------------------ | | 323| 89.7k| c = *eptr++; \ | | 324| 89.7k| if (utf && c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 10.5k| { \ | | | | 289| 10.5k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 2.83k, False: 7.76k] | | | | ------------------ | | | | 290| 10.5k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 10.5k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 6.85k, False: 910] | | | | ------------------ | | | | 292| 7.76k| { \ | | | | 293| 6.85k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 6.85k| eptr += 2; \ | | | | 295| 6.85k| } \ | | | | 296| 7.76k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 910, False: 0] | | | | ------------------ | | | | 297| 910| { \ | | | | 298| 910| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 910| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 910| eptr += 3; \ | | | | 301| 910| } \ | | | | 302| 910| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 10.5k| } | | ------------------ | | | Branch (324:7): [True: 58.5k, False: 31.2k] | | | Branch (324:14): [True: 10.5k, False: 47.9k] | | ------------------ ------------------ 334| 89.7k| } /* End checking loop */ 335| | 336| |#else /* NOT SUPPORT_UNICODE */ 337| |(void)ptr; 338| |(void)endptr; 339| |(void)utf; 340| |return TRUE; 341| |#endif /* SUPPORT_UNICODE */ 342| 18.5k|} _pcre2_strcmp_8: 103| 1.32k|{ 104| 1.32k|PCRE2_UCHAR c1, c2; ------------------ | | 813| 1.32k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 1.32k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.32k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.32k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 105| 1.73k|while (*str1 != '\0' || *str2 != '\0') ------------------ | Branch (105:8): [True: 912, False: 825] | Branch (105:25): [True: 576, False: 249] ------------------ 106| 1.48k| { 107| 1.48k| c1 = *str1++; 108| 1.48k| c2 = *str2++; 109| 1.48k| if (c1 != c2) return ((c1 > c2) << 1) - 1; ------------------ | Branch (109:7): [True: 1.07k, False: 411] ------------------ 110| 1.48k| } 111| 249|return 0; 112| 1.32k|} _pcre2_strcmp_c8_8: 131| 83.4k|{ 132| 83.4k|PCRE2_UCHAR c1, c2; ------------------ | | 813| 83.4k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 83.4k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 83.4k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 83.4k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 133| 151k|while (*str1 != '\0' || *str2 != '\0') ------------------ | Branch (133:8): [True: 127k, False: 23.8k] | Branch (133:25): [True: 11.8k, False: 12.0k] ------------------ 134| 139k| { 135| 139k| c1 = *str1++; 136| 139k| c2 = *str2++; 137| 139k| if (c1 != c2) return ((c1 > c2) << 1) - 1; ------------------ | Branch (137:7): [True: 71.3k, False: 67.8k] ------------------ 138| 139k| } 139| 12.0k|return 0; 140| 83.4k|} _pcre2_strncmp_8: 158| 255M|{ 159| 255M|PCRE2_UCHAR c1, c2; ------------------ | | 813| 255M|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 255M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 255M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 255M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 160| 509M|for (; len > 0; len--) ------------------ | Branch (160:8): [True: 255M, False: 254M] ------------------ 161| 255M| { 162| 255M| c1 = *str1++; 163| 255M| c2 = *str2++; 164| 255M| if (c1 != c2) return ((c1 > c2) << 1) - 1; ------------------ | Branch (164:7): [True: 1.05M, False: 254M] ------------------ 165| 255M| } 166| 254M|return 0; 167| 255M|} _pcre2_strncmp_c8_8: 187| 519k|{ 188| 519k|PCRE2_UCHAR c1, c2; ------------------ | | 813| 519k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 519k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 519k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 519k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 189| 669k|for (; len > 0; len--) ------------------ | Branch (189:8): [True: 640k, False: 29.7k] ------------------ 190| 640k| { 191| 640k| c1 = *str1++; 192| 640k| c2 = *str2++; 193| 640k| if (c1 != c2) return ((c1 > c2) << 1) - 1; ------------------ | Branch (193:7): [True: 489k, False: 150k] ------------------ 194| 640k| } 195| 29.7k|return 0; 196| 519k|} _pcre2_study_8: 1677| 50.3k|{ 1678| 50.3k|int count = 0; 1679| 50.3k|PCRE2_UCHAR *code; ------------------ | | 813| 50.3k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 50.3k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 50.3k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 50.3k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1680| 50.3k|BOOL utf = (re->overall_options & PCRE2_UTF) != 0; ------------------ | | 138| 50.3k|#define PCRE2_UTF 0x00080000u /* C J M D */ ------------------ 1681| 50.3k|BOOL ucp = (re->overall_options & PCRE2_UCP) != 0; ------------------ | | 136| 50.3k|#define PCRE2_UCP 0x00020000u /* C J M D */ ------------------ 1682| | 1683| |/* Find start of compiled code */ 1684| | 1685| 50.3k|code = (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code)) + 1686| 50.3k| re->name_entry_size * re->name_count; 1687| | 1688| |/* For a pattern that has a first code unit, or a multiline pattern that 1689| |matches only at "line start", there is no point in seeking a list of starting 1690| |code units. */ 1691| | 1692| 50.3k|if ((re->flags & (PCRE2_FIRSTSET|PCRE2_STARTLINE)) == 0) ------------------ | | 511| 50.3k|#define PCRE2_FIRSTSET 0x00000010 /* first_code unit is set */ ------------------ if ((re->flags & (PCRE2_FIRSTSET|PCRE2_STARTLINE)) == 0) ------------------ | | 516| 50.3k|#define PCRE2_STARTLINE 0x00000200 /* start after \n for multiline */ ------------------ | Branch (1692:5): [True: 40.1k, False: 10.1k] ------------------ 1693| 40.1k| { 1694| 40.1k| int depth = 0; 1695| 40.1k| int rc = set_start_bits(re, code, utf, ucp, &depth); 1696| 40.1k| if (rc == SSB_UNKNOWN) return 1; ------------------ | Branch (1696:7): [True: 0, False: 40.1k] ------------------ 1697| | 1698| | /* If a list of starting code units was set up, scan the list to see if only 1699| | one or two were listed. Having only one listed is rare because usually a 1700| | single starting code unit will have been recognized and PCRE2_FIRSTSET set. 1701| | If two are listed, see if they are caseless versions of the same character; 1702| | if so we can replace the list with a caseless first code unit. This gives 1703| | better performance and is plausibly worth doing for patterns such as [Ww]ord 1704| | or (word|WORD). */ 1705| | 1706| 40.1k| if (rc == SSB_DONE) ------------------ | Branch (1706:7): [True: 9.67k, False: 30.4k] ------------------ 1707| 9.67k| { 1708| 9.67k| int i; 1709| 9.67k| int a = -1; 1710| 9.67k| int b = -1; 1711| 9.67k| uint8_t *p = re->start_bitmap; 1712| 9.67k| uint32_t flags = PCRE2_FIRSTMAPSET; ------------------ | | 513| 9.67k|#define PCRE2_FIRSTMAPSET 0x00000040 /* bitmap of first code units is set */ ------------------ 1713| | 1714| 70.5k| for (i = 0; i < 256; p++, i += 8) ------------------ | Branch (1714:17): [True: 70.2k, False: 320] ------------------ 1715| 70.2k| { 1716| 70.2k| uint8_t x = *p; 1717| 70.2k| if (x != 0) ------------------ | Branch (1717:11): [True: 12.5k, False: 57.6k] ------------------ 1718| 12.5k| { 1719| 12.5k| int c; 1720| 12.5k| uint8_t y = x & (~x + 1); /* Least significant bit */ 1721| 12.5k| if (y != x) goto DONE; /* More than one bit set */ ------------------ | Branch (1721:13): [True: 6.59k, False: 5.98k] ------------------ 1722| | 1723| | /* In the 16-bit and 32-bit libraries, the bit for 0xff means "0xff and 1724| | all wide characters", so we cannot use it here. */ 1725| | 1726| |#if PCRE2_CODE_UNIT_WIDTH != 8 1727| | if (i == 248 && x == 0x80) goto DONE; 1728| |#endif 1729| | 1730| | /* Compute the character value */ 1731| | 1732| 5.98k| c = i; 1733| 5.98k| switch (x) ------------------ | Branch (1733:17): [True: 0, False: 5.98k] ------------------ 1734| 5.98k| { 1735| 1.51k| case 1: break; ------------------ | Branch (1735:11): [True: 1.51k, False: 4.47k] ------------------ 1736| 1.17k| case 2: c += 1; break; case 4: c += 2; break; ------------------ | Branch (1736:11): [True: 1.17k, False: 4.81k] | Branch (1736:37): [True: 491, False: 5.49k] ------------------ 1737| 1.02k| case 8: c += 3; break; case 16: c += 4; break; ------------------ | Branch (1737:11): [True: 1.02k, False: 4.96k] | Branch (1737:37): [True: 339, False: 5.64k] ------------------ 1738| 586| case 32: c += 5; break; case 64: c += 6; break; ------------------ | Branch (1738:11): [True: 586, False: 5.40k] | Branch (1738:37): [True: 442, False: 5.54k] ------------------ 1739| 414| case 128: c += 7; break; ------------------ | Branch (1739:11): [True: 414, False: 5.57k] ------------------ 1740| 5.98k| } 1741| | 1742| | /* c contains the code unit value, in the range 0-255. In 8-bit UTF 1743| | mode, only values < 128 can be used. In all the other cases, c is a 1744| | character value. */ 1745| | 1746| 5.98k|#if PCRE2_CODE_UNIT_WIDTH == 8 1747| 5.98k| if (utf && c > 127) goto DONE; ------------------ | Branch (1747:13): [True: 1.85k, False: 4.13k] | Branch (1747:20): [True: 425, False: 1.42k] ------------------ 1748| 5.56k|#endif 1749| 5.56k| if (a < 0) a = c; /* First one found, save in a */ ------------------ | Branch (1749:13): [True: 3.08k, False: 2.48k] ------------------ 1750| 2.48k| else if (b < 0) /* Second one found */ ------------------ | Branch (1750:18): [True: 2.46k, False: 21] ------------------ 1751| 2.46k| { 1752| 2.46k| int d = TABLE_GET((unsigned int)c, re->tables + fcc_offset, c); ------------------ | | 214| 2.46k|#define TABLE_GET(c, table, default) ((table)[c]) ------------------ 1753| | 1754| 2.46k|#ifdef SUPPORT_UNICODE 1755| 2.46k| if (utf || ucp) ------------------ | Branch (1755:15): [True: 600, False: 1.86k] | Branch (1755:22): [True: 187, False: 1.67k] ------------------ 1756| 787| { 1757| 787| if (UCD_CASESET(c) != 0) goto DONE; /* Multiple case set */ ------------------ | | 1861| 787|#define UCD_CASESET(ch) GET_UCD(ch)->caseset | | ------------------ | | | | 1846| 787|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 787|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 787|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 787| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 787|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 787|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 787|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 787| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 787|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 787|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1757:17): [True: 192, False: 595] ------------------ 1758| 595| if (c > 127) d = UCD_OTHERCASE(c); ------------------ | | 1862| 64|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 64|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 64|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 64|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 64| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 64|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 64|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 64|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 64| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 64|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 64|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1758:17): [True: 64, False: 531] ------------------ 1759| 595| } 1760| 2.27k|#endif /* SUPPORT_UNICODE */ 1761| | 1762| 2.27k| if (d != a) goto DONE; /* Not the other case of a */ ------------------ | Branch (1762:15): [True: 2.11k, False: 151] ------------------ 1763| 151| b = c; /* Save second in b */ 1764| 151| } 1765| 21| else goto DONE; /* More than two characters found */ 1766| 5.56k| } 1767| 70.2k| } 1768| | 1769| | /* Replace the start code unit bits with a first code unit, but only if it 1770| | is not the same as a required later code unit. This is because a search for 1771| | a required code unit starts after an explicit first code unit, but at a 1772| | code unit found from the bitmap. Patterns such as /a*a/ don't work 1773| | if both the start unit and required unit are the same. */ 1774| | 1775| 320| if (a >= 0 && ------------------ | Branch (1775:9): [True: 317, False: 3] ------------------ 1776| 320| ( 1777| 317| (re->flags & PCRE2_LASTSET) == 0 || ------------------ | | 514| 317|#define PCRE2_LASTSET 0x00000080 /* last code unit is set */ ------------------ | Branch (1777:9): [True: 129, False: 188] ------------------ 1778| 317| ( 1779| 188| re->last_codeunit != (uint32_t)a && ------------------ | Branch (1779:11): [True: 109, False: 79] ------------------ 1780| 188| (b < 0 || re->last_codeunit != (uint32_t)b) ------------------ | Branch (1780:12): [True: 58, False: 51] | Branch (1780:21): [True: 38, False: 13] ------------------ 1781| 188| ) 1782| 317| )) 1783| 225| { 1784| 225| re->first_codeunit = a; 1785| 225| flags = PCRE2_FIRSTSET; ------------------ | | 511| 225|#define PCRE2_FIRSTSET 0x00000010 /* first_code unit is set */ ------------------ 1786| 225| if (b >= 0) flags |= PCRE2_FIRSTCASELESS; ------------------ | | 512| 79|#define PCRE2_FIRSTCASELESS 0x00000020 /* caseless first code unit */ ------------------ | Branch (1786:11): [True: 79, False: 146] ------------------ 1787| 225| } 1788| | 1789| 9.67k| DONE: 1790| 9.67k| re->flags |= flags; 1791| 9.67k| } 1792| 40.1k| } 1793| | 1794| |/* Find the minimum length of subject string. If the pattern can match an empty 1795| |string, the minimum length is already known. If the pattern contains (*ACCEPT) 1796| |all bets are off, and we don't even try to find a minimum length. If there are 1797| |more back references than the size of the vector we are going to cache them in, 1798| |do nothing. A pattern that complicated will probably take a long time to 1799| |analyze and may in any case turn out to be too complicated. Note that back 1800| |reference minima are held as 16-bit numbers. */ 1801| | 1802| 50.3k|if ((re->flags & (PCRE2_MATCH_EMPTY|PCRE2_HASACCEPT)) == 0 && ------------------ | | 520| 50.3k|#define PCRE2_MATCH_EMPTY 0x00002000 /* pattern can match empty string */ ------------------ if ((re->flags & (PCRE2_MATCH_EMPTY|PCRE2_HASACCEPT)) == 0 && ------------------ | | 530| 50.3k|#define PCRE2_HASACCEPT 0x00800000 /* contains (*ACCEPT) */ ------------------ | Branch (1802:5): [True: 36.5k, False: 13.8k] ------------------ 1803| 50.3k| re->top_backref <= MAX_CACHE_BACKREF) ------------------ | | 53| 36.5k|#define MAX_CACHE_BACKREF 128 ------------------ | Branch (1803:6): [True: 36.5k, False: 33] ------------------ 1804| 36.5k| { 1805| 36.5k| int min; 1806| 36.5k| int backref_cache[MAX_CACHE_BACKREF+1]; 1807| 36.5k| backref_cache[0] = 0; /* Highest one that is set */ 1808| 36.5k| min = find_minlength(re, code, code, utf, NULL, &count, backref_cache); 1809| 36.5k| switch(min) 1810| 36.5k| { 1811| 116| case -1: /* \C in UTF mode or over-complex regex */ ------------------ | Branch (1811:5): [True: 116, False: 36.3k] ------------------ 1812| 116| break; /* Leave minlength unchanged (will be zero) */ 1813| | 1814| 0| case -2: ------------------ | Branch (1814:5): [True: 0, False: 36.5k] ------------------ 1815| 0| return 2; /* missing capturing bracket */ 1816| | 1817| 0| case -3: ------------------ | Branch (1817:5): [True: 0, False: 36.5k] ------------------ 1818| 0| return 3; /* unrecognized opcode */ 1819| | 1820| 36.3k| default: ------------------ | Branch (1820:5): [True: 36.3k, False: 116] ------------------ 1821| 36.3k| re->minlength = (min > UINT16_MAX)? UINT16_MAX : min; ------------------ | Branch (1821:21): [True: 0, False: 36.3k] ------------------ 1822| 36.3k| break; 1823| 36.5k| } 1824| 36.5k| } 1825| | 1826| 50.3k|return 0; 1827| 50.3k|} pcre2_study.c:set_start_bits: 957| 329k|{ 958| 329k|uint32_t c; 959| 329k|int yield = SSB_DONE; 960| | 961| 329k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 962| 329k|int table_limit = utf? 16:32; ------------------ | Branch (962:19): [True: 76.7k, False: 252k] ------------------ 963| |#else 964| |int table_limit = 32; 965| |#endif 966| | 967| 329k|*depthptr += 1; 968| 329k|if (*depthptr > 1000) return SSB_TOODEEP; ------------------ | Branch (968:5): [True: 57, False: 329k] ------------------ 969| | 970| 329k|do 971| 415k| { 972| 415k| BOOL try_next = TRUE; ------------------ | | 70| 415k|#define TRUE 1 ------------------ 973| 415k| PCRE2_SPTR tcode = code + 1 + LINK_SIZE; ------------------ | | 814| 415k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 415k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 415k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 415k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR tcode = code + 1 + LINK_SIZE; ------------------ | | 165| 415k|#define LINK_SIZE 2 ------------------ 974| | 975| 415k| if (*code == OP_CBRA || *code == OP_SCBRA || ------------------ | Branch (975:7): [True: 189k, False: 226k] | Branch (975:27): [True: 3.36k, False: 223k] ------------------ 976| 415k| *code == OP_CBRAPOS || *code == OP_SCBRAPOS) tcode += IMM2_SIZE; ------------------ | | 193| 196k|#define IMM2_SIZE 2 ------------------ | Branch (976:7): [True: 2.46k, False: 220k] | Branch (976:30): [True: 1.98k, False: 218k] ------------------ 977| | 978| 1.07M| while (try_next) /* Loop for items in this branch */ ------------------ | Branch (978:10): [True: 932k, False: 143k] ------------------ 979| 932k| { 980| 932k| int rc; 981| 932k| uint8_t *classmap = NULL; 982| 932k|#ifdef SUPPORT_WIDE_CHARS 983| 932k| PCRE2_UCHAR xclassflags; ------------------ | | 813| 932k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 932k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 932k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 932k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 984| 932k|#endif 985| | 986| 932k| switch(*tcode) 987| 932k| { 988| | /* If we reach something we don't understand, it means a new opcode has 989| | been created that hasn't been added to this function. Hopefully this 990| | problem will be discovered during testing. */ 991| | 992| 0| default: ------------------ | Branch (992:7): [True: 0, False: 932k] ------------------ 993| 0| return SSB_UNKNOWN; 994| | 995| | /* Fail for a valid opcode that implies no starting bits. */ 996| | 997| 43| case OP_ACCEPT: ------------------ | Branch (997:7): [True: 43, False: 932k] ------------------ 998| 56| case OP_ASSERT_ACCEPT: ------------------ | Branch (998:7): [True: 13, False: 932k] ------------------ 999| 846| case OP_ALLANY: ------------------ | Branch (999:7): [True: 790, False: 931k] ------------------ 1000| 6.46k| case OP_ANY: ------------------ | Branch (1000:7): [True: 5.62k, False: 926k] ------------------ 1001| 6.46k| case OP_ANYBYTE: ------------------ | Branch (1001:7): [True: 0, False: 932k] ------------------ 1002| 6.65k| case OP_CIRCM: ------------------ | Branch (1002:7): [True: 189, False: 931k] ------------------ 1003| 6.69k| case OP_CLOSE: ------------------ | Branch (1003:7): [True: 37, False: 932k] ------------------ 1004| 6.72k| case OP_COMMIT: ------------------ | Branch (1004:7): [True: 32, False: 932k] ------------------ 1005| 6.76k| case OP_COMMIT_ARG: ------------------ | Branch (1005:7): [True: 36, False: 932k] ------------------ 1006| 7.32k| case OP_COND: ------------------ | Branch (1006:7): [True: 564, False: 931k] ------------------ 1007| 7.32k| case OP_CREF: ------------------ | Branch (1007:7): [True: 4, False: 932k] ------------------ 1008| 7.33k| case OP_FALSE: ------------------ | Branch (1008:7): [True: 3, False: 932k] ------------------ 1009| 7.33k| case OP_TRUE: ------------------ | Branch (1009:7): [True: 3, False: 932k] ------------------ 1010| 7.33k| case OP_DNCREF: ------------------ | Branch (1010:7): [True: 4, False: 932k] ------------------ 1011| 7.42k| case OP_DNREF: ------------------ | Branch (1011:7): [True: 90, False: 932k] ------------------ 1012| 7.46k| case OP_DNREFI: ------------------ | Branch (1012:7): [True: 37, False: 932k] ------------------ 1013| 7.46k| case OP_DNRREF: ------------------ | Branch (1013:7): [True: 3, False: 932k] ------------------ 1014| 9.03k| case OP_DOLL: ------------------ | Branch (1014:7): [True: 1.57k, False: 930k] ------------------ 1015| 9.76k| case OP_DOLLM: ------------------ | Branch (1015:7): [True: 725, False: 931k] ------------------ 1016| 9.76k| case OP_END: ------------------ | Branch (1016:7): [True: 0, False: 932k] ------------------ 1017| 9.82k| case OP_EOD: ------------------ | Branch (1017:7): [True: 61, False: 932k] ------------------ 1018| 9.92k| case OP_EODN: ------------------ | Branch (1018:7): [True: 104, False: 931k] ------------------ 1019| 10.2k| case OP_EXTUNI: ------------------ | Branch (1019:7): [True: 368, False: 931k] ------------------ 1020| 10.3k| case OP_FAIL: ------------------ | Branch (1020:7): [True: 68, False: 932k] ------------------ 1021| 10.4k| case OP_MARK: ------------------ | Branch (1021:7): [True: 106, False: 931k] ------------------ 1022| 10.6k| case OP_NOT: ------------------ | Branch (1022:7): [True: 211, False: 931k] ------------------ 1023| 10.8k| case OP_NOTEXACT: ------------------ | Branch (1023:7): [True: 133, False: 931k] ------------------ 1024| 10.8k| case OP_NOTEXACTI: ------------------ | Branch (1024:7): [True: 64, False: 932k] ------------------ 1025| 10.9k| case OP_NOTI: ------------------ | Branch (1025:7): [True: 85, False: 932k] ------------------ 1026| 11.0k| case OP_NOTMINPLUS: ------------------ | Branch (1026:7): [True: 53, False: 932k] ------------------ 1027| 11.0k| case OP_NOTMINPLUSI: ------------------ | Branch (1027:7): [True: 37, False: 932k] ------------------ 1028| 11.0k| case OP_NOTMINQUERY: ------------------ | Branch (1028:7): [True: 32, False: 932k] ------------------ 1029| 11.1k| case OP_NOTMINQUERYI: ------------------ | Branch (1029:7): [True: 22, False: 932k] ------------------ 1030| 11.1k| case OP_NOTMINSTAR: ------------------ | Branch (1030:7): [True: 52, False: 932k] ------------------ 1031| 11.1k| case OP_NOTMINSTARI: ------------------ | Branch (1031:7): [True: 30, False: 932k] ------------------ 1032| 11.1k| case OP_NOTMINUPTO: ------------------ | Branch (1032:7): [True: 4, False: 932k] ------------------ 1033| 11.1k| case OP_NOTMINUPTOI: ------------------ | Branch (1033:7): [True: 3, False: 932k] ------------------ 1034| 11.3k| case OP_NOTPLUS: ------------------ | Branch (1034:7): [True: 131, False: 931k] ------------------ 1035| 11.3k| case OP_NOTPLUSI: ------------------ | Branch (1035:7): [True: 28, False: 932k] ------------------ 1036| 11.4k| case OP_NOTPOSPLUS: ------------------ | Branch (1036:7): [True: 95, False: 931k] ------------------ 1037| 11.4k| case OP_NOTPOSPLUSI: ------------------ | Branch (1037:7): [True: 23, False: 932k] ------------------ 1038| 11.5k| case OP_NOTPOSQUERY: ------------------ | Branch (1038:7): [True: 65, False: 932k] ------------------ 1039| 11.5k| case OP_NOTPOSQUERYI: ------------------ | Branch (1039:7): [True: 12, False: 932k] ------------------ 1040| 11.6k| case OP_NOTPOSSTAR: ------------------ | Branch (1040:7): [True: 89, False: 932k] ------------------ 1041| 11.6k| case OP_NOTPOSSTARI: ------------------ | Branch (1041:7): [True: 20, False: 932k] ------------------ 1042| 11.6k| case OP_NOTPOSUPTO: ------------------ | Branch (1042:7): [True: 8, False: 932k] ------------------ 1043| 11.6k| case OP_NOTPOSUPTOI: ------------------ | Branch (1043:7): [True: 5, False: 932k] ------------------ 1044| 13.2k| case OP_NOTPROP: ------------------ | Branch (1044:7): [True: 1.55k, False: 930k] ------------------ 1045| 13.3k| case OP_NOTQUERY: ------------------ | Branch (1045:7): [True: 100, False: 931k] ------------------ 1046| 13.3k| case OP_NOTQUERYI: ------------------ | Branch (1046:7): [True: 24, False: 932k] ------------------ 1047| 13.4k| case OP_NOTSTAR: ------------------ | Branch (1047:7): [True: 84, False: 932k] ------------------ 1048| 13.4k| case OP_NOTSTARI: ------------------ | Branch (1048:7): [True: 18, False: 932k] ------------------ 1049| 13.4k| case OP_NOTUPTO: ------------------ | Branch (1049:7): [True: 16, False: 932k] ------------------ 1050| 13.4k| case OP_NOTUPTOI: ------------------ | Branch (1050:7): [True: 4, False: 932k] ------------------ 1051| 14.6k| case OP_NOT_HSPACE: ------------------ | Branch (1051:7): [True: 1.21k, False: 930k] ------------------ 1052| 15.3k| case OP_NOT_VSPACE: ------------------ | Branch (1052:7): [True: 692, False: 931k] ------------------ 1053| 15.4k| case OP_PRUNE: ------------------ | Branch (1053:7): [True: 34, False: 932k] ------------------ 1054| 15.4k| case OP_PRUNE_ARG: ------------------ | Branch (1054:7): [True: 40, False: 932k] ------------------ 1055| 15.9k| case OP_RECURSE: ------------------ | Branch (1055:7): [True: 514, False: 931k] ------------------ 1056| 16.4k| case OP_REF: ------------------ | Branch (1056:7): [True: 451, False: 931k] ------------------ 1057| 16.5k| case OP_REFI: ------------------ | Branch (1057:7): [True: 134, False: 931k] ------------------ 1058| 16.5k| case OP_REVERSE: ------------------ | Branch (1058:7): [True: 18, False: 932k] ------------------ 1059| 16.5k| case OP_RREF: ------------------ | Branch (1059:7): [True: 14, False: 932k] ------------------ 1060| 16.6k| case OP_SCOND: ------------------ | Branch (1060:7): [True: 66, False: 932k] ------------------ 1061| 16.6k| case OP_SET_SOM: ------------------ | Branch (1061:7): [True: 8, False: 932k] ------------------ 1062| 16.7k| case OP_SKIP: ------------------ | Branch (1062:7): [True: 49, False: 932k] ------------------ 1063| 16.9k| case OP_SKIP_ARG: ------------------ | Branch (1063:7): [True: 262, False: 931k] ------------------ 1064| 17.0k| case OP_SOD: ------------------ | Branch (1064:7): [True: 71, False: 932k] ------------------ 1065| 17.0k| case OP_SOM: ------------------ | Branch (1065:7): [True: 36, False: 932k] ------------------ 1066| 17.1k| case OP_THEN: ------------------ | Branch (1066:7): [True: 100, False: 931k] ------------------ 1067| 17.2k| case OP_THEN_ARG: ------------------ | Branch (1067:7): [True: 44, False: 932k] ------------------ 1068| 17.2k| return SSB_FAIL; 1069| | 1070| | /* OP_CIRC happens only at the start of an anchored branch (multiline ^ 1071| | uses OP_CIRCM). Skip over it. */ 1072| | 1073| 4.57k| case OP_CIRC: ------------------ | Branch (1073:7): [True: 4.57k, False: 927k] ------------------ 1074| 4.57k| tcode += PRIV(OP_lengths)[OP_CIRC]; ------------------ | | 177| 4.57k|#define PRIV(name) _pcre2_##name ------------------ 1075| 4.57k| break; 1076| | 1077| | /* A "real" property test implies no starting bits, but the fake property 1078| | PT_CLIST identifies a list of characters. These lists are short, as they 1079| | are used for characters with more than one "other case", so there is no 1080| | point in recognizing them for OP_NOTPROP. */ 1081| | 1082| 4.07k| case OP_PROP: ------------------ | Branch (1082:7): [True: 4.07k, False: 928k] ------------------ 1083| 4.07k| if (tcode[1] != PT_CLIST) return SSB_FAIL; ------------------ | | 1285| 4.07k|#define PT_CLIST 10 /* Pseudo-property: match character list */ ------------------ | Branch (1083:11): [True: 789, False: 3.28k] ------------------ 1084| 3.28k| { 1085| 3.28k| const uint32_t *p = PRIV(ucd_caseless_sets) + tcode[2]; ------------------ | | 177| 3.28k|#define PRIV(name) _pcre2_##name ------------------ 1086| 13.3k| while ((c = *p++) < NOTACHAR) ------------------ | | 205| 13.3k|#define NOTACHAR 0xffffffff ------------------ | Branch (1086:16): [True: 10.0k, False: 3.28k] ------------------ 1087| 10.0k| { 1088| 10.0k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 1089| 10.0k| if (utf) ------------------ | Branch (1089:15): [True: 3.90k, False: 6.13k] ------------------ 1090| 3.90k| { 1091| 3.90k| PCRE2_UCHAR buff[6]; ------------------ | | 813| 3.90k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 3.90k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 3.90k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 3.90k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1092| 3.90k| (void)PRIV(ord2utf)(c, buff); ------------------ | | 177| 3.90k|#define PRIV(name) _pcre2_##name ------------------ 1093| 3.90k| c = buff[0]; 1094| 3.90k| } 1095| 10.0k|#endif 1096| 10.0k| if (c > 0xff) SET_BIT(0xff); else SET_BIT(c); ------------------ | | 57| 2.05k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ if (c > 0xff) SET_BIT(0xff); else SET_BIT(c); ------------------ | | 57| 7.98k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ | Branch (1096:15): [True: 2.05k, False: 7.98k] ------------------ 1097| 10.0k| } 1098| 3.28k| } 1099| 3.28k| try_next = FALSE; ------------------ | | 69| 3.28k|#define FALSE 0 ------------------ 1100| 3.28k| break; 1101| | 1102| | /* We can ignore word boundary tests. */ 1103| | 1104| 3.40k| case OP_WORD_BOUNDARY: ------------------ | Branch (1104:7): [True: 3.40k, False: 928k] ------------------ 1105| 5.93k| case OP_NOT_WORD_BOUNDARY: ------------------ | Branch (1105:7): [True: 2.52k, False: 929k] ------------------ 1106| 7.23k| case OP_UCP_WORD_BOUNDARY: ------------------ | Branch (1106:7): [True: 1.30k, False: 930k] ------------------ 1107| 9.28k| case OP_NOT_UCP_WORD_BOUNDARY: ------------------ | Branch (1107:7): [True: 2.04k, False: 930k] ------------------ 1108| 9.28k| tcode++; 1109| 9.28k| break; 1110| | 1111| | /* If we hit a bracket or a positive lookahead assertion, recurse to set 1112| | bits from within the subpattern. If it can't find anything, we have to 1113| | give up. If it finds some mandatory character(s), we are done for this 1114| | branch. Otherwise, carry on scanning after the subpattern. */ 1115| | 1116| 55.8k| case OP_BRA: ------------------ | Branch (1116:7): [True: 55.8k, False: 876k] ------------------ 1117| 56.8k| case OP_SBRA: ------------------ | Branch (1117:7): [True: 971, False: 931k] ------------------ 1118| 244k| case OP_CBRA: ------------------ | Branch (1118:7): [True: 187k, False: 744k] ------------------ 1119| 246k| case OP_SCBRA: ------------------ | Branch (1119:7): [True: 1.43k, False: 930k] ------------------ 1120| 246k| case OP_BRAPOS: ------------------ | Branch (1120:7): [True: 649, False: 931k] ------------------ 1121| 247k| case OP_SBRAPOS: ------------------ | Branch (1121:7): [True: 808, False: 931k] ------------------ 1122| 248k| case OP_CBRAPOS: ------------------ | Branch (1122:7): [True: 692, False: 931k] ------------------ 1123| 250k| case OP_SCBRAPOS: ------------------ | Branch (1123:7): [True: 1.70k, False: 930k] ------------------ 1124| 252k| case OP_ONCE: ------------------ | Branch (1124:7): [True: 2.23k, False: 929k] ------------------ 1125| 253k| case OP_SCRIPT_RUN: ------------------ | Branch (1125:7): [True: 1.56k, False: 930k] ------------------ 1126| 255k| case OP_ASSERT: ------------------ | Branch (1126:7): [True: 2.10k, False: 929k] ------------------ 1127| 258k| case OP_ASSERT_NA: ------------------ | Branch (1127:7): [True: 3.00k, False: 929k] ------------------ 1128| 258k| rc = set_start_bits(re, tcode, utf, ucp, depthptr); 1129| 258k| if (rc == SSB_DONE) ------------------ | Branch (1129:11): [True: 4.86k, False: 254k] ------------------ 1130| 4.86k| { 1131| 4.86k| try_next = FALSE; ------------------ | | 69| 4.86k|#define FALSE 0 ------------------ 1132| 4.86k| } 1133| 254k| else if (rc == SSB_CONTINUE) ------------------ | Branch (1133:16): [True: 245k, False: 8.33k] ------------------ 1134| 245k| { 1135| 324k| do tcode += GET(tcode, 1); while (*tcode == OP_ALT); ------------------ | | 109| 324k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (1135:43): [True: 78.8k, False: 245k] ------------------ 1136| 245k| tcode += 1 + LINK_SIZE; ------------------ | | 165| 245k|#define LINK_SIZE 2 ------------------ 1137| 245k| } 1138| 8.33k| else return rc; /* FAIL, UNKNOWN, or TOODEEP */ 1139| 250k| break; 1140| | 1141| | /* If we hit ALT or KET, it means we haven't found anything mandatory in 1142| | this branch, though we might have found something optional. For ALT, we 1143| | continue with the next alternative, but we have to arrange that the final 1144| | result from subpattern is SSB_CONTINUE rather than SSB_DONE. For KET, 1145| | return SSB_CONTINUE: if this is the top level, that indicates failure, 1146| | but after a nested subpattern, it causes scanning to continue. */ 1147| | 1148| 250k| case OP_ALT: ------------------ | Branch (1148:7): [True: 54.8k, False: 877k] ------------------ 1149| 54.8k| yield = SSB_CONTINUE; 1150| 54.8k| try_next = FALSE; ------------------ | | 69| 54.8k|#define FALSE 0 ------------------ 1151| 54.8k| break; 1152| | 1153| 224k| case OP_KET: ------------------ | Branch (1153:7): [True: 224k, False: 707k] ------------------ 1154| 227k| case OP_KETRMAX: ------------------ | Branch (1154:7): [True: 3.77k, False: 928k] ------------------ 1155| 229k| case OP_KETRMIN: ------------------ | Branch (1155:7): [True: 1.10k, False: 930k] ------------------ 1156| 231k| case OP_KETRPOS: ------------------ | Branch (1156:7): [True: 2.64k, False: 929k] ------------------ 1157| 231k| return SSB_CONTINUE; 1158| | 1159| | /* Skip over callout */ 1160| | 1161| 89.7k| case OP_CALLOUT: ------------------ | Branch (1161:7): [True: 89.7k, False: 842k] ------------------ 1162| 89.7k| tcode += PRIV(OP_lengths)[OP_CALLOUT]; ------------------ | | 177| 89.7k|#define PRIV(name) _pcre2_##name ------------------ 1163| 89.7k| break; 1164| | 1165| 1.89k| case OP_CALLOUT_STR: ------------------ | Branch (1165:7): [True: 1.89k, False: 930k] ------------------ 1166| 1.89k| tcode += GET(tcode, 1 + 2*LINK_SIZE); ------------------ | | 109| 1.89k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1167| 1.89k| break; 1168| | 1169| | /* Skip over lookbehind and negative lookahead assertions */ 1170| | 1171| 10.9k| case OP_ASSERT_NOT: ------------------ | Branch (1171:7): [True: 10.9k, False: 921k] ------------------ 1172| 12.3k| case OP_ASSERTBACK: ------------------ | Branch (1172:7): [True: 1.40k, False: 930k] ------------------ 1173| 14.3k| case OP_ASSERTBACK_NOT: ------------------ | Branch (1173:7): [True: 1.97k, False: 930k] ------------------ 1174| 15.1k| case OP_ASSERTBACK_NA: ------------------ | Branch (1174:7): [True: 840, False: 931k] ------------------ 1175| 16.7k| do tcode += GET(tcode, 1); while (*tcode == OP_ALT); ------------------ | | 109| 16.7k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (1175:41): [True: 1.57k, False: 15.1k] ------------------ 1176| 15.1k| tcode += 1 + LINK_SIZE; ------------------ | | 165| 15.1k|#define LINK_SIZE 2 ------------------ 1177| 15.1k| break; 1178| | 1179| | /* BRAZERO does the bracket, but carries on. */ 1180| | 1181| 24.6k| case OP_BRAZERO: ------------------ | Branch (1181:7): [True: 24.6k, False: 907k] ------------------ 1182| 28.2k| case OP_BRAMINZERO: ------------------ | Branch (1182:7): [True: 3.59k, False: 928k] ------------------ 1183| 30.4k| case OP_BRAPOSZERO: ------------------ | Branch (1183:7): [True: 2.24k, False: 929k] ------------------ 1184| 30.4k| rc = set_start_bits(re, ++tcode, utf, ucp, depthptr); 1185| 30.4k| if (rc == SSB_FAIL || rc == SSB_UNKNOWN || rc == SSB_TOODEEP) return rc; ------------------ | Branch (1185:11): [True: 1.26k, False: 29.1k] | Branch (1185:29): [True: 0, False: 29.1k] | Branch (1185:50): [True: 7.19k, False: 21.9k] ------------------ 1186| 22.4k| do tcode += GET(tcode,1); while (*tcode == OP_ALT); ------------------ | | 109| 22.4k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (1186:40): [True: 426, False: 21.9k] ------------------ 1187| 21.9k| tcode += 1 + LINK_SIZE; ------------------ | | 165| 21.9k|#define LINK_SIZE 2 ------------------ 1188| 21.9k| break; 1189| | 1190| | /* SKIPZERO skips the bracket. */ 1191| | 1192| 632| case OP_SKIPZERO: ------------------ | Branch (1192:7): [True: 632, False: 931k] ------------------ 1193| 632| tcode++; 1194| 960| do tcode += GET(tcode,1); while (*tcode == OP_ALT); ------------------ | | 109| 960| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (1194:40): [True: 328, False: 632] ------------------ 1195| 632| tcode += 1 + LINK_SIZE; ------------------ | | 165| 632|#define LINK_SIZE 2 ------------------ 1196| 632| break; 1197| | 1198| | /* Single-char * or ? sets the bit and tries the next item */ 1199| | 1200| 14.0k| case OP_STAR: ------------------ | Branch (1200:7): [True: 14.0k, False: 918k] ------------------ 1201| 15.2k| case OP_MINSTAR: ------------------ | Branch (1201:7): [True: 1.19k, False: 930k] ------------------ 1202| 17.8k| case OP_POSSTAR: ------------------ | Branch (1202:7): [True: 2.65k, False: 929k] ------------------ 1203| 27.6k| case OP_QUERY: ------------------ | Branch (1203:7): [True: 9.83k, False: 922k] ------------------ 1204| 28.3k| case OP_MINQUERY: ------------------ | Branch (1204:7): [True: 618, False: 931k] ------------------ 1205| 30.5k| case OP_POSQUERY: ------------------ | Branch (1205:7): [True: 2.26k, False: 929k] ------------------ 1206| 30.5k| tcode = set_table_bit(re, tcode + 1, FALSE, utf, ucp); ------------------ | | 69| 30.5k|#define FALSE 0 ------------------ 1207| 30.5k| break; 1208| | 1209| 3.17k| case OP_STARI: ------------------ | Branch (1209:7): [True: 3.17k, False: 928k] ------------------ 1210| 5.56k| case OP_MINSTARI: ------------------ | Branch (1210:7): [True: 2.39k, False: 929k] ------------------ 1211| 7.13k| case OP_POSSTARI: ------------------ | Branch (1211:7): [True: 1.57k, False: 930k] ------------------ 1212| 9.52k| case OP_QUERYI: ------------------ | Branch (1212:7): [True: 2.38k, False: 929k] ------------------ 1213| 13.2k| case OP_MINQUERYI: ------------------ | Branch (1213:7): [True: 3.71k, False: 928k] ------------------ 1214| 14.2k| case OP_POSQUERYI: ------------------ | Branch (1214:7): [True: 964, False: 931k] ------------------ 1215| 14.2k| tcode = set_table_bit(re, tcode + 1, TRUE, utf, ucp); ------------------ | | 70| 14.2k|#define TRUE 1 ------------------ 1216| 14.2k| break; 1217| | 1218| | /* Single-char upto sets the bit and tries the next */ 1219| | 1220| 1.46k| case OP_UPTO: ------------------ | Branch (1220:7): [True: 1.46k, False: 930k] ------------------ 1221| 1.76k| case OP_MINUPTO: ------------------ | Branch (1221:7): [True: 300, False: 931k] ------------------ 1222| 2.58k| case OP_POSUPTO: ------------------ | Branch (1222:7): [True: 819, False: 931k] ------------------ 1223| 2.58k| tcode = set_table_bit(re, tcode + 1 + IMM2_SIZE, FALSE, utf, ucp); ------------------ | | 193| 2.58k|#define IMM2_SIZE 2 ------------------ tcode = set_table_bit(re, tcode + 1 + IMM2_SIZE, FALSE, utf, ucp); ------------------ | | 69| 2.58k|#define FALSE 0 ------------------ 1224| 2.58k| break; 1225| | 1226| 378| case OP_UPTOI: ------------------ | Branch (1226:7): [True: 378, False: 931k] ------------------ 1227| 1.25k| case OP_MINUPTOI: ------------------ | Branch (1227:7): [True: 880, False: 931k] ------------------ 1228| 1.77k| case OP_POSUPTOI: ------------------ | Branch (1228:7): [True: 519, False: 931k] ------------------ 1229| 1.77k| tcode = set_table_bit(re, tcode + 1 + IMM2_SIZE, TRUE, utf, ucp); ------------------ | | 193| 1.77k|#define IMM2_SIZE 2 ------------------ tcode = set_table_bit(re, tcode + 1 + IMM2_SIZE, TRUE, utf, ucp); ------------------ | | 70| 1.77k|#define TRUE 1 ------------------ 1230| 1.77k| break; 1231| | 1232| | /* At least one single char sets the bit and stops */ 1233| | 1234| 1.93k| case OP_EXACT: ------------------ | Branch (1234:7): [True: 1.93k, False: 930k] ------------------ 1235| 1.93k| tcode += IMM2_SIZE; ------------------ | | 193| 1.93k|#define IMM2_SIZE 2 ------------------ 1236| | /* Fall through */ 1237| 19.8k| case OP_CHAR: ------------------ | Branch (1237:7): [True: 17.8k, False: 914k] ------------------ 1238| 24.7k| case OP_PLUS: ------------------ | Branch (1238:7): [True: 4.93k, False: 927k] ------------------ 1239| 24.9k| case OP_MINPLUS: ------------------ | Branch (1239:7): [True: 244, False: 931k] ------------------ 1240| 25.8k| case OP_POSPLUS: ------------------ | Branch (1240:7): [True: 898, False: 931k] ------------------ 1241| 25.8k| (void)set_table_bit(re, tcode + 1, FALSE, utf, ucp); ------------------ | | 69| 25.8k|#define FALSE 0 ------------------ 1242| 25.8k| try_next = FALSE; ------------------ | | 69| 25.8k|#define FALSE 0 ------------------ 1243| 25.8k| break; 1244| | 1245| 849| case OP_EXACTI: ------------------ | Branch (1245:7): [True: 849, False: 931k] ------------------ 1246| 849| tcode += IMM2_SIZE; ------------------ | | 193| 849|#define IMM2_SIZE 2 ------------------ 1247| | /* Fall through */ 1248| 6.63k| case OP_CHARI: ------------------ | Branch (1248:7): [True: 5.78k, False: 926k] ------------------ 1249| 7.68k| case OP_PLUSI: ------------------ | Branch (1249:7): [True: 1.05k, False: 931k] ------------------ 1250| 8.57k| case OP_MINPLUSI: ------------------ | Branch (1250:7): [True: 890, False: 931k] ------------------ 1251| 8.96k| case OP_POSPLUSI: ------------------ | Branch (1251:7): [True: 389, False: 931k] ------------------ 1252| 8.96k| (void)set_table_bit(re, tcode + 1, TRUE, utf, ucp); ------------------ | | 70| 8.96k|#define TRUE 1 ------------------ 1253| 8.96k| try_next = FALSE; ------------------ | | 69| 8.96k|#define FALSE 0 ------------------ 1254| 8.96k| break; 1255| | 1256| | /* Special spacing and line-terminating items. These recognize specific 1257| | lists of characters. The difference between VSPACE and ANYNL is that the 1258| | latter can match the two-character CRLF sequence, but that is not 1259| | relevant for finding the first character, so their code here is 1260| | identical. */ 1261| | 1262| 3.59k| case OP_HSPACE: ------------------ | Branch (1262:7): [True: 3.59k, False: 928k] ------------------ 1263| 3.59k| SET_BIT(CHAR_HT); ------------------ | | 57| 3.59k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1264| 3.59k| SET_BIT(CHAR_SPACE); ------------------ | | 57| 3.59k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1265| | 1266| | /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set 1267| | the bits for 0xA0 and for code units >= 255, independently of UTF. */ 1268| | 1269| |#if PCRE2_CODE_UNIT_WIDTH != 8 1270| | SET_BIT(0xA0); 1271| | SET_BIT(0xFF); 1272| |#else 1273| | /* For the 8-bit library in UTF-8 mode, set the bits for the first code 1274| | units of horizontal space characters. */ 1275| | 1276| 3.59k|#ifdef SUPPORT_UNICODE 1277| 3.59k| if (utf) ------------------ | Branch (1277:11): [True: 1.30k, False: 2.28k] ------------------ 1278| 1.30k| { 1279| 1.30k| SET_BIT(0xC2); /* For U+00A0 */ ------------------ | | 57| 1.30k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1280| 1.30k| SET_BIT(0xE1); /* For U+1680, U+180E */ ------------------ | | 57| 1.30k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1281| 1.30k| SET_BIT(0xE2); /* For U+2000 - U+200A, U+202F, U+205F */ ------------------ | | 57| 1.30k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1282| 1.30k| SET_BIT(0xE3); /* For U+3000 */ ------------------ | | 57| 1.30k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1283| 1.30k| } 1284| 2.28k| else 1285| 2.28k|#endif 1286| | /* For the 8-bit library not in UTF-8 mode, set the bit for 0xA0, unless 1287| | the code is EBCDIC. */ 1288| 2.28k| { 1289| 2.28k|#ifndef EBCDIC 1290| 2.28k| SET_BIT(0xA0); ------------------ | | 57| 2.28k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1291| 2.28k|#endif /* Not EBCDIC */ 1292| 2.28k| } 1293| 3.59k|#endif /* 8-bit support */ 1294| | 1295| 3.59k| try_next = FALSE; ------------------ | | 69| 3.59k|#define FALSE 0 ------------------ 1296| 3.59k| break; 1297| | 1298| 1.52k| case OP_ANYNL: ------------------ | Branch (1298:7): [True: 1.52k, False: 930k] ------------------ 1299| 3.63k| case OP_VSPACE: ------------------ | Branch (1299:7): [True: 2.10k, False: 929k] ------------------ 1300| 3.63k| SET_BIT(CHAR_LF); ------------------ | | 57| 3.63k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1301| 3.63k| SET_BIT(CHAR_VT); ------------------ | | 57| 3.63k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1302| 3.63k| SET_BIT(CHAR_FF); ------------------ | | 57| 3.63k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1303| 3.63k| SET_BIT(CHAR_CR); ------------------ | | 57| 3.63k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1304| | 1305| | /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set 1306| | the bits for NEL and for code units >= 255, independently of UTF. */ 1307| | 1308| |#if PCRE2_CODE_UNIT_WIDTH != 8 1309| | SET_BIT(CHAR_NEL); 1310| | SET_BIT(0xFF); 1311| |#else 1312| | /* For the 8-bit library in UTF-8 mode, set the bits for the first code 1313| | units of vertical space characters. */ 1314| | 1315| 3.63k|#ifdef SUPPORT_UNICODE 1316| 3.63k| if (utf) ------------------ | Branch (1316:11): [True: 722, False: 2.91k] ------------------ 1317| 722| { 1318| 722| SET_BIT(0xC2); /* For U+0085 (NEL) */ ------------------ | | 57| 722|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1319| 722| SET_BIT(0xE2); /* For U+2028, U+2029 */ ------------------ | | 57| 722|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1320| 722| } 1321| 2.91k| else 1322| 2.91k|#endif 1323| | /* For the 8-bit library not in UTF-8 mode, set the bit for NEL. */ 1324| 2.91k| { 1325| 2.91k| SET_BIT(CHAR_NEL); ------------------ | | 57| 2.91k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1326| 2.91k| } 1327| 3.63k|#endif /* 8-bit support */ 1328| | 1329| 3.63k| try_next = FALSE; ------------------ | | 69| 3.63k|#define FALSE 0 ------------------ 1330| 3.63k| break; 1331| | 1332| | /* Single character types set the bits and stop. Note that if PCRE2_UCP 1333| | is set, we do not see these opcodes because \d etc are converted to 1334| | properties. Therefore, these apply in the case when only characters less 1335| | than 256 are recognized to match the types. */ 1336| | 1337| 1.84k| case OP_NOT_DIGIT: ------------------ | Branch (1337:7): [True: 1.84k, False: 930k] ------------------ 1338| 1.84k| set_nottype_bits(re, cbit_digit, table_limit); ------------------ | | 565| 1.84k|#define cbit_digit 64 /* [:digit:] or \d */ ------------------ 1339| 1.84k| try_next = FALSE; ------------------ | | 69| 1.84k|#define FALSE 0 ------------------ 1340| 1.84k| break; 1341| | 1342| 7.40k| case OP_DIGIT: ------------------ | Branch (1342:7): [True: 7.40k, False: 924k] ------------------ 1343| 7.40k| set_type_bits(re, cbit_digit, table_limit); ------------------ | | 565| 7.40k|#define cbit_digit 64 /* [:digit:] or \d */ ------------------ 1344| 7.40k| try_next = FALSE; ------------------ | | 69| 7.40k|#define FALSE 0 ------------------ 1345| 7.40k| break; 1346| | 1347| 3.38k| case OP_NOT_WHITESPACE: ------------------ | Branch (1347:7): [True: 3.38k, False: 928k] ------------------ 1348| 3.38k| set_nottype_bits(re, cbit_space, table_limit); ------------------ | | 563| 3.38k|#define cbit_space 0 /* [:space:] or \s */ ------------------ 1349| 3.38k| try_next = FALSE; ------------------ | | 69| 3.38k|#define FALSE 0 ------------------ 1350| 3.38k| break; 1351| | 1352| 4.85k| case OP_WHITESPACE: ------------------ | Branch (1352:7): [True: 4.85k, False: 927k] ------------------ 1353| 4.85k| set_type_bits(re, cbit_space, table_limit); ------------------ | | 563| 4.85k|#define cbit_space 0 /* [:space:] or \s */ ------------------ 1354| 4.85k| try_next = FALSE; ------------------ | | 69| 4.85k|#define FALSE 0 ------------------ 1355| 4.85k| break; 1356| | 1357| 4.05k| case OP_NOT_WORDCHAR: ------------------ | Branch (1357:7): [True: 4.05k, False: 928k] ------------------ 1358| 4.05k| set_nottype_bits(re, cbit_word, table_limit); ------------------ | | 568| 4.05k|#define cbit_word 160 /* [:word:] or \w */ ------------------ 1359| 4.05k| try_next = FALSE; ------------------ | | 69| 4.05k|#define FALSE 0 ------------------ 1360| 4.05k| break; 1361| | 1362| 7.61k| case OP_WORDCHAR: ------------------ | Branch (1362:7): [True: 7.61k, False: 924k] ------------------ 1363| 7.61k| set_type_bits(re, cbit_word, table_limit); ------------------ | | 568| 7.61k|#define cbit_word 160 /* [:word:] or \w */ ------------------ 1364| 7.61k| try_next = FALSE; ------------------ | | 69| 7.61k|#define FALSE 0 ------------------ 1365| 7.61k| break; 1366| | 1367| | /* One or more character type fudges the pointer and restarts, knowing 1368| | it will hit a single character type and stop there. */ 1369| | 1370| 6.11k| case OP_TYPEPLUS: ------------------ | Branch (1370:7): [True: 6.11k, False: 925k] ------------------ 1371| 8.41k| case OP_TYPEMINPLUS: ------------------ | Branch (1371:7): [True: 2.30k, False: 929k] ------------------ 1372| 10.7k| case OP_TYPEPOSPLUS: ------------------ | Branch (1372:7): [True: 2.34k, False: 929k] ------------------ 1373| 10.7k| tcode++; 1374| 10.7k| break; 1375| | 1376| 2.31k| case OP_TYPEEXACT: ------------------ | Branch (1376:7): [True: 2.31k, False: 929k] ------------------ 1377| 2.31k| tcode += 1 + IMM2_SIZE; ------------------ | | 193| 2.31k|#define IMM2_SIZE 2 ------------------ 1378| 2.31k| break; 1379| | 1380| | /* Zero or more repeats of character types set the bits and then 1381| | try again. */ 1382| | 1383| 469| case OP_TYPEUPTO: ------------------ | Branch (1383:7): [True: 469, False: 931k] ------------------ 1384| 831| case OP_TYPEMINUPTO: ------------------ | Branch (1384:7): [True: 362, False: 931k] ------------------ 1385| 1.28k| case OP_TYPEPOSUPTO: ------------------ | Branch (1385:7): [True: 455, False: 931k] ------------------ 1386| 1.28k| tcode += IMM2_SIZE; /* Fall through */ ------------------ | | 193| 1.28k|#define IMM2_SIZE 2 ------------------ 1387| | 1388| 30.7k| case OP_TYPESTAR: ------------------ | Branch (1388:7): [True: 29.5k, False: 902k] ------------------ 1389| 33.9k| case OP_TYPEMINSTAR: ------------------ | Branch (1389:7): [True: 3.11k, False: 928k] ------------------ 1390| 35.8k| case OP_TYPEPOSSTAR: ------------------ | Branch (1390:7): [True: 1.89k, False: 930k] ------------------ 1391| 55.3k| case OP_TYPEQUERY: ------------------ | Branch (1391:7): [True: 19.5k, False: 912k] ------------------ 1392| 57.4k| case OP_TYPEMINQUERY: ------------------ | Branch (1392:7): [True: 2.13k, False: 929k] ------------------ 1393| 60.8k| case OP_TYPEPOSQUERY: ------------------ | Branch (1393:7): [True: 3.40k, False: 928k] ------------------ 1394| 60.8k| switch(tcode[1]) 1395| 60.8k| { 1396| 2.96k| default: ------------------ | Branch (1396:9): [True: 2.96k, False: 57.8k] ------------------ 1397| 4.32k| case OP_ANY: ------------------ | Branch (1397:9): [True: 1.35k, False: 59.5k] ------------------ 1398| 4.77k| case OP_ALLANY: ------------------ | Branch (1398:9): [True: 450, False: 60.4k] ------------------ 1399| 4.77k| return SSB_FAIL; 1400| | 1401| 5.11k| case OP_HSPACE: ------------------ | Branch (1401:9): [True: 5.11k, False: 55.7k] ------------------ 1402| 5.11k| SET_BIT(CHAR_HT); ------------------ | | 57| 5.11k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1403| 5.11k| SET_BIT(CHAR_SPACE); ------------------ | | 57| 5.11k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1404| | 1405| | /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set 1406| | the bits for 0xA0 and for code units >= 255, independently of UTF. */ 1407| | 1408| |#if PCRE2_CODE_UNIT_WIDTH != 8 1409| | SET_BIT(0xA0); 1410| | SET_BIT(0xFF); 1411| |#else 1412| | /* For the 8-bit library in UTF-8 mode, set the bits for the first code 1413| | units of horizontal space characters. */ 1414| | 1415| 5.11k|#ifdef SUPPORT_UNICODE 1416| 5.11k| if (utf) ------------------ | Branch (1416:13): [True: 1.64k, False: 3.47k] ------------------ 1417| 1.64k| { 1418| 1.64k| SET_BIT(0xC2); /* For U+00A0 */ ------------------ | | 57| 1.64k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1419| 1.64k| SET_BIT(0xE1); /* For U+1680, U+180E */ ------------------ | | 57| 1.64k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1420| 1.64k| SET_BIT(0xE2); /* For U+2000 - U+200A, U+202F, U+205F */ ------------------ | | 57| 1.64k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1421| 1.64k| SET_BIT(0xE3); /* For U+3000 */ ------------------ | | 57| 1.64k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1422| 1.64k| } 1423| 3.47k| else 1424| 3.47k|#endif 1425| | /* For the 8-bit library not in UTF-8 mode, set the bit for 0xA0, unless 1426| | the code is EBCDIC. */ 1427| 3.47k| { 1428| 3.47k|#ifndef EBCDIC 1429| 3.47k| SET_BIT(0xA0); ------------------ | | 57| 3.47k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1430| 3.47k|#endif /* Not EBCDIC */ 1431| 3.47k| } 1432| 5.11k|#endif /* 8-bit support */ 1433| 5.11k| break; 1434| | 1435| 4.11k| case OP_ANYNL: ------------------ | Branch (1435:9): [True: 4.11k, False: 56.7k] ------------------ 1436| 8.37k| case OP_VSPACE: ------------------ | Branch (1436:9): [True: 4.25k, False: 56.6k] ------------------ 1437| 8.37k| SET_BIT(CHAR_LF); ------------------ | | 57| 8.37k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1438| 8.37k| SET_BIT(CHAR_VT); ------------------ | | 57| 8.37k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1439| 8.37k| SET_BIT(CHAR_FF); ------------------ | | 57| 8.37k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1440| 8.37k| SET_BIT(CHAR_CR); ------------------ | | 57| 8.37k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1441| | 1442| | /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set 1443| | the bits for NEL and for code units >= 255, independently of UTF. */ 1444| | 1445| |#if PCRE2_CODE_UNIT_WIDTH != 8 1446| | SET_BIT(CHAR_NEL); 1447| | SET_BIT(0xFF); 1448| |#else 1449| | /* For the 8-bit library in UTF-8 mode, set the bits for the first code 1450| | units of vertical space characters. */ 1451| | 1452| 8.37k|#ifdef SUPPORT_UNICODE 1453| 8.37k| if (utf) ------------------ | Branch (1453:13): [True: 2.29k, False: 6.07k] ------------------ 1454| 2.29k| { 1455| 2.29k| SET_BIT(0xC2); /* For U+0085 (NEL) */ ------------------ | | 57| 2.29k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1456| 2.29k| SET_BIT(0xE2); /* For U+2028, U+2029 */ ------------------ | | 57| 2.29k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1457| 2.29k| } 1458| 6.07k| else 1459| 6.07k|#endif 1460| | /* For the 8-bit library not in UTF-8 mode, set the bit for NEL. */ 1461| 6.07k| { 1462| 6.07k| SET_BIT(CHAR_NEL); ------------------ | | 57| 6.07k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 1463| 6.07k| } 1464| 8.37k|#endif /* 8-bit support */ 1465| 8.37k| break; 1466| | 1467| 3.96k| case OP_NOT_DIGIT: ------------------ | Branch (1467:9): [True: 3.96k, False: 56.9k] ------------------ 1468| 3.96k| set_nottype_bits(re, cbit_digit, table_limit); ------------------ | | 565| 3.96k|#define cbit_digit 64 /* [:digit:] or \d */ ------------------ 1469| 3.96k| break; 1470| | 1471| 9.34k| case OP_DIGIT: ------------------ | Branch (1471:9): [True: 9.34k, False: 51.5k] ------------------ 1472| 9.34k| set_type_bits(re, cbit_digit, table_limit); ------------------ | | 565| 9.34k|#define cbit_digit 64 /* [:digit:] or \d */ ------------------ 1473| 9.34k| break; 1474| | 1475| 6.88k| case OP_NOT_WHITESPACE: ------------------ | Branch (1475:9): [True: 6.88k, False: 53.9k] ------------------ 1476| 6.88k| set_nottype_bits(re, cbit_space, table_limit); ------------------ | | 563| 6.88k|#define cbit_space 0 /* [:space:] or \s */ ------------------ 1477| 6.88k| break; 1478| | 1479| 9.11k| case OP_WHITESPACE: ------------------ | Branch (1479:9): [True: 9.11k, False: 51.7k] ------------------ 1480| 9.11k| set_type_bits(re, cbit_space, table_limit); ------------------ | | 563| 9.11k|#define cbit_space 0 /* [:space:] or \s */ ------------------ 1481| 9.11k| break; 1482| | 1483| 5.27k| case OP_NOT_WORDCHAR: ------------------ | Branch (1483:9): [True: 5.27k, False: 55.5k] ------------------ 1484| 5.27k| set_nottype_bits(re, cbit_word, table_limit); ------------------ | | 568| 5.27k|#define cbit_word 160 /* [:word:] or \w */ ------------------ 1485| 5.27k| break; 1486| | 1487| 8.01k| case OP_WORDCHAR: ------------------ | Branch (1487:9): [True: 8.01k, False: 52.8k] ------------------ 1488| 8.01k| set_type_bits(re, cbit_word, table_limit); ------------------ | | 568| 8.01k|#define cbit_word 160 /* [:word:] or \w */ ------------------ 1489| 8.01k| break; 1490| 60.8k| } 1491| | 1492| 56.0k| tcode += 2; 1493| 56.0k| break; 1494| | 1495| | /* Extended class: if there are any property checks, or if this is a 1496| | negative XCLASS without a map, give up. If there are no property checks, 1497| | there must be wide characters on the XCLASS list, because otherwise an 1498| | XCLASS would not have been created. This means that code points >= 255 1499| | are potential starters. In the UTF-8 case we can scan them and set bits 1500| | for the relevant leading bytes. */ 1501| | 1502| 0|#ifdef SUPPORT_WIDE_CHARS 1503| 2.22k| case OP_XCLASS: ------------------ | Branch (1503:7): [True: 2.22k, False: 929k] ------------------ 1504| 2.22k| xclassflags = tcode[1 + LINK_SIZE]; ------------------ | | 165| 2.22k|#define LINK_SIZE 2 ------------------ 1505| 2.22k| if ((xclassflags & XCL_HASPROP) != 0 || ------------------ | | 1311| 2.22k|#define XCL_HASPROP 0x04 /* Flag: property checks are present. */ ------------------ | Branch (1505:11): [True: 556, False: 1.67k] ------------------ 1506| 2.22k| (xclassflags & (XCL_MAP|XCL_NOT)) == XCL_NOT) ------------------ | | 1310| 1.67k|#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */ ------------------ (xclassflags & (XCL_MAP|XCL_NOT)) == XCL_NOT) ------------------ | | 1309| 1.67k|#define XCL_NOT 0x01 /* Flag: this is a negative class */ ------------------ (xclassflags & (XCL_MAP|XCL_NOT)) == XCL_NOT) ------------------ | | 1309| 1.67k|#define XCL_NOT 0x01 /* Flag: this is a negative class */ ------------------ | Branch (1506:11): [True: 6, False: 1.66k] ------------------ 1507| 562| return SSB_FAIL; 1508| | 1509| | /* We have a positive XCLASS or a negative one without a map. Set up the 1510| | map pointer if there is one, and fall through. */ 1511| | 1512| 1.66k| classmap = ((xclassflags & XCL_MAP) == 0)? NULL : ------------------ | | 1310| 1.66k|#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */ ------------------ | Branch (1512:18): [True: 499, False: 1.16k] ------------------ 1513| 1.66k| (uint8_t *)(tcode + 1 + LINK_SIZE + 1); ------------------ | | 165| 1.16k|#define LINK_SIZE 2 ------------------ 1514| | 1515| | /* In UTF-8 mode, scan the character list and set bits for leading bytes, 1516| | then jump to handle the map. */ 1517| | 1518| 1.66k|#if PCRE2_CODE_UNIT_WIDTH == 8 1519| 1.66k| if (utf && (xclassflags & XCL_NOT) == 0) ------------------ | | 1309| 1.66k|#define XCL_NOT 0x01 /* Flag: this is a negative class */ ------------------ | Branch (1519:11): [True: 1.66k, False: 0] | Branch (1519:18): [True: 1.34k, False: 317] ------------------ 1520| 1.34k| { 1521| 1.34k| PCRE2_UCHAR b, e; ------------------ | | 813| 1.34k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 1.34k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.34k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.34k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1522| 1.34k| PCRE2_SPTR p = tcode + 1 + LINK_SIZE + 1 + ((classmap == NULL)? 0:32); ------------------ | | 814| 1.34k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 1.34k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 1.34k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 1.34k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR p = tcode + 1 + LINK_SIZE + 1 + ((classmap == NULL)? 0:32); ------------------ | | 165| 1.34k|#define LINK_SIZE 2 ------------------ | Branch (1522:53): [True: 499, False: 849] ------------------ 1523| 1.34k| tcode += GET(tcode, 1); ------------------ | | 109| 1.34k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1524| | 1525| 6.57k| for (;;) switch (*p++) 1526| 6.57k| { 1527| 2.75k| case XCL_SINGLE: ------------------ | | 1314| 2.75k|#define XCL_SINGLE 1 /* Single item (one multibyte char) follows */ ------------------ | Branch (1527:11): [True: 2.75k, False: 3.82k] ------------------ 1528| 2.75k| b = *p++; 1529| 6.66k| while ((*p & 0xc0) == 0x80) p++; ------------------ | Branch (1529:18): [True: 3.91k, False: 2.75k] ------------------ 1530| 2.75k| re->start_bitmap[b/8] |= (1u << (b&7)); 1531| 2.75k| break; 1532| | 1533| 2.47k| case XCL_RANGE: ------------------ | | 1315| 2.47k|#define XCL_RANGE 2 /* A range (two multibyte chars) follows */ ------------------ | Branch (1533:11): [True: 2.47k, False: 4.09k] ------------------ 1534| 2.47k| b = *p++; 1535| 6.89k| while ((*p & 0xc0) == 0x80) p++; ------------------ | Branch (1535:18): [True: 4.42k, False: 2.47k] ------------------ 1536| 2.47k| e = *p++; 1537| 7.65k| while ((*p & 0xc0) == 0x80) p++; ------------------ | Branch (1537:18): [True: 5.17k, False: 2.47k] ------------------ 1538| 22.8k| for (; b <= e; b++) ------------------ | Branch (1538:18): [True: 20.3k, False: 2.47k] ------------------ 1539| 20.3k| re->start_bitmap[b/8] |= (1u << (b&7)); 1540| 2.47k| break; 1541| | 1542| 1.34k| case XCL_END: ------------------ | | 1313| 1.34k|#define XCL_END 0 /* Marks end of individual items */ ------------------ | Branch (1542:11): [True: 1.34k, False: 5.22k] ------------------ 1543| 1.34k| goto HANDLE_CLASSMAP; 1544| | 1545| 0| default: ------------------ | Branch (1545:11): [True: 0, False: 6.57k] ------------------ 1546| 0| return SSB_UNKNOWN; /* Internal error, should not occur */ 1547| 6.57k| } 1548| 1.34k| } 1549| 317|#endif /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 */ 1550| 317|#endif /* SUPPORT_WIDE_CHARS */ 1551| | 1552| | /* It seems that the fall through comment must be outside the #ifdef if 1553| | it is to avoid the gcc compiler warning. */ 1554| | 1555| | /* Fall through */ 1556| | 1557| | /* Enter here for a negative non-XCLASS. In the 8-bit library, if we are 1558| | in UTF mode, any byte with a value >= 0xc4 is a potentially valid starter 1559| | because it starts a character with a value > 255. In 8-bit non-UTF mode, 1560| | there is no difference between CLASS and NCLASS. In all other wide 1561| | character modes, set the 0xFF bit to indicate code units >= 255. */ 1562| | 1563| 2.19k| case OP_NCLASS: ------------------ | Branch (1563:7): [True: 1.88k, False: 930k] ------------------ 1564| 2.19k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 1565| 2.19k| if (utf) ------------------ | Branch (1565:11): [True: 438, False: 1.76k] ------------------ 1566| 438| { 1567| 438| re->start_bitmap[24] |= 0xf0; /* Bits for 0xc4 - 0xc8 */ 1568| 438| memset(re->start_bitmap+25, 0xff, 7); /* Bits for 0xc9 - 0xff */ 1569| 438| } 1570| |#elif PCRE2_CODE_UNIT_WIDTH != 8 1571| | SET_BIT(0xFF); /* For characters >= 255 */ 1572| |#endif 1573| | /* Fall through */ 1574| | 1575| | /* Enter here for a positive non-XCLASS. If we have fallen through from 1576| | an XCLASS, classmap will already be set; just advance the code pointer. 1577| | Otherwise, set up classmap for a a non-XCLASS and advance past it. */ 1578| | 1579| 17.3k| case OP_CLASS: ------------------ | Branch (1579:7): [True: 15.1k, False: 916k] ------------------ 1580| 17.3k| if (*tcode == OP_XCLASS) tcode += GET(tcode, 1); else ------------------ | | 109| 317| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (1580:11): [True: 317, False: 16.9k] ------------------ 1581| 16.9k| { 1582| 16.9k| classmap = (uint8_t *)(++tcode); 1583| 16.9k| tcode += 32 / sizeof(PCRE2_UCHAR); 1584| 16.9k| } 1585| | 1586| | /* When wide characters are supported, classmap may be NULL. In UTF-8 1587| | (sic) mode, the bits in a class bit map correspond to character values, 1588| | not to byte values. However, the bit map we are constructing is for byte 1589| | values. So we have to do a conversion for characters whose code point is 1590| | greater than 127. In fact, there are only two possible starting bytes for 1591| | characters in the range 128 - 255. */ 1592| | 1593| 17.3k|#if defined SUPPORT_WIDE_CHARS && PCRE2_CODE_UNIT_WIDTH == 8 1594| 18.6k| HANDLE_CLASSMAP: 1595| 18.6k|#endif 1596| 18.6k| if (classmap != NULL) ------------------ | Branch (1596:11): [True: 18.1k, False: 499] ------------------ 1597| 18.1k| { 1598| 18.1k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 1599| 18.1k| if (utf) ------------------ | Branch (1599:13): [True: 4.52k, False: 13.6k] ------------------ 1600| 4.52k| { 1601| 76.9k| for (c = 0; c < 16; c++) re->start_bitmap[c] |= classmap[c]; ------------------ | Branch (1601:23): [True: 72.4k, False: 4.52k] ------------------ 1602| 501k| for (c = 128; c < 256; c++) ------------------ | Branch (1602:25): [True: 497k, False: 4.52k] ------------------ 1603| 497k| { 1604| 497k| if ((classmap[c/8] & (1u << (c&7))) != 0) ------------------ | Branch (1604:17): [True: 1.48k, False: 495k] ------------------ 1605| 1.48k| { 1606| 1.48k| int d = (c >> 6) | 0xc0; /* Set bit for this starter */ 1607| 1.48k| re->start_bitmap[d/8] |= (1u << (d&7)); /* and then skip on to the */ 1608| 1.48k| c = (c & 0xc0) + 0x40 - 1; /* next relevant character. */ 1609| 1.48k| } 1610| 497k| } 1611| 4.52k| } 1612| 13.6k| else 1613| 13.6k|#endif 1614| | /* In all modes except UTF-8, the two bit maps are compatible. */ 1615| | 1616| 13.6k| { 1617| 449k| for (c = 0; c < 32; c++) re->start_bitmap[c] |= classmap[c]; ------------------ | Branch (1617:23): [True: 436k, False: 13.6k] ------------------ 1618| 13.6k| } 1619| 18.1k| } 1620| | 1621| | /* Act on what follows the class. For a zero minimum repeat, continue; 1622| | otherwise stop processing. */ 1623| | 1624| 18.6k| switch (*tcode) 1625| 18.6k| { 1626| 1.41k| case OP_CRSTAR: ------------------ | Branch (1626:9): [True: 1.41k, False: 17.2k] ------------------ 1627| 2.07k| case OP_CRMINSTAR: ------------------ | Branch (1627:9): [True: 657, False: 17.9k] ------------------ 1628| 4.78k| case OP_CRQUERY: ------------------ | Branch (1628:9): [True: 2.71k, False: 15.9k] ------------------ 1629| 6.08k| case OP_CRMINQUERY: ------------------ | Branch (1629:9): [True: 1.30k, False: 17.3k] ------------------ 1630| 6.93k| case OP_CRPOSSTAR: ------------------ | Branch (1630:9): [True: 848, False: 17.8k] ------------------ 1631| 8.24k| case OP_CRPOSQUERY: ------------------ | Branch (1631:9): [True: 1.30k, False: 17.3k] ------------------ 1632| 8.24k| tcode++; 1633| 8.24k| break; 1634| | 1635| 926| case OP_CRRANGE: ------------------ | Branch (1635:9): [True: 926, False: 17.7k] ------------------ 1636| 1.51k| case OP_CRMINRANGE: ------------------ | Branch (1636:9): [True: 584, False: 18.0k] ------------------ 1637| 2.35k| case OP_CRPOSRANGE: ------------------ | Branch (1637:9): [True: 849, False: 17.8k] ------------------ 1638| 2.35k| if (GET2(tcode, 1) == 0) tcode += 1 + 2 * IMM2_SIZE; ------------------ | | 194| 2.35k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ if (GET2(tcode, 1) == 0) tcode += 1 + 2 * IMM2_SIZE; ------------------ | | 193| 769|#define IMM2_SIZE 2 ------------------ | Branch (1638:13): [True: 769, False: 1.59k] ------------------ 1639| 1.59k| else try_next = FALSE; ------------------ | | 69| 1.59k|#define FALSE 0 ------------------ 1640| 2.35k| break; 1641| | 1642| 8.04k| default: ------------------ | Branch (1642:9): [True: 8.04k, False: 10.6k] ------------------ 1643| 8.04k| try_next = FALSE; ------------------ | | 69| 8.04k|#define FALSE 0 ------------------ 1644| 8.04k| break; 1645| 18.6k| } 1646| 18.6k| break; /* End of class handling case */ 1647| 932k| } /* End of switch for opcodes */ 1648| 932k| } /* End of try_next loop */ 1649| | 1650| 143k| code += GET(code, 1); /* Advance to next branch */ ------------------ | | 109| 143k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 1651| 143k| } 1652| 329k|while (*code == OP_ALT); ------------------ | Branch (1652:8): [True: 86.2k, False: 57.6k] ------------------ 1653| | 1654| 57.6k|return yield; 1655| 329k|} pcre2_study.c:set_table_bit: 785| 84.0k|{ 786| 84.0k|uint32_t c = *p++; /* First code unit */ 787| | 788| 84.0k|(void)utf; /* Stop compiler warnings when UTF not supported */ 789| 84.0k|(void)ucp; 790| | 791| |/* In 16-bit and 32-bit modes, code units greater than 0xff set the bit for 792| |0xff. */ 793| | 794| |#if PCRE2_CODE_UNIT_WIDTH != 8 795| |if (c > 0xff) SET_BIT(0xff); else 796| |#endif 797| | 798| 84.0k|SET_BIT(c); ------------------ | | 57| 84.0k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 799| | 800| |/* In UTF-8 or UTF-16 mode, pick up the remaining code units in order to find 801| |the end of the character, even when caseless. */ 802| | 803| 84.0k|#ifdef SUPPORT_UNICODE 804| 84.0k|if (utf) ------------------ | Branch (804:5): [True: 17.3k, False: 66.6k] ------------------ 805| 17.3k| { 806| 17.3k|#if PCRE2_CODE_UNIT_WIDTH == 8 807| 17.3k| if (c >= 0xc0) GETUTF8INC(c, p); ------------------ | | 288| 5.05k| { \ | | 289| 5.05k| if ((c & 0x20u) == 0) \ | | ------------------ | | | Branch (289:9): [True: 2.58k, False: 2.46k] | | ------------------ | | 290| 5.05k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | 291| 5.05k| else if ((c & 0x10u) == 0) \ | | ------------------ | | | Branch (291:14): [True: 1.86k, False: 607] | | ------------------ | | 292| 2.46k| { \ | | 293| 1.86k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | 294| 1.86k| eptr += 2; \ | | 295| 1.86k| } \ | | 296| 2.46k| else if ((c & 0x08u) == 0) \ | | ------------------ | | | Branch (296:14): [True: 607, False: 0] | | ------------------ | | 297| 607| { \ | | 298| 607| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | 299| 607| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | 300| 607| eptr += 3; \ | | 301| 607| } \ | | 302| 607| else if ((c & 0x04u) == 0) \ | | ------------------ | | | Branch (302:14): [True: 0, False: 0] | | ------------------ | | 303| 0| { \ | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | 306| 0| (eptr[3] & 0x3fu); \ | | 307| 0| eptr += 4; \ | | 308| 0| } \ | | 309| 0| else \ | | 310| 0| { \ | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | 314| 0| eptr += 5; \ | | 315| 0| } \ | | 316| 5.05k| } ------------------ | Branch (807:7): [True: 5.05k, False: 12.3k] ------------------ 808| |#elif PCRE2_CODE_UNIT_WIDTH == 16 809| | if ((c & 0xfc00) == 0xd800) GETUTF16INC(c, p); 810| |#endif 811| 17.3k| } 812| 84.0k|#endif /* SUPPORT_UNICODE */ 813| | 814| |/* If caseless, handle the other case of the character. */ 815| | 816| 84.0k|if (caseless) ------------------ | Branch (816:5): [True: 24.9k, False: 59.0k] ------------------ 817| 24.9k| { 818| 24.9k|#ifdef SUPPORT_UNICODE 819| 24.9k| if (utf || ucp) ------------------ | Branch (819:7): [True: 13.3k, False: 11.5k] | Branch (819:14): [True: 8.66k, False: 2.89k] ------------------ 820| 22.0k| { 821| 22.0k| c = UCD_OTHERCASE(c); ------------------ | | 1862| 22.0k|#define UCD_OTHERCASE(ch) ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case))) | | ------------------ | | | | 1846| 22.0k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | | | ------------------ | | | | | | 1838| 22.0k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | | | ------------------ | | | | | | | | 177| 22.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | 1839| 22.0k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 22.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 177| 22.0k|#define PRIV(name) _pcre2_##name | | | | | | ------------------ | | | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | | | ------------------ | | | | | | | | 1837| 22.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | 1840| 22.0k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 22.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | | | ------------------ | | | | | | | | 1837| 22.0k|#define UCD_BLOCK_SIZE 128 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 822| 22.0k|#if PCRE2_CODE_UNIT_WIDTH == 8 823| 22.0k| if (utf) ------------------ | Branch (823:9): [True: 13.3k, False: 8.66k] ------------------ 824| 13.3k| { 825| 13.3k| PCRE2_UCHAR buff[6]; ------------------ | | 813| 13.3k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 13.3k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 13.3k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 13.3k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 826| 13.3k| (void)PRIV(ord2utf)(c, buff); ------------------ | | 177| 13.3k|#define PRIV(name) _pcre2_##name ------------------ 827| 13.3k| SET_BIT(buff[0]); ------------------ | | 57| 13.3k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 828| 13.3k| } 829| 8.66k| else if (c < 256) SET_BIT(c); ------------------ | | 57| 6.95k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ | Branch (829:14): [True: 6.95k, False: 1.70k] ------------------ 830| |#else /* 16-bit or 32-bit mode */ 831| | if (c > 0xff) SET_BIT(0xff); else SET_BIT(c); 832| |#endif 833| 22.0k| } 834| | 835| 2.89k| else 836| 2.89k|#endif /* SUPPORT_UNICODE */ 837| | 838| | /* Not UTF or UCP */ 839| | 840| 2.89k| if (MAX_255(c)) SET_BIT(re->tables[fcc_offset + c]); ------------------ | | 212| 2.89k|#define MAX_255(c) TRUE | | ------------------ | | | | 70| 2.89k|#define TRUE 1 | | | | ------------------ | | | | | Branch (70:17): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ if (MAX_255(c)) SET_BIT(re->tables[fcc_offset + c]); ------------------ | | 57| 2.89k|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 841| 24.9k| } 842| | 843| 84.0k|return p; 844| 84.0k|} pcre2_study.c:set_nottype_bits: 910| 25.4k|{ 911| 25.4k|uint32_t c; 912| 737k|for (c = 0; c < table_limit; c++) ------------------ | Branch (912:13): [True: 711k, False: 25.4k] ------------------ 913| 711k| re->start_bitmap[c] |= (uint8_t)(~(re->tables[c+cbits_offset+cbit_type])); ------------------ | | 590| 711k|#define cbits_offset 512 /* Character classes */ ------------------ 914| 25.4k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 915| 57.0k|if (table_limit != 32) for (c = 24; c < 32; c++) re->start_bitmap[c] = 0xff; ------------------ | Branch (915:5): [True: 6.34k, False: 19.0k] | Branch (915:37): [True: 50.7k, False: 6.34k] ------------------ 916| 25.4k|#endif 917| 25.4k|} pcre2_study.c:set_type_bits: 869| 46.3k|{ 870| 46.3k|uint32_t c; 871| 1.25M|for (c = 0; c < table_limit; c++) ------------------ | Branch (871:13): [True: 1.21M, False: 46.3k] ------------------ 872| 1.21M| re->start_bitmap[c] |= re->tables[c+cbits_offset+cbit_type]; ------------------ | | 590| 1.21M|#define cbits_offset 512 /* Character classes */ ------------------ 873| 46.3k|#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 874| 46.3k|if (table_limit == 32) return; ------------------ | Branch (874:5): [True: 29.4k, False: 16.9k] ------------------ 875| 2.18M|for (c = 128; c < 256; c++) ------------------ | Branch (875:15): [True: 2.16M, False: 16.9k] ------------------ 876| 2.16M| { 877| 2.16M| if ((re->tables[cbits_offset + c/8] & (1u << (c&7))) != 0) ------------------ | | 590| 2.16M|#define cbits_offset 512 /* Character classes */ ------------------ | Branch (877:7): [True: 0, False: 2.16M] ------------------ 878| 0| { 879| 0| PCRE2_UCHAR buff[6]; ------------------ | | 813| 0|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 0|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 0|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 0|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 880| 0| (void)PRIV(ord2utf)(c, buff); ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ 881| 0| SET_BIT(buff[0]); ------------------ | | 57| 0|#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) ------------------ 882| 0| } 883| 2.16M| } 884| 16.9k|#endif /* UTF-8 */ 885| 16.9k|} pcre2_study.c:find_minlength: 106| 378k|{ 107| 378k|int length = -1; 108| 378k|int branchlength = 0; 109| 378k|int prev_cap_recno = -1; 110| 378k|int prev_cap_d = 0; 111| 378k|int prev_recurse_recno = -1; 112| 378k|int prev_recurse_d = 0; 113| 378k|uint32_t once_fudge = 0; 114| 378k|BOOL had_recurse = FALSE; ------------------ | | 69| 378k|#define FALSE 0 ------------------ 115| 378k|BOOL dupcapused = (re->flags & PCRE2_DUPCAPUSED) != 0; ------------------ | | 528| 378k|#define PCRE2_DUPCAPUSED 0x00200000 /* contains (?| */ ------------------ 116| 378k|PCRE2_SPTR nextbranch = code + GET(code, 1); ------------------ | | 814| 378k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 378k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 378k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 378k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_SPTR nextbranch = code + GET(code, 1); ------------------ | | 109| 378k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 117| 378k|PCRE2_UCHAR *cc = (PCRE2_UCHAR *)code + 1 + LINK_SIZE; ------------------ | | 813| 378k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 378k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 378k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 378k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ PCRE2_UCHAR *cc = (PCRE2_UCHAR *)code + 1 + LINK_SIZE; ------------------ | | 165| 378k|#define LINK_SIZE 2 ------------------ 118| 378k|recurse_check this_recurse; 119| | 120| |/* If this is a "could be empty" group, its minimum length is 0. */ 121| | 122| 378k|if (*code >= OP_SBRA && *code <= OP_SCOND) return 0; ------------------ | Branch (122:5): [True: 2.29k, False: 375k] | Branch (122:25): [True: 2.29k, False: 0] ------------------ 123| | 124| |/* Skip over capturing bracket number */ 125| | 126| 375k|if (*code == OP_CBRA || *code == OP_CBRAPOS) cc += IMM2_SIZE; ------------------ | | 193| 154k|#define IMM2_SIZE 2 ------------------ | Branch (126:5): [True: 153k, False: 222k] | Branch (126:25): [True: 1.16k, False: 221k] ------------------ 127| | 128| |/* A large and/or complex regex can take too long to process. */ 129| | 130| 375k|if ((*countptr)++ > 1000) return -1; ------------------ | Branch (130:5): [True: 116, False: 375k] ------------------ 131| | 132| |/* Scan along the opcodes for this branch. If we get to the end of the branch, 133| |check the length against that of the other branches. If the accumulated length 134| |passes 16-bits, reset to that value and skip the rest of the branch. */ 135| | 136| 375k|for (;;) 137| 2.06M| { 138| 2.06M| int d, min, recno; 139| 2.06M| PCRE2_UCHAR op, *cs, *ce; ------------------ | | 813| 2.06M|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 2.06M|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 2.06M|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 2.06M|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 140| | 141| 2.06M| if (branchlength >= UINT16_MAX) ------------------ | Branch (141:7): [True: 969, False: 2.06M] ------------------ 142| 969| { 143| 969| branchlength = UINT16_MAX; 144| 969| cc = (PCRE2_UCHAR *)nextbranch; 145| 969| } 146| | 147| 2.06M| op = *cc; 148| 2.06M| switch (op) 149| 2.06M| { 150| 4.19k| case OP_COND: ------------------ | Branch (150:5): [True: 4.19k, False: 2.05M] ------------------ 151| 5.17k| case OP_SCOND: ------------------ | Branch (151:5): [True: 980, False: 2.06M] ------------------ 152| | 153| | /* If there is only one branch in a condition, the implied branch has zero 154| | length, so we don't add anything. This covers the DEFINE "condition" 155| | automatically. If there are two branches we can treat it the same as any 156| | other non-capturing subpattern. */ 157| | 158| 5.17k| cs = cc + GET(cc, 1); ------------------ | | 109| 5.17k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 159| 5.17k| if (*cs != OP_ALT) ------------------ | Branch (159:9): [True: 2.65k, False: 2.52k] ------------------ 160| 2.65k| { 161| 2.65k| cc = cs + 1 + LINK_SIZE; ------------------ | | 165| 2.65k|#define LINK_SIZE 2 ------------------ 162| 2.65k| break; 163| 2.65k| } 164| 2.52k| goto PROCESS_NON_CAPTURE; 165| | 166| 168k| case OP_BRA: ------------------ | Branch (166:5): [True: 168k, False: 1.89M] ------------------ 167| | /* There's a special case of OP_BRA, when it is wrapped round a repeated 168| | OP_RECURSE. We'd like to process the latter at this level so that 169| | remembering the value works for repeated cases. So we do nothing, but 170| | set a fudge value to skip over the OP_KET after the recurse. */ 171| | 172| 168k| if (cc[1+LINK_SIZE] == OP_RECURSE && cc[2*(1+LINK_SIZE)] == OP_KET) ------------------ | | 165| 168k|#define LINK_SIZE 2 ------------------ if (cc[1+LINK_SIZE] == OP_RECURSE && cc[2*(1+LINK_SIZE)] == OP_KET) ------------------ | | 165| 3.55k|#define LINK_SIZE 2 ------------------ | Branch (172:9): [True: 3.55k, False: 164k] | Branch (172:42): [True: 1.95k, False: 1.60k] ------------------ 173| 1.95k| { 174| 1.95k| once_fudge = 1 + LINK_SIZE; ------------------ | | 165| 1.95k|#define LINK_SIZE 2 ------------------ 175| 1.95k| cc += 1 + LINK_SIZE; ------------------ | | 165| 1.95k|#define LINK_SIZE 2 ------------------ 176| 1.95k| break; 177| 1.95k| } 178| | /* Fall through */ 179| | 180| 177k| case OP_ONCE: ------------------ | Branch (180:5): [True: 11.2k, False: 2.05M] ------------------ 181| 180k| case OP_SCRIPT_RUN: ------------------ | Branch (181:5): [True: 3.06k, False: 2.06M] ------------------ 182| 181k| case OP_SBRA: ------------------ | Branch (182:5): [True: 403, False: 2.06M] ------------------ 183| 182k| case OP_BRAPOS: ------------------ | Branch (183:5): [True: 1.70k, False: 2.06M] ------------------ 184| 183k| case OP_SBRAPOS: ------------------ | Branch (184:5): [True: 432, False: 2.06M] ------------------ 185| 185k| PROCESS_NON_CAPTURE: 186| 185k| d = find_minlength(re, cc, startcode, utf, recurses, countptr, 187| 185k| backref_cache); 188| 185k| if (d < 0) return d; ------------------ | Branch (188:9): [True: 326, False: 185k] ------------------ 189| 185k| branchlength += d; 190| 199k| do cc += GET(cc, 1); while (*cc == OP_ALT); ------------------ | | 109| 199k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (190:33): [True: 14.2k, False: 185k] ------------------ 191| 185k| cc += 1 + LINK_SIZE; ------------------ | | 165| 185k|#define LINK_SIZE 2 ------------------ 192| 185k| break; 193| | 194| | /* To save time for repeated capturing subpatterns, we remember the 195| | length of the previous one. Unfortunately we can't do the same for 196| | the unnumbered ones above. Nor can we do this if (?| is present in the 197| | pattern because captures with the same number are not then identical. */ 198| | 199| 428k| case OP_CBRA: ------------------ | Branch (199:5): [True: 428k, False: 1.63M] ------------------ 200| 429k| case OP_SCBRA: ------------------ | Branch (200:5): [True: 688, False: 2.06M] ------------------ 201| 430k| case OP_CBRAPOS: ------------------ | Branch (201:5): [True: 1.12k, False: 2.06M] ------------------ 202| 430k| case OP_SCBRAPOS: ------------------ | Branch (202:5): [True: 267, False: 2.06M] ------------------ 203| 430k| recno = (int)GET2(cc, 1+LINK_SIZE); ------------------ | | 194| 430k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 204| 430k| if (dupcapused || recno != prev_cap_recno) ------------------ | Branch (204:9): [True: 34.5k, False: 396k] | Branch (204:23): [True: 94.0k, False: 302k] ------------------ 205| 128k| { 206| 128k| prev_cap_recno = recno; 207| 128k| prev_cap_d = find_minlength(re, cc, startcode, utf, recurses, countptr, 208| 128k| backref_cache); 209| 128k| if (prev_cap_d < 0) return prev_cap_d; ------------------ | Branch (209:11): [True: 1.10k, False: 127k] ------------------ 210| 128k| } 211| 429k| branchlength += prev_cap_d; 212| 464k| do cc += GET(cc, 1); while (*cc == OP_ALT); ------------------ | | 109| 464k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (212:33): [True: 34.9k, False: 429k] ------------------ 213| 429k| cc += 1 + LINK_SIZE; ------------------ | | 165| 429k|#define LINK_SIZE 2 ------------------ 214| 429k| break; 215| | 216| | /* ACCEPT makes things far too complicated; we have to give up. In fact, 217| | from 10.34 onwards, if a pattern contains (*ACCEPT), this function is not 218| | used. However, leave the code in place, just in case. */ 219| | 220| 0| case OP_ACCEPT: ------------------ | Branch (220:5): [True: 0, False: 2.06M] ------------------ 221| 0| case OP_ASSERT_ACCEPT: ------------------ | Branch (221:5): [True: 0, False: 2.06M] ------------------ 222| 0| return -1; 223| | 224| | /* Reached end of a branch; if it's a ket it is the end of a nested 225| | call. If it's ALT it is an alternation in a nested call. If it is END it's 226| | the end of the outer call. All can be handled by the same code. If the 227| | length of any branch is zero, there is no need to scan any subsequent 228| | branches. */ 229| | 230| 19.2k| case OP_ALT: ------------------ | Branch (230:5): [True: 19.2k, False: 2.04M] ------------------ 231| 378k| case OP_KET: ------------------ | Branch (231:5): [True: 359k, False: 1.70M] ------------------ 232| 380k| case OP_KETRMAX: ------------------ | Branch (232:5): [True: 2.23k, False: 2.06M] ------------------ 233| 381k| case OP_KETRMIN: ------------------ | Branch (233:5): [True: 1.14k, False: 2.06M] ------------------ 234| 384k| case OP_KETRPOS: ------------------ | Branch (234:5): [True: 2.86k, False: 2.06M] ------------------ 235| 384k| case OP_END: ------------------ | Branch (235:5): [True: 0, False: 2.06M] ------------------ 236| 384k| if (length < 0 || (!had_recurse && branchlength < length)) ------------------ | Branch (236:9): [True: 373k, False: 11.2k] | Branch (236:24): [True: 10.1k, False: 1.11k] | Branch (236:40): [True: 7.09k, False: 3.07k] ------------------ 237| 380k| length = branchlength; 238| 384k| if (op != OP_ALT || length == 0) return length; ------------------ | Branch (238:9): [True: 365k, False: 19.2k] | Branch (238:25): [True: 8.01k, False: 11.2k] ------------------ 239| 11.2k| nextbranch = cc + GET(cc, 1); ------------------ | | 109| 11.2k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 240| 11.2k| cc += 1 + LINK_SIZE; ------------------ | | 165| 11.2k|#define LINK_SIZE 2 ------------------ 241| 11.2k| branchlength = 0; 242| 11.2k| had_recurse = FALSE; ------------------ | | 69| 11.2k|#define FALSE 0 ------------------ 243| 11.2k| break; 244| | 245| | /* Skip over assertive subpatterns */ 246| | 247| 1.05k| case OP_ASSERT: ------------------ | Branch (247:5): [True: 1.05k, False: 2.06M] ------------------ 248| 7.52k| case OP_ASSERT_NOT: ------------------ | Branch (248:5): [True: 6.47k, False: 2.05M] ------------------ 249| 8.40k| case OP_ASSERTBACK: ------------------ | Branch (249:5): [True: 881, False: 2.06M] ------------------ 250| 9.31k| case OP_ASSERTBACK_NOT: ------------------ | Branch (250:5): [True: 904, False: 2.06M] ------------------ 251| 10.7k| case OP_ASSERT_NA: ------------------ | Branch (251:5): [True: 1.39k, False: 2.06M] ------------------ 252| 11.1k| case OP_ASSERTBACK_NA: ------------------ | Branch (252:5): [True: 428, False: 2.06M] ------------------ 253| 12.4k| do cc += GET(cc, 1); while (*cc == OP_ALT); ------------------ | | 109| 12.4k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (253:33): [True: 1.28k, False: 11.1k] ------------------ 254| | /* Fall through */ 255| | 256| | /* Skip over things that don't match chars */ 257| | 258| 11.1k| case OP_REVERSE: ------------------ | Branch (258:5): [True: 0, False: 2.06M] ------------------ 259| 11.8k| case OP_CREF: ------------------ | Branch (259:5): [True: 671, False: 2.06M] ------------------ 260| 12.0k| case OP_DNCREF: ------------------ | Branch (260:5): [True: 254, False: 2.06M] ------------------ 261| 12.6k| case OP_RREF: ------------------ | Branch (261:5): [True: 539, False: 2.06M] ------------------ 262| 12.8k| case OP_DNRREF: ------------------ | Branch (262:5): [True: 267, False: 2.06M] ------------------ 263| 13.2k| case OP_FALSE: ------------------ | Branch (263:5): [True: 362, False: 2.06M] ------------------ 264| 13.5k| case OP_TRUE: ------------------ | Branch (264:5): [True: 311, False: 2.06M] ------------------ 265| 288k| case OP_CALLOUT: ------------------ | Branch (265:5): [True: 274k, False: 1.78M] ------------------ 266| 289k| case OP_SOD: ------------------ | Branch (266:5): [True: 1.42k, False: 2.06M] ------------------ 267| 291k| case OP_SOM: ------------------ | Branch (267:5): [True: 1.89k, False: 2.06M] ------------------ 268| 292k| case OP_EOD: ------------------ | Branch (268:5): [True: 765, False: 2.06M] ------------------ 269| 293k| case OP_EODN: ------------------ | Branch (269:5): [True: 886, False: 2.06M] ------------------ 270| 295k| case OP_CIRC: ------------------ | Branch (270:5): [True: 2.91k, False: 2.06M] ------------------ 271| 297k| case OP_CIRCM: ------------------ | Branch (271:5): [True: 1.20k, False: 2.06M] ------------------ 272| 303k| case OP_DOLL: ------------------ | Branch (272:5): [True: 6.44k, False: 2.05M] ------------------ 273| 306k| case OP_DOLLM: ------------------ | Branch (273:5): [True: 2.61k, False: 2.06M] ------------------ 274| 307k| case OP_NOT_WORD_BOUNDARY: ------------------ | Branch (274:5): [True: 1.64k, False: 2.06M] ------------------ 275| 309k| case OP_WORD_BOUNDARY: ------------------ | Branch (275:5): [True: 1.57k, False: 2.06M] ------------------ 276| 310k| case OP_NOT_UCP_WORD_BOUNDARY: ------------------ | Branch (276:5): [True: 1.35k, False: 2.06M] ------------------ 277| 311k| case OP_UCP_WORD_BOUNDARY: ------------------ | Branch (277:5): [True: 816, False: 2.06M] ------------------ 278| 311k| cc += PRIV(OP_lengths)[*cc]; ------------------ | | 177| 311k|#define PRIV(name) _pcre2_##name ------------------ 279| 311k| break; 280| | 281| 1.02k| case OP_CALLOUT_STR: ------------------ | Branch (281:5): [True: 1.02k, False: 2.06M] ------------------ 282| 1.02k| cc += GET(cc, 1 + 2*LINK_SIZE); ------------------ | | 109| 1.02k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 283| 1.02k| break; 284| | 285| | /* Skip over a subpattern that has a {0} or {0,x} quantifier */ 286| | 287| 2.49k| case OP_BRAZERO: ------------------ | Branch (287:5): [True: 2.49k, False: 2.06M] ------------------ 288| 2.92k| case OP_BRAMINZERO: ------------------ | Branch (288:5): [True: 433, False: 2.06M] ------------------ 289| 4.20k| case OP_BRAPOSZERO: ------------------ | Branch (289:5): [True: 1.27k, False: 2.06M] ------------------ 290| 4.53k| case OP_SKIPZERO: ------------------ | Branch (290:5): [True: 336, False: 2.06M] ------------------ 291| 4.53k| cc += PRIV(OP_lengths)[*cc]; ------------------ | | 177| 4.53k|#define PRIV(name) _pcre2_##name ------------------ 292| 5.20k| do cc += GET(cc, 1); while (*cc == OP_ALT); ------------------ | | 109| 5.20k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (292:33): [True: 672, False: 4.53k] ------------------ 293| 4.53k| cc += 1 + LINK_SIZE; ------------------ | | 165| 4.53k|#define LINK_SIZE 2 ------------------ 294| 4.53k| break; 295| | 296| | /* Handle literal characters and + repetitions */ 297| | 298| 358k| case OP_CHAR: ------------------ | Branch (298:5): [True: 358k, False: 1.70M] ------------------ 299| 430k| case OP_CHARI: ------------------ | Branch (299:5): [True: 71.8k, False: 1.99M] ------------------ 300| 432k| case OP_NOT: ------------------ | Branch (300:5): [True: 1.79k, False: 2.06M] ------------------ 301| 433k| case OP_NOTI: ------------------ | Branch (301:5): [True: 1.27k, False: 2.06M] ------------------ 302| 436k| case OP_PLUS: ------------------ | Branch (302:5): [True: 2.71k, False: 2.06M] ------------------ 303| 437k| case OP_PLUSI: ------------------ | Branch (303:5): [True: 1.07k, False: 2.06M] ------------------ 304| 439k| case OP_MINPLUS: ------------------ | Branch (304:5): [True: 2.17k, False: 2.06M] ------------------ 305| 442k| case OP_MINPLUSI: ------------------ | Branch (305:5): [True: 2.97k, False: 2.06M] ------------------ 306| 447k| case OP_POSPLUS: ------------------ | Branch (306:5): [True: 5.50k, False: 2.05M] ------------------ 307| 449k| case OP_POSPLUSI: ------------------ | Branch (307:5): [True: 1.06k, False: 2.06M] ------------------ 308| 450k| case OP_NOTPLUS: ------------------ | Branch (308:5): [True: 1.32k, False: 2.06M] ------------------ 309| 450k| case OP_NOTPLUSI: ------------------ | Branch (309:5): [True: 373, False: 2.06M] ------------------ 310| 451k| case OP_NOTMINPLUS: ------------------ | Branch (310:5): [True: 464, False: 2.06M] ------------------ 311| 452k| case OP_NOTMINPLUSI: ------------------ | Branch (311:5): [True: 1.09k, False: 2.06M] ------------------ 312| 452k| case OP_NOTPOSPLUS: ------------------ | Branch (312:5): [True: 433, False: 2.06M] ------------------ 313| 453k| case OP_NOTPOSPLUSI: ------------------ | Branch (313:5): [True: 343, False: 2.06M] ------------------ 314| 453k| branchlength++; 315| 453k| cc += 2; 316| 453k|#ifdef SUPPORT_UNICODE 317| 453k| if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); ------------------ | | 286| 75.4k|#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c) | | ------------------ | | | | 254| 75.4k|#define HASUTF8EXTRALEN(c) ((c) >= 0xc0) | | | | ------------------ | | | | | Branch (254:28): [True: 12.8k, False: 62.5k] | | | | ------------------ | | ------------------ ------------------ if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); ------------------ | | 291| 12.8k|#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu]) | | ------------------ | | | | 177| 12.8k|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ | Branch (317:9): [True: 75.4k, False: 377k] ------------------ 318| 453k|#endif 319| 453k| break; 320| | 321| 10.4k| case OP_TYPEPLUS: ------------------ | Branch (321:5): [True: 10.4k, False: 2.05M] ------------------ 322| 15.3k| case OP_TYPEMINPLUS: ------------------ | Branch (322:5): [True: 4.84k, False: 2.05M] ------------------ 323| 19.7k| case OP_TYPEPOSPLUS: ------------------ | Branch (323:5): [True: 4.41k, False: 2.05M] ------------------ 324| 19.7k| branchlength++; 325| 19.7k| cc += (cc[1] == OP_PROP || cc[1] == OP_NOTPROP)? 4 : 2; ------------------ | Branch (325:12): [True: 2.29k, False: 17.4k] | Branch (325:32): [True: 2.51k, False: 14.9k] ------------------ 326| 19.7k| break; 327| | 328| | /* Handle exact repetitions. The count is already in characters, but we 329| | may need to skip over a multibyte character in UTF mode. */ 330| | 331| 2.59k| case OP_EXACT: ------------------ | Branch (331:5): [True: 2.59k, False: 2.06M] ------------------ 332| 5.98k| case OP_EXACTI: ------------------ | Branch (332:5): [True: 3.38k, False: 2.06M] ------------------ 333| 8.51k| case OP_NOTEXACT: ------------------ | Branch (333:5): [True: 2.53k, False: 2.06M] ------------------ 334| 10.7k| case OP_NOTEXACTI: ------------------ | Branch (334:5): [True: 2.25k, False: 2.06M] ------------------ 335| 10.7k| branchlength += GET2(cc,1); ------------------ | | 194| 10.7k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 336| 10.7k| cc += 2 + IMM2_SIZE; ------------------ | | 193| 10.7k|#define IMM2_SIZE 2 ------------------ 337| 10.7k|#ifdef SUPPORT_UNICODE 338| 10.7k| if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); ------------------ | | 286| 4.19k|#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c) | | ------------------ | | | | 254| 4.19k|#define HASUTF8EXTRALEN(c) ((c) >= 0xc0) | | | | ------------------ | | | | | Branch (254:28): [True: 361, False: 3.83k] | | | | ------------------ | | ------------------ ------------------ if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); ------------------ | | 291| 361|#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu]) | | ------------------ | | | | 177| 361|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ | Branch (338:9): [True: 4.19k, False: 6.57k] ------------------ 339| 10.7k|#endif 340| 10.7k| break; 341| | 342| 5.02k| case OP_TYPEEXACT: ------------------ | Branch (342:5): [True: 5.02k, False: 2.05M] ------------------ 343| 5.02k| branchlength += GET2(cc,1); ------------------ | | 194| 5.02k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 344| 5.02k| cc += 2 + IMM2_SIZE + ((cc[1 + IMM2_SIZE] == OP_PROP ------------------ | | 193| 5.02k|#define IMM2_SIZE 2 ------------------ cc += 2 + IMM2_SIZE + ((cc[1 + IMM2_SIZE] == OP_PROP ------------------ | | 193| 5.02k|#define IMM2_SIZE 2 ------------------ | Branch (344:29): [True: 622, False: 4.40k] ------------------ 345| 5.02k| || cc[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0); ------------------ | | 193| 4.40k|#define IMM2_SIZE 2 ------------------ | Branch (345:10): [True: 1.70k, False: 2.70k] ------------------ 346| 5.02k| break; 347| | 348| | /* Handle single-char non-literal matchers */ 349| | 350| 5.29k| case OP_PROP: ------------------ | Branch (350:5): [True: 5.29k, False: 2.05M] ------------------ 351| 11.7k| case OP_NOTPROP: ------------------ | Branch (351:5): [True: 6.44k, False: 2.05M] ------------------ 352| 11.7k| cc += 2; 353| | /* Fall through */ 354| | 355| 13.2k| case OP_NOT_DIGIT: ------------------ | Branch (355:5): [True: 1.48k, False: 2.06M] ------------------ 356| 16.2k| case OP_DIGIT: ------------------ | Branch (356:5): [True: 3.05k, False: 2.06M] ------------------ 357| 19.2k| case OP_NOT_WHITESPACE: ------------------ | Branch (357:5): [True: 3.02k, False: 2.06M] ------------------ 358| 20.7k| case OP_WHITESPACE: ------------------ | Branch (358:5): [True: 1.46k, False: 2.06M] ------------------ 359| 23.0k| case OP_NOT_WORDCHAR: ------------------ | Branch (359:5): [True: 2.24k, False: 2.06M] ------------------ 360| 25.2k| case OP_WORDCHAR: ------------------ | Branch (360:5): [True: 2.22k, False: 2.06M] ------------------ 361| 30.4k| case OP_ANY: ------------------ | Branch (361:5): [True: 5.20k, False: 2.05M] ------------------ 362| 31.8k| case OP_ALLANY: ------------------ | Branch (362:5): [True: 1.37k, False: 2.06M] ------------------ 363| 32.8k| case OP_EXTUNI: ------------------ | Branch (363:5): [True: 1.08k, False: 2.06M] ------------------ 364| 34.7k| case OP_HSPACE: ------------------ | Branch (364:5): [True: 1.86k, False: 2.06M] ------------------ 365| 44.9k| case OP_NOT_HSPACE: ------------------ | Branch (365:5): [True: 10.1k, False: 2.05M] ------------------ 366| 46.0k| case OP_VSPACE: ------------------ | Branch (366:5): [True: 1.12k, False: 2.06M] ------------------ 367| 49.4k| case OP_NOT_VSPACE: ------------------ | Branch (367:5): [True: 3.37k, False: 2.06M] ------------------ 368| 49.4k| branchlength++; 369| 49.4k| cc++; 370| 49.4k| break; 371| | 372| | /* "Any newline" might match two characters, but it also might match just 373| | one. */ 374| | 375| 2.36k| case OP_ANYNL: ------------------ | Branch (375:5): [True: 2.36k, False: 2.06M] ------------------ 376| 2.36k| branchlength += 1; 377| 2.36k| cc++; 378| 2.36k| break; 379| | 380| | /* The single-byte matcher means we can't proceed in UTF mode. (In 381| | non-UTF mode \C will actually be turned into OP_ALLANY, so won't ever 382| | appear, but leave the code, just in case.) */ 383| | 384| 0| case OP_ANYBYTE: ------------------ | Branch (384:5): [True: 0, False: 2.06M] ------------------ 385| 0|#ifdef SUPPORT_UNICODE 386| 0| if (utf) return -1; ------------------ | Branch (386:9): [True: 0, False: 0] ------------------ 387| 0|#endif 388| 0| branchlength++; 389| 0| cc++; 390| 0| break; 391| | 392| | /* For repeated character types, we have to test for \p and \P, which have 393| | an extra two bytes of parameters. */ 394| | 395| 17.3k| case OP_TYPESTAR: ------------------ | Branch (395:5): [True: 17.3k, False: 2.04M] ------------------ 396| 21.3k| case OP_TYPEMINSTAR: ------------------ | Branch (396:5): [True: 3.97k, False: 2.05M] ------------------ 397| 31.2k| case OP_TYPEQUERY: ------------------ | Branch (397:5): [True: 9.90k, False: 2.05M] ------------------ 398| 32.5k| case OP_TYPEMINQUERY: ------------------ | Branch (398:5): [True: 1.27k, False: 2.06M] ------------------ 399| 41.0k| case OP_TYPEPOSSTAR: ------------------ | Branch (399:5): [True: 8.53k, False: 2.05M] ------------------ 400| 42.9k| case OP_TYPEPOSQUERY: ------------------ | Branch (400:5): [True: 1.86k, False: 2.06M] ------------------ 401| 42.9k| if (cc[1] == OP_PROP || cc[1] == OP_NOTPROP) cc += 2; ------------------ | Branch (401:9): [True: 4.52k, False: 38.3k] | Branch (401:29): [True: 7.69k, False: 30.6k] ------------------ 402| 42.9k| cc += PRIV(OP_lengths)[op]; ------------------ | | 177| 42.9k|#define PRIV(name) _pcre2_##name ------------------ 403| 42.9k| break; 404| | 405| 1.43k| case OP_TYPEUPTO: ------------------ | Branch (405:5): [True: 1.43k, False: 2.06M] ------------------ 406| 2.93k| case OP_TYPEMINUPTO: ------------------ | Branch (406:5): [True: 1.49k, False: 2.06M] ------------------ 407| 4.74k| case OP_TYPEPOSUPTO: ------------------ | Branch (407:5): [True: 1.81k, False: 2.06M] ------------------ 408| 4.74k| if (cc[1 + IMM2_SIZE] == OP_PROP ------------------ | | 193| 4.74k|#define IMM2_SIZE 2 ------------------ | Branch (408:9): [True: 2.09k, False: 2.64k] ------------------ 409| 4.74k| || cc[1 + IMM2_SIZE] == OP_NOTPROP) cc += 2; ------------------ | | 193| 2.64k|#define IMM2_SIZE 2 ------------------ | Branch (409:10): [True: 298, False: 2.34k] ------------------ 410| 4.74k| cc += PRIV(OP_lengths)[op]; ------------------ | | 177| 4.74k|#define PRIV(name) _pcre2_##name ------------------ 411| 4.74k| break; 412| | 413| | /* Check a class for variable quantification */ 414| | 415| 11.0k| case OP_CLASS: ------------------ | Branch (415:5): [True: 11.0k, False: 2.05M] ------------------ 416| 14.4k| case OP_NCLASS: ------------------ | Branch (416:5): [True: 3.37k, False: 2.06M] ------------------ 417| 14.4k|#ifdef SUPPORT_WIDE_CHARS 418| 18.7k| case OP_XCLASS: ------------------ | Branch (418:5): [True: 4.33k, False: 2.05M] ------------------ 419| | /* The original code caused an unsigned overflow in 64 bit systems, 420| | so now we use a conditional statement. */ 421| 18.7k| if (op == OP_XCLASS) ------------------ | Branch (421:9): [True: 4.33k, False: 14.4k] ------------------ 422| 4.33k| cc += GET(cc, 1); ------------------ | | 109| 4.33k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 423| 14.4k| else 424| 14.4k| cc += PRIV(OP_lengths)[OP_CLASS]; ------------------ | | 177| 14.4k|#define PRIV(name) _pcre2_##name ------------------ 425| |#else 426| | cc += PRIV(OP_lengths)[OP_CLASS]; 427| |#endif 428| | 429| 18.7k| switch (*cc) 430| 18.7k| { 431| 746| case OP_CRPLUS: ------------------ | Branch (431:7): [True: 746, False: 18.0k] ------------------ 432| 1.83k| case OP_CRMINPLUS: ------------------ | Branch (432:7): [True: 1.08k, False: 17.6k] ------------------ 433| 2.89k| case OP_CRPOSPLUS: ------------------ | Branch (433:7): [True: 1.05k, False: 17.6k] ------------------ 434| 2.89k| branchlength++; 435| | /* Fall through */ 436| | 437| 4.17k| case OP_CRSTAR: ------------------ | Branch (437:7): [True: 1.28k, False: 17.4k] ------------------ 438| 5.14k| case OP_CRMINSTAR: ------------------ | Branch (438:7): [True: 973, False: 17.7k] ------------------ 439| 5.69k| case OP_CRQUERY: ------------------ | Branch (439:7): [True: 545, False: 18.2k] ------------------ 440| 6.51k| case OP_CRMINQUERY: ------------------ | Branch (440:7): [True: 823, False: 17.9k] ------------------ 441| 7.31k| case OP_CRPOSSTAR: ------------------ | Branch (441:7): [True: 803, False: 17.9k] ------------------ 442| 8.21k| case OP_CRPOSQUERY: ------------------ | Branch (442:7): [True: 901, False: 17.8k] ------------------ 443| 8.21k| cc++; 444| 8.21k| break; 445| | 446| 489| case OP_CRRANGE: ------------------ | Branch (446:7): [True: 489, False: 18.2k] ------------------ 447| 898| case OP_CRMINRANGE: ------------------ | Branch (447:7): [True: 409, False: 18.3k] ------------------ 448| 1.60k| case OP_CRPOSRANGE: ------------------ | Branch (448:7): [True: 711, False: 18.0k] ------------------ 449| 1.60k| branchlength += GET2(cc,1); ------------------ | | 194| 1.60k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 450| 1.60k| cc += 1 + 2 * IMM2_SIZE; ------------------ | | 193| 1.60k|#define IMM2_SIZE 2 ------------------ 451| 1.60k| break; 452| | 453| 8.91k| default: ------------------ | Branch (453:7): [True: 8.91k, False: 9.82k] ------------------ 454| 8.91k| branchlength++; 455| 8.91k| break; 456| 18.7k| } 457| 18.7k| break; 458| | 459| | /* Backreferences and subroutine calls (OP_RECURSE) are treated in the same 460| | way: we find the minimum length for the subpattern. A recursion 461| | (backreference or subroutine) causes an a flag to be set that causes the 462| | length of this branch to be ignored. The logic is that a recursion can only 463| | make sense if there is another alternative that stops the recursing. That 464| | will provide the minimum length (when no recursion happens). 465| | 466| | If PCRE2_MATCH_UNSET_BACKREF is set, a backreference to an unset bracket 467| | matches an empty string (by default it causes a matching failure), so in 468| | that case we must set the minimum length to zero. 469| | 470| | For backreferenes, if duplicate numbers are present in the pattern we check 471| | for a reference to a duplicate. If it is, we don't know which version will 472| | be referenced, so we have to set the minimum length to zero. */ 473| | 474| | /* Duplicate named pattern back reference. */ 475| | 476| 18.7k| case OP_DNREF: ------------------ | Branch (476:5): [True: 2.67k, False: 2.06M] ------------------ 477| 3.06k| case OP_DNREFI: ------------------ | Branch (477:5): [True: 384, False: 2.06M] ------------------ 478| 3.06k| if (!dupcapused && (re->overall_options & PCRE2_MATCH_UNSET_BACKREF) == 0) ------------------ | | 128| 2.74k|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ ------------------ | Branch (478:9): [True: 2.74k, False: 316] | Branch (478:24): [True: 2.45k, False: 292] ------------------ 479| 2.45k| { 480| 2.45k| int count = GET2(cc, 1+IMM2_SIZE); ------------------ | | 194| 2.45k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 481| 2.45k| PCRE2_UCHAR *slot = ------------------ | | 813| 2.45k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 2.45k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 2.45k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 2.45k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 482| 2.45k| (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code)) + 483| 2.45k| GET2(cc, 1) * re->name_entry_size; ------------------ | | 194| 2.45k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 484| | 485| 2.45k| d = INT_MAX; 486| | 487| | /* Scan all groups with the same name; find the shortest. */ 488| | 489| 4.58k| while (count-- > 0) ------------------ | Branch (489:14): [True: 4.12k, False: 455] ------------------ 490| 4.12k| { 491| 4.12k| int dd, i; 492| 4.12k| recno = GET2(slot, 0); ------------------ | | 194| 4.12k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 493| | 494| 4.12k| if (recno <= backref_cache[0] && backref_cache[recno] >= 0) ------------------ | Branch (494:13): [True: 1.77k, False: 2.35k] | Branch (494:42): [True: 1.53k, False: 240] ------------------ 495| 1.53k| dd = backref_cache[recno]; 496| 2.59k| else 497| 2.59k| { 498| 2.59k| ce = cs = (PCRE2_UCHAR *)PRIV(find_bracket)(startcode, utf, recno); ------------------ | | 177| 2.59k|#define PRIV(name) _pcre2_##name ------------------ 499| 2.59k| if (cs == NULL) return -2; ------------------ | Branch (499:15): [True: 0, False: 2.59k] ------------------ 500| 2.87k| do ce += GET(ce, 1); while (*ce == OP_ALT); ------------------ | | 109| 2.87k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (500:39): [True: 280, False: 2.59k] ------------------ 501| | 502| 2.59k| dd = 0; 503| 2.59k| if (!dupcapused || ------------------ | Branch (503:15): [True: 2.59k, False: 0] ------------------ 504| 2.59k| (PCRE2_UCHAR *)PRIV(find_bracket)(ce, utf, recno) == NULL) ------------------ | | 177| 0|#define PRIV(name) _pcre2_##name ------------------ | Branch (504:15): [True: 0, False: 0] ------------------ 505| 2.59k| { 506| 2.59k| if (cc > cs && cc < ce) /* Simple recursion */ ------------------ | Branch (506:17): [True: 731, False: 1.85k] | Branch (506:28): [True: 283, False: 448] ------------------ 507| 283| { 508| 283| had_recurse = TRUE; ------------------ | | 70| 283|#define TRUE 1 ------------------ 509| 283| } 510| 2.30k| else 511| 2.30k| { 512| 2.30k| recurse_check *r = recurses; 513| 7.75k| for (r = recurses; r != NULL; r = r->prev) ------------------ | Branch (513:34): [True: 5.57k, False: 2.17k] ------------------ 514| 5.57k| if (r->group == cs) break; ------------------ | Branch (514:21): [True: 130, False: 5.44k] ------------------ 515| 2.30k| if (r != NULL) /* Mutual recursion */ ------------------ | Branch (515:19): [True: 130, False: 2.17k] ------------------ 516| 130| { 517| 130| had_recurse = TRUE; ------------------ | | 70| 130|#define TRUE 1 ------------------ 518| 130| } 519| 2.17k| else 520| 2.17k| { 521| 2.17k| this_recurse.prev = recurses; /* No recursion */ 522| 2.17k| this_recurse.group = cs; 523| 2.17k| dd = find_minlength(re, cs, startcode, utf, &this_recurse, 524| 2.17k| countptr, backref_cache); 525| 2.17k| if (dd < 0) return dd; ------------------ | Branch (525:21): [True: 10, False: 2.16k] ------------------ 526| 2.17k| } 527| 2.30k| } 528| 2.59k| } 529| | 530| 2.58k| backref_cache[recno] = dd; 531| 7.42k| for (i = backref_cache[0] + 1; i < recno; i++) backref_cache[i] = -1; ------------------ | Branch (531:42): [True: 4.84k, False: 2.58k] ------------------ 532| 2.58k| backref_cache[0] = recno; 533| 2.58k| } 534| | 535| 4.11k| if (dd < d) d = dd; ------------------ | Branch (535:13): [True: 3.44k, False: 668] ------------------ 536| 4.11k| if (d <= 0) break; /* No point looking at any more */ ------------------ | Branch (536:13): [True: 1.98k, False: 2.12k] ------------------ 537| 2.12k| slot += re->name_entry_size; 538| 2.12k| } 539| 2.45k| } 540| 608| else d = 0; 541| 3.05k| cc += 1 + 2*IMM2_SIZE; ------------------ | | 193| 3.05k|#define IMM2_SIZE 2 ------------------ 542| 3.05k| goto REPEAT_BACK_REFERENCE; 543| | 544| | /* Single back reference by number. References by name are converted to by 545| | number when there is no duplication. */ 546| | 547| 31.4k| case OP_REF: ------------------ | Branch (547:5): [True: 31.4k, False: 2.03M] ------------------ 548| 34.7k| case OP_REFI: ------------------ | Branch (548:5): [True: 3.27k, False: 2.06M] ------------------ 549| 34.7k| recno = GET2(cc, 1); ------------------ | | 194| 34.7k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 550| 34.7k| if (recno <= backref_cache[0] && backref_cache[recno] >= 0) ------------------ | Branch (550:9): [True: 16.6k, False: 18.1k] | Branch (550:38): [True: 12.3k, False: 4.30k] ------------------ 551| 12.3k| d = backref_cache[recno]; 552| 22.4k| else 553| 22.4k| { 554| 22.4k| int i; 555| 22.4k| d = 0; 556| | 557| 22.4k| if ((re->overall_options & PCRE2_MATCH_UNSET_BACKREF) == 0) ------------------ | | 128| 22.4k|#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u /* C J M */ ------------------ | Branch (557:11): [True: 21.7k, False: 644] ------------------ 558| 21.7k| { 559| 21.7k| ce = cs = (PCRE2_UCHAR *)PRIV(find_bracket)(startcode, utf, recno); ------------------ | | 177| 21.7k|#define PRIV(name) _pcre2_##name ------------------ 560| 21.7k| if (cs == NULL) return -2; ------------------ | Branch (560:13): [True: 0, False: 21.7k] ------------------ 561| 22.0k| do ce += GET(ce, 1); while (*ce == OP_ALT); ------------------ | | 109| 22.0k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (561:37): [True: 252, False: 21.7k] ------------------ 562| | 563| 21.7k| if (!dupcapused || ------------------ | Branch (563:13): [True: 20.1k, False: 1.61k] ------------------ 564| 21.7k| (PCRE2_UCHAR *)PRIV(find_bracket)(ce, utf, recno) == NULL) ------------------ | | 177| 1.61k|#define PRIV(name) _pcre2_##name ------------------ | Branch (564:13): [True: 1.41k, False: 197] ------------------ 565| 21.5k| { 566| 21.5k| if (cc > cs && cc < ce) /* Simple recursion */ ------------------ | Branch (566:15): [True: 8.20k, False: 13.3k] | Branch (566:26): [True: 5.88k, False: 2.32k] ------------------ 567| 5.88k| { 568| 5.88k| had_recurse = TRUE; ------------------ | | 70| 5.88k|#define TRUE 1 ------------------ 569| 5.88k| } 570| 15.7k| else 571| 15.7k| { 572| 15.7k| recurse_check *r = recurses; 573| 290k| for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break; ------------------ | Branch (573:32): [True: 275k, False: 15.3k] | Branch (573:60): [True: 373, False: 274k] ------------------ 574| 15.7k| if (r != NULL) /* Mutual recursion */ ------------------ | Branch (574:17): [True: 373, False: 15.3k] ------------------ 575| 373| { 576| 373| had_recurse = TRUE; ------------------ | | 70| 373|#define TRUE 1 ------------------ 577| 373| } 578| 15.3k| else /* No recursion */ 579| 15.3k| { 580| 15.3k| this_recurse.prev = recurses; 581| 15.3k| this_recurse.group = cs; 582| 15.3k| d = find_minlength(re, cs, startcode, utf, &this_recurse, countptr, 583| 15.3k| backref_cache); 584| 15.3k| if (d < 0) return d; ------------------ | Branch (584:19): [True: 489, False: 14.8k] ------------------ 585| 15.3k| } 586| 15.7k| } 587| 21.5k| } 588| 21.7k| } 589| | 590| 21.9k| backref_cache[recno] = d; 591| 61.6k| for (i = backref_cache[0] + 1; i < recno; i++) backref_cache[i] = -1; ------------------ | Branch (591:38): [True: 39.6k, False: 21.9k] ------------------ 592| 21.9k| backref_cache[0] = recno; 593| 21.9k| } 594| | 595| 34.2k| cc += 1 + IMM2_SIZE; ------------------ | | 193| 34.2k|#define IMM2_SIZE 2 ------------------ 596| | 597| | /* Handle repeated back references */ 598| | 599| 37.3k| REPEAT_BACK_REFERENCE: 600| 37.3k| switch (*cc) 601| 37.3k| { 602| 652| case OP_CRSTAR: ------------------ | Branch (602:7): [True: 652, False: 36.6k] ------------------ 603| 1.05k| case OP_CRMINSTAR: ------------------ | Branch (603:7): [True: 406, False: 36.9k] ------------------ 604| 2.55k| case OP_CRQUERY: ------------------ | Branch (604:7): [True: 1.50k, False: 35.8k] ------------------ 605| 3.10k| case OP_CRMINQUERY: ------------------ | Branch (605:7): [True: 548, False: 36.7k] ------------------ 606| 3.10k| case OP_CRPOSSTAR: ------------------ | Branch (606:7): [True: 0, False: 37.3k] ------------------ 607| 3.10k| case OP_CRPOSQUERY: ------------------ | Branch (607:7): [True: 0, False: 37.3k] ------------------ 608| 3.10k| min = 0; 609| 3.10k| cc++; 610| 3.10k| break; 611| | 612| 827| case OP_CRPLUS: ------------------ | Branch (612:7): [True: 827, False: 36.4k] ------------------ 613| 1.13k| case OP_CRMINPLUS: ------------------ | Branch (613:7): [True: 311, False: 37.0k] ------------------ 614| 1.13k| case OP_CRPOSPLUS: ------------------ | Branch (614:7): [True: 0, False: 37.3k] ------------------ 615| 1.13k| min = 1; 616| 1.13k| cc++; 617| 1.13k| break; 618| | 619| 1.36k| case OP_CRRANGE: ------------------ | Branch (619:7): [True: 1.36k, False: 35.9k] ------------------ 620| 1.97k| case OP_CRMINRANGE: ------------------ | Branch (620:7): [True: 616, False: 36.7k] ------------------ 621| 1.97k| case OP_CRPOSRANGE: ------------------ | Branch (621:7): [True: 0, False: 37.3k] ------------------ 622| 1.97k| min = GET2(cc, 1); ------------------ | | 194| 1.97k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 623| 1.97k| cc += 1 + 2 * IMM2_SIZE; ------------------ | | 193| 1.97k|#define IMM2_SIZE 2 ------------------ 624| 1.97k| break; 625| | 626| 31.1k| default: ------------------ | Branch (626:7): [True: 31.1k, False: 6.22k] ------------------ 627| 31.1k| min = 1; 628| 31.1k| break; 629| 37.3k| } 630| | 631| | /* Take care not to overflow: (1) min and d are ints, so check that their 632| | product is not greater than INT_MAX. (2) branchlength is limited to 633| | UINT16_MAX (checked at the top of the loop). */ 634| | 635| 37.3k| if ((d > 0 && (INT_MAX/d) < min) || UINT16_MAX - branchlength < min*d) ------------------ | Branch (635:10): [True: 15.1k, False: 22.1k] | Branch (635:19): [True: 581, False: 14.5k] | Branch (635:41): [True: 315, False: 36.4k] ------------------ 636| 896| branchlength = UINT16_MAX; 637| 36.4k| else branchlength += min * d; 638| 37.3k| break; 639| | 640| | /* Recursion always refers to the first occurrence of a subpattern with a 641| | given number. Therefore, we can always make use of caching, even when the 642| | pattern contains multiple subpatterns with the same number. */ 643| | 644| 21.9k| case OP_RECURSE: ------------------ | Branch (644:5): [True: 21.9k, False: 2.04M] ------------------ 645| 21.9k| cs = ce = (PCRE2_UCHAR *)startcode + GET(cc, 1); ------------------ | | 109| 21.9k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 646| 21.9k| recno = GET2(cs, 1+LINK_SIZE); ------------------ | | 194| 21.9k|#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ 647| 21.9k| if (recno == prev_recurse_recno) ------------------ | Branch (647:9): [True: 386, False: 21.6k] ------------------ 648| 386| { 649| 386| branchlength += prev_recurse_d; 650| 386| } 651| 21.6k| else 652| 21.6k| { 653| 22.4k| do ce += GET(ce, 1); while (*ce == OP_ALT); ------------------ | | 109| 22.4k| (unsigned int)(((a)[n] << 8) | (a)[(n)+1]) ------------------ | Branch (653:35): [True: 879, False: 21.6k] ------------------ 654| 21.6k| if (cc > cs && cc < ce) /* Simple recursion */ ------------------ | Branch (654:11): [True: 13.8k, False: 7.73k] | Branch (654:22): [True: 9.24k, False: 4.63k] ------------------ 655| 9.24k| had_recurse = TRUE; ------------------ | | 70| 9.24k|#define TRUE 1 ------------------ 656| 12.3k| else 657| 12.3k| { 658| 12.3k| recurse_check *r = recurses; 659| 138k| for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break; ------------------ | Branch (659:28): [True: 128k, False: 9.57k] | Branch (659:56): [True: 2.79k, False: 125k] ------------------ 660| 12.3k| if (r != NULL) /* Mutual recursion */ ------------------ | Branch (660:13): [True: 2.79k, False: 9.57k] ------------------ 661| 2.79k| had_recurse = TRUE; ------------------ | | 70| 2.79k|#define TRUE 1 ------------------ 662| 9.57k| else 663| 9.57k| { 664| 9.57k| this_recurse.prev = recurses; 665| 9.57k| this_recurse.group = cs; 666| 9.57k| prev_recurse_d = find_minlength(re, cs, startcode, utf, &this_recurse, 667| 9.57k| countptr, backref_cache); 668| 9.57k| if (prev_recurse_d < 0) return prev_recurse_d; ------------------ | Branch (668:15): [True: 203, False: 9.37k] ------------------ 669| 9.37k| prev_recurse_recno = recno; 670| 9.37k| branchlength += prev_recurse_d; 671| 9.37k| } 672| 12.3k| } 673| 21.6k| } 674| 21.7k| cc += 1 + LINK_SIZE + once_fudge; ------------------ | | 165| 21.7k|#define LINK_SIZE 2 ------------------ 675| 21.7k| once_fudge = 0; 676| 21.7k| break; 677| | 678| | /* Anything else does not or need not match a character. We can get the 679| | item's length from the table, but for those that can match zero occurrences 680| | of a character, we must take special action for UTF-8 characters. As it 681| | happens, the "NOT" versions of these opcodes are used at present only for 682| | ASCII characters, so they could be omitted from this list. However, in 683| | future that may change, so we include them here so as not to leave a 684| | gotcha for a future maintainer. */ 685| | 686| 417| case OP_UPTO: ------------------ | Branch (686:5): [True: 417, False: 2.06M] ------------------ 687| 1.46k| case OP_UPTOI: ------------------ | Branch (687:5): [True: 1.05k, False: 2.06M] ------------------ 688| 5.69k| case OP_NOTUPTO: ------------------ | Branch (688:5): [True: 4.22k, False: 2.05M] ------------------ 689| 5.98k| case OP_NOTUPTOI: ------------------ | Branch (689:5): [True: 289, False: 2.06M] ------------------ 690| 6.33k| case OP_MINUPTO: ------------------ | Branch (690:5): [True: 347, False: 2.06M] ------------------ 691| 6.66k| case OP_MINUPTOI: ------------------ | Branch (691:5): [True: 332, False: 2.06M] ------------------ 692| 6.95k| case OP_NOTMINUPTO: ------------------ | Branch (692:5): [True: 291, False: 2.06M] ------------------ 693| 11.1k| case OP_NOTMINUPTOI: ------------------ | Branch (693:5): [True: 4.18k, False: 2.05M] ------------------ 694| 11.7k| case OP_POSUPTO: ------------------ | Branch (694:5): [True: 653, False: 2.06M] ------------------ 695| 12.9k| case OP_POSUPTOI: ------------------ | Branch (695:5): [True: 1.17k, False: 2.06M] ------------------ 696| 14.3k| case OP_NOTPOSUPTO: ------------------ | Branch (696:5): [True: 1.40k, False: 2.06M] ------------------ 697| 15.5k| case OP_NOTPOSUPTOI: ------------------ | Branch (697:5): [True: 1.19k, False: 2.06M] ------------------ 698| | 699| 18.7k| case OP_STAR: ------------------ | Branch (699:5): [True: 3.22k, False: 2.06M] ------------------ 700| 19.8k| case OP_STARI: ------------------ | Branch (700:5): [True: 1.01k, False: 2.06M] ------------------ 701| 20.2k| case OP_NOTSTAR: ------------------ | Branch (701:5): [True: 487, False: 2.06M] ------------------ 702| 20.5k| case OP_NOTSTARI: ------------------ | Branch (702:5): [True: 262, False: 2.06M] ------------------ 703| 21.3k| case OP_MINSTAR: ------------------ | Branch (703:5): [True: 775, False: 2.06M] ------------------ 704| 21.7k| case OP_MINSTARI: ------------------ | Branch (704:5): [True: 473, False: 2.06M] ------------------ 705| 22.0k| case OP_NOTMINSTAR: ------------------ | Branch (705:5): [True: 288, False: 2.06M] ------------------ 706| 22.4k| case OP_NOTMINSTARI: ------------------ | Branch (706:5): [True: 354, False: 2.06M] ------------------ 707| 26.0k| case OP_POSSTAR: ------------------ | Branch (707:5): [True: 3.58k, False: 2.05M] ------------------ 708| 30.2k| case OP_POSSTARI: ------------------ | Branch (708:5): [True: 4.24k, False: 2.05M] ------------------ 709| 30.5k| case OP_NOTPOSSTAR: ------------------ | Branch (709:5): [True: 245, False: 2.06M] ------------------ 710| 30.8k| case OP_NOTPOSSTARI: ------------------ | Branch (710:5): [True: 317, False: 2.06M] ------------------ 711| | 712| 37.2k| case OP_QUERY: ------------------ | Branch (712:5): [True: 6.43k, False: 2.05M] ------------------ 713| 39.2k| case OP_QUERYI: ------------------ | Branch (713:5): [True: 2.01k, False: 2.06M] ------------------ 714| 40.4k| case OP_NOTQUERY: ------------------ | Branch (714:5): [True: 1.12k, False: 2.06M] ------------------ 715| 40.9k| case OP_NOTQUERYI: ------------------ | Branch (715:5): [True: 551, False: 2.06M] ------------------ 716| 41.5k| case OP_MINQUERY: ------------------ | Branch (716:5): [True: 619, False: 2.06M] ------------------ 717| 48.8k| case OP_MINQUERYI: ------------------ | Branch (717:5): [True: 7.23k, False: 2.05M] ------------------ 718| 49.2k| case OP_NOTMINQUERY: ------------------ | Branch (718:5): [True: 393, False: 2.06M] ------------------ 719| 49.4k| case OP_NOTMINQUERYI: ------------------ | Branch (719:5): [True: 234, False: 2.06M] ------------------ 720| 52.0k| case OP_POSQUERY: ------------------ | Branch (720:5): [True: 2.63k, False: 2.06M] ------------------ 721| 63.9k| case OP_POSQUERYI: ------------------ | Branch (721:5): [True: 11.9k, False: 2.05M] ------------------ 722| 64.8k| case OP_NOTPOSQUERY: ------------------ | Branch (722:5): [True: 863, False: 2.06M] ------------------ 723| 65.7k| case OP_NOTPOSQUERYI: ------------------ | Branch (723:5): [True: 872, False: 2.06M] ------------------ 724| | 725| 65.7k| cc += PRIV(OP_lengths)[op]; ------------------ | | 177| 65.7k|#define PRIV(name) _pcre2_##name ------------------ 726| 65.7k|#ifdef SUPPORT_UNICODE 727| 65.7k| if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); ------------------ | | 286| 28.7k|#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c) | | ------------------ | | | | 254| 28.7k|#define HASUTF8EXTRALEN(c) ((c) >= 0xc0) | | | | ------------------ | | | | | Branch (254:28): [True: 18.6k, False: 10.1k] | | | | ------------------ | | ------------------ ------------------ if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); ------------------ | | 291| 18.6k|#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu]) | | ------------------ | | | | 177| 18.6k|#define PRIV(name) _pcre2_##name | | ------------------ ------------------ | Branch (727:9): [True: 28.7k, False: 36.9k] ------------------ 728| 65.7k|#endif 729| 65.7k| break; 730| | 731| | /* Skip these, but we need to add in the name length. */ 732| | 733| 575| case OP_MARK: ------------------ | Branch (733:5): [True: 575, False: 2.06M] ------------------ 734| 1.24k| case OP_COMMIT_ARG: ------------------ | Branch (734:5): [True: 671, False: 2.06M] ------------------ 735| 2.13k| case OP_PRUNE_ARG: ------------------ | Branch (735:5): [True: 884, False: 2.06M] ------------------ 736| 2.79k| case OP_SKIP_ARG: ------------------ | Branch (736:5): [True: 663, False: 2.06M] ------------------ 737| 3.12k| case OP_THEN_ARG: ------------------ | Branch (737:5): [True: 330, False: 2.06M] ------------------ 738| 3.12k| cc += PRIV(OP_lengths)[op] + cc[1]; ------------------ | | 177| 3.12k|#define PRIV(name) _pcre2_##name ------------------ 739| 3.12k| break; 740| | 741| | /* The remaining opcodes are just skipped over. */ 742| | 743| 0| case OP_CLOSE: ------------------ | Branch (743:5): [True: 0, False: 2.06M] ------------------ 744| 300| case OP_COMMIT: ------------------ | Branch (744:5): [True: 300, False: 2.06M] ------------------ 745| 1.10k| case OP_FAIL: ------------------ | Branch (745:5): [True: 806, False: 2.06M] ------------------ 746| 1.49k| case OP_PRUNE: ------------------ | Branch (746:5): [True: 386, False: 2.06M] ------------------ 747| 2.31k| case OP_SET_SOM: ------------------ | Branch (747:5): [True: 822, False: 2.06M] ------------------ 748| 3.49k| case OP_SKIP: ------------------ | Branch (748:5): [True: 1.17k, False: 2.06M] ------------------ 749| 4.72k| case OP_THEN: ------------------ | Branch (749:5): [True: 1.23k, False: 2.06M] ------------------ 750| 4.72k| cc += PRIV(OP_lengths)[op]; ------------------ | | 177| 4.72k|#define PRIV(name) _pcre2_##name ------------------ 751| 4.72k| break; 752| | 753| | /* This should not occur: we list all opcodes explicitly so that when 754| | new ones get added they are properly considered. */ 755| | 756| 0| default: ------------------ | Branch (756:5): [True: 0, False: 2.06M] ------------------ 757| 0| return -3; 758| 2.06M| } 759| 2.06M| } 760| |/* Control never gets here */ 761| 375k|} _pcre2_valid_utf_8: 95| 116k|{ 96| 116k|PCRE2_SPTR p; ------------------ | | 814| 116k|#define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) | | ------------------ | | | | 986| 116k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 116k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 116k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 97| 116k|uint32_t c; 98| | 99| |/* ----------------- Check a UTF-8 string ----------------- */ 100| | 101| 116k|#if PCRE2_CODE_UNIT_WIDTH == 8 102| | 103| |/* Originally, this function checked according to RFC 2279, allowing for values 104| |in the range 0 to 0x7fffffff, up to 6 bytes long, but ensuring that they were 105| |in the canonical format. Once somebody had pointed out RFC 3629 to me (it 106| |obsoletes 2279), additional restrictions were applied. The values are now 107| |limited to be between 0 and 0x0010ffff, no more than 4 bytes long, and the 108| |subrange 0xd000 to 0xdfff is excluded. However, the format of 5-byte and 6-byte 109| |characters is still checked. Error returns are as follows: 110| | 111| |PCRE2_ERROR_UTF8_ERR1 Missing 1 byte at the end of the string 112| |PCRE2_ERROR_UTF8_ERR2 Missing 2 bytes at the end of the string 113| |PCRE2_ERROR_UTF8_ERR3 Missing 3 bytes at the end of the string 114| |PCRE2_ERROR_UTF8_ERR4 Missing 4 bytes at the end of the string 115| |PCRE2_ERROR_UTF8_ERR5 Missing 5 bytes at the end of the string 116| |PCRE2_ERROR_UTF8_ERR6 2nd-byte's two top bits are not 0x80 117| |PCRE2_ERROR_UTF8_ERR7 3rd-byte's two top bits are not 0x80 118| |PCRE2_ERROR_UTF8_ERR8 4th-byte's two top bits are not 0x80 119| |PCRE2_ERROR_UTF8_ERR9 5th-byte's two top bits are not 0x80 120| |PCRE2_ERROR_UTF8_ERR10 6th-byte's two top bits are not 0x80 121| |PCRE2_ERROR_UTF8_ERR11 5-byte character is not permitted by RFC 3629 122| |PCRE2_ERROR_UTF8_ERR12 6-byte character is not permitted by RFC 3629 123| |PCRE2_ERROR_UTF8_ERR13 4-byte character with value > 0x10ffff is not permitted 124| |PCRE2_ERROR_UTF8_ERR14 3-byte character with value 0xd800-0xdfff is not permitted 125| |PCRE2_ERROR_UTF8_ERR15 Overlong 2-byte sequence 126| |PCRE2_ERROR_UTF8_ERR16 Overlong 3-byte sequence 127| |PCRE2_ERROR_UTF8_ERR17 Overlong 4-byte sequence 128| |PCRE2_ERROR_UTF8_ERR18 Overlong 5-byte sequence (won't ever occur) 129| |PCRE2_ERROR_UTF8_ERR19 Overlong 6-byte sequence (won't ever occur) 130| |PCRE2_ERROR_UTF8_ERR20 Isolated 0x80 byte (not within UTF-8 character) 131| |PCRE2_ERROR_UTF8_ERR21 Byte with the illegal value 0xfe or 0xff 132| |*/ 133| | 134| 2.05M|for (p = string; length > 0; p++) ------------------ | Branch (134:18): [True: 1.93M, False: 113k] ------------------ 135| 1.93M| { 136| 1.93M| uint32_t ab, d; 137| | 138| 1.93M| c = *p; 139| 1.93M| length--; 140| | 141| 1.93M| if (c < 128) continue; /* ASCII character */ ------------------ | Branch (141:7): [True: 1.85M, False: 76.7k] ------------------ 142| | 143| 76.7k| if (c < 0xc0) /* Isolated 10xx xxxx byte */ ------------------ | Branch (143:7): [True: 982, False: 75.7k] ------------------ 144| 982| { 145| 982| *erroroffset = (PCRE2_SIZE)(p - string); 146| 982| return PCRE2_ERROR_UTF8_ERR20; ------------------ | | 350| 982|#define PCRE2_ERROR_UTF8_ERR20 (-22) ------------------ 147| 982| } 148| | 149| 75.7k| if (c >= 0xfe) /* Invalid 0xfe or 0xff bytes */ ------------------ | Branch (149:7): [True: 361, False: 75.4k] ------------------ 150| 361| { 151| 361| *erroroffset = (PCRE2_SIZE)(p - string); 152| 361| return PCRE2_ERROR_UTF8_ERR21; ------------------ | | 351| 361|#define PCRE2_ERROR_UTF8_ERR21 (-23) ------------------ 153| 361| } 154| | 155| 75.4k| ab = PRIV(utf8_table4)[c & 0x3f]; /* Number of additional bytes (1-5) */ ------------------ | | 177| 75.4k|#define PRIV(name) _pcre2_##name ------------------ 156| 75.4k| if (length < ab) /* Missing bytes */ ------------------ | Branch (156:7): [True: 345, False: 75.0k] ------------------ 157| 345| { 158| 345| *erroroffset = (PCRE2_SIZE)(p - string); 159| 345| switch(ab - length) ------------------ | Branch (159:12): [True: 0, False: 345] ------------------ 160| 345| { 161| 168| case 1: return PCRE2_ERROR_UTF8_ERR1; ------------------ | | 331| 168|#define PCRE2_ERROR_UTF8_ERR1 (-3) ------------------ | Branch (161:7): [True: 168, False: 177] ------------------ 162| 93| case 2: return PCRE2_ERROR_UTF8_ERR2; ------------------ | | 332| 93|#define PCRE2_ERROR_UTF8_ERR2 (-4) ------------------ | Branch (162:7): [True: 93, False: 252] ------------------ 163| 46| case 3: return PCRE2_ERROR_UTF8_ERR3; ------------------ | | 333| 46|#define PCRE2_ERROR_UTF8_ERR3 (-5) ------------------ | Branch (163:7): [True: 46, False: 299] ------------------ 164| 26| case 4: return PCRE2_ERROR_UTF8_ERR4; ------------------ | | 334| 26|#define PCRE2_ERROR_UTF8_ERR4 (-6) ------------------ | Branch (164:7): [True: 26, False: 319] ------------------ 165| 12| case 5: return PCRE2_ERROR_UTF8_ERR5; ------------------ | | 335| 12|#define PCRE2_ERROR_UTF8_ERR5 (-7) ------------------ | Branch (165:7): [True: 12, False: 333] ------------------ 166| 345| } 167| 345| } 168| 75.0k| length -= ab; /* Length remaining */ 169| | 170| | /* Check top bits in the second byte */ 171| | 172| 75.0k| if (((d = *(++p)) & 0xc0) != 0x80) ------------------ | Branch (172:7): [True: 611, False: 74.4k] ------------------ 173| 611| { 174| 611| *erroroffset = (PCRE2_SIZE)(p - string) - 1; 175| 611| return PCRE2_ERROR_UTF8_ERR6; ------------------ | | 336| 611|#define PCRE2_ERROR_UTF8_ERR6 (-8) ------------------ 176| 611| } 177| | 178| | /* For each length, check that the remaining bytes start with the 0x80 bit 179| | set and not the 0x40 bit. Then check for an overlong sequence, and for the 180| | excluded range 0xd800 to 0xdfff. */ 181| | 182| 74.4k| switch (ab) ------------------ | Branch (182:11): [True: 0, False: 74.4k] ------------------ 183| 74.4k| { 184| | /* 2-byte character. No further bytes to check for 0x80. Check first byte 185| | for for xx00 000x (overlong sequence). */ 186| | 187| 26.6k| case 1: if ((c & 0x3e) == 0) ------------------ | Branch (187:5): [True: 26.6k, False: 47.8k] | Branch (187:17): [True: 3, False: 26.6k] ------------------ 188| 3| { 189| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 1; 190| 3| return PCRE2_ERROR_UTF8_ERR15; ------------------ | | 345| 3|#define PCRE2_ERROR_UTF8_ERR15 (-17) ------------------ 191| 3| } 192| 26.6k| break; 193| | 194| | /* 3-byte character. Check third byte for 0x80. Then check first 2 bytes 195| | for 1110 0000, xx0x xxxx (overlong sequence) or 196| | 1110 1101, 1010 xxxx (0xd800 - 0xdfff) */ 197| | 198| 35.0k| case 2: ------------------ | Branch (198:5): [True: 35.0k, False: 39.3k] ------------------ 199| 35.0k| if ((*(++p) & 0xc0) != 0x80) /* Third byte */ ------------------ | Branch (199:9): [True: 8, False: 35.0k] ------------------ 200| 8| { 201| 8| *erroroffset = (PCRE2_SIZE)(p - string) - 2; 202| 8| return PCRE2_ERROR_UTF8_ERR7; ------------------ | | 337| 8|#define PCRE2_ERROR_UTF8_ERR7 (-9) ------------------ 203| 8| } 204| 35.0k| if (c == 0xe0 && (d & 0x20) == 0) ------------------ | Branch (204:9): [True: 735, False: 34.3k] | Branch (204:22): [True: 3, False: 732] ------------------ 205| 3| { 206| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 2; 207| 3| return PCRE2_ERROR_UTF8_ERR16; ------------------ | | 346| 3|#define PCRE2_ERROR_UTF8_ERR16 (-18) ------------------ 208| 3| } 209| 35.0k| if (c == 0xed && d >= 0xa0) ------------------ | Branch (209:9): [True: 557, False: 34.5k] | Branch (209:22): [True: 6, False: 551] ------------------ 210| 6| { 211| 6| *erroroffset = (PCRE2_SIZE)(p - string) - 2; 212| 6| return PCRE2_ERROR_UTF8_ERR14; ------------------ | | 344| 6|#define PCRE2_ERROR_UTF8_ERR14 (-16) ------------------ 213| 6| } 214| 35.0k| break; 215| | 216| | /* 4-byte character. Check 3rd and 4th bytes for 0x80. Then check first 2 217| | bytes for for 1111 0000, xx00 xxxx (overlong sequence), then check for a 218| | character greater than 0x0010ffff (f4 8f bf bf) */ 219| | 220| 35.0k| case 3: ------------------ | Branch (220:5): [True: 12.7k, False: 61.7k] ------------------ 221| 12.7k| if ((*(++p) & 0xc0) != 0x80) /* Third byte */ ------------------ | Branch (221:9): [True: 4, False: 12.7k] ------------------ 222| 4| { 223| 4| *erroroffset = (PCRE2_SIZE)(p - string) - 2; 224| 4| return PCRE2_ERROR_UTF8_ERR7; ------------------ | | 337| 4|#define PCRE2_ERROR_UTF8_ERR7 (-9) ------------------ 225| 4| } 226| 12.7k| if ((*(++p) & 0xc0) != 0x80) /* Fourth byte */ ------------------ | Branch (226:9): [True: 9, False: 12.7k] ------------------ 227| 9| { 228| 9| *erroroffset = (PCRE2_SIZE)(p - string) - 3; 229| 9| return PCRE2_ERROR_UTF8_ERR8; ------------------ | | 338| 9|#define PCRE2_ERROR_UTF8_ERR8 (-10) ------------------ 230| 9| } 231| 12.7k| if (c == 0xf0 && (d & 0x30) == 0) ------------------ | Branch (231:9): [True: 2.60k, False: 10.0k] | Branch (231:22): [True: 3, False: 2.60k] ------------------ 232| 3| { 233| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 3; 234| 3| return PCRE2_ERROR_UTF8_ERR17; ------------------ | | 347| 3|#define PCRE2_ERROR_UTF8_ERR17 (-19) ------------------ 235| 3| } 236| 12.6k| if (c > 0xf4 || (c == 0xf4 && d > 0x8f)) ------------------ | Branch (236:9): [True: 3, False: 12.6k] | Branch (236:22): [True: 2.45k, False: 10.2k] | Branch (236:35): [True: 8, False: 2.44k] ------------------ 237| 11| { 238| 11| *erroroffset = (PCRE2_SIZE)(p - string) - 3; 239| 11| return PCRE2_ERROR_UTF8_ERR13; ------------------ | | 343| 11|#define PCRE2_ERROR_UTF8_ERR13 (-15) ------------------ 240| 11| } 241| 12.6k| break; 242| | 243| | /* 5-byte and 6-byte characters are not allowed by RFC 3629, and will be 244| | rejected by the length test below. However, we do the appropriate tests 245| | here so that overlong sequences get diagnosed, and also in case there is 246| | ever an option for handling these larger code points. */ 247| | 248| | /* 5-byte character. Check 3rd, 4th, and 5th bytes for 0x80. Then check for 249| | 1111 1000, xx00 0xxx */ 250| | 251| 12.6k| case 4: ------------------ | Branch (251:5): [True: 19, False: 74.4k] ------------------ 252| 19| if ((*(++p) & 0xc0) != 0x80) /* Third byte */ ------------------ | Branch (252:9): [True: 4, False: 15] ------------------ 253| 4| { 254| 4| *erroroffset = (PCRE2_SIZE)(p - string) - 2; 255| 4| return PCRE2_ERROR_UTF8_ERR7; ------------------ | | 337| 4|#define PCRE2_ERROR_UTF8_ERR7 (-9) ------------------ 256| 4| } 257| 15| if ((*(++p) & 0xc0) != 0x80) /* Fourth byte */ ------------------ | Branch (257:9): [True: 3, False: 12] ------------------ 258| 3| { 259| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 3; 260| 3| return PCRE2_ERROR_UTF8_ERR8; ------------------ | | 338| 3|#define PCRE2_ERROR_UTF8_ERR8 (-10) ------------------ 261| 3| } 262| 12| if ((*(++p) & 0xc0) != 0x80) /* Fifth byte */ ------------------ | Branch (262:9): [True: 3, False: 9] ------------------ 263| 3| { 264| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 4; 265| 3| return PCRE2_ERROR_UTF8_ERR9; ------------------ | | 339| 3|#define PCRE2_ERROR_UTF8_ERR9 (-11) ------------------ 266| 3| } 267| 9| if (c == 0xf8 && (d & 0x38) == 0) ------------------ | Branch (267:9): [True: 6, False: 3] | Branch (267:22): [True: 3, False: 3] ------------------ 268| 3| { 269| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 4; 270| 3| return PCRE2_ERROR_UTF8_ERR18; ------------------ | | 348| 3|#define PCRE2_ERROR_UTF8_ERR18 (-20) ------------------ 271| 3| } 272| 6| break; 273| | 274| | /* 6-byte character. Check 3rd-6th bytes for 0x80. Then check for 275| | 1111 1100, xx00 00xx. */ 276| | 277| 24| case 5: ------------------ | Branch (277:5): [True: 24, False: 74.4k] ------------------ 278| 24| if ((*(++p) & 0xc0) != 0x80) /* Third byte */ ------------------ | Branch (278:9): [True: 3, False: 21] ------------------ 279| 3| { 280| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 2; 281| 3| return PCRE2_ERROR_UTF8_ERR7; ------------------ | | 337| 3|#define PCRE2_ERROR_UTF8_ERR7 (-9) ------------------ 282| 3| } 283| 21| if ((*(++p) & 0xc0) != 0x80) /* Fourth byte */ ------------------ | Branch (283:9): [True: 3, False: 18] ------------------ 284| 3| { 285| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 3; 286| 3| return PCRE2_ERROR_UTF8_ERR8; ------------------ | | 338| 3|#define PCRE2_ERROR_UTF8_ERR8 (-10) ------------------ 287| 3| } 288| 18| if ((*(++p) & 0xc0) != 0x80) /* Fifth byte */ ------------------ | Branch (288:9): [True: 5, False: 13] ------------------ 289| 5| { 290| 5| *erroroffset = (PCRE2_SIZE)(p - string) - 4; 291| 5| return PCRE2_ERROR_UTF8_ERR9; ------------------ | | 339| 5|#define PCRE2_ERROR_UTF8_ERR9 (-11) ------------------ 292| 5| } 293| 13| if ((*(++p) & 0xc0) != 0x80) /* Sixth byte */ ------------------ | Branch (293:9): [True: 4, False: 9] ------------------ 294| 4| { 295| 4| *erroroffset = (PCRE2_SIZE)(p - string) - 5; 296| 4| return PCRE2_ERROR_UTF8_ERR10; ------------------ | | 340| 4|#define PCRE2_ERROR_UTF8_ERR10 (-12) ------------------ 297| 4| } 298| 9| if (c == 0xfc && (d & 0x3c) == 0) ------------------ | Branch (298:9): [True: 6, False: 3] | Branch (298:22): [True: 3, False: 3] ------------------ 299| 3| { 300| 3| *erroroffset = (PCRE2_SIZE)(p - string) - 5; 301| 3| return PCRE2_ERROR_UTF8_ERR19; ------------------ | | 349| 3|#define PCRE2_ERROR_UTF8_ERR19 (-21) ------------------ 302| 3| } 303| 6| break; 304| 74.4k| } 305| | 306| | /* Character is valid under RFC 2279, but 4-byte and 5-byte characters are 307| | excluded by RFC 3629. The pointer p is currently at the last byte of the 308| | character. */ 309| | 310| 74.3k| if (ab > 3) ------------------ | Branch (310:7): [True: 12, False: 74.3k] ------------------ 311| 12| { 312| 12| *erroroffset = (PCRE2_SIZE)(p - string) - ab; 313| 12| return (ab == 4)? PCRE2_ERROR_UTF8_ERR11 : PCRE2_ERROR_UTF8_ERR12; ------------------ | | 341| 6|#define PCRE2_ERROR_UTF8_ERR11 (-13) ------------------ return (ab == 4)? PCRE2_ERROR_UTF8_ERR11 : PCRE2_ERROR_UTF8_ERR12; ------------------ | | 342| 6|#define PCRE2_ERROR_UTF8_ERR12 (-14) ------------------ | Branch (313:12): [True: 6, False: 6] ------------------ 314| 12| } 315| 74.3k| } 316| 113k|return 0; 317| | 318| | 319| |/* ----------------- Check a UTF-16 string ----------------- */ 320| | 321| |#elif PCRE2_CODE_UNIT_WIDTH == 16 322| | 323| |/* There's not so much work, nor so many errors, for UTF-16. 324| |PCRE2_ERROR_UTF16_ERR1 Missing low surrogate at the end of the string 325| |PCRE2_ERROR_UTF16_ERR2 Invalid low surrogate 326| |PCRE2_ERROR_UTF16_ERR3 Isolated low surrogate 327| |*/ 328| | 329| |for (p = string; length > 0; p++) 330| | { 331| | c = *p; 332| | length--; 333| | 334| | if ((c & 0xf800) != 0xd800) 335| | { 336| | /* Normal UTF-16 code point. Neither high nor low surrogate. */ 337| | } 338| | else if ((c & 0x0400) == 0) 339| | { 340| | /* High surrogate. Must be a followed by a low surrogate. */ 341| | if (length == 0) 342| | { 343| | *erroroffset = (PCRE2_SIZE)(p - string); 344| | return PCRE2_ERROR_UTF16_ERR1; 345| | } 346| | p++; 347| | length--; 348| | if ((*p & 0xfc00) != 0xdc00) 349| | { 350| | *erroroffset = (PCRE2_SIZE)(p - string) - 1; 351| | return PCRE2_ERROR_UTF16_ERR2; 352| | } 353| | } 354| | else 355| | { 356| | /* Isolated low surrogate. Always an error. */ 357| | *erroroffset = (PCRE2_SIZE)(p - string); 358| | return PCRE2_ERROR_UTF16_ERR3; 359| | } 360| | } 361| |return 0; 362| | 363| | 364| | 365| |/* ----------------- Check a UTF-32 string ----------------- */ 366| | 367| |#else 368| | 369| |/* There is very little to do for a UTF-32 string. 370| |PCRE2_ERROR_UTF32_ERR1 Surrogate character 371| |PCRE2_ERROR_UTF32_ERR2 Character > 0x10ffff 372| |*/ 373| | 374| |for (p = string; length > 0; length--, p++) 375| | { 376| | c = *p; 377| | if ((c & 0xfffff800u) != 0xd800u) 378| | { 379| | /* Normal UTF-32 code point. Neither high nor low surrogate. */ 380| | if (c > 0x10ffffu) 381| | { 382| | *erroroffset = (PCRE2_SIZE)(p - string); 383| | return PCRE2_ERROR_UTF32_ERR2; 384| | } 385| | } 386| | else 387| | { 388| | /* A surrogate */ 389| | *erroroffset = (PCRE2_SIZE)(p - string); 390| | return PCRE2_ERROR_UTF32_ERR1; 391| | } 392| | } 393| |return 0; 394| |#endif /* CODE_UNIT_WIDTH */ 395| 116k|} _pcre2_xclass_8: 70| 746k|{ 71| 746k|PCRE2_UCHAR t; ------------------ | | 813| 746k|#define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) | | ------------------ | | | | 986| 746k|#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) | | | | ------------------ | | | | | | 807| 746k|#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) | | | | | | ------------------ | | | | | | | | 806| 746k|#define PCRE2_JOIN(a,b) a ## b | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 72| 746k|BOOL negated = (*data & XCL_NOT) != 0; ------------------ | | 1309| 746k|#define XCL_NOT 0x01 /* Flag: this is a negative class */ ------------------ 73| | 74| 746k|#if PCRE2_CODE_UNIT_WIDTH == 8 75| |/* In 8 bit mode, this must always be TRUE. Help the compiler to know that. */ 76| 746k|utf = TRUE; ------------------ | | 70| 746k|#define TRUE 1 ------------------ 77| 746k|#endif 78| | 79| |/* Code points < 256 are matched against a bitmap, if one is present. If not, 80| |we still carry on, because there may be ranges that start below 256 in the 81| |additional data. */ 82| | 83| 746k|if (c < 256) ------------------ | Branch (83:5): [True: 734k, False: 11.2k] ------------------ 84| 734k| { 85| 734k| if ((*data & XCL_HASPROP) == 0) ------------------ | | 1311| 734k|#define XCL_HASPROP 0x04 /* Flag: property checks are present. */ ------------------ | Branch (85:7): [True: 49.7k, False: 685k] ------------------ 86| 49.7k| { 87| 49.7k| if ((*data & XCL_MAP) == 0) return negated; ------------------ | | 1310| 49.7k|#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */ ------------------ | Branch (87:9): [True: 2.26k, False: 47.5k] ------------------ 88| 47.5k| return (((uint8_t *)(data + 1))[c/8] & (1u << (c&7))) != 0; 89| 49.7k| } 90| 685k| if ((*data & XCL_MAP) != 0 && ------------------ | | 1310| 685k|#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */ ------------------ | Branch (90:7): [True: 585k, False: 99.8k] ------------------ 91| 685k| (((uint8_t *)(data + 1))[c/8] & (1u << (c&7))) != 0) ------------------ | Branch (91:5): [True: 497k, False: 88.0k] ------------------ 92| 497k| return !negated; /* char found */ 93| 685k| } 94| | 95| |/* First skip the bit map if present. Then match against the list of Unicode 96| |properties or large chars or ranges that end with a large char. We won't ever 97| |encounter XCL_PROP or XCL_NOTPROP when UTF support is not compiled. */ 98| | 99| 199k|if ((*data++ & XCL_MAP) != 0) data += 32 / sizeof(PCRE2_UCHAR); ------------------ | | 1310| 199k|#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */ ------------------ | Branch (99:5): [True: 93.7k, False: 105k] ------------------ 100| | 101| 336k|while ((t = *data++) != XCL_END) ------------------ | | 1313| 336k|#define XCL_END 0 /* Marks end of individual items */ ------------------ | Branch (101:8): [True: 278k, False: 57.7k] ------------------ 102| 278k| { 103| 278k| uint32_t x, y; 104| 278k| if (t == XCL_SINGLE) ------------------ | | 1314| 278k|#define XCL_SINGLE 1 /* Single item (one multibyte char) follows */ ------------------ | Branch (104:7): [True: 11.0k, False: 267k] ------------------ 105| 11.0k| { 106| 11.0k|#ifdef SUPPORT_UNICODE 107| 11.0k| if (utf) ------------------ | Branch (107:9): [True: 11.0k, False: 0] ------------------ 108| 11.0k| { 109| 11.0k| GETCHARINC(x, data); /* macro generates multiple statements */ ------------------ | | 316| 11.0k| c = *eptr++; \ | | 317| 11.0k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 11.0k| { \ | | | | 289| 11.0k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 4.22k, False: 6.87k] | | | | ------------------ | | | | 290| 11.0k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 11.0k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 6.05k, False: 817] | | | | ------------------ | | | | 292| 6.87k| { \ | | | | 293| 6.05k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 6.05k| eptr += 2; \ | | | | 295| 6.05k| } \ | | | | 296| 6.87k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 817, False: 0] | | | | ------------------ | | | | 297| 817| { \ | | | | 298| 817| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 817| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 817| eptr += 3; \ | | | | 301| 817| } \ | | | | 302| 817| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 11.0k| } | | ------------------ | | | Branch (317:7): [True: 11.0k, False: 0] | | ------------------ ------------------ 110| 11.0k| } 111| 0| else 112| 0|#endif 113| 0| x = *data++; 114| 11.0k| if (c == x) return !negated; ------------------ | Branch (114:9): [True: 2.85k, False: 8.24k] ------------------ 115| 11.0k| } 116| 267k| else if (t == XCL_RANGE) ------------------ | | 1315| 267k|#define XCL_RANGE 2 /* A range (two multibyte chars) follows */ ------------------ | Branch (116:12): [True: 5.47k, False: 262k] ------------------ 117| 5.47k| { 118| 5.47k|#ifdef SUPPORT_UNICODE 119| 5.47k| if (utf) ------------------ | Branch (119:9): [True: 5.47k, False: 0] ------------------ 120| 5.47k| { 121| 5.47k| GETCHARINC(x, data); /* macro generates multiple statements */ ------------------ | | 316| 5.47k| c = *eptr++; \ | | 317| 5.47k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 5.47k| { \ | | | | 289| 5.47k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 2.72k, False: 2.74k] | | | | ------------------ | | | | 290| 5.47k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 5.47k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 2.51k, False: 227] | | | | ------------------ | | | | 292| 2.74k| { \ | | | | 293| 2.51k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 2.51k| eptr += 2; \ | | | | 295| 2.51k| } \ | | | | 296| 2.74k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 227, False: 0] | | | | ------------------ | | | | 297| 227| { \ | | | | 298| 227| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 227| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 227| eptr += 3; \ | | | | 301| 227| } \ | | | | 302| 227| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 5.47k| } | | ------------------ | | | Branch (317:7): [True: 5.47k, False: 0] | | ------------------ ------------------ 122| 5.47k| GETCHARINC(y, data); /* macro generates multiple statements */ ------------------ | | 316| 5.47k| c = *eptr++; \ | | 317| 5.47k| if (c >= 0xc0u) GETUTF8INC(c, eptr); | | ------------------ | | | | 288| 5.47k| { \ | | | | 289| 5.47k| if ((c & 0x20u) == 0) \ | | | | ------------------ | | | | | Branch (289:9): [True: 2.11k, False: 3.35k] | | | | ------------------ | | | | 290| 5.47k| c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \ | | | | 291| 5.47k| else if ((c & 0x10u) == 0) \ | | | | ------------------ | | | | | Branch (291:14): [True: 2.70k, False: 653] | | | | ------------------ | | | | 292| 3.35k| { \ | | | | 293| 2.70k| c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \ | | | | 294| 2.70k| eptr += 2; \ | | | | 295| 2.70k| } \ | | | | 296| 3.35k| else if ((c & 0x08u) == 0) \ | | | | ------------------ | | | | | Branch (296:14): [True: 653, False: 0] | | | | ------------------ | | | | 297| 653| { \ | | | | 298| 653| c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \ | | | | 299| 653| ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \ | | | | 300| 653| eptr += 3; \ | | | | 301| 653| } \ | | | | 302| 653| else if ((c & 0x04u) == 0) \ | | | | ------------------ | | | | | Branch (302:14): [True: 0, False: 0] | | | | ------------------ | | | | 303| 0| { \ | | | | 304| 0| c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \ | | | | 305| 0| ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \ | | | | 306| 0| (eptr[3] & 0x3fu); \ | | | | 307| 0| eptr += 4; \ | | | | 308| 0| } \ | | | | 309| 0| else \ | | | | 310| 0| { \ | | | | 311| 0| c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \ | | | | 312| 0| ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \ | | | | 313| 0| ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \ | | | | 314| 0| eptr += 5; \ | | | | 315| 0| } \ | | | | 316| 5.47k| } | | ------------------ | | | Branch (317:7): [True: 5.47k, False: 0] | | ------------------ ------------------ 123| 5.47k| } 124| 0| else 125| 0|#endif 126| 0| { 127| 0| x = *data++; 128| 0| y = *data++; 129| 0| } 130| 5.47k| if (c >= x && c <= y) return !negated; ------------------ | Branch (130:9): [True: 3.10k, False: 2.36k] | Branch (130:19): [True: 1.22k, False: 1.88k] ------------------ 131| 5.47k| } 132| | 133| 262k|#ifdef SUPPORT_UNICODE 134| 262k| else /* XCL_PROP & XCL_NOTPROP */ 135| 262k| { 136| 262k| const ucd_record *prop = GET_UCD(c); ------------------ | | 1846| 262k|#define GET_UCD(ch) REAL_GET_UCD(ch) | | ------------------ | | | | 1838| 262k|#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ | | | | ------------------ | | | | | | 177| 262k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | 1839| 262k| PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 262k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 177| 262k|#define PRIV(name) _pcre2_##name | | | | ------------------ | | | | PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ | | | | ------------------ | | | | | | 1837| 262k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | 1840| 262k| UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 262k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | | | UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE]) | | | | ------------------ | | | | | | 1837| 262k|#define UCD_BLOCK_SIZE 128 | | | | ------------------ | | ------------------ ------------------ 137| 262k| BOOL isprop = t == XCL_PROP; ------------------ | | 1316| 262k|#define XCL_PROP 3 /* Unicode property (2-byte property code follows) */ ------------------ 138| 262k| BOOL ok; 139| | 140| 262k| switch(*data) 141| 262k| { 142| 504| case PT_ANY: ------------------ | | 1275| 504|#define PT_ANY 0 /* Any property - matches all chars */ ------------------ | Branch (142:7): [True: 504, False: 261k] ------------------ 143| 504| if (isprop) return !negated; ------------------ | Branch (143:11): [True: 236, False: 268] ------------------ 144| 268| break; 145| | 146| 2.27k| case PT_LAMP: ------------------ | | 1276| 2.27k|#define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */ ------------------ | Branch (146:7): [True: 2.27k, False: 259k] ------------------ 147| 2.27k| if ((prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || ------------------ | Branch (147:11): [True: 1.42k, False: 853] | Branch (147:12): [True: 342, False: 1.93k] | Branch (147:40): [True: 315, False: 1.61k] ------------------ 148| 2.27k| prop->chartype == ucp_Lt) == isprop) return !negated; ------------------ | Branch (148:12): [True: 0, False: 1.61k] ------------------ 149| 853| break; 150| | 151| 26.2k| case PT_GC: ------------------ | | 1277| 26.2k|#define PT_GC 2 /* Specified general characteristic (e.g. L) */ ------------------ | Branch (151:7): [True: 26.2k, False: 236k] ------------------ 152| 26.2k| if ((data[1] == PRIV(ucp_gentype)[prop->chartype]) == isprop) ------------------ | | 177| 26.2k|#define PRIV(name) _pcre2_##name ------------------ | Branch (152:11): [True: 13.7k, False: 12.5k] ------------------ 153| 13.7k| return !negated; 154| 12.5k| break; 155| | 156| 13.2k| case PT_PC: ------------------ | | 1278| 13.2k|#define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */ ------------------ | Branch (156:7): [True: 13.2k, False: 248k] ------------------ 157| 13.2k| if ((data[1] == prop->chartype) == isprop) return !negated; ------------------ | Branch (157:11): [True: 5.54k, False: 7.75k] ------------------ 158| 7.75k| break; 159| | 160| 44.0k| case PT_SC: ------------------ | | 1279| 44.0k|#define PT_SC 4 /* Script only (e.g. Han) */ ------------------ | Branch (160:7): [True: 44.0k, False: 218k] ------------------ 161| 44.0k| if ((data[1] == prop->script) == isprop) return !negated; ------------------ | Branch (161:11): [True: 42.8k, False: 1.20k] ------------------ 162| 1.20k| break; 163| | 164| 1.20k| case PT_SCX: ------------------ | | 1280| 1.12k|#define PT_SCX 5 /* Script extensions (includes SC) */ ------------------ | Branch (164:7): [True: 1.12k, False: 261k] ------------------ 165| 1.12k| ok = (data[1] == prop->script || ------------------ | Branch (165:13): [True: 220, False: 905] ------------------ 166| 1.12k| MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), data[1]) != 0); ------------------ | | 1871| 905|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ | Branch (166:13): [True: 0, False: 905] ------------------ 167| 1.12k| if (ok == isprop) return !negated; ------------------ | Branch (167:11): [True: 610, False: 515] ------------------ 168| 515| break; 169| | 170| 872| case PT_ALNUM: ------------------ | | 1281| 872|#define PT_ALNUM 6 /* Alphanumeric - the union of L and N */ ------------------ | Branch (170:7): [True: 872, False: 261k] ------------------ 171| 872| if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 872|#define PRIV(name) _pcre2_##name ------------------ | Branch (171:11): [True: 333, False: 539] | Branch (171:12): [True: 267, False: 605] ------------------ 172| 872| PRIV(ucp_gentype)[prop->chartype] == ucp_N) == isprop) ------------------ | | 177| 605|#define PRIV(name) _pcre2_##name ------------------ | Branch (172:12): [True: 0, False: 605] ------------------ 173| 333| return !negated; 174| 539| break; 175| | 176| | /* Perl space used to exclude VT, but from Perl 5.18 it is included, 177| | which means that Perl space and POSIX space are now identical. PCRE 178| | was changed at release 8.34. */ 179| | 180| 106k| case PT_SPACE: /* Perl space */ ------------------ | | 1282| 106k|#define PT_SPACE 7 /* Perl space - general category Z plus 9,10,12,13 */ ------------------ | Branch (180:7): [True: 106k, False: 155k] ------------------ 181| 107k| case PT_PXSPACE: /* POSIX space */ ------------------ | | 1283| 107k|#define PT_PXSPACE 8 /* POSIX space - Z plus 9,10,11,12,13 */ ------------------ | Branch (181:7): [True: 526, False: 261k] ------------------ 182| 107k| switch(c) 183| 107k| { 184| 42.5k| HSPACE_CASES: ------------------ | | 412| 709| HSPACE_BYTE_CASES: \ | | ------------------ | | | | 407| 229| case CHAR_HT: \ | | | | ------------------ | | | | | | 969| 229|#define CHAR_HT '\011' | | | | ------------------ | | | | | Branch (407:3): [True: 229, False: 107k] | | | | ------------------ | | | | 408| 471| case CHAR_SPACE: \ | | | | ------------------ | | | | | | 982| 471|#define CHAR_SPACE '\040' | | | | ------------------ | | | | | Branch (408:3): [True: 242, False: 107k] | | | | ------------------ | | | | 409| 709| case CHAR_NBSP | | | | ------------------ | | | | | | 1077| 0|#define CHAR_NBSP ((unsigned char)'\xa0') | | | | ------------------ | | ------------------ | | 413| 951| HSPACE_MULTIBYTE_CASES | | ------------------ | | | | 389| 951| case 0x1680: /* OGHAM SPACE MARK */ \ | | | | ------------------ | | | | | Branch (389:3): [True: 242, False: 107k] | | | | ------------------ | | | | 390| 1.15k| case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */ \ | | | | ------------------ | | | | | Branch (390:3): [True: 202, False: 107k] | | | | ------------------ | | | | 391| 1.36k| case 0x2000: /* EN QUAD */ \ | | | | ------------------ | | | | | Branch (391:3): [True: 208, False: 107k] | | | | ------------------ | | | | 392| 1.58k| case 0x2001: /* EM QUAD */ \ | | | | ------------------ | | | | | Branch (392:3): [True: 222, False: 107k] | | | | ------------------ | | | | 393| 1.79k| case 0x2002: /* EN SPACE */ \ | | | | ------------------ | | | | | Branch (393:3): [True: 208, False: 107k] | | | | ------------------ | | | | 394| 1.99k| case 0x2003: /* EM SPACE */ \ | | | | ------------------ | | | | | Branch (394:3): [True: 206, False: 107k] | | | | ------------------ | | | | 395| 2.20k| case 0x2004: /* THREE-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (395:3): [True: 208, False: 107k] | | | | ------------------ | | | | 396| 2.48k| case 0x2005: /* FOUR-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (396:3): [True: 276, False: 107k] | | | | ------------------ | | | | 397| 2.68k| case 0x2006: /* SIX-PER-EM SPACE */ \ | | | | ------------------ | | | | | Branch (397:3): [True: 206, False: 107k] | | | | ------------------ | | | | 398| 2.89k| case 0x2007: /* FIGURE SPACE */ \ | | | | ------------------ | | | | | Branch (398:3): [True: 209, False: 107k] | | | | ------------------ | | | | 399| 3.11k| case 0x2008: /* PUNCTUATION SPACE */ \ | | | | ------------------ | | | | | Branch (399:3): [True: 222, False: 107k] | | | | ------------------ | | | | 400| 3.35k| case 0x2009: /* THIN SPACE */ \ | | | | ------------------ | | | | | Branch (400:3): [True: 232, False: 107k] | | | | ------------------ | | | | 401| 3.57k| case 0x200A: /* HAIR SPACE */ \ | | | | ------------------ | | | | | Branch (401:3): [True: 222, False: 107k] | | | | ------------------ | | | | 402| 3.77k| case 0x202f: /* NARROW NO-BREAK SPACE */ \ | | | | ------------------ | | | | | Branch (402:3): [True: 206, False: 107k] | | | | ------------------ | | | | 403| 3.99k| case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ \ | | | | ------------------ | | | | | Branch (403:3): [True: 213, False: 107k] | | | | ------------------ | | | | 404| 4.20k| case 0x3000 /* IDEOGRAPHIC SPACE */ | | ------------------ ------------------ 185| 42.5k| VSPACE_CASES: ------------------ | | 430| 5.45k| VSPACE_BYTE_CASES: \ | | ------------------ | | | | 423| 4.41k| case CHAR_LF: \ | | | | ------------------ | | | | | | 973| 4.41k|#define CHAR_LF '\012' | | | | ------------------ | | | | | Branch (423:3): [True: 213, False: 107k] | | | | ------------------ | | | | 424| 4.71k| case CHAR_VT: \ | | | | ------------------ | | | | | | 970| 4.71k|#define CHAR_VT '\013' | | | | ------------------ | | | | | Branch (424:3): [True: 295, False: 107k] | | | | ------------------ | | | | 425| 4.92k| case CHAR_FF: \ | | | | ------------------ | | | | | | 971| 4.92k|#define CHAR_FF '\014' | | | | ------------------ | | | | | Branch (425:3): [True: 207, False: 107k] | | | | ------------------ | | | | 426| 5.17k| case CHAR_CR: \ | | | | ------------------ | | | | | | 972| 5.17k|#define CHAR_CR '\015' | | | | ------------------ | | | | | Branch (426:3): [True: 250, False: 107k] | | | | ------------------ | | | | 427| 5.45k| case CHAR_NEL | | | | ------------------ | | | | | | 975| 4.20k|#define CHAR_NEL ((unsigned char)'\x85') | | | | ------------------ | | ------------------ | | 431| 5.67k| VSPACE_MULTIBYTE_CASES | | ------------------ | | | | 419| 5.67k| case 0x2028: /* LINE SEPARATOR */ \ | | | | ------------------ | | | | | Branch (419:3): [True: 216, False: 107k] | | | | ------------------ | | | | 420| 5.90k| case 0x2029 /* PARAGRAPH SEPARATOR */ | | ------------------ ------------------ 186| 36.2k| if (isprop) return !negated; ------------------ | Branch (186:13): [True: 2.85k, False: 3.04k] ------------------ 187| 3.04k| break; 188| | 189| 101k| default: ------------------ | Branch (189:9): [True: 101k, False: 5.90k] ------------------ 190| 101k| if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == isprop) ------------------ | | 177| 101k|#define PRIV(name) _pcre2_##name ------------------ | Branch (190:13): [True: 23.9k, False: 77.6k] ------------------ 191| 23.9k| return !negated; 192| 77.6k| break; 193| 107k| } 194| 80.6k| break; 195| | 196| 80.6k| case PT_WORD: ------------------ | | 1284| 20.5k|#define PT_WORD 9 /* Word - L plus N plus underscore */ ------------------ | Branch (196:7): [True: 20.5k, False: 241k] ------------------ 197| 20.5k| if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L || ------------------ | | 177| 20.5k|#define PRIV(name) _pcre2_##name ------------------ | Branch (197:11): [True: 8.10k, False: 12.4k] | Branch (197:12): [True: 3.71k, False: 16.8k] ------------------ 198| 20.5k| PRIV(ucp_gentype)[prop->chartype] == ucp_N || c == CHAR_UNDERSCORE) ------------------ | | 177| 16.8k|#define PRIV(name) _pcre2_##name ------------------ PRIV(ucp_gentype)[prop->chartype] == ucp_N || c == CHAR_UNDERSCORE) ------------------ | | 1045| 16.2k|#define CHAR_UNDERSCORE '\137' ------------------ | Branch (198:12): [True: 592, False: 16.2k] | Branch (198:58): [True: 0, False: 16.2k] ------------------ 199| 20.5k| == isprop) 200| 8.10k| return !negated; 201| 12.4k| break; 202| | 203| 12.4k| case PT_UCNC: ------------------ | | 1286| 10.5k|#define PT_UCNC 11 /* Universal Character nameable character */ ------------------ | Branch (203:7): [True: 10.5k, False: 251k] ------------------ 204| 10.5k| if (c < 0xa0) ------------------ | Branch (204:11): [True: 9.63k, False: 956] ------------------ 205| 9.63k| { 206| 9.63k| if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 986| 19.2k|#define CHAR_DOLLAR_SIGN '\044' ------------------ if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT || ------------------ | | 1014| 18.7k|#define CHAR_COMMERCIAL_AT '\100' ------------------ | Branch (206:13): [True: 7.48k, False: 2.14k] | Branch (206:14): [True: 501, False: 9.12k] | Branch (206:39): [True: 279, False: 8.85k] ------------------ 207| 9.63k| c == CHAR_GRAVE_ACCENT) == isprop) ------------------ | | 1046| 8.85k|#define CHAR_GRAVE_ACCENT '\140' ------------------ | Branch (207:14): [True: 153, False: 8.69k] ------------------ 208| 7.48k| return !negated; 209| 9.63k| } 210| 956| else 211| 956| { 212| 956| if ((c < 0xd800 || c > 0xdfff) == isprop) ------------------ | Branch (212:13): [True: 279, False: 677] | Branch (212:14): [True: 738, False: 218] | Branch (212:28): [True: 218, False: 0] ------------------ 213| 279| return !negated; 214| 956| } 215| 2.82k| break; 216| | 217| 2.82k| case PT_BIDICL: ------------------ | | 1287| 1.08k|#define PT_BIDICL 12 /* Specified bidi class */ ------------------ | Branch (217:7): [True: 1.08k, False: 261k] ------------------ 218| 1.08k| if ((UCD_BIDICLASS_PROP(prop) == data[1]) == isprop) ------------------ | | 1854| 1.08k|#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT) | | ------------------ | | | | 1850| 1.08k|#define UCD_BIDICLASS_SHIFT 11 | | ------------------ ------------------ | Branch (218:11): [True: 771, False: 315] ------------------ 219| 771| return !negated; 220| 315| break; 221| | 222| 542| case PT_BOOL: ------------------ | | 1288| 542|#define PT_BOOL 13 /* Boolean property */ ------------------ | Branch (222:7): [True: 542, False: 261k] ------------------ 223| 542| ok = MAPBIT(PRIV(ucd_boolprop_sets) + ------------------ | | 1871| 542|#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32))) ------------------ 224| 542| UCD_BPROPS_PROP(prop), data[1]) != 0; 225| 542| if (ok == isprop) return !negated; ------------------ | Branch (225:11): [True: 264, False: 278] ------------------ 226| 278| break; 227| | 228| | /* The following three properties can occur only in an XCLASS, as there 229| | is no \p or \P coding for them. */ 230| | 231| | /* Graphic character. Implement this as not Z (space or separator) and 232| | not C (other), except for Cf (format) with a few exceptions. This seems 233| | to be what Perl does. The exceptional characters are: 234| | 235| | U+061C Arabic Letter Mark 236| | U+180E Mongolian Vowel Separator 237| | U+2066 - U+2069 Various "isolate"s 238| | */ 239| | 240| 18.6k| case PT_PXGRAPH: ------------------ | | 1297| 18.6k|#define PT_PXGRAPH 14 /* [:graph:] - characters that mark the paper */ ------------------ | Branch (240:7): [True: 18.6k, False: 243k] ------------------ 241| 18.6k| if ((PRIV(ucp_gentype)[prop->chartype] != ucp_Z && ------------------ | | 177| 18.6k|#define PRIV(name) _pcre2_##name ------------------ | Branch (241:11): [True: 16.5k, False: 2.12k] | Branch (241:12): [True: 18.0k, False: 657] ------------------ 242| 18.6k| (PRIV(ucp_gentype)[prop->chartype] != ucp_C || ------------------ | | 177| 18.0k|#define PRIV(name) _pcre2_##name ------------------ | Branch (242:14): [True: 16.0k, False: 1.96k] ------------------ 243| 18.0k| (prop->chartype == ucp_Cf && ------------------ | Branch (243:16): [True: 1.20k, False: 757] ------------------ 244| 1.96k| c != 0x061c && c != 0x180e && (c < 0x2066 || c > 0x2069)) ------------------ | Branch (244:17): [True: 1.00k, False: 198] | Branch (244:32): [True: 496, False: 510] | Branch (244:48): [True: 256, False: 240] | Branch (244:62): [True: 236, False: 4] ------------------ 245| 18.0k| )) == isprop) 246| 16.5k| return !negated; 247| 2.12k| break; 248| | 249| | /* Printable character: same as graphic, with the addition of Zs, i.e. 250| | not Zl and not Zp, and U+180E. */ 251| | 252| 12.7k| case PT_PXPRINT: ------------------ | | 1298| 12.7k|#define PT_PXPRINT 15 /* [:print:] - [:graph:] plus non-control spaces */ ------------------ | Branch (252:7): [True: 12.7k, False: 249k] ------------------ 253| 12.7k| if ((prop->chartype != ucp_Zl && ------------------ | Branch (253:11): [True: 11.0k, False: 1.77k] | Branch (253:12): [True: 12.5k, False: 225] ------------------ 254| 12.7k| prop->chartype != ucp_Zp && ------------------ | Branch (254:12): [True: 12.3k, False: 230] ------------------ 255| 12.7k| (PRIV(ucp_gentype)[prop->chartype] != ucp_C || ------------------ | | 177| 12.3k|#define PRIV(name) _pcre2_##name ------------------ | Branch (255:14): [True: 10.7k, False: 1.54k] ------------------ 256| 12.3k| (prop->chartype == ucp_Cf && ------------------ | Branch (256:16): [True: 773, False: 772] ------------------ 257| 1.54k| c != 0x061c && (c < 0x2066 || c > 0x2069)) ------------------ | Branch (257:17): [True: 545, False: 228] | Branch (257:33): [True: 226, False: 319] | Branch (257:47): [True: 0, False: 319] ------------------ 258| 12.3k| )) == isprop) 259| 11.0k| return !negated; 260| 1.77k| break; 261| | 262| | /* Punctuation: all Unicode punctuation, plus ASCII characters that 263| | Unicode treats as symbols rather than punctuation, for Perl 264| | compatibility (these are $+<=>^`|~). */ 265| | 266| 2.18k| case PT_PXPUNCT: ------------------ | | 1299| 2.18k|#define PT_PXPUNCT 16 /* [:punct:] - punctuation characters */ ------------------ | Branch (266:7): [True: 2.18k, False: 260k] ------------------ 267| 2.18k| if ((PRIV(ucp_gentype)[prop->chartype] == ucp_P || ------------------ | | 177| 2.18k|#define PRIV(name) _pcre2_##name ------------------ | Branch (267:11): [True: 1.29k, False: 884] | Branch (267:12): [True: 1.06k, False: 1.11k] ------------------ 268| 2.18k| (c < 128 && PRIV(ucp_gentype)[prop->chartype] == ucp_S)) == isprop) ------------------ | | 177| 888|#define PRIV(name) _pcre2_##name ------------------ | Branch (268:14): [True: 888, False: 228] | Branch (268:25): [True: 235, False: 653] ------------------ 269| 1.29k| return !negated; 270| 884| break; 271| | 272| | /* This should never occur, but compilers may mutter if there is no 273| | default. */ 274| | 275| 884| default: ------------------ | Branch (275:7): [True: 0, False: 262k] ------------------ 276| 0| return FALSE; ------------------ | | 69| 0|#define FALSE 0 ------------------ 277| 262k| } 278| | 279| 125k| data += 2; 280| 125k| } 281| |#else 282| | (void)utf; /* Avoid compiler warning */ 283| |#endif /* SUPPORT_UNICODE */ 284| 278k| } 285| | 286| 57.7k|return negated; /* char did not match */ 287| 199k|}