Lines Matching defs:scan
2252 register regnode *scan; /* Current node. */
2280 scan = prog;
2281 while (scan != NULL) {
2310 regprop(prop, scan);
2313 do_utf8 && OP(scan) != CANY ?
2318 char *s1 = do_utf8 && OP(scan) != CANY ?
2323 char *s2 = do_utf8 && OP(scan) != CANY ?
2343 (IV)(scan - PL_regprogram), PL_regindent*2, "",
2348 next = scan + NEXT_OFF(scan);
2349 if (next == scan)
2352 switch (OP(scan)) {
2427 s = STRING(scan);
2428 ln = STR_LEN(scan);
2482 s = STRING(scan);
2483 ln = STR_LEN(scan);
2514 UCHARAT(s) != ((OP(scan) == EXACTF)
2519 if (ln > 1 && (OP(scan) == EXACTF
2530 if (!reginclass(scan, (U8*)locinput, &inclasslen, do_utf8))
2541 if (!REGINCLASS(scan, (U8*)locinput))
2552 if (ANYOF_FOLD_SHARP_S(scan, locinput, PL_regeol)) {
2567 if (!(OP(scan) == ALNUM
2577 if (!(OP(scan) == ALNUM
2590 if (OP(scan) == NALNUM
2600 if (OP(scan) == NALNUM
2620 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
2633 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
2642 if (((!ln) == (!n)) == (OP(scan) == BOUND ||
2643 OP(scan) == BOUNDL))
2655 if (!(OP(scan) == SPACE
2665 if (!(OP(scan) == SPACE
2671 if (!(OP(scan) == SPACE
2685 if (OP(scan) == NSPACE
2695 if (OP(scan) == NSPACE
2708 if (!(OP(scan) == DIGIT
2718 if (!(OP(scan) == DIGIT
2731 if (OP(scan) == NDIGIT
2741 if (OP(scan) == NDIGIT
2769 n = ARG(scan); /* which paren pair */
2778 if (do_utf8 && OP(scan) != REF) { /* REF can do byte comparison */
2786 if (OP(scan) == REFF) {
2808 (OP(scan) == REF ||
2809 (UCHARAT(s) != ((OP(scan) == REFF
2815 if (ln > 1 && (OP(scan) == REF
2817 : (OP(scan) == REFF
2839 n = ARG(scan);
2977 n = ARG(scan); /* which paren pair */
2983 n = ARG(scan); /* which paren pair */
2991 n = ARG(scan); /* which paren pair */
2997 next = NEXTOPER(NEXTOPER(scan));
2999 next = scan + ARG(scan);
3005 logical = scan->flags;
3086 I32 parenfloor = scan->flags;
3098 cc.min = ARG1(scan);
3099 cc.max = ARG2(scan);
3100 cc.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
3136 /* If degenerate scan matches "", assume scan done. */
3160 if (regmatch(cc->scan))
3167 if (scan->flags) {
3172 PL_reg_maxiter = (PL_regeol - PL_bostr + 1) * (scan->flags>>4);
3197 o = (scan->flags & 0xf) - 1 + o * (scan->flags>>4);
3215 /* Prefer next over scan for minimal matching. */
3255 if (regmatch(cc->scan)) {
3266 /* Prefer scan over next for maximal matching. */
3273 if (regmatch(cc->scan)) {
3294 /* Failed deeper matches of scan, so see if this one works. */
3309 next = scan + ARG(scan);
3310 if (next == scan)
3312 inner = NEXTOPER(NEXTOPER(scan));
3315 inner = NEXTOPER(scan);
3318 c1 = OP(scan);
3360 ln = ARG1(scan); /* min to match */
3361 n = ARG2(scan); /* max to match */
3362 paren = scan->flags;
3369 scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
3371 scan += NEXT_OFF(scan); /* Skip former OPEN. */
3375 if (ln && regrepeat_hard(scan, ln, &l) < ln)
3433 if (regrepeat_hard(scan, 1, &l)) {
3442 n = regrepeat_hard(scan, n, &l);
3517 paren = scan->flags; /* Which paren to set */
3522 ln = ARG1(scan); /* min to match */
3523 n = ARG2(scan); /* max to match */
3524 scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
3528 ln = ARG1(scan); /* min to match */
3529 n = ARG2(scan); /* max to match */
3530 scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
3535 scan = NEXTOPER(scan);
3541 scan = NEXTOPER(scan);
3607 if (ln && regrepeat(scan, ln) < ln)
3681 if (regrepeat(scan, count) < count)
3723 if (regrepeat(scan, 1)) {
3733 n = regrepeat(scan, n);
3851 if (scan->flags) {
3852 s = HOPBACKc(locinput, scan->flags);
3863 if (scan->flags) {
3864 s = HOPBACKc(locinput, scan->flags);
3873 inner = NEXTOPER(NEXTOPER(scan));
3893 if (OP(scan) == SUSPEND) {
3900 next = scan + ARG(scan);
3901 if (next == scan)
3906 PTR2UV(scan), OP(scan));
3910 scan = next;
3965 scan = next = uwb->next;
3966 if ( !scan ||
3967 OP(scan) != (uwb->type == RE_UNWIND_BRANCH
3983 next = NEXTOPER(scan);
4011 * That was true before, but now we assume scan - reginput is the count,
4017 register char *scan;
4023 scan = PL_reginput;
4026 else if (max < loceol - scan)
4027 loceol = scan + max;
4032 while (scan < loceol && hardcount < max && *scan != '\n') {
4033 scan += UTF8SKIP(scan);
4037 while (scan < loceol && *scan != '\n')
4038 scan++;
4044 while (scan < loceol && hardcount < max) {
4045 scan += UTF8SKIP(scan);
4050 scan = loceol;
4053 scan = loceol;
4057 while (scan < loceol && UCHARAT(scan) == c)
4058 scan++;
4062 while (scan < loceol &&
4063 (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold[c]))
4064 scan++;
4069 while (scan < loceol &&
4070 (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold_locale[c]))
4071 scan++;
4076 while (hardcount < max && scan < loceol &&
4077 reginclass(p, (U8*)scan, 0, do_utf8)) {
4078 scan += UTF8SKIP(scan);
4082 while (scan < loceol && REGINCLASS(p, (U8*)scan))
4083 scan++;
4090 while (hardcount < max && scan < loceol &&
4091 swash_fetch(PL_utf8_alnum, (U8*)scan, do_utf8)) {
4092 scan += UTF8SKIP(scan);
4096 while (scan < loceol && isALNUM(*scan))
4097 scan++;
4104 while (hardcount < max && scan < loceol &&
4105 isALNUM_LC_utf8((U8*)scan)) {
4106 scan += UTF8SKIP(scan);
4110 while (scan < loceol && isALNUM_LC(*scan))
4111 scan++;
4118 while (hardcount < max && scan < loceol &&
4119 !swash_fetch(PL_utf8_alnum, (U8*)scan, do_utf8)) {
4120 scan += UTF8SKIP(scan);
4124 while (scan < loceol && !isALNUM(*scan))
4125 scan++;
4132 while (hardcount < max && scan < loceol &&
4133 !isALNUM_LC_utf8((U8*)scan)) {
4134 scan += UTF8SKIP(scan);
4138 while (scan < loceol && !isALNUM_LC(*scan))
4139 scan++;
4146 while (hardcount < max && scan < loceol &&
4147 (*scan == ' ' ||
4148 swash_fetch(PL_utf8_space,(U8*)scan, do_utf8))) {
4149 scan += UTF8SKIP(scan);
4153 while (scan < loceol && isSPACE(*scan))
4154 scan++;
4161 while (hardcount < max && scan < loceol &&
4162 (*scan == ' ' || isSPACE_LC_utf8((U8*)scan))) {
4163 scan += UTF8SKIP(scan);
4167 while (scan < loceol && isSPACE_LC(*scan))
4168 scan++;
4175 while (hardcount < max && scan < loceol &&
4176 !(*scan == ' ' ||
4177 swash_fetch(PL_utf8_space,(U8*)scan, do_utf8))) {
4178 scan += UTF8SKIP(scan);
4182 while (scan < loceol && !isSPACE(*scan))
4183 scan++;
4190 while (hardcount < max && scan < loceol &&
4191 !(*scan == ' ' || isSPACE_LC_utf8((U8*)scan))) {
4192 scan += UTF8SKIP(scan);
4196 while (scan < loceol && !isSPACE_LC(*scan))
4197 scan++;
4204 while (hardcount < max && scan < loceol &&
4205 swash_fetch(PL_utf8_digit, (U8*)scan, do_utf8)) {
4206 scan += UTF8SKIP(scan);
4210 while (scan < loceol && isDIGIT(*scan))
4211 scan++;
4218 while (hardcount < max && scan < loceol &&
4219 !swash_fetch(PL_utf8_digit, (U8*)scan, do_utf8)) {
4220 scan += UTF8SKIP(scan);
4224 while (scan < loceol && !isDIGIT(*scan))
4225 scan++;
4235 c = scan - PL_reginput;
4236 PL_reginput = scan;
4260 register char *scan = Nullch;
4271 while (PL_reginput < loceol && (scan = PL_reginput, res = regmatch(p))) {
4287 while (PL_reginput < loceol && (scan = PL_reginput, res = regmatch(p))) {
4290 if (max != REG_INFTY && l*max < loceol - scan)
4291 loceol = scan + l*max;
4298 PL_reginput = scan;