src/lib/libc/regex/regcomp.c - diff

Return to regcomp.c CVS log

Up to [cvs.NetBSD.org] / src / lib / libc / regex

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libc/regex/regcomp.c between version 1.13 and 1.14

version 1.13, 1998/12/13 12:21:46

version 1.14, 1999/09/16 11:45:21

Line 50 __RCSID("$NetBSD$");

#include "namespace.h"

#include <sys/types.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include <ctype.h>

#include <limits.h>

#include <stdlib.h>

#include <regex.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef __weak_alias

__weak_alias(regcomp,_regcomp);

Line 206 int cflags;

Line 208 int cflags;

# define GOODFLAGS(f) ((f)&~REG_DUMP)

#endif

_DIAGASSERT(preg != NULL);

_DIAGASSERT(pattern != NULL);

#ifdef _DIAGNOSTIC

if (preg == NULL || pattern == NULL)

return (REG_INVARG);

#endif

cflags = GOODFLAGS(cflags);

if ((cflags&REG_EXTENDED) && (cflags&REG_NOSPEC))

return(REG_INVARG);

Line 305 int stop; /* character this ERE should

Line 314 int stop; /* character this ERE should

sopno conc;

int first = 1; /* is this the first alternative? */

_DIAGASSERT(p != NULL);

for (;;) {

/* do a bunch of concatenated expressions */

conc = HERE();

Line 351 struct parse *p;

Line 362 struct parse *p;

sopno subno;

int wascaret = 0;

_DIAGASSERT(p != NULL);

assert(MORE()); /* caller should have ensured this */

c = GETNEXT();

Line 493 static void

Line 506 static void

p_str(p)

struct parse *p;

{

_DIAGASSERT(p != NULL);

REQUIRE(MORE(), REG_EMPTY);

while (MORE())

ordinary(p, GETNEXT());

Line 516 struct parse *p;

Line 532 struct parse *p;

int end1; /* first terminating character */

int end2; /* second terminating character */

{

sopno start = HERE();

sopno start;

int first = 1; /* first subexpression? */

int wasdollar = 0;

_DIAGASSERT(p != NULL);

start = HERE();

if (EAT('^')) {

EMIT(OBOL, 0);

p->g->iflags |= USEBOL;

Line 556 int starordinary; /* is a leading * an

Line 576 int starordinary; /* is a leading * an

sopno subno;

# define BACKSL (1<<CHAR_BIT)

_DIAGASSERT(p != NULL);

pos = HERE(); /* repetion op, if any, covers from here */

assert(MORE()); /* caller should have ensured this */

Line 668 struct parse *p;

Line 690 struct parse *p;

int count = 0;

int ndigits = 0;

_DIAGASSERT(p != NULL);

while (MORE() && isdigit(PEEK()) && count <= DUPMAX) {

count = count*10 + (GETNEXT() - '0');

ndigits++;

Line 688 static void

Line 712 static void

p_bracket(p)

struct parse *p;

{

cset *cs = allocset(p);

cset *cs;

int invert = 0;

_DIAGASSERT(p != NULL);

cs = allocset(p);

/* Dept of Truly Sickening Special-Case Kludges */

if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]",

(size_t)6) == 0) {

Line 769 cset *cs;

Line 797 cset *cs;

char start, finish;

int i;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

/* classify what we've got */

switch ((MORE()) ? PEEK() : '\0') {

case '[':

Line 832 p_b_cclass(p, cs)

Line 863 p_b_cclass(p, cs)

struct parse *p;

cset *cs;

{

char *sp = p->next;

char *sp;

const struct cclass *cp;

size_t len;

const char *u;

char c;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

sp = p->next;

while (MORE() && isalpha(PEEK()))

NEXT();

len = p->next - sp;

Line 870 cset *cs;

Line 906 cset *cs;

{

char c;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

c = p_b_coll_elem(p, '=');

CHadd(cs, c);

}

Line 884 struct parse *p;

Line 923 struct parse *p;

{

char value;

_DIAGASSERT(p != NULL);

REQUIRE(MORE(), REG_EBRACK);

if (!EATTWO('[', '.'))

return(GETNEXT());

Line 903 p_b_coll_elem(p, endc)

Line 944 p_b_coll_elem(p, endc)

struct parse *p;

int endc; /* name ended by endc,']' */

{

char *sp = p->next;

char *sp;

const struct cname *cp;

size_t len;

_DIAGASSERT(p != NULL);

sp = p->next;

while (MORE() && !SEETWO(endc, ']'))

NEXT();

if (!MORE()) {

Line 951 bothcases(p, ch)

Line 996 bothcases(p, ch)

struct parse *p;

int ch;

{

char *oldnext = p->next;

char *oldnext;

char *oldend = p->end;

char *oldend;

char bracket[3];

_DIAGASSERT(p != NULL);

oldnext = p->next;

oldend = p->end;

assert(othercase(ch) != ch); /* p_bracket() would recurse */

p->next = bracket;

p->end = bracket+2;

Line 976 ordinary(p, ch)

Line 1026 ordinary(p, ch)

struct parse *p;

int ch;

{

cat_t *cap = p->g->categories;

cat_t *cap;

_DIAGASSERT(p != NULL);

cap = p->g->categories;

if ((p->g->cflags&REG_ICASE) && isalpha(ch) && othercase(ch) != ch)

bothcases(p, ch);

else {

Line 997 static void

Line 1050 static void

nonnewline(p)

struct parse *p;

{

char *oldnext = p->next;

char *oldnext;

char *oldend = p->end;

char *oldend;

char bracket[4];

_DIAGASSERT(p != NULL);

oldnext = p->next;

oldend = p->end;

p->next = bracket;

p->end = bracket+3;

bracket[0] = '^';

Line 1024 sopno start; /* operand from here to e

Line 1082 sopno start; /* operand from here to e

int from; /* repeated from this number */

int to; /* to this number of times (maybe INFINITY) */

{

sopno finish = HERE();

sopno finish;

# define N 2

# define INF 3

# define REP(f, t) ((f)*8 + (t))

# define MAP(n) (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)

sopno copy;

_DIAGASSERT(p != NULL);

finish = HERE();

if (p->error != 0) /* head off possible runaway recursion */

return;

Line 1094 seterr(p, e)

Line 1156 seterr(p, e)

struct parse *p;

int e;

{

_DIAGASSERT(p != NULL);

if (p->error == 0) /* keep earliest error condition */

p->error = e;

p->next = nuls; /* try to bring things to a halt */

Line 1109 static cset *

Line 1174 static cset *

allocset(p)

struct parse *p;

{

int no = p->g->ncsets++;

int no;

size_t nc;

size_t nbytes;

cset *cs;

size_t css = (size_t)p->g->csetsize;

size_t css;

int i;

_DIAGASSERT(p != NULL);

no = p->g->ncsets++;

css = (size_t)p->g->csetsize;

if (no >= p->ncsalloc) { /* need another column of space */

p->ncsalloc += CHAR_BIT;

nc = p->ncsalloc;

Line 1164 struct parse *p;

Line 1233 struct parse *p;

cset *cs;

{

int i;

cset *top = &p->g->sets[p->g->ncsets];

cset *top;

size_t css = (size_t)p->g->csetsize;

size_t css;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

top = &p->g->sets[p->g->ncsets];

css = (size_t)p->g->csetsize;

for (i = 0; i < css; i++)

CHsub(cs, i);

Line 1188 freezeset(p, cs)

Line 1263 freezeset(p, cs)

struct parse *p;

cset *cs;

{

uch h = cs->hash;

uch h;

int i;

cset *top = &p->g->sets[p->g->ncsets];

cset *top;

cset *cs2;

size_t css = (size_t)p->g->csetsize;

size_t css;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

h = cs->hash;

top = &p->g->sets[p->g->ncsets];

css = (size_t)p->g->csetsize;

/* look for an earlier one which is the same */

for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)

Line 1223 struct parse *p;

Line 1305 struct parse *p;

cset *cs;

{

int i;

size_t css = (size_t)p->g->csetsize;

size_t css;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

css = (size_t)p->g->csetsize;

for (i = 0; i < css; i++)

if (CHIN(cs, i))

Line 1242 struct parse *p;

Line 1329 struct parse *p;

cset *cs;

{

int i;

size_t css = (size_t)p->g->csetsize;

size_t css;

int n = 0;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

css = (size_t)p->g->csetsize;

for (i = 0; i < css; i++)

if (CHIN(cs, i))

n++;

Line 1262 struct parse *p;

Line 1354 struct parse *p;

cset *cs;

const char *cp;

{

size_t oldend = cs->smultis;

size_t oldend;

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

_DIAGASSERT(cp != NULL);

oldend = cs->smultis;

cs->smultis += strlen(cp) + 1;

if (cs->multis == NULL)

Line 1288 mcsub(cs, cp)

Line 1386 mcsub(cs, cp)

cset *cs;

char *cp;

{

char *fp = mcfind(cs, cp);

char *fp;

size_t len = strlen(fp);

size_t len;

_DIAGASSERT(cs != NULL);

_DIAGASSERT(cp != NULL);

fp = mcfind(cs, cp);

len = strlen(fp);

assert(fp != NULL);

(void) memmove(fp, fp + len + 1,

Line 1315 mcin(cs, cp)

Line 1419 mcin(cs, cp)

cset *cs;

char *cp;

{

_DIAGASSERT(cs != NULL);

_DIAGASSERT(cp != NULL);

return(mcfind(cs, cp) != NULL);

}

Line 1329 char *cp;

Line 1437 char *cp;

{

char *p;

_DIAGASSERT(cs != NULL);

_DIAGASSERT(cp != NULL);

if (cs->multis == NULL)

return(NULL);

for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)

Line 1351 mcinvert(p, cs)

Line 1462 mcinvert(p, cs)

struct parse *p;

cset *cs;

{

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

assert(cs->multis == NULL); /* xxx */

}

Line 1367 mccase(p, cs)

Line 1482 mccase(p, cs)

struct parse *p;

cset *cs;

{

_DIAGASSERT(p != NULL);

_DIAGASSERT(cs != NULL);

assert(cs->multis == NULL); /* xxx */

}

Line 1381 int c;

Line 1500 int c;

{

uch *col;

int i;

int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;

int ncols;

unsigned uc = (unsigned char)c;

_DIAGASSERT(g != NULL);

ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;

for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)

if (col[uc] != 0)

return(1);

Line 1402 int c2;

Line 1525 int c2;

{

uch *col;

int i;

int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;

int ncols;

unsigned uc1 = (unsigned char)c1;

unsigned uc2 = (unsigned char)c2;

_DIAGASSERT(g != NULL);

ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;

for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)

if (col[uc1] != col[uc2])

return(0);

Line 1421 categorize(p, g)

Line 1548 categorize(p, g)

struct parse *p;

struct re_guts *g;

{

cat_t *cats = g->categories;

cat_t *cats;

int c;

int c2;

cat_t cat;

_DIAGASSERT(p != NULL);

_DIAGASSERT(g != NULL);

cats = g->categories;

/* avoid making error situations worse */

if (p->error != 0)

return;

Line 1450 struct parse *p;

Line 1582 struct parse *p;

sopno start; /* from here */

sopno finish; /* to this less one */

{

sopno ret = HERE();

sopno ret;

sopno len = finish - start;

_DIAGASSERT(p != NULL);

ret = HERE();

assert(finish >= start);

if (len == 0)

return(ret);

Line 1478 struct parse *p;

Line 1614 struct parse *p;

sop op;

sopno opnd;

{

_DIAGASSERT(p != NULL);

/* avoid making error situations worse */

if (p->error != 0)

return;

Line 1509 sopno pos;

Line 1648 sopno pos;

sop s;

int i;

_DIAGASSERT(p != NULL);

/* avoid making error situations worse */

if (p->error != 0)

return;

Line 1543 struct parse *p;

Line 1684 struct parse *p;

sopno pos;

sopno value;

{

_DIAGASSERT(p != NULL);

/* avoid making error situations worse */

if (p->error != 0)

return;

Line 1562 sopno size;

Line 1706 sopno size;

{

sop *sp;

_DIAGASSERT(p != NULL);

if (p->ssize >= size)

return;

Line 1583 stripsnug(p, g)

Line 1729 stripsnug(p, g)

struct parse *p;

struct re_guts *g;

{

_DIAGASSERT(p != NULL);

_DIAGASSERT(g != NULL);

g->nstates = p->slen;

g->strip = realloc(p->strip, p->slen * sizeof(sop));

if (g->strip == NULL) {

Line 1614 struct re_guts *g;

Line 1764 struct re_guts *g;

char *cp;

sopno i;

_DIAGASSERT(p != NULL);

_DIAGASSERT(g != NULL);

/* avoid making error situations worse */

if (p->error != 0)

return;

Line 1692 struct re_guts *g;

Line 1845 struct re_guts *g;

sopno plusnest = 0;

sopno maxnest = 0;

_DIAGASSERT(p != NULL);

_DIAGASSERT(g != NULL);

if (p->error != 0)

return(0); /* there may not be an OEND */

CVSweb <webmaster@jp.NetBSD.org>