/*
|
/*
|
* TclRegComp and TclRegExec -- TclRegSub is elsewhere
|
* TclRegComp and TclRegExec -- TclRegSub is elsewhere
|
*
|
*
|
* Copyright (c) 1986 by University of Toronto.
|
* Copyright (c) 1986 by University of Toronto.
|
* Written by Henry Spencer. Not derived from licensed software.
|
* Written by Henry Spencer. Not derived from licensed software.
|
*
|
*
|
* Permission is granted to anyone to use this software for any
|
* Permission is granted to anyone to use this software for any
|
* purpose on any computer system, and to redistribute it freely,
|
* purpose on any computer system, and to redistribute it freely,
|
* subject to the following restrictions:
|
* subject to the following restrictions:
|
*
|
*
|
* 1. The author is not responsible for the consequences of use of
|
* 1. The author is not responsible for the consequences of use of
|
* this software, no matter how awful, even if they arise
|
* this software, no matter how awful, even if they arise
|
* from defects in it.
|
* from defects in it.
|
*
|
*
|
* 2. The origin of this software must not be misrepresented, either
|
* 2. The origin of this software must not be misrepresented, either
|
* by explicit claim or by omission.
|
* by explicit claim or by omission.
|
*
|
*
|
* 3. Altered versions must be plainly marked as such, and must not
|
* 3. Altered versions must be plainly marked as such, and must not
|
* be misrepresented as being the original software.
|
* be misrepresented as being the original software.
|
*
|
*
|
* Beware that some of this code is subtly aware of the way operator
|
* Beware that some of this code is subtly aware of the way operator
|
* precedence is structured in regular expressions. Serious changes in
|
* precedence is structured in regular expressions. Serious changes in
|
* regular-expression syntax might require a total rethink.
|
* regular-expression syntax might require a total rethink.
|
*
|
*
|
* *** NOTE: this code has been altered slightly for use in Tcl: ***
|
* *** NOTE: this code has been altered slightly for use in Tcl: ***
|
* *** 1. Use ckalloc and ckfree instead of malloc and free. ***
|
* *** 1. Use ckalloc and ckfree instead of malloc and free. ***
|
* *** 2. Add extra argument to regexp to specify the real ***
|
* *** 2. Add extra argument to regexp to specify the real ***
|
* *** start of the string separately from the start of the ***
|
* *** start of the string separately from the start of the ***
|
* *** current search. This is needed to search for multiple ***
|
* *** current search. This is needed to search for multiple ***
|
* *** matches within a string. ***
|
* *** matches within a string. ***
|
* *** 3. Names have been changed, e.g. from regcomp to ***
|
* *** 3. Names have been changed, e.g. from regcomp to ***
|
* *** TclRegComp, to avoid clashes with other ***
|
* *** TclRegComp, to avoid clashes with other ***
|
* *** regexp implementations used by applications. ***
|
* *** regexp implementations used by applications. ***
|
* *** 4. Added errMsg declaration and TclRegError procedure ***
|
* *** 4. Added errMsg declaration and TclRegError procedure ***
|
* *** 5. Various lint-like things, such as casting arguments ***
|
* *** 5. Various lint-like things, such as casting arguments ***
|
* *** in procedure calls. ***
|
* *** in procedure calls. ***
|
*
|
*
|
* *** NOTE: This code has been altered for use in MT-Sturdy Tcl ***
|
* *** NOTE: This code has been altered for use in MT-Sturdy Tcl ***
|
* *** 1. All use of static variables has been changed to access ***
|
* *** 1. All use of static variables has been changed to access ***
|
* *** fields of a structure. ***
|
* *** fields of a structure. ***
|
* *** 2. This in addition to changes to TclRegError makes the ***
|
* *** 2. This in addition to changes to TclRegError makes the ***
|
* *** code multi-thread safe. ***
|
* *** code multi-thread safe. ***
|
*
|
*
|
* RCS: @(#) $Id: regexp.c,v 1.1.1.1 2002-01-16 10:25:25 markom Exp $
|
* RCS: @(#) $Id: regexp.c,v 1.1.1.1 2002-01-16 10:25:25 markom Exp $
|
*/
|
*/
|
|
|
#include "tclInt.h"
|
#include "tclInt.h"
|
#include "tclPort.h"
|
#include "tclPort.h"
|
|
|
/*
|
/*
|
* The variable below is set to NULL before invoking regexp functions
|
* The variable below is set to NULL before invoking regexp functions
|
* and checked after those functions. If an error occurred then TclRegError
|
* and checked after those functions. If an error occurred then TclRegError
|
* will set the variable to point to a (static) error message. This
|
* will set the variable to point to a (static) error message. This
|
* mechanism unfortunately does not support multi-threading, but the
|
* mechanism unfortunately does not support multi-threading, but the
|
* procedures TclRegError and TclGetRegError can be modified to use
|
* procedures TclRegError and TclGetRegError can be modified to use
|
* thread-specific storage for the variable and thereby make the code
|
* thread-specific storage for the variable and thereby make the code
|
* thread-safe.
|
* thread-safe.
|
*/
|
*/
|
|
|
static char *errMsg = NULL;
|
static char *errMsg = NULL;
|
|
|
/*
|
/*
|
* The "internal use only" fields in regexp.h are present to pass info from
|
* 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
|
* compile to execute that permits the execute phase to run lots faster on
|
* simple cases. They are:
|
* simple cases. They are:
|
*
|
*
|
* regstart char that must begin a match; '\0' if none obvious
|
* regstart char that must begin a match; '\0' if none obvious
|
* reganch is the match anchored (at beginning-of-line only)?
|
* reganch is the match anchored (at beginning-of-line only)?
|
* regmust string (pointer into program) that match must include, or NULL
|
* regmust string (pointer into program) that match must include, or NULL
|
* regmlen length of regmust string
|
* regmlen length of regmust string
|
*
|
*
|
* Regstart and reganch permit very fast decisions on suitable starting points
|
* Regstart and reganch permit very fast decisions on suitable starting points
|
* for a match, cutting down the work a lot. Regmust permits fast rejection
|
* 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
|
* of lines that cannot possibly match. The regmust tests are costly enough
|
* that TclRegComp() supplies a regmust only if the r.e. contains something
|
* that TclRegComp() supplies a regmust only if the r.e. contains something
|
* potentially expensive (at present, the only such thing detected is * or +
|
* 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
|
* 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
|
* supplied because the test in TclRegExec() needs it and TclRegComp() is
|
* computing it anyway.
|
* computing it anyway.
|
*/
|
*/
|
|
|
/*
|
/*
|
* Structure for regexp "program". This is essentially a linear encoding
|
* Structure for regexp "program". This is essentially a linear encoding
|
* of a nondeterministic finite-state machine (aka syntax charts or
|
* of a nondeterministic finite-state machine (aka syntax charts or
|
* "railroad normal form" in parsing technology). Each node is an opcode
|
* "railroad normal form" in parsing technology). Each node is an opcode
|
* plus a "next" pointer, possibly plus an operand. "Next" pointers of
|
* plus a "next" pointer, possibly plus an operand. "Next" pointers of
|
* all nodes except BRANCH implement concatenation; a "next" pointer with
|
* all nodes except BRANCH implement concatenation; a "next" pointer with
|
* a BRANCH on both ends of it is connecting two alternatives. (Here we
|
* a BRANCH on both ends of it is connecting two alternatives. (Here we
|
* have one of the subtle syntax dependencies: an individual BRANCH (as
|
* have one of the subtle syntax dependencies: an individual BRANCH (as
|
* opposed to a collection of them) is never concatenated with anything
|
* opposed to a collection of them) is never concatenated with anything
|
* because of operator precedence.) The operand of some types of node is
|
* 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
|
* 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.
|
* 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
|
* (NB this is *not* a tree structure: the tail of the branch connects
|
* to the thing following the set of BRANCHes.) The opcodes are:
|
* to the thing following the set of BRANCHes.) The opcodes are:
|
*/
|
*/
|
|
|
/* definition number opnd? meaning */
|
/* definition number opnd? meaning */
|
#define END 0 /* no End of program. */
|
#define END 0 /* no End of program. */
|
#define BOL 1 /* no Match "" at beginning of line. */
|
#define BOL 1 /* no Match "" at beginning of line. */
|
#define EOL 2 /* no Match "" at end of line. */
|
#define EOL 2 /* no Match "" at end of line. */
|
#define ANY 3 /* no Match any one character. */
|
#define ANY 3 /* no Match any one character. */
|
#define ANYOF 4 /* str Match any character in this string. */
|
#define ANYOF 4 /* str Match any character in this string. */
|
#define ANYBUT 5 /* str Match any character not in this string. */
|
#define ANYBUT 5 /* str Match any character not in this string. */
|
#define BRANCH 6 /* node Match this alternative, or the next... */
|
#define BRANCH 6 /* node Match this alternative, or the next... */
|
#define BACK 7 /* no Match "", "next" ptr points backward. */
|
#define BACK 7 /* no Match "", "next" ptr points backward. */
|
#define EXACTLY 8 /* str Match this string. */
|
#define EXACTLY 8 /* str Match this string. */
|
#define NOTHING 9 /* no Match empty string. */
|
#define NOTHING 9 /* no Match empty string. */
|
#define STAR 10 /* node Match this (simple) thing 0 or more times. */
|
#define STAR 10 /* node Match this (simple) thing 0 or more times. */
|
#define PLUS 11 /* node Match this (simple) thing 1 or more times. */
|
#define PLUS 11 /* node Match this (simple) thing 1 or more times. */
|
#define OPEN 20 /* no Mark this point in input as start of #n. */
|
#define OPEN 20 /* no Mark this point in input as start of #n. */
|
/* OPEN+1 is number 1, etc. */
|
/* OPEN+1 is number 1, etc. */
|
#define CLOSE (OPEN+NSUBEXP) /* no Analogous to OPEN. */
|
#define CLOSE (OPEN+NSUBEXP) /* no Analogous to OPEN. */
|
|
|
/*
|
/*
|
* Opcode notes:
|
* Opcode notes:
|
*
|
*
|
* BRANCH The set of branches constituting a single choice are hooked
|
* BRANCH The set of branches constituting a single choice are hooked
|
* together with their "next" pointers, since precedence prevents
|
* together with their "next" pointers, since precedence prevents
|
* anything being concatenated to any individual branch. The
|
* anything being concatenated to any individual branch. The
|
* "next" pointer of the last BRANCH in a choice points to the
|
* "next" pointer of the last BRANCH in a choice points to the
|
* thing following the whole choice. This is also where the
|
* thing following the whole choice. This is also where the
|
* final "next" pointer of each individual branch points; each
|
* final "next" pointer of each individual branch points; each
|
* branch starts with the operand node of a BRANCH node.
|
* branch starts with the operand node of a BRANCH node.
|
*
|
*
|
* BACK Normal "next" pointers all implicitly point forward; BACK
|
* BACK Normal "next" pointers all implicitly point forward; BACK
|
* exists to make loop structures possible.
|
* exists to make loop structures possible.
|
*
|
*
|
* STAR,PLUS '?', and complex '*' and '+', are implemented as circular
|
* STAR,PLUS '?', and complex '*' and '+', are implemented as circular
|
* BRANCH structures using BACK. Simple cases (one character
|
* BRANCH structures using BACK. Simple cases (one character
|
* per match) are implemented with STAR and PLUS for speed
|
* per match) are implemented with STAR and PLUS for speed
|
* and to minimize recursive plunges.
|
* and to minimize recursive plunges.
|
*
|
*
|
* OPEN,CLOSE ...are numbered at compile time.
|
* OPEN,CLOSE ...are numbered at compile time.
|
*/
|
*/
|
|
|
/*
|
/*
|
* A node is one char of opcode followed by two chars of "next" pointer.
|
* 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
|
* "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.
|
* 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
|
* An operand, if any, simply follows the node. (Note that much of the
|
* code generation knows about this implicit relationship.)
|
* code generation knows about this implicit relationship.)
|
*
|
*
|
* Using two bytes for the "next" pointer is vast overkill for most things,
|
* Using two bytes for the "next" pointer is vast overkill for most things,
|
* but allows patterns to get big without disasters.
|
* but allows patterns to get big without disasters.
|
*/
|
*/
|
#define OP(p) (*(p))
|
#define OP(p) (*(p))
|
#define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
|
#define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
|
#define OPERAND(p) ((p) + 3)
|
#define OPERAND(p) ((p) + 3)
|
|
|
/*
|
/*
|
* See regmagic.h for one further detail of program structure.
|
* See regmagic.h for one further detail of program structure.
|
*/
|
*/
|
|
|
|
|
/*
|
/*
|
* Utility definitions.
|
* Utility definitions.
|
*/
|
*/
|
#ifndef CHARBITS
|
#ifndef CHARBITS
|
#define UCHARAT(p) ((int)*(unsigned char *)(p))
|
#define UCHARAT(p) ((int)*(unsigned char *)(p))
|
#else
|
#else
|
#define UCHARAT(p) ((int)*(p)&CHARBITS)
|
#define UCHARAT(p) ((int)*(p)&CHARBITS)
|
#endif
|
#endif
|
|
|
#define FAIL(m) { TclRegError(m); return(NULL); }
|
#define FAIL(m) { TclRegError(m); return(NULL); }
|
#define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?')
|
#define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?')
|
#define META "^$.[()|?+*\\"
|
#define META "^$.[()|?+*\\"
|
|
|
/*
|
/*
|
* Flags to be passed up and down.
|
* Flags to be passed up and down.
|
*/
|
*/
|
#define HASWIDTH 01 /* Known never to match null string. */
|
#define HASWIDTH 01 /* Known never to match null string. */
|
#define SIMPLE 02 /* Simple enough to be STAR/PLUS operand. */
|
#define SIMPLE 02 /* Simple enough to be STAR/PLUS operand. */
|
#define SPSTART 04 /* Starts with * or +. */
|
#define SPSTART 04 /* Starts with * or +. */
|
#define WORST 0 /* Worst case. */
|
#define WORST 0 /* Worst case. */
|
|
|
/*
|
/*
|
* Global work variables for TclRegComp().
|
* Global work variables for TclRegComp().
|
*/
|
*/
|
struct regcomp_state {
|
struct regcomp_state {
|
char *regparse; /* Input-scan pointer. */
|
char *regparse; /* Input-scan pointer. */
|
int regnpar; /* () count. */
|
int regnpar; /* () count. */
|
char *regcode; /* Code-emit pointer; ®dummy = don't. */
|
char *regcode; /* Code-emit pointer; ®dummy = don't. */
|
long regsize; /* Code size. */
|
long regsize; /* Code size. */
|
};
|
};
|
|
|
static char regdummy;
|
static char regdummy;
|
|
|
/*
|
/*
|
* The first byte of the regexp internal "program" is actually this magic
|
* The first byte of the regexp internal "program" is actually this magic
|
* number; the start node begins in the second byte.
|
* number; the start node begins in the second byte.
|
*/
|
*/
|
#define MAGIC 0234
|
#define MAGIC 0234
|
|
|
|
|
/*
|
/*
|
* Forward declarations for TclRegComp()'s friends.
|
* Forward declarations for TclRegComp()'s friends.
|
*/
|
*/
|
|
|
static char * reg _ANSI_ARGS_((int paren, int *flagp,
|
static char * reg _ANSI_ARGS_((int paren, int *flagp,
|
struct regcomp_state *rcstate));
|
struct regcomp_state *rcstate));
|
static char * regatom _ANSI_ARGS_((int *flagp,
|
static char * regatom _ANSI_ARGS_((int *flagp,
|
struct regcomp_state *rcstate));
|
struct regcomp_state *rcstate));
|
static char * regbranch _ANSI_ARGS_((int *flagp,
|
static char * regbranch _ANSI_ARGS_((int *flagp,
|
struct regcomp_state *rcstate));
|
struct regcomp_state *rcstate));
|
static void regc _ANSI_ARGS_((int b,
|
static void regc _ANSI_ARGS_((int b,
|
struct regcomp_state *rcstate));
|
struct regcomp_state *rcstate));
|
static void reginsert _ANSI_ARGS_((int op, char *opnd,
|
static void reginsert _ANSI_ARGS_((int op, char *opnd,
|
struct regcomp_state *rcstate));
|
struct regcomp_state *rcstate));
|
static char * regnext _ANSI_ARGS_((char *p));
|
static char * regnext _ANSI_ARGS_((char *p));
|
static char * regnode _ANSI_ARGS_((int op,
|
static char * regnode _ANSI_ARGS_((int op,
|
struct regcomp_state *rcstate));
|
struct regcomp_state *rcstate));
|
static void regoptail _ANSI_ARGS_((char *p, char *val));
|
static void regoptail _ANSI_ARGS_((char *p, char *val));
|
static char * regpiece _ANSI_ARGS_((int *flagp,
|
static char * regpiece _ANSI_ARGS_((int *flagp,
|
struct regcomp_state *rcstate));
|
struct regcomp_state *rcstate));
|
static void regtail _ANSI_ARGS_((char *p, char *val));
|
static void regtail _ANSI_ARGS_((char *p, char *val));
|
|
|
#ifdef STRCSPN
|
#ifdef STRCSPN
|
static int strcspn _ANSI_ARGS_((char *s1, char *s2));
|
static int strcspn _ANSI_ARGS_((char *s1, char *s2));
|
#endif
|
#endif
|
|
|
/*
|
/*
|
- TclRegComp - compile a regular expression into internal code
|
- TclRegComp - compile a regular expression into internal code
|
*
|
*
|
* We can't allocate space until we know how big the compiled form will be,
|
* 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
|
* 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
|
* 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".
|
* 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
|
* 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
|
* 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
|
* 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.)
|
* one piece because free() must be able to free it all.)
|
*
|
*
|
* Beware that the optimization-preparation code in here knows about some
|
* Beware that the optimization-preparation code in here knows about some
|
* of the structure of the compiled regexp.
|
* of the structure of the compiled regexp.
|
*/
|
*/
|
regexp *
|
regexp *
|
TclRegComp(exp)
|
TclRegComp(exp)
|
char *exp;
|
char *exp;
|
{
|
{
|
register regexp *r;
|
register regexp *r;
|
register char *scan;
|
register char *scan;
|
register char *longest;
|
register char *longest;
|
register int len;
|
register int len;
|
int flags;
|
int flags;
|
struct regcomp_state state;
|
struct regcomp_state state;
|
struct regcomp_state *rcstate= &state;
|
struct regcomp_state *rcstate= &state;
|
|
|
if (exp == NULL)
|
if (exp == NULL)
|
FAIL("NULL argument");
|
FAIL("NULL argument");
|
|
|
/* First pass: determine size, legality. */
|
/* First pass: determine size, legality. */
|
rcstate->regparse = exp;
|
rcstate->regparse = exp;
|
rcstate->regnpar = 1;
|
rcstate->regnpar = 1;
|
rcstate->regsize = 0L;
|
rcstate->regsize = 0L;
|
rcstate->regcode = ®dummy;
|
rcstate->regcode = ®dummy;
|
regc(MAGIC, rcstate);
|
regc(MAGIC, rcstate);
|
if (reg(0, &flags, rcstate) == NULL)
|
if (reg(0, &flags, rcstate) == NULL)
|
return(NULL);
|
return(NULL);
|
|
|
/* Small enough for pointer-storage convention? */
|
/* Small enough for pointer-storage convention? */
|
if (rcstate->regsize >= 32767L) /* Probably could be 65535L. */
|
if (rcstate->regsize >= 32767L) /* Probably could be 65535L. */
|
FAIL("regexp too big");
|
FAIL("regexp too big");
|
|
|
/* Allocate space. */
|
/* Allocate space. */
|
r = (regexp *)ckalloc(sizeof(regexp) + (unsigned)rcstate->regsize);
|
r = (regexp *)ckalloc(sizeof(regexp) + (unsigned)rcstate->regsize);
|
if (r == NULL)
|
if (r == NULL)
|
FAIL("out of space");
|
FAIL("out of space");
|
|
|
/* Second pass: emit code. */
|
/* Second pass: emit code. */
|
rcstate->regparse = exp;
|
rcstate->regparse = exp;
|
rcstate->regnpar = 1;
|
rcstate->regnpar = 1;
|
rcstate->regcode = r->program;
|
rcstate->regcode = r->program;
|
regc(MAGIC, rcstate);
|
regc(MAGIC, rcstate);
|
if (reg(0, &flags, rcstate) == NULL)
|
if (reg(0, &flags, rcstate) == NULL)
|
return(NULL);
|
return(NULL);
|
|
|
/* Dig out information for optimizations. */
|
/* Dig out information for optimizations. */
|
r->regstart = '\0'; /* Worst-case defaults. */
|
r->regstart = '\0'; /* Worst-case defaults. */
|
r->reganch = 0;
|
r->reganch = 0;
|
r->regmust = NULL;
|
r->regmust = NULL;
|
r->regmlen = 0;
|
r->regmlen = 0;
|
scan = r->program+1; /* First BRANCH. */
|
scan = r->program+1; /* First BRANCH. */
|
if (OP(regnext(scan)) == END) { /* Only one top-level choice. */
|
if (OP(regnext(scan)) == END) { /* Only one top-level choice. */
|
scan = OPERAND(scan);
|
scan = OPERAND(scan);
|
|
|
/* Starting-point info. */
|
/* Starting-point info. */
|
if (OP(scan) == EXACTLY)
|
if (OP(scan) == EXACTLY)
|
r->regstart = *OPERAND(scan);
|
r->regstart = *OPERAND(scan);
|
else if (OP(scan) == BOL)
|
else if (OP(scan) == BOL)
|
r->reganch++;
|
r->reganch++;
|
|
|
/*
|
/*
|
* If there's something expensive in the r.e., find the
|
* If there's something expensive in the r.e., find the
|
* longest literal string that must appear and make it the
|
* longest literal string that must appear and make it the
|
* regmust. Resolve ties in favor of later strings, since
|
* regmust. Resolve ties in favor of later strings, since
|
* the regstart check works with the beginning of the r.e.
|
* the regstart check works with the beginning of the r.e.
|
* and avoiding duplication strengthens checking. Not a
|
* and avoiding duplication strengthens checking. Not a
|
* strong reason, but sufficient in the absence of others.
|
* strong reason, but sufficient in the absence of others.
|
*/
|
*/
|
if (flags&SPSTART) {
|
if (flags&SPSTART) {
|
longest = NULL;
|
longest = NULL;
|
len = 0;
|
len = 0;
|
for (; scan != NULL; scan = regnext(scan))
|
for (; scan != NULL; scan = regnext(scan))
|
if (OP(scan) == EXACTLY && ((int) strlen(OPERAND(scan))) >= len) {
|
if (OP(scan) == EXACTLY && ((int) strlen(OPERAND(scan))) >= len) {
|
longest = OPERAND(scan);
|
longest = OPERAND(scan);
|
len = strlen(OPERAND(scan));
|
len = strlen(OPERAND(scan));
|
}
|
}
|
r->regmust = longest;
|
r->regmust = longest;
|
r->regmlen = len;
|
r->regmlen = len;
|
}
|
}
|
}
|
}
|
|
|
return(r);
|
return(r);
|
}
|
}
|
|
|
/*
|
/*
|
- reg - regular expression, i.e. main body or parenthesized thing
|
- reg - regular expression, i.e. main body or parenthesized thing
|
*
|
*
|
* Caller must absorb opening parenthesis.
|
* Caller must absorb opening parenthesis.
|
*
|
*
|
* Combining parenthesis handling with the base level of regular expression
|
* 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
|
* is a trifle forced, but the need to tie the tails of the branches to what
|
* follows makes it hard to avoid.
|
* follows makes it hard to avoid.
|
*/
|
*/
|
static char *
|
static char *
|
reg(paren, flagp, rcstate)
|
reg(paren, flagp, rcstate)
|
int paren; /* Parenthesized? */
|
int paren; /* Parenthesized? */
|
int *flagp;
|
int *flagp;
|
struct regcomp_state *rcstate;
|
struct regcomp_state *rcstate;
|
{
|
{
|
register char *ret;
|
register char *ret;
|
register char *br;
|
register char *br;
|
register char *ender;
|
register char *ender;
|
register int parno = 0;
|
register int parno = 0;
|
int flags;
|
int flags;
|
|
|
*flagp = HASWIDTH; /* Tentatively. */
|
*flagp = HASWIDTH; /* Tentatively. */
|
|
|
/* Make an OPEN node, if parenthesized. */
|
/* Make an OPEN node, if parenthesized. */
|
if (paren) {
|
if (paren) {
|
if (rcstate->regnpar >= NSUBEXP)
|
if (rcstate->regnpar >= NSUBEXP)
|
FAIL("too many ()");
|
FAIL("too many ()");
|
parno = rcstate->regnpar;
|
parno = rcstate->regnpar;
|
rcstate->regnpar++;
|
rcstate->regnpar++;
|
ret = regnode(OPEN+parno,rcstate);
|
ret = regnode(OPEN+parno,rcstate);
|
} else
|
} else
|
ret = NULL;
|
ret = NULL;
|
|
|
/* Pick up the branches, linking them together. */
|
/* Pick up the branches, linking them together. */
|
br = regbranch(&flags,rcstate);
|
br = regbranch(&flags,rcstate);
|
if (br == NULL)
|
if (br == NULL)
|
return(NULL);
|
return(NULL);
|
if (ret != NULL)
|
if (ret != NULL)
|
regtail(ret, br); /* OPEN -> first. */
|
regtail(ret, br); /* OPEN -> first. */
|
else
|
else
|
ret = br;
|
ret = br;
|
if (!(flags&HASWIDTH))
|
if (!(flags&HASWIDTH))
|
*flagp &= ~HASWIDTH;
|
*flagp &= ~HASWIDTH;
|
*flagp |= flags&SPSTART;
|
*flagp |= flags&SPSTART;
|
while (*rcstate->regparse == '|') {
|
while (*rcstate->regparse == '|') {
|
rcstate->regparse++;
|
rcstate->regparse++;
|
br = regbranch(&flags,rcstate);
|
br = regbranch(&flags,rcstate);
|
if (br == NULL)
|
if (br == NULL)
|
return(NULL);
|
return(NULL);
|
regtail(ret, br); /* BRANCH -> BRANCH. */
|
regtail(ret, br); /* BRANCH -> BRANCH. */
|
if (!(flags&HASWIDTH))
|
if (!(flags&HASWIDTH))
|
*flagp &= ~HASWIDTH;
|
*flagp &= ~HASWIDTH;
|
*flagp |= flags&SPSTART;
|
*flagp |= flags&SPSTART;
|
}
|
}
|
|
|
/* Make a closing node, and hook it on the end. */
|
/* Make a closing node, and hook it on the end. */
|
ender = regnode((paren) ? CLOSE+parno : END,rcstate);
|
ender = regnode((paren) ? CLOSE+parno : END,rcstate);
|
regtail(ret, ender);
|
regtail(ret, ender);
|
|
|
/* Hook the tails of the branches to the closing node. */
|
/* Hook the tails of the branches to the closing node. */
|
for (br = ret; br != NULL; br = regnext(br))
|
for (br = ret; br != NULL; br = regnext(br))
|
regoptail(br, ender);
|
regoptail(br, ender);
|
|
|
/* Check for proper termination. */
|
/* Check for proper termination. */
|
if (paren && *rcstate->regparse++ != ')') {
|
if (paren && *rcstate->regparse++ != ')') {
|
FAIL("unmatched ()");
|
FAIL("unmatched ()");
|
} else if (!paren && *rcstate->regparse != '\0') {
|
} else if (!paren && *rcstate->regparse != '\0') {
|
if (*rcstate->regparse == ')') {
|
if (*rcstate->regparse == ')') {
|
FAIL("unmatched ()");
|
FAIL("unmatched ()");
|
} else
|
} else
|
FAIL("junk on end"); /* "Can't happen". */
|
FAIL("junk on end"); /* "Can't happen". */
|
/* NOTREACHED */
|
/* NOTREACHED */
|
}
|
}
|
|
|
return(ret);
|
return(ret);
|
}
|
}
|
|
|
/*
|
/*
|
- regbranch - one alternative of an | operator
|
- regbranch - one alternative of an | operator
|
*
|
*
|
* Implements the concatenation operator.
|
* Implements the concatenation operator.
|
*/
|
*/
|
static char *
|
static char *
|
regbranch(flagp, rcstate)
|
regbranch(flagp, rcstate)
|
int *flagp;
|
int *flagp;
|
struct regcomp_state *rcstate;
|
struct regcomp_state *rcstate;
|
{
|
{
|
register char *ret;
|
register char *ret;
|
register char *chain;
|
register char *chain;
|
register char *latest;
|
register char *latest;
|
int flags;
|
int flags;
|
|
|
*flagp = WORST; /* Tentatively. */
|
*flagp = WORST; /* Tentatively. */
|
|
|
ret = regnode(BRANCH,rcstate);
|
ret = regnode(BRANCH,rcstate);
|
chain = NULL;
|
chain = NULL;
|
while (*rcstate->regparse != '\0' && *rcstate->regparse != '|' &&
|
while (*rcstate->regparse != '\0' && *rcstate->regparse != '|' &&
|
*rcstate->regparse != ')') {
|
*rcstate->regparse != ')') {
|
latest = regpiece(&flags, rcstate);
|
latest = regpiece(&flags, rcstate);
|
if (latest == NULL)
|
if (latest == NULL)
|
return(NULL);
|
return(NULL);
|
*flagp |= flags&HASWIDTH;
|
*flagp |= flags&HASWIDTH;
|
if (chain == NULL) /* First piece. */
|
if (chain == NULL) /* First piece. */
|
*flagp |= flags&SPSTART;
|
*flagp |= flags&SPSTART;
|
else
|
else
|
regtail(chain, latest);
|
regtail(chain, latest);
|
chain = latest;
|
chain = latest;
|
}
|
}
|
if (chain == NULL) /* Loop ran zero times. */
|
if (chain == NULL) /* Loop ran zero times. */
|
(void) regnode(NOTHING,rcstate);
|
(void) regnode(NOTHING,rcstate);
|
|
|
return(ret);
|
return(ret);
|
}
|
}
|
|
|
/*
|
/*
|
- regpiece - something followed by possible [*+?]
|
- regpiece - something followed by possible [*+?]
|
*
|
*
|
* Note that the branching code sequences used for ? and the general cases
|
* Note that the branching code sequences used for ? and the general cases
|
* of * and + are somewhat optimized: they use the same NOTHING node as
|
* 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.
|
* 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
|
* It might seem that this node could be dispensed with entirely, but the
|
* endmarker role is not redundant.
|
* endmarker role is not redundant.
|
*/
|
*/
|
static char *
|
static char *
|
regpiece(flagp, rcstate)
|
regpiece(flagp, rcstate)
|
int *flagp;
|
int *flagp;
|
struct regcomp_state *rcstate;
|
struct regcomp_state *rcstate;
|
{
|
{
|
register char *ret;
|
register char *ret;
|
register char op;
|
register char op;
|
register char *next;
|
register char *next;
|
int flags;
|
int flags;
|
|
|
ret = regatom(&flags,rcstate);
|
ret = regatom(&flags,rcstate);
|
if (ret == NULL)
|
if (ret == NULL)
|
return(NULL);
|
return(NULL);
|
|
|
op = *rcstate->regparse;
|
op = *rcstate->regparse;
|
if (!ISMULT(op)) {
|
if (!ISMULT(op)) {
|
*flagp = flags;
|
*flagp = flags;
|
return(ret);
|
return(ret);
|
}
|
}
|
|
|
if (!(flags&HASWIDTH) && op != '?')
|
if (!(flags&HASWIDTH) && op != '?')
|
FAIL("*+ operand could be empty");
|
FAIL("*+ operand could be empty");
|
*flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
|
*flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
|
|
|
if (op == '*' && (flags&SIMPLE))
|
if (op == '*' && (flags&SIMPLE))
|
reginsert(STAR, ret, rcstate);
|
reginsert(STAR, ret, rcstate);
|
else if (op == '*') {
|
else if (op == '*') {
|
/* Emit x* as (x&|), where & means "self". */
|
/* Emit x* as (x&|), where & means "self". */
|
reginsert(BRANCH, ret, rcstate); /* Either x */
|
reginsert(BRANCH, ret, rcstate); /* Either x */
|
regoptail(ret, regnode(BACK,rcstate)); /* and loop */
|
regoptail(ret, regnode(BACK,rcstate)); /* and loop */
|
regoptail(ret, ret); /* back */
|
regoptail(ret, ret); /* back */
|
regtail(ret, regnode(BRANCH,rcstate)); /* or */
|
regtail(ret, regnode(BRANCH,rcstate)); /* or */
|
regtail(ret, regnode(NOTHING,rcstate)); /* null. */
|
regtail(ret, regnode(NOTHING,rcstate)); /* null. */
|
} else if (op == '+' && (flags&SIMPLE))
|
} else if (op == '+' && (flags&SIMPLE))
|
reginsert(PLUS, ret, rcstate);
|
reginsert(PLUS, ret, rcstate);
|
else if (op == '+') {
|
else if (op == '+') {
|
/* Emit x+ as x(&|), where & means "self". */
|
/* Emit x+ as x(&|), where & means "self". */
|
next = regnode(BRANCH,rcstate); /* Either */
|
next = regnode(BRANCH,rcstate); /* Either */
|
regtail(ret, next);
|
regtail(ret, next);
|
regtail(regnode(BACK,rcstate), ret); /* loop back */
|
regtail(regnode(BACK,rcstate), ret); /* loop back */
|
regtail(next, regnode(BRANCH,rcstate)); /* or */
|
regtail(next, regnode(BRANCH,rcstate)); /* or */
|
regtail(ret, regnode(NOTHING,rcstate)); /* null. */
|
regtail(ret, regnode(NOTHING,rcstate)); /* null. */
|
} else if (op == '?') {
|
} else if (op == '?') {
|
/* Emit x? as (x|) */
|
/* Emit x? as (x|) */
|
reginsert(BRANCH, ret, rcstate); /* Either x */
|
reginsert(BRANCH, ret, rcstate); /* Either x */
|
regtail(ret, regnode(BRANCH,rcstate)); /* or */
|
regtail(ret, regnode(BRANCH,rcstate)); /* or */
|
next = regnode(NOTHING,rcstate); /* null. */
|
next = regnode(NOTHING,rcstate); /* null. */
|
regtail(ret, next);
|
regtail(ret, next);
|
regoptail(ret, next);
|
regoptail(ret, next);
|
}
|
}
|
rcstate->regparse++;
|
rcstate->regparse++;
|
if (ISMULT(*rcstate->regparse))
|
if (ISMULT(*rcstate->regparse))
|
FAIL("nested *?+");
|
FAIL("nested *?+");
|
|
|
return(ret);
|
return(ret);
|
}
|
}
|
|
|
/*
|
/*
|
- regatom - the lowest level
|
- regatom - the lowest level
|
*
|
*
|
* Optimization: gobbles an entire sequence of ordinary characters so that
|
* Optimization: gobbles an entire sequence of ordinary characters so that
|
* it can turn them into a single node, which is smaller to store and
|
* it can turn them into a single node, which is smaller to store and
|
* faster to run. Backslashed characters are exceptions, each becoming a
|
* faster to run. Backslashed characters are exceptions, each becoming a
|
* separate node; the code is simpler that way and it's not worth fixing.
|
* separate node; the code is simpler that way and it's not worth fixing.
|
*/
|
*/
|
static char *
|
static char *
|
regatom(flagp, rcstate)
|
regatom(flagp, rcstate)
|
int *flagp;
|
int *flagp;
|
struct regcomp_state *rcstate;
|
struct regcomp_state *rcstate;
|
{
|
{
|
register char *ret;
|
register char *ret;
|
int flags;
|
int flags;
|
|
|
*flagp = WORST; /* Tentatively. */
|
*flagp = WORST; /* Tentatively. */
|
|
|
switch (*rcstate->regparse++) {
|
switch (*rcstate->regparse++) {
|
case '^':
|
case '^':
|
ret = regnode(BOL,rcstate);
|
ret = regnode(BOL,rcstate);
|
break;
|
break;
|
case '$':
|
case '$':
|
ret = regnode(EOL,rcstate);
|
ret = regnode(EOL,rcstate);
|
break;
|
break;
|
case '.':
|
case '.':
|
ret = regnode(ANY,rcstate);
|
ret = regnode(ANY,rcstate);
|
*flagp |= HASWIDTH|SIMPLE;
|
*flagp |= HASWIDTH|SIMPLE;
|
break;
|
break;
|
case '[': {
|
case '[': {
|
register int clss;
|
register int clss;
|
register int classend;
|
register int classend;
|
|
|
if(rcstate->regparse[0] != '\\' &&
|
if(rcstate->regparse[0] != '\\' &&
|
rcstate->regparse[0] != '^' &&
|
rcstate->regparse[0] != '^' &&
|
rcstate->regparse[1] == ']') {
|
rcstate->regparse[1] == ']') {
|
ret = regnode(EXACTLY,rcstate);
|
ret = regnode(EXACTLY,rcstate);
|
regc(*rcstate->regparse++,rcstate);
|
regc(*rcstate->regparse++,rcstate);
|
regc('\0',rcstate);
|
regc('\0',rcstate);
|
rcstate->regparse++;
|
rcstate->regparse++;
|
*flagp |= HASWIDTH|SIMPLE;
|
*flagp |= HASWIDTH|SIMPLE;
|
break;
|
break;
|
}
|
}
|
if (*rcstate->regparse == '^') { /* Complement of range. */
|
if (*rcstate->regparse == '^') { /* Complement of range. */
|
ret = regnode(ANYBUT,rcstate);
|
ret = regnode(ANYBUT,rcstate);
|
rcstate->regparse++;
|
rcstate->regparse++;
|
} else
|
} else
|
ret = regnode(ANYOF,rcstate);
|
ret = regnode(ANYOF,rcstate);
|
if (*rcstate->regparse == ']' || *rcstate->regparse == '-')
|
if (*rcstate->regparse == ']' || *rcstate->regparse == '-')
|
regc(*rcstate->regparse++,rcstate);
|
regc(*rcstate->regparse++,rcstate);
|
while (*rcstate->regparse != '\0' && *rcstate->regparse != ']') {
|
while (*rcstate->regparse != '\0' && *rcstate->regparse != ']') {
|
if (*rcstate->regparse == '-') {
|
if (*rcstate->regparse == '-') {
|
rcstate->regparse++;
|
rcstate->regparse++;
|
if (*rcstate->regparse == ']' || *rcstate->regparse == '\0')
|
if (*rcstate->regparse == ']' || *rcstate->regparse == '\0')
|
regc('-',rcstate);
|
regc('-',rcstate);
|
else {
|
else {
|
clss = UCHARAT(rcstate->regparse-2)+1;
|
clss = UCHARAT(rcstate->regparse-2)+1;
|
classend = UCHARAT(rcstate->regparse);
|
classend = UCHARAT(rcstate->regparse);
|
if (clss > classend+1)
|
if (clss > classend+1)
|
FAIL("invalid [] range");
|
FAIL("invalid [] range");
|
for (; clss <= classend; clss++)
|
for (; clss <= classend; clss++)
|
regc((char)clss,rcstate);
|
regc((char)clss,rcstate);
|
rcstate->regparse++;
|
rcstate->regparse++;
|
}
|
}
|
} else
|
} else
|
regc(*rcstate->regparse++,rcstate);
|
regc(*rcstate->regparse++,rcstate);
|
}
|
}
|
regc('\0',rcstate);
|
regc('\0',rcstate);
|
if (*rcstate->regparse != ']')
|
if (*rcstate->regparse != ']')
|
FAIL("unmatched []");
|
FAIL("unmatched []");
|
rcstate->regparse++;
|
rcstate->regparse++;
|
*flagp |= HASWIDTH|SIMPLE;
|
*flagp |= HASWIDTH|SIMPLE;
|
}
|
}
|
break;
|
break;
|
case '(':
|
case '(':
|
ret = reg(1, &flags, rcstate);
|
ret = reg(1, &flags, rcstate);
|
if (ret == NULL)
|
if (ret == NULL)
|
return(NULL);
|
return(NULL);
|
*flagp |= flags&(HASWIDTH|SPSTART);
|
*flagp |= flags&(HASWIDTH|SPSTART);
|
break;
|
break;
|
case '\0':
|
case '\0':
|
case '|':
|
case '|':
|
case ')':
|
case ')':
|
FAIL("internal urp"); /* Supposed to be caught earlier. */
|
FAIL("internal urp"); /* Supposed to be caught earlier. */
|
/* NOTREACHED */
|
/* NOTREACHED */
|
case '?':
|
case '?':
|
case '+':
|
case '+':
|
case '*':
|
case '*':
|
FAIL("?+* follows nothing");
|
FAIL("?+* follows nothing");
|
/* NOTREACHED */
|
/* NOTREACHED */
|
case '\\':
|
case '\\':
|
if (*rcstate->regparse == '\0')
|
if (*rcstate->regparse == '\0')
|
FAIL("trailing \\");
|
FAIL("trailing \\");
|
ret = regnode(EXACTLY,rcstate);
|
ret = regnode(EXACTLY,rcstate);
|
regc(*rcstate->regparse++,rcstate);
|
regc(*rcstate->regparse++,rcstate);
|
regc('\0',rcstate);
|
regc('\0',rcstate);
|
*flagp |= HASWIDTH|SIMPLE;
|
*flagp |= HASWIDTH|SIMPLE;
|
break;
|
break;
|
default: {
|
default: {
|
register int len;
|
register int len;
|
register char ender;
|
register char ender;
|
|
|
rcstate->regparse--;
|
rcstate->regparse--;
|
len = strcspn(rcstate->regparse, META);
|
len = strcspn(rcstate->regparse, META);
|
if (len <= 0)
|
if (len <= 0)
|
FAIL("internal disaster");
|
FAIL("internal disaster");
|
ender = *(rcstate->regparse+len);
|
ender = *(rcstate->regparse+len);
|
if (len > 1 && ISMULT(ender))
|
if (len > 1 && ISMULT(ender))
|
len--; /* Back off clear of ?+* operand. */
|
len--; /* Back off clear of ?+* operand. */
|
*flagp |= HASWIDTH;
|
*flagp |= HASWIDTH;
|
if (len == 1)
|
if (len == 1)
|
*flagp |= SIMPLE;
|
*flagp |= SIMPLE;
|
ret = regnode(EXACTLY,rcstate);
|
ret = regnode(EXACTLY,rcstate);
|
while (len > 0) {
|
while (len > 0) {
|
regc(*rcstate->regparse++,rcstate);
|
regc(*rcstate->regparse++,rcstate);
|
len--;
|
len--;
|
}
|
}
|
regc('\0',rcstate);
|
regc('\0',rcstate);
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
return(ret);
|
return(ret);
|
}
|
}
|
|
|
/*
|
/*
|
- regnode - emit a node
|
- regnode - emit a node
|
*/
|
*/
|
static char * /* Location. */
|
static char * /* Location. */
|
regnode(op, rcstate)
|
regnode(op, rcstate)
|
int op;
|
int op;
|
struct regcomp_state *rcstate;
|
struct regcomp_state *rcstate;
|
{
|
{
|
register char *ret;
|
register char *ret;
|
register char *ptr;
|
register char *ptr;
|
|
|
ret = rcstate->regcode;
|
ret = rcstate->regcode;
|
if (ret == ®dummy) {
|
if (ret == ®dummy) {
|
rcstate->regsize += 3;
|
rcstate->regsize += 3;
|
return(ret);
|
return(ret);
|
}
|
}
|
|
|
ptr = ret;
|
ptr = ret;
|
*ptr++ = (char)op;
|
*ptr++ = (char)op;
|
*ptr++ = '\0'; /* Null "next" pointer. */
|
*ptr++ = '\0'; /* Null "next" pointer. */
|
*ptr++ = '\0';
|
*ptr++ = '\0';
|
rcstate->regcode = ptr;
|
rcstate->regcode = ptr;
|
|
|
return(ret);
|
return(ret);
|
}
|
}
|
|
|
/*
|
/*
|
- regc - emit (if appropriate) a byte of code
|
- regc - emit (if appropriate) a byte of code
|
*/
|
*/
|
static void
|
static void
|
regc(b, rcstate)
|
regc(b, rcstate)
|
int b;
|
int b;
|
struct regcomp_state *rcstate;
|
struct regcomp_state *rcstate;
|
{
|
{
|
if (rcstate->regcode != ®dummy)
|
if (rcstate->regcode != ®dummy)
|
*rcstate->regcode++ = (char)b;
|
*rcstate->regcode++ = (char)b;
|
else
|
else
|
rcstate->regsize++;
|
rcstate->regsize++;
|
}
|
}
|
|
|
/*
|
/*
|
- reginsert - insert an operator in front of already-emitted operand
|
- reginsert - insert an operator in front of already-emitted operand
|
*
|
*
|
* Means relocating the operand.
|
* Means relocating the operand.
|
*/
|
*/
|
static void
|
static void
|
reginsert(op, opnd, rcstate)
|
reginsert(op, opnd, rcstate)
|
int op;
|
int op;
|
char *opnd;
|
char *opnd;
|
struct regcomp_state *rcstate;
|
struct regcomp_state *rcstate;
|
{
|
{
|
register char *src;
|
register char *src;
|
register char *dst;
|
register char *dst;
|
register char *place;
|
register char *place;
|
|
|
if (rcstate->regcode == ®dummy) {
|
if (rcstate->regcode == ®dummy) {
|
rcstate->regsize += 3;
|
rcstate->regsize += 3;
|
return;
|
return;
|
}
|
}
|
|
|
src = rcstate->regcode;
|
src = rcstate->regcode;
|
rcstate->regcode += 3;
|
rcstate->regcode += 3;
|
dst = rcstate->regcode;
|
dst = rcstate->regcode;
|
while (src > opnd)
|
while (src > opnd)
|
*--dst = *--src;
|
*--dst = *--src;
|
|
|
place = opnd; /* Op node, where operand used to be. */
|
place = opnd; /* Op node, where operand used to be. */
|
*place++ = (char)op;
|
*place++ = (char)op;
|
*place++ = '\0';
|
*place++ = '\0';
|
*place = '\0';
|
*place = '\0';
|
}
|
}
|
|
|
/*
|
/*
|
- regtail - set the next-pointer at the end of a node chain
|
- regtail - set the next-pointer at the end of a node chain
|
*/
|
*/
|
static void
|
static void
|
regtail(p, val)
|
regtail(p, val)
|
char *p;
|
char *p;
|
char *val;
|
char *val;
|
{
|
{
|
register char *scan;
|
register char *scan;
|
register char *temp;
|
register char *temp;
|
register int offset;
|
register int offset;
|
|
|
if (p == ®dummy)
|
if (p == ®dummy)
|
return;
|
return;
|
|
|
/* Find last node. */
|
/* Find last node. */
|
scan = p;
|
scan = p;
|
for (;;) {
|
for (;;) {
|
temp = regnext(scan);
|
temp = regnext(scan);
|
if (temp == NULL)
|
if (temp == NULL)
|
break;
|
break;
|
scan = temp;
|
scan = temp;
|
}
|
}
|
|
|
if (OP(scan) == BACK)
|
if (OP(scan) == BACK)
|
offset = scan - val;
|
offset = scan - val;
|
else
|
else
|
offset = val - scan;
|
offset = val - scan;
|
*(scan+1) = (char)((offset>>8)&0377);
|
*(scan+1) = (char)((offset>>8)&0377);
|
*(scan+2) = (char)(offset&0377);
|
*(scan+2) = (char)(offset&0377);
|
}
|
}
|
|
|
/*
|
/*
|
- regoptail - regtail on operand of first argument; nop if operandless
|
- regoptail - regtail on operand of first argument; nop if operandless
|
*/
|
*/
|
static void
|
static void
|
regoptail(p, val)
|
regoptail(p, val)
|
char *p;
|
char *p;
|
char *val;
|
char *val;
|
{
|
{
|
/* "Operandless" and "op != BRANCH" are synonymous in practice. */
|
/* "Operandless" and "op != BRANCH" are synonymous in practice. */
|
if (p == NULL || p == ®dummy || OP(p) != BRANCH)
|
if (p == NULL || p == ®dummy || OP(p) != BRANCH)
|
return;
|
return;
|
regtail(OPERAND(p), val);
|
regtail(OPERAND(p), val);
|
}
|
}
|
|
|
/*
|
/*
|
* TclRegExec and friends
|
* TclRegExec and friends
|
*/
|
*/
|
|
|
/*
|
/*
|
* Global work variables for TclRegExec().
|
* Global work variables for TclRegExec().
|
*/
|
*/
|
struct regexec_state {
|
struct regexec_state {
|
char *reginput; /* String-input pointer. */
|
char *reginput; /* String-input pointer. */
|
char *regbol; /* Beginning of input, for ^ check. */
|
char *regbol; /* Beginning of input, for ^ check. */
|
char **regstartp; /* Pointer to startp array. */
|
char **regstartp; /* Pointer to startp array. */
|
char **regendp; /* Ditto for endp. */
|
char **regendp; /* Ditto for endp. */
|
};
|
};
|
|
|
/*
|
/*
|
* Forwards.
|
* Forwards.
|
*/
|
*/
|
static int regtry _ANSI_ARGS_((regexp *prog, char *string,
|
static int regtry _ANSI_ARGS_((regexp *prog, char *string,
|
struct regexec_state *restate));
|
struct regexec_state *restate));
|
static int regmatch _ANSI_ARGS_((char *prog,
|
static int regmatch _ANSI_ARGS_((char *prog,
|
struct regexec_state *restate));
|
struct regexec_state *restate));
|
static int regrepeat _ANSI_ARGS_((char *p,
|
static int regrepeat _ANSI_ARGS_((char *p,
|
struct regexec_state *restate));
|
struct regexec_state *restate));
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
int regnarrate = 0;
|
int regnarrate = 0;
|
void regdump _ANSI_ARGS_((regexp *r));
|
void regdump _ANSI_ARGS_((regexp *r));
|
static char *regprop _ANSI_ARGS_((char *op));
|
static char *regprop _ANSI_ARGS_((char *op));
|
#endif
|
#endif
|
|
|
/*
|
/*
|
- TclRegExec - match a regexp against a string
|
- TclRegExec - match a regexp against a string
|
*/
|
*/
|
int
|
int
|
TclRegExec(prog, string, start)
|
TclRegExec(prog, string, start)
|
register regexp *prog;
|
register regexp *prog;
|
register char *string;
|
register char *string;
|
char *start;
|
char *start;
|
{
|
{
|
register char *s;
|
register char *s;
|
struct regexec_state state;
|
struct regexec_state state;
|
struct regexec_state *restate= &state;
|
struct regexec_state *restate= &state;
|
|
|
/* Be paranoid... */
|
/* Be paranoid... */
|
if (prog == NULL || string == NULL) {
|
if (prog == NULL || string == NULL) {
|
TclRegError("NULL parameter");
|
TclRegError("NULL parameter");
|
return(0);
|
return(0);
|
}
|
}
|
|
|
/* Check validity of program. */
|
/* Check validity of program. */
|
if (UCHARAT(prog->program) != MAGIC) {
|
if (UCHARAT(prog->program) != MAGIC) {
|
TclRegError("corrupted program");
|
TclRegError("corrupted program");
|
return(0);
|
return(0);
|
}
|
}
|
|
|
/* If there is a "must appear" string, look for it. */
|
/* If there is a "must appear" string, look for it. */
|
if (prog->regmust != NULL) {
|
if (prog->regmust != NULL) {
|
s = string;
|
s = string;
|
while ((s = strchr(s, prog->regmust[0])) != NULL) {
|
while ((s = strchr(s, prog->regmust[0])) != NULL) {
|
if (strncmp(s, prog->regmust, (size_t) prog->regmlen)
|
if (strncmp(s, prog->regmust, (size_t) prog->regmlen)
|
== 0)
|
== 0)
|
break; /* Found it. */
|
break; /* Found it. */
|
s++;
|
s++;
|
}
|
}
|
if (s == NULL) /* Not present. */
|
if (s == NULL) /* Not present. */
|
return(0);
|
return(0);
|
}
|
}
|
|
|
/* Mark beginning of line for ^ . */
|
/* Mark beginning of line for ^ . */
|
restate->regbol = start;
|
restate->regbol = start;
|
|
|
/* Simplest case: anchored match need be tried only once. */
|
/* Simplest case: anchored match need be tried only once. */
|
if (prog->reganch)
|
if (prog->reganch)
|
return(regtry(prog, string, restate));
|
return(regtry(prog, string, restate));
|
|
|
/* Messy cases: unanchored match. */
|
/* Messy cases: unanchored match. */
|
s = string;
|
s = string;
|
if (prog->regstart != '\0')
|
if (prog->regstart != '\0')
|
/* We know what char it must start with. */
|
/* We know what char it must start with. */
|
while ((s = strchr(s, prog->regstart)) != NULL) {
|
while ((s = strchr(s, prog->regstart)) != NULL) {
|
if (regtry(prog, s, restate))
|
if (regtry(prog, s, restate))
|
return(1);
|
return(1);
|
s++;
|
s++;
|
}
|
}
|
else
|
else
|
/* We don't -- general case. */
|
/* We don't -- general case. */
|
do {
|
do {
|
if (regtry(prog, s, restate))
|
if (regtry(prog, s, restate))
|
return(1);
|
return(1);
|
} while (*s++ != '\0');
|
} while (*s++ != '\0');
|
|
|
/* Failure. */
|
/* Failure. */
|
return(0);
|
return(0);
|
}
|
}
|
|
|
/*
|
/*
|
- regtry - try match at specific point
|
- regtry - try match at specific point
|
*/
|
*/
|
static int /* 0 failure, 1 success */
|
static int /* 0 failure, 1 success */
|
regtry(prog, string, restate)
|
regtry(prog, string, restate)
|
regexp *prog;
|
regexp *prog;
|
char *string;
|
char *string;
|
struct regexec_state *restate;
|
struct regexec_state *restate;
|
{
|
{
|
register int i;
|
register int i;
|
register char **sp;
|
register char **sp;
|
register char **ep;
|
register char **ep;
|
|
|
restate->reginput = string;
|
restate->reginput = string;
|
restate->regstartp = prog->startp;
|
restate->regstartp = prog->startp;
|
restate->regendp = prog->endp;
|
restate->regendp = prog->endp;
|
|
|
sp = prog->startp;
|
sp = prog->startp;
|
ep = prog->endp;
|
ep = prog->endp;
|
for (i = NSUBEXP; i > 0; i--) {
|
for (i = NSUBEXP; i > 0; i--) {
|
*sp++ = NULL;
|
*sp++ = NULL;
|
*ep++ = NULL;
|
*ep++ = NULL;
|
}
|
}
|
if (regmatch(prog->program + 1,restate)) {
|
if (regmatch(prog->program + 1,restate)) {
|
prog->startp[0] = string;
|
prog->startp[0] = string;
|
prog->endp[0] = restate->reginput;
|
prog->endp[0] = restate->reginput;
|
return(1);
|
return(1);
|
} else
|
} else
|
return(0);
|
return(0);
|
}
|
}
|
|
|
/*
|
/*
|
- regmatch - main matching routine
|
- regmatch - main matching routine
|
*
|
*
|
* Conceptually the strategy is simple: check to see whether the current
|
* Conceptually the strategy is simple: check to see whether the current
|
* node matches, call self recursively to see whether the rest matches,
|
* node matches, call self recursively to see whether the rest matches,
|
* and then act accordingly. In practice we make some effort to avoid
|
* and then act accordingly. In practice we make some effort to avoid
|
* recursion, in particular by going through "ordinary" nodes (that don't
|
* 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
|
* need to know whether the rest of the match failed) by a loop instead of
|
* by recursion.
|
* by recursion.
|
*/
|
*/
|
static int /* 0 failure, 1 success */
|
static int /* 0 failure, 1 success */
|
regmatch(prog, restate)
|
regmatch(prog, restate)
|
char *prog;
|
char *prog;
|
struct regexec_state *restate;
|
struct regexec_state *restate;
|
{
|
{
|
register char *scan; /* Current node. */
|
register char *scan; /* Current node. */
|
char *next; /* Next node. */
|
char *next; /* Next node. */
|
|
|
scan = prog;
|
scan = prog;
|
#ifdef DEBUG
|
#ifdef DEBUG
|
if (scan != NULL && regnarrate)
|
if (scan != NULL && regnarrate)
|
fprintf(stderr, "%s(\n", regprop(scan));
|
fprintf(stderr, "%s(\n", regprop(scan));
|
#endif
|
#endif
|
while (scan != NULL) {
|
while (scan != NULL) {
|
#ifdef DEBUG
|
#ifdef DEBUG
|
if (regnarrate)
|
if (regnarrate)
|
fprintf(stderr, "%s...\n", regprop(scan));
|
fprintf(stderr, "%s...\n", regprop(scan));
|
#endif
|
#endif
|
next = regnext(scan);
|
next = regnext(scan);
|
|
|
switch (OP(scan)) {
|
switch (OP(scan)) {
|
case BOL:
|
case BOL:
|
if (restate->reginput != restate->regbol) {
|
if (restate->reginput != restate->regbol) {
|
return 0;
|
return 0;
|
}
|
}
|
break;
|
break;
|
case EOL:
|
case EOL:
|
if (*restate->reginput != '\0') {
|
if (*restate->reginput != '\0') {
|
return 0;
|
return 0;
|
}
|
}
|
break;
|
break;
|
case ANY:
|
case ANY:
|
if (*restate->reginput == '\0') {
|
if (*restate->reginput == '\0') {
|
return 0;
|
return 0;
|
}
|
}
|
restate->reginput++;
|
restate->reginput++;
|
break;
|
break;
|
case EXACTLY: {
|
case EXACTLY: {
|
register int len;
|
register int len;
|
register char *opnd;
|
register char *opnd;
|
|
|
opnd = OPERAND(scan);
|
opnd = OPERAND(scan);
|
/* Inline the first character, for speed. */
|
/* Inline the first character, for speed. */
|
if (*opnd != *restate->reginput) {
|
if (*opnd != *restate->reginput) {
|
return 0 ;
|
return 0 ;
|
}
|
}
|
len = strlen(opnd);
|
len = strlen(opnd);
|
if (len > 1 && strncmp(opnd, restate->reginput, (size_t) len)
|
if (len > 1 && strncmp(opnd, restate->reginput, (size_t) len)
|
!= 0) {
|
!= 0) {
|
return 0;
|
return 0;
|
}
|
}
|
restate->reginput += len;
|
restate->reginput += len;
|
break;
|
break;
|
}
|
}
|
case ANYOF:
|
case ANYOF:
|
if (*restate->reginput == '\0'
|
if (*restate->reginput == '\0'
|
|| strchr(OPERAND(scan), *restate->reginput) == NULL) {
|
|| strchr(OPERAND(scan), *restate->reginput) == NULL) {
|
return 0;
|
return 0;
|
}
|
}
|
restate->reginput++;
|
restate->reginput++;
|
break;
|
break;
|
case ANYBUT:
|
case ANYBUT:
|
if (*restate->reginput == '\0'
|
if (*restate->reginput == '\0'
|
|| strchr(OPERAND(scan), *restate->reginput) != NULL) {
|
|| strchr(OPERAND(scan), *restate->reginput) != NULL) {
|
return 0;
|
return 0;
|
}
|
}
|
restate->reginput++;
|
restate->reginput++;
|
break;
|
break;
|
case NOTHING:
|
case NOTHING:
|
break;
|
break;
|
case BACK:
|
case BACK:
|
break;
|
break;
|
case OPEN+1:
|
case OPEN+1:
|
case OPEN+2:
|
case OPEN+2:
|
case OPEN+3:
|
case OPEN+3:
|
case OPEN+4:
|
case OPEN+4:
|
case OPEN+5:
|
case OPEN+5:
|
case OPEN+6:
|
case OPEN+6:
|
case OPEN+7:
|
case OPEN+7:
|
case OPEN+8:
|
case OPEN+8:
|
case OPEN+9: {
|
case OPEN+9: {
|
register int no;
|
register int no;
|
register char *save;
|
register char *save;
|
|
|
doOpen:
|
doOpen:
|
no = OP(scan) - OPEN;
|
no = OP(scan) - OPEN;
|
save = restate->reginput;
|
save = restate->reginput;
|
|
|
if (regmatch(next,restate)) {
|
if (regmatch(next,restate)) {
|
/*
|
/*
|
* Don't set startp if some later invocation of the
|
* Don't set startp if some later invocation of the
|
* same parentheses already has.
|
* same parentheses already has.
|
*/
|
*/
|
if (restate->regstartp[no] == NULL) {
|
if (restate->regstartp[no] == NULL) {
|
restate->regstartp[no] = save;
|
restate->regstartp[no] = save;
|
}
|
}
|
return 1;
|
return 1;
|
} else {
|
} else {
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
case CLOSE+1:
|
case CLOSE+1:
|
case CLOSE+2:
|
case CLOSE+2:
|
case CLOSE+3:
|
case CLOSE+3:
|
case CLOSE+4:
|
case CLOSE+4:
|
case CLOSE+5:
|
case CLOSE+5:
|
case CLOSE+6:
|
case CLOSE+6:
|
case CLOSE+7:
|
case CLOSE+7:
|
case CLOSE+8:
|
case CLOSE+8:
|
case CLOSE+9: {
|
case CLOSE+9: {
|
register int no;
|
register int no;
|
register char *save;
|
register char *save;
|
|
|
doClose:
|
doClose:
|
no = OP(scan) - CLOSE;
|
no = OP(scan) - CLOSE;
|
save = restate->reginput;
|
save = restate->reginput;
|
|
|
if (regmatch(next,restate)) {
|
if (regmatch(next,restate)) {
|
/*
|
/*
|
* Don't set endp if some later
|
* Don't set endp if some later
|
* invocation of the same parentheses
|
* invocation of the same parentheses
|
* already has.
|
* already has.
|
*/
|
*/
|
if (restate->regendp[no] == NULL)
|
if (restate->regendp[no] == NULL)
|
restate->regendp[no] = save;
|
restate->regendp[no] = save;
|
return 1;
|
return 1;
|
} else {
|
} else {
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
case BRANCH: {
|
case BRANCH: {
|
register char *save;
|
register char *save;
|
|
|
if (OP(next) != BRANCH) { /* No choice. */
|
if (OP(next) != BRANCH) { /* No choice. */
|
next = OPERAND(scan); /* Avoid recursion. */
|
next = OPERAND(scan); /* Avoid recursion. */
|
} else {
|
} else {
|
do {
|
do {
|
save = restate->reginput;
|
save = restate->reginput;
|
if (regmatch(OPERAND(scan),restate))
|
if (regmatch(OPERAND(scan),restate))
|
return(1);
|
return(1);
|
restate->reginput = save;
|
restate->reginput = save;
|
scan = regnext(scan);
|
scan = regnext(scan);
|
} while (scan != NULL && OP(scan) == BRANCH);
|
} while (scan != NULL && OP(scan) == BRANCH);
|
return 0;
|
return 0;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
case STAR:
|
case STAR:
|
case PLUS: {
|
case PLUS: {
|
register char nextch;
|
register char nextch;
|
register int no;
|
register int no;
|
register char *save;
|
register char *save;
|
register int min;
|
register int min;
|
|
|
/*
|
/*
|
* Lookahead to avoid useless match attempts
|
* Lookahead to avoid useless match attempts
|
* when we know what character comes next.
|
* when we know what character comes next.
|
*/
|
*/
|
nextch = '\0';
|
nextch = '\0';
|
if (OP(next) == EXACTLY)
|
if (OP(next) == EXACTLY)
|
nextch = *OPERAND(next);
|
nextch = *OPERAND(next);
|
min = (OP(scan) == STAR) ? 0 : 1;
|
min = (OP(scan) == STAR) ? 0 : 1;
|
save = restate->reginput;
|
save = restate->reginput;
|
no = regrepeat(OPERAND(scan),restate);
|
no = regrepeat(OPERAND(scan),restate);
|
while (no >= min) {
|
while (no >= min) {
|
/* If it could work, try it. */
|
/* If it could work, try it. */
|
if (nextch == '\0' || *restate->reginput == nextch)
|
if (nextch == '\0' || *restate->reginput == nextch)
|
if (regmatch(next,restate))
|
if (regmatch(next,restate))
|
return(1);
|
return(1);
|
if (nextch != '\0' && no > (min + 1)) {
|
if (nextch != '\0' && no > (min + 1)) {
|
char tmp = *(save + no);
|
char tmp = *(save + no);
|
char *p;
|
char *p;
|
*(save + no) = 0;
|
*(save + no) = 0;
|
p = strrchr(save, nextch);
|
p = strrchr(save, nextch);
|
*(save + no) = tmp;
|
*(save + no) = tmp;
|
if (p != NULL)
|
if (p != NULL)
|
no = p - save + 1;
|
no = p - save + 1;
|
else
|
else
|
no = 0;
|
no = 0;
|
}
|
}
|
|
|
/* Couldn't or didn't -- back up. */
|
/* Couldn't or didn't -- back up. */
|
no--;
|
no--;
|
restate->reginput = save + no;
|
restate->reginput = save + no;
|
}
|
}
|
return(0);
|
return(0);
|
}
|
}
|
case END:
|
case END:
|
return(1); /* Success! */
|
return(1); /* Success! */
|
default:
|
default:
|
if (OP(scan) > OPEN && OP(scan) < OPEN+NSUBEXP) {
|
if (OP(scan) > OPEN && OP(scan) < OPEN+NSUBEXP) {
|
goto doOpen;
|
goto doOpen;
|
} else if (OP(scan) > CLOSE && OP(scan) < CLOSE+NSUBEXP) {
|
} else if (OP(scan) > CLOSE && OP(scan) < CLOSE+NSUBEXP) {
|
goto doClose;
|
goto doClose;
|
}
|
}
|
TclRegError("memory corruption");
|
TclRegError("memory corruption");
|
return 0;
|
return 0;
|
}
|
}
|
|
|
scan = next;
|
scan = next;
|
}
|
}
|
|
|
/*
|
/*
|
* We get here only if there's trouble -- normally "case END" is
|
* We get here only if there's trouble -- normally "case END" is
|
* the terminating point.
|
* the terminating point.
|
*/
|
*/
|
TclRegError("corrupted pointers");
|
TclRegError("corrupted pointers");
|
return(0);
|
return(0);
|
}
|
}
|
|
|
/*
|
/*
|
- regrepeat - repeatedly match something simple, report how many
|
- regrepeat - repeatedly match something simple, report how many
|
*/
|
*/
|
static int
|
static int
|
regrepeat(p, restate)
|
regrepeat(p, restate)
|
char *p;
|
char *p;
|
struct regexec_state *restate;
|
struct regexec_state *restate;
|
{
|
{
|
register int count = 0;
|
register int count = 0;
|
register char *scan;
|
register char *scan;
|
register char *opnd;
|
register char *opnd;
|
|
|
scan = restate->reginput;
|
scan = restate->reginput;
|
opnd = OPERAND(p);
|
opnd = OPERAND(p);
|
switch (OP(p)) {
|
switch (OP(p)) {
|
case ANY:
|
case ANY:
|
count = strlen(scan);
|
count = strlen(scan);
|
scan += count;
|
scan += count;
|
break;
|
break;
|
case EXACTLY:
|
case EXACTLY:
|
while (*opnd == *scan) {
|
while (*opnd == *scan) {
|
count++;
|
count++;
|
scan++;
|
scan++;
|
}
|
}
|
break;
|
break;
|
case ANYOF:
|
case ANYOF:
|
while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
|
while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
|
count++;
|
count++;
|
scan++;
|
scan++;
|
}
|
}
|
break;
|
break;
|
case ANYBUT:
|
case ANYBUT:
|
while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
|
while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
|
count++;
|
count++;
|
scan++;
|
scan++;
|
}
|
}
|
break;
|
break;
|
default: /* Oh dear. Called inappropriately. */
|
default: /* Oh dear. Called inappropriately. */
|
TclRegError("internal foulup");
|
TclRegError("internal foulup");
|
count = 0; /* Best compromise. */
|
count = 0; /* Best compromise. */
|
break;
|
break;
|
}
|
}
|
restate->reginput = scan;
|
restate->reginput = scan;
|
|
|
return(count);
|
return(count);
|
}
|
}
|
|
|
/*
|
/*
|
- regnext - dig the "next" pointer out of a node
|
- regnext - dig the "next" pointer out of a node
|
*/
|
*/
|
static char *
|
static char *
|
regnext(p)
|
regnext(p)
|
register char *p;
|
register char *p;
|
{
|
{
|
register int offset;
|
register int offset;
|
|
|
if (p == ®dummy)
|
if (p == ®dummy)
|
return(NULL);
|
return(NULL);
|
|
|
offset = NEXT(p);
|
offset = NEXT(p);
|
if (offset == 0)
|
if (offset == 0)
|
return(NULL);
|
return(NULL);
|
|
|
if (OP(p) == BACK)
|
if (OP(p) == BACK)
|
return(p-offset);
|
return(p-offset);
|
else
|
else
|
return(p+offset);
|
return(p+offset);
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
|
|
static char *regprop();
|
static char *regprop();
|
|
|
/*
|
/*
|
- regdump - dump a regexp onto stdout in vaguely comprehensible form
|
- regdump - dump a regexp onto stdout in vaguely comprehensible form
|
*/
|
*/
|
void
|
void
|
regdump(r)
|
regdump(r)
|
regexp *r;
|
regexp *r;
|
{
|
{
|
register char *s;
|
register char *s;
|
register char op = EXACTLY; /* Arbitrary non-END op. */
|
register char op = EXACTLY; /* Arbitrary non-END op. */
|
register char *next;
|
register char *next;
|
|
|
|
|
s = r->program + 1;
|
s = r->program + 1;
|
while (op != END) { /* While that wasn't END last time... */
|
while (op != END) { /* While that wasn't END last time... */
|
op = OP(s);
|
op = OP(s);
|
printf("%2d%s", s-r->program, regprop(s)); /* Where, what. */
|
printf("%2d%s", s-r->program, regprop(s)); /* Where, what. */
|
next = regnext(s);
|
next = regnext(s);
|
if (next == NULL) /* Next ptr. */
|
if (next == NULL) /* Next ptr. */
|
printf("(0)");
|
printf("(0)");
|
else
|
else
|
printf("(%d)", (s-r->program)+(next-s));
|
printf("(%d)", (s-r->program)+(next-s));
|
s += 3;
|
s += 3;
|
if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
|
if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
|
/* Literal string, where present. */
|
/* Literal string, where present. */
|
while (*s != '\0') {
|
while (*s != '\0') {
|
putchar(*s);
|
putchar(*s);
|
s++;
|
s++;
|
}
|
}
|
s++;
|
s++;
|
}
|
}
|
putchar('\n');
|
putchar('\n');
|
}
|
}
|
|
|
/* Header fields of interest. */
|
/* Header fields of interest. */
|
if (r->regstart != '\0')
|
if (r->regstart != '\0')
|
printf("start `%c' ", r->regstart);
|
printf("start `%c' ", r->regstart);
|
if (r->reganch)
|
if (r->reganch)
|
printf("anchored ");
|
printf("anchored ");
|
if (r->regmust != NULL)
|
if (r->regmust != NULL)
|
printf("must have \"%s\"", r->regmust);
|
printf("must have \"%s\"", r->regmust);
|
printf("\n");
|
printf("\n");
|
}
|
}
|
|
|
/*
|
/*
|
- regprop - printable representation of opcode
|
- regprop - printable representation of opcode
|
*/
|
*/
|
static char *
|
static char *
|
regprop(op)
|
regprop(op)
|
char *op;
|
char *op;
|
{
|
{
|
register char *p;
|
register char *p;
|
static char buf[50];
|
static char buf[50];
|
|
|
(void) strcpy(buf, ":");
|
(void) strcpy(buf, ":");
|
|
|
switch (OP(op)) {
|
switch (OP(op)) {
|
case BOL:
|
case BOL:
|
p = "BOL";
|
p = "BOL";
|
break;
|
break;
|
case EOL:
|
case EOL:
|
p = "EOL";
|
p = "EOL";
|
break;
|
break;
|
case ANY:
|
case ANY:
|
p = "ANY";
|
p = "ANY";
|
break;
|
break;
|
case ANYOF:
|
case ANYOF:
|
p = "ANYOF";
|
p = "ANYOF";
|
break;
|
break;
|
case ANYBUT:
|
case ANYBUT:
|
p = "ANYBUT";
|
p = "ANYBUT";
|
break;
|
break;
|
case BRANCH:
|
case BRANCH:
|
p = "BRANCH";
|
p = "BRANCH";
|
break;
|
break;
|
case EXACTLY:
|
case EXACTLY:
|
p = "EXACTLY";
|
p = "EXACTLY";
|
break;
|
break;
|
case NOTHING:
|
case NOTHING:
|
p = "NOTHING";
|
p = "NOTHING";
|
break;
|
break;
|
case BACK:
|
case BACK:
|
p = "BACK";
|
p = "BACK";
|
break;
|
break;
|
case END:
|
case END:
|
p = "END";
|
p = "END";
|
break;
|
break;
|
case OPEN+1:
|
case OPEN+1:
|
case OPEN+2:
|
case OPEN+2:
|
case OPEN+3:
|
case OPEN+3:
|
case OPEN+4:
|
case OPEN+4:
|
case OPEN+5:
|
case OPEN+5:
|
case OPEN+6:
|
case OPEN+6:
|
case OPEN+7:
|
case OPEN+7:
|
case OPEN+8:
|
case OPEN+8:
|
case OPEN+9:
|
case OPEN+9:
|
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
|
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
|
p = NULL;
|
p = NULL;
|
break;
|
break;
|
case CLOSE+1:
|
case CLOSE+1:
|
case CLOSE+2:
|
case CLOSE+2:
|
case CLOSE+3:
|
case CLOSE+3:
|
case CLOSE+4:
|
case CLOSE+4:
|
case CLOSE+5:
|
case CLOSE+5:
|
case CLOSE+6:
|
case CLOSE+6:
|
case CLOSE+7:
|
case CLOSE+7:
|
case CLOSE+8:
|
case CLOSE+8:
|
case CLOSE+9:
|
case CLOSE+9:
|
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
|
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
|
p = NULL;
|
p = NULL;
|
break;
|
break;
|
case STAR:
|
case STAR:
|
p = "STAR";
|
p = "STAR";
|
break;
|
break;
|
case PLUS:
|
case PLUS:
|
p = "PLUS";
|
p = "PLUS";
|
break;
|
break;
|
default:
|
default:
|
if (OP(op) > OPEN && OP(op) < OPEN+NSUBEXP) {
|
if (OP(op) > OPEN && OP(op) < OPEN+NSUBEXP) {
|
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
|
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
|
p = NULL;
|
p = NULL;
|
break;
|
break;
|
} else if (OP(op) > CLOSE && OP(op) < CLOSE+NSUBEXP) {
|
} else if (OP(op) > CLOSE && OP(op) < CLOSE+NSUBEXP) {
|
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
|
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
|
p = NULL;
|
p = NULL;
|
} else {
|
} else {
|
TclRegError("corrupted opcode");
|
TclRegError("corrupted opcode");
|
}
|
}
|
break;
|
break;
|
}
|
}
|
if (p != NULL)
|
if (p != NULL)
|
(void) strcat(buf, p);
|
(void) strcat(buf, p);
|
return(buf);
|
return(buf);
|
}
|
}
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* The following is provided for those people who do not have strcspn() in
|
* 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
|
* their C libraries. They should get off their butts and do something
|
* about it; at least one public-domain implementation of those (highly
|
* about it; at least one public-domain implementation of those (highly
|
* useful) string routines has been published on Usenet.
|
* useful) string routines has been published on Usenet.
|
*/
|
*/
|
#ifdef STRCSPN
|
#ifdef STRCSPN
|
/*
|
/*
|
* strcspn - find length of initial segment of s1 consisting entirely
|
* strcspn - find length of initial segment of s1 consisting entirely
|
* of characters not from s2
|
* of characters not from s2
|
*/
|
*/
|
|
|
static int
|
static int
|
strcspn(s1, s2)
|
strcspn(s1, s2)
|
char *s1;
|
char *s1;
|
char *s2;
|
char *s2;
|
{
|
{
|
register char *scan1;
|
register char *scan1;
|
register char *scan2;
|
register char *scan2;
|
register int count;
|
register int count;
|
|
|
count = 0;
|
count = 0;
|
for (scan1 = s1; *scan1 != '\0'; scan1++) {
|
for (scan1 = s1; *scan1 != '\0'; scan1++) {
|
for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */
|
for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */
|
if (*scan1 == *scan2++)
|
if (*scan1 == *scan2++)
|
return(count);
|
return(count);
|
count++;
|
count++;
|
}
|
}
|
return(count);
|
return(count);
|
}
|
}
|
#endif
|
#endif
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TclRegError --
|
* TclRegError --
|
*
|
*
|
* This procedure is invoked by the regexp code when an error
|
* This procedure is invoked by the regexp code when an error
|
* occurs. It saves the error message so it can be seen by the
|
* occurs. It saves the error message so it can be seen by the
|
* code that called Spencer's code.
|
* code that called Spencer's code.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* The value of "string" is saved in "errMsg".
|
* The value of "string" is saved in "errMsg".
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
TclRegError(string)
|
TclRegError(string)
|
char *string; /* Error message. */
|
char *string; /* Error message. */
|
{
|
{
|
errMsg = string;
|
errMsg = string;
|
}
|
}
|
|
|
char *
|
char *
|
TclGetRegError()
|
TclGetRegError()
|
{
|
{
|
return errMsg;
|
return errMsg;
|
}
|
}
|
|
|
