De-K&R-ify source, remove register keywords.
authorJoerg Sonnenberger <joerg@dragonflybsd.org>
Fri, 6 Feb 2004 22:36:50 +0000 (22:36 +0000)
committerJoerg Sonnenberger <joerg@dragonflybsd.org>
Fri, 6 Feb 2004 22:36:50 +0000 (22:36 +0000)
Patch submited by Chris Pressey <cpressey@catseye.mine.nu>

Additionally cleanup some prototyps.

lib/libc/regex/engine.c
lib/libc/regex/regcomp.c
lib/libc/regex/regerror.c
lib/libc/regex/regexec.c
lib/libc/regex/regfree.c

index f77d03b..597670d 100644 (file)
@@ -37,7 +37,7 @@
  *     @(#)engine.c    8.5 (Berkeley) 3/20/94
  *
  * $FreeBSD: src/lib/libc/regex/engine.c,v 1.5.8.1 2000/07/31 06:30:37 dcs Exp $
- * $DragonFly: src/lib/libc/regex/engine.c,v 1.3 2003/11/12 20:21:25 eirikn Exp $
+ * $DragonFly: src/lib/libc/regex/engine.c,v 1.4 2004/02/06 22:36:50 joerg Exp $
  */
 
 /*
@@ -93,12 +93,12 @@ extern "C" {
 #endif
 
 /* === engine.c === */
-static int matcher (struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
-static char *dissect (struct match *m, char *start, char *stop, sopno startst, sopno stopst);
-static char *backref (struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev);
-static char *fast (struct match *m, char *start, char *stop, sopno startst, sopno stopst);
-static char *slow (struct match *m, char *start, char *stop, sopno startst, sopno stopst);
-static states step (struct re_guts *g, sopno start, sopno stop, states bef, int ch, states aft);
+static int matcher(struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
+static char *dissect(struct match *m, char *start, char *stop, sopno startst, sopno stopst);
+static char *backref(struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev);
+static char *fast(struct match *m, char *start, char *stop, sopno startst, sopno stopst);
+static char *slow(struct match *m, char *start, char *stop, sopno startst, sopno stopst);
+static states step(struct re_guts *g, sopno start, sopno stop, states bef, int ch, states aft);
 #define        BOL     (OUT+1)
 #define        EOL     (BOL+1)
 #define        BOLEOL  (BOL+2)
@@ -109,13 +109,13 @@ static states step (struct re_guts *g, sopno start, sopno stop, states bef, int
 #define        NONCHAR(c)      ((c) > CHAR_MAX)
 #define        NNONCHAR        (CODEMAX-CHAR_MAX)
 #ifdef REDEBUG
-static void print (struct match *m, char *caption, states st, int ch, FILE *d);
+static void print(struct match *m, char *caption, states st, int ch, FILE *d);
 #endif
 #ifdef REDEBUG
-static void at (struct match *m, char *title, char *start, char *stop, sopno startst, sopno stopst);
+static void at(struct match *m, char *title, char *start, char *stop, sopno startst, sopno stopst);
 #endif
 #ifdef REDEBUG
-static char *pchar (int ch);
+static char *pchar(int ch);
 #endif
 
 #ifdef __cplusplus
@@ -139,29 +139,25 @@ static char *pchar (int ch);
  ==    size_t nmatch, regmatch_t pmatch[], int eflags);
  */
 static int                     /* 0 success, REG_NOMATCH failure */
-matcher(g, string, nmatch, pmatch, eflags)
-register struct re_guts *g;
-char *string;
-size_t nmatch;
-regmatch_t pmatch[];
-int eflags;
+matcher(struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[],
+       int eflags)
 {
-       register char *endp;
-       register int i;
+       char *endp;
+       int i;
        struct match mv;
-       register struct match *m = &mv;
-       register char *dp;
-       register const sopno gf = g->firststate+1;      /* +1 for OEND */
-       register const sopno gl = g->laststate;
+       struct match *m = &mv;
+       char *dp;
+       const sopno gf = g->firststate+1;       /* +1 for OEND */
+       const sopno gl = g->laststate;
        char *start;
        char *stop;
        /* Boyer-Moore algorithms variables */
-       register char *pp;
+       char *pp;
        int cj, mj;
-       register char *mustfirst;
-       register char *mustlast;
-       register int *matchjump;
-       register int *charjump;
+       char *mustfirst;
+       char *mustlast;
+       int *matchjump;
+       int *charjump;
 
        /* simplify the situation where possible */
        if (g->cflags&REG_NOSUB)
@@ -350,26 +346,21 @@ int eflags;
  ==    char *stop, sopno startst, sopno stopst);
  */
 static char *                  /* == stop (success) always */
-dissect(m, start, stop, startst, stopst)
-register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+dissect(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
 {
-       register int i;
-       register sopno ss;      /* start sop of current subRE */
-       register sopno es;      /* end sop of current subRE */
-       register char *sp;      /* start of string matched by it */
-       register char *stp;     /* string matched by it cannot pass here */
-       register char *rest;    /* start of rest of string */
-       register char *tail;    /* string unmatched by rest of RE */
-       register sopno ssub;    /* start sop of subsubRE */
-       register sopno esub;    /* end sop of subsubRE */
-       register char *ssp;     /* start of string matched by subsubRE */
-       register char *sep;     /* end of string matched by subsubRE */
-       register char *oldssp;  /* previous ssp */
-       register char *dp;
+       int i;
+       sopno ss;               /* start sop of current subRE */
+       sopno es;               /* end sop of current subRE */
+       char *sp;               /* start of string matched by it */
+       char *stp;              /* string matched by it cannot pass here */
+       char *rest;             /* start of rest of string */
+       char *tail;             /* string unmatched by rest of RE */
+       sopno ssub;             /* start sop of subsubRE */
+       sopno esub;             /* end sop of subsubRE */
+       char *ssp;              /* start of string matched by subsubRE */
+       char *sep;              /* end of string matched by subsubRE */
+       char *oldssp;           /* previous ssp */
+       char *dp;
 
        AT("diss", start, stop, startst, stopst);
        sp = start;
@@ -538,26 +529,21 @@ sopno stopst;
  ==    char *stop, sopno startst, sopno stopst, sopno lev);
  */
 static char *                  /* == stop (success) or NULL (failure) */
-backref(m, start, stop, startst, stopst, lev)
-register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
-sopno lev;                     /* PLUS nesting level */
+backref(struct match *m, char *start, char *stop, sopno startst, sopno stopst,
+       sopno lev)                      /* PLUS nesting level */
 {
-       register int i;
-       register sopno ss;      /* start sop of current subRE */
-       register char *sp;      /* start of string matched by it */
-       register sopno ssub;    /* start sop of subsubRE */
-       register sopno esub;    /* end sop of subsubRE */
-       register char *ssp;     /* start of string matched by subsubRE */
-       register char *dp;
-       register size_t len;
-       register int hard;
-       register sop s;
-       register regoff_t offsave;
-       register cset *cs;
+       int i;
+       sopno ss;               /* start sop of current subRE */
+       char *sp;               /* start of string matched by it */
+       sopno ssub;             /* start sop of subsubRE */
+       sopno esub;             /* end sop of subsubRE */
+       char *ssp;              /* start of string matched by subsubRE */
+       char *dp;
+       size_t len;
+       int hard;
+       sop s;
+       regoff_t offsave;
+       cset *cs;
 
        AT("back", start, stop, startst, stopst);
        sp = start;
@@ -743,22 +729,17 @@ sopno lev;                        /* PLUS nesting level */
  ==    char *stop, sopno startst, sopno stopst);
  */
 static char *                  /* where tentative match ended, or NULL */
-fast(m, start, stop, startst, stopst)
-register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+fast(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
 {
-       register states st = m->st;
-       register states fresh = m->fresh;
-       register states tmp = m->tmp;
-       register char *p = start;
-       register int c = (start == m->beginp) ? OUT : *(start-1);
-       register int lastc;     /* previous c */
-       register int flagch;
-       register int i;
-       register char *coldp;   /* last p after which no match was underway */
+       states st = m->st;
+       states fresh = m->fresh;
+       states tmp = m->tmp;
+       char *p = start;
+       int c = (start == m->beginp) ? OUT : *(start-1);
+       int lastc;              /* previous c */
+       int flagch;
+       int i;
+       char *coldp;            /* last p after which no match was underway */
 
        CLEAR(st);
        SET1(st, startst);
@@ -834,22 +815,17 @@ sopno stopst;
  ==    char *stop, sopno startst, sopno stopst);
  */
 static char *                  /* where it ended */
-slow(m, start, stop, startst, stopst)
-register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+slow(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
 {
-       register states st = m->st;
-       register states empty = m->empty;
-       register states tmp = m->tmp;
-       register char *p = start;
-       register int c = (start == m->beginp) ? OUT : *(start-1);
-       register int lastc;     /* previous c */
-       register int flagch;
-       register int i;
-       register char *matchp;  /* last p at which a match ended */
+       states st = m->st;
+       states empty = m->empty;
+       states tmp = m->tmp;
+       char *p = start;
+       int c = (start == m->beginp) ? OUT : *(start-1);
+       int lastc;              /* previous c */
+       int flagch;
+       int i;
+       char *matchp;           /* last p at which a match ended */
 
        AT("slow", start, stop, startst, stopst);
        CLEAR(st);
@@ -930,20 +906,19 @@ sopno stopst;
  == #define    NNONCHAR        (CODEMAX-CHAR_MAX)
  */
 static states
-step(g, start, stop, bef, ch, aft)
-register struct re_guts *g;
-sopno start;                   /* start state within strip */
-sopno stop;                    /* state after stop state within strip */
-register states bef;           /* states reachable before */
-int ch;                                /* character or NONCHAR code */
-register states aft;           /* states already known reachable after */
+step(struct re_guts *g,
+     sopno start,              /* start state within strip */
+     sopno stop,               /* state after stop state within strip */
+     states bef,               /* states reachable before */
+     int ch,                   /* character or NONCHAR code */
+     states aft)               /* states already known reachable after */
 {
-       register cset *cs;
-       register sop s;
-       register sopno pc;
-       register onestate here;         /* note, macros know this name */
-       register sopno look;
-       register int i;
+       cset *cs;
+       sop s;
+       sopno pc;
+       onestate here;                  /* note, macros know this name */
+       sopno look;
+       int i;
 
        for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
                s = g->strip[pc];
@@ -1052,16 +1027,11 @@ register states aft;            /* states already known reachable after */
  == #endif
  */
 static void
-print(m, caption, st, ch, d)
-struct match *m;
-char *caption;
-states st;
-int ch;
-FILE *d;
+print(struct match *m, char *caption, states st, int ch, FILE *d)
 {
-       register struct re_guts *g = m->g;
-       register int i;
-       register int first = 1;
+       struct re_guts *g = m->g;
+       int i;
+       int first = 1;
 
        if (!(m->eflags&REG_TRACE))
                return;
@@ -1085,13 +1055,8 @@ FILE *d;
  == #endif
  */
 static void
-at(m, title, start, stop, startst, stopst)
-struct match *m;
-char *title;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+at(struct match *m, char *title, char *start, char *stop, sopno startst,
+   sopno stopst)
 {
        if (!(m->eflags&REG_TRACE))
                return;
@@ -1115,8 +1080,7 @@ sopno stopst;
  * the non-debug compilation anyway, so it doesn't matter much.
  */
 static char *                  /* -> representation */
-pchar(ch)
-int ch;
+pchar(int ch)
 {
        static char pbuf[10];
 
index 59fef85..c539d6e 100644 (file)
@@ -37,7 +37,7 @@
  *     @(#)regcomp.c   8.5 (Berkeley) 3/20/94
  *
  * $FreeBSD: src/lib/libc/regex/regcomp.c,v 1.13.2.2 2002/03/20 13:13:15 dcs Exp $
- * $DragonFly: src/lib/libc/regex/regcomp.c,v 1.3 2003/11/12 20:21:25 eirikn Exp $
+ * $DragonFly: src/lib/libc/regex/regcomp.c,v 1.4 2004/02/06 22:36:50 joerg Exp $
  *
  * @(#)regcomp.c       8.5 (Berkeley) 3/20/94
  */
@@ -82,51 +82,51 @@ extern "C" {
 #endif
 
 /* === regcomp.c === */
-static void p_ere (struct parse *p, int stop);
-static void p_ere_exp (struct parse *p);
-static void p_str (struct parse *p);
-static void p_bre (struct parse *p, int end1, int end2);
-static int p_simp_re (struct parse *p, int starordinary);
-static int p_count (struct parse *p);
-static void p_bracket (struct parse *p);
-static void p_b_term (struct parse *p, cset *cs);
-static void p_b_cclass (struct parse *p, cset *cs);
-static void p_b_eclass (struct parse *p, cset *cs);
-static char p_b_symbol (struct parse *p);
-static char p_b_coll_elem (struct parse *p, int endc);
-static char othercase (int ch);
-static void bothcases (struct parse *p, int ch);
-static void ordinary (struct parse *p, int ch);
-static void nonnewline (struct parse *p);
-static void repeat (struct parse *p, sopno start, int from, int to);
-static int seterr (struct parse *p, int e);
-static cset *allocset (struct parse *p);
-static void freeset (struct parse *p, cset *cs);
-static int freezeset (struct parse *p, cset *cs);
-static int firstch (struct parse *p, cset *cs);
-static int nch (struct parse *p, cset *cs);
-static void mcadd (struct parse *p, cset *cs, char *cp);
+static void p_ere(struct parse *p, int stop);
+static void p_ere_exp(struct parse *p);
+static void p_str(struct parse *p);
+static void p_bre(struct parse *p, int end1, int end2);
+static int p_simp_re(struct parse *p, int starordinary);
+static int p_count(struct parse *p);
+static void p_bracket(struct parse *p);
+static void p_b_term(struct parse *p, cset *cs);
+static void p_b_cclass(struct parse *p, cset *cs);
+static void p_b_eclass(struct parse *p, cset *cs);
+static char p_b_symbol(struct parse *p);
+static char p_b_coll_elem(struct parse *p, int endc);
+static char othercase(int ch);
+static void bothcases(struct parse *p, int ch);
+static void ordinary(struct parse *p, int ch);
+static void nonnewline(struct parse *p);
+static void repeat(struct parse *p, sopno start, int from, int to);
+static int seterr(struct parse *p, int e);
+static cset *allocset(struct parse *p);
+static void freeset(struct parse *p, cset *cs);
+static int freezeset(struct parse *p, cset *cs);
+static int firstch(struct parse *p, cset *cs);
+static int nch(struct parse *p, cset *cs);
+static void mcadd(struct parse *p, cset *cs, char *cp);
 #if used
-static void mcsub (cset *cs, char *cp);
-static int mcin (cset *cs, char *cp);
-static char *mcfind (cset *cs, char *cp);
+static void mcsub(cset *cs, char *cp);
+static int mcin(cset *cs, char *cp);
+static char *mcfind(cset *cs, char *cp);
 #endif
-static void mcinvert (struct parse *p, cset *cs);
-static void mccase (struct parse *p, cset *cs);
-static int isinsets (struct re_guts *g, int c);
-static int samesets (struct re_guts *g, int c1, int c2);
-static void categorize (struct parse *p, struct re_guts *g);
-static sopno dupl (struct parse *p, sopno start, sopno finish);
-static void doemit (struct parse *p, sop op, size_t opnd);
-static void doinsert (struct parse *p, sop op, size_t opnd, sopno pos);
-static void dofwd (struct parse *p, sopno pos, sop value);
-static void enlarge (struct parse *p, sopno size);
-static void stripsnug (struct parse *p, struct re_guts *g);
-static void findmust (struct parse *p, struct re_guts *g);
-static int altoffset (sop *scan, int offset, int mccs);
-static void computejumps (struct parse *p, struct re_guts *g);
-static void computematchjumps (struct parse *p, struct re_guts *g);
-static sopno pluscount (struct parse *p, struct re_guts *g);
+static void mcinvert(struct parse *p, cset *cs);
+static void mccase(struct parse *p, cset *cs);
+static int isinsets(struct re_guts *g, int c);
+static int samesets(struct re_guts *g, int c1, int c2);
+static void categorize(struct parse *p, struct re_guts *g);
+static sopno dupl(struct parse *p, sopno start, sopno finish);
+static void doemit(struct parse *p, sop op, size_t opnd);
+static void doinsert(struct parse *p, sop op, size_t opnd, sopno pos);
+static void dofwd(struct parse *p, sopno pos, sop value);
+static void enlarge(struct parse *p, sopno size);
+static void stripsnug(struct parse *p, struct re_guts *g);
+static void findmust(struct parse *p, struct re_guts *g);
+static int altoffset(sop *scan, int offset, int mccs);
+static void computejumps(struct parse *p, struct re_guts *g);
+static void computematchjumps(struct parse *p, struct re_guts *g);
+static sopno pluscount(struct parse *p, struct re_guts *g);
 
 #ifdef __cplusplus
 }
@@ -187,16 +187,13 @@ static int never = 0;             /* for use in asserts; shuts lint up */
  = #define     REG_DUMP        0200
  */
 int                            /* 0 success, otherwise REG_something */
-regcomp(preg, pattern, cflags)
-regex_t *preg;
-const char *pattern;
-int cflags;
+regcomp(regex_t *preg, const char *pattern, int cflags)
 {
        struct parse pa;
-       register struct re_guts *g;
-       register struct parse *p = &pa;
-       register int i;
-       register size_t len;
+       struct re_guts *g;
+       struct parse *p = &pa;
+       int i;
+       size_t len;
 #ifdef REDEBUG
 #      define  GOODFLAGS(f)    (f)
 #else
@@ -305,15 +302,14 @@ int cflags;
  == static void p_ere(register struct parse *p, int stop);
  */
 static void
-p_ere(p, stop)
-register struct parse *p;
-int stop;                      /* character this ERE should end at */
+p_ere(struct parse *p,
+      int stop)                        /* character this ERE should end at */
 {
-       register char c;
-       register sopno prevback;
-       register sopno prevfwd;
-       register sopno conc;
-       register int first = 1;         /* is this the first alternative? */
+       char c;
+       sopno prevback;
+       sopno prevfwd;
+       sopno conc;
+       int first = 1;          /* is this the first alternative? */
 
        for (;;) {
                /* do a bunch of concatenated expressions */
@@ -351,14 +347,13 @@ int stop;                 /* character this ERE should end at */
  == static void p_ere_exp(register struct parse *p);
  */
 static void
-p_ere_exp(p)
-register struct parse *p;
+p_ere_exp(struct parse *p)
 {
-       register char c;
-       register sopno pos;
-       register int count;
-       register int count2;
-       register sopno subno;
+       char c;
+       sopno pos;
+       int count;
+       int count2;
+       sopno subno;
        int wascaret = 0;
 
        assert(MORE());         /* caller should have ensured this */
@@ -500,8 +495,7 @@ register struct parse *p;
  == static void p_str(register struct parse *p);
  */
 static void
-p_str(p)
-register struct parse *p;
+p_str(struct parse *p)
 {
        (void)REQUIRE(MORE(), REG_EMPTY);
        while (MORE())
@@ -521,14 +515,13 @@ register struct parse *p;
  * The amount of lookahead needed to avoid this kludge is excessive.
  */
 static void
-p_bre(p, end1, end2)
-register struct parse *p;
-register int end1;             /* first terminating character */
-register int end2;             /* second terminating character */
+p_bre(struct parse *p,
+      int end1,                        /* first terminating character */
+      int end2)                        /* second terminating character */
 {
-       register sopno start = HERE();
-       register int first = 1;                 /* first subexpression? */
-       register int wasdollar = 0;
+       sopno start = HERE();
+       int first = 1;                  /* first subexpression? */
+       int wasdollar = 0;
 
        if (EAT('^')) {
                EMIT(OBOL, 0);
@@ -554,16 +547,15 @@ register int end2;                /* second terminating character */
  == static int p_simp_re(register struct parse *p, int starordinary);
  */
 static int                     /* was the simple RE an unbackslashed $? */
-p_simp_re(p, starordinary)
-register struct parse *p;
-int starordinary;              /* is a leading * an ordinary character? */
+p_simp_re(struct parse *p,
+         int starordinary)     /* is a leading * an ordinary character? */
 {
-       register int c;
-       register int count;
-       register int count2;
-       register sopno pos;
-       register int i;
-       register sopno subno;
+       int c;
+       int count;
+       int count2;
+       sopno pos;
+       int i;
+       sopno subno;
 #      define  BACKSL  (1<<CHAR_BIT)
 
        pos = HERE();           /* repetion op, if any, covers from here */
@@ -672,11 +664,10 @@ int starordinary;         /* is a leading * an ordinary character? */
  == static int p_count(register struct parse *p);
  */
 static int                     /* the value */
-p_count(p)
-register struct parse *p;
+p_count(struct parse *p)
 {
-       register int count = 0;
-       register int ndigits = 0;
+       int count = 0;
+       int ndigits = 0;
 
        while (MORE() && isdigit((uch)PEEK()) && count <= DUPMAX) {
                count = count*10 + (GETNEXT() - '0');
@@ -695,11 +686,10 @@ register struct parse *p;
  * no set operations are done.
  */
 static void
-p_bracket(p)
-register struct parse *p;
+p_bracket(struct parse *p)
 {
-       register cset *cs = allocset(p);
-       register int invert = 0;
+       cset *cs = allocset(p);
+       int invert = 0;
 
        /* Dept of Truly Sickening Special-Case Kludges */
        if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) {
@@ -769,13 +759,11 @@ register struct parse *p;
  == static void p_b_term(register struct parse *p, register cset *cs);
  */
 static void
-p_b_term(p, cs)
-register struct parse *p;
-register cset *cs;
+p_b_term(struct parse *p, cset *cs)
 {
-       register char c;
-       register char start, finish;
-       register int i;
+       char c;
+       char start, finish;
+       int i;
 
        /* classify what we've got */
        switch ((MORE()) ? PEEK() : '\0') {
@@ -848,14 +836,12 @@ register cset *cs;
  == static void p_b_cclass(register struct parse *p, register cset *cs);
  */
 static void
-p_b_cclass(p, cs)
-register struct parse *p;
-register cset *cs;
+p_b_cclass(struct parse *p, cset *cs)
 {
-       register int c;
-       register char *sp = p->next;
-       register struct cclass *cp;
-       register size_t len;
+       int c;
+       char *sp = p->next;
+       struct cclass *cp;
+       size_t len;
 
        while (MORE() && isalpha((uch)PEEK()))
                NEXT();
@@ -944,11 +930,9 @@ register cset *cs;
  * This implementation is incomplete. xxx
  */
 static void
-p_b_eclass(p, cs)
-register struct parse *p;
-register cset *cs;
+p_b_eclass(struct parse *p, cset *cs)
 {
-       register char c;
+       char c;
 
        c = p_b_coll_elem(p, '=');
        CHadd(cs, c);
@@ -959,10 +943,9 @@ register cset *cs;
  == static char p_b_symbol(register struct parse *p);
  */
 static char                    /* value of symbol */
-p_b_symbol(p)
-register struct parse *p;
+p_b_symbol(struct parse *p)
 {
-       register char value;
+       char value;
 
        (void)REQUIRE(MORE(), REG_EBRACK);
        if (!EATTWO('[', '.'))
@@ -979,13 +962,12 @@ register struct parse *p;
  == static char p_b_coll_elem(register struct parse *p, int endc);
  */
 static char                    /* value of collating element */
-p_b_coll_elem(p, endc)
-register struct parse *p;
-int endc;                      /* name ended by endc,']' */
+p_b_coll_elem(struct parse *p,
+    int endc)                  /* name ended by endc,']' */
 {
-       register char *sp = p->next;
-       register struct cname *cp;
-       register int len;
+       char *sp = p->next;
+       struct cname *cp;
+       int len;
 
        while (MORE() && !SEETWO(endc, ']'))
                NEXT();
@@ -1008,8 +990,7 @@ int endc;                  /* name ended by endc,']' */
  == static char othercase(int ch);
  */
 static char                    /* if no counterpart, return ch */
-othercase(ch)
-int ch;
+othercase(int ch)
 {
        ch = (uch)ch;
        assert(isalpha(ch));
@@ -1028,12 +1009,10 @@ int ch;
  * Boy, is this implementation ever a kludge...
  */
 static void
-bothcases(p, ch)
-register struct parse *p;
-int ch;
+bothcases(struct parse *p, int ch)
 {
-       register char *oldnext = p->next;
-       register char *oldend = p->end;
+       char *oldnext = p->next;
+       char *oldend = p->end;
        char bracket[3];
 
        ch = (uch)ch;
@@ -1054,11 +1033,9 @@ int ch;
  == static void ordinary(register struct parse *p, register int ch);
  */
 static void
-ordinary(p, ch)
-register struct parse *p;
-register int ch;
+ordinary(struct parse *p, int ch)
 {
-       register cat_t *cap = p->g->categories;
+       cat_t *cap = p->g->categories;
 
        if ((p->g->cflags&REG_ICASE) && isalpha((uch)ch) && othercase(ch) != ch)
                bothcases(p, ch);
@@ -1076,11 +1053,10 @@ register int ch;
  * Boy, is this implementation ever a kludge...
  */
 static void
-nonnewline(p)
-register struct parse *p;
+nonnewline(struct parse *p)
 {
-       register char *oldnext = p->next;
-       register char *oldend = p->end;
+       char *oldnext = p->next;
+       char *oldend = p->end;
        char bracket[4];
 
        p->next = bracket;
@@ -1100,18 +1076,17 @@ register struct parse *p;
  == static void repeat(register struct parse *p, sopno start, int from, int to);
  */
 static void
-repeat(p, start, from, to)
-register struct parse *p;
-sopno start;                   /* operand from here to end of strip */
-int from;                      /* repeated from this number */
-int to;                                /* to this number of times (maybe INFINITY) */
+repeat(struct parse *p,
+       sopno start,            /* operand from here to end of strip */
+       int from,               /* repeated from this number */
+       int to)                 /* to this number of times (maybe INFINITY) */
 {
-       register sopno finish = HERE();
+       sopno finish = HERE();
 #      define  N       2
 #      define  INF     3
 #      define  REP(f, t)       ((f)*8 + (t))
 #      define  MAP(n)  (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)
-       register sopno copy;
+       sopno copy;
 
        if (p->error != 0)      /* head off possible runaway recursion */
                return;
@@ -1172,9 +1147,7 @@ int to;                           /* to this number of times (maybe INFINITY) */
  == static int seterr(register struct parse *p, int e);
  */
 static int                     /* useless but makes type checking happy */
-seterr(p, e)
-register struct parse *p;
-int e;
+seterr(struct parse *p, int e)
 {
        if (p->error == 0)      /* keep earliest error condition */
                p->error = e;
@@ -1188,15 +1161,14 @@ int e;
  == static cset *allocset(register struct parse *p);
  */
 static cset *
-allocset(p)
-register struct parse *p;
+allocset(struct parse *p)
 {
-       register int no = p->g->ncsets++;
-       register size_t nc;
-       register size_t nbytes;
-       register cset *cs;
-       register size_t css = (size_t)p->g->csetsize;
-       register int i;
+       int no = p->g->ncsets++;
+       size_t nc;
+       size_t nbytes;
+       cset *cs;
+       size_t css = (size_t)p->g->csetsize;
+       int i;
 
        if (no >= p->ncsalloc) {        /* need another column of space */
                p->ncsalloc += CHAR_BIT;
@@ -1243,13 +1215,11 @@ register struct parse *p;
  == static void freeset(register struct parse *p, register cset *cs);
  */
 static void
-freeset(p, cs)
-register struct parse *p;
-register cset *cs;
+freeset(struct parse *p, cset *cs)
 {
-       register int i;
-       register cset *top = &p->g->sets[p->g->ncsets];
-       register size_t css = (size_t)p->g->csetsize;
+       int i;
+       cset *top = &p->g->sets[p->g->ncsets];
+       size_t css = (size_t)p->g->csetsize;
 
        for (i = 0; i < css; i++)
                CHsub(cs, i);
@@ -1268,15 +1238,13 @@ register cset *cs;
  * the same value!
  */
 static int                     /* set number */
-freezeset(p, cs)
-register struct parse *p;
-register cset *cs;
+freezeset(struct parse *p, cset *cs)
 {
-       register short h = cs->hash;
-       register int i;
-       register cset *top = &p->g->sets[p->g->ncsets];
-       register cset *cs2;
-       register size_t css = (size_t)p->g->csetsize;
+       short h = cs->hash;
+       int i;
+       cset *top = &p->g->sets[p->g->ncsets];
+       cset *cs2;
+       size_t css = (size_t)p->g->csetsize;
 
        /* look for an earlier one which is the same */
        for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)
@@ -1302,12 +1270,10 @@ register cset *cs;
  == static int firstch(register struct parse *p, register cset *cs);
  */
 static int                     /* character; there is no "none" value */
-firstch(p, cs)
-register struct parse *p;
-register cset *cs;
+firstch(struct parse *p, cset *cs)
 {
-       register int i;
-       register size_t css = (size_t)p->g->csetsize;
+       int i;
+       size_t css = (size_t)p->g->csetsize;
 
        for (i = 0; i < css; i++)
                if (CHIN(cs, i))
@@ -1321,13 +1287,11 @@ register cset *cs;
  == static int nch(register struct parse *p, register cset *cs);
  */
 static int
-nch(p, cs)
-register struct parse *p;
-register cset *cs;
+nch(struct parse *p, cset *cs)
 {
-       register int i;
-       register size_t css = (size_t)p->g->csetsize;
-       register int n = 0;
+       int i;
+       size_t css = (size_t)p->g->csetsize;
+       int n = 0;
 
        for (i = 0; i < css; i++)
                if (CHIN(cs, i))
@@ -1341,12 +1305,9 @@ register cset *cs;
  ==    register char *cp);
  */
 static void
-mcadd(p, cs, cp)
-register struct parse *p;
-register cset *cs;
-register char *cp;
+mcadd(struct parse *p, cset *cs, char *cp)
 {
-       register size_t oldend = cs->smultis;
+       size_t oldend = cs->smultis;
 
        cs->smultis += strlen(cp) + 1;
        if (cs->multis == NULL)
@@ -1368,12 +1329,10 @@ register char *cp;
  == static void mcsub(register cset *cs, register char *cp);
  */
 static void
-mcsub(cs, cp)
-register cset *cs;
-register char *cp;
+mcsub(cset *cs, char *cp)
 {
-       register char *fp = mcfind(cs, cp);
-       register size_t len = strlen(fp);
+       char *fp = mcfind(cs, cp);
+       size_t len = strlen(fp);
 
        assert(fp != NULL);
        (void) memmove(fp, fp + len + 1,
@@ -1395,9 +1354,7 @@ register char *cp;
  == static int mcin(register cset *cs, register char *cp);
  */
 static int
-mcin(cs, cp)
-register cset *cs;
-register char *cp;
+mcin(cset *cs, char *cp)
 {
        return(mcfind(cs, cp) != NULL);
 }
@@ -1407,11 +1364,9 @@ register char *cp;
  == static char *mcfind(register cset *cs, register char *cp);
  */
 static char *
-mcfind(cs, cp)
-register cset *cs;
-register char *cp;
+mcfind(cset *cs, char *cp)
 {
-       register char *p;
+       char *p;
 
        if (cs->multis == NULL)
                return(NULL);
@@ -1430,9 +1385,7 @@ register char *cp;
  * is deferred.
  */
 static void
-mcinvert(p, cs)
-register struct parse *p;
-register cset *cs;
+mcinvert(struct parse *p, cset *cs)
 {
        assert(cs->multis == NULL);     /* xxx */
 }
@@ -1445,9 +1398,7 @@ register cset *cs;
  * is deferred.
  */
 static void
-mccase(p, cs)
-register struct parse *p;
-register cset *cs;
+mccase(struct parse *p, cset *cs)
 {
        assert(cs->multis == NULL);     /* xxx */
 }
@@ -1457,14 +1408,12 @@ register cset *cs;
  == static int isinsets(register struct re_guts *g, int c);
  */
 static int                     /* predicate */
-isinsets(g, c)
-register struct re_guts *g;
-int c;
+isinsets(struct re_guts *g, int c)
 {
-       register uch *col;
-       register int i;
-       register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-       register unsigned uc = (uch)c;
+       uch *col;
+       int i;
+       int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+       unsigned uc = (uch)c;
 
        for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
                if (col[uc] != 0)
@@ -1477,16 +1426,13 @@ int c;
  == static int samesets(register struct re_guts *g, int c1, int c2);
  */
 static int                     /* predicate */
-samesets(g, c1, c2)
-register struct re_guts *g;
-int c1;
-int c2;
+samesets(struct re_guts *g, int c1, int c2)
 {
-       register uch *col;
-       register int i;
-       register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-       register unsigned uc1 = (uch)c1;
-       register unsigned uc2 = (uch)c2;
+       uch *col;
+       int i;
+       int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+       unsigned uc1 = (uch)c1;
+       unsigned uc2 = (uch)c2;
 
        for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
                if (col[uc1] != col[uc2])
@@ -1499,14 +1445,12 @@ int c2;
  == static void categorize(struct parse *p, register struct re_guts *g);
  */
 static void
-categorize(p, g)
-struct parse *p;
-register struct re_guts *g;
+categorize(struct parse *p, struct re_guts *g)
 {
-       register cat_t *cats = g->categories;
-       register int c;
-       register int c2;
-       register cat_t cat;
+       cat_t *cats = g->categories;
+       int c;
+       int c2;
+       cat_t cat;
 
        /* avoid making error situations worse */
        if (p->error != 0)
@@ -1527,13 +1471,12 @@ register struct re_guts *g;
  == static sopno dupl(register struct parse *p, sopno start, sopno finish);
  */
 static sopno                   /* start of duplicate */
-dupl(p, start, finish)
-register struct parse *p;
-sopno start;                   /* from here */
-sopno finish;                  /* to this less one */
+dupl(struct parse *p,
+     sopno start,              /* from here */
+     sopno finish)             /* to this less one */
 {
-       register sopno ret = HERE();
-       register sopno len = finish - start;
+       sopno ret = HERE();
+       sopno len = finish - start;
 
        assert(finish >= start);
        if (len == 0)
@@ -1555,10 +1498,7 @@ sopno finish;                    /* to this less one */
  * some changes to the data structures.  Maybe later.
  */
 static void
-doemit(p, op, opnd)
-register struct parse *p;
-sop op;
-size_t opnd;
+doemit(struct parse *p, sop op, size_t opnd)
 {
        /* avoid making error situations worse */
        if (p->error != 0)
@@ -1581,15 +1521,11 @@ size_t opnd;
  == static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
  */
 static void
-doinsert(p, op, opnd, pos)
-register struct parse *p;
-sop op;
-size_t opnd;
-sopno pos;
+doinsert(struct parse *p, sop op, size_t opnd, sopno pos)
 {
-       register sopno sn;
-       register sop s;
-       register int i;
+       sopno sn;
+       sop s;
+       int i;
 
        /* avoid making error situations worse */
        if (p->error != 0)
@@ -1621,10 +1557,7 @@ sopno pos;
  == static void dofwd(register struct parse *p, sopno pos, sop value);
  */
 static void
-dofwd(p, pos, value)
-register struct parse *p;
-register sopno pos;
-sop value;
+dofwd(struct parse *p, sopno pos, sop value)
 {
        /* avoid making error situations worse */
        if (p->error != 0)
@@ -1639,11 +1572,9 @@ sop value;
  == static void enlarge(register struct parse *p, sopno size);
  */
 static void
-enlarge(p, size)
-register struct parse *p;
-register sopno size;
+enlarge(struct parse *p, sopno size)
 {
-       register sop *sp;
+       sop *sp;
 
        if (p->ssize >= size)
                return;
@@ -1662,9 +1593,7 @@ register sopno size;
  == static void stripsnug(register struct parse *p, register struct re_guts *g);
  */
 static void
-stripsnug(p, g)
-register struct parse *p;
-register struct re_guts *g;
+stripsnug(struct parse *p, struct re_guts *g)
 {
        g->nstates = p->slen;
        g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
@@ -1685,17 +1614,15 @@ register struct re_guts *g;
  * Note that must and mlen got initialized during setup.
  */
 static void
-findmust(p, g)
-struct parse *p;
-register struct re_guts *g;
+findmust(struct parse *p, struct re_guts *g)
 {
-       register sop *scan;
+       sop *scan;
        sop *start;
-       register sop *newstart;
-       register sopno newlen;
-       register sop s;
-       register char *cp;
-       register sopno i;
+       sop *newstart;
+       sopno newlen;
+       sop s;
+       char *cp;
+       sopno i;
        int offset;
        int cs, mccs;
 
@@ -1854,10 +1781,7 @@ register struct re_guts *g;
  * re paths.
  */
 static int
-altoffset(scan, offset, mccs)
-sop *scan;
-int offset;
-int mccs;
+altoffset(sop *scan, int offset, int mccs)
 {
        int largest;
        int try;
@@ -1934,9 +1858,7 @@ int mccs;
  * the value of the character from the text that was mismatched.
  */
 static void
-computejumps(p, g)
-struct parse *p;
-struct re_guts *g;
+computejumps(struct parse *p, struct re_guts *g)
 {
        int ch;
        int mindex;
@@ -1980,9 +1902,7 @@ struct re_guts *g;
  * the search algorithm works.
  */
 static void
-computematchjumps(p, g)
-struct parse *p;
-struct re_guts *g;
+computematchjumps(struct parse *p, struct re_guts *g)
 {
        int mindex;             /* General "must" iterator */
        int suffix;             /* Keeps track of matching suffix */
@@ -2056,14 +1976,12 @@ struct re_guts *g;
  == static sopno pluscount(register struct parse *p, register struct re_guts *g);
  */
 static sopno                   /* nesting depth */
-pluscount(p, g)
-struct parse *p;
-register struct re_guts *g;
+pluscount(struct parse *p, struct re_guts *g)
 {
-       register sop *scan;
-       register sop s;
-       register sopno plusnest = 0;
-       register sopno maxnest = 0;
+       sop *scan;
+       sop s;
+       sopno plusnest = 0;
+       sopno maxnest = 0;
 
        if (p->error != 0)
                return(0);      /* there may not be an OEND */
index 19572d0..cb44501 100644 (file)
@@ -37,7 +37,7 @@
  *     @(#)regerror.c  8.4 (Berkeley) 3/20/94
  *
  * @(#)regerror.c      8.4 (Berkeley) 3/20/94
- * $DragonFly: src/lib/libc/regex/regerror.c,v 1.4 2003/11/12 20:21:25 eirikn Exp $
+ * $DragonFly: src/lib/libc/regex/regerror.c,v 1.5 2004/02/06 22:36:50 joerg Exp $
  */
 
 #include <sys/types.h>
@@ -55,7 +55,7 @@ extern "C" {
 #endif
 
 /* === regerror.c === */
-static char *regatoi (const regex_t *preg, char *localbuf);
+static char *regatoi(const regex_t *preg, char *localbuf);
 
 #ifdef __cplusplus
 }
@@ -111,16 +111,12 @@ static struct rerr {
  */
 /* ARGSUSED */
 size_t
-regerror(errcode, preg, errbuf, errbuf_size)
-int errcode;
-const regex_t *preg;
-char *errbuf;
-size_t errbuf_size;
+regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
 {
-       register struct rerr *r;
-       register size_t len;
-       register int target = errcode &~ REG_ITOA;
-       register char *s;
+       struct rerr *r;
+       size_t len;
+       int target = errcode &~ REG_ITOA;
+       char *s;
        char convbuf[50];
 
        if (errcode == REG_ATOI)
@@ -159,11 +155,9 @@ size_t errbuf_size;
  == static char *regatoi(const regex_t *preg, char *localbuf);
  */
 static char *
-regatoi(preg, localbuf)
-const regex_t *preg;
-char *localbuf;
+regatoi(const regex_t *preg, char *localbuf)
 {
-       register struct rerr *r;
+       struct rerr *r;
 
        for (r = rerrs; r->code != 0; r++)
                if (strcmp(r->name, preg->re_endp) == 0)
index 9764be9..92dcb2b 100644 (file)
@@ -37,6 +37,8 @@
  *     @(#)regexec.c   8.3 (Berkeley) 3/20/94
  *
  * @(#)regexec.c       8.3 (Berkeley) 3/20/94
+ *
+ * $DragonFly: src/lib/libc/regex/regexec.c,v 1.3 2004/02/06 22:36:50 joerg Exp $
  */
 
 /*
@@ -151,14 +153,10 @@ static int nope = 0;              /* for use in asserts; shuts lint up */
  * have been prototyped.
  */
 int                            /* 0 success, REG_NOMATCH failure */
-regexec(preg, string, nmatch, pmatch, eflags)
-const regex_t *preg;
-const char *string;
-size_t nmatch;
-regmatch_t pmatch[];
-int eflags;
+regexec(const regex_t *preg, const char *string, size_t nmatch,
+       regmatch_t pmatch[], int eflags)
 {
-       register struct re_guts *g = preg->re_g;
+       struct re_guts *g = preg->re_g;
 #ifdef REDEBUG
 #      define  GOODFLAGS(f)    (f)
 #else
index f334201..e032646 100644 (file)
@@ -37,7 +37,7 @@
  *     @(#)regfree.c   8.3 (Berkeley) 3/20/94
  *
  * $FreeBSD: src/lib/libc/regex/regfree.c,v 1.1.1.1.14.1 2000/07/31 06:30:37 dcs Exp $
- * $DragonFly: src/lib/libc/regex/regfree.c,v 1.2 2003/06/17 04:26:44 dillon Exp $
+ * $DragonFly: src/lib/libc/regex/regfree.c,v 1.3 2004/02/06 22:36:50 joerg Exp $
  *
  * @(#)regfree.c       8.3 (Berkeley) 3/20/94
  */
  = extern void regfree(regex_t *);
  */
 void
-regfree(preg)
-regex_t *preg;
+regfree(regex_t *preg)
 {
-       register struct re_guts *g;
+       struct re_guts *g;
 
        if (preg->re_magic != MAGIC1)   /* oops */
                return;                 /* nice to complain, but hard */