2003-02-05 18:41:33 +01:00
|
|
|
/*
|
|
|
|
* lexical analyzer
|
|
|
|
* This file is #included by regcomp.c.
|
|
|
|
*
|
2003-08-04 02:43:34 +02:00
|
|
|
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
|
|
|
*
|
2003-02-05 18:41:33 +01:00
|
|
|
* Development of this software was funded, in part, by Cray Research Inc.,
|
|
|
|
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
|
|
|
* Corporation, none of whom are responsible for the results. The author
|
2003-08-04 02:43:34 +02:00
|
|
|
* thanks all of them.
|
|
|
|
*
|
2003-02-05 18:41:33 +01:00
|
|
|
* Redistribution and use in source and binary forms -- with or without
|
|
|
|
* modification -- are permitted for any purpose, provided that
|
|
|
|
* redistributions in source form retain this entire copyright notice and
|
|
|
|
* indicate the origin and nature of any modifications.
|
2003-08-04 02:43:34 +02:00
|
|
|
*
|
2003-02-05 18:41:33 +01:00
|
|
|
* I'd appreciate being given credit for this package in the documentation
|
|
|
|
* of software which uses it, but that is not a requirement.
|
2003-08-04 02:43:34 +02:00
|
|
|
*
|
2003-02-05 18:41:33 +01:00
|
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
|
|
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
|
|
* HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
2009-06-11 16:49:15 +02:00
|
|
|
* $PostgreSQL: pgsql/src/backend/regex/regc_lex.c,v 1.9 2009/06/11 14:49:01 momjian Exp $
|
2003-02-05 18:41:33 +01:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* scanning macros (know about v) */
|
2003-08-04 02:43:34 +02:00
|
|
|
#define ATEOS() (v->now >= v->stop)
|
|
|
|
#define HAVE(n) (v->stop - v->now >= (n))
|
|
|
|
#define NEXT1(c) (!ATEOS() && *v->now == CHR(c))
|
|
|
|
#define NEXT2(a,b) (HAVE(2) && *v->now == CHR(a) && *(v->now+1) == CHR(b))
|
|
|
|
#define NEXT3(a,b,c) (HAVE(3) && *v->now == CHR(a) && \
|
2003-02-05 18:41:33 +01:00
|
|
|
*(v->now+1) == CHR(b) && \
|
|
|
|
*(v->now+2) == CHR(c))
|
2003-08-04 02:43:34 +02:00
|
|
|
#define SET(c) (v->nexttype = (c))
|
|
|
|
#define SETV(c, n) (v->nexttype = (c), v->nextvalue = (n))
|
|
|
|
#define RET(c) return (SET(c), 1)
|
|
|
|
#define RETV(c, n) return (SETV(c, n), 1)
|
|
|
|
#define FAILW(e) return (ERR(e), 0) /* ERR does SET(EOS) */
|
|
|
|
#define LASTTYPE(t) (v->lasttype == (t))
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
/* lexical contexts */
|
2003-08-04 02:43:34 +02:00
|
|
|
#define L_ERE 1 /* mainline ERE/ARE */
|
|
|
|
#define L_BRE 2 /* mainline BRE */
|
|
|
|
#define L_Q 3 /* REG_QUOTE */
|
|
|
|
#define L_EBND 4 /* ERE/ARE bound */
|
|
|
|
#define L_BBND 5 /* BRE bound */
|
|
|
|
#define L_BRACK 6 /* brackets */
|
|
|
|
#define L_CEL 7 /* collating element */
|
|
|
|
#define L_ECL 8 /* equivalence class */
|
|
|
|
#define L_CCL 9 /* character class */
|
|
|
|
#define INTOCON(c) (v->lexcon = (c))
|
|
|
|
#define INCON(con) (v->lexcon == (con))
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
/* construct pointer past end of chr array */
|
2003-08-04 02:43:34 +02:00
|
|
|
#define ENDOF(array) ((array) + sizeof(array)/sizeof(chr))
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* lexstart - set up lexical stuff, scan leading options
|
|
|
|
*/
|
|
|
|
static void
|
2003-08-04 02:43:34 +02:00
|
|
|
lexstart(struct vars * v)
|
2003-02-05 18:41:33 +01:00
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
prefixes(v); /* may turn on new type bits etc. */
|
2003-02-05 18:41:33 +01:00
|
|
|
NOERR();
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
if (v->cflags & REG_QUOTE)
|
|
|
|
{
|
|
|
|
assert(!(v->cflags & (REG_ADVANCED | REG_EXPANDED | REG_NEWLINE)));
|
2003-02-05 18:41:33 +01:00
|
|
|
INTOCON(L_Q);
|
2003-08-04 02:43:34 +02:00
|
|
|
}
|
|
|
|
else if (v->cflags & REG_EXTENDED)
|
|
|
|
{
|
|
|
|
assert(!(v->cflags & REG_QUOTE));
|
2003-02-05 18:41:33 +01:00
|
|
|
INTOCON(L_ERE);
|
2003-08-04 02:43:34 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert(!(v->cflags & (REG_QUOTE | REG_ADVF)));
|
2003-02-05 18:41:33 +01:00
|
|
|
INTOCON(L_BRE);
|
|
|
|
}
|
|
|
|
|
|
|
|
v->nexttype = EMPTY; /* remember we were at the start */
|
2003-08-04 02:43:34 +02:00
|
|
|
next(v); /* set up the first token */
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* prefixes - implement various special prefixes
|
|
|
|
*/
|
|
|
|
static void
|
2003-08-04 02:43:34 +02:00
|
|
|
prefixes(struct vars * v)
|
2003-02-05 18:41:33 +01:00
|
|
|
{
|
|
|
|
/* literal string doesn't get any of this stuff */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (v->cflags & REG_QUOTE)
|
2003-02-05 18:41:33 +01:00
|
|
|
return;
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
/* initial "***" gets special things */
|
2003-02-05 18:41:33 +01:00
|
|
|
if (HAVE(4) && NEXT3('*', '*', '*'))
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (*(v->now + 3))
|
|
|
|
{
|
|
|
|
case CHR('?'): /* "***?" error, msg shows version */
|
|
|
|
ERR(REG_BADPAT);
|
|
|
|
return; /* proceed no further */
|
|
|
|
break;
|
|
|
|
case CHR('='): /* "***=" shifts to literal string */
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
v->cflags |= REG_QUOTE;
|
|
|
|
v->cflags &= ~(REG_ADVANCED | REG_EXPANDED | REG_NEWLINE);
|
|
|
|
v->now += 4;
|
|
|
|
return; /* and there can be no more prefixes */
|
|
|
|
break;
|
|
|
|
case CHR(':'): /* "***:" shifts to AREs */
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
v->cflags |= REG_ADVANCED;
|
|
|
|
v->now += 4;
|
|
|
|
break;
|
|
|
|
default: /* otherwise *** is just an error */
|
|
|
|
ERR(REG_BADRPT);
|
|
|
|
return;
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* BREs and EREs don't get embedded options */
|
2003-08-04 02:43:34 +02:00
|
|
|
if ((v->cflags & REG_ADVANCED) != REG_ADVANCED)
|
2003-02-05 18:41:33 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* embedded options (AREs only) */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (HAVE(3) && NEXT2('(', '?') && iscalpha(*(v->now + 2)))
|
|
|
|
{
|
2003-02-05 18:41:33 +01:00
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
v->now += 2;
|
|
|
|
for (; !ATEOS() && iscalpha(*v->now); v->now++)
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (*v->now)
|
|
|
|
{
|
|
|
|
case CHR('b'): /* BREs (but why???) */
|
|
|
|
v->cflags &= ~(REG_ADVANCED | REG_QUOTE);
|
|
|
|
break;
|
|
|
|
case CHR('c'): /* case sensitive */
|
|
|
|
v->cflags &= ~REG_ICASE;
|
|
|
|
break;
|
|
|
|
case CHR('e'): /* plain EREs */
|
|
|
|
v->cflags |= REG_EXTENDED;
|
|
|
|
v->cflags &= ~(REG_ADVF | REG_QUOTE);
|
|
|
|
break;
|
|
|
|
case CHR('i'): /* case insensitive */
|
|
|
|
v->cflags |= REG_ICASE;
|
|
|
|
break;
|
|
|
|
case CHR('m'): /* Perloid synonym for n */
|
|
|
|
case CHR('n'): /* \n affects ^ $ . [^ */
|
|
|
|
v->cflags |= REG_NEWLINE;
|
|
|
|
break;
|
|
|
|
case CHR('p'): /* ~Perl, \n affects . [^ */
|
|
|
|
v->cflags |= REG_NLSTOP;
|
|
|
|
v->cflags &= ~REG_NLANCH;
|
|
|
|
break;
|
|
|
|
case CHR('q'): /* literal string */
|
|
|
|
v->cflags |= REG_QUOTE;
|
|
|
|
v->cflags &= ~REG_ADVANCED;
|
|
|
|
break;
|
|
|
|
case CHR('s'): /* single line, \n ordinary */
|
|
|
|
v->cflags &= ~REG_NEWLINE;
|
|
|
|
break;
|
|
|
|
case CHR('t'): /* tight syntax */
|
|
|
|
v->cflags &= ~REG_EXPANDED;
|
|
|
|
break;
|
|
|
|
case CHR('w'): /* weird, \n affects ^ $ only */
|
|
|
|
v->cflags &= ~REG_NLSTOP;
|
|
|
|
v->cflags |= REG_NLANCH;
|
|
|
|
break;
|
|
|
|
case CHR('x'): /* expanded syntax */
|
|
|
|
v->cflags |= REG_EXPANDED;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ERR(REG_BADOPT);
|
|
|
|
return;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
2003-08-04 02:43:34 +02:00
|
|
|
if (!NEXT1(')'))
|
|
|
|
{
|
2003-02-05 18:41:33 +01:00
|
|
|
ERR(REG_BADOPT);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
v->now++;
|
2003-08-04 02:43:34 +02:00
|
|
|
if (v->cflags & REG_QUOTE)
|
|
|
|
v->cflags &= ~(REG_EXPANDED | REG_NEWLINE);
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lexnest - "call a subroutine", interpolating string at the lexical level
|
|
|
|
*
|
|
|
|
* Note, this is not a very general facility. There are a number of
|
|
|
|
* implicit assumptions about what sorts of strings can be subroutines.
|
|
|
|
*/
|
|
|
|
static void
|
2003-08-04 02:43:34 +02:00
|
|
|
lexnest(struct vars * v,
|
2008-02-14 18:33:37 +01:00
|
|
|
const chr *beginp, /* start of interpolation */
|
|
|
|
const chr *endp) /* one past end of interpolation */
|
2003-02-05 18:41:33 +01:00
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
assert(v->savenow == NULL); /* only one level of nesting */
|
2003-02-05 18:41:33 +01:00
|
|
|
v->savenow = v->now;
|
|
|
|
v->savestop = v->stop;
|
|
|
|
v->now = beginp;
|
|
|
|
v->stop = endp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* string constants to interpolate as expansions of things like \d
|
|
|
|
*/
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr backd[] = { /* \d */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR('['), CHR(':'),
|
|
|
|
CHR('d'), CHR('i'), CHR('g'), CHR('i'), CHR('t'),
|
|
|
|
CHR(':'), CHR(']'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr backD[] = { /* \D */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR('^'), CHR('['), CHR(':'),
|
|
|
|
CHR('d'), CHR('i'), CHR('g'), CHR('i'), CHR('t'),
|
|
|
|
CHR(':'), CHR(']'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr brbackd[] = { /* \d within brackets */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR(':'),
|
|
|
|
CHR('d'), CHR('i'), CHR('g'), CHR('i'), CHR('t'),
|
|
|
|
CHR(':'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr backs[] = { /* \s */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR('['), CHR(':'),
|
|
|
|
CHR('s'), CHR('p'), CHR('a'), CHR('c'), CHR('e'),
|
|
|
|
CHR(':'), CHR(']'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr backS[] = { /* \S */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR('^'), CHR('['), CHR(':'),
|
|
|
|
CHR('s'), CHR('p'), CHR('a'), CHR('c'), CHR('e'),
|
|
|
|
CHR(':'), CHR(']'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr brbacks[] = { /* \s within brackets */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR(':'),
|
|
|
|
CHR('s'), CHR('p'), CHR('a'), CHR('c'), CHR('e'),
|
|
|
|
CHR(':'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr backw[] = { /* \w */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR('['), CHR(':'),
|
|
|
|
CHR('a'), CHR('l'), CHR('n'), CHR('u'), CHR('m'),
|
|
|
|
CHR(':'), CHR(']'), CHR('_'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr backW[] = { /* \W */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR('^'), CHR('['), CHR(':'),
|
|
|
|
CHR('a'), CHR('l'), CHR('n'), CHR('u'), CHR('m'),
|
|
|
|
CHR(':'), CHR(']'), CHR('_'), CHR(']')
|
|
|
|
};
|
2009-06-11 16:49:15 +02:00
|
|
|
static const chr brbackw[] = { /* \w within brackets */
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('['), CHR(':'),
|
|
|
|
CHR('a'), CHR('l'), CHR('n'), CHR('u'), CHR('m'),
|
|
|
|
CHR(':'), CHR(']'), CHR('_')
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lexword - interpolate a bracket expression for word characters
|
|
|
|
* Possibly ought to inquire whether there is a "word" character class.
|
|
|
|
*/
|
|
|
|
static void
|
2003-08-04 02:43:34 +02:00
|
|
|
lexword(struct vars * v)
|
2003-02-05 18:41:33 +01:00
|
|
|
{
|
|
|
|
lexnest(v, backw, ENDOF(backw));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* next - get next token
|
|
|
|
*/
|
2003-08-04 02:43:34 +02:00
|
|
|
static int /* 1 normal, 0 failure */
|
|
|
|
next(struct vars * v)
|
2003-02-05 18:41:33 +01:00
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
chr c;
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
/* errors yield an infinite sequence of failures */
|
|
|
|
if (ISERR())
|
2003-08-04 02:43:34 +02:00
|
|
|
return 0; /* the error has set nexttype to EOS */
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
/* remember flavor of last token */
|
|
|
|
v->lasttype = v->nexttype;
|
|
|
|
|
|
|
|
/* REG_BOSONLY */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (v->nexttype == EMPTY && (v->cflags & REG_BOSONLY))
|
|
|
|
{
|
2003-02-05 18:41:33 +01:00
|
|
|
/* at start of a REG_BOSONLY RE */
|
|
|
|
RETV(SBEGIN, 0); /* same as \A */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we're nested and we've hit end, return to outer level */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (v->savenow != NULL && ATEOS())
|
|
|
|
{
|
2003-02-05 18:41:33 +01:00
|
|
|
v->now = v->savenow;
|
|
|
|
v->stop = v->savestop;
|
|
|
|
v->savenow = v->savestop = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* skip white space etc. if appropriate (not in literal or []) */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (v->cflags & REG_EXPANDED)
|
|
|
|
switch (v->lexcon)
|
|
|
|
{
|
|
|
|
case L_ERE:
|
|
|
|
case L_BRE:
|
|
|
|
case L_EBND:
|
|
|
|
case L_BBND:
|
|
|
|
skip(v);
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* handle EOS, depending on context */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (ATEOS())
|
|
|
|
{
|
|
|
|
switch (v->lexcon)
|
|
|
|
{
|
|
|
|
case L_ERE:
|
|
|
|
case L_BRE:
|
|
|
|
case L_Q:
|
|
|
|
RET(EOS);
|
|
|
|
break;
|
|
|
|
case L_EBND:
|
|
|
|
case L_BBND:
|
|
|
|
FAILW(REG_EBRACE);
|
|
|
|
break;
|
|
|
|
case L_BRACK:
|
|
|
|
case L_CEL:
|
|
|
|
case L_ECL:
|
|
|
|
case L_CCL:
|
|
|
|
FAILW(REG_EBRACK);
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
assert(NOTREACHED);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* okay, time to actually get a character */
|
|
|
|
c = *v->now++;
|
|
|
|
|
|
|
|
/* deal with the easy contexts, punt EREs to code below */
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (v->lexcon)
|
|
|
|
{
|
|
|
|
case L_BRE: /* punt BREs to separate function */
|
|
|
|
return brenext(v, c);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case L_ERE: /* see below */
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case L_Q: /* literal strings are easy */
|
|
|
|
RETV(PLAIN, c);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case L_BBND: /* bounds are fairly simple */
|
|
|
|
case L_EBND:
|
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case CHR('0'):
|
|
|
|
case CHR('1'):
|
|
|
|
case CHR('2'):
|
|
|
|
case CHR('3'):
|
|
|
|
case CHR('4'):
|
|
|
|
case CHR('5'):
|
|
|
|
case CHR('6'):
|
|
|
|
case CHR('7'):
|
|
|
|
case CHR('8'):
|
|
|
|
case CHR('9'):
|
|
|
|
RETV(DIGIT, (chr) DIGITVAL(c));
|
|
|
|
break;
|
|
|
|
case CHR(','):
|
|
|
|
RET(',');
|
|
|
|
break;
|
|
|
|
case CHR('}'): /* ERE bound ends with } */
|
|
|
|
if (INCON(L_EBND))
|
|
|
|
{
|
|
|
|
INTOCON(L_ERE);
|
|
|
|
if ((v->cflags & REG_ADVF) && NEXT1('?'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RETV('}', 0);
|
|
|
|
}
|
|
|
|
RETV('}', 1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
FAILW(REG_BADBR);
|
|
|
|
break;
|
|
|
|
case CHR('\\'): /* BRE bound ends with \} */
|
|
|
|
if (INCON(L_BBND) && NEXT1('}'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
INTOCON(L_BRE);
|
|
|
|
RET('}');
|
|
|
|
}
|
|
|
|
else
|
|
|
|
FAILW(REG_BADBR);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
FAILW(REG_BADBR);
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
2003-08-04 02:43:34 +02:00
|
|
|
assert(NOTREACHED);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case L_BRACK: /* brackets are not too hard */
|
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case CHR(']'):
|
|
|
|
if (LASTTYPE('['))
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
INTOCON((v->cflags & REG_EXTENDED) ?
|
|
|
|
L_ERE : L_BRE);
|
|
|
|
RET(']');
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHR('\\'):
|
|
|
|
NOTE(REG_UBBS);
|
|
|
|
if (!(v->cflags & REG_ADVF))
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
if (ATEOS())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
(DISCARD) lexescape(v);
|
|
|
|
switch (v->nexttype)
|
|
|
|
{ /* not all escapes okay here */
|
|
|
|
case PLAIN:
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case CCLASS:
|
|
|
|
switch (v->nextvalue)
|
|
|
|
{
|
|
|
|
case 'd':
|
|
|
|
lexnest(v, brbackd, ENDOF(brbackd));
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
lexnest(v, brbacks, ENDOF(brbacks));
|
|
|
|
break;
|
|
|
|
case 'w':
|
|
|
|
lexnest(v, brbackw, ENDOF(brbackw));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* lexnest done, back up and try again */
|
|
|
|
v->nexttype = v->lasttype;
|
|
|
|
return next(v);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* not one of the acceptable escapes */
|
|
|
|
FAILW(REG_EESCAPE);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case CHR('-'):
|
|
|
|
if (LASTTYPE('[') || NEXT1(']'))
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
else
|
|
|
|
RETV(RANGE, c);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case CHR('['):
|
|
|
|
if (ATEOS())
|
|
|
|
FAILW(REG_EBRACK);
|
|
|
|
switch (*v->now++)
|
|
|
|
{
|
|
|
|
case CHR('.'):
|
|
|
|
INTOCON(L_CEL);
|
|
|
|
/* might or might not be locale-specific */
|
|
|
|
RET(COLLEL);
|
|
|
|
break;
|
|
|
|
case CHR('='):
|
|
|
|
INTOCON(L_ECL);
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RET(ECLASS);
|
|
|
|
break;
|
|
|
|
case CHR(':'):
|
|
|
|
INTOCON(L_CCL);
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RET(CCLASS);
|
|
|
|
break;
|
|
|
|
default: /* oops */
|
|
|
|
v->now--;
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
assert(NOTREACHED);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
|
|
|
default:
|
2003-08-04 02:43:34 +02:00
|
|
|
RETV(PLAIN, c);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2003-08-04 02:43:34 +02:00
|
|
|
assert(NOTREACHED);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case L_CEL: /* collating elements are easy */
|
|
|
|
if (c == CHR('.') && NEXT1(']'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
INTOCON(L_BRACK);
|
|
|
|
RETV(END, '.');
|
|
|
|
}
|
2003-02-05 18:41:33 +01:00
|
|
|
else
|
2003-08-04 02:43:34 +02:00
|
|
|
RETV(PLAIN, c);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
2003-08-04 02:43:34 +02:00
|
|
|
case L_ECL: /* ditto equivalence classes */
|
|
|
|
if (c == CHR('=') && NEXT1(']'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
INTOCON(L_BRACK);
|
|
|
|
RETV(END, '=');
|
|
|
|
}
|
|
|
|
else
|
2003-02-05 18:41:33 +01:00
|
|
|
RETV(PLAIN, c);
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
|
|
|
case L_CCL: /* ditto character classes */
|
|
|
|
if (c == CHR(':') && NEXT1(']'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
INTOCON(L_BRACK);
|
|
|
|
RETV(END, ':');
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
2003-08-04 02:43:34 +02:00
|
|
|
else
|
|
|
|
RETV(PLAIN, c);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
|
|
|
default:
|
2003-08-04 02:43:34 +02:00
|
|
|
assert(NOTREACHED);
|
2003-02-05 18:41:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* that got rid of everything except EREs and AREs */
|
|
|
|
assert(INCON(L_ERE));
|
|
|
|
|
|
|
|
/* deal with EREs and AREs, except for backslashes */
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case CHR('|'):
|
|
|
|
RET('|');
|
|
|
|
break;
|
|
|
|
case CHR('*'):
|
|
|
|
if ((v->cflags & REG_ADVF) && NEXT1('?'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RETV('*', 0);
|
|
|
|
}
|
|
|
|
RETV('*', 1);
|
|
|
|
break;
|
|
|
|
case CHR('+'):
|
|
|
|
if ((v->cflags & REG_ADVF) && NEXT1('?'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RETV('+', 0);
|
|
|
|
}
|
|
|
|
RETV('+', 1);
|
|
|
|
break;
|
|
|
|
case CHR('?'):
|
|
|
|
if ((v->cflags & REG_ADVF) && NEXT1('?'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RETV('?', 0);
|
|
|
|
}
|
|
|
|
RETV('?', 1);
|
|
|
|
break;
|
|
|
|
case CHR('{'): /* bounds start or plain character */
|
|
|
|
if (v->cflags & REG_EXPANDED)
|
|
|
|
skip(v);
|
|
|
|
if (ATEOS() || !iscdigit(*v->now))
|
|
|
|
{
|
|
|
|
NOTE(REG_UBRACES);
|
|
|
|
NOTE(REG_UUNSPEC);
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
NOTE(REG_UBOUNDS);
|
|
|
|
INTOCON(L_EBND);
|
|
|
|
RET('{');
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
assert(NOTREACHED);
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
|
|
|
case CHR('('): /* parenthesis, or advanced extension */
|
|
|
|
if ((v->cflags & REG_ADVF) && NEXT1('?'))
|
|
|
|
{
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
v->now++;
|
|
|
|
switch (*v->now++)
|
|
|
|
{
|
|
|
|
case CHR(':'): /* non-capturing paren */
|
|
|
|
RETV('(', 0);
|
|
|
|
break;
|
|
|
|
case CHR('#'): /* comment */
|
|
|
|
while (!ATEOS() && *v->now != CHR(')'))
|
|
|
|
v->now++;
|
|
|
|
if (!ATEOS())
|
|
|
|
v->now++;
|
|
|
|
assert(v->nexttype == v->lasttype);
|
|
|
|
return next(v);
|
|
|
|
break;
|
|
|
|
case CHR('='): /* positive lookahead */
|
|
|
|
NOTE(REG_ULOOKAHEAD);
|
|
|
|
RETV(LACON, 1);
|
|
|
|
break;
|
|
|
|
case CHR('!'): /* negative lookahead */
|
|
|
|
NOTE(REG_ULOOKAHEAD);
|
|
|
|
RETV(LACON, 0);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
FAILW(REG_BADRPT);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
assert(NOTREACHED);
|
|
|
|
}
|
|
|
|
if (v->cflags & REG_NOSUB)
|
|
|
|
RETV('(', 0); /* all parens non-capturing */
|
|
|
|
else
|
|
|
|
RETV('(', 1);
|
|
|
|
break;
|
|
|
|
case CHR(')'):
|
|
|
|
if (LASTTYPE('('))
|
|
|
|
NOTE(REG_UUNSPEC);
|
|
|
|
RETV(')', c);
|
|
|
|
break;
|
|
|
|
case CHR('['): /* easy except for [[:<:]] and [[:>:]] */
|
|
|
|
if (HAVE(6) && *(v->now + 0) == CHR('[') &&
|
|
|
|
*(v->now + 1) == CHR(':') &&
|
|
|
|
(*(v->now + 2) == CHR('<') ||
|
|
|
|
*(v->now + 2) == CHR('>')) &&
|
|
|
|
*(v->now + 3) == CHR(':') &&
|
|
|
|
*(v->now + 4) == CHR(']') &&
|
|
|
|
*(v->now + 5) == CHR(']'))
|
|
|
|
{
|
|
|
|
c = *(v->now + 2);
|
|
|
|
v->now += 6;
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RET((c == CHR('<')) ? '<' : '>');
|
|
|
|
}
|
|
|
|
INTOCON(L_BRACK);
|
|
|
|
if (NEXT1('^'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
RETV('[', 0);
|
|
|
|
}
|
|
|
|
RETV('[', 1);
|
|
|
|
break;
|
|
|
|
case CHR('.'):
|
|
|
|
RET('.');
|
|
|
|
break;
|
|
|
|
case CHR('^'):
|
|
|
|
RET('^');
|
|
|
|
break;
|
|
|
|
case CHR('$'):
|
|
|
|
RET('$');
|
|
|
|
break;
|
|
|
|
case CHR('\\'): /* mostly punt backslashes to code below */
|
|
|
|
if (ATEOS())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
break;
|
|
|
|
default: /* ordinary character */
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ERE/ARE backslash handling; backslash already eaten */
|
|
|
|
assert(!ATEOS());
|
2003-08-04 02:43:34 +02:00
|
|
|
if (!(v->cflags & REG_ADVF))
|
|
|
|
{ /* only AREs have non-trivial escapes */
|
|
|
|
if (iscalnum(*v->now))
|
|
|
|
{
|
2003-02-05 18:41:33 +01:00
|
|
|
NOTE(REG_UBSALNUM);
|
|
|
|
NOTE(REG_UUNSPEC);
|
|
|
|
}
|
|
|
|
RETV(PLAIN, *v->now++);
|
|
|
|
}
|
2003-08-04 02:43:34 +02:00
|
|
|
(DISCARD) lexescape(v);
|
2003-02-05 18:41:33 +01:00
|
|
|
if (ISERR())
|
|
|
|
FAILW(REG_EESCAPE);
|
2003-08-04 02:43:34 +02:00
|
|
|
if (v->nexttype == CCLASS)
|
|
|
|
{ /* fudge at lexical level */
|
|
|
|
switch (v->nextvalue)
|
|
|
|
{
|
|
|
|
case 'd':
|
|
|
|
lexnest(v, backd, ENDOF(backd));
|
|
|
|
break;
|
|
|
|
case 'D':
|
|
|
|
lexnest(v, backD, ENDOF(backD));
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
lexnest(v, backs, ENDOF(backs));
|
|
|
|
break;
|
|
|
|
case 'S':
|
|
|
|
lexnest(v, backS, ENDOF(backS));
|
|
|
|
break;
|
|
|
|
case 'w':
|
|
|
|
lexnest(v, backw, ENDOF(backw));
|
|
|
|
break;
|
|
|
|
case 'W':
|
|
|
|
lexnest(v, backW, ENDOF(backW));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(NOTREACHED);
|
|
|
|
FAILW(REG_ASSERT);
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
/* lexnest done, back up and try again */
|
|
|
|
v->nexttype = v->lasttype;
|
|
|
|
return next(v);
|
|
|
|
}
|
|
|
|
/* otherwise, lexescape has already done the work */
|
|
|
|
return !ISERR();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lexescape - parse an ARE backslash escape (backslash already eaten)
|
|
|
|
* Note slightly nonstandard use of the CCLASS type code.
|
|
|
|
*/
|
2005-10-15 04:49:52 +02:00
|
|
|
static int /* not actually used, but convenient for RETV */
|
2003-08-04 02:43:34 +02:00
|
|
|
lexescape(struct vars * v)
|
2003-02-05 18:41:33 +01:00
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
chr c;
|
|
|
|
static chr alert[] = {
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('a'), CHR('l'), CHR('e'), CHR('r'), CHR('t')
|
|
|
|
};
|
2003-08-04 02:43:34 +02:00
|
|
|
static chr esc[] = {
|
2003-02-05 18:41:33 +01:00
|
|
|
CHR('E'), CHR('S'), CHR('C')
|
|
|
|
};
|
2008-02-14 18:33:37 +01:00
|
|
|
const chr *save;
|
2003-02-05 18:41:33 +01:00
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
assert(v->cflags & REG_ADVF);
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
assert(!ATEOS());
|
|
|
|
c = *v->now++;
|
|
|
|
if (!iscalnum(c))
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
|
|
|
|
NOTE(REG_UNONPOSIX);
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case CHR('a'):
|
|
|
|
RETV(PLAIN, chrnamed(v, alert, ENDOF(alert), CHR('\007')));
|
|
|
|
break;
|
|
|
|
case CHR('A'):
|
|
|
|
RETV(SBEGIN, 0);
|
|
|
|
break;
|
|
|
|
case CHR('b'):
|
|
|
|
RETV(PLAIN, CHR('\b'));
|
|
|
|
break;
|
|
|
|
case CHR('B'):
|
|
|
|
RETV(PLAIN, CHR('\\'));
|
|
|
|
break;
|
|
|
|
case CHR('c'):
|
|
|
|
NOTE(REG_UUNPORT);
|
|
|
|
if (ATEOS())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
RETV(PLAIN, (chr) (*v->now++ & 037));
|
|
|
|
break;
|
|
|
|
case CHR('d'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(CCLASS, 'd');
|
|
|
|
break;
|
|
|
|
case CHR('D'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(CCLASS, 'D');
|
|
|
|
break;
|
|
|
|
case CHR('e'):
|
|
|
|
NOTE(REG_UUNPORT);
|
|
|
|
RETV(PLAIN, chrnamed(v, esc, ENDOF(esc), CHR('\033')));
|
|
|
|
break;
|
|
|
|
case CHR('f'):
|
|
|
|
RETV(PLAIN, CHR('\f'));
|
|
|
|
break;
|
|
|
|
case CHR('m'):
|
|
|
|
RET('<');
|
|
|
|
break;
|
|
|
|
case CHR('M'):
|
|
|
|
RET('>');
|
|
|
|
break;
|
|
|
|
case CHR('n'):
|
|
|
|
RETV(PLAIN, CHR('\n'));
|
|
|
|
break;
|
|
|
|
case CHR('r'):
|
|
|
|
RETV(PLAIN, CHR('\r'));
|
|
|
|
break;
|
|
|
|
case CHR('s'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(CCLASS, 's');
|
|
|
|
break;
|
|
|
|
case CHR('S'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(CCLASS, 'S');
|
|
|
|
break;
|
|
|
|
case CHR('t'):
|
|
|
|
RETV(PLAIN, CHR('\t'));
|
|
|
|
break;
|
|
|
|
case CHR('u'):
|
|
|
|
c = lexdigits(v, 16, 4, 4);
|
|
|
|
if (ISERR())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
|
|
|
case CHR('U'):
|
|
|
|
c = lexdigits(v, 16, 8, 8);
|
|
|
|
if (ISERR())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
|
|
|
case CHR('v'):
|
|
|
|
RETV(PLAIN, CHR('\v'));
|
|
|
|
break;
|
|
|
|
case CHR('w'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(CCLASS, 'w');
|
|
|
|
break;
|
|
|
|
case CHR('W'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(CCLASS, 'W');
|
|
|
|
break;
|
|
|
|
case CHR('x'):
|
|
|
|
NOTE(REG_UUNPORT);
|
2005-10-15 04:49:52 +02:00
|
|
|
c = lexdigits(v, 16, 1, 255); /* REs >255 long outside spec */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (ISERR())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
|
|
|
case CHR('y'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(WBDRY, 0);
|
|
|
|
break;
|
|
|
|
case CHR('Y'):
|
|
|
|
NOTE(REG_ULOCALE);
|
|
|
|
RETV(NWBDRY, 0);
|
|
|
|
break;
|
|
|
|
case CHR('Z'):
|
|
|
|
RETV(SEND, 0);
|
|
|
|
break;
|
|
|
|
case CHR('1'):
|
|
|
|
case CHR('2'):
|
|
|
|
case CHR('3'):
|
|
|
|
case CHR('4'):
|
|
|
|
case CHR('5'):
|
|
|
|
case CHR('6'):
|
|
|
|
case CHR('7'):
|
|
|
|
case CHR('8'):
|
|
|
|
case CHR('9'):
|
|
|
|
save = v->now;
|
|
|
|
v->now--; /* put first digit back */
|
2005-10-15 04:49:52 +02:00
|
|
|
c = lexdigits(v, 10, 1, 255); /* REs >255 long outside spec */
|
2003-08-04 02:43:34 +02:00
|
|
|
if (ISERR())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
/* ugly heuristic (first test is "exactly 1 digit?") */
|
Fix assorted security-grade bugs in the regex engine. All of these problems
are shared with Tcl, since it's their code to begin with, and the patches
have been copied from Tcl 8.5.0. Problems:
CVE-2007-4769: Inadequate check on the range of backref numbers allows
crash due to out-of-bounds read.
CVE-2007-4772: Infinite loop in regex optimizer for pattern '($|^)*'.
CVE-2007-6067: Very slow optimizer cleanup for regex with a large NFA
representation, as well as crash if we encounter an out-of-memory condition
during NFA construction.
Part of the response to CVE-2007-6067 is to put a limit on the number of
states in the NFA representation of a regex. This seems needed even though
the within-the-code problems have been corrected, since otherwise the code
could try to use very large amounts of memory for a suitably-crafted regex,
leading to potential DOS by driving the system into swap, activating a kernel
OOM killer, etc.
Although there are certainly plenty of ways to drive the system into effective
DOS with poorly-written SQL queries, these problems seem worth treating as
security issues because many applications might accept regex search patterns
from untrustworthy sources.
Thanks to Will Drewry of Google for reporting these problems. Patches by Will
Drewry and Tom Lane.
Security: CVE-2007-4769, CVE-2007-4772, CVE-2007-6067
2008-01-03 21:47:55 +01:00
|
|
|
if (v->now - save == 0 || ((int) c > 0 && (int) c <= v->nsubexp))
|
2003-08-04 02:43:34 +02:00
|
|
|
{
|
|
|
|
NOTE(REG_UBACKREF);
|
|
|
|
RETV(BACKREF, (chr) c);
|
|
|
|
}
|
|
|
|
/* oops, doesn't look like it's a backref after all... */
|
|
|
|
v->now = save;
|
|
|
|
/* and fall through into octal number */
|
|
|
|
case CHR('0'):
|
|
|
|
NOTE(REG_UUNPORT);
|
|
|
|
v->now--; /* put first digit back */
|
|
|
|
c = lexdigits(v, 8, 1, 3);
|
|
|
|
if (ISERR())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(iscalpha(c));
|
|
|
|
FAILW(REG_EESCAPE); /* unknown alphabetic escape */
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
assert(NOTREACHED);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lexdigits - slurp up digits and return chr value
|
|
|
|
*/
|
2003-08-08 23:42:59 +02:00
|
|
|
static chr /* chr value; errors signalled via ERR */
|
2003-08-04 02:43:34 +02:00
|
|
|
lexdigits(struct vars * v,
|
2003-02-05 18:41:33 +01:00
|
|
|
int base,
|
|
|
|
int minlen,
|
|
|
|
int maxlen)
|
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
uchr n; /* unsigned to avoid overflow misbehavior */
|
|
|
|
int len;
|
|
|
|
chr c;
|
|
|
|
int d;
|
|
|
|
const uchr ub = (uchr) base;
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
n = 0;
|
2003-08-04 02:43:34 +02:00
|
|
|
for (len = 0; len < maxlen && !ATEOS(); len++)
|
|
|
|
{
|
2003-02-05 18:41:33 +01:00
|
|
|
c = *v->now++;
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case CHR('0'):
|
|
|
|
case CHR('1'):
|
|
|
|
case CHR('2'):
|
|
|
|
case CHR('3'):
|
|
|
|
case CHR('4'):
|
|
|
|
case CHR('5'):
|
|
|
|
case CHR('6'):
|
|
|
|
case CHR('7'):
|
|
|
|
case CHR('8'):
|
|
|
|
case CHR('9'):
|
|
|
|
d = DIGITVAL(c);
|
|
|
|
break;
|
|
|
|
case CHR('a'):
|
|
|
|
case CHR('A'):
|
|
|
|
d = 10;
|
|
|
|
break;
|
|
|
|
case CHR('b'):
|
|
|
|
case CHR('B'):
|
|
|
|
d = 11;
|
|
|
|
break;
|
|
|
|
case CHR('c'):
|
|
|
|
case CHR('C'):
|
|
|
|
d = 12;
|
|
|
|
break;
|
|
|
|
case CHR('d'):
|
|
|
|
case CHR('D'):
|
|
|
|
d = 13;
|
|
|
|
break;
|
|
|
|
case CHR('e'):
|
|
|
|
case CHR('E'):
|
|
|
|
d = 14;
|
|
|
|
break;
|
|
|
|
case CHR('f'):
|
|
|
|
case CHR('F'):
|
|
|
|
d = 15;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
v->now--; /* oops, not a digit at all */
|
|
|
|
d = -1;
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
if (d >= base)
|
|
|
|
{ /* not a plausible digit */
|
2003-02-05 18:41:33 +01:00
|
|
|
v->now--;
|
|
|
|
d = -1;
|
|
|
|
}
|
|
|
|
if (d < 0)
|
2003-08-04 02:43:34 +02:00
|
|
|
break; /* NOTE BREAK OUT */
|
|
|
|
n = n * ub + (uchr) d;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
if (len < minlen)
|
|
|
|
ERR(REG_EESCAPE);
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
return (chr) n;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* brenext - get next BRE token
|
|
|
|
*
|
|
|
|
* This is much like EREs except for all the stupid backslashes and the
|
|
|
|
* context-dependency of some things.
|
|
|
|
*/
|
2003-08-04 02:43:34 +02:00
|
|
|
static int /* 1 normal, 0 failure */
|
|
|
|
brenext(struct vars * v,
|
2003-02-05 18:41:33 +01:00
|
|
|
chr pc)
|
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
chr c = (chr) pc;
|
2003-02-05 18:41:33 +01:00
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case CHR('*'):
|
|
|
|
if (LASTTYPE(EMPTY) || LASTTYPE('(') || LASTTYPE('^'))
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
RET('*');
|
|
|
|
break;
|
|
|
|
case CHR('['):
|
|
|
|
if (HAVE(6) && *(v->now + 0) == CHR('[') &&
|
|
|
|
*(v->now + 1) == CHR(':') &&
|
|
|
|
(*(v->now + 2) == CHR('<') ||
|
|
|
|
*(v->now + 2) == CHR('>')) &&
|
|
|
|
*(v->now + 3) == CHR(':') &&
|
|
|
|
*(v->now + 4) == CHR(']') &&
|
|
|
|
*(v->now + 5) == CHR(']'))
|
|
|
|
{
|
|
|
|
c = *(v->now + 2);
|
|
|
|
v->now += 6;
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RET((c == CHR('<')) ? '<' : '>');
|
|
|
|
}
|
|
|
|
INTOCON(L_BRACK);
|
|
|
|
if (NEXT1('^'))
|
|
|
|
{
|
|
|
|
v->now++;
|
|
|
|
RETV('[', 0);
|
|
|
|
}
|
|
|
|
RETV('[', 1);
|
|
|
|
break;
|
|
|
|
case CHR('.'):
|
|
|
|
RET('.');
|
|
|
|
break;
|
|
|
|
case CHR('^'):
|
|
|
|
if (LASTTYPE(EMPTY))
|
|
|
|
RET('^');
|
|
|
|
if (LASTTYPE('('))
|
|
|
|
{
|
|
|
|
NOTE(REG_UUNSPEC);
|
|
|
|
RET('^');
|
|
|
|
}
|
2003-02-05 18:41:33 +01:00
|
|
|
RETV(PLAIN, c);
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
|
|
|
case CHR('$'):
|
|
|
|
if (v->cflags & REG_EXPANDED)
|
|
|
|
skip(v);
|
|
|
|
if (ATEOS())
|
|
|
|
RET('$');
|
|
|
|
if (NEXT2('\\', ')'))
|
|
|
|
{
|
|
|
|
NOTE(REG_UUNSPEC);
|
|
|
|
RET('$');
|
|
|
|
}
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
|
|
|
case CHR('\\'):
|
|
|
|
break; /* see below */
|
|
|
|
default:
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(c == CHR('\\'));
|
|
|
|
|
|
|
|
if (ATEOS())
|
|
|
|
FAILW(REG_EESCAPE);
|
|
|
|
|
|
|
|
c = *v->now++;
|
2003-08-04 02:43:34 +02:00
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case CHR('{'):
|
|
|
|
INTOCON(L_BBND);
|
|
|
|
NOTE(REG_UBOUNDS);
|
|
|
|
RET('{');
|
|
|
|
break;
|
|
|
|
case CHR('('):
|
|
|
|
RETV('(', 1);
|
|
|
|
break;
|
|
|
|
case CHR(')'):
|
|
|
|
RETV(')', c);
|
|
|
|
break;
|
|
|
|
case CHR('<'):
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RET('<');
|
|
|
|
break;
|
|
|
|
case CHR('>'):
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
RET('>');
|
|
|
|
break;
|
|
|
|
case CHR('1'):
|
|
|
|
case CHR('2'):
|
|
|
|
case CHR('3'):
|
|
|
|
case CHR('4'):
|
|
|
|
case CHR('5'):
|
|
|
|
case CHR('6'):
|
|
|
|
case CHR('7'):
|
|
|
|
case CHR('8'):
|
|
|
|
case CHR('9'):
|
|
|
|
NOTE(REG_UBACKREF);
|
|
|
|
RETV(BACKREF, (chr) DIGITVAL(c));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (iscalnum(c))
|
|
|
|
{
|
|
|
|
NOTE(REG_UBSALNUM);
|
|
|
|
NOTE(REG_UUNSPEC);
|
|
|
|
}
|
|
|
|
RETV(PLAIN, c);
|
|
|
|
break;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(NOTREACHED);
|
2007-10-22 03:02:22 +02:00
|
|
|
return 0;
|
2003-02-05 18:41:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* skip - skip white space and comments in expanded form
|
|
|
|
*/
|
|
|
|
static void
|
2003-08-04 02:43:34 +02:00
|
|
|
skip(struct vars * v)
|
2003-02-05 18:41:33 +01:00
|
|
|
{
|
2008-02-14 18:33:37 +01:00
|
|
|
const chr *start = v->now;
|
2003-02-05 18:41:33 +01:00
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
assert(v->cflags & REG_EXPANDED);
|
2003-02-05 18:41:33 +01:00
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
for (;;)
|
|
|
|
{
|
2003-02-05 18:41:33 +01:00
|
|
|
while (!ATEOS() && iscspace(*v->now))
|
|
|
|
v->now++;
|
|
|
|
if (ATEOS() || *v->now != CHR('#'))
|
|
|
|
break; /* NOTE BREAK OUT */
|
|
|
|
assert(NEXT1('#'));
|
|
|
|
while (!ATEOS() && *v->now != CHR('\n'))
|
|
|
|
v->now++;
|
|
|
|
/* leave the newline to be picked up by the iscspace loop */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (v->now != start)
|
|
|
|
NOTE(REG_UNONPOSIX);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* newline - return the chr for a newline
|
|
|
|
*
|
|
|
|
* This helps confine use of CHR to this source file.
|
|
|
|
*/
|
|
|
|
static chr
|
|
|
|
newline(void)
|
|
|
|
{
|
|
|
|
return CHR('\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* chrnamed - return the chr known by a given (chr string) name
|
|
|
|
*
|
|
|
|
* The code is a bit clumsy, but this routine gets only such specialized
|
|
|
|
* use that it hardly matters.
|
|
|
|
*/
|
|
|
|
static chr
|
2003-08-04 02:43:34 +02:00
|
|
|
chrnamed(struct vars * v,
|
2008-02-14 18:33:37 +01:00
|
|
|
const chr *startp, /* start of name */
|
|
|
|
const chr *endp, /* just past end of name */
|
2003-02-05 18:41:33 +01:00
|
|
|
chr lastresort) /* what to return if name lookup fails */
|
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
celt c;
|
|
|
|
int errsave;
|
|
|
|
int e;
|
2003-02-05 18:41:33 +01:00
|
|
|
struct cvec *cv;
|
|
|
|
|
|
|
|
errsave = v->err;
|
|
|
|
v->err = 0;
|
|
|
|
c = element(v, startp, endp);
|
|
|
|
e = v->err;
|
|
|
|
v->err = errsave;
|
|
|
|
|
|
|
|
if (e != 0)
|
2003-08-04 02:43:34 +02:00
|
|
|
return (chr) lastresort;
|
2003-02-05 18:41:33 +01:00
|
|
|
|
|
|
|
cv = range(v, c, c, 0);
|
|
|
|
if (cv->nchrs == 0)
|
2003-08-04 02:43:34 +02:00
|
|
|
return (chr) lastresort;
|
2003-02-05 18:41:33 +01:00
|
|
|
return cv->chrs[0];
|
|
|
|
}
|