This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perl 4.0 patch 16: patch #11, continued
[perl5.git] / regexec.c
CommitLineData
a687059c
LW
1/* NOTE: this is derived from Henry Spencer's regexp code, and should not
2 * confused with the original package (see point 3 below). Thanks, Henry!
3 */
4
5/* Additional note: this code is very heavily munged from Henry's version
6 * in places. In some spots I've traded clarity for efficiency, so don't
7 * blame Henry for some of the lack of readability.
8 */
9
f0fcb552 10/* $RCSfile: regexec.c,v $$Revision: 4.0.1.3 $$Date: 91/11/05 18:23:55 $
a687059c
LW
11 *
12 * $Log: regexec.c,v $
f0fcb552
LW
13 * Revision 4.0.1.3 91/11/05 18:23:55 lwall
14 * patch11: prepared for ctype implementations that don't define isascii()
15 * patch11: initial .* in pattern had dependency on value of $*
16 *
9ef589d8
LW
17 * Revision 4.0.1.2 91/06/07 11:50:33 lwall
18 * patch4: new copyright notice
19 * patch4: // wouldn't use previous pattern if it started with a null character
20 *
35c8bce7
LW
21 * Revision 4.0.1.1 91/04/12 09:07:39 lwall
22 * patch1: regexec only allocated space for 9 subexpresssions
23 *
fe14fcc3
LW
24 * Revision 4.0 91/03/20 01:39:16 lwall
25 * 4.0 baseline.
a687059c
LW
26 *
27 */
f0fcb552 28/*SUPPRESS 112*/
a687059c
LW
29/*
30 * regcomp and regexec -- regsub and regerror are not used in perl
31 *
32 * Copyright (c) 1986 by University of Toronto.
33 * Written by Henry Spencer. Not derived from licensed software.
34 *
35 * Permission is granted to anyone to use this software for any
36 * purpose on any computer system, and to redistribute it freely,
37 * subject to the following restrictions:
38 *
39 * 1. The author is not responsible for the consequences of use of
40 * this software, no matter how awful, even if they arise
41 * from defects in it.
42 *
43 * 2. The origin of this software must not be misrepresented, either
44 * by explicit claim or by omission.
45 *
46 * 3. Altered versions must be plainly marked as such, and must not
47 * be misrepresented as being the original software.
48 *
49 **** Alterations to Henry's code are...
50 ****
9ef589d8 51 **** Copyright (c) 1991, Larry Wall
a687059c 52 ****
9ef589d8
LW
53 **** You may distribute under the terms of either the GNU General Public
54 **** License or the Artistic License, as specified in the README file.
a687059c
LW
55 *
56 * Beware that some of this code is subtly aware of the way operator
57 * precedence is structured in regular expressions. Serious changes in
58 * regular-expression syntax might require a total rethink.
59 */
60#include "EXTERN.h"
61#include "perl.h"
62#include "regcomp.h"
63
64#ifndef STATIC
65#define STATIC static
66#endif
67
68#ifdef DEBUGGING
69int regnarrate = 0;
70#endif
71
72/*
73 * regexec and friends
74 */
75
76/*
77 * Global work variables for regexec().
78 */
79static char *regprecomp;
80static char *reginput; /* String-input pointer. */
ac58e20f 81static char regprev; /* char before regbol, \n if none */
a687059c
LW
82static char *regbol; /* Beginning of input, for ^ check. */
83static char *regeol; /* End of input, for $ check. */
84static char **regstartp; /* Pointer to startp array. */
85static char **regendp; /* Ditto for endp. */
86static char *reglastparen; /* Similarly for lastparen. */
87static char *regtill;
88
35c8bce7
LW
89static int regmyp_size = 0;
90static char **regmystartp = Null(char**);
91static char **regmyendp = Null(char**);
a687059c
LW
92
93/*
94 * Forwards.
95 */
96STATIC int regtry();
97STATIC int regmatch();
98STATIC int regrepeat();
99
100extern int multiline;
101
102/*
103 - regexec - match a regexp against a string
104 */
105int
106regexec(prog, stringarg, strend, strbeg, minend, screamer, safebase)
107register regexp *prog;
108char *stringarg;
109register char *strend; /* pointer to null at end of string */
110char *strbeg; /* real beginning of string */
111int minend; /* end of match must be at least minend after stringarg */
112STR *screamer;
113int safebase; /* no need to remember string in subbase */
114{
115 register char *s;
116 register int i;
117 register char *c;
118 register char *string = stringarg;
119 register int tmp;
120 int minlen = 0; /* must match at least this many chars */
121 int dontbother = 0; /* how many characters not to try at end */
a687059c
LW
122
123 /* Be paranoid... */
124 if (prog == NULL || string == NULL) {
125 fatal("NULL regexp parameter");
126 return(0);
127 }
128
ac58e20f
LW
129 if (string == strbeg) /* is ^ valid at stringarg? */
130 regprev = '\n';
0a12ae7d 131 else {
ac58e20f 132 regprev = stringarg[-1];
0a12ae7d
LW
133 if (!multiline && regprev == '\n')
134 regprev = '\0'; /* force ^ to NOT match */
135 }
a687059c
LW
136 regprecomp = prog->precomp;
137 /* Check validity of program. */
138 if (UCHARAT(prog->program) != MAGIC) {
139 FAIL("corrupted regexp program");
140 }
141
142 if (prog->do_folding) {
143 safebase = FALSE;
144 i = strend - string;
145 New(1101,c,i+1,char);
146 (void)bcopy(string, c, i+1);
147 string = c;
148 strend = string + i;
149 for (s = string; s < strend; s++)
ac58e20f 150 if (isUPPER(*s))
a687059c
LW
151 *s = tolower(*s);
152 }
153
154 /* If there is a "must appear" string, look for it. */
155 s = string;
34de22dd 156 if (prog->regmust != Nullstr &&
9ef589d8
LW
157 (!(prog->reganch & ROPT_ANCH)
158 || (multiline && prog->regback >= 0)) ) {
ac58e20f 159 if (stringarg == strbeg && screamer) {
a687059c
LW
160 if (screamfirst[prog->regmust->str_rare] >= 0)
161 s = screaminstr(screamer,prog->regmust);
162 else
163 s = Nullch;
164 }
165#ifndef lint
166 else
167 s = fbminstr((unsigned char*)s, (unsigned char*)strend,
168 prog->regmust);
169#endif
170 if (!s) {
171 ++prog->regmust->str_u.str_useful; /* hooray */
172 goto phooey; /* not present */
173 }
174 else if (prog->regback >= 0) {
175 s -= prog->regback;
176 if (s < string)
177 s = string;
178 minlen = prog->regback + prog->regmust->str_cur;
179 }
180 else if (--prog->regmust->str_u.str_useful < 0) { /* boo */
181 str_free(prog->regmust);
182 prog->regmust = Nullstr; /* disable regmust */
183 s = string;
184 }
185 else {
186 s = string;
187 minlen = prog->regmust->str_cur;
188 }
189 }
190
191 /* Mark beginning of line for ^ . */
ac58e20f 192 regbol = string;
a687059c
LW
193
194 /* Mark end of line for $ (and such) */
195 regeol = strend;
196
197 /* see how far we have to get to not match where we matched before */
198 regtill = string+minend;
199
35c8bce7
LW
200 /* Allocate our backreference arrays */
201 if ( regmyp_size < prog->nparens + 1 ) {
202 /* Allocate or enlarge the arrays */
203 regmyp_size = prog->nparens + 1;
204 if ( regmyp_size < 10 ) regmyp_size = 10; /* minimum */
205 if ( regmystartp ) {
206 /* reallocate larger */
207 Renew(regmystartp,regmyp_size,char*);
208 Renew(regmyendp, regmyp_size,char*);
209 }
210 else {
211 /* Initial allocation */
212 New(1102,regmystartp,regmyp_size,char*);
213 New(1102,regmyendp, regmyp_size,char*);
214 }
215
216 }
217
a687059c
LW
218 /* Simplest case: anchored match need be tried only once. */
219 /* [unless multiline is set] */
9ef589d8 220 if (prog->reganch & ROPT_ANCH) {
a687059c
LW
221 if (regtry(prog, string))
222 goto got_it;
f0fcb552 223 else if (multiline || (prog->reganch & ROPT_IMPLICIT)) {
a687059c
LW
224 if (minlen)
225 dontbother = minlen - 1;
226 strend -= dontbother;
227 /* for multiline we only have to try after newlines */
228 if (s > string)
229 s--;
00bf170e
LW
230 while (s < strend) {
231 if (*s++ == '\n') {
232 if (s < strend && regtry(prog, s))
a687059c
LW
233 goto got_it;
234 }
235 }
236 }
237 goto phooey;
238 }
239
240 /* Messy cases: unanchored match. */
241 if (prog->regstart) {
9ef589d8 242 if (prog->reganch & ROPT_SKIP) { /* we have /x+whatever/ */
00bf170e
LW
243 /* it must be a one character string */
244 i = prog->regstart->str_ptr[0];
245 while (s < strend) {
246 if (*s == i) {
247 if (regtry(prog, s))
248 goto got_it;
249 s++;
250 while (s < strend && *s == i)
251 s++;
252 }
253 s++;
254 }
255 }
256 else if (prog->regstart->str_pok == 3) {
257 /* We know what string it must start with. */
a687059c
LW
258#ifndef lint
259 while ((s = fbminstr((unsigned char*)s,
260 (unsigned char*)strend, prog->regstart)) != NULL)
261#else
262 while (s = Nullch)
263#endif
264 {
265 if (regtry(prog, s))
266 goto got_it;
267 s++;
268 }
269 }
270 else {
271 c = prog->regstart->str_ptr;
272 while ((s = ninstr(s, strend,
273 c, c + prog->regstart->str_cur )) != NULL) {
274 if (regtry(prog, s))
275 goto got_it;
276 s++;
277 }
278 }
279 goto phooey;
280 }
f0fcb552 281 /*SUPPRESS 560*/
a687059c 282 if (c = prog->regstclass) {
9ef589d8 283 int doevery = (prog->reganch & ROPT_SKIP) == 0;
00bf170e 284
a687059c
LW
285 if (minlen)
286 dontbother = minlen - 1;
287 strend -= dontbother; /* don't bother with what can't match */
00bf170e 288 tmp = 1;
a687059c
LW
289 /* We know what class it must start with. */
290 switch (OP(c)) {
00bf170e 291 case ANYOF:
a687059c
LW
292 c = OPERAND(c);
293 while (s < strend) {
ac58e20f 294 i = UCHARAT(s);
00bf170e
LW
295 if (!(c[i >> 3] & (1 << (i&7)))) {
296 if (tmp && regtry(prog, s))
a687059c 297 goto got_it;
00bf170e
LW
298 else
299 tmp = doevery;
300 }
301 else
302 tmp = 1;
a687059c
LW
303 s++;
304 }
305 break;
306 case BOUND:
307 if (minlen)
308 dontbother++,strend--;
309 if (s != string) {
310 i = s[-1];
ac58e20f 311 tmp = isALNUM(i);
a687059c
LW
312 }
313 else
ac58e20f 314 tmp = isALNUM(regprev); /* assume not alphanumeric */
a687059c
LW
315 while (s < strend) {
316 i = *s;
ac58e20f 317 if (tmp != isALNUM(i)) {
a687059c
LW
318 tmp = !tmp;
319 if (regtry(prog, s))
320 goto got_it;
321 }
322 s++;
323 }
ae986130 324 if ((minlen || tmp) && regtry(prog,s))
a687059c
LW
325 goto got_it;
326 break;
327 case NBOUND:
328 if (minlen)
329 dontbother++,strend--;
330 if (s != string) {
331 i = s[-1];
ac58e20f 332 tmp = isALNUM(i);
a687059c
LW
333 }
334 else
ac58e20f 335 tmp = isALNUM(regprev); /* assume not alphanumeric */
a687059c
LW
336 while (s < strend) {
337 i = *s;
ac58e20f 338 if (tmp != isALNUM(i))
a687059c
LW
339 tmp = !tmp;
340 else if (regtry(prog, s))
341 goto got_it;
342 s++;
343 }
ae986130 344 if ((minlen || !tmp) && regtry(prog,s))
a687059c
LW
345 goto got_it;
346 break;
347 case ALNUM:
348 while (s < strend) {
349 i = *s;
00bf170e
LW
350 if (isALNUM(i)) {
351 if (tmp && regtry(prog, s))
a687059c 352 goto got_it;
00bf170e
LW
353 else
354 tmp = doevery;
355 }
356 else
357 tmp = 1;
a687059c
LW
358 s++;
359 }
360 break;
361 case NALNUM:
362 while (s < strend) {
363 i = *s;
00bf170e
LW
364 if (!isALNUM(i)) {
365 if (tmp && regtry(prog, s))
a687059c 366 goto got_it;
00bf170e
LW
367 else
368 tmp = doevery;
369 }
370 else
371 tmp = 1;
a687059c
LW
372 s++;
373 }
374 break;
375 case SPACE:
376 while (s < strend) {
00bf170e
LW
377 if (isSPACE(*s)) {
378 if (tmp && regtry(prog, s))
a687059c 379 goto got_it;
00bf170e
LW
380 else
381 tmp = doevery;
382 }
383 else
384 tmp = 1;
a687059c
LW
385 s++;
386 }
387 break;
388 case NSPACE:
389 while (s < strend) {
00bf170e
LW
390 if (!isSPACE(*s)) {
391 if (tmp && regtry(prog, s))
a687059c 392 goto got_it;
00bf170e
LW
393 else
394 tmp = doevery;
395 }
396 else
397 tmp = 1;
a687059c
LW
398 s++;
399 }
400 break;
401 case DIGIT:
402 while (s < strend) {
00bf170e
LW
403 if (isDIGIT(*s)) {
404 if (tmp && regtry(prog, s))
a687059c 405 goto got_it;
00bf170e
LW
406 else
407 tmp = doevery;
408 }
409 else
410 tmp = 1;
a687059c
LW
411 s++;
412 }
413 break;
414 case NDIGIT:
415 while (s < strend) {
00bf170e
LW
416 if (!isDIGIT(*s)) {
417 if (tmp && regtry(prog, s))
a687059c 418 goto got_it;
00bf170e
LW
419 else
420 tmp = doevery;
421 }
422 else
423 tmp = 1;
a687059c
LW
424 s++;
425 }
426 break;
427 }
428 }
429 else {
663a0e37
LW
430 if (minlen)
431 dontbother = minlen - 1;
a687059c
LW
432 strend -= dontbother;
433 /* We don't know much -- general case. */
434 do {
435 if (regtry(prog, s))
436 goto got_it;
437 } while (s++ < strend);
438 }
439
440 /* Failure. */
441 goto phooey;
442
443 got_it:
444 if ((!safebase && (prog->nparens || sawampersand)) || prog->do_folding){
445 strend += dontbother; /* uncheat */
446 if (safebase) /* no need for $digit later */
447 s = strbeg;
448 else if (strbeg != prog->subbase) {
449 i = strend - string + (stringarg - strbeg);
450 s = nsavestr(strbeg,i); /* so $digit will work later */
451 if (prog->subbase)
452 Safefree(prog->subbase);
9ef589d8 453 prog->subbeg = prog->subbase = s;
00bf170e 454 prog->subend = s+i;
a687059c
LW
455 }
456 else
457 s = prog->subbase;
458 s += (stringarg - strbeg);
459 for (i = 0; i <= prog->nparens; i++) {
460 if (prog->endp[i]) {
461 prog->startp[i] = s + (prog->startp[i] - string);
462 prog->endp[i] = s + (prog->endp[i] - string);
463 }
464 }
465 if (prog->do_folding)
466 Safefree(string);
467 }
468 return(1);
469
470 phooey:
471 if (prog->do_folding)
472 Safefree(string);
473 return(0);
474}
475
476/*
477 - regtry - try match at specific point
478 */
479static int /* 0 failure, 1 success */
480regtry(prog, string)
481regexp *prog;
482char *string;
483{
484 register int i;
485 register char **sp;
486 register char **ep;
487
488 reginput = string;
489 regstartp = prog->startp;
490 regendp = prog->endp;
491 reglastparen = &prog->lastparen;
492 prog->lastparen = 0;
493
494 sp = prog->startp;
495 ep = prog->endp;
496 if (prog->nparens) {
fe14fcc3 497 for (i = prog->nparens; i >= 0; i--) {
a687059c
LW
498 *sp++ = NULL;
499 *ep++ = NULL;
500 }
501 }
502 if (regmatch(prog->program + 1) && reginput >= regtill) {
503 prog->startp[0] = string;
504 prog->endp[0] = reginput;
505 return(1);
506 } else
507 return(0);
508}
509
510/*
511 - regmatch - main matching routine
512 *
513 * Conceptually the strategy is simple: check to see whether the current
514 * node matches, call self recursively to see whether the rest matches,
515 * and then act accordingly. In practice we make some effort to avoid
516 * recursion, in particular by going through "ordinary" nodes (that don't
517 * need to know whether the rest of the match failed) by a loop instead of
518 * by recursion.
519 */
520/* [lwall] I've hoisted the register declarations to the outer block in order to
521 * maybe save a little bit of pushing and popping on the stack. It also takes
522 * advantage of machines that use a register save mask on subroutine entry.
523 */
524static int /* 0 failure, 1 success */
525regmatch(prog)
526char *prog;
527{
528 register char *scan; /* Current node. */
529 char *next; /* Next node. */
530 register int nextchar;
531 register int n; /* no or next */
532 register int ln; /* len or last */
533 register char *s; /* operand or save */
534 register char *locinput = reginput;
535
536 nextchar = *locinput;
537 scan = prog;
538#ifdef DEBUGGING
539 if (scan != NULL && regnarrate)
540 fprintf(stderr, "%s(\n", regprop(scan));
541#endif
542 while (scan != NULL) {
543#ifdef DEBUGGING
544 if (regnarrate)
545 fprintf(stderr, "%s...\n", regprop(scan));
546#endif
547
548#ifdef REGALIGN
549 next = scan + NEXT(scan);
550 if (next == scan)
551 next = NULL;
552#else
553 next = regnext(scan);
554#endif
555
556 switch (OP(scan)) {
557 case BOL:
ac58e20f 558 if (locinput == regbol ? regprev == '\n' :
a687059c
LW
559 ((nextchar || locinput < regeol) &&
560 locinput[-1] == '\n') )
561 {
fe14fcc3 562 /* regtill = regbol; */
a687059c
LW
563 break;
564 }
565 return(0);
566 case EOL:
567 if ((nextchar || locinput < regeol) && nextchar != '\n')
568 return(0);
00bf170e
LW
569 if (!multiline && regeol - locinput > 1)
570 return 0;
fe14fcc3 571 /* regtill = regbol; */
a687059c
LW
572 break;
573 case ANY:
574 if ((nextchar == '\0' && locinput >= regeol) ||
575 nextchar == '\n')
576 return(0);
577 nextchar = *++locinput;
578 break;
579 case EXACTLY:
580 s = OPERAND(scan);
581 ln = *s++;
582 /* Inline the first character, for speed. */
583 if (*s != nextchar)
584 return(0);
00bf170e 585 if (regeol - locinput < ln)
a687059c
LW
586 return 0;
587 if (ln > 1 && bcmp(s, locinput, ln) != 0)
588 return(0);
589 locinput += ln;
590 nextchar = *locinput;
591 break;
592 case ANYOF:
a687059c
LW
593 s = OPERAND(scan);
594 if (nextchar < 0)
595 nextchar = UCHARAT(locinput);
596 if (s[nextchar >> 3] & (1 << (nextchar&7)))
597 return(0);
34de22dd 598 if (!nextchar && locinput >= regeol)
a687059c 599 return 0;
34de22dd 600 nextchar = *++locinput;
a687059c
LW
601 break;
602 case ALNUM:
603 if (!nextchar)
604 return(0);
ac58e20f 605 if (!isALNUM(nextchar))
a687059c
LW
606 return(0);
607 nextchar = *++locinput;
608 break;
609 case NALNUM:
610 if (!nextchar && locinput >= regeol)
611 return(0);
ac58e20f 612 if (isALNUM(nextchar))
a687059c
LW
613 return(0);
614 nextchar = *++locinput;
615 break;
616 case NBOUND:
617 case BOUND:
618 if (locinput == regbol) /* was last char in word? */
ac58e20f 619 ln = isALNUM(regprev);
a687059c 620 else
ac58e20f
LW
621 ln = isALNUM(locinput[-1]);
622 n = isALNUM(nextchar); /* is next char in word? */
a687059c
LW
623 if ((ln == n) == (OP(scan) == BOUND))
624 return(0);
625 break;
626 case SPACE:
627 if (!nextchar && locinput >= regeol)
628 return(0);
ac58e20f 629 if (!isSPACE(nextchar))
a687059c
LW
630 return(0);
631 nextchar = *++locinput;
632 break;
633 case NSPACE:
634 if (!nextchar)
635 return(0);
ac58e20f 636 if (isSPACE(nextchar))
a687059c
LW
637 return(0);
638 nextchar = *++locinput;
639 break;
640 case DIGIT:
ac58e20f 641 if (!isDIGIT(nextchar))
a687059c
LW
642 return(0);
643 nextchar = *++locinput;
644 break;
645 case NDIGIT:
646 if (!nextchar && locinput >= regeol)
647 return(0);
ac58e20f 648 if (isDIGIT(nextchar))
a687059c
LW
649 return(0);
650 nextchar = *++locinput;
651 break;
652 case REF:
fe14fcc3 653 n = ARG1(scan); /* which paren pair */
a687059c
LW
654 s = regmystartp[n];
655 if (!s)
656 return(0);
657 if (!regmyendp[n])
658 return(0);
659 if (s == regmyendp[n])
660 break;
661 /* Inline the first character, for speed. */
662 if (*s != nextchar)
663 return(0);
664 ln = regmyendp[n] - s;
665 if (locinput + ln > regeol)
666 return 0;
667 if (ln > 1 && bcmp(s, locinput, ln) != 0)
668 return(0);
669 locinput += ln;
670 nextchar = *locinput;
671 break;
672
673 case NOTHING:
674 break;
675 case BACK:
676 break;
fe14fcc3
LW
677 case OPEN:
678 n = ARG1(scan); /* which paren pair */
a687059c
LW
679 reginput = locinput;
680
681 regmystartp[n] = locinput; /* for REF */
682 if (regmatch(next)) {
683 /*
684 * Don't set startp if some later
685 * invocation of the same parentheses
686 * already has.
687 */
688 if (regstartp[n] == NULL)
689 regstartp[n] = locinput;
690 return(1);
691 } else
692 return(0);
693 /* NOTREACHED */
fe14fcc3
LW
694 case CLOSE: {
695 n = ARG1(scan); /* which paren pair */
a687059c
LW
696 reginput = locinput;
697
698 regmyendp[n] = locinput; /* for REF */
699 if (regmatch(next)) {
700 /*
701 * Don't set endp if some later
702 * invocation of the same parentheses
703 * already has.
704 */
705 if (regendp[n] == NULL) {
706 regendp[n] = locinput;
707 if (n > *reglastparen)
708 *reglastparen = n;
709 }
710 return(1);
711 } else
712 return(0);
713 }
714 /*NOTREACHED*/
715 case BRANCH: {
716 if (OP(next) != BRANCH) /* No choice. */
717 next = NEXTOPER(scan); /* Avoid recursion. */
718 else {
719 do {
720 reginput = locinput;
721 if (regmatch(NEXTOPER(scan)))
722 return(1);
723#ifdef REGALIGN
f0fcb552 724 /*SUPPRESS 560*/
a687059c
LW
725 if (n = NEXT(scan))
726 scan += n;
727 else
728 scan = NULL;
729#else
730 scan = regnext(scan);
731#endif
732 } while (scan != NULL && OP(scan) == BRANCH);
733 return(0);
734 /* NOTREACHED */
735 }
736 }
737 break;
00bf170e
LW
738 case CURLY:
739 ln = ARG1(scan); /* min to match */
740 n = ARG2(scan); /* max to match */
741 scan = NEXTOPER(scan) + 4;
742 goto repeat;
a687059c 743 case STAR:
00bf170e
LW
744 ln = 0;
745 n = 0;
746 scan = NEXTOPER(scan);
747 goto repeat;
a687059c
LW
748 case PLUS:
749 /*
750 * Lookahead to avoid useless match attempts
751 * when we know what character comes next.
752 */
00bf170e
LW
753 ln = 1;
754 n = 0;
755 scan = NEXTOPER(scan);
756 repeat:
a687059c
LW
757 if (OP(next) == EXACTLY)
758 nextchar = *(OPERAND(next)+1);
759 else
760 nextchar = -1000;
a687059c 761 reginput = locinput;
00bf170e 762 n = regrepeat(scan, n);
0a12ae7d 763 if (!multiline && OP(next) == EOL && ln < n)
00bf170e 764 ln = n; /* why back off? */
a687059c
LW
765 while (n >= ln) {
766 /* If it could work, try it. */
767 if (nextchar == -1000 || *reginput == nextchar)
768 if (regmatch(next))
769 return(1);
770 /* Couldn't or didn't -- back up. */
771 n--;
772 reginput = locinput + n;
773 }
774 return(0);
775 case END:
776 reginput = locinput; /* put where regtry can find it */
777 return(1); /* Success! */
778 default:
779 printf("%x %d\n",scan,scan[1]);
780 FAIL("regexp memory corruption");
781 }
782
783 scan = next;
784 }
785
786 /*
787 * We get here only if there's trouble -- normally "case END" is
788 * the terminating point.
789 */
790 FAIL("corrupted regexp pointers");
791 /*NOTREACHED*/
792#ifdef lint
793 return 0;
794#endif
795}
796
797/*
798 - regrepeat - repeatedly match something simple, report how many
799 */
800/*
801 * [This routine now assumes that it will only match on things of length 1.
802 * That was true before, but now we assume scan - reginput is the count,
803 * rather than incrementing count on every character.]
804 */
805static int
00bf170e 806regrepeat(p, max)
a687059c 807char *p;
00bf170e 808int max;
a687059c
LW
809{
810 register char *scan;
811 register char *opnd;
812 register int c;
813 register char *loceol = regeol;
814
815 scan = reginput;
00bf170e
LW
816 if (max && max < loceol - scan)
817 loceol = scan + max;
a687059c
LW
818 opnd = OPERAND(p);
819 switch (OP(p)) {
820 case ANY:
821 while (scan < loceol && *scan != '\n')
822 scan++;
823 break;
824 case EXACTLY: /* length of string is 1 */
825 opnd++;
826 while (scan < loceol && *opnd == *scan)
827 scan++;
828 break;
829 case ANYOF:
a687059c
LW
830 c = UCHARAT(scan);
831 while (scan < loceol && !(opnd[c >> 3] & (1 << (c & 7)))) {
832 scan++;
833 c = UCHARAT(scan);
834 }
835 break;
836 case ALNUM:
0a12ae7d 837 while (scan < loceol && isALNUM(*scan))
a687059c
LW
838 scan++;
839 break;
840 case NALNUM:
ac58e20f 841 while (scan < loceol && !isALNUM(*scan))
a687059c
LW
842 scan++;
843 break;
844 case SPACE:
ac58e20f 845 while (scan < loceol && isSPACE(*scan))
a687059c
LW
846 scan++;
847 break;
848 case NSPACE:
ac58e20f 849 while (scan < loceol && !isSPACE(*scan))
a687059c
LW
850 scan++;
851 break;
852 case DIGIT:
0a12ae7d 853 while (scan < loceol && isDIGIT(*scan))
a687059c
LW
854 scan++;
855 break;
856 case NDIGIT:
ac58e20f 857 while (scan < loceol && !isDIGIT(*scan))
a687059c
LW
858 scan++;
859 break;
860 default: /* Oh dear. Called inappropriately. */
861 FAIL("internal regexp foulup");
862 /* NOTREACHED */
863 }
864
865 c = scan - reginput;
866 reginput = scan;
867
868 return(c);
869}
870
871/*
872 - regnext - dig the "next" pointer out of a node
873 *
874 * [Note, when REGALIGN is defined there are two places in regmatch()
875 * that bypass this code for speed.]
876 */
877char *
878regnext(p)
879register char *p;
880{
881 register int offset;
882
883 if (p == &regdummy)
884 return(NULL);
885
886 offset = NEXT(p);
887 if (offset == 0)
888 return(NULL);
889
890#ifdef REGALIGN
891 return(p+offset);
892#else
893 if (OP(p) == BACK)
894 return(p-offset);
895 else
896 return(p+offset);
897#endif
898}