X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=regcomp.c;h=356fcb31494da66928682ad5d83d2160b7666345;hb=11faa288e292c27cb2ddc4ccdc483b523d26ce19;hp=0dafdd0b9bc1fdb1ca066c92eecf20c1bb00b5ca;hpb=73b437c8b23cd73848b265b0c5a0c71d47dc6532;p=p5sagit%2Fp5-mst-13.2.git diff --git a/regcomp.c b/regcomp.c index 0dafdd0..356fcb3 100644 --- a/regcomp.c +++ b/regcomp.c @@ -844,7 +844,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) DEBUG_r(if (!PL_colorset) reginitcolors()); DEBUG_r(PerlIO_printf(Perl_debug_log, "%sCompiling REx%s `%s%*s%s'\n", PL_colors[4],PL_colors[5],PL_colors[0], - xend - exp, PL_regprecomp, PL_colors[1])); + (int)(xend - exp), PL_regprecomp, PL_colors[1])); PL_regflags = pm->op_pmflags; PL_regsawback = 0; @@ -944,7 +944,12 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) /* Starting-point info. */ again: - if (OP(first) == EXACT); /* Empty, get anchored substr later. */ + if (PL_regkind[(U8)OP(first) == EXACT]) { + if (OP(first) == EXACT); /* Empty, get anchored substr later. */ + else if ((OP(first) == EXACTF || OP(first) == EXACTFL) + && !UTF) + r->regstclass = first; + } else if (strchr((char*)PL_simple+4,OP(first))) r->regstclass = first; else if (PL_regkind[(U8)OP(first)] == BOUND || @@ -986,8 +991,8 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) r->reganch |= ROPT_SKIP; /* Scan is after the zeroth branch, first is atomic matcher. */ - DEBUG_r(PerlIO_printf(Perl_debug_log, "first at %d\n", - first - scan + 1)); + DEBUG_r(PerlIO_printf(Perl_debug_log, "first at %"IVdf"\n", + (IV)(first - scan + 1))); /* * If there's something expensive in the r.e., find the * longest literal string that must appear and make it the @@ -2022,7 +2027,7 @@ tryagain: if (!e) FAIL("Missing right brace on \\x{}"); else if (UTF) { - ender = scan_hex(p + 1, e - p, &numlen); + ender = (UV)scan_hex(p + 1, e - p, &numlen); if (numlen + len >= 127) { /* numlen is generous */ p--; goto loopdone; @@ -2033,7 +2038,7 @@ tryagain: FAIL("Can't use \\x{} without 'use utf8' declaration"); } else { - ender = scan_hex(p, 2, &numlen); + ender = (UV)scan_hex(p, 2, &numlen); p += numlen; } break; @@ -2046,7 +2051,7 @@ tryagain: case '5': case '6': case '7': case '8':case '9': if (*p == '0' || (isDIGIT(p[1]) && atoi(p) >= PL_regnpar) ) { - ender = scan_oct(p, 3, &numlen); + ender = (UV)scan_oct(p, 3, &numlen); p += numlen; } else { @@ -2061,9 +2066,9 @@ tryagain: default: if (!SIZE_ONLY && ckWARN(WARN_UNSAFE) && isALPHA(*p)) Perl_warner(aTHX_ WARN_UNSAFE, - "/%.127s/: Unrecognized escape \\%c passed through", - PL_regprecomp, - *p); + "/%.127s/: Unrecognized escape \\%c passed through", + PL_regprecomp, + *p); goto normal_default; } break; @@ -2156,7 +2161,7 @@ S_regpposixcc(pTHX_ I32 value) { dTHR; char *posixcc = 0; - I32 namedclass = -1; + I32 namedclass = OOB_NAMEDCLASS; if (value == '[' && PL_regcomp_parse + 1 < PL_regxend && /* I smell either [: or [= or [. -- POSIX has been here, right? */ @@ -2269,7 +2274,7 @@ S_regpposixcc(pTHX_ I32 value) STATIC void S_checkposixcc(pTHX) { - if (ckWARN(WARN_UNSAFE) && !SIZE_ONLY && + if (!SIZE_ONLY && ckWARN(WARN_UNSAFE) && (*PL_regcomp_parse == ':' || *PL_regcomp_parse == '=' || *PL_regcomp_parse == '.')) { @@ -2292,8 +2297,7 @@ STATIC regnode * S_regclass(pTHX) { dTHR; - register char *opnd, *s; - register I32 value; + register UV value; register I32 lastvalue = OOB_CHAR8; register I32 range = 0; register regnode *ret; @@ -2301,29 +2305,29 @@ S_regclass(pTHX) I32 numlen; I32 namedclass; char *rangebegin; + bool need_class = 0; - s = opnd = MASK(PL_regcode); ret = reg_node(ANYOF); - for (value = 0; value < ANYOF_SIZE; value++) - REGC(0, s++); + if (SIZE_ONLY) + PL_regsize += ANYOF_SKIP; + else { + ret->flags = 0; + ANYOF_BITMAP_ZERO(ret); + PL_regcode += ANYOF_SKIP; + if (FOLD) + ANYOF_FLAGS(ret) |= ANYOF_FOLD; + if (LOC) + ANYOF_FLAGS(ret) |= ANYOF_LOCALE; + } if (*PL_regcomp_parse == '^') { /* Complement of range. */ PL_regnaughty++; PL_regcomp_parse++; if (!SIZE_ONLY) - ANYOF_FLAGS(opnd) |= ANYOF_INVERT; - } - if (!SIZE_ONLY) { - PL_regcode += ANY_SKIP; - if (FOLD) - ANYOF_FLAGS(opnd) |= ANYOF_FOLD; - if (LOC) - ANYOF_FLAGS(opnd) |= ANYOF_LOCALE; - } - else { - PL_regsize += ANY_SKIP; + ANYOF_FLAGS(ret) |= ANYOF_INVERT; } - checkposixcc(); + if (!SIZE_ONLY && ckWARN(WARN_UNSAFE)) + checkposixcc(); if (*PL_regcomp_parse == ']' || *PL_regcomp_parse == '-') goto skipcond; /* allow 1st char to be ] or - */ @@ -2352,7 +2356,7 @@ S_regclass(pTHX) case 'e': value = '\033'; break; case 'a': value = '\007'; break; case 'x': - value = scan_hex(PL_regcomp_parse, 2, &numlen); + value = (UV)scan_hex(PL_regcomp_parse, 2, &numlen); PL_regcomp_parse += numlen; break; case 'c': @@ -2361,12 +2365,22 @@ S_regclass(pTHX) break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': - value = scan_oct(--PL_regcomp_parse, 3, &numlen); + value = (UV)scan_oct(--PL_regcomp_parse, 3, &numlen); PL_regcomp_parse += numlen; break; + default: + if (!SIZE_ONLY && ckWARN(WARN_UNSAFE) && isALPHA(value)) + Perl_warner(aTHX_ WARN_UNSAFE, + "/%.127s/: Unrecognized escape \\%c in character class passed through", + PL_regprecomp, + value); + break; } } if (namedclass > OOB_NAMEDCLASS) { + if (!need_class && !SIZE_ONLY) + ANYOF_CLASS_ZERO(ret); + need_class = 1; if (range) { /* a-\d, a-[:digit:] */ if (!SIZE_ONLY) { if (ckWARN(WARN_UNSAFE)) @@ -2376,8 +2390,8 @@ S_regclass(pTHX) PL_regcomp_parse - rangebegin, PL_regcomp_parse - rangebegin, rangebegin); - ANYOF_BITMAP_SET(opnd, lastvalue); - ANYOF_BITMAP_SET(opnd, '-'); + ANYOF_BITMAP_SET(ret, lastvalue); + ANYOF_BITMAP_SET(ret, '-'); } range = 0; /* this is not a true range */ } @@ -2385,235 +2399,235 @@ S_regclass(pTHX) switch (namedclass) { case ANYOF_ALNUM: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_ALNUM); + ANYOF_CLASS_SET(ret, ANYOF_ALNUM); else { for (value = 0; value < 256; value++) if (isALNUM(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NALNUM: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NALNUM); + ANYOF_CLASS_SET(ret, ANYOF_NALNUM); else { for (value = 0; value < 256; value++) if (!isALNUM(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_SPACE: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_SPACE); + ANYOF_CLASS_SET(ret, ANYOF_SPACE); else { for (value = 0; value < 256; value++) if (isSPACE(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NSPACE: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NSPACE); + ANYOF_CLASS_SET(ret, ANYOF_NSPACE); else { for (value = 0; value < 256; value++) if (!isSPACE(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_DIGIT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_DIGIT); + ANYOF_CLASS_SET(ret, ANYOF_DIGIT); else { for (value = '0'; value <= '9'; value++) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NDIGIT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NDIGIT); + ANYOF_CLASS_SET(ret, ANYOF_NDIGIT); else { for (value = 0; value < '0'; value++) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); for (value = '9' + 1; value < 256; value++) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NALNUMC: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NALNUMC); + ANYOF_CLASS_SET(ret, ANYOF_NALNUMC); else { for (value = 0; value < 256; value++) if (!isALNUMC(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_ALNUMC: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_ALNUMC); + ANYOF_CLASS_SET(ret, ANYOF_ALNUMC); else { for (value = 0; value < 256; value++) if (isALNUMC(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_ALPHA: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_ALPHA); + ANYOF_CLASS_SET(ret, ANYOF_ALPHA); else { for (value = 0; value < 256; value++) if (isALPHA(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NALPHA: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NALPHA); + ANYOF_CLASS_SET(ret, ANYOF_NALPHA); else { for (value = 0; value < 256; value++) if (!isALPHA(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_ASCII: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_ASCII); + ANYOF_CLASS_SET(ret, ANYOF_ASCII); else { for (value = 0; value < 128; value++) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NASCII: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NASCII); + ANYOF_CLASS_SET(ret, ANYOF_NASCII); else { for (value = 128; value < 256; value++) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_CNTRL: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_CNTRL); + ANYOF_CLASS_SET(ret, ANYOF_CNTRL); else { for (value = 0; value < 256; value++) if (isCNTRL(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } lastvalue = OOB_CHAR8; break; case ANYOF_NCNTRL: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NCNTRL); + ANYOF_CLASS_SET(ret, ANYOF_NCNTRL); else { for (value = 0; value < 256; value++) if (!isCNTRL(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_GRAPH: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_GRAPH); + ANYOF_CLASS_SET(ret, ANYOF_GRAPH); else { for (value = 0; value < 256; value++) if (isGRAPH(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NGRAPH: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NGRAPH); + ANYOF_CLASS_SET(ret, ANYOF_NGRAPH); else { for (value = 0; value < 256; value++) if (!isGRAPH(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_LOWER: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_LOWER); + ANYOF_CLASS_SET(ret, ANYOF_LOWER); else { for (value = 0; value < 256; value++) if (isLOWER(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NLOWER: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NLOWER); + ANYOF_CLASS_SET(ret, ANYOF_NLOWER); else { for (value = 0; value < 256; value++) if (!isLOWER(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_PRINT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_PRINT); + ANYOF_CLASS_SET(ret, ANYOF_PRINT); else { for (value = 0; value < 256; value++) if (isPRINT(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NPRINT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NPRINT); + ANYOF_CLASS_SET(ret, ANYOF_NPRINT); else { for (value = 0; value < 256; value++) if (!isPRINT(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_PUNCT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_PUNCT); + ANYOF_CLASS_SET(ret, ANYOF_PUNCT); else { for (value = 0; value < 256; value++) if (isPUNCT(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NPUNCT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NPUNCT); + ANYOF_CLASS_SET(ret, ANYOF_NPUNCT); else { for (value = 0; value < 256; value++) if (!isPUNCT(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_UPPER: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_UPPER); + ANYOF_CLASS_SET(ret, ANYOF_UPPER); else { for (value = 0; value < 256; value++) if (isUPPER(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NUPPER: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NUPPER); + ANYOF_CLASS_SET(ret, ANYOF_NUPPER); else { for (value = 0; value < 256; value++) if (!isUPPER(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_XDIGIT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_XDIGIT); + ANYOF_CLASS_SET(ret, ANYOF_XDIGIT); else { for (value = 0; value < 256; value++) if (isXDIGIT(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; case ANYOF_NXDIGIT: if (LOC) - ANYOF_CLASS_SET(opnd, ANYOF_NXDIGIT); + ANYOF_CLASS_SET(ret, ANYOF_NXDIGIT); else { for (value = 0; value < 256; value++) if (!isXDIGIT(value)) - ANYOF_BITMAP_SET(opnd, value); + ANYOF_BITMAP_SET(ret, value); } break; default: @@ -2621,7 +2635,7 @@ S_regclass(pTHX) break; } if (LOC) - ANYOF_FLAGS(opnd) |= ANYOF_CLASS; + ANYOF_FLAGS(ret) |= ANYOF_CLASS; continue; } } @@ -2650,7 +2664,7 @@ S_regclass(pTHX) PL_regcomp_parse - rangebegin, rangebegin); if (!SIZE_ONLY) - ANYOF_BITMAP_SET(opnd, '-'); + ANYOF_BITMAP_SET(ret, '-'); } else range = 1; continue; /* do it next time */ @@ -2666,36 +2680,42 @@ S_regclass(pTHX) if (isLOWER(lastvalue)) { for (i = lastvalue; i <= value; i++) if (isLOWER(i)) - ANYOF_BITMAP_SET(opnd, i); + ANYOF_BITMAP_SET(ret, i); } else { for (i = lastvalue; i <= value; i++) if (isUPPER(i)) - ANYOF_BITMAP_SET(opnd, i); + ANYOF_BITMAP_SET(ret, i); } } else #endif for ( ; lastvalue <= value; lastvalue++) - ANYOF_BITMAP_SET(opnd, lastvalue); + ANYOF_BITMAP_SET(ret, lastvalue); } range = 0; } + if (need_class) { + if (SIZE_ONLY) + PL_regsize += ANYOF_CLASS_ADD_SKIP; + else + PL_regcode += ANYOF_CLASS_ADD_SKIP; + } /* optimize case-insensitive simple patterns (e.g. /[a-z]/i) */ if (!SIZE_ONLY && - (ANYOF_FLAGS(opnd) & (ANYOF_FLAGS_ALL ^ ANYOF_INVERT)) == ANYOF_FOLD) { + (ANYOF_FLAGS(ret) & (ANYOF_FLAGS_ALL ^ ANYOF_INVERT)) == ANYOF_FOLD) { for (value = 0; value < 256; ++value) { - if (ANYOF_BITMAP_TEST(opnd, value)) { + if (ANYOF_BITMAP_TEST(ret, value)) { I32 cf = PL_fold[value]; - ANYOF_BITMAP_SET(opnd, cf); + ANYOF_BITMAP_SET(ret, cf); } } - ANYOF_FLAGS(opnd) &= ~ANYOF_FOLD; + ANYOF_FLAGS(ret) &= ~ANYOF_FOLD; } /* optimize inverted simple patterns (e.g. [^a-z]) */ - if (!SIZE_ONLY && (ANYOF_FLAGS(opnd) & ANYOF_FLAGS_ALL) == ANYOF_INVERT) { + if (!SIZE_ONLY && (ANYOF_FLAGS(ret) & ANYOF_FLAGS_ALL) == ANYOF_INVERT) { for (value = 0; value < ANYOF_BITMAP_SIZE; ++value) - opnd[ANYOF_BITMAP_OFFSET + value] ^= ANYOF_FLAGS_ALL; - ANYOF_FLAGS(opnd) = 0; + ANYOF_BITMAP(ret)[value] ^= ANYOF_FLAGS_ALL; + ANYOF_FLAGS(ret) = 0; } return ret; } @@ -2704,8 +2724,8 @@ STATIC regnode * S_regclassutf8(pTHX) { dTHR; - register char *opnd, *e; - register U32 value; + register char *e; + register UV value; register U32 lastvalue = OOB_UTF8; register I32 range = 0; register regnode *ret; @@ -2730,7 +2750,8 @@ S_regclassutf8(pTHX) listsv = newSVpvn("# comment\n",10); } - checkposixcc(); + if (!SIZE_ONLY && ckWARN(WARN_UNSAFE)) + checkposixcc(); if (*PL_regcomp_parse == ']' || *PL_regcomp_parse == '-') goto skipcond; /* allow 1st char to be ] or - */ @@ -2789,13 +2810,13 @@ S_regclassutf8(pTHX) e = strchr(PL_regcomp_parse++, '}'); if (!e) FAIL("Missing right brace on \\x{}"); - value = scan_hex(PL_regcomp_parse, + value = (UV)scan_hex(PL_regcomp_parse, e - PL_regcomp_parse, &numlen); PL_regcomp_parse = e + 1; } else { - value = scan_hex(PL_regcomp_parse, 2, &numlen); + value = (UV)scan_hex(PL_regcomp_parse, 2, &numlen); PL_regcomp_parse += numlen; } break; @@ -2805,9 +2826,16 @@ S_regclassutf8(pTHX) break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': - value = scan_oct(--PL_regcomp_parse, 3, &numlen); + value = (UV)scan_oct(--PL_regcomp_parse, 3, &numlen); PL_regcomp_parse += numlen; break; + default: + if (!SIZE_ONLY && ckWARN(WARN_UNSAFE) && isALPHA(value)) + Perl_warner(aTHX_ WARN_UNSAFE, + "/%.127s/: Unrecognized escape \\%c in character class passed through", + PL_regprecomp, + value); + break; } } if (namedclass > OOB_NAMEDCLASS) { @@ -3159,12 +3187,12 @@ S_dumpuntil(pTHX_ regnode *start, regnode *node, regnode *last, SV* sv, I32 l) if (OP(node) == OPTIMIZED) goto after_print; regprop(sv, node); - PerlIO_printf(Perl_debug_log, "%4d:%*s%s", node - start, + PerlIO_printf(Perl_debug_log, "%4"IVdf":%*s%s", (IV)(node - start), 2*l + 1, "", SvPVX(sv)); if (next == NULL) /* Next ptr. */ PerlIO_printf(Perl_debug_log, "(0)"); else - PerlIO_printf(Perl_debug_log, "(%d)", next - start); + PerlIO_printf(Perl_debug_log, "(%"IVdf")", (IV)(next - start)); (void)PerlIO_putc(Perl_debug_log, '\n'); after_print: if (PL_regkind[(U8)op] == BRANCHJ) { @@ -3191,7 +3219,7 @@ S_dumpuntil(pTHX_ regnode *start, regnode *node, regnode *last, SV* sv, I32 l) } else if (op == ANYOF) { node = NEXTOPER(node); - node += ANY_SKIP; + node += ANYOF_SKIP; } else if (PL_regkind[(U8)op] == EXACT) { /* Literal string, where present. */ @@ -3225,21 +3253,23 @@ Perl_regdump(pTHX_ regexp *r) /* Header fields of interest. */ if (r->anchored_substr) - PerlIO_printf(Perl_debug_log, "anchored `%s%.*s%s'%s at %d ", + PerlIO_printf(Perl_debug_log, + "anchored `%s%.*s%s'%s at %"IVdf" ", PL_colors[0], - SvCUR(r->anchored_substr) - (SvTAIL(r->anchored_substr)!=0), + (int)(SvCUR(r->anchored_substr) - (SvTAIL(r->anchored_substr)!=0)), SvPVX(r->anchored_substr), PL_colors[1], SvTAIL(r->anchored_substr) ? "$" : "", - r->anchored_offset); + (IV)r->anchored_offset); if (r->float_substr) - PerlIO_printf(Perl_debug_log, "floating `%s%.*s%s'%s at %d..%u ", + PerlIO_printf(Perl_debug_log, + "floating `%s%.*s%s'%s at %"IVdf"..%"UVuf" ", PL_colors[0], - SvCUR(r->float_substr) - (SvTAIL(r->float_substr)!=0), + (int)(SvCUR(r->float_substr) - (SvTAIL(r->float_substr)!=0)), SvPVX(r->float_substr), PL_colors[1], SvTAIL(r->float_substr) ? "$" : "", - r->float_min_offset, r->float_max_offset); + (IV)r->float_min_offset, (UV)r->float_max_offset); if (r->check_substr) PerlIO_printf(Perl_debug_log, r->check_substr == r->float_substr @@ -3511,7 +3541,6 @@ Perl_save_re_context(pTHX) } #ifdef PERL_OBJECT -#define NO_XSLOCKS #include "XSUB.h" #undef this #define this pPerl