[BACK]Return to engine.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / regex

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libc/regex/engine.c between version 1.6 and 1.15

version 1.6, 1997/01/23 14:02:11 version 1.15, 2003/08/07 16:43:19
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
   
 /*-  /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.  
  * Copyright (c) 1992, 1993, 1994   * Copyright (c) 1992, 1993, 1994
  *      The Regents of the University of California.  All rights reserved.   *      The Regents of the University of California.  All rights reserved.
  *   *
Line 16 
Line 15 
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
    * 3. Neither the name of the University nor the names of its contributors
    *    may be used to endorse or promote products derived from this software
    *    without specific prior written permission.
    *
    * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    * SUCH DAMAGE.
    *
    *      @(#)engine.c    8.5 (Berkeley) 3/20/94
    */
   
   /*-
    * Copyright (c) 1992, 1993, 1994 Henry Spencer.
    *
    * This code is derived from software contributed to Berkeley by
    * Henry Spencer.
    *
    * 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 conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software   * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:   *    must display the following acknowledgement:
  *      This product includes software developed by the University of   *      This product includes software developed by the University of
Line 56 
Line 88 
 #define print   sprint  #define print   sprint
 #define at      sat  #define at      sat
 #define match   smat  #define match   smat
   #define nope    snope
 #endif  #endif
 #ifdef LNAMES  #ifdef LNAMES
 #define matcher lmatcher  #define matcher lmatcher
Line 67 
Line 100 
 #define print   lprint  #define print   lprint
 #define at      lat  #define at      lat
 #define match   lmat  #define match   lmat
   #define nope    lnope
 #endif  #endif
   
 /* another structure passed up and down to avoid zillions of parameters */  /* another structure passed up and down to avoid zillions of parameters */
Line 126  static char *pchar __P((int ch));
Line 160  static char *pchar __P((int ch));
 #define SP(t, s, c)     print(m, t, s, c, stdout)  #define SP(t, s, c)     print(m, t, s, c, stdout)
 #define AT(t, p1, p2, s1, s2)   at(m, t, p1, p2, s1, s2)  #define AT(t, p1, p2, s1, s2)   at(m, t, p1, p2, s1, s2)
 #define NOTE(str)       { if (m->eflags&REG_TRACE) printf("=%s\n", (str)); }  #define NOTE(str)       { if (m->eflags&REG_TRACE) printf("=%s\n", (str)); }
   static int nope = 0;
 #else  #else
 #define SP(t, s, c)     /* nothing */  #define SP(t, s, c)     /* nothing */
 #define AT(t, p1, p2, s1, s2)   /* nothing */  #define AT(t, p1, p2, s1, s2)   /* nothing */
Line 134  static char *pchar __P((int ch));
Line 169  static char *pchar __P((int ch));
   
 /*  /*
  - matcher - the actual matching engine   - matcher - the actual matching engine
  == static int matcher(register struct re_guts *g, char *string, \   == static int matcher(struct re_guts *g, char *string, \
  ==     size_t nmatch, regmatch_t pmatch[], int eflags);   ==     size_t nmatch, regmatch_t pmatch[], int eflags);
  */   */
 static int                      /* 0 success, REG_NOMATCH failure */  static int                      /* 0 success, REG_NOMATCH failure */
 matcher(g, string, nmatch, pmatch, eflags)  matcher(g, string, nmatch, pmatch, eflags)
 register struct re_guts *g;  struct re_guts *g;
 char *string;  char *string;
 size_t nmatch;  size_t nmatch;
 regmatch_t pmatch[];  regmatch_t pmatch[];
 int eflags;  int eflags;
 {  {
         register char *endp;          char *endp;
         register int i;          int i;
         struct match mv;          struct match mv;
         register struct match *m = &mv;          struct match *m = &mv;
         register char *dp;          char *dp;
         const register sopno gf = g->firststate+1;      /* +1 for OEND */          const sopno gf = g->firststate+1;       /* +1 for OEND */
         const register sopno gl = g->laststate;          const sopno gl = g->laststate;
         char *start;          char *start;
         char *stop;          char *stop;
           int error = 0;
   
           _DIAGASSERT(g != NULL);
           _DIAGASSERT(string != NULL);
           /* pmatch checked below */
   
         /* simplify the situation where possible */          /* simplify the situation where possible */
         if (g->cflags&REG_NOSUB)          if (g->cflags&REG_NOSUB)
                 nmatch = 0;                  nmatch = 0;
         if (eflags&REG_STARTEND) {          if (eflags&REG_STARTEND) {
                 start = string + pmatch[0].rm_so;                  _DIAGASSERT(pmatch != NULL);
                 stop = string + pmatch[0].rm_eo;                  start = string + (size_t)pmatch[0].rm_so;
                   stop = string + (size_t)pmatch[0].rm_eo;
         } else {          } else {
                 start = string;                  start = string;
                 stop = start + strlen(start);                  stop = start + strlen(start);
Line 197  int eflags;
Line 238  int eflags;
         for (;;) {          for (;;) {
                 endp = fast(m, start, stop, gf, gl);                  endp = fast(m, start, stop, gf, gl);
                 if (endp == NULL) {             /* a miss */                  if (endp == NULL) {             /* a miss */
                         STATETEARDOWN(m);                          error = REG_NOMATCH;
                         return(REG_NOMATCH);                          goto done;
                 }                  }
                 if (nmatch == 0 && !g->backrefs)                  if (nmatch == 0 && !g->backrefs)
                         break;          /* no further info needed */                          break;          /* no further info needed */
Line 221  int eflags;
Line 262  int eflags;
                         m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *                          m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *
                                                         sizeof(regmatch_t));                                                          sizeof(regmatch_t));
                 if (m->pmatch == NULL) {                  if (m->pmatch == NULL) {
                         STATETEARDOWN(m);                          error = REG_ESPACE;
                         return(REG_ESPACE);                          goto done;
                 }                  }
                 for (i = 1; i <= m->g->nsub; i++)                  for (i = 1; i <= m->g->nsub; i++)
                         m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;                          m->pmatch[i].rm_so = m->pmatch[i].rm_eo = (regoff_t)-1;
                 if (!g->backrefs && !(m->eflags&REG_BACKR)) {                  if (!g->backrefs && !(m->eflags&REG_BACKR)) {
                         NOTE("dissecting");                          NOTE("dissecting");
                         dp = dissect(m, m->coldp, endp, gf, gl);                          dp = dissect(m, m->coldp, endp, gf, gl);
Line 234  int eflags;
Line 275  int eflags;
                                 m->lastpos = (char **)malloc((g->nplus+1) *                                  m->lastpos = (char **)malloc((g->nplus+1) *
                                                         sizeof(char *));                                                          sizeof(char *));
                         if (g->nplus > 0 && m->lastpos == NULL) {                          if (g->nplus > 0 && m->lastpos == NULL) {
                                 free(m->pmatch);                                  error = REG_ESPACE;
                                 STATETEARDOWN(m);                                  goto done;
                                 return(REG_ESPACE);  
                         }                          }
                         NOTE("backref dissect");                          NOTE("backref dissect");
                         dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);                          dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
Line 257  int eflags;
Line 297  int eflags;
                         /* try it on a shorter possibility */                          /* try it on a shorter possibility */
 #ifndef NDEBUG  #ifndef NDEBUG
                         for (i = 1; i <= m->g->nsub; i++) {                          for (i = 1; i <= m->g->nsub; i++) {
                                 assert(m->pmatch[i].rm_so == -1);                                  assert(m->pmatch[i].rm_so == (regoff_t)-1);
                                 assert(m->pmatch[i].rm_eo == -1);                                  assert(m->pmatch[i].rm_eo == (regoff_t)-1);
                         }                          }
 #endif  #endif
                         NOTE("backoff dissect");                          NOTE("backoff dissect");
Line 276  int eflags;
Line 316  int eflags;
   
         /* fill in the details if requested */          /* fill in the details if requested */
         if (nmatch > 0) {          if (nmatch > 0) {
                   _DIAGASSERT(pmatch != NULL);
                 pmatch[0].rm_so = m->coldp - m->offp;                  pmatch[0].rm_so = m->coldp - m->offp;
                 pmatch[0].rm_eo = endp - m->offp;                  pmatch[0].rm_eo = endp - m->offp;
         }          }
Line 285  int eflags;
Line 326  int eflags;
                         if (i <= m->g->nsub)                          if (i <= m->g->nsub)
                                 pmatch[i] = m->pmatch[i];                                  pmatch[i] = m->pmatch[i];
                         else {                          else {
                                 pmatch[i].rm_so = -1;                                  pmatch[i].rm_so = (regoff_t)-1;
                                 pmatch[i].rm_eo = -1;                                  pmatch[i].rm_eo = (regoff_t)-1;
                         }                          }
         }          }
   
         if (m->pmatch != NULL)  done:
                 free((char *)m->pmatch);          if (m->pmatch != NULL) {
         if (m->lastpos != NULL)                  free(m->pmatch);
                 free((char *)m->lastpos);                  m->pmatch = NULL;
           }
           if (m->lastpos != NULL) {
                   free(m->lastpos);
                   m->lastpos = NULL;
           }
         STATETEARDOWN(m);          STATETEARDOWN(m);
         return(0);          return error;
 }  }
   
 /*  /*
  - dissect - figure out what matched what, no back references   - dissect - figure out what matched what, no back references
  == static char *dissect(register struct match *m, char *start, \   == static char *dissect(struct match *m, char *start, \
  ==     char *stop, sopno startst, sopno stopst);   ==     char *stop, sopno startst, sopno stopst);
  */   */
 static char *                   /* == stop (success) always */  static char *                   /* == stop (success) always */
 dissect(m, start, stop, startst, stopst)  dissect(m, start, stop, startst, stopst)
 register struct match *m;  struct match *m;
 char *start;  char *start;
 char *stop;  char *stop;
 sopno startst;  sopno startst;
 sopno stopst;  sopno stopst;
 {  {
         register int i;          int i;
         register sopno ss;      /* start sop of current subRE */          sopno ss;       /* start sop of current subRE */
         register sopno es;      /* end sop of current subRE */          sopno es;       /* end sop of current subRE */
         register char *sp;      /* start of string matched by it */          char *sp;       /* start of string matched by it */
         register char *stp;     /* string matched by it cannot pass here */          char *stp;      /* string matched by it cannot pass here */
         register char *rest;    /* start of rest of string */          char *rest;     /* start of rest of string */
         register char *tail;    /* string unmatched by rest of RE */          char *tail;     /* string unmatched by rest of RE */
         register sopno ssub;    /* start sop of subsubRE */          sopno ssub;     /* start sop of subsubRE */
         register sopno esub;    /* end sop of subsubRE */          sopno esub;     /* end sop of subsubRE */
         register char *ssp;     /* start of string matched by subsubRE */          char *ssp;      /* start of string matched by subsubRE */
         register char *sep;     /* end of string matched by subsubRE */          char *sep;      /* end of string matched by subsubRE */
         register char *oldssp;  /* previous ssp */          char *oldssp;   /* previous ssp */
         register char *dp;  #ifndef NDEBUG
           char *dp;
   #endif
   
           _DIAGASSERT(m != NULL);
           _DIAGASSERT(start != NULL);
           _DIAGASSERT(stop != NULL);
   
         AT("diss", start, stop, startst, stopst);          AT("diss", start, stop, startst, stopst);
         sp = start;          sp = start;
Line 382  sopno stopst;
Line 434  sopno stopst;
                         esub = es - 1;                          esub = es - 1;
                         /* did innards match? */                          /* did innards match? */
                         if (slow(m, sp, rest, ssub, esub) != NULL) {                          if (slow(m, sp, rest, ssub, esub) != NULL) {
                                 dp = dissect(m, sp, rest, ssub, esub);  #ifdef NDEBUG
                                   (void)
   #else
                                   dp =
   #endif
                                       dissect(m, sp, rest, ssub, esub);
                                 assert(dp == rest);                                  assert(dp == rest);
                         } else          /* no */                          } else          /* no */
                                 assert(sp == rest);                                  assert(sp == rest);
Line 420  sopno stopst;
Line 477  sopno stopst;
                         }                          }
                         assert(sep == rest);    /* must exhaust substring */                          assert(sep == rest);    /* must exhaust substring */
                         assert(slow(m, ssp, sep, ssub, esub) == rest);                          assert(slow(m, ssp, sep, ssub, esub) == rest);
                         dp = dissect(m, ssp, sep, ssub, esub);  #ifdef NDEBUG
                           (void)
   #else
                           dp =
   #endif
                               dissect(m, ssp, sep, ssub, esub);
                         assert(dp == sep);                          assert(dp == sep);
                         sp = rest;                          sp = rest;
                         break;                          break;
Line 455  sopno stopst;
Line 517  sopno stopst;
                                 else                                  else
                                         assert(OP(m->g->strip[esub]) == O_CH);                                          assert(OP(m->g->strip[esub]) == O_CH);
                         }                          }
                         dp = dissect(m, sp, rest, ssub, esub);  #ifdef NDEBUG
                           (void)
   #else
                           dp =
   #endif
                               dissect(m, sp, rest, ssub, esub);
                         assert(dp == rest);                          assert(dp == rest);
                         sp = rest;                          sp = rest;
                         break;                          break;
Line 488  sopno stopst;
Line 555  sopno stopst;
   
 /*  /*
  - backref - figure out what matched what, figuring in back references   - backref - figure out what matched what, figuring in back references
  == static char *backref(register struct match *m, char *start, \   == static char *backref(struct match *m, char *start, \
  ==     char *stop, sopno startst, sopno stopst, sopno lev);   ==     char *stop, sopno startst, sopno stopst, sopno lev);
  */   */
 static char *                   /* == stop (success) or NULL (failure) */  static char *                   /* == stop (success) or NULL (failure) */
 backref(m, start, stop, startst, stopst, lev)  backref(m, start, stop, startst, stopst, lev)
 register struct match *m;  struct match *m;
 char *start;  char *start;
 char *stop;  char *stop;
 sopno startst;  sopno startst;
 sopno stopst;  sopno stopst;
 sopno lev;                      /* PLUS nesting level */  sopno lev;                      /* PLUS nesting level */
 {  {
         register int i;          int i;
         register sopno ss;      /* start sop of current subRE */          sopno ss;       /* start sop of current subRE */
         register char *sp;      /* start of string matched by it */          char *sp;       /* start of string matched by it */
         register sopno ssub;    /* start sop of subsubRE */          sopno ssub;     /* start sop of subsubRE */
         register sopno esub;    /* end sop of subsubRE */          sopno esub;     /* end sop of subsubRE */
         register char *ssp;     /* start of string matched by subsubRE */          char *ssp;      /* start of string matched by subsubRE */
         register char *dp;          char *dp;
         register size_t len;          size_t len;
         register int hard;          int hard;
         register sop s;          sop s;
         register regoff_t offsave;          regoff_t offsave;
         register cset *cs;          cset *cs;
   
           _DIAGASSERT(m != NULL);
           _DIAGASSERT(start != NULL);
           _DIAGASSERT(stop != NULL);
   
         AT("back", start, stop, startst, stopst);          AT("back", start, stop, startst, stopst);
         sp = start;          sp = start;
Line 600  sopno lev;   /* PLUS nesting level */
Line 671  sopno lev;   /* PLUS nesting level */
         case OBACK_:            /* the vilest depths */          case OBACK_:            /* the vilest depths */
                 i = OPND(s);                  i = OPND(s);
                 assert(0 < i && i <= m->g->nsub);                  assert(0 < i && i <= m->g->nsub);
                 if (m->pmatch[i].rm_eo == -1)                  if (m->pmatch[i].rm_eo == (regoff_t)-1)
                         return(NULL);                          return(NULL);
                 assert(m->pmatch[i].rm_so != -1);                  assert(m->pmatch[i].rm_so != (regoff_t)-1);
                 len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;                  len = (size_t)(m->pmatch[i].rm_eo - m->pmatch[i].rm_so);
                 assert(stop - m->beginp >= len);                  assert(stop - m->beginp >= len);
                 if (sp > stop - len)                  if (sp > stop - len)
                         return(NULL);   /* not enough left to match */                          return(NULL);   /* not enough left to match */
                 ssp = m->offp + m->pmatch[i].rm_so;                  ssp = m->offp + (size_t)m->pmatch[i].rm_so;
                 if (memcmp(sp, ssp, len) != 0)                  if (memcmp(sp, ssp, len) != 0)
                         return(NULL);                          return(NULL);
                 while (m->g->strip[ss] != SOP(O_BACK, i))                  while (m->g->strip[ss] != SOP(O_BACK, i))
                         ss++;                          ss++;
                 return(backref(m, sp+len, stop, ss+1, stopst, lev));                  return(backref(m, sp+len, stop, ss+1, stopst, lev));
                 break;  
         case OQUEST_:           /* to null or not */          case OQUEST_:           /* to null or not */
                 dp = backref(m, sp, stop, ss+1, stopst, lev);                  dp = backref(m, sp, stop, ss+1, stopst, lev);
                 if (dp != NULL)                  if (dp != NULL)
                         return(dp);     /* not */                          return(dp);     /* not */
                 return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));                  return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));
                 break;  
         case OPLUS_:          case OPLUS_:
                 assert(m->lastpos != NULL);                  assert(m->lastpos != NULL);
                 assert(lev+1 <= m->g->nplus);                  assert(lev+1 <= m->g->nplus);
                 m->lastpos[lev+1] = sp;                  m->lastpos[lev+1] = sp;
                 return(backref(m, sp, stop, ss+1, stopst, lev+1));                  return(backref(m, sp, stop, ss+1, stopst, lev+1));
                 break;  
         case O_PLUS:          case O_PLUS:
                 if (sp == m->lastpos[lev])      /* last pass matched null */                  if (sp == m->lastpos[lev])      /* last pass matched null */
                         return(backref(m, sp, stop, ss+1, stopst, lev-1));                          return(backref(m, sp, stop, ss+1, stopst, lev-1));
Line 633  sopno lev;   /* PLUS nesting level */
Line 704  sopno lev;   /* PLUS nesting level */
                 m->lastpos[lev] = sp;                  m->lastpos[lev] = sp;
                 dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);                  dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);
                 if (dp == NULL)                  if (dp == NULL)
                         return(backref(m, sp, stop, ss+1, stopst, lev-1));                          dp = backref(m, sp, stop, ss+1, stopst, lev-1);
                 else                  return(dp);
                         return(dp);  
                 break;  
         case OCH_:              /* find the right one, if any */          case OCH_:              /* find the right one, if any */
                 ssub = ss + 1;                  ssub = ss + 1;
                 esub = ss + OPND(s) - 1;                  esub = ss + OPND(s) - 1;
Line 657  sopno lev;   /* PLUS nesting level */
Line 727  sopno lev;   /* PLUS nesting level */
                         else                          else
                                 assert(OP(m->g->strip[esub]) == O_CH);                                  assert(OP(m->g->strip[esub]) == O_CH);
                 }                  }
                 break;  
         case OLPAREN:           /* must undo assignment if rest fails */          case OLPAREN:           /* must undo assignment if rest fails */
                 i = OPND(s);                  i = OPND(s);
                 assert(0 < i && i <= m->g->nsub);                  assert(0 < i && i <= m->g->nsub);
Line 668  sopno lev;   /* PLUS nesting level */
Line 738  sopno lev;   /* PLUS nesting level */
                         return(dp);                          return(dp);
                 m->pmatch[i].rm_so = offsave;                  m->pmatch[i].rm_so = offsave;
                 return(NULL);                  return(NULL);
                 break;  
         case ORPAREN:           /* must undo assignment if rest fails */          case ORPAREN:           /* must undo assignment if rest fails */
                 i = OPND(s);                  i = OPND(s);
                 assert(0 < i && i <= m->g->nsub);                  assert(0 < i && i <= m->g->nsub);
Line 679  sopno lev;   /* PLUS nesting level */
Line 749  sopno lev;   /* PLUS nesting level */
                         return(dp);                          return(dp);
                 m->pmatch[i].rm_eo = offsave;                  m->pmatch[i].rm_eo = offsave;
                 return(NULL);                  return(NULL);
                 break;  
         default:                /* uh oh */          default:                /* uh oh */
                 assert(nope);                  assert(nope);
                 break;                  break;
Line 688  sopno lev;   /* PLUS nesting level */
Line 758  sopno lev;   /* PLUS nesting level */
         /* "can't happen" */          /* "can't happen" */
         assert(nope);          assert(nope);
         /* NOTREACHED */          /* NOTREACHED */
           return NULL;
 }  }
   
 /*  /*
  - fast - step through the string at top speed   - fast - step through the string at top speed
  == static char *fast(register struct match *m, char *start, \   == static char *fast(struct match *m, char *start, \
  ==     char *stop, sopno startst, sopno stopst);   ==     char *stop, sopno startst, sopno stopst);
  */   */
 static char *                   /* where tentative match ended, or NULL */  static char *                   /* where tentative match ended, or NULL */
 fast(m, start, stop, startst, stopst)  fast(m, start, stop, startst, stopst)
 register struct match *m;  struct match *m;
 char *start;  char *start;
 char *stop;  char *stop;
 sopno startst;  sopno startst;
 sopno stopst;  sopno stopst;
 {  {
         register states st = m->st;          states st = m->st;
         register states fresh = m->fresh;          states fresh = m->fresh;
         register states tmp = m->tmp;          states tmp = m->tmp;
         register char *p = start;          char *p = start;
         register int c = (start == m->beginp) ? OUT : *(start-1);          int c = (start == m->beginp) ? OUT : *(start-1);
         register int lastc;     /* previous c */          int lastc;      /* previous c */
         register int flagch;          int flagch;
         register int i;          int i;
         register char *coldp;   /* last p after which no match was underway */          char *coldp;    /* last p after which no match was underway */
   
           _DIAGASSERT(m != NULL);
           _DIAGASSERT(start != NULL);
           _DIAGASSERT(stop != NULL);
   
         CLEAR(st);          CLEAR(st);
         SET1(st, startst);          SET1(st, startst);
Line 783  sopno stopst;
Line 858  sopno stopst;
   
 /*  /*
  - slow - step through the string more deliberately   - slow - step through the string more deliberately
  == static char *slow(register struct match *m, char *start, \   == static char *slow(struct match *m, char *start, \
  ==     char *stop, sopno startst, sopno stopst);   ==     char *stop, sopno startst, sopno stopst);
  */   */
 static char *                   /* where it ended */  static char *                   /* where it ended */
 slow(m, start, stop, startst, stopst)  slow(m, start, stop, startst, stopst)
 register struct match *m;  struct match *m;
 char *start;  char *start;
 char *stop;  char *stop;
 sopno startst;  sopno startst;
 sopno stopst;  sopno stopst;
 {  {
         register states st = m->st;          states st = m->st;
         register states empty = m->empty;          states empty = m->empty;
         register states tmp = m->tmp;          states tmp = m->tmp;
         register char *p = start;          char *p = start;
         register int c = (start == m->beginp) ? OUT : *(start-1);          int c = (start == m->beginp) ? OUT : *(start-1);
         register int lastc;     /* previous c */          int lastc;      /* previous c */
         register int flagch;          int flagch;
         register int i;          int i;
         register char *matchp;  /* last p at which a match ended */          char *matchp;   /* last p at which a match ended */
   
           _DIAGASSERT(m != NULL);
           _DIAGASSERT(start != NULL);
           _DIAGASSERT(stop != NULL);
   
         AT("slow", start, stop, startst, stopst);          AT("slow", start, stop, startst, stopst);
         CLEAR(st);          CLEAR(st);
Line 870  sopno stopst;
Line 949  sopno stopst;
   
 /*  /*
  - step - map set of states reachable before char to set reachable after   - step - map set of states reachable before char to set reachable after
  == static states step(register struct re_guts *g, sopno start, sopno stop, \   == static states step(struct re_guts *g, sopno start, sopno stop, \
  ==     register states bef, int ch, register states aft);   ==     states bef, int ch, states aft);
  == #define     BOL     (OUT+1)   == #define     BOL     (OUT+1)
  == #define     EOL     (BOL+1)   == #define     EOL     (BOL+1)
  == #define     BOLEOL  (BOL+2)   == #define     BOLEOL  (BOL+2)
Line 884  sopno stopst;
Line 963  sopno stopst;
  */   */
 static states  static states
 step(g, start, stop, bef, ch, aft)  step(g, start, stop, bef, ch, aft)
 register struct re_guts *g;  struct re_guts *g;
 sopno start;                    /* start state within strip */  sopno start;                    /* start state within strip */
 sopno stop;                     /* state after stop state within strip */  sopno stop;                     /* state after stop state within strip */
 register states bef;            /* states reachable before */  states bef;             /* states reachable before */
 int ch;                         /* character or NONCHAR code */  int ch;                         /* character or NONCHAR code */
 register states aft;            /* states already known reachable after */  states aft;             /* states already known reachable after */
 {  {
         register cset *cs;          cset *cs;
         register sop s;          sop s;
         register sopno pc;          sopno pc;
         register onestate here;         /* note, macros know this name */          onestate here;          /* note, macros know this name */
         register sopno look;          sopno look;
         register int i;          int i;
   
           _DIAGASSERT(g != NULL);
   
         for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {          for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
                 s = g->strip[pc];                  s = g->strip[pc];
Line 1012  states st;
Line 1093  states st;
 int ch;  int ch;
 FILE *d;  FILE *d;
 {  {
         register struct re_guts *g = m->g;          struct re_guts *g = m->g;
         register int i;          int i;
         register int first = 1;          int first = 1;
   
           _DIAGASSERT(m != NULL);
           _DIAGASSERT(caption != NULL);
   
         if (!(m->eflags&REG_TRACE))          if (!(m->eflags&REG_TRACE))
                 return;                  return;
   
           _DIAGASSERT(d != NULL);
   
         fprintf(d, "%s", caption);          fprintf(d, "%s", caption);
         if (ch != '\0')          if (ch != '\0')
                 fprintf(d, " %s", pchar(ch));                  fprintf(d, " %s", pchar(ch));
Line 1046  char *stop;
Line 1132  char *stop;
 sopno startst;  sopno startst;
 sopno stopst;  sopno stopst;
 {  {
   
           _DIAGASSERT(m != NULL);
           _DIAGASSERT(title != NULL);
           _DIAGASSERT(start != NULL);
           _DIAGASSERT(stop != NULL);
   
         if (!(m->eflags&REG_TRACE))          if (!(m->eflags&REG_TRACE))
                 return;                  return;
   
Line 1091  int ch;
Line 1183  int ch;
 #undef  print  #undef  print
 #undef  at  #undef  at
 #undef  match  #undef  match
   #undef  nope

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.15

CVSweb <webmaster@jp.NetBSD.org>