/*
* TclRegComp and TclRegExec -- TclRegSub is elsewhere
*
* 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.
*
* 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.
*
* *** NOTE: this code has been altered slightly for use in Tcl: ***
* *** 1. Use ckalloc and ckfree instead of malloc and free. ***
* *** 2. Add extra argument to regexp to specify the real ***
* *** start of the string separately from the start of the ***
* *** current search. This is needed to search for multiple ***
* *** matches within a string. ***
* *** 3. Names have been changed, e.g. from regcomp to ***
* *** TclRegComp, to avoid clashes with other ***
* *** regexp implementations used by applications. ***
* *** 4. Added errMsg declaration and TclRegError procedure ***
* *** 5. Various lint-like things, such as casting arguments ***
* *** in procedure calls. ***
*
* *** NOTE: This code has been altered for use in MT-Sturdy Tcl ***
* *** 1. All use of static variables has been changed to access ***
* *** fields of a structure. ***
* *** 2. This in addition to changes to TclRegError makes the ***
* *** code multi-thread safe. ***
*
* SCCS: @(#) regexp.c 1.12 96/04/02 13:54:57
*/
#include "tclInt.h"
#include "tclPort.h"
/*
* The variable below is set to NULL before invoking regexp functions
* and checked after those functions. If an error occurred then TclRegError
* will set the variable to point to a (static) error message. This
* mechanism unfortunately does not support multi-threading, but the
* procedures TclRegError and TclGetRegError can be modified to use
* thread-specific storage for the variable and thereby make the code
* thread-safe.
*/
/*
* 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 TclRegComp() 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 TclRegExec() needs it and TclRegComp() 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
* plus a "next" pointer, possibly plus an operand. "Next" pointers of
* all nodes except BRANCH implement concatenation; a "next" pointer with
* 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:
*/
/* definition number opnd? meaning */
/* OPEN+1 is number 1, etc. */
/*
* Opcode notes:
*
* BRANCH The set of branches constituting a single choice are hooked
* together with their "next" pointers, since precedence prevents
* anything being concatenated to any individual branch. The
* "next" pointer of the last BRANCH in a choice points to the
* thing following the whole choice. This is also where the
* final "next" pointer of each individual branch points; each
* branch starts with the operand node of a BRANCH node.
*
* BACK Normal "next" pointers all implicitly point forward; BACK
* exists to make loop structures possible.
*
* STAR,PLUS '?', and complex '*' and '+', are implemented as circular
* BRANCH structures using BACK. Simple cases (one character
* per match) are implemented with STAR and PLUS for speed
* and to minimize recursive plunges.
*
* OPEN,CLOSE ...are numbered at compile time.
*/
/*
* 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
* 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.)
*
* Using two bytes for the "next" pointer is vast overkill for most things,
* but allows patterns to get big without disasters.
*/
#define OP(p) (*(p))
/*
* See regmagic.h for one further detail of program structure.
*/
/*
* Utility definitions.
*/
#ifndef CHARBITS
#define UCHARAT(p) ((int)*(unsigned char *)(p))
#else
#endif
/*
* Flags to be passed up and down.
*/
/*
* Global work variables for TclRegComp().
*/
struct regcomp_state {
};
static char regdummy;
/*
* The first byte of the regexp internal "program" is actually this magic
* number; the start node begins in the second byte.
*/
/*
* Forward declarations for TclRegComp()'s friends.
*/
struct regcomp_state *rcstate));
struct regcomp_state *rcstate));
struct regcomp_state *rcstate));
static void regc _ANSI_ARGS_((int b,
struct regcomp_state *rcstate));
struct regcomp_state *rcstate));
static char * regnext _ANSI_ARGS_((char *p));
struct regcomp_state *rcstate));
struct regcomp_state *rcstate));
#ifdef STRCSPN
#endif
/*
- TclRegComp - 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.
*/
regexp *
char *exp;
{
register regexp *r;
register char *scan;
register char *longest;
register int len;
int flags;
FAIL("NULL argument");
/* First pass: determine size, legality. */
return(NULL);
/* Small enough for pointer-storage convention? */
FAIL("regexp too big");
/* Allocate space. */
if (r == NULL)
FAIL("out of space");
/* Second pass: emit code. */
return(NULL);
/* Dig out information for optimizations. */
r->reganch = 0;
r->regmlen = 0;
/* Starting-point info. */
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.
*/
len = 0;
}
}
}
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.
*/
static char *
int paren; /* Parenthesized? */
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char *br;
register char *ender;
register int parno = 0;
int flags;
/* Make an OPEN node, if parenthesized. */
if (paren) {
FAIL("too many ()");
} else
/* Pick up the branches, linking them together. */
return(NULL);
else
return(NULL);
}
/* Make a closing node, and hook it on the end. */
/* Hook the tails of the branches to the closing node. */
/* Check for proper termination. */
FAIL("unmatched ()");
FAIL("unmatched ()");
} else
/* NOTREACHED */
}
return(ret);
}
/*
- regbranch - one alternative of an | operator
*
* Implements the concatenation operator.
*/
static char *
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char *chain;
register char *latest;
int flags;
return(NULL);
else
}
return(ret);
}
/*
- regpiece - something followed by possible [*+?]
*
* Note that the branching code sequences used for ? and the general cases
* of * and + are 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.
*/
static char *
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char op;
register char *next;
int flags;
return(NULL);
return(ret);
}
FAIL("*+ operand could be empty");
else if (op == '*') {
/* Emit x* as (x&|), where & means "self". */
else if (op == '+') {
/* Emit x+ as x(&|), where & means "self". */
} else if (op == '?') {
/* Emit x? as (x|) */
}
FAIL("nested *?+");
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. Backslashed characters are exceptions, each becoming a
* separate node; the code is simpler that way and it's not worth fixing.
*/
static char *
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
int flags;
case '^':
break;
case '$':
break;
case '.':
break;
case '[': {
register int clss;
register int classend;
} else
else {
FAIL("invalid [] range");
}
} else
}
FAIL("unmatched []");
}
break;
case '(':
return(NULL);
break;
case '\0':
case '|':
case ')':
/* NOTREACHED */
break;
case '?':
case '+':
case '*':
FAIL("?+* follows nothing");
/* NOTREACHED */
break;
case '\\':
FAIL("trailing \\");
break;
default: {
register int len;
register char ender;
if (len <= 0)
FAIL("internal disaster");
len--; /* Back off clear of ?+* operand. */
if (len == 1)
while (len > 0) {
len--;
}
}
break;
}
return(ret);
}
/*
- regnode - emit a node
*/
static char * /* Location. */
int op;
struct regcomp_state *rcstate;
{
register char *ret;
register char *ptr;
return(ret);
}
*ptr++ = '\0';
return(ret);
}
/*
- regc - emit (if appropriate) a byte of code
*/
static void
int b;
struct regcomp_state *rcstate;
{
else
}
/*
- reginsert - insert an operator in front of already-emitted operand
*
* Means relocating the operand.
*/
static void
int op;
char *opnd;
struct regcomp_state *rcstate;
{
register char *src;
register char *dst;
register char *place;
return;
}
*place++ = '\0';
*place = '\0';
}
/*
- regtail - set the next-pointer at the end of a node chain
*/
static void
char *p;
char *val;
{
register char *scan;
register char *temp;
register int offset;
if (p == ®dummy)
return;
/* Find last node. */
scan = p;
for (;;) {
break;
}
else
}
/*
- regoptail - regtail on operand of first argument; nop if operandless
*/
static void
char *p;
char *val;
{
/* "Operandless" and "op != BRANCH" are synonymous in practice. */
return;
}
/*
* TclRegExec and friends
*/
/*
* Global work variables for TclRegExec().
*/
struct regexec_state {
};
/*
* Forwards.
*/
struct regexec_state *restate));
struct regexec_state *restate));
static int regrepeat _ANSI_ARGS_((char *p,
struct regexec_state *restate));
#ifdef DEBUG
int regnarrate = 0;
#endif
/*
- TclRegExec - match a regexp against a string
*/
int
register char *string;
char *start;
{
register char *s;
/* Be paranoid... */
TclRegError("NULL parameter");
return(0);
}
/* Check validity of program. */
TclRegError("corrupted program");
return(0);
}
/* If there is a "must appear" string, look for it. */
s = string;
== 0)
break; /* Found it. */
s++;
}
if (s == NULL) /* Not present. */
return(0);
}
/* Mark beginning of line for ^ . */
/* Simplest case: anchored match need be tried only once. */
/* Messy cases: unanchored match. */
s = string;
/* We know what char it must start with. */
return(1);
s++;
}
else
/* We don't -- general case. */
do {
return(1);
} while (*s++ != '\0');
/* Failure. */
return(0);
}
/*
- regtry - try match at specific point
*/
static int /* 0 failure, 1 success */
char *string;
struct regexec_state *restate;
{
register int i;
register char **sp;
register char **ep;
for (i = NSUBEXP; i > 0; i--) {
}
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 /* 0 failure, 1 success */
char *prog;
struct regexec_state *restate;
{
#ifdef DEBUG
#endif
#ifdef DEBUG
if (regnarrate)
#endif
case BOL:
return 0;
}
break;
case EOL:
return 0;
}
break;
case ANY:
return 0;
}
break;
case EXACTLY: {
register int len;
register char *opnd;
/* Inline the first character, for speed. */
return 0 ;
}
!= 0) {
return 0;
}
break;
}
case ANYOF:
return 0;
}
break;
case ANYBUT:
return 0;
}
break;
case NOTHING:
break;
case BACK:
break;
case OPEN+1:
case OPEN+2:
case OPEN+3:
case OPEN+4:
case OPEN+5:
case OPEN+6:
case OPEN+7:
case OPEN+8:
case OPEN+9: {
register int no;
register char *save;
/*
* Don't set startp if some later invocation of the
* same parentheses already has.
*/
}
return 1;
} else {
return 0;
}
}
case CLOSE+1:
case CLOSE+2:
case CLOSE+3:
case CLOSE+4:
case CLOSE+5:
case CLOSE+6:
case CLOSE+7:
case CLOSE+8:
case CLOSE+9: {
register int no;
register char *save;
/*
* Don't set endp if some later
* invocation of the same parentheses
* already has.
*/
return 1;
} else {
return 0;
}
}
case BRANCH: {
register char *save;
} else {
do {
return(1);
return 0;
}
break;
}
case STAR:
case PLUS: {
register char nextch;
register int no;
register char *save;
register int min;
/*
* Lookahead to avoid useless match attempts
* when we know what character comes next.
*/
nextch = '\0';
/* If it could work, try it. */
return(1);
/* Couldn't or didn't -- back up. */
no--;
}
return(0);
}
case END:
return(1); /* Success! */
default:
goto doOpen;
goto doClose;
}
TclRegError("memory corruption");
return 0;
}
}
/*
* We get here only if there's trouble -- normally "case END" is
* the terminating point.
*/
TclRegError("corrupted pointers");
return(0);
}
/*
- regrepeat - repeatedly match something simple, report how many
*/
static int
char *p;
struct regexec_state *restate;
{
register int count = 0;
register char *scan;
register char *opnd;
switch (OP(p)) {
case ANY:
break;
case EXACTLY:
count++;
scan++;
}
break;
case ANYOF:
count++;
scan++;
}
break;
case ANYBUT:
count++;
scan++;
}
break;
default: /* Oh dear. Called inappropriately. */
TclRegError("internal foulup");
count = 0; /* Best compromise. */
break;
}
return(count);
}
/*
- regnext - dig the "next" pointer out of a node
*/
static char *
regnext(p)
register char *p;
{
register int offset;
if (p == ®dummy)
return(NULL);
if (offset == 0)
return(NULL);
return(p-offset);
else
return(p+offset);
}
#ifdef DEBUG
static char *regprop();
/*
- regdump - dump a regexp onto stdout in vaguely comprehensible form
*/
void
regdump(r)
regexp *r;
{
register char *s;
register char *next;
s = r->program + 1;
printf("(0)");
else
s += 3;
/* Literal string, where present. */
while (*s != '\0') {
putchar(*s);
s++;
}
s++;
}
putchar('\n');
}
/* Header fields of interest. */
if (r->regstart != '\0')
if (r->reganch)
printf("anchored ");
printf("\n");
}
/*
- regprop - printable representation of opcode
*/
static char *
char *op;
{
register char *p;
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;
case OPEN+1:
case OPEN+2:
case OPEN+3:
case OPEN+4:
case OPEN+5:
case OPEN+6:
case OPEN+7:
case OPEN+8:
case OPEN+9:
p = NULL;
break;
case CLOSE+1:
case CLOSE+2:
case CLOSE+3:
case CLOSE+4:
case CLOSE+5:
case CLOSE+6:
case CLOSE+7:
case CLOSE+8:
case CLOSE+9:
p = NULL;
break;
case STAR:
p = "STAR";
break;
case PLUS:
p = "PLUS";
break;
default:
p = NULL;
break;
p = NULL;
} else {
TclRegError("corrupted opcode");
}
break;
}
if (p != NULL)
return(buf);
}
#endif
/*
* The following is provided for those people who do not have strcspn() in
* their C libraries. They should get off their butts and do something
* about it; at least one public-domain implementation of those (highly
* useful) string routines has been published on Usenet.
*/
#ifdef STRCSPN
/*
* strcspn - find length of initial segment of s1 consisting entirely
* of characters not from s2
*/
static int
char *s1;
char *s2;
{
register char *scan1;
register char *scan2;
register int count;
count = 0;
return(count);
count++;
}
return(count);
}
#endif
/*
*----------------------------------------------------------------------
*
* TclRegError --
*
* This procedure is invoked by the regexp code when an error
* occurs. It saves the error message so it can be seen by the
* code that called Spencer's code.
*
* Results:
* None.
*
* Side effects:
* The value of "string" is saved in "errMsg".
*
*----------------------------------------------------------------------
*/
void
char *string; /* Error message. */
{
}
char *
{
return errMsg;
}