swatch[offset >> 3] |= 1 << (offset & 7);
}
- join_end_of_list:
+ join_end_of_list:
/* Quit if at the end of the list */
if (i >= len) {
: REGEX_DEPENDS_CHARSET;
has_charset_modifier = DEPENDS_PAT_MOD;
break;
- excess_modifier:
+ excess_modifier:
RExC_parse++;
if (has_charset_modifier == ASCII_RESTRICT_PAT_MOD) {
vFAIL2("Regexp modifier \"%c\" may appear a maximum of twice", ASCII_RESTRICT_PAT_MOD);
vFAIL3("Regexp modifiers \"%c\" and \"%c\" are mutually exclusive", has_charset_modifier, *(RExC_parse - 1));
}
NOT_REACHED; /*NOTREACHED*/
- neg_modifier:
+ neg_modifier:
RExC_parse++;
vFAIL2("Regexp modifier \"%c\" may not appear after the \"-\"",
*(RExC_parse - 1));
return;
/*NOTREACHED*/
default:
- fail_modifiers:
+ fail_modifiers:
RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
/* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */
vFAIL2utf8f("Sequence (%"UTF8f"...) not recognized",
nextchar(pRExC_state);
}
- do_curly:
+ do_curly:
if ((flags&SIMPLE)) {
MARK_NAUGHTY_EXP(2, 2);
reginsert(pRExC_state, CURLY, ret, depth+1);
case 's':
arg = ANYOF_SPACE;
- join_posix:
+ join_posix:
op = POSIXD + get_regex_charset(RExC_flags);
if (op > POSIXA) { /* /aa is same as /a */
RExC_contains_locale = 1;
}
- join_posix_op_known:
+ join_posix_op_known:
if (invert) {
op += NPOSIXD - POSIXD;
*flagp |= HASWIDTH|SIMPLE;
/* FALLTHROUGH */
- finish_meta_pat:
+ finish_meta_pat:
nextchar(pRExC_state);
Set_Node_Length(ret, 2); /* MJD */
break;
}
break;
case 'k': /* Handle \k<NAME> and \k'NAME' */
- parse_named_seq:
+ parse_named_seq:
{
char ch= RExC_parse[1];
if (ch != '<' && ch != '\'' && ch != '{') {
RExC_parse++;
- defchar: {
+ defchar: {
STRLEN len = 0;
UV ender = 0;
char *p;
s0 = s;
- reparse:
+ reparse:
/* We do the EXACTFish to EXACT node only if folding. (And we
* don't need to figure this out until pass 2) */
if (IN_ENCODING && ender < 0x100)
goto recode_encoding;
break;
- recode_encoding:
+ recode_encoding:
if (! RExC_override_recoding) {
SV* enc = _get_encoding();
ender = reg_recode((const char)(U8)ender, &enc);
}
} /* End of verifying node ends with an appropriate char */
- loopdone: /* Jumped to when encounters something that shouldn't be in
- the node */
+ loopdone: /* Jumped to when encounters something that shouldn't be
+ in the node */
/* I (khw) don't know if you can get here with zero length, but the
* old code handled this situation by creating a zero-length EXACT
RExC_parse++;
}
- no_close:
+ no_close:
FAIL("Syntax error in (?[...])");
}
break;
}
- charclassloop:
+ charclassloop:
namedclass = OOB_NAMEDCLASS; /* initialize as illegal */
save_value = value;
goto recode_encoding;
break;
}
- recode_encoding:
+ recode_encoding:
if (! RExC_override_recoding) {
SV* enc = _get_encoding();
value = reg_recode((const char)(U8)value, &enc);
op = POSIXA;
}
- join_posix:
+ join_posix:
/* The odd numbered ones are the complements of the
* next-lower even number one */
if (namedclass % 2 == 1) {
sv_catpv(sv, t);
}
- out_dump:
+ out_dump:
Safefree(origs);
SvREFCNT_dec_NN(lv);
/* FALLTHROUGH */
- do_exactf_non_utf8: /* Neither pattern nor string are UTF8, and there
+ do_exactf_non_utf8: /* Neither pattern nor string are UTF8, and there
are no glitches with fold-length differences
between the target string and pattern */
}
break;
- do_exactf_utf8:
- {
+ do_exactf_utf8:
+ {
unsigned expansion;
/* If one of the operands is in utf8, we can't use the simpler folding
}
else {
- posix_utf8:
+ posix_utf8:
classnum = (_char_class_number) FLAGS(c);
if (classnum < _FIRST_NON_SWASH_CC) {
while (s < strend) {
case BOUNDA: /* /\b/a */
- bound_ascii_match_only:
+ bound_ascii_match_only:
/* Here the string isn't utf8, or is utf8 and only ascii characters
* are to match \w. In the latter case looking at the byte just
* prior to the current one may be just the final byte of a
locinput += 2;
}
else { /* Handle above Latin-1 code points */
- utf8_posix_above_latin1:
+ utf8_posix_above_latin1:
classnum = (_char_class_number) FLAGS(scan);
if (classnum < _FIRST_NON_SWASH_CC) {
locinput += UTF8SKIP(locinput);
}
}
- exit_utf8:
+ exit_utf8:
if (locinput > reginfo->strend) sayNO;
}
break;
maxopenparen = 0;
/* run the pattern returned from (??{...}) */
- eval_recurse_doit: /* Share code with GOSUB below this line
+ eval_recurse_doit: /* Share code with GOSUB below this line
* At this point we expect the stack context to be
* set up correctly */
/* NOTREACHED */
NOT_REACHED;
- curly_try_B_max:
+ curly_try_B_max:
/* a successful greedy match: now try to match B */
if (cur_eval && cur_eval->u.eval.close_paren &&
cur_eval->u.eval.close_paren == (U32)ST.paren) {
#undef ST
case END: /* last op of main pattern */
- fake_end:
+ fake_end:
if (cur_eval) {
/* we've just finished A in /(??{A})B/; now continue with B */
/* this is a point to jump to in order to increment
* locinput by one character */
- increment_locinput:
+ increment_locinput:
assert(!NEXTCHR_IS_EOS);
if (utf8_target) {
locinput += PL_utf8skip[nextchr];
case EXACTFU:
utf8_flags = reginfo->is_utf8_pat ? FOLDEQ_S2_ALREADY_FOLDED : 0;
- do_exactf: {
+ do_exactf: {
int c1, c2;
U8 c1_utf8[UTF8_MAXBYTES+1], c2_utf8[UTF8_MAXBYTES+1];
}
}
else {
- utf8_posix:
+ utf8_posix:
classnum = (_char_class_number) FLAGS(p);
if (classnum < _FIRST_NON_SWASH_CC) {