-1 we are not allowed an argument*/\n\n if (has_intervening_patws) {\n RExC_parse++; /* past the '*' */\n vFAIL(\"In '(*VERB...)', the '(' and '*' must be adjacent\");\n }\n\t while (RExC_parse < RExC_end && *RExC_parse != ')' ) {\n\t if ( *RExC_parse == ':' ) {\n\t start_arg = RExC_parse + 1;\n\t break;\n\t }\n\t RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n\t }\n\t verb_len = RExC_parse - start_verb;\n\t if ( start_arg ) {\n if (RExC_parse >= RExC_end) {\n goto unterminated_verb_pattern;\n }\n\t RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n\t while ( RExC_parse < RExC_end && *RExC_parse != ')' )\n RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n\t if ( RExC_parse >= RExC_end || *RExC_parse != ')' )\n unterminated_verb_pattern:\n\t vFAIL(\"Unterminated verb pattern argument\");\n\t if ( RExC_parse == start_arg )\n\t start_arg = NULL;\n\t } else {\n\t if ( RExC_parse >= RExC_end || *RExC_parse != ')' )\n\t vFAIL(\"Unterminated verb pattern\");\n\t }\n\n /* Here, we know that RExC_parse < RExC_end */\n\n\t switch ( *start_verb ) {\n case 'A': /* (*ACCEPT) */\n if ( memEQs(start_verb,verb_len,\"ACCEPT\") ) {\n\t\t op = ACCEPT;\n\t\t internal_argval = RExC_nestroot;\n\t\t}\n\t\tbreak;\n case 'C': /* (*COMMIT) */\n if ( memEQs(start_verb,verb_len,\"COMMIT\") )\n op = COMMIT;\n break;\n case 'F': /* (*FAIL) */\n if ( verb_len==1 || memEQs(start_verb,verb_len,\"FAIL\") ) {\n\t\t op = OPFAIL;\n\t\t}\n\t\tbreak;\n case ':': /* (*:NAME) */\n\t case 'M': /* (*MARK:NAME) */\n\t if ( verb_len==0 || memEQs(start_verb,verb_len,\"MARK\") ) {\n op = MARKPOINT;\n arg_required = 1;\n }\n break;\n case 'P': /* (*PRUNE) */\n if ( memEQs(start_verb,verb_len,\"PRUNE\") )\n op = PRUNE;\n break;\n case 'S': /* (*SKIP) */\n if ( memEQs(start_verb,verb_len,\"SKIP\") )\n op = SKIP;\n break;\n case 'T': /* (*THEN) */\n /* [19:06] <TimToady> :: is then */\n if ( memEQs(start_verb,verb_len,\"THEN\") ) {\n op = CUTGROUP;\n RExC_seen |= REG_CUTGROUP_SEEN;\n }\n break;\n\t }\n\t if ( ! op ) {\n\t RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n vFAIL2utf8f(\n \"Unknown verb pattern '%\" UTF8f \"'\",\n UTF8fARG(UTF, verb_len, start_verb));\n\t }\n if ( arg_required && !start_arg ) {\n vFAIL3(\"Verb pattern '%.*s' has a mandatory argument\",\n verb_len, start_verb);\n }\n if (internal_argval == -1) {\n ret = reganode(pRExC_state, op, 0);\n } else {\n ret = reg2Lanode(pRExC_state, op, 0, internal_argval);\n }\n RExC_seen |= REG_VERBARG_SEEN;\n if ( ! SIZE_ONLY ) {\n if (start_arg) {\n SV *sv = newSVpvn( start_arg,\n RExC_parse - start_arg);\n ARG(ret) = add_data( pRExC_state,\n STR_WITH_LEN(\"S\"));\n RExC_rxi->data->data[ARG(ret)]=(void*)sv;\n ret->flags = 1;\n } else {\n ret->flags = 0;\n }\n if ( internal_argval != -1 )\n ARG2L_SET(ret, internal_argval);\n }\n\t nextchar(pRExC_state);\n\t return ret;\n }\n else if (*RExC_parse == '?') { /* (?...) */\n\t bool is_logical = 0;\n\t const char * const seqstart = RExC_parse;\n const char * endptr;\n if (has_intervening_patws) {\n RExC_parse++;\n vFAIL(\"In '(?...)', the '(' and '?' must be adjacent\");\n }\n\n\t RExC_parse++; /* past the '?' */\n paren = *RExC_parse; /* might be a trailing NUL, if not\n well-formed */\n RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n if (RExC_parse > RExC_end) {\n paren = '\\0';\n }\n\t ret = NULL;\t\t\t/* For look-ahead/behind. */\n\t switch (paren) {\n\n\t case 'P':\t/* (?P...) variants for those used to PCRE/Python */\n\t paren = *RExC_parse;\n\t\tif ( paren == '<') { /* (?P<...>) named capture */\n RExC_parse++;\n if (RExC_parse >= RExC_end) {\n vFAIL(\"Sequence (?P<... not terminated\");\n }\n\t\t goto named_capture;\n }\n else if (paren == '>') { /* (?P>name) named recursion */\n RExC_parse++;\n if (RExC_parse >= RExC_end) {\n vFAIL(\"Sequence (?P>... not terminated\");\n }\n goto named_recursion;\n }\n else if (paren == '=') { /* (?P=...) named backref */\n RExC_parse++;\n return handle_named_backref(pRExC_state, flagp,\n parse_start, ')');\n }\n RExC_parse += SKIP_IF_CHAR(RExC_parse);\n /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */\n\t\tvFAIL3(\"Sequence (%.*s...) not recognized\",\n RExC_parse-seqstart, seqstart);\n\t\tNOT_REACHED; /*NOTREACHED*/\n case '<': /* (?<...) */\n\t\tif (*RExC_parse == '!')\n\t\t paren = ',';\n\t\telse if (*RExC_parse != '=')\n named_capture:\n\t\t{ /* (?<...>) */\n\t\t char *name_start;\n\t\t SV *svname;\n\t\t paren= '>';\n /* FALLTHROUGH */\n case '\\'': /* (?'...') */\n name_start = RExC_parse;\n svname = reg_scan_name(pRExC_state,\n SIZE_ONLY /* reverse test from the others */\n ? REG_RSN_RETURN_NAME\n : REG_RSN_RETURN_NULL);\n\t\t if ( RExC_parse == name_start\n || RExC_parse >= RExC_end\n || *RExC_parse != paren)\n {\n\t\t vFAIL2(\"Sequence (?%c... not terminated\",\n\t\t paren=='>' ? '<' : paren);\n }\n\t\t if (SIZE_ONLY) {\n\t\t\tHE *he_str;\n\t\t\tSV *sv_dat = NULL;\n if (!svname) /* shouldn't happen */\n Perl_croak(aTHX_\n \"panic: reg_scan_name returned NULL\");\n if (!RExC_paren_names) {\n RExC_paren_names= newHV();\n sv_2mortal(MUTABLE_SV(RExC_paren_names));\n#ifdef DEBUGGING\n RExC_paren_name_list= newAV();\n sv_2mortal(MUTABLE_SV(RExC_paren_name_list));\n#endif\n }\n he_str = hv_fetch_ent( RExC_paren_names, svname, 1, 0 );\n if ( he_str )\n sv_dat = HeVAL(he_str);\n if ( ! sv_dat ) {\n /* croak baby croak */\n Perl_croak(aTHX_\n \"panic: paren_name hash element allocation failed\");\n } else if ( SvPOK(sv_dat) ) {\n /* (?|...) can mean we have dupes so scan to check\n its already been stored. Maybe a flag indicating\n we are inside such a construct would be useful,\n but the arrays are likely to be quite small, so\n for now we punt -- dmq */\n IV count = SvIV(sv_dat);\n I32 *pv = (I32*)SvPVX(sv_dat);\n IV i;\n for ( i = 0 ; i < count ; i++ ) {\n if ( pv[i] == RExC_npar ) {\n count = 0;\n break;\n }\n }\n if ( count ) {\n pv = (I32*)SvGROW(sv_dat,\n SvCUR(sv_dat) + sizeof(I32)+1);\n SvCUR_set(sv_dat, SvCUR(sv_dat) + sizeof(I32));\n pv[count] = RExC_npar;\n SvIV_set(sv_dat, SvIVX(sv_dat) + 1);\n }\n } else {\n (void)SvUPGRADE(sv_dat,SVt_PVNV);\n sv_setpvn(sv_dat, (char *)&(RExC_npar),\n sizeof(I32));\n SvIOK_on(sv_dat);\n SvIV_set(sv_dat, 1);\n }\n#ifdef DEBUGGING\n /* Yes this does cause a memory leak in debugging Perls\n * */\n if (!av_store(RExC_paren_name_list,\n RExC_npar, SvREFCNT_inc(svname)))\n SvREFCNT_dec_NN(svname);\n#endif\n\n /*sv_dump(sv_dat);*/\n }\n nextchar(pRExC_state);\n\t\t paren = 1;\n\t\t goto capturing_parens;\n\t\t}\n RExC_seen |= REG_LOOKBEHIND_SEEN;\n\t\tRExC_in_lookbehind++;\n\t\tRExC_parse++;\n if (RExC_parse >= RExC_end) {\n vFAIL(\"Sequence (?... not terminated\");\n }\n\n /* FALLTHROUGH */\n\t case '=': /* (?=...) */\n\t\tRExC_seen_zerolen++;\n break;\n\t case '!': /* (?!...) */\n\t\tRExC_seen_zerolen++;\n\t\t/* check if we're really just a \"FAIL\" assertion */\n skip_to_be_ignored_text(pRExC_state, &RExC_parse,\n FALSE /* Don't force to /x */ );\n\t if (*RExC_parse == ')') {\n ret=reganode(pRExC_state, OPFAIL, 0);\n\t nextchar(pRExC_state);\n\t return ret;\n\t }\n\t break;\n\t case '|': /* (?|...) */\n\t /* branch reset, behave like a (?:...) except that\n\t buffers in alternations share the same numbers */\n\t paren = ':';\n\t after_freeze = freeze_paren = RExC_npar;\n\t break;\n\t case ':': /* (?:...) */\n\t case '>': /* (?>...) */\n\t\tbreak;\n\t case '$': /* (?$...) */\n\t case '@': /* (?@...) */\n\t\tvFAIL2(\"Sequence (?%c...) not implemented\", (int)paren);\n\t\tbreak;\n\t case '0' : /* (?0) */\n\t case 'R' : /* (?R) */\n if (RExC_parse == RExC_end || *RExC_parse != ')')\n\t\t FAIL(\"Sequence (?R) not terminated\");\n num = 0;\n RExC_seen |= REG_RECURSE_SEEN;\n\t\t*flagp |= POSTPONED;\n goto gen_recurse_regop;\n\t\t/*notreached*/\n /* named and numeric backreferences */\n case '&': /* (?&NAME) */\n parse_start = RExC_parse - 1;\n named_recursion:\n {\n \t\t SV *sv_dat = reg_scan_name(pRExC_state,\n \t\t SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);\n \t\t num = sv_dat ? *((I32 *)SvPVX(sv_dat)) : 0;\n }\n if (RExC_parse >= RExC_end || *RExC_parse != ')')\n vFAIL(\"Sequence (?&... not terminated\");\n goto gen_recurse_regop;\n /* NOTREACHED */\n case '+':\n if (!(RExC_parse[0] >= '1' && RExC_parse[0] <= '9')) {\n RExC_parse++;\n vFAIL(\"Illegal pattern\");\n }\n goto parse_recursion;\n /* NOTREACHED*/\n case '-': /* (?-1) */\n if (!(RExC_parse[0] >= '1' && RExC_parse[0] <= '9')) {\n RExC_parse--; /* rewind to let it be handled later */\n goto parse_flags;\n }\n /* FALLTHROUGH */\n case '1': case '2': case '3': case '4': /* (?1) */\n\t case '5': case '6': case '7': case '8': case '9':\n\t RExC_parse = (char *) seqstart + 1; /* Point to the digit */\n parse_recursion:\n {\n bool is_neg = FALSE;\n UV unum;\n parse_start = RExC_parse - 1; /* MJD */\n if (*RExC_parse == '-') {\n RExC_parse++;\n is_neg = TRUE;\n }\n if (grok_atoUV(RExC_parse, &unum, &endptr)\n && unum <= I32_MAX\n ) {\n num = (I32)unum;\n RExC_parse = (char*)endptr;\n } else\n num = I32_MAX;\n if (is_neg) {\n /* Some limit for num? */\n num = -num;\n }\n }\n\t if (*RExC_parse!=')')\n\t vFAIL(\"Expecting close bracket\");\n\n gen_recurse_regop:\n if ( paren == '-' ) {\n /*\n Diagram of capture buffer numbering.\n Top line is the normal capture buffer numbers\n Bottom line is the negative indexing as from\n the X (the (?-2))\n\n + 1 2 3 4 5 X 6 7\n /(a(x)y)(a(b(c(?-2)d)e)f)(g(h))/\n - 5 4 3 2 1 X x x\n\n */\n num = RExC_npar + num;\n if (num < 1) {\n RExC_parse++;\n vFAIL(\"Reference to nonexistent group\");\n }\n } else if ( paren == '+' ) {\n num = RExC_npar + num - 1;\n }\n /* We keep track how many GOSUB items we have produced.\n To start off the ARG2L() of the GOSUB holds its \"id\",\n which is used later in conjunction with RExC_recurse\n to calculate the offset we need to jump for the GOSUB,\n which it will store in the final representation.\n We have to defer the actual calculation until much later\n as the regop may move.\n */\n\n ret = reg2Lanode(pRExC_state, GOSUB, num, RExC_recurse_count);\n if (!SIZE_ONLY) {\n\t\t if (num > (I32)RExC_rx->nparens) {\n\t\t\tRExC_parse++;\n\t\t\tvFAIL(\"Reference to nonexistent group\");\n\t }\n\t RExC_recurse_count++;\n DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_\n \"%*s%*s Recurse #%\" UVuf \" to %\" IVdf \"\\n\",\n 22, \"| |\", (int)(depth * 2 + 1), \"\",\n (UV)ARG(ret), (IV)ARG2L(ret)));\n }\n RExC_seen |= REG_RECURSE_SEEN;\n\n Set_Node_Length(ret, 1 + regarglen[OP(ret)]); /* MJD */\n\t\tSet_Node_Offset(ret, parse_start); /* MJD */\n\n *flagp |= POSTPONED;\n assert(*RExC_parse == ')');\n nextchar(pRExC_state);\n return ret;\n\n /* NOTREACHED */\n\n\t case '?': /* (??...) */\n\t\tis_logical = 1;\n\t\tif (*RExC_parse != '{') {\n RExC_parse += SKIP_IF_CHAR(RExC_parse);\n /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */\n vFAIL2utf8f(\n \"Sequence (%\" UTF8f \"...) not recognized\",\n UTF8fARG(UTF, RExC_parse-seqstart, seqstart));\n\t\t NOT_REACHED; /*NOTREACHED*/\n\t\t}\n\t\t*flagp |= POSTPONED;\n\t\tparen = '{';\n RExC_parse++;\n\t\t/* FALLTHROUGH */\n\t case '{': /* (?{...}) */\n\t {\n\t\tU32 n = 0;\n\t\tstruct reg_code_block *cb;\n\n\t\tRExC_seen_zerolen++;\n\n\t\tif ( !pRExC_state->code_blocks\n\t\t || pRExC_state->code_index\n >= pRExC_state->code_blocks->count\n\t\t || pRExC_state->code_blocks->cb[pRExC_state->code_index].start\n\t\t\t!= (STRLEN)((RExC_parse -3 - (is_logical ? 1 : 0))\n\t\t\t - RExC_start)\n\t\t) {\n\t\t if (RExC_pm_flags & PMf_USE_RE_EVAL)\n\t\t\tFAIL(\"panic: Sequence (?{...}): no code block found\\n\");\n\t\t FAIL(\"Eval-group not allowed at runtime, use re 'eval'\");\n\t\t}\n\t\t/* this is a pre-compiled code block (?{...}) */\n\t\tcb = &pRExC_state->code_blocks->cb[pRExC_state->code_index];\n\t\tRExC_parse = RExC_start + cb->end;\n\t\tif (!SIZE_ONLY) {\n\t\t OP *o = cb->block;\n\t\t if (cb->src_regex) {\n\t\t\tn = add_data(pRExC_state, STR_WITH_LEN(\"rl\"));\n\t\t\tRExC_rxi->data->data[n] =\n\t\t\t (void*)SvREFCNT_inc((SV*)cb->src_regex);\n\t\t\tRExC_rxi->data->data[n+1] = (void*)o;\n\t\t }\n\t\t else {\n\t\t\tn = add_data(pRExC_state,\n\t\t\t (RExC_pm_flags & PMf_HAS_CV) ? \"L\" : \"l\", 1);\n\t\t\tRExC_rxi->data->data[n] = (void*)o;\n\t\t }\n\t\t}\n\t\tpRExC_state->code_index++;\n\t\tnextchar(pRExC_state);\n\n\t\tif (is_logical) {\n regnode *eval;\n\t\t ret = reg_node(pRExC_state, LOGICAL);\n\n eval = reg2Lanode(pRExC_state, EVAL,\n n,\n\n /* for later propagation into (??{})\n * return value */\n RExC_flags & RXf_PMf_COMPILETIME\n );\n\t\t if (!SIZE_ONLY) {\n\t\t\tret->flags = 2;\n }\n REGTAIL(pRExC_state, ret, eval);\n /* deal with the length of this later - MJD */\n\t\t return ret;\n\t\t}\n\t\tret = reg2Lanode(pRExC_state, EVAL, n, 0);\n\t\tSet_Node_Length(ret, RExC_parse - parse_start + 1);\n\t\tSet_Node_Offset(ret, parse_start);\n\t\treturn ret;\n\t }\n\t case '(': /* (?(?{...})...) and (?(?=...)...) */\n\t {\n\t int is_define= 0;\n const int DEFINE_len = sizeof(\"DEFINE\") - 1;\n\t\tif (RExC_parse[0] == '?') { /* (?(?...)) */\n if ( RExC_parse < RExC_end - 1\n && ( RExC_parse[1] == '='\n || RExC_parse[1] == '!'\n || RExC_parse[1] == '<'\n || RExC_parse[1] == '{')\n ) { /* Lookahead or eval. */\n\t\t\tI32 flag;\n regnode *tail;\n\n\t\t\tret = reg_node(pRExC_state, LOGICAL);\n\t\t\tif (!SIZE_ONLY)\n\t\t\t ret->flags = 1;\n\n tail = reg(pRExC_state, 1, &flag, depth+1);\n if (flag & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flag & (RESTART_PASS1|NEED_UTF8);\n return NULL;\n }\n REGTAIL(pRExC_state, ret, tail);\n\t\t\tgoto insert_if;\n\t\t }\n\t\t /* Fall through to ‘Unknown switch condition’ at the\n\t\t end of the if/else chain. */\n\t\t}\n\t\telse if ( RExC_parse[0] == '<' /* (?(<NAME>)...) */\n\t\t || RExC_parse[0] == '\\'' ) /* (?('NAME')...) */\n\t {\n\t char ch = RExC_parse[0] == '<' ? '>' : '\\'';\n\t char *name_start= RExC_parse++;\n\t U32 num = 0;\n\t SV *sv_dat=reg_scan_name(pRExC_state,\n\t SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);\n\t if ( RExC_parse == name_start\n || RExC_parse >= RExC_end\n || *RExC_parse != ch)\n {\n vFAIL2(\"Sequence (?(%c... not terminated\",\n (ch == '>' ? '<' : ch));\n }\n RExC_parse++;\n\t if (!SIZE_ONLY) {\n num = add_data( pRExC_state, STR_WITH_LEN(\"S\"));\n RExC_rxi->data->data[num]=(void*)sv_dat;\n SvREFCNT_inc_simple_void(sv_dat);\n }\n ret = reganode(pRExC_state,NGROUPP,num);\n goto insert_if_check_paren;\n\t\t}\n\t\telse if (memBEGINs(RExC_parse,\n (STRLEN) (RExC_end - RExC_parse),\n \"DEFINE\"))\n {\n\t\t ret = reganode(pRExC_state,DEFINEP,0);\n\t\t RExC_parse += DEFINE_len;\n\t\t is_define = 1;\n\t\t goto insert_if_check_paren;\n\t\t}\n\t\telse if (RExC_parse[0] == 'R') {\n\t\t RExC_parse++;\n /* parno == 0 => /(?(R)YES|NO)/ \"in any form of recursion OR eval\"\n * parno == 1 => /(?(R0)YES|NO)/ \"in GOSUB (?0) / (?R)\"\n * parno == 2 => /(?(R1)YES|NO)/ \"in GOSUB (?1) (parno-1)\"\n */\n\t\t parno = 0;\n if (RExC_parse[0] == '0') {\n parno = 1;\n RExC_parse++;\n }\n else if (RExC_parse[0] >= '1' && RExC_parse[0] <= '9' ) {\n UV uv;\n if (grok_atoUV(RExC_parse, &uv, &endptr)\n && uv <= I32_MAX\n ) {\n parno = (I32)uv + 1;\n RExC_parse = (char*)endptr;\n }\n /* else \"Switch condition not recognized\" below */\n\t\t } else if (RExC_parse[0] == '&') {\n\t\t SV *sv_dat;\n\t\t RExC_parse++;\n\t\t sv_dat = reg_scan_name(pRExC_state,\n SIZE_ONLY\n ? REG_RSN_RETURN_NULL\n : REG_RSN_RETURN_DATA);\n\n /* we should only have a false sv_dat when\n * SIZE_ONLY is true, and we always have false\n * sv_dat when SIZE_ONLY is true.\n * reg_scan_name() will VFAIL() if the name is\n * unknown when SIZE_ONLY is false, and otherwise\n * will return something, and when SIZE_ONLY is\n * true, reg_scan_name() just parses the string,\n * and doesnt return anything. (in theory) */\n assert(SIZE_ONLY ? !sv_dat : !!sv_dat);\n\n if (sv_dat)\n parno = 1 + *((I32 *)SvPVX(sv_dat));\n\t\t }\n\t\t ret = reganode(pRExC_state,INSUBP,parno);\n\t\t goto insert_if_check_paren;\n\t\t}\n\t\telse if (RExC_parse[0] >= '1' && RExC_parse[0] <= '9' ) {\n /* (?(1)...) */\n\t\t char c;\n UV uv;\n if (grok_atoUV(RExC_parse, &uv, &endptr)\n && uv <= I32_MAX\n ) {\n parno = (I32)uv;\n RExC_parse = (char*)endptr;\n }\n else {\n vFAIL(\"panic: grok_atoUV returned FALSE\");\n }\n ret = reganode(pRExC_state, GROUPP, parno);\n\n insert_if_check_paren:\n\t\t if (UCHARAT(RExC_parse) != ')') {\n RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n\t\t\tvFAIL(\"Switch condition not recognized\");\n\t\t }\n\t\t nextchar(pRExC_state);\n\t\t insert_if:\n REGTAIL(pRExC_state, ret, reganode(pRExC_state, IFTHEN, 0));\n br = regbranch(pRExC_state, &flags, 1,depth+1);\n\t\t if (br == NULL) {\n if (flags & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flags & (RESTART_PASS1|NEED_UTF8);\n return NULL;\n }\n FAIL2(\"panic: regbranch returned NULL, flags=%#\" UVxf,\n (UV) flags);\n } else\n REGTAIL(pRExC_state, br, reganode(pRExC_state,\n LONGJMP, 0));\n\t\t c = UCHARAT(RExC_parse);\n nextchar(pRExC_state);\n\t\t if (flags&HASWIDTH)\n\t\t\t*flagp |= HASWIDTH;\n\t\t if (c == '|') {\n\t\t if (is_define)\n\t\t vFAIL(\"(?(DEFINE)....) does not allow branches\");\n\n /* Fake one for optimizer. */\n lastbr = reganode(pRExC_state, IFTHEN, 0);\n\n if (!regbranch(pRExC_state, &flags, 1,depth+1)) {\n if (flags & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flags & (RESTART_PASS1|NEED_UTF8);\n return NULL;\n }\n FAIL2(\"panic: regbranch returned NULL, flags=%#\" UVxf,\n (UV) flags);\n }\n REGTAIL(pRExC_state, ret, lastbr);\n\t\t \tif (flags&HASWIDTH)\n\t\t\t *flagp |= HASWIDTH;\n c = UCHARAT(RExC_parse);\n nextchar(pRExC_state);\n\t\t }\n\t\t else\n\t\t\tlastbr = NULL;\n if (c != ')') {\n if (RExC_parse >= RExC_end)\n vFAIL(\"Switch (?(condition)... not terminated\");\n else\n vFAIL(\"Switch (?(condition)... contains too many branches\");\n }\n\t\t ender = reg_node(pRExC_state, TAIL);\n REGTAIL(pRExC_state, br, ender);\n\t\t if (lastbr) {\n REGTAIL(pRExC_state, lastbr, ender);\n REGTAIL(pRExC_state, NEXTOPER(NEXTOPER(lastbr)), ender);\n\t\t }\n\t\t else\n REGTAIL(pRExC_state, ret, ender);\n RExC_size++; /* XXX WHY do we need this?!!\n For large programs it seems to be required\n but I can't figure out why. -- dmq*/\n\t\t return ret;\n\t\t}\n RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n vFAIL(\"Unknown switch condition (?(...))\");\n\t }\n\t case '[': /* (?[ ... ]) */\n return handle_regex_sets(pRExC_state, NULL, flagp, depth+1,\n oregcomp_parse);\n case 0: /* A NUL */\n\t\tRExC_parse--; /* for vFAIL to print correctly */\n vFAIL(\"Sequence (? incomplete\");\n break;\n\t default: /* e.g., (?i) */\n\t RExC_parse = (char *) seqstart + 1;\n parse_flags:\n\t\tparse_lparen_question_flags(pRExC_state);\n if (UCHARAT(RExC_parse) != ':') {\n if (RExC_parse < RExC_end)\n nextchar(pRExC_state);\n *flagp = TRYAGAIN;\n return NULL;\n }\n paren = ':';\n nextchar(pRExC_state);\n ret = NULL;\n goto parse_rest;\n } /* end switch */\n\t}\n\telse if (!(RExC_flags & RXf_PMf_NOCAPTURE)) { /* (...) */\n\t capturing_parens:\n\t parno = RExC_npar;\n\t RExC_npar++;\n\n\t ret = reganode(pRExC_state, OPEN, parno);\n\t if (!SIZE_ONLY ){\n\t if (!RExC_nestroot)\n\t RExC_nestroot = parno;\n if (RExC_open_parens && !RExC_open_parens[parno])\n\t {\n DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_\n \"%*s%*s Setting open paren #%\" IVdf \" to %d\\n\",\n 22, \"| |\", (int)(depth * 2 + 1), \"\",\n\t\t\t(IV)parno, REG_NODE_NUM(ret)));\n RExC_open_parens[parno]= ret;\n\t }\n\t }\n Set_Node_Length(ret, 1); /* MJD */\n Set_Node_Offset(ret, RExC_parse); /* MJD */\n\t is_open = 1;\n\t} else {\n /* with RXf_PMf_NOCAPTURE treat (...) as (?:...) */\n paren = ':';\n\t ret = NULL;\n\t}\n }\n else /* ! paren */\n\tret = NULL;\n\n parse_rest:\n /* Pick up the branches, linking them together. */\n parse_start = RExC_parse; /* MJD */\n br = regbranch(pRExC_state, &flags, 1,depth+1);\n\n /* branch_len = (paren != 0); */\n\n if (br == NULL) {\n if (flags & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flags & (RESTART_PASS1|NEED_UTF8);\n return NULL;\n }\n FAIL2(\"panic: regbranch returned NULL, flags=%#\" UVxf, (UV) flags);\n }\n if (*RExC_parse == '|') {\n\tif (!SIZE_ONLY && RExC_extralen) {\n\t reginsert(pRExC_state, BRANCHJ, br, depth+1);\n\t}\n\telse { /* MJD */\n\t reginsert(pRExC_state, BRANCH, br, depth+1);\n Set_Node_Length(br, paren != 0);\n Set_Node_Offset_To_R(br-RExC_emit_start, parse_start-RExC_start);\n }\n\thave_branch = 1;\n\tif (SIZE_ONLY)\n\t RExC_extralen += 1;\t\t/* For BRANCHJ-BRANCH. */\n }\n else if (paren == ':') {\n\t*flagp |= flags&SIMPLE;\n }\n if (is_open) {\t\t\t\t/* Starts with OPEN. */\n REGTAIL(pRExC_state, ret, br); /* OPEN -> first. */\n }\n else if (paren != '?')\t\t/* Not Conditional */\n\tret = br;\n *flagp |= flags & (SPSTART | HASWIDTH | POSTPONED);\n lastbr = br;\n while (*RExC_parse == '|') {\n\tif (!SIZE_ONLY && RExC_extralen) {\n\t ender = reganode(pRExC_state, LONGJMP,0);\n\n /* Append to the previous. */\n REGTAIL(pRExC_state, NEXTOPER(NEXTOPER(lastbr)), ender);\n\t}\n\tif (SIZE_ONLY)\n\t RExC_extralen += 2;\t\t/* Account for LONGJMP. */\n\tnextchar(pRExC_state);\n\tif (freeze_paren) {\n\t if (RExC_npar > after_freeze)\n\t after_freeze = RExC_npar;\n RExC_npar = freeze_paren;\n }\n br = regbranch(pRExC_state, &flags, 0, depth+1);\n\n\tif (br == NULL) {\n if (flags & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flags & (RESTART_PASS1|NEED_UTF8);\n return NULL;\n }\n FAIL2(\"panic: regbranch returned NULL, flags=%#\" UVxf, (UV) flags);\n }\n REGTAIL(pRExC_state, lastbr, br); /* BRANCH -> BRANCH. */\n\tlastbr = br;\n\t*flagp |= flags & (SPSTART | HASWIDTH | POSTPONED);\n }\n\n if (have_branch || paren != ':') {\n\t/* Make a closing node, and hook it on the end. */\n\tswitch (paren) {\n\tcase ':':\n\t ender = reg_node(pRExC_state, TAIL);\n\t break;\n\tcase 1: case 2:\n\t ender = reganode(pRExC_state, CLOSE, parno);\n if ( RExC_close_parens ) {\n DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_\n \"%*s%*s Setting close paren #%\" IVdf \" to %d\\n\",\n 22, \"| |\", (int)(depth * 2 + 1), \"\", (IV)parno, REG_NODE_NUM(ender)));\n RExC_close_parens[parno]= ender;\n\t if (RExC_nestroot == parno)\n\t RExC_nestroot = 0;\n\t }\n Set_Node_Offset(ender,RExC_parse+1); /* MJD */\n Set_Node_Length(ender,1); /* MJD */\n\t break;\n\tcase '<':\n\tcase ',':\n\tcase '=':\n\tcase '!':\n\t *flagp &= ~HASWIDTH;\n\t /* FALLTHROUGH */\n\tcase '>':\n\t ender = reg_node(pRExC_state, SUCCEED);\n\t break;\n\tcase 0:\n\t ender = reg_node(pRExC_state, END);\n\t if (!SIZE_ONLY) {\n assert(!RExC_end_op); /* there can only be one! */\n RExC_end_op = ender;\n if (RExC_close_parens) {\n DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_\n \"%*s%*s Setting close paren #0 (END) to %d\\n\",\n 22, \"| |\", (int)(depth * 2 + 1), \"\", REG_NODE_NUM(ender)));\n\n RExC_close_parens[0]= ender;\n }\n }\n\t break;\n\t}\n DEBUG_PARSE_r(if (!SIZE_ONLY) {\n DEBUG_PARSE_MSG(\"lsbr\");\n regprop(RExC_rx, RExC_mysv1, lastbr, NULL, pRExC_state);\n regprop(RExC_rx, RExC_mysv2, ender, NULL, pRExC_state);\n Perl_re_printf( aTHX_ \"~ tying lastbr %s (%\" IVdf \") to ender %s (%\" IVdf \") offset %\" IVdf \"\\n\",\n SvPV_nolen_const(RExC_mysv1),\n (IV)REG_NODE_NUM(lastbr),\n SvPV_nolen_const(RExC_mysv2),\n (IV)REG_NODE_NUM(ender),\n (IV)(ender - lastbr)\n );\n });\n REGTAIL(pRExC_state, lastbr, ender);\n\n\tif (have_branch && !SIZE_ONLY) {\n char is_nothing= 1;\n\t if (depth==1)\n RExC_seen |= REG_TOP_LEVEL_BRANCHES_SEEN;\n\n\t /* Hook the tails of the branches to the closing node. */\n\t for (br = ret; br; br = regnext(br)) {\n\t\tconst U8 op = PL_regkind[OP(br)];\n\t\tif (op == BRANCH) {\n REGTAIL_STUDY(pRExC_state, NEXTOPER(br), ender);\n if ( OP(NEXTOPER(br)) != NOTHING\n || regnext(NEXTOPER(br)) != ender)\n is_nothing= 0;\n\t\t}\n\t\telse if (op == BRANCHJ) {\n REGTAIL_STUDY(pRExC_state, NEXTOPER(NEXTOPER(br)), ender);\n /* for now we always disable this optimisation * /\n if ( OP(NEXTOPER(NEXTOPER(br))) != NOTHING\n || regnext(NEXTOPER(NEXTOPER(br))) != ender)\n */\n is_nothing= 0;\n\t\t}\n\t }\n if (is_nothing) {\n br= PL_regkind[OP(ret)] != BRANCH ? regnext(ret) : ret;\n DEBUG_PARSE_r(if (!SIZE_ONLY) {\n DEBUG_PARSE_MSG(\"NADA\");\n regprop(RExC_rx, RExC_mysv1, ret, NULL, pRExC_state);\n regprop(RExC_rx, RExC_mysv2, ender, NULL, pRExC_state);\n Perl_re_printf( aTHX_ \"~ converting ret %s (%\" IVdf \") to ender %s (%\" IVdf \") offset %\" IVdf \"\\n\",\n SvPV_nolen_const(RExC_mysv1),\n (IV)REG_NODE_NUM(ret),\n SvPV_nolen_const(RExC_mysv2),\n (IV)REG_NODE_NUM(ender),\n (IV)(ender - ret)\n );\n });\n OP(br)= NOTHING;\n if (OP(ender) == TAIL) {\n NEXT_OFF(br)= 0;\n RExC_emit= br + 1;\n } else {\n regnode *opt;\n for ( opt= br + 1; opt < ender ; opt++ )\n OP(opt)= OPTIMIZED;\n NEXT_OFF(br)= ender - br;\n }\n }\n\t}\n }\n\n {\n const char *p;\n static const char parens[] = \"=!<,>\";\n\n\tif (paren && (p = strchr(parens, paren))) {\n\t U8 node = ((p - parens) % 2) ? UNLESSM : IFMATCH;\n\t int flag = (p - parens) > 1;\n\n\t if (paren == '>')\n\t\tnode = SUSPEND, flag = 0;\n\t reginsert(pRExC_state, node,ret, depth+1);\n Set_Node_Cur_Length(ret, parse_start);\n\t Set_Node_Offset(ret, parse_start + 1);\n\t ret->flags = flag;\n REGTAIL_STUDY(pRExC_state, ret, reg_node(pRExC_state, TAIL));\n\t}\n }\n\n /* Check for proper termination. */\n if (paren) {\n /* restore original flags, but keep (?p) and, if we've changed from /d\n * rules to /u, keep the /u */\n\tRExC_flags = oregflags | (RExC_flags & RXf_PMf_KEEPCOPY);\n if (DEPENDS_SEMANTICS && RExC_uni_semantics) {\n set_regex_charset(&RExC_flags, REGEX_UNICODE_CHARSET);\n }\n\tif (RExC_parse >= RExC_end || UCHARAT(RExC_parse) != ')') {\n\t RExC_parse = oregcomp_parse;\n\t vFAIL(\"Unmatched (\");\n\t}\n\tnextchar(pRExC_state);\n }\n else if (!paren && RExC_parse < RExC_end) {\n\tif (*RExC_parse == ')') {\n\t RExC_parse++;\n\t vFAIL(\"Unmatched )\");\n\t}\n\telse\n\t FAIL(\"Junk on end of regexp\");\t/* \"Can't happen\". */\n\tNOT_REACHED; /* NOTREACHED */\n }\n\n if (RExC_in_lookbehind) {\n\tRExC_in_lookbehind--;\n }\n if (after_freeze > RExC_npar)\n RExC_npar = after_freeze;\n return(ret);\n}\n\n/*\n - regbranch - one alternative of an | operator\n *\n * Implements the concatenation operator.\n *\n * Returns NULL, setting *flagp to RESTART_PASS1 if the sizing scan needs to be\n * restarted, or'd with NEED_UTF8 if the pattern needs to be upgraded to UTF-8\n */\nSTATIC regnode *\nS_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)\n{\n regnode *ret;\n regnode *chain = NULL;\n regnode *latest;\n I32 flags = 0, c = 0;\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGBRANCH;\n\n DEBUG_PARSE(\"brnc\");\n\n if (first)\n\tret = NULL;\n else {\n\tif (!SIZE_ONLY && RExC_extralen)\n\t ret = reganode(pRExC_state, BRANCHJ,0);\n\telse {\n\t ret = reg_node(pRExC_state, BRANCH);\n Set_Node_Length(ret, 1);\n }\n }\n\n if (!first && SIZE_ONLY)\n\tRExC_extralen += 1;\t\t\t/* BRANCHJ */\n\n *flagp = WORST;\t\t\t/* Tentatively. */\n\n skip_to_be_ignored_text(pRExC_state, &RExC_parse,\n FALSE /* Don't force to /x */ );\n while (RExC_parse < RExC_end && *RExC_parse != '|' && *RExC_parse != ')') {\n\tflags &= ~TRYAGAIN;\n latest = regpiece(pRExC_state, &flags,depth+1);\n\tif (latest == NULL) {\n\t if (flags & TRYAGAIN)\n\t\tcontinue;\n if (flags & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flags & (RESTART_PASS1|NEED_UTF8);\n return NULL;\n }\n FAIL2(\"panic: regpiece returned NULL, flags=%#\" UVxf, (UV) flags);\n\t}\n\telse if (ret == NULL)\n ret = latest;\n\t*flagp |= flags&(HASWIDTH|POSTPONED);\n\tif (chain == NULL) \t/* First piece. */\n\t *flagp |= flags&SPSTART;\n\telse {\n\t /* FIXME adding one for every branch after the first is probably\n\t * excessive now we have TRIE support. (hv) */\n\t MARK_NAUGHTY(1);\n REGTAIL(pRExC_state, chain, latest);\n\t}\n\tchain = latest;\n\tc++;\n }\n if (chain == NULL) {\t/* Loop ran zero times. */\n\tchain = reg_node(pRExC_state, NOTHING);\n\tif (ret == NULL)\n\t ret = chain;\n }\n if (c == 1) {\n\t*flagp |= flags&SIMPLE;\n }\n\n return ret;\n}\n\n/*\n - regpiece - something followed by possible quantifier * + ? {n,m}\n *\n * Note that the branching code sequences used for ? and the general cases\n * of * and + are somewhat optimized: they use the same NOTHING node as\n * both the endmarker for their branch list and the body of the last branch.\n * It might seem that this node could be dispensed with entirely, but the\n * endmarker role is not redundant.\n *\n * Returns NULL, setting *flagp to TRYAGAIN if regatom() returns NULL with\n * TRYAGAIN.\n * Returns NULL, setting *flagp to RESTART_PASS1 if the sizing scan needs to be\n * restarted, or'd with NEED_UTF8 if the pattern needs to be upgraded to UTF-8\n */\nSTATIC regnode *\nS_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)\n{\n regnode *ret;\n char op;\n char *next;\n I32 flags;\n const char * const origparse = RExC_parse;\n I32 min;\n I32 max = REG_INFTY;\n#ifdef RE_TRACK_PATTERN_OFFSETS\n char *parse_start;\n#endif\n const char *maxpos = NULL;\n UV uv;\n\n /* Save the original in case we change the emitted regop to a FAIL. */\n regnode * const orig_emit = RExC_emit;\n\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGPIECE;\n\n DEBUG_PARSE(\"piec\");\n\n ret = regatom(pRExC_state, &flags,depth+1);\n if (ret == NULL) {\n\tif (flags & (TRYAGAIN|RESTART_PASS1|NEED_UTF8))\n\t *flagp |= flags & (TRYAGAIN|RESTART_PASS1|NEED_UTF8);\n else\n FAIL2(\"panic: regatom returned NULL, flags=%#\" UVxf, (UV) flags);\n\treturn(NULL);\n }\n\n op = *RExC_parse;\n\n if (op == '{' && regcurly(RExC_parse)) {\n\tmaxpos = NULL;\n#ifdef RE_TRACK_PATTERN_OFFSETS\n parse_start = RExC_parse; /* MJD */\n#endif\n\tnext = RExC_parse + 1;\n\twhile (isDIGIT(*next) || *next == ',') {\n\t if (*next == ',') {\n\t\tif (maxpos)\n\t\t break;\n\t\telse\n\t\t maxpos = next;\n\t }\n\t next++;\n\t}\n\tif (*next == '}') {\t\t/* got one */\n const char* endptr;\n\t if (!maxpos)\n\t\tmaxpos = next;\n\t RExC_parse++;\n if (isDIGIT(*RExC_parse)) {\n if (!grok_atoUV(RExC_parse, &uv, &endptr))\n vFAIL(\"Invalid quantifier in {,}\");\n if (uv >= REG_INFTY)\n vFAIL2(\"Quantifier in {,} bigger than %d\", REG_INFTY - 1);\n min = (I32)uv;\n } else {\n min = 0;\n }\n\t if (*maxpos == ',')\n\t\tmaxpos++;\n\t else\n\t\tmaxpos = RExC_parse;\n if (isDIGIT(*maxpos)) {\n if (!grok_atoUV(maxpos, &uv, &endptr))\n vFAIL(\"Invalid quantifier in {,}\");\n if (uv >= REG_INFTY)\n vFAIL2(\"Quantifier in {,} bigger than %d\", REG_INFTY - 1);\n max = (I32)uv;\n } else {\n\t\tmax = REG_INFTY;\t\t/* meaning \"infinity\" */\n }\n\t RExC_parse = next;\n\t nextchar(pRExC_state);\n if (max < min) { /* If can't match, warn and optimize to fail\n unconditionally */\n reginsert(pRExC_state, OPFAIL, orig_emit, depth+1);\n if (PASS2) {\n ckWARNreg(RExC_parse, \"Quantifier {n,m} with n > m can't match\");\n NEXT_OFF(orig_emit)= regarglen[OPFAIL] + NODE_STEP_REGNODE;\n }\n return ret;\n }\n else if (min == max && *RExC_parse == '?')\n {\n if (PASS2) {\n ckWARN2reg(RExC_parse + 1,\n \"Useless use of greediness modifier '%c'\",\n *RExC_parse);\n }\n }\n\n\t do_curly:\n\t if ((flags&SIMPLE)) {\n if (min == 0 && max == REG_INFTY) {\n reginsert(pRExC_state, STAR, ret, depth+1);\n MARK_NAUGHTY(4);\n RExC_seen |= REG_UNBOUNDED_QUANTIFIER_SEEN;\n goto nest_check;\n }\n if (min == 1 && max == REG_INFTY) {\n reginsert(pRExC_state, PLUS, ret, depth+1);\n MARK_NAUGHTY(3);\n RExC_seen |= REG_UNBOUNDED_QUANTIFIER_SEEN;\n goto nest_check;\n }\n MARK_NAUGHTY_EXP(2, 2);\n\t\treginsert(pRExC_state, CURLY, ret, depth+1);\n Set_Node_Offset(ret, parse_start+1); /* MJD */\n Set_Node_Cur_Length(ret, parse_start);\n\t }\n\t else {\n\t\tregnode * const w = reg_node(pRExC_state, WHILEM);\n\n\t\tw->flags = 0;\n REGTAIL(pRExC_state, ret, w);\n\t\tif (!SIZE_ONLY && RExC_extralen) {\n\t\t reginsert(pRExC_state, LONGJMP,ret, depth+1);\n\t\t reginsert(pRExC_state, NOTHING,ret, depth+1);\n\t\t NEXT_OFF(ret) = 3;\t/* Go over LONGJMP. */\n\t\t}\n\t\treginsert(pRExC_state, CURLYX,ret, depth+1);\n /* MJD hk */\n Set_Node_Offset(ret, parse_start+1);\n Set_Node_Length(ret,\n op == '{' ? (RExC_parse - parse_start) : 1);\n\n\t\tif (!SIZE_ONLY && RExC_extralen)\n\t\t NEXT_OFF(ret) = 3;\t/* Go over NOTHING to LONGJMP. */\n REGTAIL(pRExC_state, ret, reg_node(pRExC_state, NOTHING));\n\t\tif (SIZE_ONLY)\n\t\t RExC_whilem_seen++, RExC_extralen += 3;\n MARK_NAUGHTY_EXP(1, 4); /* compound interest */\n\t }\n\t ret->flags = 0;\n\n\t if (min > 0)\n\t\t*flagp = WORST;\n\t if (max > 0)\n\t\t*flagp |= HASWIDTH;\n\t if (!SIZE_ONLY) {\n\t\tARG1_SET(ret, (U16)min);\n\t\tARG2_SET(ret, (U16)max);\n\t }\n if (max == REG_INFTY)\n RExC_seen |= REG_UNBOUNDED_QUANTIFIER_SEEN;\n\n\t goto nest_check;\n\t}\n }\n\n if (!ISMULT1(op)) {\n\t*flagp = flags;\n\treturn(ret);\n }\n\n#if 0\t\t\t\t/* Now runtime fix should be reliable. */\n\n /* if this is reinstated, don't forget to put this back into perldiag:\n\n\t =item Regexp *+ operand could be empty at {#} in regex m/%s/\n\n\t (F) The part of the regexp subject to either the * or + quantifier\n could match an empty string. The {#} shows in the regular\n expression about where the problem was discovered.\n\n */\n\n if (!(flags&HASWIDTH) && op != '?')\n vFAIL(\"Regexp *+ operand could be empty\");\n#endif\n\n#ifdef RE_TRACK_PATTERN_OFFSETS\n parse_start = RExC_parse;\n#endif\n nextchar(pRExC_state);\n\n *flagp = (op != '+') ? (WORST|SPSTART|HASWIDTH) : (WORST|HASWIDTH);\n\n if (op == '*') {\n\tmin = 0;\n\tgoto do_curly;\n }\n else if (op == '+') {\n\tmin = 1;\n\tgoto do_curly;\n }\n else if (op == '?') {\n\tmin = 0; max = 1;\n\tgoto do_curly;\n }\n nest_check:\n if (!SIZE_ONLY && !(flags&(HASWIDTH|POSTPONED)) && max > REG_INFTY/3) {\n\tSAVEFREESV(RExC_rx_sv); /* in case of fatal warnings */\n\tckWARN2reg(RExC_parse,\n\t\t \"%\" UTF8f \" matches null string many times\",\n\t\t UTF8fARG(UTF, (RExC_parse >= origparse\n ? RExC_parse - origparse\n : 0),\n\t\t origparse));\n\t(void)ReREFCNT_inc(RExC_rx_sv);\n }\n\n if (*RExC_parse == '?') {\n\tnextchar(pRExC_state);\n\treginsert(pRExC_state, MINMOD, ret, depth+1);\n REGTAIL(pRExC_state, ret, ret + NODE_STEP_REGNODE);\n }\n else if (*RExC_parse == '+') {\n regnode *ender;\n nextchar(pRExC_state);\n ender = reg_node(pRExC_state, SUCCEED);\n REGTAIL(pRExC_state, ret, ender);\n reginsert(pRExC_state, SUSPEND, ret, depth+1);\n ender = reg_node(pRExC_state, TAIL);\n REGTAIL(pRExC_state, ret, ender);\n }\n\n if (ISMULT2(RExC_parse)) {\n\tRExC_parse++;\n\tvFAIL(\"Nested quantifiers\");\n }\n\n return(ret);\n}\n\nSTATIC bool\nS_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state,\n regnode ** node_p,\n UV * code_point_p,\n int * cp_count,\n I32 * flagp,\n const bool strict,\n const U32 depth\n )\n{\n /* This routine teases apart the various meanings of \\N and returns\n * accordingly. The input parameters constrain which meaning(s) is/are valid\n * in the current context.\n *\n * Exactly one of <node_p> and <code_point_p> must be non-NULL.\n *\n * If <code_point_p> is not NULL, the context is expecting the result to be a\n * single code point. If this \\N instance turns out to a single code point,\n * the function returns TRUE and sets *code_point_p to that code point.\n *\n * If <node_p> is not NULL, the context is expecting the result to be one of\n * the things representable by a regnode. If this \\N instance turns out to be\n * one such, the function generates the regnode, returns TRUE and sets *node_p\n * to point to that regnode.\n *\n * If this instance of \\N isn't legal in any context, this function will\n * generate a fatal error and not return.\n *\n * On input, RExC_parse should point to the first char following the \\N at the\n * time of the call. On successful return, RExC_parse will have been updated\n * to point to just after the sequence identified by this routine. Also\n * *flagp has been updated as needed.\n *\n * When there is some problem with the current context and this \\N instance,\n * the function returns FALSE, without advancing RExC_parse, nor setting\n * *node_p, nor *code_point_p, nor *flagp.\n *\n * If <cp_count> is not NULL, the caller wants to know the length (in code\n * points) that this \\N sequence matches. This is set even if the function\n * returns FALSE, as detailed below.\n *\n * There are 5 possibilities here, as detailed in the next 5 paragraphs.\n *\n * Probably the most common case is for the \\N to specify a single code point.\n * *cp_count will be set to 1, and *code_point_p will be set to that code\n * point.\n *\n * Another possibility is for the input to be an empty \\N{}, which for\n * backwards compatibility we accept. *cp_count will be set to 0. *node_p\n * will be set to a generated NOTHING node.\n *\n * Still another possibility is for the \\N to mean [^\\n]. *cp_count will be\n * set to 0. *node_p will be set to a generated REG_ANY node.\n *\n * The fourth possibility is that \\N resolves to a sequence of more than one\n * code points. *cp_count will be set to the number of code points in the\n * sequence. *node_p * will be set to a generated node returned by this\n * function calling S_reg().\n *\n * The final possibility is that it is premature to be calling this function;\n * that pass1 needs to be restarted. This can happen when this changes from\n * /d to /u rules, or when the pattern needs to be upgraded to UTF-8. The\n * latter occurs only when the fourth possibility would otherwise be in\n * effect, and is because one of those code points requires the pattern to be\n * recompiled as UTF-8. The function returns FALSE, and sets the\n * RESTART_PASS1 and NEED_UTF8 flags in *flagp, as appropriate. When this\n * happens, the caller needs to desist from continuing parsing, and return\n * this information to its caller. This is not set for when there is only one\n * code point, as this can be called as part of an ANYOF node, and they can\n * store above-Latin1 code points without the pattern having to be in UTF-8.\n *\n * For non-single-quoted regexes, the tokenizer has resolved character and\n * sequence names inside \\N{...} into their Unicode values, normalizing the\n * result into what we should see here: '\\N{U+c1.c2...}', where c1... are the\n * hex-represented code points in the sequence. This is done there because\n * the names can vary based on what charnames pragma is in scope at the time,\n * so we need a way to take a snapshot of what they resolve to at the time of\n * the original parse. [perl #56444].\n *\n * That parsing is skipped for single-quoted regexes, so we may here get\n * '\\N{NAME}'. This is a fatal error. These names have to be resolved by the\n * parser. But if the single-quoted regex is something like '\\N{U+41}', that\n * is legal and handled here. The code point is Unicode, and has to be\n * translated into the native character set for non-ASCII platforms.\n */\n\n char * endbrace; /* points to '}' following the name */\n char *endchar;\t/* Points to '.' or '}' ending cur char in the input\n stream */\n char* p = RExC_parse; /* Temporary */\n\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_GROK_BSLASH_N;\n\n GET_RE_DEBUG_FLAGS;\n\n assert(cBOOL(node_p) ^ cBOOL(code_point_p)); /* Exactly one should be set */\n assert(! (node_p && cp_count)); /* At most 1 should be set */\n\n if (cp_count) { /* Initialize return for the most common case */\n *cp_count = 1;\n }\n\n /* The [^\\n] meaning of \\N ignores spaces and comments under the /x\n * modifier. The other meanings do not, so use a temporary until we find\n * out which we are being called with */\n skip_to_be_ignored_text(pRExC_state, &p,\n FALSE /* Don't force to /x */ );\n\n /* Disambiguate between \\N meaning a named character versus \\N meaning\n * [^\\n]. The latter is assumed when the {...} following the \\N is a legal\n * quantifier, or there is no '{' at all */\n if (*p != '{' || regcurly(p)) {\n\tRExC_parse = p;\n if (cp_count) {\n *cp_count = -1;\n }\n\n\tif (! node_p) {\n return FALSE;\n }\n\n\t*node_p = reg_node(pRExC_state, REG_ANY);\n\t*flagp |= HASWIDTH|SIMPLE;\n\tMARK_NAUGHTY(1);\n Set_Node_Length(*node_p, 1); /* MJD */\n\treturn TRUE;\n }\n\n /* Here, we have decided it should be a named character or sequence */\n\n /* The test above made sure that the next real character is a '{', but\n * under the /x modifier, it could be separated by space (or a comment and\n * \\n) and this is not allowed (for consistency with \\x{...} and the\n * tokenizer handling of \\N{NAME}). */\n if (*RExC_parse != '{') {\n\tvFAIL(\"Missing braces on \\\\N{}\");\n }\n\n RExC_parse++;\t/* Skip past the '{' */\n\n endbrace = (char *) memchr(RExC_parse, '}', RExC_end - RExC_parse);\n if (! endbrace) { /* no trailing brace */\n vFAIL2(\"Missing right brace on \\\\%c{}\", 'N');\n }\n else if (!( endbrace == RExC_parse\t/* nothing between the {} */\n || memBEGINs(RExC_parse, /* U+ (bad hex is checked below\n for a better error msg) */\n (STRLEN) (RExC_end - RExC_parse),\n \"U+\")))\n {\n\tRExC_parse = endbrace;\t/* position msg's '<--HERE' */\n\tvFAIL(\"\\\\N{NAME} must be resolved by the lexer\");\n }\n\n REQUIRE_UNI_RULES(flagp, FALSE); /* Unicode named chars imply Unicode\n semantics */\n\n if (endbrace == RExC_parse) { /* empty: \\N{} */\n if (strict) {\n RExC_parse++; /* Position after the \"}\" */\n vFAIL(\"Zero length \\\\N{}\");\n }\n if (cp_count) {\n *cp_count = 0;\n }\n nextchar(pRExC_state);\n\tif (! node_p) {\n return FALSE;\n }\n\n *node_p = reg_node(pRExC_state,NOTHING);\n return TRUE;\n }\n\n RExC_parse += 2;\t/* Skip past the 'U+' */\n\n /* Because toke.c has generated a special construct for us guaranteed not\n * to have NULs, we can use a str function */\n endchar = RExC_parse + strcspn(RExC_parse, \".}\");\n\n /* Code points are separated by dots. If none, there is only one code\n * point, and is terminated by the brace */\n\n if (endchar >= endbrace) {\n\tSTRLEN length_of_hex;\n\tI32 grok_hex_flags;\n\n /* Here, exactly one code point. If that isn't what is wanted, fail */\n if (! code_point_p) {\n RExC_parse = p;\n return FALSE;\n }\n\n /* Convert code point from hex */\n\tlength_of_hex = (STRLEN)(endchar - RExC_parse);\n\tgrok_hex_flags = PERL_SCAN_ALLOW_UNDERSCORES\n | PERL_SCAN_DISALLOW_PREFIX\n\n /* No errors in the first pass (See [perl\n * #122671].) We let the code below find the\n * errors when there are multiple chars. */\n | ((SIZE_ONLY)\n ? PERL_SCAN_SILENT_ILLDIGIT\n : 0);\n\n /* This routine is the one place where both single- and double-quotish\n * \\N{U+xxxx} are evaluated. The value is a Unicode code point which\n * must be converted to native. */\n\t*code_point_p = UNI_TO_NATIVE(grok_hex(RExC_parse,\n &length_of_hex,\n &grok_hex_flags,\n NULL));\n\n\t/* The tokenizer should have guaranteed validity, but it's possible to\n * bypass it by using single quoting, so check. Don't do the check\n * here when there are multiple chars; we do it below anyway. */\n if (length_of_hex == 0\n || length_of_hex != (STRLEN)(endchar - RExC_parse) )\n {\n RExC_parse += length_of_hex;\t/* Includes all the valid */\n RExC_parse += (RExC_orig_utf8)\t/* point to after 1st invalid */\n ? UTF8SKIP(RExC_parse)\n : 1;\n /* Guard against malformed utf8 */\n if (RExC_parse >= endchar) {\n RExC_parse = endchar;\n }\n vFAIL(\"Invalid hexadecimal number in \\\\N{U+...}\");\n }\n\n RExC_parse = endbrace + 1;\n return TRUE;\n }\n else { /* Is a multiple character sequence */\n\tSV * substitute_parse;\n\tSTRLEN len;\n\tchar *orig_end = RExC_end;\n\tchar *save_start = RExC_start;\n I32 flags;\n\n /* Count the code points, if desired, in the sequence */\n if (cp_count) {\n *cp_count = 0;\n while (RExC_parse < endbrace) {\n /* Point to the beginning of the next character in the sequence. */\n RExC_parse = endchar + 1;\n endchar = RExC_parse + strcspn(RExC_parse, \".}\");\n (*cp_count)++;\n }\n }\n\n /* Fail if caller doesn't want to handle a multi-code-point sequence.\n * But don't backup up the pointer if the caller wants to know how many\n * code points there are (they can then handle things) */\n if (! node_p) {\n if (! cp_count) {\n RExC_parse = p;\n }\n return FALSE;\n }\n\n\t/* What is done here is to convert this to a sub-pattern of the form\n * \\x{char1}\\x{char2}... and then call reg recursively to parse it\n * (enclosing in \"(?: ... )\" ). That way, it retains its atomicness,\n * while not having to worry about special handling that some code\n * points may have. */\n\n\tsubstitute_parse = newSVpvs(\"?:\");\n\n\twhile (RExC_parse < endbrace) {\n\n\t /* Convert to notation the rest of the code understands */\n\t sv_catpv(substitute_parse, \"\\\\x{\");\n\t sv_catpvn(substitute_parse, RExC_parse, endchar - RExC_parse);\n\t sv_catpv(substitute_parse, \"}\");\n\n\t /* Point to the beginning of the next character in the sequence. */\n\t RExC_parse = endchar + 1;\n\t endchar = RExC_parse + strcspn(RExC_parse, \".}\");\n\n\t}\n sv_catpv(substitute_parse, \")\");\n\n len = SvCUR(substitute_parse);\n\n\t/* Don't allow empty number */\n\tif (len < (STRLEN) 8) {\n RExC_parse = endbrace;\n\t vFAIL(\"Invalid hexadecimal number in \\\\N{U+...}\");\n\t}\n\n RExC_parse = RExC_start = RExC_adjusted_start\n = SvPV_nolen(substitute_parse);\n\tRExC_end = RExC_parse + len;\n\n /* The values are Unicode, and therefore not subject to recoding, but\n * have to be converted to native on a non-Unicode (meaning non-ASCII)\n * platform. */\n#ifdef EBCDIC\n RExC_recode_x_to_native = 1;\n#endif\n\n *node_p = reg(pRExC_state, 1, &flags, depth+1);\n\n /* Restore the saved values */\n\tRExC_start = RExC_adjusted_start = save_start;\n\tRExC_parse = endbrace;\n\tRExC_end = orig_end;\n#ifdef EBCDIC\n RExC_recode_x_to_native = 0;\n#endif\n SvREFCNT_dec_NN(substitute_parse);\n\n if (! *node_p) {\n if (flags & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flags & (RESTART_PASS1|NEED_UTF8);\n return FALSE;\n }\n FAIL2(\"panic: reg returned NULL to grok_bslash_N, flags=%#\" UVxf,\n (UV) flags);\n }\n *flagp |= flags&(HASWIDTH|SPSTART|SIMPLE|POSTPONED);\n\n nextchar(pRExC_state);\n\n return TRUE;\n }\n}\n\n\nPERL_STATIC_INLINE U8\nS_compute_EXACTish(RExC_state_t *pRExC_state)\n{\n U8 op;\n\n PERL_ARGS_ASSERT_COMPUTE_EXACTISH;\n\n if (! FOLD) {\n return (LOC)\n ? EXACTL\n : EXACT;\n }\n\n op = get_regex_charset(RExC_flags);\n if (op >= REGEX_ASCII_RESTRICTED_CHARSET) {\n op--; /* /a is same as /u, and map /aa's offset to what /a's would have\n been, so there is no hole */\n }\n\n return op + EXACTF;\n}\n\nPERL_STATIC_INLINE void\nS_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_state,\n regnode *node, I32* flagp, STRLEN len, UV code_point,\n bool downgradable)\n{\n /* This knows the details about sizing an EXACTish node, setting flags for\n * it (by setting <*flagp>, and potentially populating it with a single\n * character.\n *\n * If <len> (the length in bytes) is non-zero, this function assumes that\n * the node has already been populated, and just does the sizing. In this\n * case <code_point> should be the final code point that has already been\n * placed into the node. This value will be ignored except that under some\n * circumstances <*flagp> is set based on it.\n *\n * If <len> is zero, the function assumes that the node is to contain only\n * the single character given by <code_point> and calculates what <len>\n * should be. In pass 1, it sizes the node appropriately. In pass 2, it\n * additionally will populate the node's STRING with <code_point> or its\n * fold if folding.\n *\n * In both cases <*flagp> is appropriately set\n *\n * It knows that under FOLD, the Latin Sharp S and UTF characters above\n * 255, must be folded (the former only when the rules indicate it can\n * match 'ss')\n *\n * When it does the populating, it looks at the flag 'downgradable'. If\n * true with a node that folds, it checks if the single code point\n * participates in a fold, and if not downgrades the node to an EXACT.\n * This helps the optimizer */\n\n bool len_passed_in = cBOOL(len != 0);\n U8 character[UTF8_MAXBYTES_CASE+1];\n\n PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT;\n\n /* Don't bother to check for downgrading in PASS1, as it doesn't make any\n * sizing difference, and is extra work that is thrown away */\n if (downgradable && ! PASS2) {\n downgradable = FALSE;\n }\n\n if (! len_passed_in) {\n if (UTF) {\n if (UVCHR_IS_INVARIANT(code_point)) {\n if (LOC || ! FOLD) { /* /l defers folding until runtime */\n *character = (U8) code_point;\n }\n else { /* Here is /i and not /l. (toFOLD() is defined on just\n ASCII, which isn't the same thing as INVARIANT on\n EBCDIC, but it works there, as the extra invariants\n fold to themselves) */\n *character = toFOLD((U8) code_point);\n\n /* We can downgrade to an EXACT node if this character\n * isn't a folding one. Note that this assumes that\n * nothing above Latin1 folds to some other invariant than\n * one of these alphabetics; otherwise we would also have\n * to check:\n * && (! HAS_NONLATIN1_FOLD_CLOSURE(code_point)\n * || ASCII_FOLD_RESTRICTED))\n */\n if (downgradable && PL_fold[code_point] == code_point) {\n OP(node) = EXACT;\n }\n }\n len = 1;\n }\n else if (FOLD && (! LOC\n || ! is_PROBLEMATIC_LOCALE_FOLD_cp(code_point)))\n { /* Folding, and ok to do so now */\n UV folded = _to_uni_fold_flags(\n code_point,\n character,\n &len,\n FOLD_FLAGS_FULL | ((ASCII_FOLD_RESTRICTED)\n ? FOLD_FLAGS_NOMIX_ASCII\n : 0));\n if (downgradable\n && folded == code_point /* This quickly rules out many\n cases, avoiding the\n _invlist_contains_cp() overhead\n for those. */\n && ! _invlist_contains_cp(PL_utf8_foldable, code_point))\n {\n OP(node) = (LOC)\n ? EXACTL\n : EXACT;\n }\n }\n else if (code_point <= MAX_UTF8_TWO_BYTE) {\n\n /* Not folding this cp, and can output it directly */\n *character = UTF8_TWO_BYTE_HI(code_point);\n *(character + 1) = UTF8_TWO_BYTE_LO(code_point);\n len = 2;\n }\n else {\n uvchr_to_utf8( character, code_point);\n len = UTF8SKIP(character);\n }\n } /* Else pattern isn't UTF8. */\n else if (! FOLD) {\n *character = (U8) code_point;\n len = 1;\n } /* Else is folded non-UTF8 */\n#if UNICODE_MAJOR_VERSION > 3 /* no multifolds in early Unicode */ \\\n || (UNICODE_MAJOR_VERSION == 3 && ( UNICODE_DOT_VERSION > 0) \\\n || UNICODE_DOT_DOT_VERSION > 0)\n else if (LIKELY(code_point != LATIN_SMALL_LETTER_SHARP_S)) {\n#else\n else if (1) {\n#endif\n /* We don't fold any non-UTF8 except possibly the Sharp s (see\n * comments at join_exact()); */\n *character = (U8) code_point;\n len = 1;\n\n /* Can turn into an EXACT node if we know the fold at compile time,\n * and it folds to itself and doesn't particpate in other folds */\n if (downgradable\n && ! LOC\n && PL_fold_latin1[code_point] == code_point\n && (! HAS_NONLATIN1_FOLD_CLOSURE(code_point)\n || (isASCII(code_point) && ASCII_FOLD_RESTRICTED)))\n {\n OP(node) = EXACT;\n }\n } /* else is Sharp s. May need to fold it */\n else if (AT_LEAST_UNI_SEMANTICS && ! ASCII_FOLD_RESTRICTED) {\n *character = 's';\n *(character + 1) = 's';\n len = 2;\n }\n else {\n *character = LATIN_SMALL_LETTER_SHARP_S;\n len = 1;\n }\n }\n\n if (SIZE_ONLY) {\n RExC_size += STR_SZ(len);\n }\n else {\n RExC_emit += STR_SZ(len);\n STR_LEN(node) = len;\n if (! len_passed_in) {\n Copy((char *) character, STRING(node), len, char);\n }\n }\n\n *flagp |= HASWIDTH;\n\n /* A single character node is SIMPLE, except for the special-cased SHARP S\n * under /di. */\n if ((len == 1 || (UTF && len == UVCHR_SKIP(code_point)))\n#if UNICODE_MAJOR_VERSION > 3 /* no multifolds in early Unicode */ \\\n || (UNICODE_MAJOR_VERSION == 3 && ( UNICODE_DOT_VERSION > 0) \\\n || UNICODE_DOT_DOT_VERSION > 0)\n && ( code_point != LATIN_SMALL_LETTER_SHARP_S\n || ! FOLD || ! DEPENDS_SEMANTICS)\n#endif\n ) {\n *flagp |= SIMPLE;\n }\n\n /* The OP may not be well defined in PASS1 */\n if (PASS2 && OP(node) == EXACTFL) {\n RExC_contains_locale = 1;\n }\n}\n\nSTATIC bool\nS_new_regcurly(const char *s, const char *e)\n{\n /* This is a temporary function designed to match the most lenient form of\n * a {m,n} quantifier we ever envision, with either number omitted, and\n * spaces anywhere between/before/after them.\n *\n * If this function fails, then the string it matches is very unlikely to\n * ever be considered a valid quantifier, so we can allow the '{' that\n * begins it to be considered as a literal */\n\n bool has_min = FALSE;\n bool has_max = FALSE;\n\n PERL_ARGS_ASSERT_NEW_REGCURLY;\n\n if (s >= e || *s++ != '{')\n\treturn FALSE;\n\n while (s < e && isSPACE(*s)) {\n s++;\n }\n while (s < e && isDIGIT(*s)) {\n has_min = TRUE;\n s++;\n }\n while (s < e && isSPACE(*s)) {\n s++;\n }\n\n if (*s == ',') {\n\ts++;\n while (s < e && isSPACE(*s)) {\n s++;\n }\n while (s < e && isDIGIT(*s)) {\n has_max = TRUE;\n s++;\n }\n while (s < e && isSPACE(*s)) {\n s++;\n }\n }\n\n return s < e && *s == '}' && (has_min || has_max);\n}\n\n/* Parse backref decimal value, unless it's too big to sensibly be a backref,\n * in which case return I32_MAX (rather than possibly 32-bit wrapping) */\n\nstatic I32\nS_backref_value(char *p)\n{\n const char* endptr;\n UV val;\n if (grok_atoUV(p, &val, &endptr) && val <= I32_MAX)\n return (I32)val;\n return I32_MAX;\n}\n\n\n/*\n - regatom - the lowest level\n\n Try to identify anything special at the start of the current parse position.\n If there is, then handle it as required. This may involve generating a\n single regop, such as for an assertion; or it may involve recursing, such as\n to handle a () structure.\n\n If the string doesn't start with something special then we gobble up\n as much literal text as we can. If we encounter a quantifier, we have to\n back off the final literal character, as that quantifier applies to just it\n and not to the whole string of literals.\n\n Once we have been able to handle whatever type of thing started the\n sequence, we return.\n\n Note: we have to be careful with escapes, as they can be both literal\n and special, and in the case of \\10 and friends, context determines which.\n\n A summary of the code structure is:\n\n switch (first_byte) {\n\tcases for each special:\n\t handle this special;\n\t break;\n\tcase '\\\\':\n\t switch (2nd byte) {\n\t\tcases for each unambiguous special:\n\t\t handle this special;\n\t\t break;\n\t\tcases for each ambigous special/literal:\n\t\t disambiguate;\n\t\t if (special) handle here\n\t\t else goto defchar;\n\t\tdefault: // unambiguously literal:\n\t\t goto defchar;\n\t }\n\tdefault: // is a literal char\n\t // FALL THROUGH\n\tdefchar:\n\t create EXACTish node for literal;\n\t while (more input and node isn't full) {\n\t\tswitch (input_byte) {\n\t\t cases for each special;\n make sure parse pointer is set so that the next call to\n regatom will see this special first\n goto loopdone; // EXACTish node terminated by prev. char\n\t\t default:\n\t\t append char to EXACTISH node;\n\t\t}\n\t get next input byte;\n\t }\n loopdone:\n }\n return the generated node;\n\n Specifically there are two separate switches for handling\n escape sequences, with the one for handling literal escapes requiring\n a dummy entry for all of the special escapes that are actually handled\n by the other.\n\n Returns NULL, setting *flagp to TRYAGAIN if reg() returns NULL with\n TRYAGAIN.\n Returns NULL, setting *flagp to RESTART_PASS1 if the sizing scan needs to be\n restarted, or'd with NEED_UTF8 if the pattern needs to be upgraded to UTF-8\n Otherwise does not return NULL.\n*/\n\nSTATIC regnode *\nS_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)\n{\n regnode *ret = NULL;\n I32 flags = 0;\n char *parse_start;\n U8 op;\n int invert = 0;\n U8 arg;\n\n GET_RE_DEBUG_FLAGS_DECL;\n\n *flagp = WORST;\t\t/* Tentatively. */\n\n DEBUG_PARSE(\"atom\");\n\n PERL_ARGS_ASSERT_REGATOM;\n\n tryagain:\n parse_start = RExC_parse;\n assert(RExC_parse < RExC_end);\n switch ((U8)*RExC_parse) {\n case '^':\n\tRExC_seen_zerolen++;\n\tnextchar(pRExC_state);\n\tif (RExC_flags & RXf_PMf_MULTILINE)\n\t ret = reg_node(pRExC_state, MBOL);\n\telse\n\t ret = reg_node(pRExC_state, SBOL);\n Set_Node_Length(ret, 1); /* MJD */\n\tbreak;\n case '$':\n\tnextchar(pRExC_state);\n\tif (*RExC_parse)\n\t RExC_seen_zerolen++;\n\tif (RExC_flags & RXf_PMf_MULTILINE)\n\t ret = reg_node(pRExC_state, MEOL);\n\telse\n\t ret = reg_node(pRExC_state, SEOL);\n Set_Node_Length(ret, 1); /* MJD */\n\tbreak;\n case '.':\n\tnextchar(pRExC_state);\n\tif (RExC_flags & RXf_PMf_SINGLELINE)\n\t ret = reg_node(pRExC_state, SANY);\n\telse\n\t ret = reg_node(pRExC_state, REG_ANY);\n\t*flagp |= HASWIDTH|SIMPLE;\n\tMARK_NAUGHTY(1);\n Set_Node_Length(ret, 1); /* MJD */\n\tbreak;\n case '[':\n {\n\tchar * const oregcomp_parse = ++RExC_parse;\n ret = regclass(pRExC_state, flagp,depth+1,\n FALSE, /* means parse the whole char class */\n TRUE, /* allow multi-char folds */\n FALSE, /* don't silence non-portable warnings. */\n (bool) RExC_strict,\n TRUE, /* Allow an optimized regnode result */\n NULL,\n NULL);\n if (ret == NULL) {\n if (*flagp & (RESTART_PASS1|NEED_UTF8))\n return NULL;\n FAIL2(\"panic: regclass returned NULL to regatom, flags=%#\" UVxf,\n (UV) *flagp);\n }\n\tif (*RExC_parse != ']') {\n\t RExC_parse = oregcomp_parse;\n\t vFAIL(\"Unmatched [\");\n\t}\n\tnextchar(pRExC_state);\n Set_Node_Length(ret, RExC_parse - oregcomp_parse + 1); /* MJD */\n\tbreak;\n }\n case '(':\n\tnextchar(pRExC_state);\n ret = reg(pRExC_state, 2, &flags,depth+1);\n\tif (ret == NULL) {\n\t\tif (flags & TRYAGAIN) {\n\t\t if (RExC_parse >= RExC_end) {\n\t\t\t /* Make parent create an empty node if needed. */\n\t\t\t*flagp |= TRYAGAIN;\n\t\t\treturn(NULL);\n\t\t }\n\t\t goto tryagain;\n\t\t}\n if (flags & (RESTART_PASS1|NEED_UTF8)) {\n *flagp = flags & (RESTART_PASS1|NEED_UTF8);\n return NULL;\n }\n FAIL2(\"panic: reg returned NULL to regatom, flags=%#\" UVxf,\n (UV) flags);\n\t}\n\t*flagp |= flags&(HASWIDTH|SPSTART|SIMPLE|POSTPONED);\n\tbreak;\n case '|':\n case ')':\n\tif (flags & TRYAGAIN) {\n\t *flagp |= TRYAGAIN;\n\t return NULL;\n\t}\n\tvFAIL(\"Internal urp\");\n\t\t\t\t/* Supposed to be caught earlier. */\n\tbreak;\n case '?':\n case '+':\n case '*':\n\tRExC_parse++;\n\tvFAIL(\"Quantifier follows nothing\");\n\tbreak;\n case '\\\\':\n\t/* Special Escapes\n\n\t This switch handles escape sequences that resolve to some kind\n\t of special regop and not to literal text. Escape sequnces that\n\t resolve to literal text are handled below in the switch marked\n\t \"Literal Escapes\".\n\n\t Every entry in this switch *must* have a corresponding entry\n\t in the literal escape switch. However, the opposite is not\n\t required, as the default for this switch is to jump to the\n\t literal text handling code.\n\t*/\n\tRExC_parse++;\n\tswitch ((U8)*RExC_parse) {\n\t/* Special Escapes */\n\tcase 'A':\n\t RExC_seen_zerolen++;\n\t ret = reg_node(pRExC_state, SBOL);\n /* SBOL is shared with /^/ so we set the flags so we can tell\n * /\\A/ from /^/ in split. We check ret because first pass we\n * have no regop struct to set the flags on. */\n if (PASS2)\n ret->flags = 1;\n\t *flagp |= SIMPLE;\n\t goto finish_meta_pat;\n\tcase 'G':\n\t ret = reg_node(pRExC_state, GPOS);\n RExC_seen |= REG_GPOS_SEEN;\n\t *flagp |= SIMPLE;\n\t goto finish_meta_pat;\n\tcase 'K':\n\t RExC_seen_zerolen++;\n\t ret = reg_node(pRExC_state, KEEPS);\n\t *flagp |= SIMPLE;\n\t /* XXX:dmq : disabling in-place substitution seems to\n\t * be necessary here to avoid cases of memory corruption, as\n\t * with: C<$_=\"x\" x 80; s/x\\K/y/> -- rgs\n\t */\n RExC_seen |= REG_LOOKBEHIND_SEEN;\n\t goto finish_meta_pat;\n\tcase 'Z':\n\t ret = reg_node(pRExC_state, SEOL);\n\t *flagp |= SIMPLE;\n\t RExC_seen_zerolen++;\t\t/* Do not optimize RE away */\n\t goto finish_meta_pat;\n\tcase 'z':\n\t ret = reg_node(pRExC_state, EOS);\n\t *flagp |= SIMPLE;\n\t RExC_seen_zerolen++;\t\t/* Do not optimize RE away */\n\t goto finish_meta_pat;\n\tcase 'C':\n\t vFAIL(\"\\\\C no longer supported\");\n\tcase 'X':\n\t ret = reg_node(pRExC_state, CLUMP);\n\t *flagp |= HASWIDTH;\n\t goto finish_meta_pat;\n\n\tcase 'W':\n invert = 1;\n /* FALLTHROUGH */\n\tcase 'w':\n arg = ANYOF_WORDCHAR;\n goto join_posix;\n\n\tcase 'B':\n invert = 1;\n /* FALLTHROUGH */\n\tcase 'b':\n {\n\t regex_charset charset = get_regex_charset(RExC_flags);\n\n\t RExC_seen_zerolen++;\n RExC_seen |= REG_LOOKBEHIND_SEEN;\n\t op = BOUND + charset;\n\n if (op == BOUNDL) {\n RExC_contains_locale = 1;\n }\n\n\t ret = reg_node(pRExC_state, op);\n\t *flagp |= SIMPLE;\n\t if (RExC_parse >= RExC_end || *(RExC_parse + 1) != '{') {\n FLAGS(ret) = TRADITIONAL_BOUND;\n if (PASS2 && op > BOUNDA) { /* /aa is same as /a */\n OP(ret) = BOUNDA;\n }\n }\n else {\n STRLEN length;\n char name = *RExC_parse;\n char * endbrace = NULL;\n RExC_parse += 2;\n if (RExC_parse < RExC_end) {\n endbrace = (char *) memchr(RExC_parse, '}', RExC_end - RExC_parse);\n }\n\n if (! endbrace) {\n vFAIL2(\"Missing right brace on \\\\%c{}\", name);\n }\n /* XXX Need to decide whether to take spaces or not. Should be\n * consistent with \\p{}, but that currently is SPACE, which\n * means vertical too, which seems wrong\n * while (isBLANK(*RExC_parse)) {\n RExC_parse++;\n }*/\n if (endbrace == RExC_parse) {\n RExC_parse++; /* After the '}' */\n vFAIL2(\"Empty \\\\%c{}\", name);\n }\n length = endbrace - RExC_parse;\n /*while (isBLANK(*(RExC_parse + length - 1))) {\n length--;\n }*/\n switch (*RExC_parse) {\n case 'g':\n if ( length != 1\n && (memNEs(RExC_parse + 1, length - 1, \"cb\")))\n {\n goto bad_bound_type;\n }\n FLAGS(ret) = GCB_BOUND;\n break;\n case 'l':\n if (length != 2 || *(RExC_parse + 1) != 'b') {\n goto bad_bound_type;\n }\n FLAGS(ret) = LB_BOUND;\n break;\n case 's':\n if (length != 2 || *(RExC_parse + 1) != 'b') {\n goto bad_bound_type;\n }\n FLAGS(ret) = SB_BOUND;\n break;\n case 'w':\n if (length != 2 || *(RExC_parse + 1) != 'b') {\n goto bad_bound_type;\n }\n FLAGS(ret) = WB_BOUND;\n break;\n default:\n bad_bound_type:\n RExC_parse = endbrace;\n\t\t\tvFAIL2utf8f(\n \"'%\" UTF8f \"' is an unknown bound type\",\n\t\t\t UTF8fARG(UTF, length, endbrace - length));\n NOT_REACHED; /*NOTREACHED*/\n }\n RExC_parse = endbrace;\n REQUIRE_UNI_RULES(flagp, NULL);\n\n if (PASS2 && op >= BOUNDA) { /* /aa is same as /a */\n OP(ret) = BOUNDU;\n length += 4;\n\n /* Don't have to worry about UTF-8, in this message because\n * to get here the contents of the \\b must be ASCII */\n ckWARN4reg(RExC_parse + 1, /* Include the '}' in msg */\n \"Using /u for '%.*s' instead of /%s\",\n (unsigned) length,\n endbrace - length + 1,\n (charset == REGEX_ASCII_RESTRICTED_CHARSET)\n ? ASCII_RESTRICT_PAT_MODS\n : ASCII_MORE_RESTRICT_PAT_MODS);\n }\n\t }\n\n if (PASS2 && invert) {\n OP(ret) += NBOUND - BOUND;\n }\n\t goto finish_meta_pat;\n }\n\n\tcase 'D':\n invert = 1;\n /* FALLTHROUGH */\n\tcase 'd':\n arg = ANYOF_DIGIT;\n if (! DEPENDS_SEMANTICS) {\n goto join_posix;\n }\n\n /* \\d doesn't have any matches in the upper Latin1 range, hence /d\n * is equivalent to /u. Changing to /u saves some branches at\n * runtime */\n op = POSIXU;\n goto join_posix_op_known;\n\n\tcase 'R':\n\t ret = reg_node(pRExC_state, LNBREAK);\n\t *flagp |= HASWIDTH|SIMPLE;\n\t goto finish_meta_pat;\n\n\tcase 'H':\n invert = 1;\n /* FALLTHROUGH */\n\tcase 'h':\n\t arg = ANYOF_BLANK;\n op = POSIXU;\n goto join_posix_op_known;\n\n\tcase 'V':\n invert = 1;\n /* FALLTHROUGH */\n\tcase 'v':\n\t arg = ANYOF_VERTWS;\n op = POSIXU;\n goto join_posix_op_known;\n\n\tcase 'S':\n invert = 1;\n /* FALLTHROUGH */\n\tcase 's':\n arg = ANYOF_SPACE;\n\n join_posix:\n\n\t op = POSIXD + get_regex_charset(RExC_flags);\n if (op > POSIXA) { /* /aa is same as /a */\n op = POSIXA;\n }\n else if (op == POSIXL) {\n RExC_contains_locale = 1;\n }\n\n join_posix_op_known:\n\n if (invert) {\n op += NPOSIXD - POSIXD;\n }\n\n\t ret = reg_node(pRExC_state, op);\n if (! SIZE_ONLY) {\n FLAGS(ret) = namedclass_to_classnum(arg);\n }\n\n\t *flagp |= HASWIDTH|SIMPLE;\n /* FALLTHROUGH */\n\n finish_meta_pat:\n if ( UCHARAT(RExC_parse + 1) == '{'\n && UNLIKELY(! new_regcurly(RExC_parse + 1, RExC_end)))\n {\n RExC_parse += 2;\n vFAIL(\"Unescaped left brace in regex is illegal here\");\n }\n\t nextchar(pRExC_state);\n Set_Node_Length(ret, 2); /* MJD */\n\t break;\n\tcase 'p':\n\tcase 'P':\n RExC_parse--;\n\n ret = regclass(pRExC_state, flagp,depth+1,\n TRUE, /* means just parse this element */\n FALSE, /* don't allow multi-char folds */\n FALSE, /* don't silence non-portable warnings. It\n would be a bug if these returned\n non-portables */\n (bool) RExC_strict,\n TRUE, /* Allow an optimized regnode result */\n NULL,\n NULL);\n if (*flagp & RESTART_PASS1)\n return NULL;\n /* regclass() can only return RESTART_PASS1 and NEED_UTF8 if\n * multi-char folds are allowed. */\n if (!ret)\n FAIL2(\"panic: regclass returned NULL to regatom, flags=%#\" UVxf,\n (UV) *flagp);\n\n RExC_parse--;\n\n Set_Node_Offset(ret, parse_start);\n Set_Node_Cur_Length(ret, parse_start - 2);\n nextchar(pRExC_state);\n\t break;\n case 'N':\n /* Handle \\N, \\N{} and \\N{NAMED SEQUENCE} (the latter meaning the\n * \\N{...} evaluates to a sequence of more than one code points).\n * The function call below returns a regnode, which is our result.\n * The parameters cause it to fail if the \\N{} evaluates to a\n * single code point; we handle those like any other literal. The\n * reason that the multicharacter case is handled here and not as\n * part of the EXACtish code is because of quantifiers. In\n * /\\N{BLAH}+/, the '+' applies to the whole thing, and doing it\n * this way makes that Just Happen. dmq.\n * join_exact() will join this up with adjacent EXACTish nodes\n * later on, if appropriate. */\n ++RExC_parse;\n if (grok_bslash_N(pRExC_state,\n &ret, /* Want a regnode returned */\n NULL, /* Fail if evaluates to a single code\n point */\n NULL, /* Don't need a count of how many code\n points */\n flagp,\n RExC_strict,\n depth)\n ) {\n break;\n }\n\n if (*flagp & RESTART_PASS1)\n return NULL;\n\n /* Here, evaluates to a single code point. Go get that */\n RExC_parse = parse_start;\n goto defchar;\n\n\tcase 'k': /* Handle \\k<NAME> and \\k'NAME' */\n parse_named_seq:\n {\n char ch;\n if ( RExC_parse >= RExC_end - 1\n || (( ch = RExC_parse[1]) != '<'\n && ch != '\\''\n && ch != '{'))\n {\n\t RExC_parse++;\n\t\t/* diag_listed_as: Sequence \\%s... not terminated in regex; marked by <-- HERE in m/%s/ */\n\t vFAIL2(\"Sequence %.2s... not terminated\",parse_start);\n\t } else {\n\t\tRExC_parse += 2;\n ret = handle_named_backref(pRExC_state,\n flagp,\n parse_start,\n (ch == '<')\n ? '>'\n : (ch == '{')\n ? '}'\n : '\\'');\n }\n break;\n\t}\n\tcase 'g':\n\tcase '1': case '2': case '3': case '4':\n\tcase '5': case '6': case '7': case '8': case '9':\n\t {\n\t\tI32 num;\n\t\tbool hasbrace = 0;\n\n\t\tif (*RExC_parse == 'g') {\n bool isrel = 0;\n\n\t\t RExC_parse++;\n\t\t if (*RExC_parse == '{') {\n\t\t RExC_parse++;\n\t\t hasbrace = 1;\n\t\t }\n\t\t if (*RExC_parse == '-') {\n\t\t RExC_parse++;\n\t\t isrel = 1;\n\t\t }\n\t\t if (hasbrace && !isDIGIT(*RExC_parse)) {\n\t\t if (isrel) RExC_parse--;\n RExC_parse -= 2;\n\t\t goto parse_named_seq;\n }\n\n if (RExC_parse >= RExC_end) {\n goto unterminated_g;\n }\n num = S_backref_value(RExC_parse);\n if (num == 0)\n vFAIL(\"Reference to invalid group 0\");\n else if (num == I32_MAX) {\n if (isDIGIT(*RExC_parse))\n\t\t\t vFAIL(\"Reference to nonexistent group\");\n else\n unterminated_g:\n vFAIL(\"Unterminated \\\\g... pattern\");\n }\n\n if (isrel) {\n num = RExC_npar - num;\n if (num < 1)\n vFAIL(\"Reference to nonexistent or unclosed group\");\n }\n }\n else {\n num = S_backref_value(RExC_parse);\n /* bare \\NNN might be backref or octal - if it is larger\n * than or equal RExC_npar then it is assumed to be an\n * octal escape. Note RExC_npar is +1 from the actual\n * number of parens. */\n /* Note we do NOT check if num == I32_MAX here, as that is\n * handled by the RExC_npar check */\n\n if (\n /* any numeric escape < 10 is always a backref */\n num > 9\n /* any numeric escape < RExC_npar is a backref */\n && num >= RExC_npar\n /* cannot be an octal escape if it starts with 8 */\n && *RExC_parse != '8'\n /* cannot be an octal escape it it starts with 9 */\n && *RExC_parse != '9'\n )\n {\n /* Probably not a backref, instead likely to be an\n * octal character escape, e.g. \\35 or \\777.\n * The above logic should make it obvious why using\n * octal escapes in patterns is problematic. - Yves */\n RExC_parse = parse_start;\n goto defchar;\n }\n }\n\n /* At this point RExC_parse points at a numeric escape like\n * \\12 or \\88 or something similar, which we should NOT treat\n * as an octal escape. It may or may not be a valid backref\n * escape. For instance \\88888888 is unlikely to be a valid\n * backref. */\n while (isDIGIT(*RExC_parse))\n RExC_parse++;\n if (hasbrace) {\n if (*RExC_parse != '}')\n vFAIL(\"Unterminated \\\\g{...} pattern\");\n RExC_parse++;\n }\n if (!SIZE_ONLY) {\n if (num > (I32)RExC_rx->nparens)\n vFAIL(\"Reference to nonexistent group\");\n }\n RExC_sawback = 1;\n ret = reganode(pRExC_state,\n ((! FOLD)\n ? REF\n : (ASCII_FOLD_RESTRICTED)\n ? REFFA\n : (AT_LEAST_UNI_SEMANTICS)\n ? REFFU\n : (LOC)\n ? REFFL\n : REFF),\n num);\n *flagp |= HASWIDTH;\n\n /* override incorrect value set in reganode MJD */\n Set_Node_Offset(ret, parse_start);\n Set_Node_Cur_Length(ret, parse_start-1);\n skip_to_be_ignored_text(pRExC_state, &RExC_parse,\n FALSE /* Don't force to /x */ );\n\t }\n\t break;\n\tcase '\\0':\n\t if (RExC_parse >= RExC_end)\n\t\tFAIL(\"Trailing \\\\\");\n\t /* FALLTHROUGH */\n\tdefault:\n\t /* Do not generate \"unrecognized\" warnings here, we fall\n\t back into the quick-grab loop below */\n RExC_parse = parse_start;\n\t goto defchar;\n\t} /* end of switch on a \\foo sequence */\n\tbreak;\n\n case '#':\n\n /* '#' comments should have been spaced over before this function was\n * called */\n assert((RExC_flags & RXf_PMf_EXTENDED) == 0);\n\t/*\n if (RExC_flags & RXf_PMf_EXTENDED) {\n\t RExC_parse = reg_skipcomment( pRExC_state, RExC_parse );\n\t if (RExC_parse < RExC_end)\n\t\tgoto tryagain;\n\t}\n */\n\n\t/* FALLTHROUGH */\n\n default:\n\t defchar: {\n\n /* Here, we have determined that the next thing is probably a\n * literal character. RExC_parse points to the first byte of its\n * definition. (It still may be an escape sequence that evaluates\n * to a single character) */\n\n\t STRLEN len = 0;\n\t UV ender = 0;\n\t char *p;\n\t char *s;\n#define MAX_NODE_STRING_SIZE 127\n\t char foldbuf[MAX_NODE_STRING_SIZE+UTF8_MAXBYTES_CASE];\n\t char *s0;\n\t U8 upper_parse = MAX_NODE_STRING_SIZE;\n U8 node_type = compute_EXACTish(pRExC_state);\n bool next_is_quantifier;\n char * oldp = NULL;\n\n /* We can convert EXACTF nodes to EXACTFU if they contain only\n * characters that match identically regardless of the target\n * string's UTF8ness. The reason to do this is that EXACTF is not\n * trie-able, EXACTFU is.\n *\n * Similarly, we can convert EXACTFL nodes to EXACTFLU8 if they\n * contain only above-Latin1 characters (hence must be in UTF8),\n * which don't participate in folds with Latin1-range characters,\n * as the latter's folds aren't known until runtime. (We don't\n * need to figure this out until pass 2) */\n bool maybe_exactfu = PASS2\n && (node_type == EXACTF || node_type == EXACTFL);\n\n /* If a folding node contains only code points that don't\n * participate in folds, it can be changed into an EXACT node,\n * which allows the optimizer more things to look for */\n bool maybe_exact;\n\n\t ret = reg_node(pRExC_state, node_type);\n\n /* In pass1, folded, we use a temporary buffer instead of the\n * actual node, as the node doesn't exist yet */\n\t s = (SIZE_ONLY && FOLD) ? foldbuf : STRING(ret);\n\n s0 = s;\n\n\t reparse:\n\n /* We look for the EXACTFish to EXACT node optimizaton only if\n * folding. (And we don't need to figure this out until pass 2).\n * XXX It might actually make sense to split the node into portions\n * that are exact and ones that aren't, so that we could later use\n * the exact ones to find the longest fixed and floating strings.\n * One would want to join them back into a larger node. One could\n * use a pseudo regnode like 'EXACT_ORIG_FOLD' */\n maybe_exact = FOLD && PASS2;\n\n\t /* XXX The node can hold up to 255 bytes, yet this only goes to\n * 127. I (khw) do not know why. Keeping it somewhat less than\n * 255 allows us to not have to worry about overflow due to\n * converting to utf8 and fold expansion, but that value is\n * 255-UTF8_MAXBYTES_CASE. join_exact() may join adjacent nodes\n * split up by this limit into a single one using the real max of\n * 255. Even at 127, this breaks under rare circumstances. If\n * folding, we do not want to split a node at a character that is a\n * non-final in a multi-char fold, as an input string could just\n * happen to want to match across the node boundary. The join\n * would solve that problem if the join actually happens. But a\n * series of more than two nodes in a row each of 127 would cause\n * the first join to succeed to get to 254, but then there wouldn't\n * be room for the next one, which could at be one of those split\n * multi-char folds. I don't know of any fool-proof solution. One\n * could back off to end with only a code point that isn't such a\n * non-final, but it is possible for there not to be any in the\n * entire node. */\n\n assert( ! UTF /* Is at the beginning of a character */\n || UTF8_IS_INVARIANT(UCHARAT(RExC_parse))\n || UTF8_IS_START(UCHARAT(RExC_parse)));\n\n /* Here, we have a literal character. Find the maximal string of\n * them in the input that we can fit into a single EXACTish node.\n * We quit at the first non-literal or when the node gets full */\n\t for (p = RExC_parse;\n\t len < upper_parse && p < RExC_end;\n\t len++)\n\t {\n\t\toldp = p;\n\n /* White space has already been ignored */\n assert( (RExC_flags & RXf_PMf_EXTENDED) == 0\n || ! is_PATWS_safe((p), RExC_end, UTF));\n\n\t\tswitch ((U8)*p) {\n\t\tcase '^':\n\t\tcase '$':\n\t\tcase '.':\n\t\tcase '[':\n\t\tcase '(':\n\t\tcase ')':\n\t\tcase '|':\n\t\t goto loopdone;\n\t\tcase '\\\\':\n\t\t /* Literal Escapes Switch\n\n\t\t This switch is meant to handle escape sequences that\n\t\t resolve to a literal character.\n\n\t\t Every escape sequence that represents something\n\t\t else, like an assertion or a char class, is handled\n\t\t in the switch marked 'Special Escapes' above in this\n\t\t routine, but also has an entry here as anything that\n\t\t isn't explicitly mentioned here will be treated as\n\t\t an unescaped equivalent literal.\n\t\t */\n\n\t\t switch ((U8)*++p) {\n\t\t /* These are all the special escapes. */\n\t\t case 'A': /* Start assertion */\n\t\t case 'b': case 'B': /* Word-boundary assertion*/\n\t\t case 'C': /* Single char !DANGEROUS! */\n\t\t case 'd': case 'D': /* digit class */\n\t\t case 'g': case 'G': /* generic-backref, pos assertion */\n\t\t case 'h': case 'H': /* HORIZWS */\n\t\t case 'k': case 'K': /* named backref, keep marker */\n\t\t case 'p': case 'P': /* Unicode property */\n\t\t case 'R': /* LNBREAK */\n\t\t case 's': case 'S': /* space class */\n\t\t case 'v': case 'V': /* VERTWS */\n\t\t case 'w': case 'W': /* word class */\n case 'X': /* eXtended Unicode \"combining\n character sequence\" */\n\t\t case 'z': case 'Z': /* End of line/string assertion */\n\t\t\t--p;\n\t\t\tgoto loopdone;\n\n\t /* Anything after here is an escape that resolves to a\n\t literal. (Except digits, which may or may not)\n\t */\n\t\t case 'n':\n\t\t\tender = '\\n';\n\t\t\tp++;\n\t\t\tbreak;\n\t\t case 'N': /* Handle a single-code point named character. */\n RExC_parse = p + 1;\n if (! grok_bslash_N(pRExC_state,\n NULL, /* Fail if evaluates to\n anything other than a\n single code point */\n &ender, /* The returned single code\n point */\n NULL, /* Don't need a count of\n how many code points */\n flagp,\n RExC_strict,\n depth)\n ) {\n if (*flagp & NEED_UTF8)\n FAIL(\"panic: grok_bslash_N set NEED_UTF8\");\n if (*flagp & RESTART_PASS1)\n return NULL;\n\n /* Here, it wasn't a single code point. Go close\n * up this EXACTish node. The switch() prior to\n * this switch handles the other cases */\n RExC_parse = p = oldp;\n goto loopdone;\n }\n p = RExC_parse;\n RExC_parse = parse_start;\n if (ender > 0xff) {\n REQUIRE_UTF8(flagp);\n }\n break;\n\t\t case 'r':\n\t\t\tender = '\\r';\n\t\t\tp++;\n\t\t\tbreak;\n\t\t case 't':\n\t\t\tender = '\\t';\n\t\t\tp++;\n\t\t\tbreak;\n\t\t case 'f':\n\t\t\tender = '\\f';\n\t\t\tp++;\n\t\t\tbreak;\n\t\t case 'e':\n\t\t\tender = ESC_NATIVE;\n\t\t\tp++;\n\t\t\tbreak;\n\t\t case 'a':\n\t\t\tender = '\\a';\n\t\t\tp++;\n\t\t\tbreak;\n\t\t case 'o':\n\t\t\t{\n\t\t\t UV result;\n\t\t\t const char* error_msg;\n\n\t\t\t bool valid = grok_bslash_o(&p,\n RExC_end,\n\t\t\t\t\t\t &result,\n\t\t\t\t\t\t &error_msg,\n\t\t\t\t\t\t PASS2, /* out warnings */\n (bool) RExC_strict,\n TRUE, /* Output warnings\n for non-\n portables */\n UTF);\n\t\t\t if (! valid) {\n\t\t\t\tRExC_parse = p;\t/* going to die anyway; point\n\t\t\t\t\t\t to exact spot of failure */\n\t\t\t\tvFAIL(error_msg);\n\t\t\t }\n ender = result;\n\t\t\t if (ender > 0xff) {\n\t\t\t\tREQUIRE_UTF8(flagp);\n\t\t\t }\n\t\t\t break;\n\t\t\t}\n\t\t case 'x':\n\t\t\t{\n UV result = UV_MAX; /* initialize to erroneous\n value */\n\t\t\t const char* error_msg;\n\n\t\t\t bool valid = grok_bslash_x(&p,\n RExC_end,\n\t\t\t\t\t\t &result,\n\t\t\t\t\t\t &error_msg,\n\t\t\t\t\t\t PASS2, /* out warnings */\n (bool) RExC_strict,\n TRUE, /* Silence warnings\n for non-\n portables */\n UTF);\n\t\t\t if (! valid) {\n\t\t\t\tRExC_parse = p;\t/* going to die anyway; point\n\t\t\t\t\t\t to exact spot of failure */\n\t\t\t\tvFAIL(error_msg);\n\t\t\t }\n ender = result;\n\n if (ender < 0x100) {\n#ifdef EBCDIC\n if (RExC_recode_x_to_native) {\n ender = LATIN1_TO_NATIVE(ender);\n }\n#endif\n\t\t\t }\n else {\n\t\t\t\tREQUIRE_UTF8(flagp);\n\t\t\t }\n\t\t\t break;\n\t\t\t}\n\t\t case 'c':\n\t\t\tp++;\n\t\t\tender = grok_bslash_c(*p++, PASS2);\n\t\t\tbreak;\n case '8': case '9': /* must be a backreference */\n --p;\n /* we have an escape like \\8 which cannot be an octal escape\n * so we exit the loop, and let the outer loop handle this\n * escape which may or may not be a legitimate backref. */\n goto loopdone;\n case '1': case '2': case '3':case '4':\n\t\t case '5': case '6': case '7':\n /* When we parse backslash escapes there is ambiguity\n * between backreferences and octal escapes. Any escape\n * from \\1 - \\9 is a backreference, any multi-digit\n * escape which does not start with 0 and which when\n * evaluated as decimal could refer to an already\n * parsed capture buffer is a back reference. Anything\n * else is octal.\n *\n * Note this implies that \\118 could be interpreted as\n * 118 OR as \"\\11\" . \"8\" depending on whether there\n * were 118 capture buffers defined already in the\n * pattern. */\n\n /* NOTE, RExC_npar is 1 more than the actual number of\n * parens we have seen so far, hence the < RExC_npar below. */\n\n if ( !isDIGIT(p[1]) || S_backref_value(p) < RExC_npar)\n { /* Not to be treated as an octal constant, go\n find backref */\n --p;\n goto loopdone;\n }\n /* FALLTHROUGH */\n case '0':\n\t\t\t{\n\t\t\t I32 flags = PERL_SCAN_SILENT_ILLDIGIT;\n\t\t\t STRLEN numlen = 3;\n\t\t\t ender = grok_oct(p, &numlen, &flags, NULL);\n\t\t\t if (ender > 0xff) {\n\t\t\t\tREQUIRE_UTF8(flagp);\n\t\t\t }\n\t\t\t p += numlen;\n if (PASS2 /* like \\08, \\178 */\n && numlen < 3\n && isDIGIT(*p) && ckWARN(WARN_REGEXP))\n {\n\t\t\t\treg_warn_non_literal_string(\n p + 1,\n form_short_octal_warning(p, numlen));\n }\n\t\t\t}\n\t\t\tbreak;\n\t\t case '\\0':\n\t\t\tif (p >= RExC_end)\n\t\t\t FAIL(\"Trailing \\\\\");\n\t\t\t/* FALLTHROUGH */\n\t\t default:\n\t\t\tif (!SIZE_ONLY&& isALPHANUMERIC(*p)) {\n\t\t\t /* Include any left brace following the alpha to emphasize\n\t\t\t * that it could be part of an escape at some point\n\t\t\t * in the future */\n\t\t\t int len = (isALPHA(*p) && *(p + 1) == '{') ? 2 : 1;\n\t\t\t ckWARN3reg(p + len, \"Unrecognized escape \\\\%.*s passed through\", len, p);\n\t\t\t}\n\t\t\tgoto normal_default;\n\t\t } /* End of switch on '\\' */\n\t\t break;\n\t\tcase '{':\n /* Currently we allow an lbrace at the start of a construct\n * without raising a warning. This is because we think we\n * will never want such a brace to be meant to be other\n * than taken literally. */\n\t\t if (len || (p > RExC_start && isALPHA_A(*(p - 1)))) {\n\n /* But, we raise a fatal warning otherwise, as the\n * deprecation cycle has come and gone. Except that it\n * turns out that some heavily-relied on upstream\n * software, notably GNU Autoconf, have failed to fix\n * their uses. For these, don't make it fatal unless\n * we anticipate using the '{' for something else.\n * This happens after any alpha, and for a looser {m,n}\n * quantifier specification */\n if ( RExC_strict\n || ( p > parse_start + 1\n && isALPHA_A(*(p - 1))\n && *(p - 2) == '\\\\')\n || new_regcurly(p, RExC_end))\n {\n RExC_parse = p + 1;\n vFAIL(\"Unescaped left brace in regex is \"\n \"illegal here\");\n }\n if (PASS2) {\n ckWARNregdep(p + 1,\n \"Unescaped left brace in regex is \"\n \"deprecated here (and will be fatal \"\n \"in Perl 5.30), passed through\");\n }\n\t\t }\n\t\t goto normal_default;\n case '}':\n case ']':\n if (PASS2 && p > RExC_parse && RExC_strict) {\n ckWARN2reg(p + 1, \"Unescaped literal '%c'\", *p);\n }\n\t\t /*FALLTHROUGH*/\n\t\tdefault: /* A literal character */\n\t\t normal_default:\n\t\t if (! UTF8_IS_INVARIANT(*p) && UTF) {\n\t\t\tSTRLEN numlen;\n\t\t\tender = utf8n_to_uvchr((U8*)p, RExC_end - p,\n\t\t\t\t\t &numlen, UTF8_ALLOW_DEFAULT);\n\t\t\tp += numlen;\n\t\t }\n\t\t else\n\t\t\tender = (U8) *p++;\n\t\t break;\n\t\t} /* End of switch on the literal */\n\n\t\t/* Here, have looked at the literal character and <ender>\n * contains its ordinal, <p> points to the character after it.\n * We need to check if the next non-ignored thing is a\n * quantifier. Move <p> to after anything that should be\n * ignored, which, as a side effect, positions <p> for the next\n * loop iteration */\n skip_to_be_ignored_text(pRExC_state, &p,\n FALSE /* Don't force to /x */ );\n\n /* If the next thing is a quantifier, it applies to this\n * character only, which means that this character has to be in\n * its own node and can't just be appended to the string in an\n * existing node, so if there are already other characters in\n * the node, close the node with just them, and set up to do\n * this character again next time through, when it will be the\n * only thing in its new node */\n\n next_is_quantifier = LIKELY(p < RExC_end)\n && UNLIKELY(ISMULT2(p));\n\n if (next_is_quantifier && LIKELY(len)) {\n p = oldp;\n goto loopdone;\n }\n\n /* Ready to add 'ender' to the node */\n\n if (! FOLD) { /* The simple case, just append the literal */\n\n /* In the sizing pass, we need only the size of the\n * character we are appending, hence we can delay getting\n * its representation until PASS2. */\n if (SIZE_ONLY) {\n if (UTF && ! UVCHR_IS_INVARIANT(ender)) {\n const STRLEN unilen = UVCHR_SKIP(ender);\n s += unilen;\n\n /* We have to subtract 1 just below (and again in\n * the corresponding PASS2 code) because the loop\n * increments <len> each time, as all but this path\n * (and one other) through it add a single byte to\n * the EXACTish node. But these paths would change\n * len to be the correct final value, so cancel out\n * the increment that follows */\n len += unilen - 1;\n }\n else {\n s++;\n }\n } else { /* PASS2 */\n not_fold_common:\n if (UTF && ! UVCHR_IS_INVARIANT(ender)) {\n U8 * new_s = uvchr_to_utf8((U8*)s, ender);\n len += (char *) new_s - s - 1;\n s = (char *) new_s;\n }\n else {\n *(s++) = (char) ender;\n }\n }\n }\n else if (LOC && is_PROBLEMATIC_LOCALE_FOLD_cp(ender)) {\n\n /* Here are folding under /l, and the code point is\n * problematic. First, we know we can't simplify things */\n maybe_exact = FALSE;\n maybe_exactfu = FALSE;\n\n /* A problematic code point in this context means that its\n * fold isn't known until runtime, so we can't fold it now.\n * (The non-problematic code points are the above-Latin1\n * ones that fold to also all above-Latin1. Their folds\n * don't vary no matter what the locale is.) But here we\n * have characters whose fold depends on the locale.\n * Unlike the non-folding case above, we have to keep track\n * of these in the sizing pass, so that we can make sure we\n * don't split too-long nodes in the middle of a potential\n * multi-char fold. And unlike the regular fold case\n * handled in the else clauses below, we don't actually\n * fold and don't have special cases to consider. What we\n * do for both passes is the PASS2 code for non-folding */\n goto not_fold_common;\n }\n else /* A regular FOLD code point */\n if (! ( UTF\n#if UNICODE_MAJOR_VERSION > 3 /* no multifolds in early Unicode */ \\\n || (UNICODE_MAJOR_VERSION == 3 && ( UNICODE_DOT_VERSION > 0) \\\n || UNICODE_DOT_DOT_VERSION > 0)\n /* See comments for join_exact() as to why we fold\n * this non-UTF at compile time */\n || ( node_type == EXACTFU\n && ender == LATIN_SMALL_LETTER_SHARP_S)\n#endif\n )) {\n /* Here, are folding and are not UTF-8 encoded; therefore\n * the character must be in the range 0-255, and is not /l\n * (Not /l because we already handled these under /l in\n * is_PROBLEMATIC_LOCALE_FOLD_cp) */\n if (IS_IN_SOME_FOLD_L1(ender)) {\n maybe_exact = FALSE;\n\n /* See if the character's fold differs between /d and\n * /u. This includes the multi-char fold SHARP S to\n * 'ss' */\n if (UNLIKELY(ender == LATIN_SMALL_LETTER_SHARP_S)) {\n RExC_seen_unfolded_sharp_s = 1;\n maybe_exactfu = FALSE;\n }\n else if (maybe_exactfu\n && (PL_fold[ender] != PL_fold_latin1[ender]\n#if UNICODE_MAJOR_VERSION > 3 /* no multifolds in early Unicode */ \\\n || (UNICODE_MAJOR_VERSION == 3 && ( UNICODE_DOT_VERSION > 0) \\\n || UNICODE_DOT_DOT_VERSION > 0)\n || ( len > 0\n && isALPHA_FOLD_EQ(ender, 's')\n && isALPHA_FOLD_EQ(*(s-1), 's'))\n#endif\n )) {\n maybe_exactfu = FALSE;\n }\n }\n\n /* Even when folding, we store just the input character, as\n * we have an array that finds its fold quickly */\n *(s++) = (char) ender;\n }\n else { /* FOLD, and UTF (or sharp s) */\n /* Unlike the non-fold case, we do actually have to\n * calculate the results here in pass 1. This is for two\n * reasons, the folded length may be longer than the\n * unfolded, and we have to calculate how many EXACTish\n * nodes it will take; and we may run out of room in a node\n * in the middle of a potential multi-char fold, and have\n * to back off accordingly. */\n\n UV folded;\n if (isASCII_uni(ender)) {\n folded = toFOLD(ender);\n *(s)++ = (U8) folded;\n }\n else {\n STRLEN foldlen;\n\n folded = _to_uni_fold_flags(\n ender,\n (U8 *) s,\n &foldlen,\n FOLD_FLAGS_FULL | ((ASCII_FOLD_RESTRICTED)\n ? FOLD_FLAGS_NOMIX_ASCII\n : 0));\n s += foldlen;\n\n /* The loop increments <len> each time, as all but this\n * path (and one other) through it add a single byte to\n * the EXACTish node. But this one has changed len to\n * be the correct final value, so subtract one to\n * cancel out the increment that follows */\n len += foldlen - 1;\n }\n /* If this node only contains non-folding code points so\n * far, see if this new one is also non-folding */\n if (maybe_exact) {\n if (folded != ender) {\n maybe_exact = FALSE;\n }\n else {\n /* Here the fold is the original; we have to check\n * further to see if anything folds to it */\n if (_invlist_contains_cp(PL_utf8_foldable,\n ender))\n {\n maybe_exact = FALSE;\n }\n }\n }\n ender = folded;\n\t\t}\n\n\t\tif (next_is_quantifier) {\n\n /* Here, the next input is a quantifier, and to get here,\n * the current character is the only one in the node.\n * Also, here <len> doesn't include the final byte for this\n * character */\n len++;\n goto loopdone;\n\t\t}\n\n\t } /* End of loop through literal characters */\n\n /* Here we have either exhausted the input or ran out of room in\n * the node. (If we encountered a character that can't be in the\n * node, transfer is made directly to <loopdone>, and so we\n * wouldn't have fallen off the end of the loop.) In the latter\n * case, we artificially have to split the node into two, because\n * we just don't have enough space to hold everything. This\n * creates a problem if the final character participates in a\n * multi-character fold in the non-final position, as a match that\n * should have occurred won't, due to the way nodes are matched,\n * and our artificial boundary. So back off until we find a non-\n * problematic character -- one that isn't at the beginning or\n * middle of such a fold. (Either it doesn't participate in any\n * folds, or appears only in the final position of all the folds it\n * does participate in.) A better solution with far fewer false\n * positives, and that would fill the nodes more completely, would\n * be to actually have available all the multi-character folds to\n * test against, and to back-off only far enough to be sure that\n * this node isn't ending with a partial one. <upper_parse> is set\n * further below (if we need to reparse the node) to include just\n * up through that final non-problematic character that this code\n * identifies, so when it is set to less than the full node, we can\n * skip the rest of this */\n if (FOLD && p < RExC_end && upper_parse == MAX_NODE_STRING_SIZE) {\n\n const STRLEN full_len = len;\n\n\t\tassert(len >= MAX_NODE_STRING_SIZE);\n\n /* Here, <s> points to the final byte of the final character.\n * Look backwards through the string until find a non-\n * problematic character */\n\n\t\tif (! UTF) {\n\n /* This has no multi-char folds to non-UTF characters */\n if (ASCII_FOLD_RESTRICTED) {\n goto loopdone;\n }\n\n while (--s >= s0 && IS_NON_FINAL_FOLD(*s)) { }\n len = s - s0 + 1;\n\t\t}\n else {\n if (! PL_NonL1NonFinalFold) {\n PL_NonL1NonFinalFold = _new_invlist_C_array(\n NonL1_Perl_Non_Final_Folds_invlist);\n }\n\n /* Point to the first byte of the final character */\n s = (char *) utf8_hop((U8 *) s, -1);\n\n while (s >= s0) { /* Search backwards until find\n non-problematic char */\n if (UTF8_IS_INVARIANT(*s)) {\n\n /* There are no ascii characters that participate\n * in multi-char folds under /aa. In EBCDIC, the\n * non-ascii invariants are all control characters,\n * so don't ever participate in any folds. */\n if (ASCII_FOLD_RESTRICTED\n || ! IS_NON_FINAL_FOLD(*s))\n {\n break;\n }\n }\n else if (UTF8_IS_DOWNGRADEABLE_START(*s)) {\n if (! IS_NON_FINAL_FOLD(EIGHT_BIT_UTF8_TO_NATIVE(\n *s, *(s+1))))\n {\n break;\n }\n }\n else if (! _invlist_contains_cp(\n PL_NonL1NonFinalFold,\n valid_utf8_to_uvchr((U8 *) s, NULL)))\n {\n break;\n }\n\n /* Here, the current character is problematic in that\n * it does occur in the non-final position of some\n * fold, so try the character before it, but have to\n * special case the very first byte in the string, so\n * we don't read outside the string */\n s = (s == s0) ? s -1 : (char *) utf8_hop((U8 *) s, -1);\n } /* End of loop backwards through the string */\n\n /* If there were only problematic characters in the string,\n * <s> will point to before s0, in which case the length\n * should be 0, otherwise include the length of the\n * non-problematic character just found */\n len = (s < s0) ? 0 : s - s0 + UTF8SKIP(s);\n\t\t}\n\n /* Here, have found the final character, if any, that is\n * non-problematic as far as ending the node without splitting\n * it across a potential multi-char fold. <len> contains the\n * number of bytes in the node up-to and including that\n * character, or is 0 if there is no such character, meaning\n * the whole node contains only problematic characters. In\n * this case, give up and just take the node as-is. We can't\n * do any better */\n if (len == 0) {\n len = full_len;\n\n /* If the node ends in an 's' we make sure it stays EXACTF,\n * as if it turns into an EXACTFU, it could later get\n * joined with another 's' that would then wrongly match\n * the sharp s */\n if (maybe_exactfu && isALPHA_FOLD_EQ(ender, 's'))\n {\n maybe_exactfu = FALSE;\n }\n } else {\n\n /* Here, the node does contain some characters that aren't\n * problematic. If one such is the final character in the\n * node, we are done */\n if (len == full_len) {\n goto loopdone;\n }\n else if (len + ((UTF) ? UTF8SKIP(s) : 1) == full_len) {\n\n /* If the final character is problematic, but the\n * penultimate is not, back-off that last character to\n * later start a new node with it */\n p = oldp;\n goto loopdone;\n }\n\n /* Here, the final non-problematic character is earlier\n * in the input than the penultimate character. What we do\n * is reparse from the beginning, going up only as far as\n * this final ok one, thus guaranteeing that the node ends\n * in an acceptable character. The reason we reparse is\n * that we know how far in the character is, but we don't\n * know how to correlate its position with the input parse.\n * An alternate implementation would be to build that\n * correlation as we go along during the original parse,\n * but that would entail extra work for every node, whereas\n * this code gets executed only when the string is too\n * large for the node, and the final two characters are\n * problematic, an infrequent occurrence. Yet another\n * possible strategy would be to save the tail of the\n * string, and the next time regatom is called, initialize\n * with that. The problem with this is that unless you\n * back off one more character, you won't be guaranteed\n * regatom will get called again, unless regbranch,\n * regpiece ... are also changed. If you do back off that\n * extra character, so that there is input guaranteed to\n * force calling regatom, you can't handle the case where\n * just the first character in the node is acceptable. I\n * (khw) decided to try this method which doesn't have that\n * pitfall; if performance issues are found, we can do a\n * combination of the current approach plus that one */\n upper_parse = len;\n len = 0;\n s = s0;\n goto reparse;\n }\n\t } /* End of verifying node ends with an appropriate char */\n\n loopdone: /* Jumped to when encounters something that shouldn't be\n in the node */\n\n /* I (khw) don't know if you can get here with zero length, but the\n * old code handled this situation by creating a zero-length EXACT\n * node. Might as well be NOTHING instead */\n if (len == 0) {\n OP(ret) = NOTHING;\n }\n else {\n if (FOLD) {\n /* If 'maybe_exact' is still set here, means there are no\n * code points in the node that participate in folds;\n * similarly for 'maybe_exactfu' and code points that match\n * differently depending on UTF8ness of the target string\n * (for /u), or depending on locale for /l */\n if (maybe_exact) {\n OP(ret) = (LOC)\n ? EXACTL\n : EXACT;\n }\n else if (maybe_exactfu) {\n OP(ret) = (LOC)\n ? EXACTFLU8\n : EXACTFU;\n }\n }\n alloc_maybe_populate_EXACT(pRExC_state, ret, flagp, len, ender,\n FALSE /* Don't look to see if could\n be turned into an EXACT\n node, as we have already\n computed that */\n );\n }\n\n\t RExC_parse = p - 1;\n Set_Node_Cur_Length(ret, parse_start);\n\t RExC_parse = p;\n\t {\n\t\t/* len is STRLEN which is unsigned, need to copy to signed */\n\t\tIV iv = len;\n\t\tif (iv < 0)\n\t\t vFAIL(\"Internal disaster\");\n\t }\n\n\t} /* End of label 'defchar:' */\n\tbreak;\n } /* End of giant switch on input character */\n\n /* Position parse to next real character */\n skip_to_be_ignored_text(pRExC_state, &RExC_parse,\n FALSE /* Don't force to /x */ );\n if (PASS2 && *RExC_parse == '{' && OP(ret) != SBOL && ! regcurly(RExC_parse)) {\n ckWARNregdep(RExC_parse + 1, \"Unescaped left brace in regex is deprecated here (and will be fatal in Perl 5.30), passed through\");\n }\n\n return(ret);\n}\n\n\nSTATIC void\nS_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr)\n{\n /* Uses the inversion list '*invlist_ptr' to populate the ANYOF 'node'. It\n * sets up the bitmap and any flags, removing those code points from the\n * inversion list, setting it to NULL should it become completely empty */\n\n PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST;\n assert(PL_regkind[OP(node)] == ANYOF);\n\n ANYOF_BITMAP_ZERO(node);\n if (*invlist_ptr) {\n\n\t/* This gets set if we actually need to modify things */\n\tbool change_invlist = FALSE;\n\n\tUV start, end;\n\n\t/* Start looking through *invlist_ptr */\n\tinvlist_iterinit(*invlist_ptr);\n\twhile (invlist_iternext(*invlist_ptr, &start, &end)) {\n\t UV high;\n\t int i;\n\n if (end == UV_MAX && start <= NUM_ANYOF_CODE_POINTS) {\n ANYOF_FLAGS(node) |= ANYOF_MATCHES_ALL_ABOVE_BITMAP;\n }\n\n\t /* Quit if are above what we should change */\n\t if (start >= NUM_ANYOF_CODE_POINTS) {\n\t\tbreak;\n\t }\n\n\t change_invlist = TRUE;\n\n\t /* Set all the bits in the range, up to the max that we are doing */\n\t high = (end < NUM_ANYOF_CODE_POINTS - 1)\n ? end\n : NUM_ANYOF_CODE_POINTS - 1;\n\t for (i = start; i <= (int) high; i++) {\n\t\tif (! ANYOF_BITMAP_TEST(node, i)) {\n\t\t ANYOF_BITMAP_SET(node, i);\n\t\t}\n\t }\n\t}\n\tinvlist_iterfinish(*invlist_ptr);\n\n /* Done with loop; remove any code points that are in the bitmap from\n * *invlist_ptr; similarly for code points above the bitmap if we have\n * a flag to match all of them anyways */\n\tif (change_invlist) {\n\t _invlist_subtract(*invlist_ptr, PL_InBitmap, invlist_ptr);\n\t}\n if (ANYOF_FLAGS(node) & ANYOF_MATCHES_ALL_ABOVE_BITMAP) {\n\t _invlist_intersection(*invlist_ptr, PL_InBitmap, invlist_ptr);\n\t}\n\n\t/* If have completely emptied it, remove it completely */\n\tif (_invlist_len(*invlist_ptr) == 0) {\n\t SvREFCNT_dec_NN(*invlist_ptr);\n\t *invlist_ptr = NULL;\n\t}\n }\n}\n\n/* Parse POSIX character classes: [[:foo:]], [[=foo=]], [[.foo.]].\n Character classes ([:foo:]) can also be negated ([:^foo:]).\n Returns a named class id (ANYOF_XXX) if successful, -1 otherwise.\n Equivalence classes ([=foo=]) and composites ([.foo.]) are parsed,\n but trigger failures because they are currently unimplemented. */\n\n#define POSIXCC_DONE(c) ((c) == ':')\n#define POSIXCC_NOTYET(c) ((c) == '=' || (c) == '.')\n#define POSIXCC(c) (POSIXCC_DONE(c) || POSIXCC_NOTYET(c))\n#define MAYBE_POSIXCC(c) (POSIXCC(c) || (c) == '^' || (c) == ';')\n\n#define WARNING_PREFIX \"Assuming NOT a POSIX class since \"\n#define NO_BLANKS_POSIX_WARNING \"no blanks are allowed in one\"\n#define SEMI_COLON_POSIX_WARNING \"a semi-colon was found instead of a colon\"\n\n#define NOT_MEANT_TO_BE_A_POSIX_CLASS (OOB_NAMEDCLASS - 1)\n\n/* 'posix_warnings' and 'warn_text' are names of variables in the following\n * routine. q.v. */\n#define ADD_POSIX_WARNING(p, text) STMT_START { \\\n if (posix_warnings) { \\\n if (! RExC_warn_text ) RExC_warn_text = (AV *) sv_2mortal((SV *) newAV()); \\\n av_push(RExC_warn_text, Perl_newSVpvf(aTHX_ \\\n WARNING_PREFIX \\\n text \\\n REPORT_LOCATION, \\\n REPORT_LOCATION_ARGS(p))); \\\n } \\\n } STMT_END\n#define CLEAR_POSIX_WARNINGS() \\\n STMT_START { \\\n if (posix_warnings && RExC_warn_text) \\\n av_clear(RExC_warn_text); \\\n } STMT_END\n\n#define CLEAR_POSIX_WARNINGS_AND_RETURN(ret) \\\n STMT_START { \\\n CLEAR_POSIX_WARNINGS(); \\\n return ret; \\\n } STMT_END\n\nSTATIC int\nS_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state,\n\n const char * const s, /* Where the putative posix class begins.\n Normally, this is one past the '['. This\n parameter exists so it can be somewhere\n besides RExC_parse. */\n char ** updated_parse_ptr, /* Where to set the updated parse pointer, or\n NULL */\n AV ** posix_warnings, /* Where to place any generated warnings, or\n NULL */\n const bool check_only /* Don't die if error */\n)\n{\n /* This parses what the caller thinks may be one of the three POSIX\n * constructs:\n * 1) a character class, like [:blank:]\n * 2) a collating symbol, like [. .]\n * 3) an equivalence class, like [= =]\n * In the latter two cases, it croaks if it finds a syntactically legal\n * one, as these are not handled by Perl.\n *\n * The main purpose is to look for a POSIX character class. It returns:\n * a) the class number\n * if it is a completely syntactically and semantically legal class.\n * 'updated_parse_ptr', if not NULL, is set to point to just after the\n * closing ']' of the class\n * b) OOB_NAMEDCLASS\n * if it appears that one of the three POSIX constructs was meant, but\n * its specification was somehow defective. 'updated_parse_ptr', if\n * not NULL, is set to point to the character just after the end\n * character of the class. See below for handling of warnings.\n * c) NOT_MEANT_TO_BE_A_POSIX_CLASS\n * if it doesn't appear that a POSIX construct was intended.\n * 'updated_parse_ptr' is not changed. No warnings nor errors are\n * raised.\n *\n * In b) there may be errors or warnings generated. If 'check_only' is\n * TRUE, then any errors are discarded. Warnings are returned to the\n * caller via an AV* created into '*posix_warnings' if it is not NULL. If\n * instead it is NULL, warnings are suppressed. This is done in all\n * passes. The reason for this is that the rest of the parsing is heavily\n * dependent on whether this routine found a valid posix class or not. If\n * it did, the closing ']' is absorbed as part of the class. If no class,\n * or an invalid one is found, any ']' will be considered the terminator of\n * the outer bracketed character class, leading to very different results.\n * In particular, a '(?[ ])' construct will likely have a syntax error if\n * the class is parsed other than intended, and this will happen in pass1,\n * before the warnings would normally be output. This mechanism allows the\n * caller to output those warnings in pass1 just before dieing, giving a\n * much better clue as to what is wrong.\n *\n * The reason for this function, and its complexity is that a bracketed\n * character class can contain just about anything. But it's easy to\n * mistype the very specific posix class syntax but yielding a valid\n * regular bracketed class, so it silently gets compiled into something\n * quite unintended.\n *\n * The solution adopted here maintains backward compatibility except that\n * it adds a warning if it looks like a posix class was intended but\n * improperly specified. The warning is not raised unless what is input\n * very closely resembles one of the 14 legal posix classes. To do this,\n * it uses fuzzy parsing. It calculates how many single-character edits it\n * would take to transform what was input into a legal posix class. Only\n * if that number is quite small does it think that the intention was a\n * posix class. Obviously these are heuristics, and there will be cases\n * where it errs on one side or another, and they can be tweaked as\n * experience informs.\n *\n * The syntax for a legal posix class is:\n *\n * qr/(?xa: \\[ : \\^? [[:lower:]]{4,6} : \\] )/\n *\n * What this routine considers syntactically to be an intended posix class\n * is this (the comments indicate some restrictions that the pattern\n * doesn't show):\n *\n * qr/(?x: \\[? # The left bracket, possibly\n * # omitted\n * \\h* # possibly followed by blanks\n * (?: \\^ \\h* )? # possibly a misplaced caret\n * [:;]? # The opening class character,\n * # possibly omitted. A typo\n * # semi-colon can also be used.\n * \\h*\n * \\^? # possibly a correctly placed\n * # caret, but not if there was also\n * # a misplaced one\n * \\h*\n * .{3,15} # The class name. If there are\n * # deviations from the legal syntax,\n * # its edit distance must be close\n * # to a real class name in order\n * # for it to be considered to be\n * # an intended posix class.\n * \\h*\n * [[:punct:]]? # The closing class character,\n * # possibly omitted. If not a colon\n * # nor semi colon, the class name\n * # must be even closer to a valid\n * # one\n * \\h*\n * \\]? # The right bracket, possibly\n * # omitted.\n * )/\n *\n * In the above, \\h must be ASCII-only.\n *\n * These are heuristics, and can be tweaked as field experience dictates.\n * There will be cases when someone didn't intend to specify a posix class\n * that this warns as being so. The goal is to minimize these, while\n * maximizing the catching of things intended to be a posix class that\n * aren't parsed as such.\n */\n\n const char* p = s;\n const char * const e = RExC_end;\n unsigned complement = 0; /* If to complement the class */\n bool found_problem = FALSE; /* Assume OK until proven otherwise */\n bool has_opening_bracket = FALSE;\n bool has_opening_colon = FALSE;\n int class_number = OOB_NAMEDCLASS; /* Out-of-bounds until find\n valid class */\n const char * possible_end = NULL; /* used for a 2nd parse pass */\n const char* name_start; /* ptr to class name first char */\n\n /* If the number of single-character typos the input name is away from a\n * legal name is no more than this number, it is considered to have meant\n * the legal name */\n int max_distance = 2;\n\n /* to store the name. The size determines the maximum length before we\n * decide that no posix class was intended. Should be at least\n * sizeof(\"alphanumeric\") */\n UV input_text[15];\n STATIC_ASSERT_DECL(C_ARRAY_LENGTH(input_text) >= sizeof \"alphanumeric\");\n\n PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX;\n\n CLEAR_POSIX_WARNINGS();\n\n if (p >= e) {\n return NOT_MEANT_TO_BE_A_POSIX_CLASS;\n }\n\n if (*(p - 1) != '[') {\n ADD_POSIX_WARNING(p, \"it doesn't start with a '['\");\n found_problem = TRUE;\n }\n else {\n has_opening_bracket = TRUE;\n }\n\n /* They could be confused and think you can put spaces between the\n * components */\n if (isBLANK(*p)) {\n found_problem = TRUE;\n\n do {\n p++;\n } while (p < e && isBLANK(*p));\n\n ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);\n }\n\n /* For [. .] and [= =]. These are quite different internally from [: :],\n * so they are handled separately. */\n if (POSIXCC_NOTYET(*p) && p < e - 3) /* 1 for the close, and 1 for the ']'\n and 1 for at least one char in it\n */\n {\n const char open_char = *p;\n const char * temp_ptr = p + 1;\n\n /* These two constructs are not handled by perl, and if we find a\n * syntactically valid one, we croak. khw, who wrote this code, finds\n * this explanation of them very unclear:\n * http://pubs.opengroup.org/onlinepubs/009696899/basedefs/xbd_chap09.html\n * And searching the rest of the internet wasn't very helpful either.\n * It looks like just about any byte can be in these constructs,\n * depending on the locale. But unless the pattern is being compiled\n * under /l, which is very rare, Perl runs under the C or POSIX locale.\n * In that case, it looks like [= =] isn't allowed at all, and that\n * [. .] could be any single code point, but for longer strings the\n * constituent characters would have to be the ASCII alphabetics plus\n * the minus-hyphen. Any sensible locale definition would limit itself\n * to these. And any portable one definitely should. Trying to parse\n * the general case is a nightmare (see [perl #127604]). So, this code\n * looks only for interiors of these constructs that match:\n * qr/.|[-\\w]{2,}/\n * Using \\w relaxes the apparent rules a little, without adding much\n * danger of mistaking something else for one of these constructs.\n *\n * [. .] in some implementations described on the internet is usable to\n * escape a character that otherwise is special in bracketed character\n * classes. For example [.].] means a literal right bracket instead of\n * the ending of the class\n *\n * [= =] can legitimately contain a [. .] construct, but we don't\n * handle this case, as that [. .] construct will later get parsed\n * itself and croak then. And [= =] is checked for even when not under\n * /l, as Perl has long done so.\n *\n * The code below relies on there being a trailing NUL, so it doesn't\n * have to keep checking if the parse ptr < e.\n */\n if (temp_ptr[1] == open_char) {\n temp_ptr++;\n }\n else while ( temp_ptr < e\n && (isWORDCHAR(*temp_ptr) || *temp_ptr == '-'))\n {\n temp_ptr++;\n }\n\n if (*temp_ptr == open_char) {\n temp_ptr++;\n if (*temp_ptr == ']') {\n temp_ptr++;\n if (! found_problem && ! check_only) {\n RExC_parse = (char *) temp_ptr;\n vFAIL3(\"POSIX syntax [%c %c] is reserved for future \"\n \"extensions\", open_char, open_char);\n }\n\n /* Here, the syntax wasn't completely valid, or else the call\n * is to check-only */\n if (updated_parse_ptr) {\n *updated_parse_ptr = (char *) temp_ptr;\n }\n\n CLEAR_POSIX_WARNINGS_AND_RETURN(OOB_NAMEDCLASS);\n }\n }\n\n /* If we find something that started out to look like one of these\n * constructs, but isn't, we continue below so that it can be checked\n * for being a class name with a typo of '.' or '=' instead of a colon.\n * */\n }\n\n /* Here, we think there is a possibility that a [: :] class was meant, and\n * we have the first real character. It could be they think the '^' comes\n * first */\n if (*p == '^') {\n found_problem = TRUE;\n ADD_POSIX_WARNING(p + 1, \"the '^' must come after the colon\");\n complement = 1;\n p++;\n\n if (isBLANK(*p)) {\n found_problem = TRUE;\n\n do {\n p++;\n } while (p < e && isBLANK(*p));\n\n ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);\n }\n }\n\n /* But the first character should be a colon, which they could have easily\n * mistyped on a qwerty keyboard as a semi-colon (and which may be hard to\n * distinguish from a colon, so treat that as a colon). */\n if (*p == ':') {\n p++;\n has_opening_colon = TRUE;\n }\n else if (*p == ';') {\n found_problem = TRUE;\n p++;\n ADD_POSIX_WARNING(p, SEMI_COLON_POSIX_WARNING);\n has_opening_colon = TRUE;\n }\n else {\n found_problem = TRUE;\n ADD_POSIX_WARNING(p, \"there must be a starting ':'\");\n\n /* Consider an initial punctuation (not one of the recognized ones) to\n * be a left terminator */\n if (*p != '^' && *p != ']' && isPUNCT(*p)) {\n p++;\n }\n }\n\n /* They may think that you can put spaces between the components */\n if (isBLANK(*p)) {\n found_problem = TRUE;\n\n do {\n p++;\n } while (p < e && isBLANK(*p));\n\n ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);\n }\n\n if (*p == '^') {\n\n /* We consider something like [^:^alnum:]] to not have been intended to\n * be a posix class, but XXX maybe we should */\n if (complement) {\n CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);\n }\n\n complement = 1;\n p++;\n }\n\n /* Again, they may think that you can put spaces between the components */\n if (isBLANK(*p)) {\n found_problem = TRUE;\n\n do {\n p++;\n } while (p < e && isBLANK(*p));\n\n ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);\n }\n\n if (*p == ']') {\n\n /* XXX This ']' may be a typo, and something else was meant. But\n * treating it as such creates enough complications, that that\n * possibility isn't currently considered here. So we assume that the\n * ']' is what is intended, and if we've already found an initial '[',\n * this leaves this construct looking like [:] or [:^], which almost\n * certainly weren't intended to be posix classes */\n if (has_opening_bracket) {\n CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);\n }\n\n /* But this function can be called when we parse the colon for\n * something like qr/[alpha:]]/, so we back up to look for the\n * beginning */\n p--;\n\n if (*p == ';') {\n found_problem = TRUE;\n ADD_POSIX_WARNING(p, SEMI_COLON_POSIX_WARNING);\n }\n else if (*p != ':') {\n\n /* XXX We are currently very restrictive here, so this code doesn't\n * consider the possibility that, say, /[alpha.]]/ was intended to\n * be a posix class. */\n CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);\n }\n\n /* Here we have something like 'foo:]'. There was no initial colon,\n * and we back up over 'foo. XXX Unlike the going forward case, we\n * don't handle typos of non-word chars in the middle */\n has_opening_colon = FALSE;\n p--;\n\n while (p > RExC_start && isWORDCHAR(*p)) {\n p--;\n }\n p++;\n\n /* Here, we have positioned ourselves to where we think the first\n * character in the potential class is */\n }\n\n /* Now the interior really starts. There are certain key characters that\n * can end the interior, or these could just be typos. To catch both\n * cases, we may have to do two passes. In the first pass, we keep on\n * going unless we come to a sequence that matches\n * qr/ [[:punct:]] [[:blank:]]* \\] /xa\n * This means it takes a sequence to end the pass, so two typos in a row if\n * that wasn't what was intended. If the class is perfectly formed, just\n * this one pass is needed. We also stop if there are too many characters\n * being accumulated, but this number is deliberately set higher than any\n * real class. It is set high enough so that someone who thinks that\n * 'alphanumeric' is a correct name would get warned that it wasn't.\n * While doing the pass, we keep track of where the key characters were in\n * it. If we don't find an end to the class, and one of the key characters\n * was found, we redo the pass, but stop when we get to that character.\n * Thus the key character was considered a typo in the first pass, but a\n * terminator in the second. If two key characters are found, we stop at\n * the second one in the first pass. Again this can miss two typos, but\n * catches a single one\n *\n * In the first pass, 'possible_end' starts as NULL, and then gets set to\n * point to the first key character. For the second pass, it starts as -1.\n * */\n\n name_start = p;\n parse_name:\n {\n bool has_blank = FALSE;\n bool has_upper = FALSE;\n bool has_terminating_colon = FALSE;\n bool has_terminating_bracket = FALSE;\n bool has_semi_colon = FALSE;\n unsigned int name_len = 0;\n int punct_count = 0;\n\n while (p < e) {\n\n /* Squeeze out blanks when looking up the class name below */\n if (isBLANK(*p) ) {\n has_blank = TRUE;\n found_problem = TRUE;\n p++;\n continue;\n }\n\n /* The name will end with a punctuation */\n if (isPUNCT(*p)) {\n const char * peek = p + 1;\n\n /* Treat any non-']' punctuation followed by a ']' (possibly\n * with intervening blanks) as trying to terminate the class.\n * ']]' is very likely to mean a class was intended (but\n * missing the colon), but the warning message that gets\n * generated shows the error position better if we exit the\n * loop at the bottom (eventually), so skip it here. */\n if (*p != ']') {\n if (peek < e && isBLANK(*peek)) {\n has_blank = TRUE;\n found_problem = TRUE;\n do {\n peek++;\n } while (peek < e && isBLANK(*peek));\n }\n\n if (peek < e && *peek == ']') {\n has_terminating_bracket = TRUE;\n if (*p == ':') {\n has_terminating_colon = TRUE;\n }\n else if (*p == ';') {\n has_semi_colon = TRUE;\n has_terminating_colon = TRUE;\n }\n else {\n found_problem = TRUE;\n }\n p = peek + 1;\n goto try_posix;\n }\n }\n\n /* Here we have punctuation we thought didn't end the class.\n * Keep track of the position of the key characters that are\n * more likely to have been class-enders */\n if (*p == ']' || *p == '[' || *p == ':' || *p == ';') {\n\n /* Allow just one such possible class-ender not actually\n * ending the class. */\n if (possible_end) {\n break;\n }\n possible_end = p;\n }\n\n /* If we have too many punctuation characters, no use in\n * keeping going */\n if (++punct_count > max_distance) {\n break;\n }\n\n /* Treat the punctuation as a typo. */\n input_text[name_len++] = *p;\n p++;\n }\n else if (isUPPER(*p)) { /* Use lowercase for lookup */\n input_text[name_len++] = toLOWER(*p);\n has_upper = TRUE;\n found_problem = TRUE;\n p++;\n } else if (! UTF || UTF8_IS_INVARIANT(*p)) {\n input_text[name_len++] = *p;\n p++;\n }\n else {\n input_text[name_len++] = utf8_to_uvchr_buf((U8 *) p, e, NULL);\n p+= UTF8SKIP(p);\n }\n\n /* The declaration of 'input_text' is how long we allow a potential\n * class name to be, before saying they didn't mean a class name at\n * all */\n if (name_len >= C_ARRAY_LENGTH(input_text)) {\n break;\n }\n }\n\n /* We get to here when the possible class name hasn't been properly\n * terminated before:\n * 1) we ran off the end of the pattern; or\n * 2) found two characters, each of which might have been intended to\n * be the name's terminator\n * 3) found so many punctuation characters in the purported name,\n * that the edit distance to a valid one is exceeded\n * 4) we decided it was more characters than anyone could have\n * intended to be one. */\n\n found_problem = TRUE;\n\n /* In the final two cases, we know that looking up what we've\n * accumulated won't lead to a match, even a fuzzy one. */\n if ( name_len >= C_ARRAY_LENGTH(input_text)\n || punct_count > max_distance)\n {\n /* If there was an intermediate key character that could have been\n * an intended end, redo the parse, but stop there */\n if (possible_end && possible_end != (char *) -1) {\n possible_end = (char *) -1; /* Special signal value to say\n we've done a first pass */\n p = name_start;\n goto parse_name;\n }\n\n /* Otherwise, it can't have meant to have been a class */\n CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);\n }\n\n /* If we ran off the end, and the final character was a punctuation\n * one, back up one, to look at that final one just below. Later, we\n * will restore the parse pointer if appropriate */\n if (name_len && p == e && isPUNCT(*(p-1))) {\n p--;\n name_len--;\n }\n\n if (p < e && isPUNCT(*p)) {\n if (*p == ']') {\n has_terminating_bracket = TRUE;\n\n /* If this is a 2nd ']', and the first one is just below this\n * one, consider that to be the real terminator. This gives a\n * uniform and better positioning for the warning message */\n if ( possible_end\n && possible_end != (char *) -1\n && *possible_end == ']'\n && name_len && input_text[name_len - 1] == ']')\n {\n name_len--;\n p = possible_end;\n\n /* And this is actually equivalent to having done the 2nd\n * pass now, so set it to not try again */\n possible_end = (char *) -1;\n }\n }\n else {\n if (*p == ':') {\n has_terminating_colon = TRUE;\n }\n else if (*p == ';') {\n has_semi_colon = TRUE;\n has_terminating_colon = TRUE;\n }\n p++;\n }\n }\n\n try_posix:\n\n /* Here, we have a class name to look up. We can short circuit the\n * stuff below for short names that can't possibly be meant to be a\n * class name. (We can do this on the first pass, as any second pass\n * will yield an even shorter name) */\n if (name_len < 3) {\n CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);\n }\n\n /* Find which class it is. Initially switch on the length of the name.\n * */\n switch (name_len) {\n case 4:\n if (memEQs(name_start, 4, \"word\")) {\n /* this is not POSIX, this is the Perl \\w */\n class_number = ANYOF_WORDCHAR;\n }\n break;\n case 5:\n /* Names all of length 5: alnum alpha ascii blank cntrl digit\n * graph lower print punct space upper\n * Offset 4 gives the best switch position. */\n switch (name_start[4]) {\n case 'a':\n if (memBEGINs(name_start, 5, \"alph\")) /* alpha */\n class_number = ANYOF_ALPHA;\n break;\n case 'e':\n if (memBEGINs(name_start, 5, \"spac\")) /* space */\n class_number = ANYOF_SPACE;\n break;\n case 'h':\n if (memBEGINs(name_start, 5, \"grap\")) /* graph */\n class_number = ANYOF_GRAPH;\n break;\n case 'i':\n if (memBEGINs(name_start, 5, \"asci\")) /* ascii */\n class_number = ANYOF_ASCII;\n break;\n case 'k':\n if (memBEGINs(name_start, 5, \"blan\")) /* blank */\n class_number = ANYOF_BLANK;\n break;\n case 'l':\n if (memBEGINs(name_start, 5, \"cntr\")) /* cntrl */\n class_number = ANYOF_CNTRL;\n break;\n case 'm':\n if (memBEGINs(name_start, 5, \"alnu\")) /* alnum */\n class_number = ANYOF_ALPHANUMERIC;\n break;\n case 'r':\n if (memBEGINs(name_start, 5, \"lowe\")) /* lower */\n class_number = (FOLD) ? ANYOF_CASED : ANYOF_LOWER;\n else if (memBEGINs(name_start, 5, \"uppe\")) /* upper */\n class_number = (FOLD) ? ANYOF_CASED : ANYOF_UPPER;\n break;\n case 't':\n if (memBEGINs(name_start, 5, \"digi\")) /* digit */\n class_number = ANYOF_DIGIT;\n else if (memBEGINs(name_start, 5, \"prin\")) /* print */\n class_number = ANYOF_PRINT;\n else if (memBEGINs(name_start, 5, \"punc\")) /* punct */\n class_number = ANYOF_PUNCT;\n break;\n }\n break;\n case 6:\n if (memEQs(name_start, 6, \"xdigit\"))\n class_number = ANYOF_XDIGIT;\n break;\n }\n\n /* If the name exactly matches a posix class name the class number will\n * here be set to it, and the input almost certainly was meant to be a\n * posix class, so we can skip further checking. If instead the syntax\n * is exactly correct, but the name isn't one of the legal ones, we\n * will return that as an error below. But if neither of these apply,\n * it could be that no posix class was intended at all, or that one\n * was, but there was a typo. We tease these apart by doing fuzzy\n * matching on the name */\n if (class_number == OOB_NAMEDCLASS && found_problem) {\n const UV posix_names[][6] = {\n { 'a', 'l', 'n', 'u', 'm' },\n { 'a', 'l', 'p', 'h', 'a' },\n { 'a', 's', 'c', 'i', 'i' },\n { 'b', 'l', 'a', 'n', 'k' },\n { 'c', 'n', 't', 'r', 'l' },\n { 'd', 'i', 'g', 'i', 't' },\n { 'g', 'r', 'a', 'p', 'h' },\n { 'l', 'o', 'w', 'e', 'r' },\n { 'p', 'r', 'i', 'n', 't' },\n { 'p', 'u', 'n', 'c', 't' },\n { 's', 'p', 'a', 'c', 'e' },\n { 'u', 'p', 'p', 'e', 'r' },\n { 'w', 'o', 'r', 'd' },\n { 'x', 'd', 'i', 'g', 'i', 't' }\n };\n /* The names of the above all have added NULs to make them the same\n * size, so we need to also have the real lengths */\n const UV posix_name_lengths[] = {\n sizeof(\"alnum\") - 1,\n sizeof(\"alpha\") - 1,\n sizeof(\"ascii\") - 1,\n sizeof(\"blank\") - 1,\n sizeof(\"cntrl\") - 1,\n sizeof(\"digit\") - 1,\n sizeof(\"graph\") - 1,\n sizeof(\"lower\") - 1,\n sizeof(\"print\") - 1,\n sizeof(\"punct\") - 1,\n sizeof(\"space\") - 1,\n sizeof(\"upper\") - 1,\n sizeof(\"word\") - 1,\n sizeof(\"xdigit\")- 1\n };\n unsigned int i;\n int temp_max = max_distance; /* Use a temporary, so if we\n reparse, we haven't changed the\n outer one */\n\n /* Use a smaller max edit distance if we are missing one of the\n * delimiters */\n if ( has_opening_bracket + has_opening_colon < 2\n || has_terminating_bracket + has_terminating_colon < 2)\n {\n temp_max--;\n }\n\n /* See if the input name is close to a legal one */\n for (i = 0; i < C_ARRAY_LENGTH(posix_names); i++) {\n\n /* Short circuit call if the lengths are too far apart to be\n * able to match */\n if (abs( (int) (name_len - posix_name_lengths[i]))\n > temp_max)\n {\n continue;\n }\n\n if (edit_distance(input_text,\n posix_names[i],\n name_len,\n posix_name_lengths[i],\n temp_max\n )\n > -1)\n { /* If it is close, it probably was intended to be a class */\n goto probably_meant_to_be;\n }\n }\n\n /* Here the input name is not close enough to a valid class name\n * for us to consider it to be intended to be a posix class. If\n * we haven't already done so, and the parse found a character that\n * could have been terminators for the name, but which we absorbed\n * as typos during the first pass, repeat the parse, signalling it\n * to stop at that character */\n if (possible_end && possible_end != (char *) -1) {\n possible_end = (char *) -1;\n p = name_start;\n goto parse_name;\n }\n\n /* Here neither pass found a close-enough class name */\n CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);\n }\n\n probably_meant_to_be:\n\n /* Here we think that a posix specification was intended. Update any\n * parse pointer */\n if (updated_parse_ptr) {\n *updated_parse_ptr = (char *) p;\n }\n\n /* If a posix class name was intended but incorrectly specified, we\n * output or return the warnings */\n if (found_problem) {\n\n /* We set flags for these issues in the parse loop above instead of\n * adding them to the list of warnings, because we can parse it\n * twice, and we only want one warning instance */\n if (has_upper) {\n ADD_POSIX_WARNING(p, \"the name must be all lowercase letters\");\n }\n if (has_blank) {\n ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);\n }\n if (has_semi_colon) {\n ADD_POSIX_WARNING(p, SEMI_COLON_POSIX_WARNING);\n }\n else if (! has_terminating_colon) {\n ADD_POSIX_WARNING(p, \"there is no terminating ':'\");\n }\n if (! has_terminating_bracket) {\n ADD_POSIX_WARNING(p, \"there is no terminating ']'\");\n }\n\n if (posix_warnings && RExC_warn_text && av_top_index(RExC_warn_text) > -1) {\n *posix_warnings = RExC_warn_text;\n }\n }\n else if (class_number != OOB_NAMEDCLASS) {\n /* If it is a known class, return the class. The class number\n * #defines are structured so each complement is +1 to the normal\n * one */\n CLEAR_POSIX_WARNINGS_AND_RETURN(class_number + complement);\n }\n else if (! check_only) {\n\n /* Here, it is an unrecognized class. This is an error (unless the\n * call is to check only, which we've already handled above) */\n const char * const complement_string = (complement)\n ? \"^\"\n : \"\";\n RExC_parse = (char *) p;\n vFAIL3utf8f(\"POSIX class [:%s%\" UTF8f \":] unknown\",\n complement_string,\n UTF8fARG(UTF, RExC_parse - name_start - 2, name_start));\n }\n }\n\n return OOB_NAMEDCLASS;\n}\n#undef ADD_POSIX_WARNING\n\nSTATIC unsigned int\nS_regex_set_precedence(const U8 my_operator) {\n\n /* Returns the precedence in the (?[...]) construct of the input operator,\n * specified by its character representation. The precedence follows\n * general Perl rules, but it extends this so that ')' and ']' have (low)\n * precedence even though they aren't really operators */\n\n switch (my_operator) {\n case '!':\n return 5;\n case '&':\n return 4;\n case '^':\n case '|':\n case '+':\n case '-':\n return 3;\n case ')':\n return 2;\n case ']':\n return 1;\n }\n\n NOT_REACHED; /* NOTREACHED */\n return 0; /* Silence compiler warning */\n}\n\nSTATIC regnode *\nS_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV** return_invlist,\n I32 *flagp, U32 depth,\n char * const oregcomp_parse)\n{\n /* Handle the (?[...]) construct to do set operations */\n\n U8 curchar; /* Current character being parsed */\n UV start, end;\t /* End points of code point ranges */\n SV* final = NULL; /* The end result inversion list */\n SV* result_string; /* 'final' stringified */\n AV* stack; /* stack of operators and operands not yet\n resolved */\n AV* fence_stack = NULL; /* A stack containing the positions in\n 'stack' of where the undealt-with left\n parens would be if they were actually\n put there */\n /* The 'volatile' is a workaround for an optimiser bug\n * in Solaris Studio 12.3. See RT #127455 */\n volatile IV fence = 0; /* Position of where most recent undealt-\n with left paren in stack is; -1 if none.\n */\n STRLEN len; /* Temporary */\n regnode* node; /* Temporary, and final regnode returned by\n this function */\n const bool save_fold = FOLD; /* Temporary */\n char *save_end, *save_parse; /* Temporaries */\n const bool in_locale = LOC; /* we turn off /l during processing */\n AV* posix_warnings = NULL;\n\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_HANDLE_REGEX_SETS;\n\n DEBUG_PARSE(\"xcls\");\n\n if (in_locale) {\n set_regex_charset(&RExC_flags, REGEX_UNICODE_CHARSET);\n }\n\n REQUIRE_UNI_RULES(flagp, NULL); /* The use of this operator implies /u.\n This is required so that the compile\n time values are valid in all runtime\n cases */\n\n /* This will return only an ANYOF regnode, or (unlikely) something smaller\n * (such as EXACT). Thus we can skip most everything if just sizing. We\n * call regclass to handle '[]' so as to not have to reinvent its parsing\n * rules here (throwing away the size it computes each time). And, we exit\n * upon an unescaped ']' that isn't one ending a regclass. To do both\n * these things, we need to realize that something preceded by a backslash\n * is escaped, so we have to keep track of backslashes */\n if (SIZE_ONLY) {\n UV nest_depth = 0; /* how many nested (?[...]) constructs */\n\n while (RExC_parse < RExC_end) {\n SV* current = NULL;\n\n skip_to_be_ignored_text(pRExC_state, &RExC_parse,\n TRUE /* Force /x */ );\n\n switch (*RExC_parse) {\n case '(':\n if (RExC_parse[1] == '?' && RExC_parse[2] == '[')\n nest_depth++, RExC_parse+=2;\n /* FALLTHROUGH */\n default:\n break;\n case '\\\\':\n /* Skip past this, so the next character gets skipped, after\n * the switch */\n RExC_parse++;\n if (*RExC_parse == 'c') {\n /* Skip the \\cX notation for control characters */\n RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n }\n break;\n\n case '[':\n {\n /* See if this is a [:posix:] class. */\n bool is_posix_class = (OOB_NAMEDCLASS\n < handle_possible_posix(pRExC_state,\n RExC_parse + 1,\n NULL,\n NULL,\n TRUE /* checking only */));\n /* If it is a posix class, leave the parse pointer at the\n * '[' to fool regclass() into thinking it is part of a\n * '[[:posix:]]'. */\n if (! is_posix_class) {\n RExC_parse++;\n }\n\n /* regclass() can only return RESTART_PASS1 and NEED_UTF8\n * if multi-char folds are allowed. */\n if (!regclass(pRExC_state, flagp,depth+1,\n is_posix_class, /* parse the whole char\n class only if not a\n posix class */\n FALSE, /* don't allow multi-char folds */\n TRUE, /* silence non-portable warnings. */\n TRUE, /* strict */\n FALSE, /* Require return to be an ANYOF */\n ¤t,\n &posix_warnings\n ))\n FAIL2(\"panic: regclass returned NULL to handle_sets, \"\n \"flags=%#\" UVxf, (UV) *flagp);\n\n /* function call leaves parse pointing to the ']', except\n * if we faked it */\n if (is_posix_class) {\n RExC_parse--;\n }\n\n SvREFCNT_dec(current); /* In case it returned something */\n break;\n }\n\n case ']':\n if (RExC_parse[1] == ')') {\n RExC_parse++;\n if (nest_depth--) break;\n node = reganode(pRExC_state, ANYOF, 0);\n RExC_size += ANYOF_SKIP;\n nextchar(pRExC_state);\n Set_Node_Length(node,\n RExC_parse - oregcomp_parse + 1); /* MJD */\n if (in_locale) {\n set_regex_charset(&RExC_flags, REGEX_LOCALE_CHARSET);\n }\n\n return node;\n }\n /* We output the messages even if warnings are off, because we'll fail\n * the very next thing, and these give a likely diagnosis for that */\n if (posix_warnings && av_tindex_skip_len_mg(posix_warnings) >= 0) {\n output_or_return_posix_warnings(pRExC_state, posix_warnings, NULL);\n }\n RExC_parse++;\n vFAIL(\"Unexpected ']' with no following ')' in (?[...\");\n }\n\n RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;\n }\n\n /* We output the messages even if warnings are off, because we'll fail\n * the very next thing, and these give a likely diagnosis for that */\n if (posix_warnings && av_tindex_skip_len_mg(posix_warnings) >= 0) {\n output_or_return_posix_warnings(pRExC_state, posix_warnings, NULL);\n }\n\n vFAIL(\"Syntax error in (?[...])\");\n }\n\n /* Pass 2 only after this. */\n Perl_ck_warner_d(aTHX_\n packWARN(WARN_EXPERIMENTAL__REGEX_SETS),\n \"The regex_sets feature is experimental\" REPORT_LOCATION,\n REPORT_LOCATION_ARGS(RExC_parse));\n\n /* Everything in this construct is a metacharacter. Operands begin with\n * either a '\\' (for an escape sequence), or a '[' for a bracketed\n * character class. Any other character should be an operator, or\n * parenthesis for grouping. Both types of operands are handled by calling\n * regclass() to parse them. It is called with a parameter to indicate to\n * return the computed inversion list. The parsing here is implemented via\n * a stack. Each entry on the stack is a single character representing one\n * of the operators; or else a pointer to an operand inversion list. */\n\n#define IS_OPERATOR(a) SvIOK(a)\n#define IS_OPERAND(a) (! IS_OPERATOR(a))\n\n /* The stack is kept in Łukasiewicz order. (That's pronounced similar\n * to luke-a-shave-itch (or -itz), but people who didn't want to bother\n * with pronouncing it called it Reverse Polish instead, but now that YOU\n * know how to pronounce it you can use the correct term, thus giving due\n * credit to the person who invented it, and impressing your geek friends.\n * Wikipedia says that the pronounciation of \"Ł\" has been changing so that\n * it is now more like an English initial W (as in wonk) than an L.)\n *\n * This means that, for example, 'a | b & c' is stored on the stack as\n *\n * c [4]\n * b [3]\n * & [2]\n * a [1]\n * | [0]\n *\n * where the numbers in brackets give the stack [array] element number.\n * In this implementation, parentheses are not stored on the stack.\n * Instead a '(' creates a \"fence\" so that the part of the stack below the\n * fence is invisible except to the corresponding ')' (this allows us to\n * replace testing for parens, by using instead subtraction of the fence\n * position). As new operands are processed they are pushed onto the stack\n * (except as noted in the next paragraph). New operators of higher\n * precedence than the current final one are inserted on the stack before\n * the lhs operand (so that when the rhs is pushed next, everything will be\n * in the correct positions shown above. When an operator of equal or\n * lower precedence is encountered in parsing, all the stacked operations\n * of equal or higher precedence are evaluated, leaving the result as the\n * top entry on the stack. This makes higher precedence operations\n * evaluate before lower precedence ones, and causes operations of equal\n * precedence to left associate.\n *\n * The only unary operator '!' is immediately pushed onto the stack when\n * encountered. When an operand is encountered, if the top of the stack is\n * a '!\", the complement is immediately performed, and the '!' popped. The\n * resulting value is treated as a new operand, and the logic in the\n * previous paragraph is executed. Thus in the expression\n * [a] + ! [b]\n * the stack looks like\n *\n * !\n * a\n * +\n *\n * as 'b' gets parsed, the latter gets evaluated to '!b', and the stack\n * becomes\n *\n * !b\n * a\n * +\n *\n * A ')' is treated as an operator with lower precedence than all the\n * aforementioned ones, which causes all operations on the stack above the\n * corresponding '(' to be evaluated down to a single resultant operand.\n * Then the fence for the '(' is removed, and the operand goes through the\n * algorithm above, without the fence.\n *\n * A separate stack is kept of the fence positions, so that the position of\n * the latest so-far unbalanced '(' is at the top of it.\n *\n * The ']' ending the construct is treated as the lowest operator of all,\n * so that everything gets evaluated down to a single operand, which is the\n * result */\n\n sv_2mortal((SV *)(stack = newAV()));\n sv_2mortal((SV *)(fence_stack = newAV()));\n\n while (RExC_parse < RExC_end) {\n I32 top_index; /* Index of top-most element in 'stack' */\n SV** top_ptr; /* Pointer to top 'stack' element */\n SV* current = NULL; /* To contain the current inversion list\n operand */\n SV* only_to_avoid_leaks;\n\n skip_to_be_ignored_text(pRExC_state, &RExC_parse,\n TRUE /* Force /x */ );\n if (RExC_parse >= RExC_end) {\n Perl_croak(aTHX_ \"panic: Read past end of '(?[ ])'\");\n }\n\n curchar = UCHARAT(RExC_parse);\n\nredo_curchar:\n\n#ifdef ENABLE_REGEX_SETS_DEBUGGING\n /* Enable with -Accflags=-DENABLE_REGEX_SETS_DEBUGGING */\n DEBUG_U(dump_regex_sets_structures(pRExC_state,\n stack, fence, fence_stack));\n#endif\n\n top_index = av_tindex_skip_len_mg(stack);\n\n switch (curchar) {\n SV** stacked_ptr; /* Ptr to something already on 'stack' */\n char stacked_operator; /* The topmost operator on the 'stack'. */\n SV* lhs; /* Operand to the left of the operator */\n SV* rhs; /* Operand to the right of the operator */\n SV* fence_ptr; /* Pointer to top element of the fence\n stack */\n\n case '(':\n\n if ( RExC_parse < RExC_end - 1\n && (UCHARAT(RExC_parse + 1) == '?'))\n {\n /* If is a '(?', could be an embedded '(?flags:(?[...])'.\n * This happens when we have some thing like\n *\n * my $thai_or_lao = qr/(?[ \\p{Thai} + \\p{Lao} ])/;\n * ...\n * qr/(?[ \\p{Digit} & $thai_or_lao ])/;\n *\n * Here we would be handling the interpolated\n * '$thai_or_lao'. We handle this by a recursive call to\n * ourselves which returns the inversion list the\n * interpolated expression evaluates to. We use the flags\n * from the interpolated pattern. */\n U32 save_flags = RExC_flags;\n const char * save_parse;\n\n RExC_parse += 2; /* Skip past the '(?' */\n save_parse = RExC_parse;\n\n /* Parse any flags for the '(?' */\n parse_lparen_question_flags(pRExC_state);\n\n if (RExC_parse == save_parse /* Makes sure there was at\n least one flag (or else\n this embedding wasn't\n compiled) */\n || RExC_parse >= RExC_end - 4\n || UCHARAT(RExC_parse) != ':'\n || UCHARAT(++RExC_parse) != '('\n || UCHARAT(++RExC_parse) != '?'\n || UCHARAT(++RExC_parse) != '[')\n {\n\n /* In combination with the above, this moves the\n * pointer to the point just after the first erroneous\n * character (or if there are no flags, to where they\n * should have been) */\n if (RExC_parse >= RExC_end - 4) {\n RExC_parse = RExC_end;\n }\n else if (RExC_parse != save_parse) {\n RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;\n }\n vFAIL(\"Expecting '(?flags:(?[...'\");\n }\n\n /* Recurse, with the meat of the embedded expression */\n RExC_parse++;\n (void) handle_regex_sets(pRExC_state, ¤t, flagp,\n depth+1, oregcomp_parse);\n\n /* Here, 'current' contains the embedded expression's\n * inversion list, and RExC_parse points to the trailing\n * ']'; the next character should be the ')' */\n RExC_parse++;\n if (UCHARAT(RExC_parse) != ')')\n vFAIL(\"Expecting close paren for nested extended charclass\");\n\n /* Then the ')' matching the original '(' handled by this\n * case: statement */\n RExC_parse++;\n if (UCHARAT(RExC_parse) != ')')\n vFAIL(\"Expecting close paren for wrapper for nested extended charclass\");\n\n RExC_parse++;\n RExC_flags = save_flags;\n goto handle_operand;\n }\n\n /* A regular '('. Look behind for illegal syntax */\n if (top_index - fence >= 0) {\n /* If the top entry on the stack is an operator, it had\n * better be a '!', otherwise the entry below the top\n * operand should be an operator */\n if ( ! (top_ptr = av_fetch(stack, top_index, FALSE))\n || (IS_OPERATOR(*top_ptr) && SvUV(*top_ptr) != '!')\n || ( IS_OPERAND(*top_ptr)\n && ( top_index - fence < 1\n || ! (stacked_ptr = av_fetch(stack,\n top_index - 1,\n FALSE))\n || ! IS_OPERATOR(*stacked_ptr))))\n {\n RExC_parse++;\n vFAIL(\"Unexpected '(' with no preceding operator\");\n }\n }\n\n /* Stack the position of this undealt-with left paren */\n av_push(fence_stack, newSViv(fence));\n fence = top_index + 1;\n break;\n\n case '\\\\':\n /* regclass() can only return RESTART_PASS1 and NEED_UTF8 if\n * multi-char folds are allowed. */\n if (!regclass(pRExC_state, flagp,depth+1,\n TRUE, /* means parse just the next thing */\n FALSE, /* don't allow multi-char folds */\n FALSE, /* don't silence non-portable warnings. */\n TRUE, /* strict */\n FALSE, /* Require return to be an ANYOF */\n ¤t,\n NULL))\n {\n FAIL2(\"panic: regclass returned NULL to handle_sets, \"\n \"flags=%#\" UVxf, (UV) *flagp);\n }\n\n /* regclass() will return with parsing just the \\ sequence,\n * leaving the parse pointer at the next thing to parse */\n RExC_parse--;\n goto handle_operand;\n\n case '[': /* Is a bracketed character class */\n {\n /* See if this is a [:posix:] class. */\n bool is_posix_class = (OOB_NAMEDCLASS\n < handle_possible_posix(pRExC_state,\n RExC_parse + 1,\n NULL,\n NULL,\n TRUE /* checking only */));\n /* If it is a posix class, leave the parse pointer at the '['\n * to fool regclass() into thinking it is part of a\n * '[[:posix:]]'. */\n if (! is_posix_class) {\n RExC_parse++;\n }\n\n /* regclass() can only return RESTART_PASS1 and NEED_UTF8 if\n * multi-char folds are allowed. */\n if (!regclass(pRExC_state, flagp,depth+1,\n is_posix_class, /* parse the whole char\n class only if not a\n posix class */\n FALSE, /* don't allow multi-char folds */\n TRUE, /* silence non-portable warnings. */\n TRUE, /* strict */\n FALSE, /* Require return to be an ANYOF */\n ¤t,\n NULL\n ))\n {\n FAIL2(\"panic: regclass returned NULL to handle_sets, \"\n \"flags=%#\" UVxf, (UV) *flagp);\n }\n\n /* function call leaves parse pointing to the ']', except if we\n * faked it */\n if (is_posix_class) {\n RExC_parse--;\n }\n\n goto handle_operand;\n }\n\n case ']':\n if (top_index >= 1) {\n goto join_operators;\n }\n\n /* Only a single operand on the stack: are done */\n goto done;\n\n case ')':\n if (av_tindex_skip_len_mg(fence_stack) < 0) {\n RExC_parse++;\n vFAIL(\"Unexpected ')'\");\n }\n\n /* If nothing after the fence, is missing an operand */\n if (top_index - fence < 0) {\n RExC_parse++;\n goto bad_syntax;\n }\n /* If at least two things on the stack, treat this as an\n * operator */\n if (top_index - fence >= 1) {\n goto join_operators;\n }\n\n /* Here only a single thing on the fenced stack, and there is a\n * fence. Get rid of it */\n fence_ptr = av_pop(fence_stack);\n assert(fence_ptr);\n fence = SvIV(fence_ptr) - 1;\n SvREFCNT_dec_NN(fence_ptr);\n fence_ptr = NULL;\n\n if (fence < 0) {\n fence = 0;\n }\n\n /* Having gotten rid of the fence, we pop the operand at the\n * stack top and process it as a newly encountered operand */\n current = av_pop(stack);\n if (IS_OPERAND(current)) {\n goto handle_operand;\n }\n\n RExC_parse++;\n goto bad_syntax;\n\n case '&':\n case '|':\n case '+':\n case '-':\n case '^':\n\n /* These binary operators should have a left operand already\n * parsed */\n if ( top_index - fence < 0\n || top_index - fence == 1\n || ( ! (top_ptr = av_fetch(stack, top_index, FALSE)))\n || ! IS_OPERAND(*top_ptr))\n {\n goto unexpected_binary;\n }\n\n /* If only the one operand is on the part of the stack visible\n * to us, we just place this operator in the proper position */\n if (top_index - fence < 2) {\n\n /* Place the operator before the operand */\n\n SV* lhs = av_pop(stack);\n av_push(stack, newSVuv(curchar));\n av_push(stack, lhs);\n break;\n }\n\n /* But if there is something else on the stack, we need to\n * process it before this new operator if and only if the\n * stacked operation has equal or higher precedence than the\n * new one */\n\n join_operators:\n\n /* The operator on the stack is supposed to be below both its\n * operands */\n if ( ! (stacked_ptr = av_fetch(stack, top_index - 2, FALSE))\n || IS_OPERAND(*stacked_ptr))\n {\n /* But if not, it's legal and indicates we are completely\n * done if and only if we're currently processing a ']',\n * which should be the final thing in the expression */\n if (curchar == ']') {\n goto done;\n }\n\n unexpected_binary:\n RExC_parse++;\n vFAIL2(\"Unexpected binary operator '%c' with no \"\n \"preceding operand\", curchar);\n }\n stacked_operator = (char) SvUV(*stacked_ptr);\n\n if (regex_set_precedence(curchar)\n > regex_set_precedence(stacked_operator))\n {\n /* Here, the new operator has higher precedence than the\n * stacked one. This means we need to add the new one to\n * the stack to await its rhs operand (and maybe more\n * stuff). We put it before the lhs operand, leaving\n * untouched the stacked operator and everything below it\n * */\n lhs = av_pop(stack);\n assert(IS_OPERAND(lhs));\n\n av_push(stack, newSVuv(curchar));\n av_push(stack, lhs);\n break;\n }\n\n /* Here, the new operator has equal or lower precedence than\n * what's already there. This means the operation already\n * there should be performed now, before the new one. */\n\n rhs = av_pop(stack);\n if (! IS_OPERAND(rhs)) {\n\n /* This can happen when a ! is not followed by an operand,\n * like in /(?[\\t &!])/ */\n goto bad_syntax;\n }\n\n lhs = av_pop(stack);\n\n if (! IS_OPERAND(lhs)) {\n\n /* This can happen when there is an empty (), like in\n * /(?[[0]+()+])/ */\n goto bad_syntax;\n }\n\n switch (stacked_operator) {\n case '&':\n _invlist_intersection(lhs, rhs, &rhs);\n break;\n\n case '|':\n case '+':\n _invlist_union(lhs, rhs, &rhs);\n break;\n\n case '-':\n _invlist_subtract(lhs, rhs, &rhs);\n break;\n\n case '^': /* The union minus the intersection */\n {\n SV* i = NULL;\n SV* u = NULL;\n\n _invlist_union(lhs, rhs, &u);\n _invlist_intersection(lhs, rhs, &i);\n _invlist_subtract(u, i, &rhs);\n SvREFCNT_dec_NN(i);\n SvREFCNT_dec_NN(u);\n break;\n }\n }\n SvREFCNT_dec(lhs);\n\n /* Here, the higher precedence operation has been done, and the\n * result is in 'rhs'. We overwrite the stacked operator with\n * the result. Then we redo this code to either push the new\n * operator onto the stack or perform any higher precedence\n * stacked operation */\n only_to_avoid_leaks = av_pop(stack);\n SvREFCNT_dec(only_to_avoid_leaks);\n av_push(stack, rhs);\n goto redo_curchar;\n\n case '!': /* Highest priority, right associative */\n\n /* If what's already at the top of the stack is another '!\",\n * they just cancel each other out */\n if ( (top_ptr = av_fetch(stack, top_index, FALSE))\n && (IS_OPERATOR(*top_ptr) && SvUV(*top_ptr) == '!'))\n {\n only_to_avoid_leaks = av_pop(stack);\n SvREFCNT_dec(only_to_avoid_leaks);\n }\n else { /* Otherwise, since it's right associative, just push\n onto the stack */\n av_push(stack, newSVuv(curchar));\n }\n break;\n\n default:\n RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;\n vFAIL(\"Unexpected character\");\n\n handle_operand:\n\n /* Here 'current' is the operand. If something is already on the\n * stack, we have to check if it is a !. But first, the code above\n * may have altered the stack in the time since we earlier set\n * 'top_index'. */\n\n top_index = av_tindex_skip_len_mg(stack);\n if (top_index - fence >= 0) {\n /* If the top entry on the stack is an operator, it had better\n * be a '!', otherwise the entry below the top operand should\n * be an operator */\n top_ptr = av_fetch(stack, top_index, FALSE);\n assert(top_ptr);\n if (IS_OPERATOR(*top_ptr)) {\n\n /* The only permissible operator at the top of the stack is\n * '!', which is applied immediately to this operand. */\n curchar = (char) SvUV(*top_ptr);\n if (curchar != '!') {\n SvREFCNT_dec(current);\n vFAIL2(\"Unexpected binary operator '%c' with no \"\n \"preceding operand\", curchar);\n }\n\n _invlist_invert(current);\n\n only_to_avoid_leaks = av_pop(stack);\n SvREFCNT_dec(only_to_avoid_leaks);\n\n /* And we redo with the inverted operand. This allows\n * handling multiple ! in a row */\n goto handle_operand;\n }\n /* Single operand is ok only for the non-binary ')'\n * operator */\n else if ((top_index - fence == 0 && curchar != ')')\n || (top_index - fence > 0\n && (! (stacked_ptr = av_fetch(stack,\n top_index - 1,\n FALSE))\n || IS_OPERAND(*stacked_ptr))))\n {\n SvREFCNT_dec(current);\n vFAIL(\"Operand with no preceding operator\");\n }\n }\n\n /* Here there was nothing on the stack or the top element was\n * another operand. Just add this new one */\n av_push(stack, current);\n\n } /* End of switch on next parse token */\n\n RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;\n } /* End of loop parsing through the construct */\n\n done:\n if (av_tindex_skip_len_mg(fence_stack) >= 0) {\n vFAIL(\"Unmatched (\");\n }\n\n if (av_tindex_skip_len_mg(stack) < 0 /* Was empty */\n || ((final = av_pop(stack)) == NULL)\n || ! IS_OPERAND(final)\n || SvTYPE(final) != SVt_INVLIST\n || av_tindex_skip_len_mg(stack) >= 0) /* More left on stack */\n {\n bad_syntax:\n SvREFCNT_dec(final);\n vFAIL(\"Incomplete expression within '(?[ ])'\");\n }\n\n /* Here, 'final' is the resultant inversion list from evaluating the\n * expression. Return it if so requested */\n if (return_invlist) {\n *return_invlist = final;\n return END;\n }\n\n /* Otherwise generate a resultant node, based on 'final'. regclass() is\n * expecting a string of ranges and individual code points */\n invlist_iterinit(final);\n result_string = newSVpvs(\"\");\n while (invlist_iternext(final, &start, &end)) {\n if (start == end) {\n Perl_sv_catpvf(aTHX_ result_string, \"\\\\x{%\" UVXf \"}\", start);\n }\n else {\n Perl_sv_catpvf(aTHX_ result_string, \"\\\\x{%\" UVXf \"}-\\\\x{%\" UVXf \"}\",\n start, end);\n }\n }\n\n /* About to generate an ANYOF (or similar) node from the inversion list we\n * have calculated */\n save_parse = RExC_parse;\n RExC_parse = SvPV(result_string, len);\n save_end = RExC_end;\n RExC_end = RExC_parse + len;\n\n /* We turn off folding around the call, as the class we have constructed\n * already has all folding taken into consideration, and we don't want\n * regclass() to add to that */\n RExC_flags &= ~RXf_PMf_FOLD;\n /* regclass() can only return RESTART_PASS1 and NEED_UTF8 if multi-char\n * folds are allowed. */\n node = regclass(pRExC_state, flagp,depth+1,\n FALSE, /* means parse the whole char class */\n FALSE, /* don't allow multi-char folds */\n TRUE, /* silence non-portable warnings. The above may very\n well have generated non-portable code points, but\n they're valid on this machine */\n FALSE, /* similarly, no need for strict */\n FALSE, /* Require return to be an ANYOF */\n NULL,\n NULL\n );\n if (!node)\n FAIL2(\"panic: regclass returned NULL to handle_sets, flags=%#\" UVxf,\n PTR2UV(flagp));\n\n /* Fix up the node type if we are in locale. (We have pretended we are\n * under /u for the purposes of regclass(), as this construct will only\n * work under UTF-8 locales. But now we change the opcode to be ANYOFL (so\n * as to cause any warnings about bad locales to be output in regexec.c),\n * and add the flag that indicates to check if not in a UTF-8 locale. The\n * reason we above forbid optimization into something other than an ANYOF\n * node is simply to minimize the number of code changes in regexec.c.\n * Otherwise we would have to create new EXACTish node types and deal with\n * them. This decision could be revisited should this construct become\n * popular.\n *\n * (One might think we could look at the resulting ANYOF node and suppress\n * the flag if everything is above 255, as those would be UTF-8 only,\n * but this isn't true, as the components that led to that result could\n * have been locale-affected, and just happen to cancel each other out\n * under UTF-8 locales.) */\n if (in_locale) {\n set_regex_charset(&RExC_flags, REGEX_LOCALE_CHARSET);\n\n assert(OP(node) == ANYOF);\n\n OP(node) = ANYOFL;\n ANYOF_FLAGS(node)\n |= ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD;\n }\n\n if (save_fold) {\n RExC_flags |= RXf_PMf_FOLD;\n }\n\n RExC_parse = save_parse + 1;\n RExC_end = save_end;\n SvREFCNT_dec_NN(final);\n SvREFCNT_dec_NN(result_string);\n\n nextchar(pRExC_state);\n Set_Node_Length(node, RExC_parse - oregcomp_parse + 1); /* MJD */\n return node;\n}\n\n#ifdef ENABLE_REGEX_SETS_DEBUGGING\n\nSTATIC void\nS_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state,\n AV * stack, const IV fence, AV * fence_stack)\n{ /* Dumps the stacks in handle_regex_sets() */\n\n const SSize_t stack_top = av_tindex_skip_len_mg(stack);\n const SSize_t fence_stack_top = av_tindex_skip_len_mg(fence_stack);\n SSize_t i;\n\n PERL_ARGS_ASSERT_DUMP_REGEX_SETS_STRUCTURES;\n\n PerlIO_printf(Perl_debug_log, \"\\nParse position is:%s\\n\", RExC_parse);\n\n if (stack_top < 0) {\n PerlIO_printf(Perl_debug_log, \"Nothing on stack\\n\");\n }\n else {\n PerlIO_printf(Perl_debug_log, \"Stack: (fence=%d)\\n\", (int) fence);\n for (i = stack_top; i >= 0; i--) {\n SV ** element_ptr = av_fetch(stack, i, FALSE);\n if (! element_ptr) {\n }\n\n if (IS_OPERATOR(*element_ptr)) {\n PerlIO_printf(Perl_debug_log, \"[%d]: %c\\n\",\n (int) i, (int) SvIV(*element_ptr));\n }\n else {\n PerlIO_printf(Perl_debug_log, \"[%d] \", (int) i);\n sv_dump(*element_ptr);\n }\n }\n }\n\n if (fence_stack_top < 0) {\n PerlIO_printf(Perl_debug_log, \"Nothing on fence_stack\\n\");\n }\n else {\n PerlIO_printf(Perl_debug_log, \"Fence_stack: \\n\");\n for (i = fence_stack_top; i >= 0; i--) {\n SV ** element_ptr = av_fetch(fence_stack, i, FALSE);\n if (! element_ptr) {\n }\n\n PerlIO_printf(Perl_debug_log, \"[%d]: %d\\n\",\n (int) i, (int) SvIV(*element_ptr));\n }\n }\n}\n\n#endif\n\n#undef IS_OPERATOR\n#undef IS_OPERAND\n\nSTATIC void\nS_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist)\n{\n /* This hard-codes the Latin1/above-Latin1 folding rules, so that an\n * innocent-looking character class, like /[ks]/i won't have to go out to\n * disk to find the possible matches.\n *\n * This should be called only for a Latin1-range code points, cp, which is\n * known to be involved in a simple fold with other code points above\n * Latin1. It would give false results if /aa has been specified.\n * Multi-char folds are outside the scope of this, and must be handled\n * specially.\n *\n * XXX It would be better to generate these via regen, in case a new\n * version of the Unicode standard adds new mappings, though that is not\n * really likely, and may be caught by the default: case of the switch\n * below. */\n\n PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS;\n\n assert(HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(cp));\n\n switch (cp) {\n case 'k':\n case 'K':\n *invlist =\n add_cp_to_invlist(*invlist, KELVIN_SIGN);\n break;\n case 's':\n case 'S':\n *invlist = add_cp_to_invlist(*invlist, LATIN_SMALL_LETTER_LONG_S);\n break;\n case MICRO_SIGN:\n *invlist = add_cp_to_invlist(*invlist, GREEK_CAPITAL_LETTER_MU);\n *invlist = add_cp_to_invlist(*invlist, GREEK_SMALL_LETTER_MU);\n break;\n case LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE:\n case LATIN_SMALL_LETTER_A_WITH_RING_ABOVE:\n *invlist = add_cp_to_invlist(*invlist, ANGSTROM_SIGN);\n break;\n case LATIN_SMALL_LETTER_Y_WITH_DIAERESIS:\n *invlist = add_cp_to_invlist(*invlist,\n LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS);\n break;\n\n#ifdef LATIN_CAPITAL_LETTER_SHARP_S /* not defined in early Unicode releases */\n\n case LATIN_SMALL_LETTER_SHARP_S:\n *invlist = add_cp_to_invlist(*invlist, LATIN_CAPITAL_LETTER_SHARP_S);\n break;\n\n#endif\n\n#if UNICODE_MAJOR_VERSION < 3 \\\n || (UNICODE_MAJOR_VERSION == 3 && UNICODE_DOT_VERSION == 0)\n\n /* In 3.0 and earlier, U+0130 folded simply to 'i'; and in 3.0.1 so did\n * U+0131. */\n case 'i':\n case 'I':\n *invlist =\n add_cp_to_invlist(*invlist, LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE);\n# if UNICODE_DOT_DOT_VERSION == 1\n *invlist = add_cp_to_invlist(*invlist, LATIN_SMALL_LETTER_DOTLESS_I);\n# endif\n break;\n#endif\n\n default:\n /* Use deprecated warning to increase the chances of this being\n * output */\n if (PASS2) {\n ckWARN2reg_d(RExC_parse, \"Perl folding rules are not up-to-date for 0x%02X; please use the perlbug utility to report;\", cp);\n }\n break;\n }\n}\n\nSTATIC void\nS_output_or_return_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_warnings, AV** return_posix_warnings)\n{\n /* If the final parameter is NULL, output the elements of the array given\n * by '*posix_warnings' as REGEXP warnings. Otherwise, the elements are\n * pushed onto it, (creating if necessary) */\n\n SV * msg;\n const bool first_is_fatal = ! return_posix_warnings\n && ckDEAD(packWARN(WARN_REGEXP));\n\n PERL_ARGS_ASSERT_OUTPUT_OR_RETURN_POSIX_WARNINGS;\n\n while ((msg = av_shift(posix_warnings)) != &PL_sv_undef) {\n if (return_posix_warnings) {\n if (! *return_posix_warnings) { /* mortalize to not leak if\n warnings are fatal */\n *return_posix_warnings = (AV *) sv_2mortal((SV *) newAV());\n }\n av_push(*return_posix_warnings, msg);\n }\n else {\n if (first_is_fatal) { /* Avoid leaking this */\n av_undef(posix_warnings); /* This isn't necessary if the\n array is mortal, but is a\n fail-safe */\n (void) sv_2mortal(msg);\n if (PASS2) {\n SAVEFREESV(RExC_rx_sv);\n }\n }\n Perl_warner(aTHX_ packWARN(WARN_REGEXP), \"%s\", SvPVX(msg));\n SvREFCNT_dec_NN(msg);\n }\n }\n}\n\nSTATIC AV *\nS_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count)\n{\n /* This adds the string scalar <multi_string> to the array\n * <multi_char_matches>. <multi_string> is known to have exactly\n * <cp_count> code points in it. This is used when constructing a\n * bracketed character class and we find something that needs to match more\n * than a single character.\n *\n * <multi_char_matches> is actually an array of arrays. Each top-level\n * element is an array that contains all the strings known so far that are\n * the same length. And that length (in number of code points) is the same\n * as the index of the top-level array. Hence, the [2] element is an\n * array, each element thereof is a string containing TWO code points;\n * while element [3] is for strings of THREE characters, and so on. Since\n * this is for multi-char strings there can never be a [0] nor [1] element.\n *\n * When we rewrite the character class below, we will do so such that the\n * longest strings are written first, so that it prefers the longest\n * matching strings first. This is done even if it turns out that any\n * quantifier is non-greedy, out of this programmer's (khw) laziness. Tom\n * Christiansen has agreed that this is ok. This makes the test for the\n * ligature 'ffi' come before the test for 'ff', for example */\n\n AV* this_array;\n AV** this_array_ptr;\n\n PERL_ARGS_ASSERT_ADD_MULTI_MATCH;\n\n if (! multi_char_matches) {\n multi_char_matches = newAV();\n }\n\n if (av_exists(multi_char_matches, cp_count)) {\n this_array_ptr = (AV**) av_fetch(multi_char_matches, cp_count, FALSE);\n this_array = *this_array_ptr;\n }\n else {\n this_array = newAV();\n av_store(multi_char_matches, cp_count,\n (SV*) this_array);\n }\n av_push(this_array, multi_string);\n\n return multi_char_matches;\n}\n\n/* The names of properties whose definitions are not known at compile time are\n * stored in this SV, after a constant heading. So if the length has been\n * changed since initialization, then there is a run-time definition. */\n#define HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION \\\n (SvCUR(listsv) != initial_listsv_len)\n\n/* There is a restricted set of white space characters that are legal when\n * ignoring white space in a bracketed character class. This generates the\n * code to skip them.\n *\n * There is a line below that uses the same white space criteria but is outside\n * this macro. Both here and there must use the same definition */\n#define SKIP_BRACKETED_WHITE_SPACE(do_skip, p) \\\n STMT_START { \\\n if (do_skip) { \\\n while (isBLANK_A(UCHARAT(p))) \\\n { \\\n p++; \\\n } \\\n } \\\n } STMT_END\n\nSTATIC regnode *\nS_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth,\n const bool stop_at_1, /* Just parse the next thing, don't\n look for a full character class */\n bool allow_multi_folds,\n const bool silence_non_portable, /* Don't output warnings\n about too large\n characters */\n const bool strict,\n bool optimizable, /* ? Allow a non-ANYOF return\n node */\n SV** ret_invlist, /* Return an inversion list, not a node */\n AV** return_posix_warnings\n )\n{\n /* parse a bracketed class specification. Most of these will produce an\n * ANYOF node; but something like [a] will produce an EXACT node; [aA], an\n * EXACTFish node; [[:ascii:]], a POSIXA node; etc. It is more complex\n * under /i with multi-character folds: it will be rewritten following the\n * paradigm of this example, where the <multi-fold>s are characters which\n * fold to multiple character sequences:\n * /[abc\\x{multi-fold1}def\\x{multi-fold2}ghi]/i\n * gets effectively rewritten as:\n * /(?:\\x{multi-fold1}|\\x{multi-fold2}|[abcdefghi]/i\n * reg() gets called (recursively) on the rewritten version, and this\n * function will return what it constructs. (Actually the <multi-fold>s\n * aren't physically removed from the [abcdefghi], it's just that they are\n * ignored in the recursion by means of a flag:\n * <RExC_in_multi_char_class>.)\n *\n * ANYOF nodes contain a bit map for the first NUM_ANYOF_CODE_POINTS\n * characters, with the corresponding bit set if that character is in the\n * list. For characters above this, a range list or swash is used. There\n * are extra bits for \\w, etc. in locale ANYOFs, as what these match is not\n * determinable at compile time\n *\n * Returns NULL, setting *flagp to RESTART_PASS1 if the sizing scan needs\n * to be restarted, or'd with NEED_UTF8 if the pattern needs to be upgraded\n * to UTF-8. This can only happen if ret_invlist is non-NULL.\n */\n\n UV prevvalue = OOB_UNICODE, save_prevvalue = OOB_UNICODE;\n IV range = 0;\n UV value = OOB_UNICODE, save_value = OOB_UNICODE;\n regnode *ret;\n STRLEN numlen;\n int namedclass = OOB_NAMEDCLASS;\n char *rangebegin = NULL;\n bool need_class = 0;\n SV *listsv = NULL;\n STRLEN initial_listsv_len = 0; /* Kind of a kludge to see if it is more\n\t\t\t\t than just initialized. */\n SV* properties = NULL; /* Code points that match \\p{} \\P{} */\n SV* posixes = NULL; /* Code points that match classes like [:word:],\n extended beyond the Latin1 range. These have to\n be kept separate from other code points for much\n of this function because their handling is\n different under /i, and for most classes under\n /d as well */\n SV* nposixes = NULL; /* Similarly for [:^word:]. These are kept\n separate for a while from the non-complemented\n versions because of complications with /d\n matching */\n SV* simple_posixes = NULL; /* But under some conditions, the classes can be\n treated more simply than the general case,\n leading to less compilation and execution\n work */\n UV element_count = 0; /* Number of distinct elements in the class.\n\t\t\t Optimizations may be possible if this is tiny */\n AV * multi_char_matches = NULL; /* Code points that fold to more than one\n character; used under /i */\n UV n;\n char * stop_ptr = RExC_end; /* where to stop parsing */\n\n /* ignore unescaped whitespace? */\n const bool skip_white = cBOOL( ret_invlist\n || (RExC_flags & RXf_PMf_EXTENDED_MORE));\n\n /* Unicode properties are stored in a swash; this holds the current one\n * being parsed. If this swash is the only above-latin1 component of the\n * character class, an optimization is to pass it directly on to the\n * execution engine. Otherwise, it is set to NULL to indicate that there\n * are other things in the class that have to be dealt with at execution\n * time */\n SV* swash = NULL;\t\t/* Code points that match \\p{} \\P{} */\n\n /* Set if a component of this character class is user-defined; just passed\n * on to the engine */\n bool has_user_defined_property = FALSE;\n\n /* inversion list of code points this node matches only when the target\n * string is in UTF-8. These are all non-ASCII, < 256. (Because is under\n * /d) */\n SV* has_upper_latin1_only_utf8_matches = NULL;\n\n /* Inversion list of code points this node matches regardless of things\n * like locale, folding, utf8ness of the target string */\n SV* cp_list = NULL;\n\n /* Like cp_list, but code points on this list need to be checked for things\n * that fold to/from them under /i */\n SV* cp_foldable_list = NULL;\n\n /* Like cp_list, but code points on this list are valid only when the\n * runtime locale is UTF-8 */\n SV* only_utf8_locale_list = NULL;\n\n /* In a range, if one of the endpoints is non-character-set portable,\n * meaning that it hard-codes a code point that may mean a different\n * charactger in ASCII vs. EBCDIC, as opposed to, say, a literal 'A' or a\n * mnemonic '\\t' which each mean the same character no matter which\n * character set the platform is on. */\n unsigned int non_portable_endpoint = 0;\n\n /* Is the range unicode? which means on a platform that isn't 1-1 native\n * to Unicode (i.e. non-ASCII), each code point in it should be considered\n * to be a Unicode value. */\n bool unicode_range = FALSE;\n bool invert = FALSE; /* Is this class to be complemented */\n\n bool warn_super = ALWAYS_WARN_SUPER;\n\n regnode * const orig_emit = RExC_emit; /* Save the original RExC_emit in\n case we need to change the emitted regop to an EXACT. */\n const char * orig_parse = RExC_parse;\n const SSize_t orig_size = RExC_size;\n bool posixl_matches_all = FALSE; /* Does /l class have both e.g. \\W,\\w ? */\n\n /* This variable is used to mark where the end in the input is of something\n * that looks like a POSIX construct but isn't. During the parse, when\n * something looks like it could be such a construct is encountered, it is\n * checked for being one, but not if we've already checked this area of the\n * input. Only after this position is reached do we check again */\n char *not_posix_region_end = RExC_parse - 1;\n\n AV* posix_warnings = NULL;\n const bool do_posix_warnings = return_posix_warnings\n || (PASS2 && ckWARN(WARN_REGEXP));\n\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGCLASS;\n#ifndef DEBUGGING\n PERL_UNUSED_ARG(depth);\n#endif\n\n DEBUG_PARSE(\"clas\");\n\n#if UNICODE_MAJOR_VERSION < 3 /* no multifolds in early Unicode */ \\\n || (UNICODE_MAJOR_VERSION == 3 && UNICODE_DOT_VERSION == 0 \\\n && UNICODE_DOT_DOT_VERSION == 0)\n allow_multi_folds = FALSE;\n#endif\n\n /* Assume we are going to generate an ANYOF node. */\n ret = reganode(pRExC_state,\n (LOC)\n ? ANYOFL\n : ANYOF,\n 0);\n\n if (SIZE_ONLY) {\n\tRExC_size += ANYOF_SKIP;\n\tlistsv = &PL_sv_undef; /* For code scanners: listsv always non-NULL. */\n }\n else {\n ANYOF_FLAGS(ret) = 0;\n\n \tRExC_emit += ANYOF_SKIP;\n\tlistsv = newSVpvs_flags(\"# comment\\n\", SVs_TEMP);\n\tinitial_listsv_len = SvCUR(listsv);\n SvTEMP_off(listsv); /* Grr, TEMPs and mortals are conflated. */\n }\n\n SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse);\n\n assert(RExC_parse <= RExC_end);\n\n if (UCHARAT(RExC_parse) == '^') {\t/* Complement the class */\n\tRExC_parse++;\n invert = TRUE;\n allow_multi_folds = FALSE;\n MARK_NAUGHTY(1);\n SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse);\n }\n\n /* Check that they didn't say [:posix:] instead of [[:posix:]] */\n if (! ret_invlist && MAYBE_POSIXCC(UCHARAT(RExC_parse))) {\n int maybe_class = handle_possible_posix(pRExC_state,\n RExC_parse,\n ¬_posix_region_end,\n NULL,\n TRUE /* checking only */);\n if (PASS2 && maybe_class >= OOB_NAMEDCLASS && do_posix_warnings) {\n SAVEFREESV(RExC_rx_sv);\n ckWARN4reg(not_posix_region_end,\n \"POSIX syntax [%c %c] belongs inside character classes%s\",\n *RExC_parse, *RExC_parse,\n (maybe_class == OOB_NAMEDCLASS)\n ? ((POSIXCC_NOTYET(*RExC_parse))\n ? \" (but this one isn't implemented)\"\n : \" (but this one isn't fully valid)\")\n : \"\"\n );\n (void)ReREFCNT_inc(RExC_rx_sv);\n }\n }\n\n /* If the caller wants us to just parse a single element, accomplish this\n * by faking the loop ending condition */\n if (stop_at_1 && RExC_end > RExC_parse) {\n stop_ptr = RExC_parse + 1;\n }\n\n /* allow 1st char to be ']' (allowing it to be '-' is dealt with later) */\n if (UCHARAT(RExC_parse) == ']')\n\tgoto charclassloop;\n\n while (1) {\n\n if ( posix_warnings\n && av_tindex_skip_len_mg(posix_warnings) >= 0\n && RExC_parse > not_posix_region_end)\n {\n /* Warnings about posix class issues are considered tentative until\n * we are far enough along in the parse that we can no longer\n * change our mind, at which point we either output them or add\n * them, if it has so specified, to what gets returned to the\n * caller. This is done each time through the loop so that a later\n * class won't zap them before they have been dealt with. */\n output_or_return_posix_warnings(pRExC_state, posix_warnings,\n return_posix_warnings);\n }\n\n if (RExC_parse >= stop_ptr) {\n break;\n }\n\n SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse);\n\n if (UCHARAT(RExC_parse) == ']') {\n break;\n }\n\n charclassloop:\n\n\tnamedclass = OOB_NAMEDCLASS; /* initialize as illegal */\n save_value = value;\n save_prevvalue = prevvalue;\n\n\tif (!range) {\n\t rangebegin = RExC_parse;\n\t element_count++;\n non_portable_endpoint = 0;\n\t}\n\tif (UTF && ! UTF8_IS_INVARIANT(* RExC_parse)) {\n\t value = utf8n_to_uvchr((U8*)RExC_parse,\n\t\t\t\t RExC_end - RExC_parse,\n\t\t\t\t &numlen, UTF8_ALLOW_DEFAULT);\n\t RExC_parse += numlen;\n\t}\n\telse\n\t value = UCHARAT(RExC_parse++);\n\n if (value == '[') {\n char * posix_class_end;\n namedclass = handle_possible_posix(pRExC_state,\n RExC_parse,\n &posix_class_end,\n do_posix_warnings ? &posix_warnings : NULL,\n FALSE /* die if error */);\n if (namedclass > OOB_NAMEDCLASS) {\n\n /* If there was an earlier attempt to parse this particular\n * posix class, and it failed, it was a false alarm, as this\n * successful one proves */\n if ( posix_warnings\n && av_tindex_skip_len_mg(posix_warnings) >= 0\n && not_posix_region_end >= RExC_parse\n && not_posix_region_end <= posix_class_end)\n {\n av_undef(posix_warnings);\n }\n\n RExC_parse = posix_class_end;\n }\n else if (namedclass == OOB_NAMEDCLASS) {\n not_posix_region_end = posix_class_end;\n }\n else {\n namedclass = OOB_NAMEDCLASS;\n }\n }\n else if ( RExC_parse - 1 > not_posix_region_end\n && MAYBE_POSIXCC(value))\n {\n (void) handle_possible_posix(\n pRExC_state,\n RExC_parse - 1, /* -1 because parse has already been\n advanced */\n ¬_posix_region_end,\n do_posix_warnings ? &posix_warnings : NULL,\n TRUE /* checking only */);\n }\n else if (value == '\\\\') {\n /* Is a backslash; get the code point of the char after it */\n\n if (RExC_parse >= RExC_end) {\n vFAIL(\"Unmatched [\");\n }\n\n\t if (UTF && ! UTF8_IS_INVARIANT(UCHARAT(RExC_parse))) {\n\t\tvalue = utf8n_to_uvchr((U8*)RExC_parse,\n\t\t\t\t RExC_end - RExC_parse,\n\t\t\t\t &numlen, UTF8_ALLOW_DEFAULT);\n\t\tRExC_parse += numlen;\n\t }\n\t else\n\t\tvalue = UCHARAT(RExC_parse++);\n\n\t /* Some compilers cannot handle switching on 64-bit integer\n\t * values, therefore value cannot be an UV. Yes, this will\n\t * be a problem later if we want switch on Unicode.\n\t * A similar issue a little bit later when switching on\n\t * namedclass. --jhi */\n\n /* If the \\ is escaping white space when white space is being\n * skipped, it means that that white space is wanted literally, and\n * is already in 'value'. Otherwise, need to translate the escape\n * into what it signifies. */\n if (! skip_white || ! isBLANK_A(value)) switch ((I32)value) {\n\n\t case 'w':\tnamedclass = ANYOF_WORDCHAR;\tbreak;\n\t case 'W':\tnamedclass = ANYOF_NWORDCHAR;\tbreak;\n\t case 's':\tnamedclass = ANYOF_SPACE;\tbreak;\n\t case 'S':\tnamedclass = ANYOF_NSPACE;\tbreak;\n\t case 'd':\tnamedclass = ANYOF_DIGIT;\tbreak;\n\t case 'D':\tnamedclass = ANYOF_NDIGIT;\tbreak;\n\t case 'v':\tnamedclass = ANYOF_VERTWS;\tbreak;\n\t case 'V':\tnamedclass = ANYOF_NVERTWS;\tbreak;\n\t case 'h':\tnamedclass = ANYOF_HORIZWS;\tbreak;\n\t case 'H':\tnamedclass = ANYOF_NHORIZWS;\tbreak;\n case 'N': /* Handle \\N{NAME} in class */\n {\n const char * const backslash_N_beg = RExC_parse - 2;\n int cp_count;\n\n if (! grok_bslash_N(pRExC_state,\n NULL, /* No regnode */\n &value, /* Yes single value */\n &cp_count, /* Multiple code pt count */\n flagp,\n strict,\n depth)\n ) {\n\n if (*flagp & NEED_UTF8)\n FAIL(\"panic: grok_bslash_N set NEED_UTF8\");\n if (*flagp & RESTART_PASS1)\n return NULL;\n\n if (cp_count < 0) {\n vFAIL(\"\\\\N in a character class must be a named character: \\\\N{...}\");\n }\n else if (cp_count == 0) {\n if (PASS2) {\n ckWARNreg(RExC_parse,\n \"Ignoring zero length \\\\N{} in character class\");\n }\n }\n else { /* cp_count > 1 */\n if (! RExC_in_multi_char_class) {\n if (invert || range || *RExC_parse == '-') {\n if (strict) {\n RExC_parse--;\n vFAIL(\"\\\\N{} in inverted character class or as a range end-point is restricted to one character\");\n }\n else if (PASS2) {\n ckWARNreg(RExC_parse, \"Using just the first character returned by \\\\N{} in character class\");\n }\n break; /* <value> contains the first code\n point. Drop out of the switch to\n process it */\n }\n else {\n SV * multi_char_N = newSVpvn(backslash_N_beg,\n RExC_parse - backslash_N_beg);\n multi_char_matches\n = add_multi_match(multi_char_matches,\n multi_char_N,\n cp_count);\n }\n }\n } /* End of cp_count != 1 */\n\n /* This element should not be processed further in this\n * class */\n element_count--;\n value = save_value;\n prevvalue = save_prevvalue;\n continue; /* Back to top of loop to get next char */\n }\n\n /* Here, is a single code point, and <value> contains it */\n unicode_range = TRUE; /* \\N{} are Unicode */\n }\n break;\n\t case 'p':\n\t case 'P':\n\t\t{\n\t\tchar *e;\n\n /* We will handle any undefined properties ourselves */\n U8 swash_init_flags = _CORE_SWASH_INIT_RETURN_IF_UNDEF\n /* And we actually would prefer to get\n * the straight inversion list of the\n * swash, since we will be accessing it\n * anyway, to save a little time */\n |_CORE_SWASH_INIT_ACCEPT_INVLIST;\n\n\t\tif (RExC_parse >= RExC_end)\n\t\t vFAIL2(\"Empty \\\\%c\", (U8)value);\n\t\tif (*RExC_parse == '{') {\n\t\t const U8 c = (U8)value;\n\t\t e = (char *) memchr(RExC_parse, '}', RExC_end - RExC_parse);\n if (!e) {\n RExC_parse++;\n vFAIL2(\"Missing right brace on \\\\%c{}\", c);\n }\n\n RExC_parse++;\n while (isSPACE(*RExC_parse)) {\n RExC_parse++;\n\t\t }\n\n\t\t if (UCHARAT(RExC_parse) == '^') {\n\n /* toggle. (The rhs xor gets the single bit that\n * differs between P and p; the other xor inverts just\n * that bit) */\n value ^= 'P' ^ 'p';\n\n RExC_parse++;\n while (isSPACE(*RExC_parse)) {\n RExC_parse++;\n }\n }\n\n if (e == RExC_parse)\n vFAIL2(\"Empty \\\\%c{}\", c);\n\n\t\t n = e - RExC_parse;\n\t\t while (isSPACE(*(RExC_parse + n - 1)))\n\t\t n--;\n\t\t} /* The \\p isn't immediately followed by a '{' */\n\t\telse if (! isALPHA(*RExC_parse)) {\n RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;\n vFAIL2(\"Character following \\\\%c must be '{' or a \"\n \"single-character Unicode property name\",\n (U8) value);\n }\n else {\n\t\t e = RExC_parse;\n\t\t n = 1;\n\t\t}\n\t\tif (!SIZE_ONLY) {\n SV* invlist;\n char* name;\n char* base_name; /* name after any packages are stripped */\n char* lookup_name = NULL;\n const char * const colon_colon = \"::\";\n\n /* Try to get the definition of the property into\n * <invlist>. If /i is in effect, the effective property\n * will have its name be <__NAME_i>. The design is\n * discussed in commit\n * 2f833f5208e26b208886e51e09e2c072b5eabb46 */\n name = savepv(Perl_form(aTHX_ \"%.*s\", (int)n, RExC_parse));\n SAVEFREEPV(name);\n if (FOLD) {\n lookup_name = savepv(Perl_form(aTHX_ \"__%s_i\", name));\n\n /* The function call just below that uses this can fail\n * to return, leaking memory if we don't do this */\n SAVEFREEPV(lookup_name);\n }\n\n /* Look up the property name, and get its swash and\n * inversion list, if the property is found */\n SvREFCNT_dec(swash); /* Free any left-overs */\n swash = _core_swash_init(\"utf8\",\n (lookup_name)\n ? lookup_name\n : name,\n &PL_sv_undef,\n 1, /* binary */\n 0, /* not tr/// */\n NULL, /* No inversion list */\n &swash_init_flags\n );\n if (! swash || ! (invlist = _get_swash_invlist(swash))) {\n HV* curpkg = (IN_PERL_COMPILETIME)\n ? PL_curstash\n : CopSTASH(PL_curcop);\n UV final_n = n;\n bool has_pkg;\n\n if (swash) { /* Got a swash but no inversion list.\n Something is likely wrong that will\n be sorted-out later */\n SvREFCNT_dec_NN(swash);\n swash = NULL;\n }\n\n /* Here didn't find it. It could be a an error (like a\n * typo) in specifying a Unicode property, or it could\n * be a user-defined property that will be available at\n * run-time. The names of these must begin with 'In'\n * or 'Is' (after any packages are stripped off). So\n * if not one of those, or if we accept only\n * compile-time properties, is an error; otherwise add\n * it to the list for run-time look up. */\n if ((base_name = rninstr(name, name + n,\n colon_colon, colon_colon + 2)))\n { /* Has ::. We know this must be a user-defined\n property */\n base_name += 2;\n final_n -= base_name - name;\n has_pkg = TRUE;\n }\n else {\n base_name = name;\n has_pkg = FALSE;\n }\n\n if ( final_n < 3\n || base_name[0] != 'I'\n || (base_name[1] != 's' && base_name[1] != 'n')\n || ret_invlist)\n {\n const char * const msg\n = (has_pkg)\n ? \"Illegal user-defined property name\"\n : \"Can't find Unicode property definition\";\n RExC_parse = e + 1;\n\n /* diag_listed_as: Can't find Unicode property definition \"%s\" */\n vFAIL3utf8f(\"%s \\\"%\" UTF8f \"\\\"\",\n msg, UTF8fARG(UTF, n, name));\n }\n\n /* If the property name doesn't already have a package\n * name, add the current one to it so that it can be\n * referred to outside it. [perl #121777] */\n if (! has_pkg && curpkg) {\n char* pkgname = HvNAME(curpkg);\n if (memNEs(pkgname, HvNAMELEN(curpkg), \"main\")) {\n char* full_name = Perl_form(aTHX_\n \"%s::%s\",\n pkgname,\n name);\n n = strlen(full_name);\n name = savepvn(full_name, n);\n SAVEFREEPV(name);\n }\n }\n Perl_sv_catpvf(aTHX_ listsv, \"%cutf8::%s%\" UTF8f \"%s\\n\",\n (value == 'p' ? '+' : '!'),\n (FOLD) ? \"__\" : \"\",\n UTF8fARG(UTF, n, name),\n (FOLD) ? \"_i\" : \"\");\n has_user_defined_property = TRUE;\n optimizable = FALSE; /* Will have to leave this an\n ANYOF node */\n\n /* We don't know yet what this matches, so have to flag\n * it */\n ANYOF_FLAGS(ret) |= ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP;\n }\n else {\n\n /* Here, did get the swash and its inversion list. If\n * the swash is from a user-defined property, then this\n * whole character class should be regarded as such */\n if (swash_init_flags\n & _CORE_SWASH_INIT_USER_DEFINED_PROPERTY)\n {\n has_user_defined_property = TRUE;\n }\n else if\n /* We warn on matching an above-Unicode code point\n * if the match would return true, except don't\n * warn for \\p{All}, which has exactly one element\n * = 0 */\n (_invlist_contains_cp(invlist, 0x110000)\n && (! (_invlist_len(invlist) == 1\n && *invlist_array(invlist) == 0)))\n {\n warn_super = TRUE;\n }\n\n\n /* Invert if asking for the complement */\n if (value == 'P') {\n\t\t\t _invlist_union_complement_2nd(properties,\n invlist,\n &properties);\n\n /* The swash can't be used as-is, because we've\n\t\t\t * inverted things; delay removing it to here after\n\t\t\t * have copied its invlist above */\n SvREFCNT_dec_NN(swash);\n swash = NULL;\n }\n else {\n _invlist_union(properties, invlist, &properties);\n\t\t\t}\n\t\t }\n\t\t}\n\t\tRExC_parse = e + 1;\n namedclass = ANYOF_UNIPROP; /* no official name, but it's\n named */\n\n\t\t/* \\p means they want Unicode semantics */\n\t\tREQUIRE_UNI_RULES(flagp, NULL);\n\t\t}\n\t\tbreak;\n\t case 'n':\tvalue = '\\n';\t\t\tbreak;\n\t case 'r':\tvalue = '\\r';\t\t\tbreak;\n\t case 't':\tvalue = '\\t';\t\t\tbreak;\n\t case 'f':\tvalue = '\\f';\t\t\tbreak;\n\t case 'b':\tvalue = '\\b';\t\t\tbreak;\n\t case 'e':\tvalue = ESC_NATIVE; break;\n\t case 'a':\tvalue = '\\a'; break;\n\t case 'o':\n\t\tRExC_parse--;\t/* function expects to be pointed at the 'o' */\n\t\t{\n\t\t const char* error_msg;\n\t\t bool valid = grok_bslash_o(&RExC_parse,\n RExC_end,\n\t\t\t\t\t &value,\n\t\t\t\t\t &error_msg,\n PASS2, /* warnings only in\n pass 2 */\n strict,\n silence_non_portable,\n UTF);\n\t\t if (! valid) {\n\t\t\tvFAIL(error_msg);\n\t\t }\n\t\t}\n non_portable_endpoint++;\n\t\tbreak;\n\t case 'x':\n\t\tRExC_parse--;\t/* function expects to be pointed at the 'x' */\n\t\t{\n\t\t const char* error_msg;\n\t\t bool valid = grok_bslash_x(&RExC_parse,\n RExC_end,\n\t\t\t\t\t &value,\n\t\t\t\t\t &error_msg,\n\t\t\t\t\t PASS2, /* Output warnings */\n strict,\n silence_non_portable,\n UTF);\n if (! valid) {\n\t\t\tvFAIL(error_msg);\n\t\t }\n\t\t}\n non_portable_endpoint++;\n\t\tbreak;\n\t case 'c':\n\t\tvalue = grok_bslash_c(*RExC_parse++, PASS2);\n non_portable_endpoint++;\n\t\tbreak;\n\t case '0': case '1': case '2': case '3': case '4':\n\t case '5': case '6': case '7':\n\t\t{\n\t\t /* Take 1-3 octal digits */\n\t\t I32 flags = PERL_SCAN_SILENT_ILLDIGIT;\n numlen = (strict) ? 4 : 3;\n value = grok_oct(--RExC_parse, &numlen, &flags, NULL);\n\t\t RExC_parse += numlen;\n if (numlen != 3) {\n if (strict) {\n RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;\n vFAIL(\"Need exactly 3 octal digits\");\n }\n else if (! SIZE_ONLY /* like \\08, \\178 */\n && numlen < 3\n && RExC_parse < RExC_end\n && isDIGIT(*RExC_parse)\n && ckWARN(WARN_REGEXP))\n {\n SAVEFREESV(RExC_rx_sv);\n reg_warn_non_literal_string(\n RExC_parse + 1,\n form_short_octal_warning(RExC_parse, numlen));\n (void)ReREFCNT_inc(RExC_rx_sv);\n }\n }\n non_portable_endpoint++;\n\t\t break;\n\t\t}\n\t default:\n\t\t/* Allow \\_ to not give an error */\n\t\tif (!SIZE_ONLY && isWORDCHAR(value) && value != '_') {\n if (strict) {\n vFAIL2(\"Unrecognized escape \\\\%c in character class\",\n (int)value);\n }\n else {\n SAVEFREESV(RExC_rx_sv);\n ckWARN2reg(RExC_parse,\n \"Unrecognized escape \\\\%c in character class passed through\",\n (int)value);\n (void)ReREFCNT_inc(RExC_rx_sv);\n }\n\t\t}\n\t\tbreak;\n\t } /* End of switch on char following backslash */\n\t} /* end of handling backslash escape sequences */\n\n /* Here, we have the current token in 'value' */\n\n\tif (namedclass > OOB_NAMEDCLASS) { /* this is a named class \\blah */\n U8 classnum;\n\n\t /* a bad range like a-\\d, a-[:digit:]. The '-' is taken as a\n\t * literal, as is the character that began the false range, i.e.\n\t * the 'a' in the examples */\n\t if (range) {\n\t\tif (!SIZE_ONLY) {\n\t\t const int w = (RExC_parse >= rangebegin)\n ? RExC_parse - rangebegin\n : 0;\n if (strict) {\n vFAIL2utf8f(\n \"False [] range \\\"%\" UTF8f \"\\\"\",\n UTF8fARG(UTF, w, rangebegin));\n }\n else {\n SAVEFREESV(RExC_rx_sv); /* in case of fatal warnings */\n ckWARN2reg(RExC_parse,\n \"False [] range \\\"%\" UTF8f \"\\\"\",\n UTF8fARG(UTF, w, rangebegin));\n (void)ReREFCNT_inc(RExC_rx_sv);\n cp_list = add_cp_to_invlist(cp_list, '-');\n cp_foldable_list = add_cp_to_invlist(cp_foldable_list,\n prevvalue);\n }\n\t\t}\n\n\t\trange = 0; /* this was not a true range */\n element_count += 2; /* So counts for three values */\n\t }\n\n classnum = namedclass_to_classnum(namedclass);\n\n\t if (LOC && namedclass < ANYOF_POSIXL_MAX\n#ifndef HAS_ISASCII\n && classnum != _CC_ASCII\n#endif\n ) {\n /* What the Posix classes (like \\w, [:space:]) match in locale\n * isn't knowable under locale until actual match time. Room\n * must be reserved (one time per outer bracketed class) to\n * store such classes. The space will contain a bit for each\n * named class that is to be matched against. This isn't\n * needed for \\p{} and pseudo-classes, as they are not affected\n * by locale, and hence are dealt with separately */\n if (! need_class) {\n need_class = 1;\n if (SIZE_ONLY) {\n RExC_size += ANYOF_POSIXL_SKIP - ANYOF_SKIP;\n }\n else {\n RExC_emit += ANYOF_POSIXL_SKIP - ANYOF_SKIP;\n }\n ANYOF_FLAGS(ret) |= ANYOF_MATCHES_POSIXL;\n ANYOF_POSIXL_ZERO(ret);\n\n /* We can't change this into some other type of node\n * (unless this is the only element, in which case there\n * are nodes that mean exactly this) as has runtime\n * dependencies */\n optimizable = FALSE;\n }\n\n /* Coverity thinks it is possible for this to be negative; both\n * jhi and khw think it's not, but be safer */\n assert(! (ANYOF_FLAGS(ret) & ANYOF_MATCHES_POSIXL)\n || (namedclass + ((namedclass % 2) ? -1 : 1)) >= 0);\n\n /* See if it already matches the complement of this POSIX\n * class */\n if ((ANYOF_FLAGS(ret) & ANYOF_MATCHES_POSIXL)\n && ANYOF_POSIXL_TEST(ret, namedclass + ((namedclass % 2)\n ? -1\n : 1)))\n {\n posixl_matches_all = TRUE;\n break; /* No need to continue. Since it matches both\n e.g., \\w and \\W, it matches everything, and the\n bracketed class can be optimized into qr/./s */\n }\n\n /* Add this class to those that should be checked at runtime */\n ANYOF_POSIXL_SET(ret, namedclass);\n\n /* The above-Latin1 characters are not subject to locale rules.\n * Just add them, in the second pass, to the\n * unconditionally-matched list */\n if (! SIZE_ONLY) {\n SV* scratch_list = NULL;\n\n /* Get the list of the above-Latin1 code points this\n * matches */\n _invlist_intersection_maybe_complement_2nd(PL_AboveLatin1,\n PL_XPosix_ptrs[classnum],\n\n /* Odd numbers are complements, like\n * NDIGIT, NASCII, ... */\n namedclass % 2 != 0,\n &scratch_list);\n /* Checking if 'cp_list' is NULL first saves an extra\n * clone. Its reference count will be decremented at the\n * next union, etc, or if this is the only instance, at the\n * end of the routine */\n if (! cp_list) {\n cp_list = scratch_list;\n }\n else {\n _invlist_union(cp_list, scratch_list, &cp_list);\n SvREFCNT_dec_NN(scratch_list);\n }\n continue; /* Go get next character */\n }\n }\n else if (! SIZE_ONLY) {\n\n /* Here, not in pass1 (in that pass we skip calculating the\n * contents of this class), and is not /l, or is a POSIX class\n * for which /l doesn't matter (or is a Unicode property, which\n * is skipped here). */\n if (namedclass >= ANYOF_POSIXL_MAX) { /* If a special class */\n if (namedclass != ANYOF_UNIPROP) { /* UNIPROP = \\p and \\P */\n\n /* Here, should be \\h, \\H, \\v, or \\V. None of /d, /i\n * nor /l make a difference in what these match,\n * therefore we just add what they match to cp_list. */\n if (classnum != _CC_VERTSPACE) {\n assert( namedclass == ANYOF_HORIZWS\n || namedclass == ANYOF_NHORIZWS);\n\n /* It turns out that \\h is just a synonym for\n * XPosixBlank */\n classnum = _CC_BLANK;\n }\n\n _invlist_union_maybe_complement_2nd(\n cp_list,\n PL_XPosix_ptrs[classnum],\n namedclass % 2 != 0, /* Complement if odd\n (NHORIZWS, NVERTWS)\n */\n &cp_list);\n }\n }\n else if ( UNI_SEMANTICS\n || classnum == _CC_ASCII\n || (DEPENDS_SEMANTICS && ( classnum == _CC_DIGIT\n || classnum == _CC_XDIGIT)))\n {\n /* We usually have to worry about /d and /a affecting what\n * POSIX classes match, with special code needed for /d\n * because we won't know until runtime what all matches.\n * But there is no extra work needed under /u, and\n * [:ascii:] is unaffected by /a and /d; and :digit: and\n * :xdigit: don't have runtime differences under /d. So we\n * can special case these, and avoid some extra work below,\n * and at runtime. */\n _invlist_union_maybe_complement_2nd(\n simple_posixes,\n PL_XPosix_ptrs[classnum],\n namedclass % 2 != 0,\n &simple_posixes);\n }\n else { /* Garden variety class. If is NUPPER, NALPHA, ...\n complement and use nposixes */\n SV** posixes_ptr = namedclass % 2 == 0\n ? &posixes\n : &nposixes;\n _invlist_union_maybe_complement_2nd(\n *posixes_ptr,\n PL_XPosix_ptrs[classnum],\n namedclass % 2 != 0,\n posixes_ptr);\n }\n\t }\n\t} /* end of namedclass \\blah */\n\n SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse);\n\n /* If 'range' is set, 'value' is the ending of a range--check its\n * validity. (If value isn't a single code point in the case of a\n * range, we should have figured that out above in the code that\n * catches false ranges). Later, we will handle each individual code\n * point in the range. If 'range' isn't set, this could be the\n * beginning of a range, so check for that by looking ahead to see if\n * the next real character to be processed is the range indicator--the\n * minus sign */\n\n\tif (range) {\n#ifdef EBCDIC\n /* For unicode ranges, we have to test that the Unicode as opposed\n * to the native values are not decreasing. (Above 255, there is\n * no difference between native and Unicode) */\n\t if (unicode_range && prevvalue < 255 && value < 255) {\n if (NATIVE_TO_LATIN1(prevvalue) > NATIVE_TO_LATIN1(value)) {\n goto backwards_range;\n }\n }\n else\n#endif\n\t if (prevvalue > value) /* b-a */ {\n\t\tint w;\n#ifdef EBCDIC\n backwards_range:\n#endif\n w = RExC_parse - rangebegin;\n vFAIL2utf8f(\n \"Invalid [] range \\\"%\" UTF8f \"\\\"\",\n UTF8fARG(UTF, w, rangebegin));\n NOT_REACHED; /* NOTREACHED */\n\t }\n\t}\n\telse {\n prevvalue = value; /* save the beginning of the potential range */\n if (! stop_at_1 /* Can't be a range if parsing just one thing */\n && *RExC_parse == '-')\n {\n char* next_char_ptr = RExC_parse + 1;\n\n /* Get the next real char after the '-' */\n SKIP_BRACKETED_WHITE_SPACE(skip_white, next_char_ptr);\n\n /* If the '-' is at the end of the class (just before the ']',\n * it is a literal minus; otherwise it is a range */\n if (next_char_ptr < RExC_end && *next_char_ptr != ']') {\n RExC_parse = next_char_ptr;\n\n /* a bad range like \\w-, [:word:]- ? */\n if (namedclass > OOB_NAMEDCLASS) {\n if (strict || (PASS2 && ckWARN(WARN_REGEXP))) {\n const int w = RExC_parse >= rangebegin\n ? RExC_parse - rangebegin\n : 0;\n if (strict) {\n vFAIL4(\"False [] range \\\"%*.*s\\\"\",\n w, w, rangebegin);\n }\n else if (PASS2) {\n vWARN4(RExC_parse,\n \"False [] range \\\"%*.*s\\\"\",\n w, w, rangebegin);\n }\n }\n if (!SIZE_ONLY) {\n cp_list = add_cp_to_invlist(cp_list, '-');\n }\n element_count++;\n } else\n range = 1;\t/* yeah, it's a range! */\n continue;\t/* but do it the next time */\n }\n\t }\n\t}\n\n if (namedclass > OOB_NAMEDCLASS) {\n continue;\n }\n\n /* Here, we have a single value this time through the loop, and\n * <prevvalue> is the beginning of the range, if any; or <value> if\n * not. */\n\n\t/* non-Latin1 code point implies unicode semantics. Must be set in\n\t * pass1 so is there for the whole of pass 2 */\n\tif (value > 255) {\n REQUIRE_UNI_RULES(flagp, NULL);\n\t}\n\n /* Ready to process either the single value, or the completed range.\n * For single-valued non-inverted ranges, we consider the possibility\n * of multi-char folds. (We made a conscious decision to not do this\n * for the other cases because it can often lead to non-intuitive\n * results. For example, you have the peculiar case that:\n * \"s s\" =~ /^[^\\xDF]+$/i => Y\n * \"ss\" =~ /^[^\\xDF]+$/i => N\n *\n * See [perl #89750] */\n if (FOLD && allow_multi_folds && value == prevvalue) {\n if (value == LATIN_SMALL_LETTER_SHARP_S\n || (value > 255 && _invlist_contains_cp(PL_HasMultiCharFold,\n value)))\n {\n /* Here <value> is indeed a multi-char fold. Get what it is */\n\n U8 foldbuf[UTF8_MAXBYTES_CASE];\n STRLEN foldlen;\n\n UV folded = _to_uni_fold_flags(\n value,\n foldbuf,\n &foldlen,\n FOLD_FLAGS_FULL | (ASCII_FOLD_RESTRICTED\n ? FOLD_FLAGS_NOMIX_ASCII\n : 0)\n );\n\n /* Here, <folded> should be the first character of the\n * multi-char fold of <value>, with <foldbuf> containing the\n * whole thing. But, if this fold is not allowed (because of\n * the flags), <fold> will be the same as <value>, and should\n * be processed like any other character, so skip the special\n * handling */\n if (folded != value) {\n\n /* Skip if we are recursed, currently parsing the class\n * again. Otherwise add this character to the list of\n * multi-char folds. */\n if (! RExC_in_multi_char_class) {\n STRLEN cp_count = utf8_length(foldbuf,\n foldbuf + foldlen);\n SV* multi_fold = sv_2mortal(newSVpvs(\"\"));\n\n Perl_sv_catpvf(aTHX_ multi_fold, \"\\\\x{%\" UVXf \"}\", value);\n\n multi_char_matches\n = add_multi_match(multi_char_matches,\n multi_fold,\n cp_count);\n\n }\n\n /* This element should not be processed further in this\n * class */\n element_count--;\n value = save_value;\n prevvalue = save_prevvalue;\n continue;\n }\n }\n }\n\n if (strict && PASS2 && ckWARN(WARN_REGEXP)) {\n if (range) {\n\n /* If the range starts above 255, everything is portable and\n * likely to be so for any forseeable character set, so don't\n * warn. */\n if (unicode_range && non_portable_endpoint && prevvalue < 256) {\n vWARN(RExC_parse, \"Both or neither range ends should be Unicode\");\n }\n else if (prevvalue != value) {\n\n /* Under strict, ranges that stop and/or end in an ASCII\n * printable should have each end point be a portable value\n * for it (preferably like 'A', but we don't warn if it is\n * a (portable) Unicode name or code point), and the range\n * must be be all digits or all letters of the same case.\n * Otherwise, the range is non-portable and unclear as to\n * what it contains */\n if ( (isPRINT_A(prevvalue) || isPRINT_A(value))\n && ( non_portable_endpoint\n || ! ( (isDIGIT_A(prevvalue) && isDIGIT_A(value))\n || (isLOWER_A(prevvalue) && isLOWER_A(value))\n || (isUPPER_A(prevvalue) && isUPPER_A(value))\n ))) {\n vWARN(RExC_parse, \"Ranges of ASCII printables should\"\n \" be some subset of \\\"0-9\\\",\"\n \" \\\"A-Z\\\", or \\\"a-z\\\"\");\n }\n else if (prevvalue >= 0x660) { /* ARABIC_INDIC_DIGIT_ZERO */\n SSize_t index_start;\n SSize_t index_final;\n\n /* But the nature of Unicode and languages mean we\n * can't do the same checks for above-ASCII ranges,\n * except in the case of digit ones. These should\n * contain only digits from the same group of 10. The\n * ASCII case is handled just above. 0x660 is the\n * first digit character beyond ASCII. Hence here, the\n * range could be a range of digits. First some\n * unlikely special cases. Grandfather in that a range\n * ending in 19DA (NEW TAI LUE THAM DIGIT ONE) is bad\n * if its starting value is one of the 10 digits prior\n * to it. This is because it is an alternate way of\n * writing 19D1, and some people may expect it to be in\n * that group. But it is bad, because it won't give\n * the expected results. In Unicode 5.2 it was\n * considered to be in that group (of 11, hence), but\n * this was fixed in the next version */\n\n if (UNLIKELY(value == 0x19DA && prevvalue >= 0x19D0)) {\n goto warn_bad_digit_range;\n }\n else if (UNLIKELY( prevvalue >= 0x1D7CE\n && value <= 0x1D7FF))\n {\n /* This is the only other case currently in Unicode\n * where the algorithm below fails. The code\n * points just above are the end points of a single\n * range containing only decimal digits. It is 5\n * different series of 0-9. All other ranges of\n * digits currently in Unicode are just a single\n * series. (And mktables will notify us if a later\n * Unicode version breaks this.)\n *\n * If the range being checked is at most 9 long,\n * and the digit values represented are in\n * numerical order, they are from the same series.\n * */\n if ( value - prevvalue > 9\n || ((( value - 0x1D7CE) % 10)\n <= (prevvalue - 0x1D7CE) % 10))\n {\n goto warn_bad_digit_range;\n }\n }\n else {\n\n /* For all other ranges of digits in Unicode, the\n * algorithm is just to check if both end points\n * are in the same series, which is the same range.\n * */\n index_start = _invlist_search(\n PL_XPosix_ptrs[_CC_DIGIT],\n prevvalue);\n\n /* Warn if the range starts and ends with a digit,\n * and they are not in the same group of 10. */\n if ( index_start >= 0\n && ELEMENT_RANGE_MATCHES_INVLIST(index_start)\n && (index_final =\n _invlist_search(PL_XPosix_ptrs[_CC_DIGIT],\n value)) != index_start\n && index_final >= 0\n && ELEMENT_RANGE_MATCHES_INVLIST(index_final))\n {\n warn_bad_digit_range:\n vWARN(RExC_parse, \"Ranges of digits should be\"\n \" from the same group of\"\n \" 10\");\n }\n }\n }\n }\n }\n if ((! range || prevvalue == value) && non_portable_endpoint) {\n if (isPRINT_A(value)) {\n char literal[3];\n unsigned d = 0;\n if (isBACKSLASHED_PUNCT(value)) {\n literal[d++] = '\\\\';\n }\n literal[d++] = (char) value;\n literal[d++] = '\\0';\n\n vWARN4(RExC_parse,\n \"\\\"%.*s\\\" is more clearly written simply as \\\"%s\\\"\",\n (int) (RExC_parse - rangebegin),\n rangebegin,\n literal\n );\n }\n else if isMNEMONIC_CNTRL(value) {\n vWARN4(RExC_parse,\n \"\\\"%.*s\\\" is more clearly written simply as \\\"%s\\\"\",\n (int) (RExC_parse - rangebegin),\n rangebegin,\n cntrl_to_mnemonic((U8) value)\n );\n }\n }\n }\n\n /* Deal with this element of the class */\n\tif (! SIZE_ONLY) {\n\n#ifndef EBCDIC\n cp_foldable_list = _add_range_to_invlist(cp_foldable_list,\n prevvalue, value);\n#else\n /* On non-ASCII platforms, for ranges that span all of 0..255, and\n * ones that don't require special handling, we can just add the\n * range like we do for ASCII platforms */\n if ((UNLIKELY(prevvalue == 0) && value >= 255)\n || ! (prevvalue < 256\n && (unicode_range\n || (! non_portable_endpoint\n && ((isLOWER_A(prevvalue) && isLOWER_A(value))\n || (isUPPER_A(prevvalue)\n && isUPPER_A(value)))))))\n {\n cp_foldable_list = _add_range_to_invlist(cp_foldable_list,\n prevvalue, value);\n }\n else {\n /* Here, requires special handling. This can be because it is\n * a range whose code points are considered to be Unicode, and\n * so must be individually translated into native, or because\n * its a subrange of 'A-Z' or 'a-z' which each aren't\n * contiguous in EBCDIC, but we have defined them to include\n * only the \"expected\" upper or lower case ASCII alphabetics.\n * Subranges above 255 are the same in native and Unicode, so\n * can be added as a range */\n U8 start = NATIVE_TO_LATIN1(prevvalue);\n unsigned j;\n U8 end = (value < 256) ? NATIVE_TO_LATIN1(value) : 255;\n for (j = start; j <= end; j++) {\n cp_foldable_list = add_cp_to_invlist(cp_foldable_list, LATIN1_TO_NATIVE(j));\n }\n if (value > 255) {\n cp_foldable_list = _add_range_to_invlist(cp_foldable_list,\n 256, value);\n }\n }\n#endif\n }\n\n\trange = 0; /* this range (if it was one) is done now */\n } /* End of loop through all the text within the brackets */\n\n\n if ( posix_warnings && av_tindex_skip_len_mg(posix_warnings) >= 0) {\n output_or_return_posix_warnings(pRExC_state, posix_warnings,\n return_posix_warnings);\n }\n\n /* If anything in the class expands to more than one character, we have to\n * deal with them by building up a substitute parse string, and recursively\n * calling reg() on it, instead of proceeding */\n if (multi_char_matches) {\n\tSV * substitute_parse = newSVpvn_flags(\"?:\", 2, SVs_TEMP);\n I32 cp_count;\n\tSTRLEN len;\n\tchar *save_end = RExC_end;\n\tchar *save_parse = RExC_parse;\n\tchar *save_start = RExC_start;\n STRLEN prefix_end = 0; /* We copy the character class after a\n prefix supplied here. This is the size\n + 1 of that prefix */\n bool first_time = TRUE; /* First multi-char occurrence doesn't get\n a \"|\" */\n I32 reg_flags;\n\n assert(! invert);\n assert(RExC_precomp_adj == 0); /* Only one level of recursion allowed */\n\n#if 0 /* Have decided not to deal with multi-char folds in inverted classes,\n because too confusing */\n if (invert) {\n sv_catpv(substitute_parse, \"(?:\");\n }\n#endif\n\n /* Look at the longest folds first */\n for (cp_count = av_tindex_skip_len_mg(multi_char_matches);\n cp_count > 0;\n cp_count--)\n {\n\n if (av_exists(multi_char_matches, cp_count)) {\n AV** this_array_ptr;\n SV* this_sequence;\n\n this_array_ptr = (AV**) av_fetch(multi_char_matches,\n cp_count, FALSE);\n while ((this_sequence = av_pop(*this_array_ptr)) !=\n &PL_sv_undef)\n {\n if (! first_time) {\n sv_catpv(substitute_parse, \"|\");\n }\n first_time = FALSE;\n\n sv_catpv(substitute_parse, SvPVX(this_sequence));\n }\n }\n }\n\n /* If the character class contains anything else besides these\n * multi-character folds, have to include it in recursive parsing */\n if (element_count) {\n sv_catpv(substitute_parse, \"|[\");\n prefix_end = SvCUR(substitute_parse);\n sv_catpvn(substitute_parse, orig_parse, RExC_parse - orig_parse);\n\n /* Put in a closing ']' only if not going off the end, as otherwise\n * we are adding something that really isn't there */\n if (RExC_parse < RExC_end) {\n sv_catpv(substitute_parse, \"]\");\n }\n }\n\n sv_catpv(substitute_parse, \")\");\n#if 0\n if (invert) {\n /* This is a way to get the parse to skip forward a whole named\n * sequence instead of matching the 2nd character when it fails the\n * first */\n sv_catpv(substitute_parse, \"(*THEN)(*SKIP)(*FAIL)|.)\");\n }\n#endif\n\n /* Set up the data structure so that any errors will be properly\n * reported. See the comments at the definition of\n * REPORT_LOCATION_ARGS for details */\n RExC_precomp_adj = orig_parse - RExC_precomp;\n\tRExC_start = RExC_parse = SvPV(substitute_parse, len);\n RExC_adjusted_start = RExC_start + prefix_end;\n\tRExC_end = RExC_parse + len;\n RExC_in_multi_char_class = 1;\n RExC_emit = (regnode *)orig_emit;\n\n\tret = reg(pRExC_state, 1, ®_flags, depth+1);\n\n\t*flagp |= reg_flags&(HASWIDTH|SIMPLE|SPSTART|POSTPONED|RESTART_PASS1|NEED_UTF8);\n\n /* And restore so can parse the rest of the pattern */\n RExC_parse = save_parse;\n\tRExC_start = RExC_adjusted_start = save_start;\n RExC_precomp_adj = 0;\n\tRExC_end = save_end;\n\tRExC_in_multi_char_class = 0;\n SvREFCNT_dec_NN(multi_char_matches);\n return ret;\n }\n\n /* Here, we've gone through the entire class and dealt with multi-char\n * folds. We are now in a position that we can do some checks to see if we\n * can optimize this ANYOF node into a simpler one, even in Pass 1.\n * Currently we only do two checks:\n * 1) is in the unlikely event that the user has specified both, eg. \\w and\n * \\W under /l, then the class matches everything. (This optimization\n * is done only to make the optimizer code run later work.)\n * 2) if the character class contains only a single element (including a\n * single range), we see if there is an equivalent node for it.\n * Other checks are possible */\n if ( optimizable\n && ! ret_invlist /* Can't optimize if returning the constructed\n inversion list */\n && (UNLIKELY(posixl_matches_all) || element_count == 1))\n {\n U8 op = END;\n U8 arg = 0;\n\n if (UNLIKELY(posixl_matches_all)) {\n op = SANY;\n }\n else if (namedclass > OOB_NAMEDCLASS) { /* this is a single named\n class, like \\w or [:digit:]\n or \\p{foo} */\n\n /* All named classes are mapped into POSIXish nodes, with its FLAG\n * argument giving which class it is */\n switch ((I32)namedclass) {\n case ANYOF_UNIPROP:\n break;\n\n /* These don't depend on the charset modifiers. They always\n * match under /u rules */\n case ANYOF_NHORIZWS:\n case ANYOF_HORIZWS:\n namedclass = ANYOF_BLANK + namedclass - ANYOF_HORIZWS;\n /* FALLTHROUGH */\n\n case ANYOF_NVERTWS:\n case ANYOF_VERTWS:\n op = POSIXU;\n goto join_posix;\n\n /* The actual POSIXish node for all the rest depends on the\n * charset modifier. The ones in the first set depend only on\n * ASCII or, if available on this platform, also locale */\n case ANYOF_ASCII:\n case ANYOF_NASCII:\n#ifdef HAS_ISASCII\n op = (LOC) ? POSIXL : POSIXA;\n#else\n op = POSIXA;\n#endif\n goto join_posix;\n\n /* The following don't have any matches in the upper Latin1\n * range, hence /d is equivalent to /u for them. Making it /u\n * saves some branches at runtime */\n case ANYOF_DIGIT:\n case ANYOF_NDIGIT:\n case ANYOF_XDIGIT:\n case ANYOF_NXDIGIT:\n if (! DEPENDS_SEMANTICS) {\n goto treat_as_default;\n }\n\n op = POSIXU;\n goto join_posix;\n\n /* The following change to CASED under /i */\n case ANYOF_LOWER:\n case ANYOF_NLOWER:\n case ANYOF_UPPER:\n case ANYOF_NUPPER:\n if (FOLD) {\n namedclass = ANYOF_CASED + (namedclass % 2);\n }\n /* FALLTHROUGH */\n\n /* The rest have more possibilities depending on the charset.\n * We take advantage of the enum ordering of the charset\n * modifiers to get the exact node type, */\n default:\n treat_as_default:\n op = POSIXD + get_regex_charset(RExC_flags);\n if (op > POSIXA) { /* /aa is same as /a */\n op = POSIXA;\n }\n\n join_posix:\n /* The odd numbered ones are the complements of the\n * next-lower even number one */\n if (namedclass % 2 == 1) {\n invert = ! invert;\n namedclass--;\n }\n arg = namedclass_to_classnum(namedclass);\n break;\n }\n }\n else if (value == prevvalue) {\n\n /* Here, the class consists of just a single code point */\n\n if (invert) {\n if (! LOC && value == '\\n') {\n op = REG_ANY; /* Optimize [^\\n] */\n *flagp |= HASWIDTH|SIMPLE;\n MARK_NAUGHTY(1);\n }\n }\n else if (value < 256 || UTF) {\n\n /* Optimize a single value into an EXACTish node, but not if it\n * would require converting the pattern to UTF-8. */\n op = compute_EXACTish(pRExC_state);\n }\n } /* Otherwise is a range */\n else if (! LOC) { /* locale could vary these */\n if (prevvalue == '0') {\n if (value == '9') {\n arg = _CC_DIGIT;\n op = POSIXA;\n }\n }\n else if (! FOLD || ASCII_FOLD_RESTRICTED) {\n /* We can optimize A-Z or a-z, but not if they could match\n * something like the KELVIN SIGN under /i. */\n if (prevvalue == 'A') {\n if (value == 'Z'\n#ifdef EBCDIC\n && ! non_portable_endpoint\n#endif\n ) {\n arg = (FOLD) ? _CC_ALPHA : _CC_UPPER;\n op = POSIXA;\n }\n }\n else if (prevvalue == 'a') {\n if (value == 'z'\n#ifdef EBCDIC\n && ! non_portable_endpoint\n#endif\n ) {\n arg = (FOLD) ? _CC_ALPHA : _CC_LOWER;\n op = POSIXA;\n }\n }\n }\n }\n\n /* Here, we have changed <op> away from its initial value iff we found\n * an optimization */\n if (op != END) {\n\n /* Throw away this ANYOF regnode, and emit the calculated one,\n * which should correspond to the beginning, not current, state of\n * the parse */\n const char * cur_parse = RExC_parse;\n RExC_parse = (char *)orig_parse;\n if ( SIZE_ONLY) {\n if (! LOC) {\n\n /* To get locale nodes to not use the full ANYOF size would\n * require moving the code above that writes the portions\n * of it that aren't in other nodes to after this point.\n * e.g. ANYOF_POSIXL_SET */\n RExC_size = orig_size;\n }\n }\n else {\n RExC_emit = (regnode *)orig_emit;\n if (PL_regkind[op] == POSIXD) {\n if (op == POSIXL) {\n RExC_contains_locale = 1;\n }\n if (invert) {\n op += NPOSIXD - POSIXD;\n }\n }\n }\n\n ret = reg_node(pRExC_state, op);\n\n if (PL_regkind[op] == POSIXD || PL_regkind[op] == NPOSIXD) {\n if (! SIZE_ONLY) {\n FLAGS(ret) = arg;\n }\n *flagp |= HASWIDTH|SIMPLE;\n }\n else if (PL_regkind[op] == EXACT) {\n alloc_maybe_populate_EXACT(pRExC_state, ret, flagp, 0, value,\n TRUE /* downgradable to EXACT */\n );\n }\n\n RExC_parse = (char *) cur_parse;\n\n SvREFCNT_dec(posixes);\n SvREFCNT_dec(nposixes);\n SvREFCNT_dec(simple_posixes);\n SvREFCNT_dec(cp_list);\n SvREFCNT_dec(cp_foldable_list);\n return ret;\n }\n }\n\n if (SIZE_ONLY)\n return ret;\n /****** !SIZE_ONLY (Pass 2) AFTER HERE *********/\n\n /* If folding, we calculate all characters that could fold to or from the\n * ones already on the list */\n if (cp_foldable_list) {\n if (FOLD) {\n UV start, end;\t/* End points of code point ranges */\n\n SV* fold_intersection = NULL;\n SV** use_list;\n\n /* Our calculated list will be for Unicode rules. For locale\n * matching, we have to keep a separate list that is consulted at\n * runtime only when the locale indicates Unicode rules. For\n * non-locale, we just use the general list */\n if (LOC) {\n use_list = &only_utf8_locale_list;\n }\n else {\n use_list = &cp_list;\n }\n\n /* Only the characters in this class that participate in folds need\n * be checked. Get the intersection of this class and all the\n * possible characters that are foldable. This can quickly narrow\n * down a large class */\n _invlist_intersection(PL_utf8_foldable, cp_foldable_list,\n &fold_intersection);\n\n /* The folds for all the Latin1 characters are hard-coded into this\n * program, but we have to go out to disk to get the others. */\n if (invlist_highest(cp_foldable_list) >= 256) {\n\n /* This is a hash that for a particular fold gives all\n * characters that are involved in it */\n if (! PL_utf8_foldclosures) {\n _load_PL_utf8_foldclosures();\n }\n }\n\n /* Now look at the foldable characters in this class individually */\n invlist_iterinit(fold_intersection);\n while (invlist_iternext(fold_intersection, &start, &end)) {\n UV j;\n\n /* Look at every character in the range */\n for (j = start; j <= end; j++) {\n U8 foldbuf[UTF8_MAXBYTES_CASE+1];\n STRLEN foldlen;\n SV** listp;\n\n if (j < 256) {\n\n if (IS_IN_SOME_FOLD_L1(j)) {\n\n /* ASCII is always matched; non-ASCII is matched\n * only under Unicode rules (which could happen\n * under /l if the locale is a UTF-8 one */\n if (isASCII(j) || ! DEPENDS_SEMANTICS) {\n *use_list = add_cp_to_invlist(*use_list,\n PL_fold_latin1[j]);\n }\n else {\n has_upper_latin1_only_utf8_matches\n = add_cp_to_invlist(\n has_upper_latin1_only_utf8_matches,\n PL_fold_latin1[j]);\n }\n }\n\n if (HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(j)\n && (! isASCII(j) || ! ASCII_FOLD_RESTRICTED))\n {\n add_above_Latin1_folds(pRExC_state,\n (U8) j,\n use_list);\n }\n continue;\n }\n\n /* Here is an above Latin1 character. We don't have the\n * rules hard-coded for it. First, get its fold. This is\n * the simple fold, as the multi-character folds have been\n * handled earlier and separated out */\n _to_uni_fold_flags(j, foldbuf, &foldlen,\n (ASCII_FOLD_RESTRICTED)\n ? FOLD_FLAGS_NOMIX_ASCII\n : 0);\n\n /* Single character fold of above Latin1. Add everything in\n * its fold closure to the list that this node should match.\n * The fold closures data structure is a hash with the keys\n * being the UTF-8 of every character that is folded to, like\n * 'k', and the values each an array of all code points that\n * fold to its key. e.g. [ 'k', 'K', KELVIN_SIGN ].\n * Multi-character folds are not included */\n if ((listp = hv_fetch(PL_utf8_foldclosures,\n (char *) foldbuf, foldlen, FALSE)))\n {\n AV* list = (AV*) *listp;\n IV k;\n for (k = 0; k <= av_tindex_skip_len_mg(list); k++) {\n SV** c_p = av_fetch(list, k, FALSE);\n UV c;\n assert(c_p);\n\n c = SvUV(*c_p);\n\n /* /aa doesn't allow folds between ASCII and non- */\n if ((ASCII_FOLD_RESTRICTED\n && (isASCII(c) != isASCII(j))))\n {\n continue;\n }\n\n /* Folds under /l which cross the 255/256 boundary\n * are added to a separate list. (These are valid\n * only when the locale is UTF-8.) */\n if (c < 256 && LOC) {\n *use_list = add_cp_to_invlist(*use_list, c);\n continue;\n }\n\n if (isASCII(c) || c > 255 || AT_LEAST_UNI_SEMANTICS)\n {\n cp_list = add_cp_to_invlist(cp_list, c);\n }\n else {\n /* Similarly folds involving non-ascii Latin1\n * characters under /d are added to their list */\n has_upper_latin1_only_utf8_matches\n = add_cp_to_invlist(\n has_upper_latin1_only_utf8_matches,\n c);\n }\n }\n }\n }\n }\n SvREFCNT_dec_NN(fold_intersection);\n }\n\n /* Now that we have finished adding all the folds, there is no reason\n * to keep the foldable list separate */\n _invlist_union(cp_list, cp_foldable_list, &cp_list);\n\tSvREFCNT_dec_NN(cp_foldable_list);\n }\n\n /* And combine the result (if any) with any inversion lists from posix\n * classes. The lists are kept separate up to now because we don't want to\n * fold the classes (folding of those is automatically handled by the swash\n * fetching code) */\n if (simple_posixes) { /* These are the classes known to be unaffected by\n /a, /aa, and /d */\n if (cp_list) {\n _invlist_union(cp_list, simple_posixes, &cp_list);\n SvREFCNT_dec_NN(simple_posixes);\n }\n else {\n cp_list = simple_posixes;\n }\n }\n if (posixes || nposixes) {\n\n /* We have to adjust /a and /aa */\n if (AT_LEAST_ASCII_RESTRICTED) {\n\n /* Under /a and /aa, nothing above ASCII matches these */\n if (posixes) {\n _invlist_intersection(posixes,\n PL_XPosix_ptrs[_CC_ASCII],\n &posixes);\n }\n\n /* Under /a and /aa, everything above ASCII matches these\n * complements */\n if (nposixes) {\n _invlist_union_complement_2nd(nposixes,\n PL_XPosix_ptrs[_CC_ASCII],\n &nposixes);\n }\n }\n\n if (! DEPENDS_SEMANTICS) {\n\n /* For everything but /d, we can just add the current 'posixes' and\n * 'nposixes' to the main list */\n if (posixes) {\n if (cp_list) {\n _invlist_union(cp_list, posixes, &cp_list);\n SvREFCNT_dec_NN(posixes);\n }\n else {\n cp_list = posixes;\n }\n }\n if (nposixes) {\n if (cp_list) {\n _invlist_union(cp_list, nposixes, &cp_list);\n SvREFCNT_dec_NN(nposixes);\n }\n else {\n cp_list = nposixes;\n }\n }\n }\n else {\n /* Under /d, things like \\w match upper Latin1 characters only if\n * the target string is in UTF-8. But things like \\W match all the\n * upper Latin1 characters if the target string is not in UTF-8.\n *\n * Handle the case where there something like \\W separately */\n if (nposixes) {\n SV* only_non_utf8_list = invlist_clone(PL_UpperLatin1);\n\n /* A complemented posix class matches all upper Latin1\n * characters if not in UTF-8. And it matches just certain\n * ones when in UTF-8. That means those certain ones are\n * matched regardless, so can just be added to the\n * unconditional list */\n if (cp_list) {\n _invlist_union(cp_list, nposixes, &cp_list);\n SvREFCNT_dec_NN(nposixes);\n nposixes = NULL;\n }\n else {\n cp_list = nposixes;\n }\n\n /* Likewise for 'posixes' */\n _invlist_union(posixes, cp_list, &cp_list);\n\n /* Likewise for anything else in the range that matched only\n * under UTF-8 */\n if (has_upper_latin1_only_utf8_matches) {\n _invlist_union(cp_list,\n has_upper_latin1_only_utf8_matches,\n &cp_list);\n SvREFCNT_dec_NN(has_upper_latin1_only_utf8_matches);\n has_upper_latin1_only_utf8_matches = NULL;\n }\n\n /* If we don't match all the upper Latin1 characters regardless\n * of UTF-8ness, we have to set a flag to match the rest when\n * not in UTF-8 */\n _invlist_subtract(only_non_utf8_list, cp_list,\n &only_non_utf8_list);\n if (_invlist_len(only_non_utf8_list) != 0) {\n ANYOF_FLAGS(ret) |= ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER;\n }\n }\n else {\n /* Here there were no complemented posix classes. That means\n * the upper Latin1 characters in 'posixes' match only when the\n * target string is in UTF-8. So we have to add them to the\n * list of those types of code points, while adding the\n * remainder to the unconditional list.\n *\n * First calculate what they are */\n SV* nonascii_but_latin1_properties = NULL;\n _invlist_intersection(posixes, PL_UpperLatin1,\n &nonascii_but_latin1_properties);\n\n /* And add them to the final list of such characters. */\n _invlist_union(has_upper_latin1_only_utf8_matches,\n nonascii_but_latin1_properties,\n &has_upper_latin1_only_utf8_matches);\n\n /* Remove them from what now becomes the unconditional list */\n _invlist_subtract(posixes, nonascii_but_latin1_properties,\n &posixes);\n\n /* And add those unconditional ones to the final list */\n if (cp_list) {\n _invlist_union(cp_list, posixes, &cp_list);\n SvREFCNT_dec_NN(posixes);\n posixes = NULL;\n }\n else {\n cp_list = posixes;\n }\n\n SvREFCNT_dec(nonascii_but_latin1_properties);\n\n /* Get rid of any characters that we now know are matched\n * unconditionally from the conditional list, which may make\n * that list empty */\n _invlist_subtract(has_upper_latin1_only_utf8_matches,\n cp_list,\n &has_upper_latin1_only_utf8_matches);\n if (_invlist_len(has_upper_latin1_only_utf8_matches) == 0) {\n SvREFCNT_dec_NN(has_upper_latin1_only_utf8_matches);\n has_upper_latin1_only_utf8_matches = NULL;\n }\n }\n }\n }\n\n /* And combine the result (if any) with any inversion list from properties.\n * The lists are kept separate up to now so that we can distinguish the two\n * in regards to matching above-Unicode. A run-time warning is generated\n * if a Unicode property is matched against a non-Unicode code point. But,\n * we allow user-defined properties to match anything, without any warning,\n * and we also suppress the warning if there is a portion of the character\n * class that isn't a Unicode property, and which matches above Unicode, \\W\n * or [\\x{110000}] for example.\n * (Note that in this case, unlike the Posix one above, there is no\n * <has_upper_latin1_only_utf8_matches>, because having a Unicode property\n * forces Unicode semantics */\n if (properties) {\n if (cp_list) {\n\n /* If it matters to the final outcome, see if a non-property\n * component of the class matches above Unicode. If so, the\n * warning gets suppressed. This is true even if just a single\n * such code point is specified, as, though not strictly correct if\n * another such code point is matched against, the fact that they\n * are using above-Unicode code points indicates they should know\n * the issues involved */\n if (warn_super) {\n warn_super = ! (invert\n ^ (invlist_highest(cp_list) > PERL_UNICODE_MAX));\n }\n\n _invlist_union(properties, cp_list, &cp_list);\n SvREFCNT_dec_NN(properties);\n }\n else {\n cp_list = properties;\n }\n\n if (warn_super) {\n ANYOF_FLAGS(ret)\n |= ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER;\n\n /* Because an ANYOF node is the only one that warns, this node\n * can't be optimized into something else */\n optimizable = FALSE;\n }\n }\n\n /* Here, we have calculated what code points should be in the character\n * class.\n *\n * Now we can see about various optimizations. Fold calculation (which we\n * did above) needs to take place before inversion. Otherwise /[^k]/i\n * would invert to include K, which under /i would match k, which it\n * shouldn't. Therefore we can't invert folded locale now, as it won't be\n * folded until runtime */\n\n /* If we didn't do folding, it's because some information isn't available\n * until runtime; set the run-time fold flag for these. (We don't have to\n * worry about properties folding, as that is taken care of by the swash\n * fetching). We know to set the flag if we have a non-NULL list for UTF-8\n * locales, or the class matches at least one 0-255 range code point */\n if (LOC && FOLD) {\n\n /* Some things on the list might be unconditionally included because of\n * other components. Remove them, and clean up the list if it goes to\n * 0 elements */\n if (only_utf8_locale_list && cp_list) {\n _invlist_subtract(only_utf8_locale_list, cp_list,\n &only_utf8_locale_list);\n\n if (_invlist_len(only_utf8_locale_list) == 0) {\n SvREFCNT_dec_NN(only_utf8_locale_list);\n only_utf8_locale_list = NULL;\n }\n }\n if (only_utf8_locale_list) {\n ANYOF_FLAGS(ret)\n |= ANYOFL_FOLD\n |ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD;\n }\n else if (cp_list) { /* Look to see if a 0-255 code point is in list */\n UV start, end;\n invlist_iterinit(cp_list);\n if (invlist_iternext(cp_list, &start, &end) && start < 256) {\n ANYOF_FLAGS(ret) |= ANYOFL_FOLD;\n }\n invlist_iterfinish(cp_list);\n }\n }\n else if ( DEPENDS_SEMANTICS\n && ( has_upper_latin1_only_utf8_matches\n || (ANYOF_FLAGS(ret) & ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER)))\n {\n OP(ret) = ANYOFD;\n optimizable = FALSE;\n }\n\n\n /* Optimize inverted simple patterns (e.g. [^a-z]) when everything is known\n * at compile time. Besides not inverting folded locale now, we can't\n * invert if there are things such as \\w, which aren't known until runtime\n * */\n if (cp_list\n && invert\n && OP(ret) != ANYOFD\n && ! (ANYOF_FLAGS(ret) & (ANYOF_LOCALE_FLAGS))\n\t&& ! HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION)\n {\n _invlist_invert(cp_list);\n\n /* Any swash can't be used as-is, because we've inverted things */\n if (swash) {\n SvREFCNT_dec_NN(swash);\n swash = NULL;\n }\n\n\t/* Clear the invert flag since have just done it here */\n\tinvert = FALSE;\n }\n\n if (ret_invlist) {\n assert(cp_list);\n\n *ret_invlist = cp_list;\n SvREFCNT_dec(swash);\n\n /* Discard the generated node */\n if (SIZE_ONLY) {\n RExC_size = orig_size;\n }\n else {\n RExC_emit = orig_emit;\n }\n return orig_emit;\n }\n\n /* Some character classes are equivalent to other nodes. Such nodes take\n * up less room and generally fewer operations to execute than ANYOF nodes.\n * Above, we checked for and optimized into some such equivalents for\n * certain common classes that are easy to test. Getting to this point in\n * the code means that the class didn't get optimized there. Since this\n * code is only executed in Pass 2, it is too late to save space--it has\n * been allocated in Pass 1, and currently isn't given back. But turning\n * things into an EXACTish node can allow the optimizer to join it to any\n * adjacent such nodes. And if the class is equivalent to things like /./,\n * expensive run-time swashes can be avoided. Now that we have more\n * complete information, we can find things necessarily missed by the\n * earlier code. Another possible \"optimization\" that isn't done is that\n * something like [Ee] could be changed into an EXACTFU. khw tried this\n * and found that the ANYOF is faster, including for code points not in the\n * bitmap. This still might make sense to do, provided it got joined with\n * an adjacent node(s) to create a longer EXACTFU one. This could be\n * accomplished by creating a pseudo ANYOF_EXACTFU node type that the join\n * routine would know is joinable. If that didn't happen, the node type\n * could then be made a straight ANYOF */\n\n if (optimizable && cp_list && ! invert) {\n UV start, end;\n U8 op = END; /* The optimzation node-type */\n int posix_class = -1; /* Illegal value */\n const char * cur_parse= RExC_parse;\n\n invlist_iterinit(cp_list);\n if (! invlist_iternext(cp_list, &start, &end)) {\n\n /* Here, the list is empty. This happens, for example, when a\n * Unicode property that doesn't match anything is the only element\n * in the character class (perluniprops.pod notes such properties).\n * */\n op = OPFAIL;\n *flagp |= HASWIDTH|SIMPLE;\n }\n else if (start == end) { /* The range is a single code point */\n if (! invlist_iternext(cp_list, &start, &end)\n\n /* Don't do this optimization if it would require changing\n * the pattern to UTF-8 */\n && (start < 256 || UTF))\n {\n /* Here, the list contains a single code point. Can optimize\n * into an EXACTish node */\n\n value = start;\n\n if (! FOLD) {\n op = (LOC)\n ? EXACTL\n : EXACT;\n }\n else if (LOC) {\n\n /* A locale node under folding with one code point can be\n * an EXACTFL, as its fold won't be calculated until\n * runtime */\n op = EXACTFL;\n }\n else {\n\n /* Here, we are generally folding, but there is only one\n * code point to match. If we have to, we use an EXACT\n * node, but it would be better for joining with adjacent\n * nodes in the optimization pass if we used the same\n * EXACTFish node that any such are likely to be. We can\n * do this iff the code point doesn't participate in any\n * folds. For example, an EXACTF of a colon is the same as\n * an EXACT one, since nothing folds to or from a colon. */\n if (value < 256) {\n if (IS_IN_SOME_FOLD_L1(value)) {\n op = EXACT;\n }\n }\n else {\n if (_invlist_contains_cp(PL_utf8_foldable, value)) {\n op = EXACT;\n }\n }\n\n /* If we haven't found the node type, above, it means we\n * can use the prevailing one */\n if (op == END) {\n op = compute_EXACTish(pRExC_state);\n }\n }\n }\n } /* End of first range contains just a single code point */\n else if (start == 0) {\n if (end == UV_MAX) {\n op = SANY;\n *flagp |= HASWIDTH|SIMPLE;\n MARK_NAUGHTY(1);\n }\n else if (end == '\\n' - 1\n && invlist_iternext(cp_list, &start, &end)\n && start == '\\n' + 1 && end == UV_MAX)\n {\n op = REG_ANY;\n *flagp |= HASWIDTH|SIMPLE;\n MARK_NAUGHTY(1);\n }\n }\n invlist_iterfinish(cp_list);\n\n if (op == END) {\n const UV cp_list_len = _invlist_len(cp_list);\n const UV* cp_list_array = invlist_array(cp_list);\n\n /* Here, didn't find an optimization. See if this matches any of\n * the POSIX classes. These run slightly faster for above-Unicode\n * code points, so don't bother with POSIXA ones nor the 2 that\n * have no above-Unicode matches. We can avoid these checks unless\n * the ANYOF matches at least as high as the lowest POSIX one\n * (which was manually found to be \\v. The actual code point may\n * increase in later Unicode releases, if a higher code point is\n * assigned to be \\v, but this code will never break. It would\n * just mean we could execute the checks for posix optimizations\n * unnecessarily) */\n\n if (cp_list_array[cp_list_len-1] > 0x2029) {\n for (posix_class = 0;\n posix_class <= _HIGHEST_REGCOMP_DOT_H_SYNC;\n posix_class++)\n {\n int try_inverted;\n if (posix_class == _CC_ASCII || posix_class == _CC_CNTRL) {\n continue;\n }\n for (try_inverted = 0; try_inverted < 2; try_inverted++) {\n\n /* Check if matches normal or inverted */\n if (_invlistEQ(cp_list,\n PL_XPosix_ptrs[posix_class],\n try_inverted))\n {\n op = (try_inverted)\n ? NPOSIXU\n : POSIXU;\n *flagp |= HASWIDTH|SIMPLE;\n goto found_posix;\n }\n }\n }\n found_posix: ;\n }\n }\n\n if (op != END) {\n RExC_parse = (char *)orig_parse;\n RExC_emit = (regnode *)orig_emit;\n\n if (regarglen[op]) {\n ret = reganode(pRExC_state, op, 0);\n } else {\n ret = reg_node(pRExC_state, op);\n }\n\n RExC_parse = (char *)cur_parse;\n\n if (PL_regkind[op] == EXACT) {\n alloc_maybe_populate_EXACT(pRExC_state, ret, flagp, 0, value,\n TRUE /* downgradable to EXACT */\n );\n }\n else if (PL_regkind[op] == POSIXD || PL_regkind[op] == NPOSIXD) {\n FLAGS(ret) = posix_class;\n }\n\n SvREFCNT_dec_NN(cp_list);\n return ret;\n }\n }\n\n /* Here, <cp_list> contains all the code points we can determine at\n * compile time that match under all conditions. Go through it, and\n * for things that belong in the bitmap, put them there, and delete from\n * <cp_list>. While we are at it, see if everything above 255 is in the\n * list, and if so, set a flag to speed up execution */\n\n populate_ANYOF_from_invlist(ret, &cp_list);\n\n if (invert) {\n ANYOF_FLAGS(ret) |= ANYOF_INVERT;\n }\n\n /* Here, the bitmap has been populated with all the Latin1 code points that\n * always match. Can now add to the overall list those that match only\n * when the target string is UTF-8 (<has_upper_latin1_only_utf8_matches>).\n * */\n if (has_upper_latin1_only_utf8_matches) {\n\tif (cp_list) {\n\t _invlist_union(cp_list,\n has_upper_latin1_only_utf8_matches,\n &cp_list);\n\t SvREFCNT_dec_NN(has_upper_latin1_only_utf8_matches);\n\t}\n\telse {\n\t cp_list = has_upper_latin1_only_utf8_matches;\n\t}\n ANYOF_FLAGS(ret) |= ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP;\n }\n\n /* If there is a swash and more than one element, we can't use the swash in\n * the optimization below. */\n if (swash && element_count > 1) {\n\tSvREFCNT_dec_NN(swash);\n\tswash = NULL;\n }\n\n /* Note that the optimization of using 'swash' if it is the only thing in\n * the class doesn't have us change swash at all, so it can include things\n * that are also in the bitmap; otherwise we have purposely deleted that\n * duplicate information */\n set_ANYOF_arg(pRExC_state, ret, cp_list,\n (HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION)\n ? listsv : NULL,\n only_utf8_locale_list,\n swash, has_user_defined_property);\n\n *flagp |= HASWIDTH|SIMPLE;\n\n if (ANYOF_FLAGS(ret) & ANYOF_LOCALE_FLAGS) {\n RExC_contains_locale = 1;\n }\n\n return ret;\n}\n\n#undef HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION\n\nSTATIC void\nS_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state,\n regnode* const node,\n SV* const cp_list,\n SV* const runtime_defns,\n SV* const only_utf8_locale_list,\n SV* const swash,\n const bool has_user_defined_property)\n{\n /* Sets the arg field of an ANYOF-type node 'node', using information about\n * the node passed-in. If there is nothing outside the node's bitmap, the\n * arg is set to ANYOF_ONLY_HAS_BITMAP. Otherwise, it sets the argument to\n * the count returned by add_data(), having allocated and stored an array,\n * av, that that count references, as follows:\n * av[0] stores the character class description in its textual form.\n * This is used later (regexec.c:Perl_regclass_swash()) to\n * initialize the appropriate swash, and is also useful for dumping\n * the regnode. This is set to &PL_sv_undef if the textual\n * description is not needed at run-time (as happens if the other\n * elements completely define the class)\n * av[1] if &PL_sv_undef, is a placeholder to later contain the swash\n * computed from av[0]. But if no further computation need be done,\n * the swash is stored here now (and av[0] is &PL_sv_undef).\n * av[2] stores the inversion list of code points that match only if the\n * current locale is UTF-8\n * av[3] stores the cp_list inversion list for use in addition or instead\n * of av[0]; used only if cp_list exists and av[1] is &PL_sv_undef.\n * (Otherwise everything needed is already in av[0] and av[1])\n * av[4] is set if any component of the class is from a user-defined\n * property; used only if av[3] exists */\n\n UV n;\n\n PERL_ARGS_ASSERT_SET_ANYOF_ARG;\n\n if (! cp_list && ! runtime_defns && ! only_utf8_locale_list) {\n assert(! (ANYOF_FLAGS(node)\n & ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP));\n\tARG_SET(node, ANYOF_ONLY_HAS_BITMAP);\n }\n else {\n\tAV * const av = newAV();\n\tSV *rv;\n\n\tav_store(av, 0, (runtime_defns)\n\t\t\t? SvREFCNT_inc(runtime_defns) : &PL_sv_undef);\n\tif (swash) {\n\t assert(cp_list);\n\t av_store(av, 1, swash);\n\t SvREFCNT_dec_NN(cp_list);\n\t}\n\telse {\n\t av_store(av, 1, &PL_sv_undef);\n\t if (cp_list) {\n\t\tav_store(av, 3, cp_list);\n\t\tav_store(av, 4, newSVuv(has_user_defined_property));\n\t }\n\t}\n\n if (only_utf8_locale_list) {\n\t av_store(av, 2, only_utf8_locale_list);\n }\n else {\n\t av_store(av, 2, &PL_sv_undef);\n }\n\n\trv = newRV_noinc(MUTABLE_SV(av));\n\tn = add_data(pRExC_state, STR_WITH_LEN(\"s\"));\n\tRExC_rxi->data->data[n] = (void*)rv;\n\tARG_SET(node, n);\n }\n}\n\n#if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)\nSV *\nPerl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog,\n const regnode* node,\n bool doinit,\n SV** listsvp,\n SV** only_utf8_locale_ptr,\n SV** output_invlist)\n\n{\n /* For internal core use only.\n * Returns the swash for the input 'node' in the regex 'prog'.\n * If <doinit> is 'true', will attempt to create the swash if not already\n *\t done.\n * If <listsvp> is non-null, will return the printable contents of the\n * swash. This can be used to get debugging information even before the\n * swash exists, by calling this function with 'doinit' set to false, in\n * which case the components that will be used to eventually create the\n * swash are returned (in a printable form).\n * If <only_utf8_locale_ptr> is not NULL, it is where this routine is to\n * store an inversion list of code points that should match only if the\n * execution-time locale is a UTF-8 one.\n * If <output_invlist> is not NULL, it is where this routine is to store an\n * inversion list of the code points that would be instead returned in\n * <listsvp> if this were NULL. Thus, what gets output in <listsvp>\n * when this parameter is used, is just the non-code point data that\n * will go into creating the swash. This currently should be just\n * user-defined properties whose definitions were not known at compile\n * time. Using this parameter allows for easier manipulation of the\n * swash's data by the caller. It is illegal to call this function with\n * this parameter set, but not <listsvp>\n *\n * Tied intimately to how S_set_ANYOF_arg sets up the data structure. Note\n * that, in spite of this function's name, the swash it returns may include\n * the bitmap data as well */\n\n SV *sw = NULL;\n SV *si = NULL; /* Input swash initialization string */\n SV* invlist = NULL;\n\n RXi_GET_DECL(prog,progi);\n const struct reg_data * const data = prog ? progi->data : NULL;\n\n PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA;\n assert(! output_invlist || listsvp);\n\n if (data && data->count) {\n\tconst U32 n = ARG(node);\n\n\tif (data->what[n] == 's') {\n\t SV * const rv = MUTABLE_SV(data->data[n]);\n\t AV * const av = MUTABLE_AV(SvRV(rv));\n\t SV **const ary = AvARRAY(av);\n\t U8 swash_init_flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;\n\n\t si = *ary;\t/* ary[0] = the string to initialize the swash with */\n\n if (av_tindex_skip_len_mg(av) >= 2) {\n if (only_utf8_locale_ptr\n && ary[2]\n && ary[2] != &PL_sv_undef)\n {\n *only_utf8_locale_ptr = ary[2];\n }\n else {\n assert(only_utf8_locale_ptr);\n *only_utf8_locale_ptr = NULL;\n }\n\n /* Elements 3 and 4 are either both present or both absent. [3]\n * is any inversion list generated at compile time; [4]\n * indicates if that inversion list has any user-defined\n * properties in it. */\n if (av_tindex_skip_len_mg(av) >= 3) {\n invlist = ary[3];\n if (SvUV(ary[4])) {\n swash_init_flags |= _CORE_SWASH_INIT_USER_DEFINED_PROPERTY;\n }\n }\n else {\n invlist = NULL;\n }\n\t }\n\n\t /* Element [1] is reserved for the set-up swash. If already there,\n\t * return it; if not, create it and store it there */\n\t if (ary[1] && SvROK(ary[1])) {\n\t\tsw = ary[1];\n\t }\n\t else if (doinit && ((si && si != &PL_sv_undef)\n || (invlist && invlist != &PL_sv_undef))) {\n\t\tassert(si);\n\t\tsw = _core_swash_init(\"utf8\", /* the utf8 package */\n\t\t\t\t \"\", /* nameless */\n\t\t\t\t si,\n\t\t\t\t 1, /* binary */\n\t\t\t\t 0, /* not from tr/// */\n\t\t\t\t invlist,\n\t\t\t\t &swash_init_flags);\n\t\t(void)av_store(av, 1, sw);\n\t }\n\t}\n }\n\n /* If requested, return a printable version of what this swash matches */\n if (listsvp) {\n\tSV* matches_string = NULL;\n\n /* The swash should be used, if possible, to get the data, as it\n * contains the resolved data. But this function can be called at\n * compile-time, before everything gets resolved, in which case we\n * return the currently best available information, which is the string\n * that will eventually be used to do that resolving, 'si' */\n\tif ((! sw || (invlist = _get_swash_invlist(sw)) == NULL)\n && (si && si != &PL_sv_undef))\n {\n /* Here, we only have 'si' (and possibly some passed-in data in\n * 'invlist', which is handled below) If the caller only wants\n * 'si', use that. */\n if (! output_invlist) {\n matches_string = newSVsv(si);\n }\n else {\n /* But if the caller wants an inversion list of the node, we\n * need to parse 'si' and place as much as possible in the\n * desired output inversion list, making 'matches_string' only\n * contain the currently unresolvable things */\n const char *si_string = SvPVX(si);\n STRLEN remaining = SvCUR(si);\n UV prev_cp = 0;\n U8 count = 0;\n\n /* Ignore everything before the first new-line */\n while (*si_string != '\\n' && remaining > 0) {\n si_string++;\n remaining--;\n }\n assert(remaining > 0);\n\n si_string++;\n remaining--;\n\n while (remaining > 0) {\n\n /* The data consists of just strings defining user-defined\n * property names, but in prior incarnations, and perhaps\n * somehow from pluggable regex engines, it could still\n * hold hex code point definitions. Each component of a\n * range would be separated by a tab, and each range by a\n * new-line. If these are found, instead add them to the\n * inversion list */\n I32 grok_flags = PERL_SCAN_SILENT_ILLDIGIT\n |PERL_SCAN_SILENT_NON_PORTABLE;\n STRLEN len = remaining;\n UV cp = grok_hex(si_string, &len, &grok_flags, NULL);\n\n /* If the hex decode routine found something, it should go\n * up to the next \\n */\n if ( *(si_string + len) == '\\n') {\n if (count) { /* 2nd code point on line */\n *output_invlist = _add_range_to_invlist(*output_invlist, prev_cp, cp);\n }\n else {\n *output_invlist = add_cp_to_invlist(*output_invlist, cp);\n }\n count = 0;\n goto prepare_for_next_iteration;\n }\n\n /* If the hex decode was instead for the lower range limit,\n * save it, and go parse the upper range limit */\n if (*(si_string + len) == '\\t') {\n assert(count == 0);\n\n prev_cp = cp;\n count = 1;\n prepare_for_next_iteration:\n si_string += len + 1;\n remaining -= len + 1;\n continue;\n }\n\n /* Here, didn't find a legal hex number. Just add it from\n * here to the next \\n */\n\n remaining -= len;\n while (*(si_string + len) != '\\n' && remaining > 0) {\n remaining--;\n len++;\n }\n if (*(si_string + len) == '\\n') {\n len++;\n remaining--;\n }\n if (matches_string) {\n sv_catpvn(matches_string, si_string, len - 1);\n }\n else {\n matches_string = newSVpvn(si_string, len - 1);\n }\n si_string += len;\n sv_catpvs(matches_string, \" \");\n } /* end of loop through the text */\n\n assert(matches_string);\n if (SvCUR(matches_string)) { /* Get rid of trailing blank */\n SvCUR_set(matches_string, SvCUR(matches_string) - 1);\n }\n } /* end of has an 'si' but no swash */\n\t}\n\n /* If we have a swash in place, its equivalent inversion list was above\n * placed into 'invlist'. If not, this variable may contain a stored\n * inversion list which is information beyond what is in 'si' */\n if (invlist) {\n\n /* Again, if the caller doesn't want the output inversion list, put\n * everything in 'matches-string' */\n if (! output_invlist) {\n if ( ! matches_string) {\n matches_string = newSVpvs(\"\\n\");\n }\n sv_catsv(matches_string, invlist_contents(invlist,\n TRUE /* traditional style */\n ));\n }\n else if (! *output_invlist) {\n *output_invlist = invlist_clone(invlist);\n }\n else {\n _invlist_union(*output_invlist, invlist, output_invlist);\n }\n }\n\n\t*listsvp = matches_string;\n }\n\n return sw;\n}\n#endif /* !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION) */\n\n/* reg_skipcomment()\n\n Absorbs an /x style # comment from the input stream,\n returning a pointer to the first character beyond the comment, or if the\n comment terminates the pattern without anything following it, this returns\n one past the final character of the pattern (in other words, RExC_end) and\n sets the REG_RUN_ON_COMMENT_SEEN flag.\n\n Note it's the callers responsibility to ensure that we are\n actually in /x mode\n\n*/\n\nPERL_STATIC_INLINE char*\nS_reg_skipcomment(RExC_state_t *pRExC_state, char* p)\n{\n PERL_ARGS_ASSERT_REG_SKIPCOMMENT;\n\n assert(*p == '#');\n\n while (p < RExC_end) {\n if (*(++p) == '\\n') {\n return p+1;\n }\n }\n\n /* we ran off the end of the pattern without ending the comment, so we have\n * to add an \\n when wrapping */\n RExC_seen |= REG_RUN_ON_COMMENT_SEEN;\n return p;\n}\n\nSTATIC void\nS_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state,\n char ** p,\n const bool force_to_xmod\n )\n{\n /* If the text at the current parse position '*p' is a '(?#...)' comment,\n * or if we are under /x or 'force_to_xmod' is TRUE, and the text at '*p'\n * is /x whitespace, advance '*p' so that on exit it points to the first\n * byte past all such white space and comments */\n\n const bool use_xmod = force_to_xmod || (RExC_flags & RXf_PMf_EXTENDED);\n\n PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT;\n\n assert( ! UTF || UTF8_IS_INVARIANT(**p) || UTF8_IS_START(**p));\n\n for (;;) {\n\tif (RExC_end - (*p) >= 3\n\t && *(*p) == '('\n\t && *(*p + 1) == '?'\n\t && *(*p + 2) == '#')\n\t{\n\t while (*(*p) != ')') {\n\t\tif ((*p) == RExC_end)\n\t\t FAIL(\"Sequence (?#... not terminated\");\n\t\t(*p)++;\n\t }\n\t (*p)++;\n\t continue;\n\t}\n\n\tif (use_xmod) {\n const char * save_p = *p;\n while ((*p) < RExC_end) {\n STRLEN len;\n if ((len = is_PATWS_safe((*p), RExC_end, UTF))) {\n (*p) += len;\n }\n else if (*(*p) == '#') {\n (*p) = reg_skipcomment(pRExC_state, (*p));\n }\n else {\n break;\n }\n }\n if (*p != save_p) {\n continue;\n }\n\t}\n\n break;\n }\n\n return;\n}\n\n/* nextchar()\n\n Advances the parse position by one byte, unless that byte is the beginning\n of a '(?#...)' style comment, or is /x whitespace and /x is in effect. In\n those two cases, the parse position is advanced beyond all such comments and\n white space.\n\n This is the UTF, (?#...), and /x friendly way of saying RExC_parse++.\n*/\n\nSTATIC void\nS_nextchar(pTHX_ RExC_state_t *pRExC_state)\n{\n PERL_ARGS_ASSERT_NEXTCHAR;\n\n if (RExC_parse < RExC_end) {\n assert( ! UTF\n || UTF8_IS_INVARIANT(*RExC_parse)\n || UTF8_IS_START(*RExC_parse));\n\n RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;\n\n skip_to_be_ignored_text(pRExC_state, &RExC_parse,\n FALSE /* Don't force /x */ );\n }\n}\n\nSTATIC regnode *\nS_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_size, const char* const name)\n{\n /* Allocate a regnode for 'op' and returns it, with 'extra_size' extra\n * space. In pass1, it aligns and increments RExC_size; in pass2,\n * RExC_emit */\n\n regnode * const ret = RExC_emit;\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGNODE_GUTS;\n\n assert(extra_size >= regarglen[op]);\n\n if (SIZE_ONLY) {\n\tSIZE_ALIGN(RExC_size);\n\tRExC_size += 1 + extra_size;\n\treturn(ret);\n }\n if (RExC_emit >= RExC_emit_bound)\n Perl_croak(aTHX_ \"panic: reg_node overrun trying to emit %d, %p>=%p\",\n\t\t op, (void*)RExC_emit, (void*)RExC_emit_bound);\n\n NODE_ALIGN_FILL(ret);\n#ifndef RE_TRACK_PATTERN_OFFSETS\n PERL_UNUSED_ARG(name);\n#else\n if (RExC_offsets) { /* MJD */\n\tMJD_OFFSET_DEBUG(\n (\"%s:%d: (op %s) %s %\" UVuf \" (len %\" UVuf \") (max %\" UVuf \").\\n\",\n name, __LINE__,\n PL_reg_name[op],\n (UV)(RExC_emit - RExC_emit_start) > RExC_offsets[0]\n\t\t? \"Overwriting end of array!\\n\" : \"OK\",\n (UV)(RExC_emit - RExC_emit_start),\n (UV)(RExC_parse - RExC_start),\n (UV)RExC_offsets[0]));\n\tSet_Node_Offset(RExC_emit, RExC_parse + (op == END));\n }\n#endif\n return(ret);\n}\n\n/*\n- reg_node - emit a node\n*/\nSTATIC regnode *\t\t\t/* Location. */\nS_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)\n{\n regnode * const ret = regnode_guts(pRExC_state, op, regarglen[op], \"reg_node\");\n\n PERL_ARGS_ASSERT_REG_NODE;\n\n assert(regarglen[op] == 0);\n\n if (PASS2) {\n regnode *ptr = ret;\n FILL_ADVANCE_NODE(ptr, op);\n RExC_emit = ptr;\n }\n return(ret);\n}\n\n/*\n- reganode - emit a node with an argument\n*/\nSTATIC regnode *\t\t\t/* Location. */\nS_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)\n{\n regnode * const ret = regnode_guts(pRExC_state, op, regarglen[op], \"reganode\");\n\n PERL_ARGS_ASSERT_REGANODE;\n\n assert(regarglen[op] == 1);\n\n if (PASS2) {\n regnode *ptr = ret;\n FILL_ADVANCE_NODE_ARG(ptr, op, arg);\n RExC_emit = ptr;\n }\n return(ret);\n}\n\nSTATIC regnode *\nS_reg2Lanode(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2)\n{\n /* emit a node with U32 and I32 arguments */\n\n regnode * const ret = regnode_guts(pRExC_state, op, regarglen[op], \"reg2Lanode\");\n\n PERL_ARGS_ASSERT_REG2LANODE;\n\n assert(regarglen[op] == 2);\n\n if (PASS2) {\n regnode *ptr = ret;\n FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2);\n RExC_emit = ptr;\n }\n return(ret);\n}\n\n/*\n- reginsert - insert an operator in front of already-emitted operand\n*\n* Means relocating the operand.\n*\n* IMPORTANT NOTE - it is the *callers* responsibility to correctly\n* set up NEXT_OFF() of the inserted node if needed. Something like this:\n*\n* reginsert(pRExC, OPFAIL, orig_emit, depth+1);\n* if (PASS2)\n* NEXT_OFF(orig_emit) = regarglen[OPFAIL] + NODE_STEP_REGNODE;\n*\n* ALSO NOTE - operand->flags will be set to 0 as well.\n*/\nSTATIC void\nS_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *operand, U32 depth)\n{\n regnode *src;\n regnode *dst;\n regnode *place;\n const int offset = regarglen[(U8)op];\n const int size = NODE_STEP_REGNODE + offset;\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGINSERT;\n PERL_UNUSED_CONTEXT;\n PERL_UNUSED_ARG(depth);\n/* (PL_regkind[(U8)op] == CURLY ? EXTRA_STEP_2ARGS : 0); */\n DEBUG_PARSE_FMT(\"inst\",\" - %s\",PL_reg_name[op]);\n if (SIZE_ONLY) {\n\tRExC_size += size;\n\treturn;\n }\n assert(!RExC_study_started); /* I believe we should never use reginsert once we have started\n studying. If this is wrong then we need to adjust RExC_recurse\n below like we do with RExC_open_parens/RExC_close_parens. */\n src = RExC_emit;\n RExC_emit += size;\n dst = RExC_emit;\n if (RExC_open_parens) {\n int paren;\n /*DEBUG_PARSE_FMT(\"inst\",\" - %\" IVdf, (IV)RExC_npar);*/\n /* remember that RExC_npar is rex->nparens + 1,\n * iow it is 1 more than the number of parens seen in\n * the pattern so far. */\n for ( paren=0 ; paren < RExC_npar ; paren++ ) {\n /* note, RExC_open_parens[0] is the start of the\n * regex, it can't move. RExC_close_parens[0] is the end\n * of the regex, it *can* move. */\n if ( paren && RExC_open_parens[paren] >= operand ) {\n /*DEBUG_PARSE_FMT(\"open\",\" - %d\",size);*/\n RExC_open_parens[paren] += size;\n } else {\n /*DEBUG_PARSE_FMT(\"open\",\" - %s\",\"ok\");*/\n }\n if ( RExC_close_parens[paren] >= operand ) {\n /*DEBUG_PARSE_FMT(\"close\",\" - %d\",size);*/\n RExC_close_parens[paren] += size;\n } else {\n /*DEBUG_PARSE_FMT(\"close\",\" - %s\",\"ok\");*/\n }\n }\n }\n if (RExC_end_op)\n RExC_end_op += size;\n\n while (src > operand) {\n\tStructCopy(--src, --dst, regnode);\n#ifdef RE_TRACK_PATTERN_OFFSETS\n if (RExC_offsets) { /* MJD 20010112 */\n\t MJD_OFFSET_DEBUG(\n (\"%s(%d): (op %s) %s copy %\" UVuf \" -> %\" UVuf \" (max %\" UVuf \").\\n\",\n \"reg_insert\",\n\t\t __LINE__,\n\t\t PL_reg_name[op],\n (UV)(dst - RExC_emit_start) > RExC_offsets[0]\n\t\t ? \"Overwriting end of array!\\n\" : \"OK\",\n (UV)(src - RExC_emit_start),\n (UV)(dst - RExC_emit_start),\n (UV)RExC_offsets[0]));\n\t Set_Node_Offset_To_R(dst-RExC_emit_start, Node_Offset(src));\n\t Set_Node_Length_To_R(dst-RExC_emit_start, Node_Length(src));\n }\n#endif\n }\n\n place = operand;\t\t/* Op node, where operand used to be. */\n#ifdef RE_TRACK_PATTERN_OFFSETS\n if (RExC_offsets) { /* MJD */\n\tMJD_OFFSET_DEBUG(\n (\"%s(%d): (op %s) %s %\" UVuf \" <- %\" UVuf \" (max %\" UVuf \").\\n\",\n \"reginsert\",\n\t __LINE__,\n\t PL_reg_name[op],\n (UV)(place - RExC_emit_start) > RExC_offsets[0]\n ? \"Overwriting end of array!\\n\" : \"OK\",\n (UV)(place - RExC_emit_start),\n (UV)(RExC_parse - RExC_start),\n (UV)RExC_offsets[0]));\n\tSet_Node_Offset(place, RExC_parse);\n\tSet_Node_Length(place, 1);\n }\n#endif\n src = NEXTOPER(place);\n place->flags = 0;\n FILL_ADVANCE_NODE(place, op);\n Zero(src, offset, regnode);\n}\n\n/*\n- regtail - set the next-pointer at the end of a node chain of p to val.\n- SEE ALSO: regtail_study\n*/\nSTATIC void\nS_regtail(pTHX_ RExC_state_t * pRExC_state,\n const regnode * const p,\n const regnode * const val,\n const U32 depth)\n{\n regnode *scan;\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGTAIL;\n#ifndef DEBUGGING\n PERL_UNUSED_ARG(depth);\n#endif\n\n if (SIZE_ONLY)\n\treturn;\n\n /* Find last node. */\n scan = (regnode *) p;\n for (;;) {\n\tregnode * const temp = regnext(scan);\n DEBUG_PARSE_r({\n DEBUG_PARSE_MSG((scan==p ? \"tail\" : \"\"));\n regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state);\n Perl_re_printf( aTHX_ \"~ %s (%d) %s %s\\n\",\n SvPV_nolen_const(RExC_mysv), REG_NODE_NUM(scan),\n (temp == NULL ? \"->\" : \"\"),\n (temp == NULL ? PL_reg_name[OP(val)] : \"\")\n );\n });\n if (temp == NULL)\n break;\n scan = temp;\n }\n\n if (reg_off_by_arg[OP(scan)]) {\n ARG_SET(scan, val - scan);\n }\n else {\n NEXT_OFF(scan) = val - scan;\n }\n}\n\n#ifdef DEBUGGING\n/*\n- regtail_study - set the next-pointer at the end of a node chain of p to val.\n- Look for optimizable sequences at the same time.\n- currently only looks for EXACT chains.\n\nThis is experimental code. The idea is to use this routine to perform\nin place optimizations on branches and groups as they are constructed,\nwith the long term intention of removing optimization from study_chunk so\nthat it is purely analytical.\n\nCurrently only used when in DEBUG mode. The macro REGTAIL_STUDY() is used\nto control which is which.\n\n*/\n/* TODO: All four parms should be const */\n\nSTATIC U8\nS_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p,\n const regnode *val,U32 depth)\n{\n regnode *scan;\n U8 exact = PSEUDO;\n#ifdef EXPERIMENTAL_INPLACESCAN\n I32 min = 0;\n#endif\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGTAIL_STUDY;\n\n\n if (SIZE_ONLY)\n return exact;\n\n /* Find last node. */\n\n scan = p;\n for (;;) {\n regnode * const temp = regnext(scan);\n#ifdef EXPERIMENTAL_INPLACESCAN\n if (PL_regkind[OP(scan)] == EXACT) {\n\t bool unfolded_multi_char;\t/* Unexamined in this routine */\n if (join_exact(pRExC_state, scan, &min,\n &unfolded_multi_char, 1, val, depth+1))\n return EXACT;\n\t}\n#endif\n if ( exact ) {\n switch (OP(scan)) {\n case EXACT:\n case EXACTL:\n case EXACTF:\n case EXACTFA_NO_TRIE:\n case EXACTFA:\n case EXACTFU:\n case EXACTFLU8:\n case EXACTFU_SS:\n case EXACTFL:\n if( exact == PSEUDO )\n exact= OP(scan);\n else if ( exact != OP(scan) )\n exact= 0;\n case NOTHING:\n break;\n default:\n exact= 0;\n }\n }\n DEBUG_PARSE_r({\n DEBUG_PARSE_MSG((scan==p ? \"tsdy\" : \"\"));\n regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state);\n Perl_re_printf( aTHX_ \"~ %s (%d) -> %s\\n\",\n SvPV_nolen_const(RExC_mysv),\n REG_NODE_NUM(scan),\n PL_reg_name[exact]);\n });\n\tif (temp == NULL)\n\t break;\n\tscan = temp;\n }\n DEBUG_PARSE_r({\n DEBUG_PARSE_MSG(\"\");\n regprop(RExC_rx, RExC_mysv, val, NULL, pRExC_state);\n Perl_re_printf( aTHX_\n \"~ attach to %s (%\" IVdf \") offset to %\" IVdf \"\\n\",\n\t\t SvPV_nolen_const(RExC_mysv),\n\t\t (IV)REG_NODE_NUM(val),\n\t\t (IV)(val - scan)\n );\n });\n if (reg_off_by_arg[OP(scan)]) {\n\tARG_SET(scan, val - scan);\n }\n else {\n\tNEXT_OFF(scan) = val - scan;\n }\n\n return exact;\n}\n#endif\n\n/*\n - regdump - dump a regexp onto Perl_debug_log in vaguely comprehensible form\n */\n#ifdef DEBUGGING\n\nstatic void\nS_regdump_intflags(pTHX_ const char *lead, const U32 flags)\n{\n int bit;\n int set=0;\n\n ASSUME(REG_INTFLAGS_NAME_SIZE <= sizeof(flags)*8);\n\n for (bit=0; bit<REG_INTFLAGS_NAME_SIZE; bit++) {\n if (flags & (1<<bit)) {\n if (!set++ && lead)\n Perl_re_printf( aTHX_ \"%s\",lead);\n Perl_re_printf( aTHX_ \"%s \",PL_reg_intflags_name[bit]);\n }\n }\n if (lead) {\n if (set)\n Perl_re_printf( aTHX_ \"\\n\");\n else\n Perl_re_printf( aTHX_ \"%s[none-set]\\n\",lead);\n }\n}\n\nstatic void\nS_regdump_extflags(pTHX_ const char *lead, const U32 flags)\n{\n int bit;\n int set=0;\n regex_charset cs;\n\n ASSUME(REG_EXTFLAGS_NAME_SIZE <= sizeof(flags)*8);\n\n for (bit=0; bit<REG_EXTFLAGS_NAME_SIZE; bit++) {\n if (flags & (1<<bit)) {\n\t if ((1<<bit) & RXf_PMf_CHARSET) {\t/* Output separately, below */\n\t\tcontinue;\n\t }\n if (!set++ && lead)\n Perl_re_printf( aTHX_ \"%s\",lead);\n Perl_re_printf( aTHX_ \"%s \",PL_reg_extflags_name[bit]);\n }\n }\n if ((cs = get_regex_charset(flags)) != REGEX_DEPENDS_CHARSET) {\n if (!set++ && lead) {\n Perl_re_printf( aTHX_ \"%s\",lead);\n }\n switch (cs) {\n case REGEX_UNICODE_CHARSET:\n Perl_re_printf( aTHX_ \"UNICODE\");\n break;\n case REGEX_LOCALE_CHARSET:\n Perl_re_printf( aTHX_ \"LOCALE\");\n break;\n case REGEX_ASCII_RESTRICTED_CHARSET:\n Perl_re_printf( aTHX_ \"ASCII-RESTRICTED\");\n break;\n case REGEX_ASCII_MORE_RESTRICTED_CHARSET:\n Perl_re_printf( aTHX_ \"ASCII-MORE_RESTRICTED\");\n break;\n default:\n Perl_re_printf( aTHX_ \"UNKNOWN CHARACTER SET\");\n break;\n }\n }\n if (lead) {\n if (set)\n Perl_re_printf( aTHX_ \"\\n\");\n else\n Perl_re_printf( aTHX_ \"%s[none-set]\\n\",lead);\n }\n}\n#endif\n\nvoid\nPerl_regdump(pTHX_ const regexp *r)\n{\n#ifdef DEBUGGING\n int i;\n SV * const sv = sv_newmortal();\n SV *dsv= sv_newmortal();\n RXi_GET_DECL(r,ri);\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGDUMP;\n\n (void)dumpuntil(r, ri->program, ri->program + 1, NULL, NULL, sv, 0, 0);\n\n /* Header fields of interest. */\n for (i = 0; i < 2; i++) {\n if (r->substrs->data[i].substr) {\n RE_PV_QUOTED_DECL(s, 0, dsv,\n SvPVX_const(r->substrs->data[i].substr),\n RE_SV_DUMPLEN(r->substrs->data[i].substr),\n PL_dump_re_max_len);\n Perl_re_printf( aTHX_\n \"%s %s%s at %\" IVdf \"..%\" UVuf \" \",\n i ? \"floating\" : \"anchored\",\n s,\n RE_SV_TAIL(r->substrs->data[i].substr),\n (IV)r->substrs->data[i].min_offset,\n (UV)r->substrs->data[i].max_offset);\n }\n else if (r->substrs->data[i].utf8_substr) {\n RE_PV_QUOTED_DECL(s, 1, dsv,\n SvPVX_const(r->substrs->data[i].utf8_substr),\n RE_SV_DUMPLEN(r->substrs->data[i].utf8_substr),\n 30);\n Perl_re_printf( aTHX_\n \"%s utf8 %s%s at %\" IVdf \"..%\" UVuf \" \",\n i ? \"floating\" : \"anchored\",\n s,\n RE_SV_TAIL(r->substrs->data[i].utf8_substr),\n (IV)r->substrs->data[i].min_offset,\n (UV)r->substrs->data[i].max_offset);\n }\n }\n\n if (r->check_substr || r->check_utf8)\n Perl_re_printf( aTHX_\n\t\t (const char *)\n\t\t ( r->check_substr == r->substrs->data[1].substr\n\t\t && r->check_utf8 == r->substrs->data[1].utf8_substr\n\t\t ? \"(checking floating\" : \"(checking anchored\"));\n if (r->intflags & PREGf_NOSCAN)\n Perl_re_printf( aTHX_ \" noscan\");\n if (r->extflags & RXf_CHECK_ALL)\n Perl_re_printf( aTHX_ \" isall\");\n if (r->check_substr || r->check_utf8)\n Perl_re_printf( aTHX_ \") \");\n\n if (ri->regstclass) {\n regprop(r, sv, ri->regstclass, NULL, NULL);\n Perl_re_printf( aTHX_ \"stclass %s \", SvPVX_const(sv));\n }\n if (r->intflags & PREGf_ANCH) {\n Perl_re_printf( aTHX_ \"anchored\");\n if (r->intflags & PREGf_ANCH_MBOL)\n Perl_re_printf( aTHX_ \"(MBOL)\");\n if (r->intflags & PREGf_ANCH_SBOL)\n Perl_re_printf( aTHX_ \"(SBOL)\");\n if (r->intflags & PREGf_ANCH_GPOS)\n Perl_re_printf( aTHX_ \"(GPOS)\");\n Perl_re_printf( aTHX_ \" \");\n }\n if (r->intflags & PREGf_GPOS_SEEN)\n Perl_re_printf( aTHX_ \"GPOS:%\" UVuf \" \", (UV)r->gofs);\n if (r->intflags & PREGf_SKIP)\n Perl_re_printf( aTHX_ \"plus \");\n if (r->intflags & PREGf_IMPLICIT)\n Perl_re_printf( aTHX_ \"implicit \");\n Perl_re_printf( aTHX_ \"minlen %\" IVdf \" \", (IV)r->minlen);\n if (r->extflags & RXf_EVAL_SEEN)\n Perl_re_printf( aTHX_ \"with eval \");\n Perl_re_printf( aTHX_ \"\\n\");\n DEBUG_FLAGS_r({\n regdump_extflags(\"r->extflags: \",r->extflags);\n regdump_intflags(\"r->intflags: \",r->intflags);\n });\n#else\n PERL_ARGS_ASSERT_REGDUMP;\n PERL_UNUSED_CONTEXT;\n PERL_UNUSED_ARG(r);\n#endif\t/* DEBUGGING */\n}\n\n/* Should be synchronized with ANYOF_ #defines in regcomp.h */\n#ifdef DEBUGGING\n\n# if _CC_WORDCHAR != 0 || _CC_DIGIT != 1 || _CC_ALPHA != 2 \\\n || _CC_LOWER != 3 || _CC_UPPER != 4 || _CC_PUNCT != 5 \\\n || _CC_PRINT != 6 || _CC_ALPHANUMERIC != 7 || _CC_GRAPH != 8 \\\n || _CC_CASED != 9 || _CC_SPACE != 10 || _CC_BLANK != 11 \\\n || _CC_XDIGIT != 12 || _CC_CNTRL != 13 || _CC_ASCII != 14 \\\n || _CC_VERTSPACE != 15\n# error Need to adjust order of anyofs[]\n# endif\nstatic const char * const anyofs[] = {\n \"\\\\w\",\n \"\\\\W\",\n \"\\\\d\",\n \"\\\\D\",\n \"[:alpha:]\",\n \"[:^alpha:]\",\n \"[:lower:]\",\n \"[:^lower:]\",\n \"[:upper:]\",\n \"[:^upper:]\",\n \"[:punct:]\",\n \"[:^punct:]\",\n \"[:print:]\",\n \"[:^print:]\",\n \"[:alnum:]\",\n \"[:^alnum:]\",\n \"[:graph:]\",\n \"[:^graph:]\",\n \"[:cased:]\",\n \"[:^cased:]\",\n \"\\\\s\",\n \"\\\\S\",\n \"[:blank:]\",\n \"[:^blank:]\",\n \"[:xdigit:]\",\n \"[:^xdigit:]\",\n \"[:cntrl:]\",\n \"[:^cntrl:]\",\n \"[:ascii:]\",\n \"[:^ascii:]\",\n \"\\\\v\",\n \"\\\\V\"\n};\n#endif\n\n/*\n- regprop - printable representation of opcode, with run time support\n*/\n\nvoid\nPerl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state)\n{\n#ifdef DEBUGGING\n int k;\n RXi_GET_DECL(prog,progi);\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGPROP;\n\n SvPVCLEAR(sv);\n\n if (OP(o) > REGNODE_MAX)\t\t/* regnode.type is unsigned */\n\t/* It would be nice to FAIL() here, but this may be called from\n\t regexec.c, and it would be hard to supply pRExC_state. */\n\tPerl_croak(aTHX_ \"Corrupted regexp opcode %d > %d\",\n (int)OP(o), (int)REGNODE_MAX);\n sv_catpv(sv, PL_reg_name[OP(o)]); /* Take off const! */\n\n k = PL_regkind[OP(o)];\n\n if (k == EXACT) {\n\tsv_catpvs(sv, \" \");\n\t/* Using is_utf8_string() (via PERL_PV_UNI_DETECT)\n\t * is a crude hack but it may be the best for now since\n\t * we have no flag \"this EXACTish node was UTF-8\"\n\t * --jhi */\n\tpv_pretty(sv, STRING(o), STR_LEN(o), PL_dump_re_max_len,\n PL_colors[0], PL_colors[1],\n\t\t PERL_PV_ESCAPE_UNI_DETECT |\n\t\t PERL_PV_ESCAPE_NONASCII |\n\t\t PERL_PV_PRETTY_ELLIPSES |\n\t\t PERL_PV_PRETTY_LTGT |\n\t\t PERL_PV_PRETTY_NOCLEAR\n\t\t );\n } else if (k == TRIE) {\n\t/* print the details of the trie in dumpuntil instead, as\n\t * progi->data isn't available here */\n const char op = OP(o);\n const U32 n = ARG(o);\n const reg_ac_data * const ac = IS_TRIE_AC(op) ?\n (reg_ac_data *)progi->data->data[n] :\n NULL;\n const reg_trie_data * const trie\n\t = (reg_trie_data*)progi->data->data[!IS_TRIE_AC(op) ? n : ac->trie];\n\n Perl_sv_catpvf(aTHX_ sv, \"-%s\",PL_reg_name[o->flags]);\n DEBUG_TRIE_COMPILE_r({\n if (trie->jump)\n sv_catpvs(sv, \"(JUMP)\");\n Perl_sv_catpvf(aTHX_ sv,\n \"<S:%\" UVuf \"/%\" IVdf \" W:%\" UVuf \" L:%\" UVuf \"/%\" UVuf \" C:%\" UVuf \"/%\" UVuf \">\",\n (UV)trie->startstate,\n (IV)trie->statecount-1, /* -1 because of the unused 0 element */\n (UV)trie->wordcount,\n (UV)trie->minlen,\n (UV)trie->maxlen,\n (UV)TRIE_CHARCOUNT(trie),\n (UV)trie->uniquecharcount\n );\n });\n if ( IS_ANYOF_TRIE(op) || trie->bitmap ) {\n sv_catpvs(sv, \"[\");\n (void) put_charclass_bitmap_innards(sv,\n ((IS_ANYOF_TRIE(op))\n ? ANYOF_BITMAP(o)\n : TRIE_BITMAP(trie)),\n NULL,\n NULL,\n NULL,\n FALSE\n );\n sv_catpvs(sv, \"]\");\n }\n } else if (k == CURLY) {\n U32 lo = ARG1(o), hi = ARG2(o);\n\tif (OP(o) == CURLYM || OP(o) == CURLYN || OP(o) == CURLYX)\n\t Perl_sv_catpvf(aTHX_ sv, \"[%d]\", o->flags); /* Parenth number */\n Perl_sv_catpvf(aTHX_ sv, \"{%u,\", (unsigned) lo);\n if (hi == REG_INFTY)\n sv_catpvs(sv, \"INFTY\");\n else\n Perl_sv_catpvf(aTHX_ sv, \"%u\", (unsigned) hi);\n sv_catpvs(sv, \"}\");\n }\n else if (k == WHILEM && o->flags)\t\t\t/* Ordinal/of */\n\tPerl_sv_catpvf(aTHX_ sv, \"[%d/%d]\", o->flags & 0xf, o->flags>>4);\n else if (k == REF || k == OPEN || k == CLOSE\n || k == GROUPP || OP(o)==ACCEPT)\n {\n AV *name_list= NULL;\n U32 parno= OP(o) == ACCEPT ? (U32)ARG2L(o) : ARG(o);\n Perl_sv_catpvf(aTHX_ sv, \"%\" UVuf, (UV)parno); /* Parenth number */\n\tif ( RXp_PAREN_NAMES(prog) ) {\n name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]);\n } else if ( pRExC_state ) {\n name_list= RExC_paren_name_list;\n }\n if (name_list) {\n if ( k != REF || (OP(o) < NREF)) {\n SV **name= av_fetch(name_list, parno, 0 );\n\t if (name)\n\t Perl_sv_catpvf(aTHX_ sv, \" '%\" SVf \"'\", SVfARG(*name));\n }\n else {\n SV *sv_dat= MUTABLE_SV(progi->data->data[ parno ]);\n I32 *nums=(I32*)SvPVX(sv_dat);\n SV **name= av_fetch(name_list, nums[0], 0 );\n I32 n;\n if (name) {\n for ( n=0; n<SvIVX(sv_dat); n++ ) {\n Perl_sv_catpvf(aTHX_ sv, \"%s%\" IVdf,\n\t\t\t \t (n ? \",\" : \"\"), (IV)nums[n]);\n }\n Perl_sv_catpvf(aTHX_ sv, \" '%\" SVf \"'\", SVfARG(*name));\n }\n }\n }\n if ( k == REF && reginfo) {\n U32 n = ARG(o); /* which paren pair */\n I32 ln = prog->offs[n].start;\n if (prog->lastparen < n || ln == -1)\n Perl_sv_catpvf(aTHX_ sv, \": FAIL\");\n else if (ln == prog->offs[n].end)\n Perl_sv_catpvf(aTHX_ sv, \": ACCEPT - EMPTY STRING\");\n else {\n const char *s = reginfo->strbeg + ln;\n Perl_sv_catpvf(aTHX_ sv, \": \");\n Perl_pv_pretty( aTHX_ sv, s, prog->offs[n].end - prog->offs[n].start, 32, 0, 0,\n PERL_PV_ESCAPE_UNI_DETECT|PERL_PV_PRETTY_NOCLEAR|PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE );\n }\n }\n } else if (k == GOSUB) {\n AV *name_list= NULL;\n if ( RXp_PAREN_NAMES(prog) ) {\n name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]);\n } else if ( pRExC_state ) {\n name_list= RExC_paren_name_list;\n }\n\n /* Paren and offset */\n Perl_sv_catpvf(aTHX_ sv, \"%d[%+d:%d]\", (int)ARG(o),(int)ARG2L(o),\n (int)((o + (int)ARG2L(o)) - progi->program) );\n if (name_list) {\n SV **name= av_fetch(name_list, ARG(o), 0 );\n if (name)\n Perl_sv_catpvf(aTHX_ sv, \" '%\" SVf \"'\", SVfARG(*name));\n }\n }\n else if (k == LOGICAL)\n /* 2: embedded, otherwise 1 */\n\tPerl_sv_catpvf(aTHX_ sv, \"[%d]\", o->flags);\n else if (k == ANYOF) {\n\tconst U8 flags = ANYOF_FLAGS(o);\n bool do_sep = FALSE; /* Do we need to separate various components of\n the output? */\n /* Set if there is still an unresolved user-defined property */\n SV *unresolved = NULL;\n\n /* Things that are ignored except when the runtime locale is UTF-8 */\n SV *only_utf8_locale_invlist = NULL;\n\n /* Code points that don't fit in the bitmap */\n SV *nonbitmap_invlist = NULL;\n\n /* And things that aren't in the bitmap, but are small enough to be */\n SV* bitmap_range_not_in_bitmap = NULL;\n\n const bool inverted = flags & ANYOF_INVERT;\n\n\tif (OP(o) == ANYOFL) {\n if (ANYOFL_UTF8_LOCALE_REQD(flags)) {\n sv_catpvs(sv, \"{utf8-locale-reqd}\");\n }\n if (flags & ANYOFL_FOLD) {\n sv_catpvs(sv, \"{i}\");\n }\n }\n\n /* If there is stuff outside the bitmap, get it */\n if (ARG(o) != ANYOF_ONLY_HAS_BITMAP) {\n (void) _get_regclass_nonbitmap_data(prog, o, FALSE,\n &unresolved,\n &only_utf8_locale_invlist,\n &nonbitmap_invlist);\n /* The non-bitmap data may contain stuff that could fit in the\n * bitmap. This could come from a user-defined property being\n * finally resolved when this call was done; or much more likely\n * because there are matches that require UTF-8 to be valid, and so\n * aren't in the bitmap. This is teased apart later */\n _invlist_intersection(nonbitmap_invlist,\n PL_InBitmap,\n &bitmap_range_not_in_bitmap);\n /* Leave just the things that don't fit into the bitmap */\n _invlist_subtract(nonbitmap_invlist,\n PL_InBitmap,\n &nonbitmap_invlist);\n }\n\n /* Obey this flag to add all above-the-bitmap code points */\n if (flags & ANYOF_MATCHES_ALL_ABOVE_BITMAP) {\n nonbitmap_invlist = _add_range_to_invlist(nonbitmap_invlist,\n NUM_ANYOF_CODE_POINTS,\n UV_MAX);\n }\n\n /* Ready to start outputting. First, the initial left bracket */\n\tPerl_sv_catpvf(aTHX_ sv, \"[%s\", PL_colors[0]);\n\n /* Then all the things that could fit in the bitmap */\n do_sep = put_charclass_bitmap_innards(sv,\n ANYOF_BITMAP(o),\n bitmap_range_not_in_bitmap,\n only_utf8_locale_invlist,\n o,\n\n /* Can't try inverting for a\n * better display if there are\n * things that haven't been\n * resolved */\n unresolved != NULL);\n SvREFCNT_dec(bitmap_range_not_in_bitmap);\n\n /* If there are user-defined properties which haven't been defined yet,\n * output them. If the result is not to be inverted, it is clearest to\n * output them in a separate [] from the bitmap range stuff. If the\n * result is to be complemented, we have to show everything in one [],\n * as the inversion applies to the whole thing. Use {braces} to\n * separate them from anything in the bitmap and anything above the\n * bitmap. */\n if (unresolved) {\n if (inverted) {\n if (! do_sep) { /* If didn't output anything in the bitmap */\n sv_catpvs(sv, \"^\");\n }\n sv_catpvs(sv, \"{\");\n }\n else if (do_sep) {\n Perl_sv_catpvf(aTHX_ sv,\"%s][%s\",PL_colors[1],PL_colors[0]);\n }\n sv_catsv(sv, unresolved);\n if (inverted) {\n sv_catpvs(sv, \"}\");\n }\n do_sep = ! inverted;\n }\n\n /* And, finally, add the above-the-bitmap stuff */\n if (nonbitmap_invlist && _invlist_len(nonbitmap_invlist)) {\n SV* contents;\n\n /* See if truncation size is overridden */\n const STRLEN dump_len = (PL_dump_re_max_len > 256)\n ? PL_dump_re_max_len\n : 256;\n\n /* This is output in a separate [] */\n if (do_sep) {\n Perl_sv_catpvf(aTHX_ sv,\"%s][%s\",PL_colors[1],PL_colors[0]);\n }\n\n /* And, for easy of understanding, it is shown in the\n * uncomplemented form if possible. The one exception being if\n * there are unresolved items, where the inversion has to be\n * delayed until runtime */\n if (inverted && ! unresolved) {\n _invlist_invert(nonbitmap_invlist);\n _invlist_subtract(nonbitmap_invlist, PL_InBitmap, &nonbitmap_invlist);\n }\n\n contents = invlist_contents(nonbitmap_invlist,\n FALSE /* output suitable for catsv */\n );\n\n /* If the output is shorter than the permissible maximum, just do it. */\n if (SvCUR(contents) <= dump_len) {\n sv_catsv(sv, contents);\n }\n else {\n const char * contents_string = SvPVX(contents);\n STRLEN i = dump_len;\n\n /* Otherwise, start at the permissible max and work back to the\n * first break possibility */\n while (i > 0 && contents_string[i] != ' ') {\n i--;\n }\n if (i == 0) { /* Fail-safe. Use the max if we couldn't\n find a legal break */\n i = dump_len;\n }\n\n sv_catpvn(sv, contents_string, i);\n sv_catpvs(sv, \"...\");\n }\n\n SvREFCNT_dec_NN(contents);\n SvREFCNT_dec_NN(nonbitmap_invlist);\n }\n\n /* And finally the matching, closing ']' */\n\tPerl_sv_catpvf(aTHX_ sv, \"%s]\", PL_colors[1]);\n\n SvREFCNT_dec(unresolved);\n }\n else if (k == POSIXD || k == NPOSIXD) {\n U8 index = FLAGS(o) * 2;\n if (index < C_ARRAY_LENGTH(anyofs)) {\n if (*anyofs[index] != '[') {\n sv_catpv(sv, \"[\");\n }\n sv_catpv(sv, anyofs[index]);\n if (*anyofs[index] != '[') {\n sv_catpv(sv, \"]\");\n }\n }\n else {\n Perl_sv_catpvf(aTHX_ sv, \"[illegal type=%d])\", index);\n }\n }\n else if (k == BOUND || k == NBOUND) {\n /* Must be synced with order of 'bound_type' in regcomp.h */\n const char * const bounds[] = {\n \"\", /* Traditional */\n \"{gcb}\",\n \"{lb}\",\n \"{sb}\",\n \"{wb}\"\n };\n assert(FLAGS(o) < C_ARRAY_LENGTH(bounds));\n sv_catpv(sv, bounds[FLAGS(o)]);\n }\n else if (k == BRANCHJ && (OP(o) == UNLESSM || OP(o) == IFMATCH))\n\tPerl_sv_catpvf(aTHX_ sv, \"[%d]\", -(o->flags));\n else if (OP(o) == SBOL)\n Perl_sv_catpvf(aTHX_ sv, \" /%s/\", o->flags ? \"\\\\A\" : \"^\");\n\n /* add on the verb argument if there is one */\n if ( ( k == VERB || OP(o) == ACCEPT || OP(o) == OPFAIL ) && o->flags) {\n if ( ARG(o) )\n Perl_sv_catpvf(aTHX_ sv, \":%\" SVf,\n SVfARG((MUTABLE_SV(progi->data->data[ ARG( o ) ]))));\n else\n sv_catpvs(sv, \":NULL\");\n }\n#else\n PERL_UNUSED_CONTEXT;\n PERL_UNUSED_ARG(sv);\n PERL_UNUSED_ARG(o);\n PERL_UNUSED_ARG(prog);\n PERL_UNUSED_ARG(reginfo);\n PERL_UNUSED_ARG(pRExC_state);\n#endif\t/* DEBUGGING */\n}\n\n\n\nSV *\nPerl_re_intuit_string(pTHX_ REGEXP * const r)\n{\t\t\t\t/* Assume that RE_INTUIT is set */\n struct regexp *const prog = ReANY(r);\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_RE_INTUIT_STRING;\n PERL_UNUSED_CONTEXT;\n\n DEBUG_COMPILE_r(\n\t{\n\t const char * const s = SvPV_nolen_const(RX_UTF8(r)\n\t\t ? prog->check_utf8 : prog->check_substr);\n\n\t if (!PL_colorset) reginitcolors();\n Perl_re_printf( aTHX_\n\t\t \"%sUsing REx %ssubstr:%s \\\"%s%.60s%s%s\\\"\\n\",\n\t\t PL_colors[4],\n\t\t RX_UTF8(r) ? \"utf8 \" : \"\",\n\t\t PL_colors[5],PL_colors[0],\n\t\t s,\n\t\t PL_colors[1],\n\t\t (strlen(s) > PL_dump_re_max_len ? \"...\" : \"\"));\n\t} );\n\n /* use UTF8 check substring if regexp pattern itself is in UTF8 */\n return RX_UTF8(r) ? prog->check_utf8 : prog->check_substr;\n}\n\n/*\n pregfree()\n\n handles refcounting and freeing the perl core regexp structure. When\n it is necessary to actually free the structure the first thing it\n does is call the 'free' method of the regexp_engine associated to\n the regexp, allowing the handling of the void *pprivate; member\n first. (This routine is not overridable by extensions, which is why\n the extensions free is called first.)\n\n See regdupe and regdupe_internal if you change anything here.\n*/\n#ifndef PERL_IN_XSUB_RE\nvoid\nPerl_pregfree(pTHX_ REGEXP *r)\n{\n SvREFCNT_dec(r);\n}\n\nvoid\nPerl_pregfree2(pTHX_ REGEXP *rx)\n{\n struct regexp *const r = ReANY(rx);\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_PREGFREE2;\n\n if (r->mother_re) {\n ReREFCNT_dec(r->mother_re);\n } else {\n CALLREGFREE_PVT(rx); /* free the private data */\n SvREFCNT_dec(RXp_PAREN_NAMES(r));\n }\n if (r->substrs) {\n int i;\n for (i = 0; i < 2; i++) {\n SvREFCNT_dec(r->substrs->data[i].substr);\n SvREFCNT_dec(r->substrs->data[i].utf8_substr);\n }\n\tSafefree(r->substrs);\n }\n RX_MATCH_COPY_FREE(rx);\n#ifdef PERL_ANY_COW\n SvREFCNT_dec(r->saved_copy);\n#endif\n Safefree(r->offs);\n SvREFCNT_dec(r->qr_anoncv);\n if (r->recurse_locinput)\n Safefree(r->recurse_locinput);\n}\n\n\n/* reg_temp_copy()\n\n Copy ssv to dsv, both of which should of type SVt_REGEXP or SVt_PVLV,\n except that dsv will be created if NULL.\n\n This function is used in two main ways. First to implement\n $r = qr/....; $s = $$r;\n\n Secondly, it is used as a hacky workaround to the structural issue of\n match results\n being stored in the regexp structure which is in turn stored in\n PL_curpm/PL_reg_curpm. The problem is that due to qr// the pattern\n could be PL_curpm in multiple contexts, and could require multiple\n result sets being associated with the pattern simultaneously, such\n as when doing a recursive match with (??{$qr})\n\n The solution is to make a lightweight copy of the regexp structure\n when a qr// is returned from the code executed by (??{$qr}) this\n lightweight copy doesn't actually own any of its data except for\n the starp/end and the actual regexp structure itself.\n\n*/\n\n\nREGEXP *\nPerl_reg_temp_copy(pTHX_ REGEXP *dsv, REGEXP *ssv)\n{\n struct regexp *drx;\n struct regexp *const srx = ReANY(ssv);\n const bool islv = dsv && SvTYPE(dsv) == SVt_PVLV;\n\n PERL_ARGS_ASSERT_REG_TEMP_COPY;\n\n if (!dsv)\n\tdsv = (REGEXP*) newSV_type(SVt_REGEXP);\n else {\n\tSvOK_off((SV *)dsv);\n\tif (islv) {\n\t /* For PVLVs, the head (sv_any) points to an XPVLV, while\n * the LV's xpvlenu_rx will point to a regexp body, which\n * we allocate here */\n\t REGEXP *temp = (REGEXP *)newSV_type(SVt_REGEXP);\n\t assert(!SvPVX(dsv));\n ((XPV*)SvANY(dsv))->xpv_len_u.xpvlenu_rx = temp->sv_any;\n\t temp->sv_any = NULL;\n\t SvFLAGS(temp) = (SvFLAGS(temp) & ~SVTYPEMASK) | SVt_NULL;\n\t SvREFCNT_dec_NN(temp);\n\t /* SvCUR still resides in the xpvlv struct, so the regexp copy-\n\t ing below will not set it. */\n\t SvCUR_set(dsv, SvCUR(ssv));\n\t}\n }\n /* This ensures that SvTHINKFIRST(sv) is true, and hence that\n sv_force_normal(sv) is called. */\n SvFAKE_on(dsv);\n drx = ReANY(dsv);\n\n SvFLAGS(dsv) |= SvFLAGS(ssv) & (SVf_POK|SVp_POK|SVf_UTF8);\n SvPV_set(dsv, RX_WRAPPED(ssv));\n /* We share the same string buffer as the original regexp, on which we\n hold a reference count, incremented when mother_re is set below.\n The string pointer is copied here, being part of the regexp struct.\n */\n memcpy(&(drx->xpv_cur), &(srx->xpv_cur),\n\t sizeof(regexp) - STRUCT_OFFSET(regexp, xpv_cur));\n if (!islv)\n SvLEN_set(dsv, 0);\n if (srx->offs) {\n const I32 npar = srx->nparens+1;\n Newx(drx->offs, npar, regexp_paren_pair);\n Copy(srx->offs, drx->offs, npar, regexp_paren_pair);\n }\n if (srx->substrs) {\n int i;\n Newx(drx->substrs, 1, struct reg_substr_data);\n\tStructCopy(srx->substrs, drx->substrs, struct reg_substr_data);\n\n for (i = 0; i < 2; i++) {\n SvREFCNT_inc_void(drx->substrs->data[i].substr);\n SvREFCNT_inc_void(drx->substrs->data[i].utf8_substr);\n }\n\n\t/* check_substr and check_utf8, if non-NULL, point to either their\n\t anchored or float namesakes, and don't hold a second reference. */\n }\n RX_MATCH_COPIED_off(dsv);\n#ifdef PERL_ANY_COW\n drx->saved_copy = NULL;\n#endif\n drx->mother_re = ReREFCNT_inc(srx->mother_re ? srx->mother_re : ssv);\n SvREFCNT_inc_void(drx->qr_anoncv);\n if (srx->recurse_locinput)\n Newx(drx->recurse_locinput,srx->nparens + 1,char *);\n\n return dsv;\n}\n#endif\n\n\n/* regfree_internal()\n\n Free the private data in a regexp. This is overloadable by\n extensions. Perl takes care of the regexp structure in pregfree(),\n this covers the *pprivate pointer which technically perl doesn't\n know about, however of course we have to handle the\n regexp_internal structure when no extension is in use.\n\n Note this is called before freeing anything in the regexp\n structure.\n */\n\nvoid\nPerl_regfree_internal(pTHX_ REGEXP * const rx)\n{\n struct regexp *const r = ReANY(rx);\n RXi_GET_DECL(r,ri);\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_REGFREE_INTERNAL;\n\n DEBUG_COMPILE_r({\n\tif (!PL_colorset)\n\t reginitcolors();\n\t{\n\t SV *dsv= sv_newmortal();\n RE_PV_QUOTED_DECL(s, RX_UTF8(rx),\n dsv, RX_PRECOMP(rx), RX_PRELEN(rx), PL_dump_re_max_len);\n Perl_re_printf( aTHX_ \"%sFreeing REx:%s %s\\n\",\n PL_colors[4],PL_colors[5],s);\n }\n });\n#ifdef RE_TRACK_PATTERN_OFFSETS\n if (ri->u.offsets)\n Safefree(ri->u.offsets); /* 20010421 MJD */\n#endif\n if (ri->code_blocks)\n S_free_codeblocks(aTHX_ ri->code_blocks);\n\n if (ri->data) {\n\tint n = ri->data->count;\n\n\twhile (--n >= 0) {\n /* If you add a ->what type here, update the comment in regcomp.h */\n\t switch (ri->data->what[n]) {\n\t case 'a':\n\t case 'r':\n\t case 's':\n\t case 'S':\n\t case 'u':\n\t\tSvREFCNT_dec(MUTABLE_SV(ri->data->data[n]));\n\t\tbreak;\n\t case 'f':\n\t\tSafefree(ri->data->data[n]);\n\t\tbreak;\n\t case 'l':\n\t case 'L':\n\t break;\n case 'T':\n { /* Aho Corasick add-on structure for a trie node.\n Used in stclass optimization only */\n U32 refcount;\n reg_ac_data *aho=(reg_ac_data*)ri->data->data[n];\n#ifdef USE_ITHREADS\n dVAR;\n#endif\n OP_REFCNT_LOCK;\n refcount = --aho->refcount;\n OP_REFCNT_UNLOCK;\n if ( !refcount ) {\n PerlMemShared_free(aho->states);\n PerlMemShared_free(aho->fail);\n\t\t\t /* do this last!!!! */\n PerlMemShared_free(ri->data->data[n]);\n /* we should only ever get called once, so\n * assert as much, and also guard the free\n * which /might/ happen twice. At the least\n * it will make code anlyzers happy and it\n * doesn't cost much. - Yves */\n assert(ri->regstclass);\n if (ri->regstclass) {\n PerlMemShared_free(ri->regstclass);\n ri->regstclass = 0;\n }\n }\n }\n break;\n\t case 't':\n\t {\n\t /* trie structure. */\n\t U32 refcount;\n\t reg_trie_data *trie=(reg_trie_data*)ri->data->data[n];\n#ifdef USE_ITHREADS\n dVAR;\n#endif\n OP_REFCNT_LOCK;\n refcount = --trie->refcount;\n OP_REFCNT_UNLOCK;\n if ( !refcount ) {\n PerlMemShared_free(trie->charmap);\n PerlMemShared_free(trie->states);\n PerlMemShared_free(trie->trans);\n if (trie->bitmap)\n PerlMemShared_free(trie->bitmap);\n if (trie->jump)\n PerlMemShared_free(trie->jump);\n\t\t\tPerlMemShared_free(trie->wordinfo);\n /* do this last!!!! */\n PerlMemShared_free(ri->data->data[n]);\n\t\t }\n\t\t}\n\t\tbreak;\n\t default:\n\t\tPerl_croak(aTHX_ \"panic: regfree data code '%c'\",\n ri->data->what[n]);\n\t }\n\t}\n\tSafefree(ri->data->what);\n\tSafefree(ri->data);\n }\n\n Safefree(ri);\n}\n\n#define av_dup_inc(s,t)\tMUTABLE_AV(sv_dup_inc((const SV *)s,t))\n#define hv_dup_inc(s,t)\tMUTABLE_HV(sv_dup_inc((const SV *)s,t))\n#define SAVEPVN(p,n)\t((p) ? savepvn(p,n) : NULL)\n\n/*\n re_dup_guts - duplicate a regexp.\n\n This routine is expected to clone a given regexp structure. It is only\n compiled under USE_ITHREADS.\n\n After all of the core data stored in struct regexp is duplicated\n the regexp_engine.dupe method is used to copy any private data\n stored in the *pprivate pointer. This allows extensions to handle\n any duplication it needs to do.\n\n See pregfree() and regfree_internal() if you change anything here.\n*/\n#if defined(USE_ITHREADS)\n#ifndef PERL_IN_XSUB_RE\nvoid\nPerl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param)\n{\n dVAR;\n I32 npar;\n const struct regexp *r = ReANY(sstr);\n struct regexp *ret = ReANY(dstr);\n\n PERL_ARGS_ASSERT_RE_DUP_GUTS;\n\n npar = r->nparens+1;\n Newx(ret->offs, npar, regexp_paren_pair);\n Copy(r->offs, ret->offs, npar, regexp_paren_pair);\n\n if (ret->substrs) {\n\t/* Do it this way to avoid reading from *r after the StructCopy().\n\t That way, if any of the sv_dup_inc()s dislodge *r from the L1\n\t cache, it doesn't matter. */\n int i;\n\tconst bool anchored = r->check_substr\n\t ? r->check_substr == r->substrs->data[0].substr\n\t : r->check_utf8 == r->substrs->data[0].utf8_substr;\n Newx(ret->substrs, 1, struct reg_substr_data);\n\tStructCopy(r->substrs, ret->substrs, struct reg_substr_data);\n\n for (i = 0; i < 2; i++) {\n ret->substrs->data[i].substr =\n sv_dup_inc(ret->substrs->data[i].substr, param);\n ret->substrs->data[i].utf8_substr =\n sv_dup_inc(ret->substrs->data[i].utf8_substr, param);\n }\n\n\t/* check_substr and check_utf8, if non-NULL, point to either their\n\t anchored or float namesakes, and don't hold a second reference. */\n\n\tif (ret->check_substr) {\n\t if (anchored) {\n\t\tassert(r->check_utf8 == r->substrs->data[0].utf8_substr);\n\n\t\tret->check_substr = ret->substrs->data[0].substr;\n\t\tret->check_utf8 = ret->substrs->data[0].utf8_substr;\n\t } else {\n\t\tassert(r->check_substr == r->substrs->data[1].substr);\n\t\tassert(r->check_utf8 == r->substrs->data[1].utf8_substr);\n\n\t\tret->check_substr = ret->substrs->data[1].substr;\n\t\tret->check_utf8 = ret->substrs->data[1].utf8_substr;\n\t }\n\t} else if (ret->check_utf8) {\n\t if (anchored) {\n\t\tret->check_utf8 = ret->substrs->data[0].utf8_substr;\n\t } else {\n\t\tret->check_utf8 = ret->substrs->data[1].utf8_substr;\n\t }\n\t}\n }\n\n RXp_PAREN_NAMES(ret) = hv_dup_inc(RXp_PAREN_NAMES(ret), param);\n ret->qr_anoncv = MUTABLE_CV(sv_dup_inc((const SV *)ret->qr_anoncv, param));\n if (r->recurse_locinput)\n Newx(ret->recurse_locinput,r->nparens + 1,char *);\n\n if (ret->pprivate)\n\tRXi_SET(ret,CALLREGDUPE_PVT(dstr,param));\n\n if (RX_MATCH_COPIED(dstr))\n\tret->subbeg = SAVEPVN(ret->subbeg, ret->sublen);\n else\n\tret->subbeg = NULL;\n#ifdef PERL_ANY_COW\n ret->saved_copy = NULL;\n#endif\n\n /* Whether mother_re be set or no, we need to copy the string. We\n cannot refrain from copying it when the storage points directly to\n our mother regexp, because that's\n\t 1: a buffer in a different thread\n\t 2: something we no longer hold a reference on\n\t so we need to copy it locally. */\n RX_WRAPPED(dstr) = SAVEPVN(RX_WRAPPED_const(sstr), SvCUR(sstr)+1);\n ret->mother_re = NULL;\n}\n#endif /* PERL_IN_XSUB_RE */\n\n/*\n regdupe_internal()\n\n This is the internal complement to regdupe() which is used to copy\n the structure pointed to by the *pprivate pointer in the regexp.\n This is the core version of the extension overridable cloning hook.\n The regexp structure being duplicated will be copied by perl prior\n to this and will be provided as the regexp *r argument, however\n with the /old/ structures pprivate pointer value. Thus this routine\n may override any copying normally done by perl.\n\n It returns a pointer to the new regexp_internal structure.\n*/\n\nvoid *\nPerl_regdupe_internal(pTHX_ REGEXP * const rx, CLONE_PARAMS *param)\n{\n dVAR;\n struct regexp *const r = ReANY(rx);\n regexp_internal *reti;\n int len;\n RXi_GET_DECL(r,ri);\n\n PERL_ARGS_ASSERT_REGDUPE_INTERNAL;\n\n len = ProgLen(ri);\n\n Newxc(reti, sizeof(regexp_internal) + len*sizeof(regnode),\n char, regexp_internal);\n Copy(ri->program, reti->program, len+1, regnode);\n\n\n if (ri->code_blocks) {\n\tint n;\n\tNewx(reti->code_blocks, 1, struct reg_code_blocks);\n\tNewx(reti->code_blocks->cb, ri->code_blocks->count,\n struct reg_code_block);\n\tCopy(ri->code_blocks->cb, reti->code_blocks->cb,\n ri->code_blocks->count, struct reg_code_block);\n\tfor (n = 0; n < ri->code_blocks->count; n++)\n\t reti->code_blocks->cb[n].src_regex = (REGEXP*)\n\t\t sv_dup_inc((SV*)(ri->code_blocks->cb[n].src_regex), param);\n reti->code_blocks->count = ri->code_blocks->count;\n reti->code_blocks->refcnt = 1;\n }\n else\n\treti->code_blocks = NULL;\n\n reti->regstclass = NULL;\n\n if (ri->data) {\n\tstruct reg_data *d;\n const int count = ri->data->count;\n\tint i;\n\n\tNewxc(d, sizeof(struct reg_data) + count*sizeof(void *),\n\t\tchar, struct reg_data);\n\tNewx(d->what, count, U8);\n\n\td->count = count;\n\tfor (i = 0; i < count; i++) {\n\t d->what[i] = ri->data->what[i];\n\t switch (d->what[i]) {\n\t /* see also regcomp.h and regfree_internal() */\n case 'a': /* actually an AV, but the dup function is identical.\n values seem to be \"plain sv's\" generally. */\n case 'r': /* a compiled regex (but still just another SV) */\n case 's': /* an RV (currently only used for an RV to an AV by the ANYOF code)\n this use case should go away, the code could have used\n 'a' instead - see S_set_ANYOF_arg() for array contents. */\n case 'S': /* actually an SV, but the dup function is identical. */\n case 'u': /* actually an HV, but the dup function is identical.\n values are \"plain sv's\" */\n\t\td->data[i] = sv_dup_inc((const SV *)ri->data->data[i], param);\n\t\tbreak;\n\t case 'f':\n /* Synthetic Start Class - \"Fake\" charclass we generate to optimize\n * patterns which could start with several different things. Pre-TRIE\n * this was more important than it is now, however this still helps\n * in some places, for instance /x?a+/ might produce a SSC equivalent\n * to [xa]. This is used by Perl_re_intuit_start() and S_find_byclass()\n * in regexec.c\n */\n\t\t/* This is cheating. */\n\t\tNewx(d->data[i], 1, regnode_ssc);\n\t\tStructCopy(ri->data->data[i], d->data[i], regnode_ssc);\n\t\treti->regstclass = (regnode*)d->data[i];\n\t\tbreak;\n\t case 'T':\n /* AHO-CORASICK fail table */\n /* Trie stclasses are readonly and can thus be shared\n\t\t * without duplication. We free the stclass in pregfree\n\t\t * when the corresponding reg_ac_data struct is freed.\n\t\t */\n\t\treti->regstclass= ri->regstclass;\n\t\t/* FALLTHROUGH */\n\t case 't':\n /* TRIE transition table */\n\t\tOP_REFCNT_LOCK;\n\t\t((reg_trie_data*)ri->data->data[i])->refcount++;\n\t\tOP_REFCNT_UNLOCK;\n\t\t/* FALLTHROUGH */\n case 'l': /* (?{...}) or (??{ ... }) code (cb->block) */\n case 'L': /* same when RExC_pm_flags & PMf_HAS_CV and code\n is not from another regexp */\n\t\td->data[i] = ri->data->data[i];\n\t\tbreak;\n default:\n Perl_croak(aTHX_ \"panic: re_dup_guts unknown data code '%c'\",\n ri->data->what[i]);\n\t }\n\t}\n\n\treti->data = d;\n }\n else\n\treti->data = NULL;\n\n reti->name_list_idx = ri->name_list_idx;\n\n#ifdef RE_TRACK_PATTERN_OFFSETS\n if (ri->u.offsets) {\n Newx(reti->u.offsets, 2*len+1, U32);\n Copy(ri->u.offsets, reti->u.offsets, 2*len+1, U32);\n }\n#else\n SetProgLen(reti,len);\n#endif\n\n return (void*)reti;\n}\n\n#endif /* USE_ITHREADS */\n\n#ifndef PERL_IN_XSUB_RE\n\n/*\n - regnext - dig the \"next\" pointer out of a node\n */\nregnode *\nPerl_regnext(pTHX_ regnode *p)\n{\n I32 offset;\n\n if (!p)\n\treturn(NULL);\n\n if (OP(p) > REGNODE_MAX) {\t\t/* regnode.type is unsigned */\n\tPerl_croak(aTHX_ \"Corrupted regexp opcode %d > %d\",\n (int)OP(p), (int)REGNODE_MAX);\n }\n\n offset = (reg_off_by_arg[OP(p)] ? ARG(p) : NEXT_OFF(p));\n if (offset == 0)\n\treturn(NULL);\n\n return(p+offset);\n}\n#endif\n\nSTATIC void\nS_re_croak2(pTHX_ bool utf8, const char* pat1,const char* pat2,...)\n{\n va_list args;\n STRLEN l1 = strlen(pat1);\n STRLEN l2 = strlen(pat2);\n char buf[512];\n SV *msv;\n const char *message;\n\n PERL_ARGS_ASSERT_RE_CROAK2;\n\n if (l1 > 510)\n\tl1 = 510;\n if (l1 + l2 > 510)\n\tl2 = 510 - l1;\n Copy(pat1, buf, l1 , char);\n Copy(pat2, buf + l1, l2 , char);\n buf[l1 + l2] = '\\n';\n buf[l1 + l2 + 1] = '\\0';\n va_start(args, pat2);\n msv = vmess(buf, &args);\n va_end(args);\n message = SvPV_const(msv,l1);\n if (l1 > 512)\n\tl1 = 512;\n Copy(message, buf, l1 , char);\n /* l1-1 to avoid \\n */\n Perl_croak(aTHX_ \"%\" UTF8f, UTF8fARG(utf8, l1-1, buf));\n}\n\n/* XXX Here's a total kludge. But we need to re-enter for swash routines. */\n\n#ifndef PERL_IN_XSUB_RE\nvoid\nPerl_save_re_context(pTHX)\n{\n I32 nparens = -1;\n I32 i;\n\n /* Save $1..$n (#18107: UTF-8 s/(\\w+)/uc($1)/e); AMS 20021106. */\n\n if (PL_curpm) {\n\tconst REGEXP * const rx = PM_GETRE(PL_curpm);\n\tif (rx)\n nparens = RX_NPARENS(rx);\n }\n\n /* RT #124109. This is a complete hack; in the SWASHNEW case we know\n * that PL_curpm will be null, but that utf8.pm and the modules it\n * loads will only use $1..$3.\n * The t/porting/re_context.t test file checks this assumption.\n */\n if (nparens == -1)\n nparens = 3;\n\n for (i = 1; i <= nparens; i++) {\n char digits[TYPE_CHARS(long)];\n const STRLEN len = my_snprintf(digits, sizeof(digits),\n \"%lu\", (long)i);\n GV *const *const gvp\n = (GV**)hv_fetch(PL_defstash, digits, len, 0);\n\n if (gvp) {\n GV * const gv = *gvp;\n if (SvTYPE(gv) == SVt_PVGV && GvSV(gv))\n save_scalar(gv);\n }\n }\n}\n#endif\n\n#ifdef DEBUGGING\n\nSTATIC void\nS_put_code_point(pTHX_ SV *sv, UV c)\n{\n PERL_ARGS_ASSERT_PUT_CODE_POINT;\n\n if (c > 255) {\n Perl_sv_catpvf(aTHX_ sv, \"\\\\x{%04\" UVXf \"}\", c);\n }\n else if (isPRINT(c)) {\n\tconst char string = (char) c;\n\n /* We use {phrase} as metanotation in the class, so also escape literal\n * braces */\n\tif (isBACKSLASHED_PUNCT(c) || c == '{' || c == '}')\n\t sv_catpvs(sv, \"\\\\\");\n\tsv_catpvn(sv, &string, 1);\n }\n else if (isMNEMONIC_CNTRL(c)) {\n Perl_sv_catpvf(aTHX_ sv, \"%s\", cntrl_to_mnemonic((U8) c));\n }\n else {\n Perl_sv_catpvf(aTHX_ sv, \"\\\\x%02X\", (U8) c);\n }\n}\n\n#define MAX_PRINT_A MAX_PRINT_A_FOR_USE_ONLY_BY_REGCOMP_DOT_C\n\nSTATIC void\nS_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals)\n{\n /* Appends to 'sv' a displayable version of the range of code points from\n * 'start' to 'end'. Mnemonics (like '\\r') are used for the few controls\n * that have them, when they occur at the beginning or end of the range.\n * It uses hex to output the remaining code points, unless 'allow_literals'\n * is true, in which case the printable ASCII ones are output as-is (though\n * some of these will be escaped by put_code_point()).\n *\n * NOTE: This is designed only for printing ranges of code points that fit\n * inside an ANYOF bitmap. Higher code points are simply suppressed\n */\n\n const unsigned int min_range_count = 3;\n\n assert(start <= end);\n\n PERL_ARGS_ASSERT_PUT_RANGE;\n\n while (start <= end) {\n UV this_end;\n const char * format;\n\n if (end - start < min_range_count) {\n\n /* Output chars individually when they occur in short ranges */\n for (; start <= end; start++) {\n put_code_point(sv, start);\n }\n break;\n }\n\n /* If permitted by the input options, and there is a possibility that\n * this range contains a printable literal, look to see if there is\n * one. */\n if (allow_literals && start <= MAX_PRINT_A) {\n\n /* If the character at the beginning of the range isn't an ASCII\n * printable, effectively split the range into two parts:\n * 1) the portion before the first such printable,\n * 2) the rest\n * and output them separately. */\n if (! isPRINT_A(start)) {\n UV temp_end = start + 1;\n\n /* There is no point looking beyond the final possible\n * printable, in MAX_PRINT_A */\n UV max = MIN(end, MAX_PRINT_A);\n\n while (temp_end <= max && ! isPRINT_A(temp_end)) {\n temp_end++;\n }\n\n /* Here, temp_end points to one beyond the first printable if\n * found, or to one beyond 'max' if not. If none found, make\n * sure that we use the entire range */\n if (temp_end > MAX_PRINT_A) {\n temp_end = end + 1;\n }\n\n /* Output the first part of the split range: the part that\n * doesn't have printables, with the parameter set to not look\n * for literals (otherwise we would infinitely recurse) */\n put_range(sv, start, temp_end - 1, FALSE);\n\n /* The 2nd part of the range (if any) starts here. */\n start = temp_end;\n\n /* We do a continue, instead of dropping down, because even if\n * the 2nd part is non-empty, it could be so short that we want\n * to output it as individual characters, as tested for at the\n * top of this loop. */\n continue;\n }\n\n /* Here, 'start' is a printable ASCII. If it is an alphanumeric,\n * output a sub-range of just the digits or letters, then process\n * the remaining portion as usual. */\n if (isALPHANUMERIC_A(start)) {\n UV mask = (isDIGIT_A(start))\n ? _CC_DIGIT\n : isUPPER_A(start)\n ? _CC_UPPER\n : _CC_LOWER;\n UV temp_end = start + 1;\n\n /* Find the end of the sub-range that includes just the\n * characters in the same class as the first character in it */\n while (temp_end <= end && _generic_isCC_A(temp_end, mask)) {\n temp_end++;\n }\n temp_end--;\n\n /* For short ranges, don't duplicate the code above to output\n * them; just call recursively */\n if (temp_end - start < min_range_count) {\n put_range(sv, start, temp_end, FALSE);\n }\n else { /* Output as a range */\n put_code_point(sv, start);\n sv_catpvs(sv, \"-\");\n put_code_point(sv, temp_end);\n }\n start = temp_end + 1;\n continue;\n }\n\n /* We output any other printables as individual characters */\n if (isPUNCT_A(start) || isSPACE_A(start)) {\n while (start <= end && (isPUNCT_A(start)\n || isSPACE_A(start)))\n {\n put_code_point(sv, start);\n start++;\n }\n continue;\n }\n } /* End of looking for literals */\n\n /* Here is not to output as a literal. Some control characters have\n * mnemonic names. Split off any of those at the beginning and end of\n * the range to print mnemonically. It isn't possible for many of\n * these to be in a row, so this won't overwhelm with output */\n if ( start <= end\n && (isMNEMONIC_CNTRL(start) || isMNEMONIC_CNTRL(end)))\n {\n while (isMNEMONIC_CNTRL(start) && start <= end) {\n put_code_point(sv, start);\n start++;\n }\n\n /* If this didn't take care of the whole range ... */\n if (start <= end) {\n\n /* Look backwards from the end to find the final non-mnemonic\n * */\n UV temp_end = end;\n while (isMNEMONIC_CNTRL(temp_end)) {\n temp_end--;\n }\n\n /* And separately output the interior range that doesn't start\n * or end with mnemonics */\n put_range(sv, start, temp_end, FALSE);\n\n /* Then output the mnemonic trailing controls */\n start = temp_end + 1;\n while (start <= end) {\n put_code_point(sv, start);\n start++;\n }\n break;\n }\n }\n\n /* As a final resort, output the range or subrange as hex. */\n\n this_end = (end < NUM_ANYOF_CODE_POINTS)\n ? end\n : NUM_ANYOF_CODE_POINTS - 1;\n#if NUM_ANYOF_CODE_POINTS > 256\n format = (this_end < 256)\n ? \"\\\\x%02\" UVXf \"-\\\\x%02\" UVXf\n : \"\\\\x{%04\" UVXf \"}-\\\\x{%04\" UVXf \"}\";\n#else\n format = \"\\\\x%02\" UVXf \"-\\\\x%02\" UVXf;\n#endif\n GCC_DIAG_IGNORE(-Wformat-nonliteral);\n Perl_sv_catpvf(aTHX_ sv, format, start, this_end);\n GCC_DIAG_RESTORE;\n break;\n }\n}\n\nSTATIC void\nS_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV* invlist)\n{\n /* Concatenate onto the PV in 'sv' a displayable form of the inversion list\n * 'invlist' */\n\n UV start, end;\n bool allow_literals = TRUE;\n\n PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_INVLIST;\n\n /* Generally, it is more readable if printable characters are output as\n * literals, but if a range (nearly) spans all of them, it's best to output\n * it as a single range. This code will use a single range if all but 2\n * ASCII printables are in it */\n invlist_iterinit(invlist);\n while (invlist_iternext(invlist, &start, &end)) {\n\n /* If the range starts beyond the final printable, it doesn't have any\n * in it */\n if (start > MAX_PRINT_A) {\n break;\n }\n\n /* In both ASCII and EBCDIC, a SPACE is the lowest printable. To span\n * all but two, the range must start and end no later than 2 from\n * either end */\n if (start < ' ' + 2 && end > MAX_PRINT_A - 2) {\n if (end > MAX_PRINT_A) {\n end = MAX_PRINT_A;\n }\n if (start < ' ') {\n start = ' ';\n }\n if (end - start >= MAX_PRINT_A - ' ' - 2) {\n allow_literals = FALSE;\n }\n break;\n }\n }\n invlist_iterfinish(invlist);\n\n /* Here we have figured things out. Output each range */\n invlist_iterinit(invlist);\n while (invlist_iternext(invlist, &start, &end)) {\n if (start >= NUM_ANYOF_CODE_POINTS) {\n break;\n }\n put_range(sv, start, end, allow_literals);\n }\n invlist_iterfinish(invlist);\n\n return;\n}\n\nSTATIC SV*\nS_put_charclass_bitmap_innards_common(pTHX_\n SV* invlist, /* The bitmap */\n SV* posixes, /* Under /l, things like [:word:], \\S */\n SV* only_utf8, /* Under /d, matches iff the target is UTF-8 */\n SV* not_utf8, /* /d, matches iff the target isn't UTF-8 */\n SV* only_utf8_locale, /* Under /l, matches if the locale is UTF-8 */\n const bool invert /* Is the result to be inverted? */\n)\n{\n /* Create and return an SV containing a displayable version of the bitmap\n * and associated information determined by the input parameters. If the\n * output would have been only the inversion indicator '^', NULL is instead\n * returned. */\n\n SV * output;\n\n PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON;\n\n if (invert) {\n output = newSVpvs(\"^\");\n }\n else {\n output = newSVpvs(\"\");\n }\n\n /* First, the code points in the bitmap that are unconditionally there */\n put_charclass_bitmap_innards_invlist(output, invlist);\n\n /* Traditionally, these have been placed after the main code points */\n if (posixes) {\n sv_catsv(output, posixes);\n }\n\n if (only_utf8 && _invlist_len(only_utf8)) {\n Perl_sv_catpvf(aTHX_ output, \"%s{utf8}%s\", PL_colors[1], PL_colors[0]);\n put_charclass_bitmap_innards_invlist(output, only_utf8);\n }\n\n if (not_utf8 && _invlist_len(not_utf8)) {\n Perl_sv_catpvf(aTHX_ output, \"%s{not utf8}%s\", PL_colors[1], PL_colors[0]);\n put_charclass_bitmap_innards_invlist(output, not_utf8);\n }\n\n if (only_utf8_locale && _invlist_len(only_utf8_locale)) {\n Perl_sv_catpvf(aTHX_ output, \"%s{utf8 locale}%s\", PL_colors[1], PL_colors[0]);\n put_charclass_bitmap_innards_invlist(output, only_utf8_locale);\n\n /* This is the only list in this routine that can legally contain code\n * points outside the bitmap range. The call just above to\n * 'put_charclass_bitmap_innards_invlist' will simply suppress them, so\n * output them here. There's about a half-dozen possible, and none in\n * contiguous ranges longer than 2 */\n if (invlist_highest(only_utf8_locale) >= NUM_ANYOF_CODE_POINTS) {\n UV start, end;\n SV* above_bitmap = NULL;\n\n _invlist_subtract(only_utf8_locale, PL_InBitmap, &above_bitmap);\n\n invlist_iterinit(above_bitmap);\n while (invlist_iternext(above_bitmap, &start, &end)) {\n UV i;\n\n for (i = start; i <= end; i++) {\n put_code_point(output, i);\n }\n }\n invlist_iterfinish(above_bitmap);\n SvREFCNT_dec_NN(above_bitmap);\n }\n }\n\n if (invert && SvCUR(output) == 1) {\n return NULL;\n }\n\n return output;\n}\n\nSTATIC bool\nS_put_charclass_bitmap_innards(pTHX_ SV *sv,\n char *bitmap,\n SV *nonbitmap_invlist,\n SV *only_utf8_locale_invlist,\n const regnode * const node,\n const bool force_as_is_display)\n{\n /* Appends to 'sv' a displayable version of the innards of the bracketed\n * character class defined by the other arguments:\n * 'bitmap' points to the bitmap.\n * 'nonbitmap_invlist' is an inversion list of the code points that are in\n * the bitmap range, but for some reason aren't in the bitmap; NULL if\n * none. The reasons for this could be that they require some\n * condition such as the target string being or not being in UTF-8\n * (under /d), or because they came from a user-defined property that\n * was not resolved at the time of the regex compilation (under /u)\n * 'only_utf8_locale_invlist' is an inversion list of the code points that\n * are valid only if the runtime locale is a UTF-8 one; NULL if none\n * 'node' is the regex pattern node. It is needed only when the above two\n * parameters are not null, and is passed so that this routine can\n * tease apart the various reasons for them.\n * 'force_as_is_display' is TRUE if this routine should definitely NOT try\n * to invert things to see if that leads to a cleaner display. If\n * FALSE, this routine is free to use its judgment about doing this.\n *\n * It returns TRUE if there was actually something output. (It may be that\n * the bitmap, etc is empty.)\n *\n * When called for outputting the bitmap of a non-ANYOF node, just pass the\n * bitmap, with the succeeding parameters set to NULL, and the final one to\n * FALSE.\n */\n\n /* In general, it tries to display the 'cleanest' representation of the\n * innards, choosing whether to display them inverted or not, regardless of\n * whether the class itself is to be inverted. However, there are some\n * cases where it can't try inverting, as what actually matches isn't known\n * until runtime, and hence the inversion isn't either. */\n bool inverting_allowed = ! force_as_is_display;\n\n int i;\n STRLEN orig_sv_cur = SvCUR(sv);\n\n SV* invlist; /* Inversion list we accumulate of code points that\n are unconditionally matched */\n SV* only_utf8 = NULL; /* Under /d, list of matches iff the target is\n UTF-8 */\n SV* not_utf8 = NULL; /* /d, list of matches iff the target isn't UTF-8\n */\n SV* posixes = NULL; /* Under /l, string of things like [:word:], \\D */\n SV* only_utf8_locale = NULL; /* Under /l, list of matches if the locale\n is UTF-8 */\n\n SV* as_is_display; /* The output string when we take the inputs\n literally */\n SV* inverted_display; /* The output string when we invert the inputs */\n\n U8 flags = (node) ? ANYOF_FLAGS(node) : 0;\n\n bool invert = cBOOL(flags & ANYOF_INVERT); /* Is the input to be inverted\n to match? */\n /* We are biased in favor of displaying things without them being inverted,\n * as that is generally easier to understand */\n const int bias = 5;\n\n PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS;\n\n /* Start off with whatever code points are passed in. (We clone, so we\n * don't change the caller's list) */\n if (nonbitmap_invlist) {\n assert(invlist_highest(nonbitmap_invlist) < NUM_ANYOF_CODE_POINTS);\n invlist = invlist_clone(nonbitmap_invlist);\n }\n else { /* Worst case size is every other code point is matched */\n invlist = _new_invlist(NUM_ANYOF_CODE_POINTS / 2);\n }\n\n if (flags) {\n if (OP(node) == ANYOFD) {\n\n /* This flag indicates that the code points below 0x100 in the\n * nonbitmap list are precisely the ones that match only when the\n * target is UTF-8 (they should all be non-ASCII). */\n if (flags & ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP)\n {\n _invlist_intersection(invlist, PL_UpperLatin1, &only_utf8);\n _invlist_subtract(invlist, only_utf8, &invlist);\n }\n\n /* And this flag for matching all non-ASCII 0xFF and below */\n if (flags & ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER)\n {\n not_utf8 = invlist_clone(PL_UpperLatin1);\n }\n }\n else if (OP(node) == ANYOFL) {\n\n /* If either of these flags are set, what matches isn't\n * determinable except during execution, so don't know enough here\n * to invert */\n if (flags & (ANYOFL_FOLD|ANYOF_MATCHES_POSIXL)) {\n inverting_allowed = FALSE;\n }\n\n /* What the posix classes match also varies at runtime, so these\n * will be output symbolically. */\n if (ANYOF_POSIXL_TEST_ANY_SET(node)) {\n int i;\n\n posixes = newSVpvs(\"\");\n for (i = 0; i < ANYOF_POSIXL_MAX; i++) {\n if (ANYOF_POSIXL_TEST(node,i)) {\n sv_catpv(posixes, anyofs[i]);\n }\n }\n }\n }\n }\n\n /* Accumulate the bit map into the unconditional match list */\n for (i = 0; i < NUM_ANYOF_CODE_POINTS; i++) {\n if (BITMAP_TEST(bitmap, i)) {\n int start = i++;\n for (; i < NUM_ANYOF_CODE_POINTS && BITMAP_TEST(bitmap, i); i++) {\n /* empty */\n }\n invlist = _add_range_to_invlist(invlist, start, i-1);\n }\n }\n\n /* Make sure that the conditional match lists don't have anything in them\n * that match unconditionally; otherwise the output is quite confusing.\n * This could happen if the code that populates these misses some\n * duplication. */\n if (only_utf8) {\n _invlist_subtract(only_utf8, invlist, &only_utf8);\n }\n if (not_utf8) {\n _invlist_subtract(not_utf8, invlist, ¬_utf8);\n }\n\n if (only_utf8_locale_invlist) {\n\n /* Since this list is passed in, we have to make a copy before\n * modifying it */\n only_utf8_locale = invlist_clone(only_utf8_locale_invlist);\n\n _invlist_subtract(only_utf8_locale, invlist, &only_utf8_locale);\n\n /* And, it can get really weird for us to try outputting an inverted\n * form of this list when it has things above the bitmap, so don't even\n * try */\n if (invlist_highest(only_utf8_locale) >= NUM_ANYOF_CODE_POINTS) {\n inverting_allowed = FALSE;\n }\n }\n\n /* Calculate what the output would be if we take the input as-is */\n as_is_display = put_charclass_bitmap_innards_common(invlist,\n posixes,\n only_utf8,\n not_utf8,\n only_utf8_locale,\n invert);\n\n /* If have to take the output as-is, just do that */\n if (! inverting_allowed) {\n if (as_is_display) {\n sv_catsv(sv, as_is_display);\n SvREFCNT_dec_NN(as_is_display);\n }\n }\n else { /* But otherwise, create the output again on the inverted input, and\n use whichever version is shorter */\n\n int inverted_bias, as_is_bias;\n\n /* We will apply our bias to whichever of the the results doesn't have\n * the '^' */\n if (invert) {\n invert = FALSE;\n as_is_bias = bias;\n inverted_bias = 0;\n }\n else {\n invert = TRUE;\n as_is_bias = 0;\n inverted_bias = bias;\n }\n\n /* Now invert each of the lists that contribute to the output,\n * excluding from the result things outside the possible range */\n\n /* For the unconditional inversion list, we have to add in all the\n * conditional code points, so that when inverted, they will be gone\n * from it */\n _invlist_union(only_utf8, invlist, &invlist);\n _invlist_union(not_utf8, invlist, &invlist);\n _invlist_union(only_utf8_locale, invlist, &invlist);\n _invlist_invert(invlist);\n _invlist_intersection(invlist, PL_InBitmap, &invlist);\n\n if (only_utf8) {\n _invlist_invert(only_utf8);\n _invlist_intersection(only_utf8, PL_UpperLatin1, &only_utf8);\n }\n else if (not_utf8) {\n\n /* If a code point matches iff the target string is not in UTF-8,\n * then complementing the result has it not match iff not in UTF-8,\n * which is the same thing as matching iff it is UTF-8. */\n only_utf8 = not_utf8;\n not_utf8 = NULL;\n }\n\n if (only_utf8_locale) {\n _invlist_invert(only_utf8_locale);\n _invlist_intersection(only_utf8_locale,\n PL_InBitmap,\n &only_utf8_locale);\n }\n\n inverted_display = put_charclass_bitmap_innards_common(\n invlist,\n posixes,\n only_utf8,\n not_utf8,\n only_utf8_locale, invert);\n\n /* Use the shortest representation, taking into account our bias\n * against showing it inverted */\n if ( inverted_display\n && ( ! as_is_display\n || ( SvCUR(inverted_display) + inverted_bias\n < SvCUR(as_is_display) + as_is_bias)))\n {\n\t sv_catsv(sv, inverted_display);\n }\n else if (as_is_display) {\n\t sv_catsv(sv, as_is_display);\n }\n\n SvREFCNT_dec(as_is_display);\n SvREFCNT_dec(inverted_display);\n }\n\n SvREFCNT_dec_NN(invlist);\n SvREFCNT_dec(only_utf8);\n SvREFCNT_dec(not_utf8);\n SvREFCNT_dec(posixes);\n SvREFCNT_dec(only_utf8_locale);\n\n return SvCUR(sv) > orig_sv_cur;\n}\n\n#define CLEAR_OPTSTART \\\n if (optstart) STMT_START { \\\n DEBUG_OPTIMISE_r(Perl_re_printf( aTHX_ \\\n \" (%\" IVdf \" nodes)\\n\", (IV)(node - optstart))); \\\n optstart=NULL; \\\n } STMT_END\n\n#define DUMPUNTIL(b,e) \\\n CLEAR_OPTSTART; \\\n node=dumpuntil(r,start,(b),(e),last,sv,indent+1,depth+1);\n\nSTATIC const regnode *\nS_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node,\n\t const regnode *last, const regnode *plast,\n\t SV* sv, I32 indent, U32 depth)\n{\n U8 op = PSEUDO;\t/* Arbitrary non-END op. */\n const regnode *next;\n const regnode *optstart= NULL;\n\n RXi_GET_DECL(r,ri);\n GET_RE_DEBUG_FLAGS_DECL;\n\n PERL_ARGS_ASSERT_DUMPUNTIL;\n\n#ifdef DEBUG_DUMPUNTIL\n Perl_re_printf( aTHX_ \"--- %d : %d - %d - %d\\n\",indent,node-start,\n last ? last-start : 0,plast ? plast-start : 0);\n#endif\n\n if (plast && plast < last)\n last= plast;\n\n while (PL_regkind[op] != END && (!last || node < last)) {\n assert(node);\n\t/* While that wasn't END last time... */\n\tNODE_ALIGN(node);\n\top = OP(node);\n\tif (op == CLOSE || op == WHILEM)\n\t indent--;\n\tnext = regnext((regnode *)node);\n\n\t/* Where, what. */\n\tif (OP(node) == OPTIMIZED) {\n\t if (!optstart && RE_DEBUG_FLAG(RE_DEBUG_COMPILE_OPTIMISE))\n\t optstart = node;\n\t else\n\t\tgoto after_print;\n\t} else\n\t CLEAR_OPTSTART;\n\n regprop(r, sv, node, NULL, NULL);\n Perl_re_printf( aTHX_ \"%4\" IVdf \":%*s%s\", (IV)(node - start),\n\t\t (int)(2*indent + 1), \"\", SvPVX_const(sv));\n\n if (OP(node) != OPTIMIZED) {\n if (next == NULL)\t\t/* Next ptr. */\n Perl_re_printf( aTHX_ \" (0)\");\n else if (PL_regkind[(U8)op] == BRANCH\n && PL_regkind[OP(next)] != BRANCH )\n Perl_re_printf( aTHX_ \" (FAIL)\");\n else\n Perl_re_printf( aTHX_ \" (%\" IVdf \")\", (IV)(next - start));\n Perl_re_printf( aTHX_ \"\\n\");\n }\n\n after_print:\n\tif (PL_regkind[(U8)op] == BRANCHJ) {\n\t assert(next);\n\t {\n const regnode *nnode = (OP(next) == LONGJMP\n ? regnext((regnode *)next)\n : next);\n if (last && nnode > last)\n nnode = last;\n DUMPUNTIL(NEXTOPER(NEXTOPER(node)), nnode);\n\t }\n\t}\n\telse if (PL_regkind[(U8)op] == BRANCH) {\n\t assert(next);\n\t DUMPUNTIL(NEXTOPER(node), next);\n\t}\n\telse if ( PL_regkind[(U8)op] == TRIE ) {\n\t const regnode *this_trie = node;\n\t const char op = OP(node);\n const U32 n = ARG(node);\n\t const reg_ac_data * const ac = op>=AHOCORASICK ?\n (reg_ac_data *)ri->data->data[n] :\n NULL;\n\t const reg_trie_data * const trie =\n\t (reg_trie_data*)ri->data->data[op<AHOCORASICK ? n : ac->trie];\n#ifdef DEBUGGING\n\t AV *const trie_words\n = MUTABLE_AV(ri->data->data[n + TRIE_WORDS_OFFSET]);\n#endif\n\t const regnode *nextbranch= NULL;\n\t I32 word_idx;\n SvPVCLEAR(sv);\n\t for (word_idx= 0; word_idx < (I32)trie->wordcount; word_idx++) {\n\t\tSV ** const elem_ptr = av_fetch(trie_words,word_idx,0);\n\n Perl_re_indentf( aTHX_ \"%s \",\n indent+3,\n elem_ptr\n ? pv_pretty(sv, SvPV_nolen_const(*elem_ptr),\n SvCUR(*elem_ptr), PL_dump_re_max_len,\n PL_colors[0], PL_colors[1],\n (SvUTF8(*elem_ptr)\n ? PERL_PV_ESCAPE_UNI\n : 0)\n | PERL_PV_PRETTY_ELLIPSES\n | PERL_PV_PRETTY_LTGT\n )\n : \"???\"\n );\n if (trie->jump) {\n U16 dist= trie->jump[word_idx+1];\n Perl_re_printf( aTHX_ \"(%\" UVuf \")\\n\",\n (UV)((dist ? this_trie + dist : next) - start));\n if (dist) {\n if (!nextbranch)\n nextbranch= this_trie + trie->jump[0];\n\t\t\tDUMPUNTIL(this_trie + dist, nextbranch);\n }\n if (nextbranch && PL_regkind[OP(nextbranch)]==BRANCH)\n nextbranch= regnext((regnode *)nextbranch);\n } else {\n Perl_re_printf( aTHX_ \"\\n\");\n\t\t}\n\t }\n\t if (last && next > last)\n\t node= last;\n\t else\n\t node= next;\n\t}\n\telse if ( op == CURLY ) { /* \"next\" might be very big: optimizer */\n\t DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS,\n NEXTOPER(node) + EXTRA_STEP_2ARGS + 1);\n\t}\n\telse if (PL_regkind[(U8)op] == CURLY && op != CURLYX) {\n\t assert(next);\n\t DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS, next);\n\t}\n\telse if ( op == PLUS || op == STAR) {\n\t DUMPUNTIL(NEXTOPER(node), NEXTOPER(node) + 1);\n\t}\n\telse if (PL_regkind[(U8)op] == ANYOF) {\n\t /* arglen 1 + class block */\n\t node += 1 + ((ANYOF_FLAGS(node) & ANYOF_MATCHES_POSIXL)\n ? ANYOF_POSIXL_SKIP\n : ANYOF_SKIP);\n\t node = NEXTOPER(node);\n\t}\n\telse if (PL_regkind[(U8)op] == EXACT) {\n /* Literal string, where present. */\n\t node += NODE_SZ_STR(node) - 1;\n\t node = NEXTOPER(node);\n\t}\n\telse {\n\t node = NEXTOPER(node);\n\t node += regarglen[(U8)op];\n\t}\n\tif (op == CURLYX || op == OPEN)\n\t indent++;\n }\n CLEAR_OPTSTART;\n#ifdef DEBUG_DUMPUNTIL\n Perl_re_printf( aTHX_ \"--- %d\\n\", (int)indent);\n#endif\n return node;\n}\n\n#endif\t/* DEBUGGING */\n\n/*\n * ex: set ts=8 sts=4 sw=4 et:\n */\n"},"max_stars_repo_path":{"kind":"string","value":"./CrossVul/dataset_final_sorted/CWE-119/c/good_412_2"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":31,"numItemsPerPage":100,"numTotalItems":7736,"offset":3100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjZlMjRkN2VhYmJjMGJkMjEwY2RkODBhIl0sImlhdCI6MTc5MzY5NjcxNiwianRpIjoiZjdlNjlmZjctMTZhOS00ZTFhLTkzZDUtOTRjNmM4NjQzMTJkIiwic3ViIjoiL2RhdGFzZXRzL3hpbjE5OTcvY3Jvc3N2dWwtY3BwX2FsbF9vbmx5X2lucHV0IiwiZXhwIjoxNzkzNzAwMzE2LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.ekV-ehOkMUIlE4576rSP2VDu_e0izdhgfOy3cs2yPWVSiyatMmgBDlXYWcLuru9biwolBglzYEdITdycdREgDg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":7736,"numBytesParquet":157725013}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
id stringlengths 25 30 | content stringlengths 14 942k | max_stars_repo_path stringlengths 49 55 |
|---|---|---|
crossvul-cpp_data_good_3065_0 | /***************************************************************************
ofx_preproc.cpp
-------------------
copyright : (C) 2002 by Benoit Gr�oir
email : benoitg@coeus.ca
***********************************************************************... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_3065_0 |
crossvul-cpp_data_good_1388_1 | /*-
* Copyright 2009 Colin Percival
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditio... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_1388_1 |
crossvul-cpp_data_good_963_0 | /****************************************************************************
** libebml : parse EBML files, see http://embl.sourceforge.net/
**
** <file/class description>
**
** Copyright (C) 2002-2010 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_963_0 |
crossvul-cpp_data_bad_846_0 | /*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com) |
| Copyrigh... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_846_0 |
crossvul-cpp_data_good_2485_0 | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//---------------------------------------------------------... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_2485_0 |
crossvul-cpp_data_bad_594_1 | 404: Not Found | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_594_1 |
crossvul-cpp_data_good_578_2 | /*
Copyright 2008-2017 LibRaw LLC (info@libraw.org)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:
1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
(See file LICENSE.LGPL provided in LibRaw distribution archive for details).
2. COMMON... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_578_2 |
crossvul-cpp_data_good_598_0 | /*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com) |
| Copyrigh... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_598_0 |
crossvul-cpp_data_good_594_0 | /*
* Copyright 2011-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or a... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_594_0 |
crossvul-cpp_data_bad_594_0 | 404: Not Found | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_594_0 |
crossvul-cpp_data_good_2324_0 | /*
Copyright (c) 2008-2014, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_2324_0 |
crossvul-cpp_data_bad_962_0 | /****************************************************************************
** libebml : parse EBML files, see http://embl.sourceforge.net/
**
** <file/class description>
**
** Copyright (C) 2002-2010 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_962_0 |
crossvul-cpp_data_bad_2945_1 | /*
Copyright 2008-2017 LibRaw LLC (info@libraw.org)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:
1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
(See file LICENSE.LGPL provided in LibRaw distribution archive for details).
2. COMMON... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_2945_1 |
crossvul-cpp_data_bad_5419_0 | /* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com. */
#include <new>
#include <stdlib.h> // qsort
#include <stdarg.h>
#include <base/math.h>
#include <base/system.h>
#include <eng... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_5419_0 |
crossvul-cpp_data_good_3626_0 | /* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2010 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
* the fil... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_3626_0 |
crossvul-cpp_data_bad_598_0 | /*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com) |
| Copyrigh... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_598_0 |
crossvul-cpp_data_good_5419_0 | /* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com. */
#include <new>
#include <stdlib.h> // qsort
#include <stdarg.h>
#include <base/math.h>
#include <base/system.h>
#include <eng... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_5419_0 |
crossvul-cpp_data_bad_1382_1 | /*
* Copyright (c) 2018-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <fizz/record/Plaint... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_1382_1 |
crossvul-cpp_data_good_2972_0 | /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, instal... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_2972_0 |
crossvul-cpp_data_bad_3065_0 | /***************************************************************************
ofx_preproc.cpp
-------------------
copyright : (C) 2002 by Benoit Gr�oir
email : benoitg@coeus.ca
***********************************************************************... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_3065_0 |
crossvul-cpp_data_bad_578_3 | /* -*- C++ -*-
* File: libraw_cxx.cpp
* Copyright 2008-2017 LibRaw LLC (info@libraw.org)
* Created: Sat Mar 8 , 2008
*
* LibRaw C++ interface (implementation)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:
1. GNU LESSER GENERAL PUBLIC ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_578_3 |
crossvul-cpp_data_bad_3219_0 | 404: Not Found | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_3219_0 |
crossvul-cpp_data_bad_2485_0 | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//---------------------------------------------------------... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_2485_0 |
crossvul-cpp_data_bad_2486_0 | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//---------------------------------------------------------... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_2486_0 |
crossvul-cpp_data_good_1636_2 | // Copyright Benoit Blanchon 2014-2015
// MIT License
//
// Arduino JSON library
// https://github.com/bblanchon/ArduinoJson
#include <gtest/gtest.h>
#include <ArduinoJson/Internals/QuotedString.hpp>
using namespace ArduinoJson::Internals;
class QuotedString_ExtractFrom_Tests : public testing::Test {
protected:
v... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_1636_2 |
crossvul-cpp_data_bad_3626_0 | /* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2010 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
* the fil... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_3626_0 |
crossvul-cpp_data_good_1636_1 | // Copyright Benoit Blanchon 2014-2015
// MIT License
//
// Arduino JSON library
// https://github.com/bblanchon/ArduinoJson
#include "../../include/ArduinoJson/Internals/QuotedString.hpp"
using namespace ArduinoJson::Internals;
// How to escape special chars:
// specialChars[2*i+1] => the special char
// specialCha... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_1636_1 |
crossvul-cpp_data_good_3219_0 | /*
Audio File Library
Copyright (C) 1998-2000, 2003-2004, 2010-2013, Michael Pruett <michael@68k.org>
Copyright (C) 2000-2002, Silicon Graphics, Inc.
Copyright (C) 2002-2003, Davy Durham
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
Lice... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_3219_0 |
crossvul-cpp_data_bad_1384_0 | /*
* Copyright 2017-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or a... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_1384_0 |
crossvul-cpp_data_good_1384_0 | /*
* Copyright 2017-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or a... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_1384_0 |
crossvul-cpp_data_good_578_3 | /* -*- C++ -*-
* File: libraw_cxx.cpp
* Copyright 2008-2017 LibRaw LLC (info@libraw.org)
* Created: Sat Mar 8 , 2008
*
* LibRaw C++ interface (implementation)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:
1. GNU LESSER GENERAL PUBLIC ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_578_3 |
crossvul-cpp_data_good_962_0 | /****************************************************************************
** libebml : parse EBML files, see http://embl.sourceforge.net/
**
** <file/class description>
**
** Copyright (C) 2002-2010 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_962_0 |
crossvul-cpp_data_bad_1636_1 | // Copyright Benoit Blanchon 2014-2015
// MIT License
//
// Arduino JSON library
// https://github.com/bblanchon/ArduinoJson
#include "../../include/ArduinoJson/Internals/QuotedString.hpp"
using namespace ArduinoJson::Internals;
// How to escape special chars:
// specialChars[2*i+1] => the special char
// specialCha... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_1636_1 |
crossvul-cpp_data_bad_2486_1 | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//---------------------------------------------------------... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_2486_1 |
crossvul-cpp_data_bad_1384_1 | /*
* Copyright 2017-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or a... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_1384_1 |
crossvul-cpp_data_good_3225_1 | /*
Copyright 2008-2016 LibRaw LLC (info@libraw.org)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:
1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
(See file LICENSE.LGPL provided in LibRaw distribution archive for details).
2. COMMON... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_3225_1 |
crossvul-cpp_data_bad_963_0 | /****************************************************************************
** libebml : parse EBML files, see http://embl.sourceforge.net/
**
** <file/class description>
**
** Copyright (C) 2002-2010 Steve Lhomme. All rights reserved.
**
** This library is free software; you can redistribute it and/or
** modify it ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_963_0 |
crossvul-cpp_data_good_2486_1 | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//---------------------------------------------------------... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_2486_1 |
crossvul-cpp_data_bad_2324_0 | /*
Copyright (c) 2008-2012, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and ... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_2324_0 |
crossvul-cpp_data_good_1382_1 | /*
* Copyright (c) 2018-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <fizz/record/Plaint... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_1382_1 |
crossvul-cpp_data_bad_851_0 | /*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com) |
| Copyrigh... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_851_0 |
crossvul-cpp_data_good_2945_1 | /*
Copyright 2008-2017 LibRaw LLC (info@libraw.org)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:
1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
(See file LICENSE.LGPL provided in LibRaw distribution archive for details).
2. COMMON... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_2945_1 |
crossvul-cpp_data_good_5643_0 | /* -*- C++ -*-
* File: libraw_cxx.cpp
* Copyright 2008-2013 LibRaw LLC (info@libraw.org)
* Created: Sat Mar 8 , 2008
*
* LibRaw C++ interface (implementation)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of three licenses as you choose:
1. GNU LESSER GENERAL PUBLI... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_5643_0 |
crossvul-cpp_data_bad_2972_0 | /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, instal... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_2972_0 |
crossvul-cpp_data_bad_1388_1 | /*-
* Copyright 2009 Colin Percival
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditio... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_1388_1 |
crossvul-cpp_data_good_2486_0 | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//---------------------------------------------------------... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_2486_0 |
crossvul-cpp_data_good_851_0 | /*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com) |
| Copyrigh... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_851_0 |
crossvul-cpp_data_bad_1382_0 | /*
* Copyright (c) 2018-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <fizz/record/PlaintextRecordLayer.h>
#include <folly/String.h>
namespace fizz {
using Conte... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_1382_0 |
crossvul-cpp_data_good_1382_0 | /*
* Copyright (c) 2018-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <fizz/record/PlaintextRecordLayer.h>
#include <folly/String.h>
namespace fizz {
using Conte... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_1382_0 |
crossvul-cpp_data_good_594_1 | /*
* Copyright 2012-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or a... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/good_594_1 |
crossvul-cpp_data_bad_3225_1 | /*
Copyright 2008-2016 LibRaw LLC (info@libraw.org)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:
1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
(See file LICENSE.LGPL provided in LibRaw distribution archive for details).
2. COMMON... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_3225_1 |
crossvul-cpp_data_bad_5643_0 | /* -*- C++ -*-
* File: libraw_cxx.cpp
* Copyright 2008-2013 LibRaw LLC (info@libraw.org)
* Created: Sat Mar 8 , 2008
*
* LibRaw C++ interface (implementation)
LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of three licenses as you choose:
1. GNU LESSER GENERAL PUBLI... | ./CrossVul/dataset_final_sorted/CWE-119/cpp/bad_5643_0 |
crossvul-cpp_data_bad_2333_0 | /*
* TTUSB DEC Frontend Driver
*
* Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_2333_0 |
crossvul-cpp_data_bad_3407_0 | /* radare - LGPL - Copyright 2009-2017 // pancake */
static int cmd_mkdir(void *data, const char *input) {
char *res = r_syscmd_mkdir (input);
if (res) {
r_cons_print (res);
free (res);
}
return 0;
}
static int cmd_mv(void *data, const char *input) {
return r_syscmd_mv (input)? 1: 0;
}
static int cmd_mount(... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_3407_0 |
crossvul-cpp_data_good_344_8 | /*
* cryptoflex-tool.c: Tool for doing various Cryptoflex related stuff
*
* Copyright (C) 2001 Juha Yrjölä <juha.yrjola@iki.fi>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; e... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_344_8 |
crossvul-cpp_data_bad_5127_2 | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% W W PPPP GGGG ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_5127_2 |
crossvul-cpp_data_bad_341_1 | /*
* Support for ePass2003 smart cards
*
* Copyright (C) 2008, Weitao Sun <weitao@ftsafe.com>
* Copyright (C) 2011, Xiaoshuo Wu <xiaoshuo@ftsafe.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_341_1 |
crossvul-cpp_data_bad_4906_0 | /**
* eCryptfs: Linux filesystem encryption layer
*
* Copyright (C) 1997-2004 Erez Zadok
* Copyright (C) 2001-2004 Stony Brook University
* Copyright (C) 2004-2007 International Business Machines Corp.
* Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
* Michael C. Thompson <mcthomps@us.ibm.com>
*
* T... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_4906_0 |
crossvul-cpp_data_good_5359_0 | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_5359_0 |
crossvul-cpp_data_bad_234_0 | /* radare - LGPL - Copyright 2012-2017 - pancake, Fedor Sakharov */
#define D0 if(1)
#define D1 if(1)
#include <errno.h>
#define DWARF_DUMP 0
#if DWARF_DUMP
#define DBGFD stdout
#else
#define DBGFD NULL
#endif
#include <r_bin.h>
#include <r_bin_dwarf.h>
#include <r_core.h>
#define STANDARD_OPERAND_COUNT_DWARF2 9
... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_234_0 |
crossvul-cpp_data_bad_5280_0 | /*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
| Copyright (c) 1998-2016 Zend Technologies Ltd. (http://www.zend.com) |
+---------... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_5280_0 |
crossvul-cpp_data_bad_3314_0 | /*
* CCM: Counter with CBC-MAC
*
* (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_3314_0 |
crossvul-cpp_data_good_4950_0 | /* $Id$
*
* Copyright (C) 2006-2007 VozTelecom Sistemas S.L
*
* This file is part of Kamailio, a free SIP server.
*
* Kamailio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the Li... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_4950_0 |
crossvul-cpp_data_bad_3259_0 | /***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_3259_0 |
crossvul-cpp_data_good_340_4 | /*
* PKCS15 emulation layer for EstEID card.
*
* Copyright (C) 2004, Martin Paljak <martin@martinpaljak.net>
* Copyright (C) 2004, Bud P. Bruegger <bud@comune.grosseto.it>
* Copyright (C) 2004, Antonino Iacono <ant_iacono@tin.it>
* Copyright (C) 2003, Olaf Kirch <okir@suse.de>
*
* This library is free software;... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_340_4 |
crossvul-cpp_data_bad_3310_0 | /* dvb-usb-firmware.c is part of the DVB USB library.
*
* Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@posteo.de)
* see dvb-usb-init.c for copyright information.
*
* This file contains functions for downloading the firmware to Cypress FX 1 and 2 based devices.
*
* FIXME: This part does actually not ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_3310_0 |
crossvul-cpp_data_bad_4787_22 | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_4787_22 |
crossvul-cpp_data_good_4806_0 | /*
* Copyright (C) the libgit2 contributors. All rights reserved.
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#include "common.h"
#include "git2/types.h"
#include "git2/errors.h"
#include "git2/refs.h"
#include "g... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_4806_0 |
crossvul-cpp_data_bad_4787_16 | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_4787_16 |
crossvul-cpp_data_bad_1709_0 | /* $Id: igd_desc_parse.c,v 1.16 2014/11/17 17:19:13 nanard Exp $ */
/* Project : miniupnp
* http://miniupnp.free.fr/
* Author : Thomas Bernard
* Copyright (c) 2005-2014 Thomas Bernard
* This software is subject to the conditions detailed in the
* LICENCE file provided in this distribution. */
#include "igd_desc_p... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_1709_0 |
crossvul-cpp_data_bad_118_0 | /*
* PowerPC version
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
*
* Derived from "arch/m68k/kernel/ptrace.c"
* Copyright (C) 1994 by Hamish Macdonald
* Taken from linux/kernel/ptrace.c and modified for M680x0.
* linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
*
* M... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_118_0 |
crossvul-cpp_data_bad_5028_0 | /*
* The Python Imaging Library
* $Id$
*
* Pillow image resampling support
*
* history:
* 2002-03-09 fl Created (for PIL 1.1.3)
* 2002-03-10 fl Added support for mode "F"
*
* Copyright (c) 1997-2002 by Secret Labs AB
*
* See the README file for information on usage and redistribution.
*/
#include "Imagi... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_5028_0 |
crossvul-cpp_data_good_3315_0 | /* CAN driver for Geschwister Schneider USB/CAN devices
* and bytewerk.org candleLight USB CAN interfaces.
*
* Copyright (C) 2013-2016 Geschwister Schneider Technologie-,
* Entwicklungs- und Vertriebs UG (Haftungsbeschränkt).
* Copyright (C) 2016 Hubert Denkmair
*
* Many thanks to all socketcan devs!
*
* This ... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_3315_0 |
crossvul-cpp_data_good_4999_2 | /*
* Packet matching code.
*
* Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
* Copyright (C) 2000-2005 Netfilter Core Team <coreteam@netfilter.org>
* Copyright (c) 2006-2010 Patrick McHardy <kaber@trash.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the t... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_4999_2 |
crossvul-cpp_data_bad_2133_0 | /***************************************************************************
* Copyright (C) 2010-2012 by Bruno Prémont <bonbons@linux-vserver.org> *
* *
* Based on Logitech G13 driver (v0.4) *
* Copyr... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_2133_0 |
crossvul-cpp_data_good_343_7 | /*
* sc.c: General functions
*
* Copyright (C) 2001, 2002 Juha Yrjölä <juha.yrjola@iki.fi>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, ... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_343_7 |
crossvul-cpp_data_good_2019_4 | /* src/interfaces/ecpg/pgtypeslib/interval.c */
#include "postgres_fe.h"
#include <time.h>
#include <math.h>
#include <limits.h>
#ifdef __FAST_MATH__
#error -ffast-math is known to break this code
#endif
#include "extern.h"
#include "dt.h"
#include "pgtypes_error.h"
#include "pgtypes_interval.h"
/* copy&pasted from... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_2019_4 |
crossvul-cpp_data_good_4409_0 | // SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
* Copyright (c) 2016 Facebook
* Copyright (c) 2018 Covalent IO, Inc. http://covalent.io
*/
#include <uapi/linux/btf.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/bpf.h>
#i... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_4409_0 |
crossvul-cpp_data_good_3187_1 | /*
* Glue code for libmspack handling.
* Author: 웃 Sebastian Andrzej Siewior
* ✉ sebastian @ breakpoint ̣cc
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <mspack.h>
#include "clamav.h"
#include "fmap.h"
#include "scanners.h"
#include "others.h"
enum mspack_type {
F... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_3187_1 |
crossvul-cpp_data_bad_2686_3 | /*
* Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that: (1) source code distributions
* retain the above copyright notice and... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_2686_3 |
crossvul-cpp_data_good_4359_0 | /* pb_decode.c -- decode a protobuf using minimal resources
*
* 2011 Petteri Aimonen <jpa@kapsi.fi>
*/
/* Use the GCC warn_unused_result attribute to check that all return values
* are propagated correctly. On other compilers and gcc before 3.4.0 just
* ignore the annotation.
*/
#if !defined(__GNUC__) || ( __GNU... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_4359_0 |
crossvul-cpp_data_good_345_5 | /*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it wi... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_345_5 |
crossvul-cpp_data_bad_3173_0 | /* radare - LGPL - Copyright 2011-2016 - pancake */
#include <r_cons.h>
#include <r_types.h>
#include <r_util.h>
#include <r_lib.h>
#include <r_bin.h>
#include "dex/dex.h"
#define r_hash_adler32 __adler32
#include "../../hash/adler32.c"
extern struct r_bin_dbginfo_t r_bin_dbginfo_dex;
#define DEBUG_PRINTF 0
#if DEB... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_3173_0 |
crossvul-cpp_data_good_3191_0 | /*
* bplist.c
* Binary plist implementation
*
* Copyright (c) 2011-2017 Nikias Bassen, All Rights Reserved.
* Copyright (c) 2008-2010 Jonathan Beck, All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as p... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_3191_0 |
crossvul-cpp_data_bad_3111_1 | /**********************************************************************
* $Id$
*
* Project: MapServer
* Purpose: OGC Filter Encoding implementation
* Author: Y. Assefa, DM Solutions Group (assefa@dmsolutions.ca)
*
**********************************************************************
* Copyright (c) 2003, Y... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_3111_1 |
crossvul-cpp_data_bad_343_4 | /*
* PKCS15 emulation layer for EstEID card.
*
* Copyright (C) 2004, Martin Paljak <martin@martinpaljak.net>
* Copyright (C) 2004, Bud P. Bruegger <bud@comune.grosseto.it>
* Copyright (C) 2004, Antonino Iacono <ant_iacono@tin.it>
* Copyright (C) 2003, Olaf Kirch <okir@suse.de>
*
* This library is free software;... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_343_4 |
crossvul-cpp_data_bad_2919_0 | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% W W PPPP GGGG ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_2919_0 |
crossvul-cpp_data_bad_2132_0 | /*
* USB ConnectTech WhiteHEAT driver
*
* Copyright (C) 2002
* Connect Tech Inc.
*
* Copyright (C) 1999 - 2001
* Greg Kroah-Hartman (greg@kroah.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Fr... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_2132_0 |
crossvul-cpp_data_good_900_0 | /*
Ming, an SWF output library
Copyright (C) 2002 Opaque Industries - http://www.opaque.net/
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the ... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_900_0 |
crossvul-cpp_data_good_2333_0 | /*
* TTUSB DEC Frontend Driver
*
* Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at ... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_2333_0 |
crossvul-cpp_data_good_5661_0 | /*
* net/key/af_key.c An implementation of PF_KEYv2 sockets.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_5661_0 |
crossvul-cpp_data_good_2038_1 | /*-
* Copyright (c) 2008 Christos Zoulas
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of con... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_2038_1 |
crossvul-cpp_data_bad_732_0 | // SPDX-License-Identifier: BSD-2-Clause
/*
* Copyright (c) 2014, STMicroelectronics International N.V.
*/
#include <assert.h>
#include <compiler.h>
#include <crypto/crypto.h>
#include <kernel/tee_ta_manager.h>
#include <mm/tee_mmu.h>
#include <string_ext.h>
#include <string.h>
#include <sys/queue.h>
#include <tee_a... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_732_0 |
crossvul-cpp_data_bad_5635_0 | /*
* host.c - ChipIdea USB host controller driver
*
* Copyright (c) 2012 Intel Corporation
*
* Author: Alexander Shishkin
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_5635_0 |
crossvul-cpp_data_bad_2018_0 | /*
* Kernel-based Virtual Machine driver for Linux
*
* derived from drivers/kvm/kvm_main.c
*
* Copyright (C) 2006 Qumranet, Inc.
* Copyright (C) 2008 Qumranet, Inc.
* Copyright IBM Corporation, 2008
* Copyright 2010 Red Hat, Inc. and/or its affiliates.
*
* Authors:
* Avi Kivity <avi@qumranet.com>
* Ya... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_2018_0 |
crossvul-cpp_data_bad_107_0 | #ifndef NGIFLIB_NO_FILE
#include <stdio.h>
#endif /* NGIFLIB_NO_FILE */
#include "ngiflib.h"
/* decodeur GIF en C portable (pas de pb big/little endian)
* Thomas BERNARD. janvier 2004.
* (c) 2004-2017 Thomas Bernard. All rights reserved
*/
/* Fonction de debug */
#ifdef DEBUG
void fprintf_ngiflib_img(FILE * f, st... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_107_0 |
crossvul-cpp_data_bad_3110_0 | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_3110_0 |
crossvul-cpp_data_good_4905_0 | /**
* eCryptfs: Linux filesystem encryption layer
*
* Copyright (C) 2008 International Business Machines Corp.
* Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_4905_0 |
crossvul-cpp_data_bad_1848_0 | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... | ./CrossVul/dataset_final_sorted/CWE-119/c/bad_1848_0 |
crossvul-cpp_data_good_412_2 | /* regcomp.c
*/
/*
* 'A fair jaw-cracker dwarf-language must be.' --Samwise Gamgee
*
* [p.285 of _The Lord of the Rings_, II/iii: "The Ring Goes South"]
*/
/* This file contains functions for compiling a regular expression. See
* also regexec.c which funnily enough, contains functions for exe... | ./CrossVul/dataset_final_sorted/CWE-119/c/good_412_2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.