e576bb | 2002-10-11 | Martin Nilsson | |
|
1b10db | 2002-10-08 | Martin Nilsson | |
|
ab6aec | 1997-02-11 | Fredrik 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.
*
*/
#include "global.h"
#include <ctype.h>
|
932a1d | 1997-09-10 | Henrik Grubbström (Grubba) | | #ifdef HAVE_STRING_H
#include <string.h>
#endif /* HAVE_STRING_H */
|
7369d3 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | #include "pike_regexp.h"
|
9aa6fa | 1997-05-19 | Fredrik Hübinette (Hubbe) | | #include "pike_memory.h"
|
b2d3e4 | 2000-12-01 | Fredrik Hübinette (Hubbe) | | #include "pike_error.h"
|
151a6c | 2010-08-16 | Martin Stjernholm | | #include "interpret.h"
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
e48a9b | 2006-07-10 | Martin Nilsson | | #undef NOTHING
|
6dc277 | 2000-07-28 | Fredrik Hübinette (Hubbe) | |
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
#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
* string. */
#define BRANCH 6 /* node Match this alternative, or the
* nxt... */
#define BACK 7 /* no Match "", "nxt" 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
* times. */
#define WORDSTART 11 /* node matching a start of a word */
#define WORDEND 12 /* node matching an end of a word */
|
4138da | 2010-08-16 | Martin Stjernholm | | #define KPLUS 13 /* node Match this (simple) thing 1 or more
* times. */
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | #define OPEN 20 /* no Mark this point in input as start of
* #n. */
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | #define CLOSE (OPEN+NSUBEXP) /* no Analogous to OPEN. */
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
4138da | 2010-08-16 | Martin Stjernholm | | * STAR,KPLUS Complex cases are implemented as circular BRANCH structures
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | * using BACK. Simple cases (one character per match) are
|
4138da | 2010-08-16 | Martin Stjernholm | | * implemented with STAR or KPLUS for speed and to minimize
* recursive plunges.
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | *
* OPEN,CLOSE ...are numbered at compile time.
*/
#define OP(p) (*(p))
#define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
#define OPERAND(p) ((p) + 3)
|
b2d3e4 | 2000-12-01 | Fredrik Hübinette (Hubbe) | | #define regerror(X) Pike_error("Regexp: %s\n",X);
|
ab6aec | 1997-02-11 | Fredrik 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) == '_' )
#define HASWIDTH 01 /* Known never to match null string. */
|
4138da | 2010-08-16 | Martin Stjernholm | | #define SIMPLE 02 /* Simple enough to be STAR or KPLUS operand. */
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | #define SPSTART 04 /* Starts with * */
#define WORST 0 /* Worst case. */
static short *regparse;
static int regnpar;
static char *regcode;
static long regsize;
|
84c5c6 | 2015-04-19 | Martin Nilsson | | static char regdummy;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
7b0696 | 2015-04-19 | Martin Nilsson | | static char *reg(int, int *);
static char *regbranch(int *);
static char *regpiece(int *);
static char *regatom(int *);
static char *regnode(char);
static char *regnext(register char *);
static void regc(char b);
static void reginsert(char, char *);
static void regtail(char *, char *);
static void regoptail(char *, char *);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
21ba56 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regexp *pike_regcomp(char *exp,int excompat)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register regexp *r;
register char *scan;
register char *longest;
|
4ed1bf | 2000-09-14 | Henrik Grubbström (Grubba) | | register ptrdiff_t len;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | int flags;
short *exp2,*dest,c;
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (exp == NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | FAIL("NULL argument");
|
dc8d02 | 2014-04-27 | Martin Nilsson | | exp2=xalloc( (strlen(exp)+1) * sizeof(short) );
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | for ( scan=exp,dest=exp2;( c= UCHARAT(scan++)); ) {
switch (c) {
case '(':
case ')':
*dest++ = excompat ? c : c | SPECIAL;
break;
case '.':
case '*':
case '+':
case '|':
case '$':
case '^':
case '[':
case ']':
*dest++ = c | SPECIAL;
break;
case '\\':
switch ( c = *scan++ ) {
case '(':
case ')':
*dest++ = excompat ? c | SPECIAL : c;
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;
}
}
*dest=0;
regparse = exp2;
regnpar = 1;
regsize = 0L;
regcode = ®dummy;
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (reg(0, &flags) == NULL)
return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
if (regsize >= 32767L)
FAIL("regexp too big");
|
dc8d02 | 2014-04-27 | Martin Nilsson | | r = xalloc(sizeof(regexp) + (unsigned) regsize);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
regparse = exp2;
regnpar = 1;
regcode = r->program;
if (reg(0, &flags) == NULL)
|
bf7519 | 2015-04-19 | Martin Nilsson | | return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
r->regstart = '\0';
r->reganch = 0;
r->regmust = NULL;
r->regmlen = 0;
|
dd7b3c | 2003-08-12 | Martin Nilsson | | scan = r->program;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | if (OP(regnext(scan)) == END) {
scan = OPERAND(scan);
if (OP(scan) == EXACTLY)
r->regstart = *OPERAND(scan);
else if (OP(scan) == BOL)
r->reganch++;
if (flags & SPSTART) {
longest = NULL;
len = 0;
for (; scan != NULL; scan = regnext(scan))
if (OP(scan) == EXACTLY &&
|
4ed1bf | 2000-09-14 | Henrik Grubbström (Grubba) | | strlen(OPERAND(scan)) >= (size_t)len) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | longest = OPERAND(scan);
len = strlen(OPERAND(scan));
}
r->regmust = longest;
r->regmlen = len;
}
}
|
0ec752 | 2014-04-27 | Martin Nilsson | | free(exp2);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return (r);
}
|
ae9a03 | 1997-11-07 | Henrik Grubbström (Grubba) | | static char *reg(int paren,int *flagp)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *ret;
register char *br;
register char *ender;
register int parno=0;
int flags;
*flagp = HASWIDTH;
if (paren) {
if (regnpar >= NSUBEXP)
FAIL("too many ()");
parno = regnpar;
regnpar++;
|
f25837 | 2000-09-08 | Henrik Grubbström (Grubba) | | ret = regnode((char)(OPEN + parno));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | } else
|
bf7519 | 2015-04-19 | Martin Nilsson | | ret = NULL;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
br = regbranch(&flags);
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (br == NULL)
return (NULL);
if (ret != NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regtail(ret, br);
else
ret = br;
if (!(flags & HASWIDTH))
*flagp &= ~HASWIDTH;
*flagp |= flags & SPSTART;
while (*regparse == OR_OP) {
regparse++;
br = regbranch(&flags);
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (br == NULL)
return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regtail(ret, br);
if (!(flags & HASWIDTH))
*flagp &= ~HASWIDTH;
*flagp |= flags & SPSTART;
}
|
a30921 | 2000-09-11 | Henrik Grubbström (Grubba) | | ender = regnode((char)((paren) ? (CLOSE + parno) : END));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regtail(ret, ender);
|
bf7519 | 2015-04-19 | Martin Nilsson | | for (br = ret; br != NULL; br = regnext(br))
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regoptail(br, ender);
if (paren && *regparse++ != RBRAC) {
FAIL("unmatched ()");
} else if (!paren && *regparse != '\0') {
if (*regparse == RBRAC) {
FAIL("unmatched ()");
} else
FAIL("junk on end");
}
return (ret);
}
|
ae9a03 | 1997-11-07 | Henrik Grubbström (Grubba) | | static char *regbranch(int *flagp)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *ret;
register char *chain;
register char *latest;
int flags;
*flagp = WORST;
ret = regnode(BRANCH);
|
bf7519 | 2015-04-19 | Martin Nilsson | | chain = NULL;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | while (*regparse != '\0' && *regparse != OR_OP && *regparse != RBRAC) {
latest = regpiece(&flags);
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (latest == NULL)
return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | *flagp |= flags & HASWIDTH;
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (chain == NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | *flagp |= flags & SPSTART;
else
regtail(chain, latest);
chain = latest;
}
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (chain == NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regnode(NOTHING);
return (ret);
}
|
4138da | 2010-08-16 | Martin Stjernholm | | - regpiece - something followed by possible [*] or [+]
|
ab6aec | 1997-02-11 | Fredrik 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.
*/
|
ae9a03 | 1997-11-07 | Henrik Grubbström (Grubba) | | static char *regpiece(int *flagp)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *ret;
register short op;
int flags;
ret = regatom(&flags);
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (ret == NULL)
return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
op = *regparse;
if (!ISMULT(op)) {
*flagp = flags;
return (ret);
}
if (!(flags & HASWIDTH))
FAIL("* or + operand could be empty");
*flagp = (WORST | SPSTART);
if(op == ASTERIX)
{
if (flags & SIMPLE)
{
reginsert(STAR, ret);
}
else
{
reginsert(BRANCH, ret);
regoptail(ret, regnode(BACK));
regoptail(ret, ret);
regtail(ret, regnode(BRANCH));
regtail(ret, regnode(NOTHING));
}
}
else if(op == PLUS)
{
|
4138da | 2010-08-16 | Martin Stjernholm | | if (flags & SIMPLE)
{
reginsert(KPLUS, ret);
}
else
{
|
061ce8 | 2010-08-16 | Martin Stjernholm | |
|
4138da | 2010-08-16 | Martin Stjernholm | | char *tmp;
tmp=regnode(BACK);
reginsert(BRANCH, tmp);
regtail(ret, tmp);
regoptail(tmp, ret);
regtail(ret, regnode(BRANCH));
regtail(ret, regnode(NOTHING));
}
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | }
regparse++;
if (ISMULT(*regparse))
FAIL("nested * or +");
return (ret);
}
|
ae9a03 | 1997-11-07 | Henrik Grubbström (Grubba) | | static char *regatom(int *flagp)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *ret;
int flags;
*flagp = WORST;
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:{
register int class;
register int classend;
if (*regparse == CARET) {
ret = regnode(ANYBUT);
regparse++;
} else
ret = regnode(ANYOF);
if (*regparse == RSQBRAC || *regparse == '-')
|
f25837 | 2000-09-08 | Henrik Grubbström (Grubba) | | regc((char)(*regparse++));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | while (*regparse != '\0' && *regparse != RSQBRAC) {
if (*regparse == '-') {
regparse++;
if (*regparse == RSQBRAC || *regparse == '\0')
regc('-');
else {
class = (CHARBITS & *(regparse - 2)) + 1;
classend = (CHARBITS & *(regparse));
if (class > classend + 1)
FAIL("invalid [] range");
for (; class <= classend; class++)
|
f25837 | 2000-09-08 | Henrik Grubbström (Grubba) | | regc((char)class);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regparse++;
}
} else
|
f25837 | 2000-09-08 | Henrik Grubbström (Grubba) | | regc((char)(*regparse++));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | }
regc('\0');
if (*regparse != RSQBRAC)
FAIL("unmatched []");
regparse++;
*flagp |= HASWIDTH | SIMPLE;
}
break;
case LBRAC:
ret = reg(1, &flags);
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (ret == NULL)
return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | *flagp |= flags & (HASWIDTH | SPSTART);
break;
case '\0':
case OR_OP:
case RBRAC:
FAIL("internal urp");
case ASTERIX:
FAIL("* follows nothing\n");
default:{
register int len;
register short ender;
regparse--;
for (len=0; regparse[len] &&
!(regparse[len]&SPECIAL) && regparse[len] != RSQBRAC; len++) ;
if (len <= 0)
{
FAIL("internal disaster");
}
ender = *(regparse + len);
if (len > 1 && ISMULT(ender))
len--;
*flagp |= HASWIDTH;
if (len == 1)
*flagp |= SIMPLE;
ret = regnode(EXACTLY);
while (len > 0) {
|
f25837 | 2000-09-08 | Henrik Grubbström (Grubba) | | regc((char)(*regparse++));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | len--;
}
regc('\0');
}
break;
}
return (ret);
}
|
b191e6 | 1997-09-06 | Henrik Grubbström (Grubba) | | static char *regnode(char op)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *ret;
register char *ptr;
ret = regcode;
if (ret == ®dummy) {
regsize += 3;
return (ret);
}
ptr = ret;
*ptr++ = op;
*ptr++ = '\0';
*ptr++ = '\0';
regcode = ptr;
return (ret);
}
|
b191e6 | 1997-09-06 | Henrik Grubbström (Grubba) | | static void regc(char b)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
if (regcode != ®dummy)
*regcode++ = b;
else
regsize++;
}
|
b191e6 | 1997-09-06 | Henrik Grubbström (Grubba) | | static void reginsert(char op, char *opnd)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *src;
register char *dst;
register char *place;
if (regcode == ®dummy) {
regsize += 3;
return;
}
src = regcode;
regcode += 3;
dst = regcode;
while (src > opnd)
*--dst = *--src;
place = opnd;
*place++ = op;
*place++ = '\0';
*place++ = '\0';
}
|
ae9a03 | 1997-11-07 | Henrik Grubbström (Grubba) | | static void regtail(char *p, char *val)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
|
a17d76 | 2000-08-11 | Henrik Grubbström (Grubba) | | register char *scan;
register char *temp;
register ptrdiff_t offset;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
if (p == ®dummy)
return;
scan = p;
for (;;) {
temp = regnext(scan);
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (temp == NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | break;
scan = temp;
}
if (OP(scan) == BACK)
offset = scan - val;
else
offset = val - scan;
|
a17d76 | 2000-08-11 | Henrik Grubbström (Grubba) | | *(scan + 1) = DO_NOT_WARN((offset >> 8) & 0377);
*(scan + 2) = DO_NOT_WARN(offset & 0377);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | }
|
ae9a03 | 1997-11-07 | Henrik Grubbström (Grubba) | | static void regoptail(char *p, char *val)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (p == NULL || p == ®dummy || OP(p) != BRANCH)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return;
regtail(OPERAND(p), val);
}
static char *reginput;
static char *regbol;
static char **regstartp;
static char **regendp;
|
7b0696 | 2015-04-19 | Martin Nilsson | | static int regtry(regexp *, char *);
static int regmatch(char *);
static ptrdiff_t regrepeat(char *);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | int regnarrate = 0;
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void regdump(regexp *);
|
7b0696 | 2015-04-19 | Martin Nilsson | | static char *regprop(char *op);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | #endif
|
21ba56 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | int pike_regexec(regexp *prog, char *string)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *s;
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (prog == NULL || string == NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regerror("NULL parameter");
return (0);
}
|
dd7b3c | 2003-08-12 | Martin Nilsson | |
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (prog->regmust != NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | s = string;
|
bf7519 | 2015-04-19 | Martin Nilsson | | while ((s = strchr(s, prog->regmust[0])) != NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | if (strncmp(s, prog->regmust, prog->regmlen) == 0)
break;
s++;
}
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (s == NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return (0);
}
regbol = string;
if (prog->reganch)
return (regtry(prog, string));
s = string;
if (prog->regstart != '\0')
|
bf7519 | 2015-04-19 | Martin Nilsson | | while ((s = strchr(s, prog->regstart)) != NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | if (regtry(prog, s))
return (1);
s++;
}
else
do {
if (regtry(prog, s))
return (1);
} while (*s++ != '\0');
return (0);
}
static int regtry(regexp *prog, char *string)
{
register int i;
register char **sp;
register char **ep;
reginput = string;
regstartp = prog->startp;
regendp = prog->endp;
sp = prog->startp;
ep = prog->endp;
for (i = NSUBEXP; i > 0; i--) {
|
bf7519 | 2015-04-19 | Martin Nilsson | | *sp++ = NULL;
*ep++ = NULL;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | }
|
dd7b3c | 2003-08-12 | Martin Nilsson | | if (regmatch(prog->program)) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | prog->startp[0] = string;
prog->endp[0] = reginput;
return (1);
} else
return (0);
}
static int regmatch(char *prog)
{
register char *scan;
char *nxt;
|
151a6c | 2010-08-16 | Martin Stjernholm | | check_c_stack (4 * sizeof (void *));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | scan = prog;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (scan != NULL && regnarrate)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | fprintf(stderr, "%s(\n", regprop(scan));
#endif
|
bf7519 | 2015-04-19 | Martin Nilsson | | while (scan != NULL) {
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | if (regnarrate)
fprintf(stderr, "%s...\n", regprop(scan));
#endif
nxt = regnext(scan);
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' ||
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | ISWORDPART( *((unsigned char *)reginput-1) ) ||
!ISWORDPART( *((unsigned char *)reginput) ) )
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return (0);
break;
case WORDEND:
if (*reginput == '\0')
break;
if ( reginput == regbol ||
|
291600 | 1998-01-16 | Henrik Grubbström (Grubba) | | !ISWORDPART( *((unsigned char *)reginput-1) ) ||
ISWORDPART( *((unsigned char *)reginput) ) )
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return (0);
break;
case EXACTLY:{
|
4ed1bf | 2000-09-14 | Henrik Grubbström (Grubba) | | register ptrdiff_t len;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | register char *opnd;
opnd = OPERAND(scan);
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' ||
|
bf7519 | 2015-04-19 | Martin Nilsson | | strchr(OPERAND(scan), *reginput) == NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return (0);
reginput++;
break;
case ANYBUT:
if (*reginput == '\0' ||
|
bf7519 | 2015-04-19 | Martin Nilsson | | strchr(OPERAND(scan), *reginput) != NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return (0);
reginput++;
break;
case NOTHING:
break;
case BACK:
break;
case BRANCH:{
register char *save;
if (OP(nxt) != BRANCH)
nxt = OPERAND(scan);
else {
do {
save = reginput;
if (regmatch(OPERAND(scan)))
return (1);
reginput = save;
scan = regnext(scan);
|
bf7519 | 2015-04-19 | Martin Nilsson | | } while (scan != NULL && OP(scan) == BRANCH);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | return (0);
}
}
break;
|
4138da | 2010-08-16 | Martin Stjernholm | | case KPLUS:
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | case STAR:{
register char nextch;
|
4ed1bf | 2000-09-14 | Henrik Grubbström (Grubba) | | register ptrdiff_t no;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | register char *save;
|
4ed1bf | 2000-09-14 | Henrik Grubbström (Grubba) | | register ptrdiff_t minimum;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
nextch = '\0';
if (OP(nxt) == EXACTLY)
nextch = *OPERAND(nxt);
minimum = (OP(scan) == STAR) ? 0 : 1;
save = reginput;
|
e0ece8 | 2000-09-03 | Marcus Comstedt | | no = regrepeat(OPERAND(scan));
while (no >= minimum) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
if (nextch == '\0' || *reginput == nextch)
if (regmatch(nxt))
return (1);
no--;
reginput = save + no;
}
return (0);
}
case END:
return (1);
default:
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | if(OP(scan) >= OPEN && OP(scan)<OPEN+NSUBEXP)
{
register int no;
register char *save;
no = OP(scan) - OPEN;
save = reginput;
if (regmatch(nxt)) {
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (regstartp[no] == NULL)
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | regstartp[no] = save;
return (1);
} else
return (0);
}
if(OP(scan) >= CLOSE && OP(scan)<CLOSE+NSUBEXP)
{
register int no;
register char *save;
no = OP(scan) - CLOSE;
save = reginput;
if (regmatch(nxt)) {
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (regendp[no] == NULL)
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | regendp[no] = save;
return (1);
} else
return (0);
}
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regerror("memory corruption");
return (0);
}
scan = nxt;
}
regerror("corrupted pointers");
return (0);
}
|
4ed1bf | 2000-09-14 | Henrik Grubbström (Grubba) | | static ptrdiff_t regrepeat(char *p)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
|
4ed1bf | 2000-09-14 | Henrik Grubbström (Grubba) | | register ptrdiff_t count = 0;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | register char *scan;
register char *opnd;
scan = reginput;
opnd = OPERAND(p);
switch (OP(p)) {
case ANY:
count = strlen(scan);
scan += count;
break;
case EXACTLY:
while (*opnd == *scan) {
count++;
scan++;
}
break;
case ANYOF:
|
bf7519 | 2015-04-19 | Martin Nilsson | | while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | count++;
scan++;
}
break;
case ANYBUT:
|
bf7519 | 2015-04-19 | Martin Nilsson | | while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | count++;
scan++;
}
break;
default:
regerror("internal foulup");
count = 0;
break;
}
reginput = scan;
return (count);
}
static char *regnext(register char *p)
{
register int offset;
if (p == ®dummy)
|
bf7519 | 2015-04-19 | Martin Nilsson | | return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
offset = NEXT(p);
if (offset == 0)
|
bf7519 | 2015-04-19 | Martin Nilsson | | return (NULL);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
if (OP(p) == BACK)
return (p - offset);
else
return (p + offset);
}
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
7b0696 | 2015-04-19 | Martin Nilsson | | static char *regprop(char *);
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
void regdump(regexp *r)
{
register char *s;
register char op = EXACTLY;
register char *nxt;
|
dd7b3c | 2003-08-12 | Martin Nilsson | | s = r->program;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | while (op != END) {
op = OP(s);
|
a17d76 | 2000-08-11 | Henrik Grubbström (Grubba) | | printf("%2ld%s",
DO_NOT_WARN((long)(s - r->program)),
regprop(s));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | nxt = regnext(s);
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (nxt == NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | printf("(0)");
else
|
a17d76 | 2000-08-11 | Henrik Grubbström (Grubba) | | printf("(%ld)",
DO_NOT_WARN((long)( (s - r->program) + (nxt - s))));
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | s += 3;
if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
while (*s != '\0') {
putchar(*s);
s++;
}
s++;
}
putchar('\n');
}
if (r->regstart != '\0')
printf("start `%c' ", r->regstart);
if (r->reganch)
printf("anchored ");
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (r->regmust != NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | printf("must have \"%s\"", r->regmust);
printf("\n");
}
static char *regprop(char *op)
{
register char *p;
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;
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | |
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | case STAR:
p = "STAR";
break;
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | |
|
4138da | 2010-08-16 | Martin Stjernholm | | case KPLUS:
p = "KPLUS";
break;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | default:
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | if(OP(op) >= OPEN && OP(op) < OPEN+NSUBEXP)
{
sprintf(buf + strlen(buf), "OPEN%d", OP(op) - OPEN);
|
bf7519 | 2015-04-19 | Martin Nilsson | | p = NULL;
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | break;
}
if(OP(op) >= CLOSE && OP(op) < CLOSE+NSUBEXP)
{
sprintf(buf + strlen(buf), "CLOSE%d", OP(op) - CLOSE);
|
bf7519 | 2015-04-19 | Martin Nilsson | | p = NULL;
|
bfe763 | 1998-03-25 | Fredrik Hübinette (Hubbe) | | break;
}
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regerror("corrupted opcode");
|
bf7519 | 2015-04-19 | Martin Nilsson | | p=NULL;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | break;
}
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (p != NULL)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | strcat(buf, p);
return (buf);
}
#endif
|
21ba56 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | char *pike_regsub(regexp *prog, char *source, char *dest, int n)
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | {
register char *src;
register char *dst;
register char c;
register int no;
|
a17d76 | 2000-08-11 | Henrik Grubbström (Grubba) | | register ptrdiff_t len;
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | |
|
bf7519 | 2015-04-19 | Martin Nilsson | | if (prog == NULL ||
source == NULL || dest == NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | regerror("NULL parm to regsub");
return NULL;
}
|
dd7b3c | 2003-08-12 | Martin Nilsson | |
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | src = source;
dst = dest;
while ((c = *src++) != '\0') {
if (c == '&')
no = 0;
else if (c == '\\' && '0' <= *src && *src <= '9')
no = *src++ - '0';
else
no = -1;
if (no < 0) {
if (c == '\\' && (*src == '\\' || *src == '&'))
c = *src++;
if (--n < 0) {
regerror("line too long");
return NULL;
}
*dst++ = c;
|
bf7519 | 2015-04-19 | Martin Nilsson | | } else if (prog->startp[no] != NULL &&
prog->endp[no] != NULL) {
|
ab6aec | 1997-02-11 | Fredrik Hübinette (Hubbe) | | len = prog->endp[no] - prog->startp[no];
if ( (n-=len) < 0 ) {
regerror("line too long");
return NULL;
}
strncpy(dst, prog->startp[no], len);
dst += len;
if (len != 0 && *(dst - 1) == '\0') {
regerror("damaged match string");
return NULL;
}
}
}
if (--n < 0) {
regerror("line too long");
return NULL;
}
*dst = '\0';
return dst;
}
|