e576bb2002-10-11Martin Nilsson /* || This file is part of Pike. For copyright information see COPYRIGHT. || Pike is distributed under GPL, LGPL and MPL. See the file COPYING || for more information. */
1b10db2002-10-08Martin Nilsson  /*
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * regexp.c - regular expression matching * * DESCRIPTION * * Underneath the reformatting and comment blocks which were added to * make it consistent with the rest of the code, you will find a * modified version of Henry Specer's regular expression library. * Henry's functions were modified to provide the minimal regular * expression matching, as required by P1003. Henry's code was * copyrighted, and copy of the copyright message and restrictions * are provided, verbatim, below: * * Copyright (c) 1986 by University of Toronto. * Written by Henry Spencer. Not derived from licensed software. * * Permission is granted to anyone to use this software for any * purpose on any computer system, and to redistribute it freely, * subject to the following restrictions: * * 1. The author is not responsible for the consequences of use of * this software, no matter how awful, even if they arise * from defects in it. * * 2. The origin of this software must not be misrepresented, either * by explicit claim or by omission. * * 3. Altered versions must be plainly marked as such, and must not * be misrepresented as being the original software. * * * This version modified by Ian Phillipps to return pointer to terminating * NUL on substitution string. [ Temp mail address ex-igp@camcon.co.uk ] * * Altered by amylaar to support excompatible option and the * operators \< and >\ . ( 7.Sep. 1991 ) * * regsub altered by amylaar to take an additional parameter specifying * maximum number of bytes that can be written to the memory region * pointed to by dest * * Also altered by Fredrik Hubinette to handle the + operator and * eight-bit chars. Mars 22 1996 * * * Beware that some of this code is subtly aware of the way operator * precedence is structured in regular expressions. Serious changes in * regular-expression syntax might require a total rethink. * * AUTHORS * * Mark H. Colburn, NAPS International (mark@jhereg.mn.org) * Henry Spencer, University of Torronto (henry@utzoo.edu) * * Sponsored by The USENIX Association for public distribution. * */ /* Headers */ #include "global.h" #include <ctype.h>
932a1d1997-09-10Henrik Grubbström (Grubba) #ifdef HAVE_STRING_H #include <string.h> #endif /* HAVE_STRING_H */
7369d31997-02-11Fredrik Hübinette (Hubbe) #include "pike_regexp.h"
9aa6fa1997-05-19Fredrik Hübinette (Hubbe) #include "pike_memory.h"
b2d3e42000-12-01Fredrik Hübinette (Hubbe) #include "pike_error.h"
151a6c2010-08-16Martin Stjernholm #include "interpret.h"
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
e48a9b2006-07-10Martin Nilsson #undef NOTHING
6dc2772000-07-28Fredrik Hübinette (Hubbe) 
ab6aec1997-02-11Fredrik Hübinette (Hubbe) /* * The "internal use only" fields in regexp.h are present to pass info from * compile to execute that permits the execute phase to run lots faster on * simple cases. They are: * * regstart char that must begin a match; '\0' if none obvious * reganch is the match anchored (at beginning-of-line only)? * regmust string (pointer into program) that match must include, or NULL * regmlen length of regmust string * * Regstart and reganch permit very fast decisions on suitable starting points * for a match, cutting down the work a lot. Regmust permits fast rejection * of lines that cannot possibly match. The regmust tests are costly enough * that regcomp() supplies a regmust only if the r.e. contains something * potentially expensive (at present, the only such thing detected is * or + * at the start of the r.e., which can involve a lot of backup). Regmlen is * supplied because the test in regexec() needs it and regcomp() is computing * it anyway. */ /* * Structure for regexp "program". This is essentially a linear encoding * of a nondeterministic finite-state machine (aka syntax charts or * "railroad normal form" in parsing technology). Each node is an opcode
c842112015-04-21Martin Nilsson  * plus a "next" pointer, possibly plus an operand. "Next" pointers of * all nodes except BRANCH implement concatenation; a "next" pointer with
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * a BRANCH on both ends of it is connecting two alternatives. (Here we * have one of the subtle syntax dependencies: an individual BRANCH (as * opposed to a collection of them) is never concatenated with anything * because of operator precedence.) The operand of some types of node is * a literal string; for others, it is a node leading into a sub-FSM. In * particular, the operand of a BRANCH node is the first node of the branch. * (NB this is *not* a tree structure: the tail of the branch connects * to the thing following the set of BRANCHes.) The opcodes are: */
c842112015-04-21Martin Nilsson /* definition number opnd? meaning */ #define END 0 /* no End of program. */ #define BOL 1 /* no Match "" at beginning of line. */ #define EOL 2 /* no Match "" at end of line. */ #define ANY 3 /* no Match any one character. */ #define ANYOF 4 /* str Match any character in this string. */ #define ANYBUT 5 /* str Match any character not in this
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * string. */
c842112015-04-21Martin Nilsson #define BRANCH 6 /* node Match this alternative, or the * next... */ #define BACK 7 /* no Match "", "next" ptr points backward. */ #define EXACTLY 8 /* str Match this string. */ #define NOTHING 9 /* no Match empty string. */ #define STAR 10 /* node Match this (simple) thing 0 or more
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * times. */ #define WORDSTART 11 /* node matching a start of a word */
c842112015-04-21Martin Nilsson #define WORDEND 12 /* node matching an end of a word */ #define KPLUS 13 /* node Match this (simple) thing 1 or more
4138da2010-08-16Martin Stjernholm  * times. */
c842112015-04-21Martin Nilsson #define OPEN 20 /* no Mark this point in input as start of
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * #n. */ /* OPEN+1 is number 1, etc. */
bfe7631998-03-25Fredrik Hübinette (Hubbe) #define CLOSE (OPEN+NSUBEXP) /* no Analogous to OPEN. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* * Opcode notes: * * BRANCH The set of branches constituting a single choice are hooked
c842112015-04-21Martin Nilsson  * together with their "next" pointers, since precedence prevents
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * anything being concatenated to any individual branch. The
c842112015-04-21Martin Nilsson  * "next" pointer of the last BRANCH in a choice points to the
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * thing following the whole choice. This is also where the
c842112015-04-21Martin Nilsson  * final "next" pointer of each individual branch points; each
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * branch starts with the operand node of a BRANCH node. *
c842112015-04-21Martin Nilsson  * BACK Normal "next" pointers all implicitly point forward; BACK
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * exists to make loop structures possible. *
4138da2010-08-16Martin Stjernholm  * STAR,KPLUS Complex cases are implemented as circular BRANCH structures
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * using BACK. Simple cases (one character per match) are
4138da2010-08-16Martin Stjernholm  * implemented with STAR or KPLUS for speed and to minimize * recursive plunges.
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * * OPEN,CLOSE ...are numbered at compile time. */ /*
c842112015-04-21Martin Nilsson  * A node is one char of opcode followed by two chars of "next" pointer. * "Next" pointers are stored as two 8-bit pieces, high order first. The
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * value is a positive offset from the opcode of the node containing it. * An operand, if any, simply follows the node. (Note that much of the * code generation knows about this implicit relationship.) *
c842112015-04-21Martin Nilsson  * Using two bytes for the "next" pointer is vast overkill for most things,
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * but allows patterns to get big without disasters. */ #define OP(p) (*(p)) #define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377)) #define OPERAND(p) ((p) + 3) /* * Utility definitions. */
b2d3e42000-12-01Fredrik Hübinette (Hubbe) #define regerror(X) Pike_error("Regexp: %s\n",X);
ab6aec1997-02-11Fredrik Hübinette (Hubbe) #define SPECIAL 0x100 #define LBRAC ('('|SPECIAL) #define RBRAC (')'|SPECIAL) #define ASTERIX ('*'|SPECIAL) #define PLUS ('+'|SPECIAL) #define OR_OP ('|'|SPECIAL) #define DOLLAR ('$'|SPECIAL) #define DOT ('.'|SPECIAL) #define CARET ('^'|SPECIAL) #define LSQBRAC ('['|SPECIAL) #define RSQBRAC (']'|SPECIAL) #define LSHBRAC ('<'|SPECIAL) #define RSHBRAC ('>'|SPECIAL) #define FAIL(m) { regerror(m); return(NULL); } #define ISMULT(c) ((c) == ASTERIX || (c)==PLUS) #define META "^$.[()|*+\\" #ifndef CHARBITS #define CHARBITS 0xff #define UCHARAT(p) ((int)*(unsigned char *)(p)) #else #define UCHARAT(p) ((int)*(p)&CHARBITS) #endif #define ISWORDPART(c) ( isalnum(c) || (c) == '_' ) /* * Flags to be passed up and down. */ #define HASWIDTH 01 /* Known never to match null string. */
4138da2010-08-16Martin Stjernholm #define SIMPLE 02 /* Simple enough to be STAR or KPLUS operand. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe) #define SPSTART 04 /* Starts with * */ #define WORST 0 /* Worst case. */ /* * Global work variables for regcomp(). */ static short *regparse; /* Input-scan pointer. */ static int regnpar; /* () count. */ static char *regcode; /* Code-emit pointer; &regdummy = don't. */ static long regsize; /* Code size. */
1f9fdb2015-04-28Martin Nilsson static char regdummy[3] = { NOTHING, 0, 0 };
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* * Forward declarations for regcomp()'s friends. */
7b06962015-04-19Martin Nilsson static char *reg(int, int *); static char *regbranch(int *); static char *regpiece(int *); static char *regatom(int *); static char *regnode(char);
45f4cd2015-04-27Martin Nilsson static char *regnext(char *);
7b06962015-04-19Martin Nilsson static void regc(char b); static void reginsert(char, char *);
61d8cd2015-04-28Martin Nilsson static void regtail(char *, const char *); static void regoptail(char *, const char *);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* - regcomp - compile a regular expression into internal code * * We can't allocate space until we know how big the compiled form will be, * but we can't compile it (and thus know how big it is) until we've got a * place to put the code. So we cheat: we compile it twice, once with code * generation turned off and size counting turned on, and once "for real". * This also means that we don't allocate space until we are sure that the * thing really will compile successfully, and we never have to move the * code and thus invalidate pointers into it. (Note that it has to be in * one piece because free() must be able to free it all.) * * Beware that the optimization-preparation code in here knows about some * of the structure of the compiled regexp. */
61d8cd2015-04-28Martin Nilsson regexp *pike_regcomp(const char *exp)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  regexp *r = NULL; char *scan; int flags; short *exp2,*dest,c;
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
bf75192015-04-19Martin Nilsson  if (exp == NULL)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  FAIL("NULL argument");
25525f2015-04-19Martin Nilsson  exp2=xcalloc( (strlen(exp)+1), sizeof(short) );
61d8cd2015-04-28Martin Nilsson  for ( dest=exp2; (c=UCHARAT(exp++)); ) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  switch (c) { case '(': case ')': case '.': case '*': case '+': case '|': case '$': case '^': case '[': case ']': *dest++ = c | SPECIAL; break; case '\\':
61d8cd2015-04-28Martin Nilsson  switch ( c = *exp++ ) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  case '(': case ')':
1cd2b02015-04-27Martin Nilsson  *dest++ = c;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  break; case '<': case '>': *dest++ = c | SPECIAL; break; case '{': case '}': FAIL("sorry, unimplemented operator"); case 'b': *dest++ = '\b'; break; case 't': *dest++ = '\t'; break; case 'r': *dest++ = '\r'; break; default: *dest++ = c; } break; default: *dest++ = c; } }
25525f2015-04-19Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* First pass: determine size, legality. */ regparse = exp2; regnpar = 1; regsize = 0L;
1f9fdb2015-04-28Martin Nilsson  regcode = regdummy;
bf75192015-04-19Martin Nilsson  if (reg(0, &flags) == NULL)
25525f2015-04-19Martin Nilsson  goto exit_regcomp;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* Small enough for pointer-storage convention? */ if (regsize >= 32767L) /* Probably could be 65535L. */
df9ff82015-04-19Martin Nilsson  { free(exp2); FAIL("regexp too big"); }
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* Allocate space. */
25525f2015-04-19Martin Nilsson  r = malloc(sizeof(regexp) + (unsigned) regsize); if(!r) { free(exp2); Pike_error(msg_out_of_mem); }
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* Second pass: emit code. */ regparse = exp2; regnpar = 1; regcode = r->program; if (reg(0, &flags) == NULL)
25525f2015-04-19Martin Nilsson  { free(r); r = NULL; goto exit_regcomp; }
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* Dig out information for optimizations. */ r->regstart = '\0'; /* Worst-case defaults. */ r->reganch = 0; r->regmust = NULL; r->regmlen = 0;
dd7b3c2003-08-12Martin Nilsson  scan = r->program; /* First BRANCH. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (OP(regnext(scan)) == END) { /* Only one top-level choice. */ scan = OPERAND(scan); /* Starting-point info. */ if (OP(scan) == EXACTLY) r->regstart = *OPERAND(scan); else if (OP(scan) == BOL) r->reganch++; /* * If there's something expensive in the r.e., find the longest * literal string that must appear and make it the regmust. Resolve * ties in favor of later strings, since the regstart check works * with the beginning of the r.e. and avoiding duplication * strengthens checking. Not a strong reason, but sufficient in the * absence of others. */ if (flags & SPSTART) {
2aca082015-04-22Martin Nilsson  char *longest = NULL; size_t len = 0;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  for (; scan != NULL; scan = regnext(scan)) if (OP(scan) == EXACTLY &&
4ed1bf2000-09-14Henrik Grubbström (Grubba)  strlen(OPERAND(scan)) >= (size_t)len) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  longest = OPERAND(scan); len = strlen(OPERAND(scan)); } r->regmust = longest; r->regmlen = len; } }
25525f2015-04-19Martin Nilsson  exit_regcomp:
0ec7522014-04-27Martin Nilsson  free(exp2);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (r); } /* - reg - regular expression, i.e. main body or parenthesized thing * * Caller must absorb opening parenthesis. * * Combining parenthesis handling with the base level of regular expression * is a trifle forced, but the need to tie the tails of the branches to what * follows makes it hard to avoid. */
ae9a031997-11-07Henrik Grubbström (Grubba) static char *reg(int paren,int *flagp)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  char *ret; char *br; char *ender; int parno=0; /* make gcc happy */ int flags;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *flagp = HASWIDTH; /* Tentatively. */ /* Make an OPEN node, if parenthesized. */ if (paren) { if (regnpar >= NSUBEXP) FAIL("too many ()"); parno = regnpar; regnpar++;
f258372000-09-08Henrik Grubbström (Grubba)  ret = regnode((char)(OPEN + parno));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  } else
bf75192015-04-19Martin Nilsson  ret = NULL;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* Pick up the branches, linking them together. */ br = regbranch(&flags);
bf75192015-04-19Martin Nilsson  if (br == NULL) return (NULL); if (ret != NULL)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regtail(ret, br); /* OPEN -> first. */ else ret = br;
1f9fdb2015-04-28Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (!(flags & HASWIDTH)) *flagp &= ~HASWIDTH; *flagp |= flags & SPSTART;
1f9fdb2015-04-28Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  while (*regparse == OR_OP) { regparse++; br = regbranch(&flags);
bf75192015-04-19Martin Nilsson  if (br == NULL) return (NULL);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regtail(ret, br); /* BRANCH -> BRANCH. */ if (!(flags & HASWIDTH)) *flagp &= ~HASWIDTH; *flagp |= flags & SPSTART; } /* Make a closing node, and hook it on the end. */
a309212000-09-11Henrik Grubbström (Grubba)  ender = regnode((char)((paren) ? (CLOSE + parno) : END));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regtail(ret, ender); /* Hook the tails of the branches to the closing node. */
bf75192015-04-19Martin Nilsson  for (br = ret; br != NULL; br = regnext(br))
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regoptail(br, ender); /* Check for proper termination. */ if (paren && *regparse++ != RBRAC) { FAIL("unmatched ()"); } else if (!paren && *regparse != '\0') { if (*regparse == RBRAC) { FAIL("unmatched ()"); } else FAIL("junk on end");/* "Can't happen". */ /* NOTREACHED */ }
1f9fdb2015-04-28Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (ret); } /* - regbranch - one alternative of an | operator * * Implements the concatenation operator. */
ae9a031997-11-07Henrik Grubbström (Grubba) static char *regbranch(int *flagp)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  char *ret; char *chain; char *latest; int flags;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *flagp = WORST; /* Tentatively. */ ret = regnode(BRANCH);
bf75192015-04-19Martin Nilsson  chain = NULL;
45f4cd2015-04-27Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  while (*regparse != '\0' && *regparse != OR_OP && *regparse != RBRAC) { latest = regpiece(&flags);
bf75192015-04-19Martin Nilsson  if (latest == NULL) return (NULL);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *flagp |= flags & HASWIDTH;
bf75192015-04-19Martin Nilsson  if (chain == NULL) /* First piece. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *flagp |= flags & SPSTART; else regtail(chain, latest); chain = latest; }
bf75192015-04-19Martin Nilsson  if (chain == NULL) /* Loop ran zero times. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regnode(NOTHING); return (ret); } /*
4138da2010-08-16Martin Stjernholm  - regpiece - something followed by possible [*] or [+]
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  * * Note that the branching code sequence used for * is somewhat optimized: * they use the same NOTHING node as both the endmarker for their branch * list and the body of the last branch. It might seem that this node could * be dispensed with entirely, but the endmarker role is not redundant. */
ae9a031997-11-07Henrik Grubbström (Grubba) static char *regpiece(int *flagp)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  char *ret; short op; int flags;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  ret = regatom(&flags);
bf75192015-04-19Martin Nilsson  if (ret == NULL) return (NULL);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  op = *regparse; if (!ISMULT(op)) { *flagp = flags; return (ret); }
1f9fdb2015-04-28Martin Nilsson  /* FIXME: + can not be empty */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (!(flags & HASWIDTH)) FAIL("* or + operand could be empty"); *flagp = (WORST | SPSTART); if(op == ASTERIX) { if (flags & SIMPLE) { reginsert(STAR, ret); } else { /* Emit x* as (x&|), where & means "self". */ reginsert(BRANCH, ret); /* Either x */ regoptail(ret, regnode(BACK)); /* and loop */ regoptail(ret, ret); /* back */ regtail(ret, regnode(BRANCH)); /* or */ regtail(ret, regnode(NOTHING)); /* null. */ } } else if(op == PLUS) {
4138da2010-08-16Martin Stjernholm  if (flags & SIMPLE) { reginsert(KPLUS, ret); } else {
0523132015-04-21Martin Nilsson  /* ret -> 1: x next: 2 * tmp -> 2: BRANCH op: 3 next: 4 * 3: BACK next: 1 * 4: BRANCH op: 5 next: 5
061ce82010-08-16Martin Stjernholm  * 5: NOTHING */
4138da2010-08-16Martin Stjernholm  char *tmp; tmp=regnode(BACK); reginsert(BRANCH, tmp); regtail(ret, tmp); regoptail(tmp, ret); regtail(ret, regnode(BRANCH)); regtail(ret, regnode(NOTHING)); }
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  } regparse++; if (ISMULT(*regparse)) FAIL("nested * or +"); return (ret); } /* - regatom - the lowest level * * Optimization: gobbles an entire sequence of ordinary characters so that * it can turn them into a single node, which is smaller to store and * faster to run. */
ae9a031997-11-07Henrik Grubbström (Grubba) static char *regatom(int *flagp)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  char *ret; int flags;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *flagp = WORST; /* Tentatively. */ switch (*regparse++) { case CARET: ret = regnode(BOL); break; case DOLLAR: ret = regnode(EOL); break; case DOT: ret = regnode(ANY); *flagp |= HASWIDTH | SIMPLE; break; case LSHBRAC: ret = regnode(WORDSTART); break; case RSHBRAC: ret = regnode(WORDEND); break; case LSQBRAC:{
45f4cd2015-04-27Martin Nilsson  int range; int rangeend;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (*regparse == CARET) { /* Complement of range. */ ret = regnode(ANYBUT); regparse++; } else ret = regnode(ANYOF);
1f9fdb2015-04-28Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (*regparse == RSQBRAC || *regparse == '-')
f258372000-09-08Henrik Grubbström (Grubba)  regc((char)(*regparse++));
1f9fdb2015-04-28Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  while (*regparse != '\0' && *regparse != RSQBRAC) { if (*regparse == '-') { regparse++; if (*regparse == RSQBRAC || *regparse == '\0') regc('-'); else {
1f9fdb2015-04-28Martin Nilsson  range = (CHARBITS & *(regparse - 2));
0523132015-04-21Martin Nilsson  rangeend = (CHARBITS & *(regparse));
1f9fdb2015-04-28Martin Nilsson  if (range > rangeend)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  FAIL("invalid [] range");
1f9fdb2015-04-28Martin Nilsson  for (range++; range <= rangeend; range++)
0523132015-04-21Martin Nilsson  regc((char)range);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regparse++; } } else
f258372000-09-08Henrik Grubbström (Grubba)  regc((char)(*regparse++));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  } regc('\0'); if (*regparse != RSQBRAC) FAIL("unmatched []"); regparse++; *flagp |= HASWIDTH | SIMPLE; } break; case LBRAC: ret = reg(1, &flags);
bf75192015-04-19Martin Nilsson  if (ret == NULL) return (NULL);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *flagp |= flags & (HASWIDTH | SPSTART); break; case '\0': case OR_OP: case RBRAC: FAIL("internal urp"); /* Supposed to be caught earlier. */
1f9fdb2015-04-28Martin Nilsson  case PLUS:
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  case ASTERIX:
1f9fdb2015-04-28Martin Nilsson  FAIL("*/+ follows nothing\n");
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  default:{
1f9fdb2015-04-28Martin Nilsson  size_t len;
45f4cd2015-04-27Martin Nilsson  short ender;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regparse--; for (len=0; regparse[len] && !(regparse[len]&SPECIAL) && regparse[len] != RSQBRAC; len++) ; if (len <= 0) FAIL("internal disaster");
1f9fdb2015-04-28Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  ender = *(regparse + len); if (len > 1 && ISMULT(ender))
1f9fdb2015-04-28Martin Nilsson  len--; /* Back off clear of +,* operand. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *flagp |= HASWIDTH; if (len == 1) *flagp |= SIMPLE; ret = regnode(EXACTLY);
1f9fdb2015-04-28Martin Nilsson  for (; len > 0; len--) regc((char)(*regparse++));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regc('\0'); } break; } return (ret); } /* - regnode - emit a node */
b191e61997-09-06Henrik Grubbström (Grubba) static char *regnode(char op)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
1f9fdb2015-04-28Martin Nilsson  char *ret = regcode;
45f4cd2015-04-27Martin Nilsson  char *ptr;
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
1f9fdb2015-04-28Martin Nilsson  if (ret == regdummy) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regsize += 3; return (ret); }
1f9fdb2015-04-28Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  ptr = ret; *ptr++ = op;
c842112015-04-21Martin Nilsson  *ptr++ = '\0'; /* Null "next" pointer. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *ptr++ = '\0'; regcode = ptr; return (ret); } /* - regc - emit (if appropriate) a byte of code */
b191e61997-09-06Henrik Grubbström (Grubba) static void regc(char b)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
1f9fdb2015-04-28Martin Nilsson  if (regcode != regdummy)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  *regcode++ = b; else regsize++; } /* - reginsert - insert an operator in front of already-emitted operand * * Means relocating the operand. */
b191e61997-09-06Henrik Grubbström (Grubba) static void reginsert(char op, char *opnd)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  char *place;
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
1f9fdb2015-04-28Martin Nilsson  if (regcode == regdummy) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regsize += 3; return; }
9191b62015-04-19Martin Nilsson  memmove(opnd+3, opnd, (size_t)(regcode - opnd));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regcode += 3; place = opnd; /* Op node, where operand used to be. */ *place++ = op; *place++ = '\0'; *place++ = '\0'; } /* - regtail - set the next-pointer at the end of a node chain */
61d8cd2015-04-28Martin Nilsson static void regtail(char *p, const char *val)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  char *scan; char *temp; ptrdiff_t offset;
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
1f9fdb2015-04-28Martin Nilsson  if (p == regdummy)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return; /* Find last node. */
1f9fdb2015-04-28Martin Nilsson  for (scan = p; (temp = regnext(scan)) != NULL; scan = temp) continue;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (OP(scan) == BACK) offset = scan - val; else offset = val - scan;
a17d762000-08-11Henrik Grubbström (Grubba)  *(scan + 1) = DO_NOT_WARN((offset >> 8) & 0377); *(scan + 2) = DO_NOT_WARN(offset & 0377);
ab6aec1997-02-11Fredrik Hübinette (Hubbe) } /* - regoptail - regtail on operand of first argument; nop if operandless */
61d8cd2015-04-28Martin Nilsson static void regoptail(char *p, const char *val)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) { /* "Operandless" and "op != BRANCH" are synonymous in practice. */
1f9fdb2015-04-28Martin Nilsson  if (p == NULL || p == regdummy || OP(p) != BRANCH)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return; regtail(OPERAND(p), val); } /* * regexec and friends */ /* * Global work variables for regexec(). */ static char *reginput; /* String-input pointer. */ static char *regbol; /* Beginning of input, for ^ check. */ static char **regstartp; /* Pointer to startp array. */ static char **regendp; /* Ditto for endp. */ /* * Forwards. */
7b06962015-04-19Martin Nilsson static int regtry(regexp *, char *); static int regmatch(char *);
45f4cd2015-04-27Martin Nilsson static size_t regrepeat(const char *);
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
71f3a21998-11-22Fredrik Hübinette (Hubbe) #ifdef PIKE_DEBUG
ab6aec1997-02-11Fredrik Hübinette (Hubbe) int regnarrate = 0;
be478c1997-08-30Henrik Grubbström (Grubba) void regdump(regexp *);
7b06962015-04-19Martin Nilsson static char *regprop(char *op);
ab6aec1997-02-11Fredrik Hübinette (Hubbe) #endif /* - regexec - match a regexp against a string */
21ba561997-02-11Fredrik Hübinette (Hubbe) int pike_regexec(regexp *prog, char *string)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
45f4cd2015-04-27Martin Nilsson  char *s;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* Be paranoid... */
bf75192015-04-19Martin Nilsson  if (prog == NULL || string == NULL) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regerror("NULL parameter"); return (0); }
dd7b3c2003-08-12Martin Nilsson 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* If there is a "must appear" string, look for it. */
9191b62015-04-19Martin Nilsson  if (prog->regmust != NULL && strstr(string, prog->regmust) == NULL) return(0);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* Mark beginning of line for ^ . */ regbol = string; /* Simplest case: anchored match need be tried only once. */ if (prog->reganch) return (regtry(prog, string)); /* Messy cases: unanchored match. */ s = string; if (prog->regstart != '\0')
1f9fdb2015-04-28Martin Nilsson  {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* We know what char it must start with. */
1f9fdb2015-04-28Martin Nilsson  for (s = string; s != NULL; s = strchr(s+1, prog->regstart)) if (regtry(prog, s)) return(1); return(0); }
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  else
1f9fdb2015-04-28Martin Nilsson  {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* We don't -- general case. */
1f9fdb2015-04-28Martin Nilsson  for (s = string; !regtry(prog, s); s++) if (*s == '\0') return(0); return(1); }
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
1f9fdb2015-04-28Martin Nilsson  /* NOTREACHED */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (0); } /* - regtry - try match at specific point */ static int regtry(regexp *prog, char *string) {
45f4cd2015-04-27Martin Nilsson  int i; char **stp; char **enp;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  reginput = string; regstartp = prog->startp; regendp = prog->endp;
0523132015-04-21Martin Nilsson  stp = prog->startp; enp = prog->endp;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  for (i = NSUBEXP; i > 0; i--) {
0523132015-04-21Martin Nilsson  *stp++ = NULL; *enp++ = NULL;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  }
dd7b3c2003-08-12Martin Nilsson  if (regmatch(prog->program)) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  prog->startp[0] = string; prog->endp[0] = reginput; return (1); } else return (0); } /* - regmatch - main matching routine * * Conceptually the strategy is simple: check to see whether the current * node matches, call self recursively to see whether the rest matches, * and then act accordingly. In practice we make some effort to avoid * recursion, in particular by going through "ordinary" nodes (that don't * need to know whether the rest of the match failed) by a loop instead of * by recursion. */ static int regmatch(char *prog) {
45f4cd2015-04-27Martin Nilsson  char *scan; /* Current node. */ char *next; /* next node. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
151a6c2010-08-16Martin Stjernholm  check_c_stack (4 * sizeof (void *));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  scan = prog;
71f3a21998-11-22Fredrik Hübinette (Hubbe) #ifdef PIKE_DEBUG
bf75192015-04-19Martin Nilsson  if (scan != NULL && regnarrate)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  fprintf(stderr, "%s(\n", regprop(scan)); #endif
bf75192015-04-19Martin Nilsson  while (scan != NULL) {
71f3a21998-11-22Fredrik Hübinette (Hubbe) #ifdef PIKE_DEBUG
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (regnarrate) fprintf(stderr, "%s...\n", regprop(scan)); #endif
0523132015-04-21Martin Nilsson  next = regnext(scan);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  switch (OP(scan)) { case BOL: if (reginput != regbol) return (0); break; case EOL: if (*reginput != '\0') return (0); break; case ANY: if (*reginput == '\0') return (0); reginput++; break; case WORDSTART: if (reginput == regbol) break; if (*reginput == '\0' ||
2916001998-01-16Henrik Grubbström (Grubba)  ISWORDPART( *((unsigned char *)reginput-1) ) || !ISWORDPART( *((unsigned char *)reginput) ) )
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (0); break; case WORDEND: if (*reginput == '\0') break; if ( reginput == regbol ||
2916001998-01-16Henrik Grubbström (Grubba)  !ISWORDPART( *((unsigned char *)reginput-1) ) || ISWORDPART( *((unsigned char *)reginput) ) )
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (0); break; case EXACTLY:{
45f4cd2015-04-27Martin Nilsson  ptrdiff_t len; char *opnd;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  opnd = OPERAND(scan); /* Inline the first character, for speed. */ if (*opnd != *reginput) return (0); len = strlen(opnd); if (len > 1 && strncmp(opnd, reginput, len) != 0) return (0); reginput += len; } break; case ANYOF: if (*reginput == '\0' ||
bf75192015-04-19Martin Nilsson  strchr(OPERAND(scan), *reginput) == NULL)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (0); reginput++; break; case ANYBUT: if (*reginput == '\0' ||
bf75192015-04-19Martin Nilsson  strchr(OPERAND(scan), *reginput) != NULL)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (0); reginput++; break; case NOTHING: break; case BACK: break; case BRANCH:{
0523132015-04-21Martin Nilsson  if (OP(next) != BRANCH) /* No choice. */ next = OPERAND(scan); /* Avoid recursion. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  else {
1f9fdb2015-04-28Martin Nilsson  /* FIXME: This loop is different upstream. */ char *save = reginput;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  do { if (regmatch(OPERAND(scan))) return (1); reginput = save; scan = regnext(scan);
bf75192015-04-19Martin Nilsson  } while (scan != NULL && OP(scan) == BRANCH);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (0); /* NOTREACHED */ } } break;
4138da2010-08-16Martin Stjernholm  case KPLUS:
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  case STAR:{
45f4cd2015-04-27Martin Nilsson  char nextch =
0523132015-04-21Martin Nilsson  (OP(next) == EXACTLY) ? *OPERAND(next) : '\0';
45f4cd2015-04-27Martin Nilsson  size_t no; char *save = reginput; size_t minimum = (OP(scan) == STAR) ? 0 : 1;
9191b62015-04-19Martin Nilsson  for(no = regrepeat(OPERAND(scan)) + 1; no > minimum; no--) { reginput = save + no -1;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* If it could work, try it. */ if (nextch == '\0' || *reginput == nextch)
0523132015-04-21Martin Nilsson  if (regmatch(next))
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  return (1); } return (0); } case END: return (1); /* Success! */ default:
bfe7631998-03-25Fredrik Hübinette (Hubbe)  if(OP(scan) >= OPEN && OP(scan)<OPEN+NSUBEXP) {
1f9fdb2015-04-28Martin Nilsson  int no = OP(scan) - OPEN; char *input = reginput;
bfe7631998-03-25Fredrik Hübinette (Hubbe) 
0523132015-04-21Martin Nilsson  if (regmatch(next)) {
bfe7631998-03-25Fredrik Hübinette (Hubbe)  /* * Don't set startp if some later invocation of the same * parentheses already has. */
bf75192015-04-19Martin Nilsson  if (regstartp[no] == NULL)
0523132015-04-21Martin Nilsson  regstartp[no] = input;
bfe7631998-03-25Fredrik Hübinette (Hubbe)  return (1); } else return (0); } if(OP(scan) >= CLOSE && OP(scan)<CLOSE+NSUBEXP) {
1f9fdb2015-04-28Martin Nilsson  int no = OP(scan) - CLOSE; char *input = reginput;
bfe7631998-03-25Fredrik Hübinette (Hubbe) 
0523132015-04-21Martin Nilsson  if (regmatch(next)) {
bfe7631998-03-25Fredrik Hübinette (Hubbe)  /* * Don't set endp if some later invocation of the same * parentheses already has. */
bf75192015-04-19Martin Nilsson  if (regendp[no] == NULL)
0523132015-04-21Martin Nilsson  regendp[no] = input;
bfe7631998-03-25Fredrik Hübinette (Hubbe)  return (1); } else return (0); }
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regerror("memory corruption"); return (0); }
0523132015-04-21Martin Nilsson  scan = next;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  } /* * We get here only if there's trouble -- normally "case END" is the * terminating point. */ regerror("corrupted pointers"); return (0); } /* - regrepeat - repeatedly match something simple, report how many */
45f4cd2015-04-27Martin Nilsson static size_t regrepeat(const char *node)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
9191b62015-04-19Martin Nilsson  switch (OP(node)) {
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  case ANY:
9191b62015-04-19Martin Nilsson  return(strlen(reginput));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  break; case EXACTLY:
1f9fdb2015-04-28Martin Nilsson  { char *scan; char ch = *OPERAND(node); size_t count = 0;
9191b62015-04-19Martin Nilsson  for (scan = reginput; *scan == ch; scan++) count++; return(count);
1f9fdb2015-04-28Martin Nilsson  } break;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  case ANYOF:
9191b62015-04-19Martin Nilsson  return(strspn(reginput, OPERAND(node)));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  break; case ANYBUT:
9191b62015-04-19Martin Nilsson  return(strcspn(reginput, OPERAND(node)));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  break; default: /* Oh dear. Called inappropriately. */ regerror("internal foulup");
9191b62015-04-19Martin Nilsson  return(0); /* Best compromise. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  break; }
9191b62015-04-19Martin Nilsson  /* NOREACHED */
ab6aec1997-02-11Fredrik Hübinette (Hubbe) } /*
c842112015-04-21Martin Nilsson  - regnext - dig the "next" pointer out of a node
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  */
45f4cd2015-04-27Martin Nilsson static char *regnext(char *p)
ab6aec1997-02-11Fredrik Hübinette (Hubbe) {
1f9fdb2015-04-28Martin Nilsson  int offset = NEXT(p);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (offset == 0)
bf75192015-04-19Martin Nilsson  return (NULL);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  if (OP(p) == BACK) return (p - offset); else return (p + offset); }
71f3a21998-11-22Fredrik Hübinette (Hubbe) #ifdef PIKE_DEBUG
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
7b06962015-04-19Martin Nilsson static char *regprop(char *);
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  /* - regdump - dump a regexp onto stdout in vaguely comprehensible form */ void regdump(regexp *r) {
45f4cd2015-04-27Martin Nilsson  char *s; char op = EXACTLY; /* Arbitrary non-END op. */ char *next;
ab6aec1997-02-11Fredrik Hübinette (Hubbe) 
dd7b3c2003-08-12Martin Nilsson  s = r->program;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  while (op != END) { /* While that wasn't END last time... */ op = OP(s);
a17d762000-08-11Henrik Grubbström (Grubba)  printf("%2ld%s", /* Where, what. */ DO_NOT_WARN((long)(s - r->program)), regprop(s));
0523132015-04-21Martin Nilsson  next = regnext(s); if (next == NULL) /* next ptr. */
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  printf("(0)"); else
a17d762000-08-11Henrik Grubbström (Grubba)  printf("(%ld)",
0523132015-04-21Martin Nilsson  DO_NOT_WARN((long)( (s - r->program) + (next - s))));
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  s += 3; if (op == ANYOF || op == ANYBUT || op == EXACTLY) { /* Literal string, where present. */ while (*s != '\0') { putchar(*s); s++; } s++; } putchar('\n'); } /* Header fields of interest. */ if (r->regstart != '\0') printf("start `%c' ", r->regstart); if (r->reganch) printf("anchored ");
bf75192015-04-19Martin Nilsson  if (r->regmust != NULL)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  printf("must have \"%s\"", r->regmust); printf("\n"); } /* - regprop - printable representation of opcode */ static char *regprop(char *op) {
45f4cd2015-04-27Martin Nilsson  char *p;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  static char buf[50]; strcpy(buf, ":"); switch (OP(op)) { case BOL: p = "BOL"; break; case EOL: p = "EOL"; break; case ANY: p = "ANY"; break; case ANYOF: p = "ANYOF"; break; case ANYBUT: p = "ANYBUT"; break; case BRANCH: p = "BRANCH"; break; case EXACTLY: p = "EXACTLY"; break; case NOTHING: p = "NOTHING"; break; case BACK: p = "BACK"; break; case END: p = "END"; break;
bfe7631998-03-25Fredrik Hübinette (Hubbe) 
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  case STAR: p = "STAR"; break;
bfe7631998-03-25Fredrik Hübinette (Hubbe) 
4138da2010-08-16Martin Stjernholm  case KPLUS: p = "KPLUS"; break;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  default:
bfe7631998-03-25Fredrik Hübinette (Hubbe)  if(OP(op) >= OPEN && OP(op) < OPEN+NSUBEXP) { sprintf(buf + strlen(buf), "OPEN%d", OP(op) - OPEN);
bf75192015-04-19Martin Nilsson  p = NULL;
bfe7631998-03-25Fredrik Hübinette (Hubbe)  break; } if(OP(op) >= CLOSE && OP(op) < CLOSE+NSUBEXP) { sprintf(buf + strlen(buf), "CLOSE%d", OP(op) - CLOSE);
bf75192015-04-19Martin Nilsson  p = NULL;
bfe7631998-03-25Fredrik Hübinette (Hubbe)  break; }
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  regerror("corrupted opcode");
bf75192015-04-19Martin Nilsson  p=NULL;
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  break; }
bf75192015-04-19Martin Nilsson  if (p != NULL)
ab6aec1997-02-11Fredrik Hübinette (Hubbe)  strcat(buf, p); return (buf); } #endif