regexec.c

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