This repo was linked in the original repo as a newer version, with the current version being the original version that abandoned development 8 years ago.
Nothing has been changed outside of that source, which is from upstream.
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
- <ModuleDefinitionFile>regex/regex.def</ModuleDefinitionFile>
+ <ModuleDefinitionFile>regex/librxspencer.def</ModuleDefinitionFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
<TargetMachine>MachineX64</TargetMachine>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
- <ModuleDefinitionFile>regex/regex.def</ModuleDefinitionFile>
+ <ModuleDefinitionFile>regex/librxspencer.def</ModuleDefinitionFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Windows</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<ClCompile Include="regex\split.c" />
</ItemGroup>
<ItemGroup>
- <None Include="regex\regex.def" />
+ <None Include="regex\librxspencer.def" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="regex\regex.h" />
</ClCompile>
</ItemGroup>
<ItemGroup>
- <None Include="regex\regex.def">
+ <None Include="regex\librxspencer.def">
<Filter>Source Files</Filter>
</None>
</ItemGroup>
# Internal stuff, should not need changing.
OBJPRODN=regcomp.o regexec.o regerror.o regfree.o
OBJS=$(OBJPRODN) split.o debug.o main.o
-H=cclass.h cname.h regex2.h utils.h
+H=regex2.h utils.h
REGSRC=regcomp.c regerror.c regexec.c regfree.c
ALLSRC=$(REGSRC) engine.c debug.c main.c split.c
LINTC=regcomp.c regexec.c regerror.c regfree.c debug.c main.c
JUNKLINT=possible pointer alignment|null effect
-# arrangements to build forward-reference header files
-.SUFFIXES: .ih .h
-.c.ih:
- sh ./mkh $(MKHFLAGS) -p $< >$@
-
default: r
lib: purge $(OBJPRODN)
# dependencies
$(OBJPRODN) debug.o: utils.h regex.h regex2.h
-regcomp.o: cclass.h cname.h regcomp.ih
-regexec.o: engine.c engine.ih
-regerror.o: regerror.ih
-debug.o: debug.ih
-main.o: main.ih
+regcomp.o: regcomp.h
+regexec.o: engine.c engine.h
+regerror.o: regerror.h
+debug.o: debug.h
+main.o: main.h
# tester
re: $(OBJS)
ti README WHATSNEW notes todo | list
ti *.h | list
list *.c
- list regex.3 regex.7
+ list rxspenser.3 rxspenser.7
print:
ti README WHATSNEW notes todo | list
mf.tmp: Makefile
sed '/^REGEXH=/s/=.*/=regex.h/' Makefile | sed '/#DEL$$/d' >$@
-DTRH=cclass.h cname.h regex2.h utils.h
+DTRH=regex2.h utils.h
PRE=COPYRIGHT README WHATSNEW
-POST=mkh regex.3 regex.7 tests $(DTRH) $(ALLSRC) fake/*.[ch]
+POST=mkh rxspenser.3 rxspenser.7 tests $(DTRH) $(ALLSRC) fake/*.[ch]
FILES=$(PRE) Makefile $(POST)
DTR=$(PRE) Makefile=mf.tmp $(POST)
dtr: $(FILES) mf.tmp
rm -f junk* core core.* *.core dtr *.tmp lint
clean: tidy
- rm -f *.o *.s *.ih re libregex.a
+ rm -f *.o *.s re libregex.a
# don't do this one unless you know what you're doing
spotless: clean
-alpha3.8 release.
-Tue Aug 10 15:51:48 EDT 1999
-henry@spsystems.net (formerly henry@zoo.toronto.edu)
+This is a modified version of Henry Spencer's "BSD" regular expression
+library. The original library can be found at
+https://github.com/garyhouston/regex. A description of Spencer's
+various libraries can be found at https://garyhouston.github.io/regex/
-See WHATSNEW for change listing.
+The changes in this version are:
-installation notes:
---------
-Read the comments at the beginning of Makefile before running.
+* The library name has been changed to rxspencer, the header installs
+ into a directory rxspencer, and the man pages named accordingly, to
+ allow easy installation as a system library on Linux without
+ conflicting with other regex libraries.
+* A CMake build system, which can build either static or shared
+ libraries, maybe even on non-Unix systems.
+* A few code modernizations and changes to improve portabilty, avoid
+ compiler warnings, and improve robustness.
-Utils.h contains some things that just might have to be modified on
-some systems, as well as a nested include (ugh) of <assert.h>.
+I (Gary Houston) originally made this version with a build system
+based on GNU Automake and Libtool, to allow building a shared library
+for a project where the library needed to be dynamically loaded. The
+CMake scripts were contributed by Stephen Just, modified from LuaDist
+versions.
-The "fake" directory contains quick-and-dirty fakes for some header
-files and routines that old systems may not have. Note also that
--DUSEBCOPY will make utils.h substitute bcopy() for memmove().
+Spencer's original license can be found in the COPYRIGHT file. The CMake
+scripts are licensed under the MIT license. I release all of my own
+changes to the public domain under the Creative Commons Zero license.
-After that, "make r" will build regcomp.o, regexec.o, regfree.o,
-and regerror.o (the actual routines), bundle them together into a test
-program, and run regression tests on them. No output is good output.
+Installation
+============
-"make lib" builds just the .o files for the actual routines (when
-you're happy with testing and have adjusted CFLAGS for production),
-and puts them together into libregex.a. You can pick up either the
-library or *.o ("make lib" makes sure there are no other .o files left
-around to confuse things).
+CMake needs to be installed. To build from a Linux command line, or
+something compatible, within the source directory:
-Main.c, debug.c, split.c are used for regression testing but are not part
-of the RE routines themselves.
+to configure for a static library:
+cmake .
+or
+cmake -Drxshared=0 .
-Regex.h goes in /usr/include. All other .h files are internal only.
---------
+to configure for a shared library:
+cmake -Drxshared=1 .
+
+to disable tests:
+cmake -DBUILD_TESTING=OFF .
+
+to disable manuals/ documentation:
+cmake -DINSTALL_DOCS=OFF .
+
+to build:
+make
+make install
+
+also required on Linux, after installing the shared library:
+ldconfig
+
+to run the tests:
+make test
+
+to run the tests, with output displayed:
+ctest -V
+
+Usage
+=====
+
+Include the following header in a C program:
+
+#include <rxspencer/regex.h>
+
+Link with the library using the -lrxspencer flag, as in:
+gcc test.c -o test -lrxspencer
+
+The library is further described in the supplied man pages: rxspencer.3
+and rxspencer.7, which are formatted at
+https://garyhouston.github.io/regex/regex3.html and
+https://garyhouston.github.io/regex/regex7.html.
+
+--
+Gary Houston, ghouston@arglist.com
+New in 3.9.0 (Gary Houston): Conversion to cmake build system,
+contributed by Stephen Just. Simplify version labelling. Simplify
+build system by not generating headers. Adjust types and add casts to
+avoid compiler warnings. Remove unused and undocumented REG_DUMP
+flag. Make regerror more robust.
+
+New in alpha3.8.g7 (Gary Houston): Configuration scripts updated. Make sure
+symlinks aren't created by libtool. 26 Nov 2015.
+
+New in alpha3.8.g6 (Gary Houston): Bug fix for integer overflow in regcomp
+for excessively long pattern strings. CERT Vulnerability Note VU#695940.
+Found by Guido Vranken. Configuration scripts updated. 25 Feb 2015.
+
+New in alpha3.8.g5 (Gary Houston): Configuration scripts updated. Fixed
+"make check". Deleted unused "fake" C library headers.
+
+New in alpha3.8.g4 (Gary Houston): Makefile.am: account for $(DESTDIR)
+in install-data-local, thanks to Aleksey Cheusov. Configuration scripts
+updated.
+
+New in alpha3.8.g3 (Gary Houston): configuration scripts updated.
+
+New in alpha3.8.g2 (Gary Houston): configure.in, Makefile.am: updated
+for newer versions of autoconf/automake/libtool, with miscellaneous
+changes. mkh: don't set PATH, in case utilities are in non-standard
+locations (i.e., cygwin).
+
+New in alpha3.8.g1 (Gary Houston): Use autoconf/automake/libtool to
+build, test and install the library. Renamed the installed files to
+avoid conflicts with other regex libraries.
+
New in alpha3.8: Bug fix for signed/unsigned mixup, found and fixed
by the FreeBSD folks.
+++ /dev/null
-/* character-class table */
-static struct cclass {
- char *name;
- char *chars;
- char *multis;
-} cclasses[] = {
- "alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
-0123456789", "",
- "alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
- "",
- "blank", " \t", "",
- "cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
-\25\26\27\30\31\32\33\34\35\36\37\177", "",
- "digit", "0123456789", "",
- "graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
-0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
- "",
- "lower", "abcdefghijklmnopqrstuvwxyz",
- "",
- "print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
-0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
- "",
- "punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
- "",
- "space", "\t\n\v\f\r ", "",
- "upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
- "",
- "xdigit", "0123456789ABCDEFabcdef",
- "",
- NULL, 0, ""
-};
+++ /dev/null
-/* character-name table */
-static struct cname {
- char *name;
- char code;
-} cnames[] = {
- "NUL", '\0',
- "SOH", '\001',
- "STX", '\002',
- "ETX", '\003',
- "EOT", '\004',
- "ENQ", '\005',
- "ACK", '\006',
- "BEL", '\007',
- "alert", '\007',
- "BS", '\010',
- "backspace", '\b',
- "HT", '\011',
- "tab", '\t',
- "LF", '\012',
- "newline", '\n',
- "VT", '\013',
- "vertical-tab", '\v',
- "FF", '\014',
- "form-feed", '\f',
- "CR", '\015',
- "carriage-return", '\r',
- "SO", '\016',
- "SI", '\017',
- "DLE", '\020',
- "DC1", '\021',
- "DC2", '\022',
- "DC3", '\023',
- "DC4", '\024',
- "NAK", '\025',
- "SYN", '\026',
- "ETB", '\027',
- "CAN", '\030',
- "EM", '\031',
- "SUB", '\032',
- "ESC", '\033',
- "IS4", '\034',
- "FS", '\034',
- "IS3", '\035',
- "GS", '\035',
- "IS2", '\036',
- "RS", '\036',
- "IS1", '\037',
- "US", '\037',
- "space", ' ',
- "exclamation-mark", '!',
- "quotation-mark", '"',
- "number-sign", '#',
- "dollar-sign", '$',
- "percent-sign", '%',
- "ampersand", '&',
- "apostrophe", '\'',
- "left-parenthesis", '(',
- "right-parenthesis", ')',
- "asterisk", '*',
- "plus-sign", '+',
- "comma", ',',
- "hyphen", '-',
- "hyphen-minus", '-',
- "period", '.',
- "full-stop", '.',
- "slash", '/',
- "solidus", '/',
- "zero", '0',
- "one", '1',
- "two", '2',
- "three", '3',
- "four", '4',
- "five", '5',
- "six", '6',
- "seven", '7',
- "eight", '8',
- "nine", '9',
- "colon", ':',
- "semicolon", ';',
- "less-than-sign", '<',
- "equals-sign", '=',
- "greater-than-sign", '>',
- "question-mark", '?',
- "commercial-at", '@',
- "left-square-bracket", '[',
- "backslash", '\\',
- "reverse-solidus", '\\',
- "right-square-bracket", ']',
- "circumflex", '^',
- "circumflex-accent", '^',
- "underscore", '_',
- "low-line", '_',
- "grave-accent", '`',
- "left-brace", '{',
- "left-curly-bracket", '{',
- "vertical-line", '|',
- "right-brace", '}',
- "right-curly-bracket", '}',
- "tilde", '~',
- "DEL", '\177',
- NULL, 0,
-};
#include <limits.h>
#include <stdlib.h>
#include <sys/types.h>
-#include <regex.h>
-#include "utils.h"
+#include "regex.h"
#include "regex2.h"
-#include "debug.ih"
+
+static void s_print(struct re_guts *g, FILE *d);
+static char *regchar(int ch);
/*
- regprint - print a regexp for debugging
- == void regprint(regex_t *r, FILE *d);
*/
void
regprint(r, d)
regex_t *r;
FILE *d;
{
- register struct re_guts *g = r->re_g;
- register int i;
- register int c;
- register int last;
+ struct re_guts *g = r->re_g;
+ int i;
+ int c;
+ int last;
int nincat[NC];
fprintf(d, "%ld states, %d categories", (long)g->nstates,
/*
- s_print - print the strip for debugging
- == static void s_print(register struct re_guts *g, FILE *d);
*/
static void
s_print(g, d)
-register struct re_guts *g;
+struct re_guts *g;
FILE *d;
{
- register sop *s;
- register cset *cs;
- register int i;
- register int done = 0;
- register sop opnd;
- register int col = 0;
- register int last;
- register sopno offset = 2;
+ sop *s;
+ cset *cs;
+ int i;
+ int done = 0;
+ sop opnd;
+ int col = 0;
+ int last;
+ sopno offset = 2;
# define GAP() { if (offset % 5 == 0) { \
if (col > 40) { \
fprintf(d, "\n\t"); \
fprintf(d, ">");
break;
default:
- fprintf(d, "!%d(%d)!", OP(*s), opnd);
+ fprintf(d, "!%ld(%ld)!", OP(*s), opnd);
break;
}
if (!done)
/*
- regchar - make a character printable
- == static char *regchar(int ch);
*/
static char * /* -> representation */
regchar(ch)
states empty; /* empty set of states */
};
-#include "engine.ih"
-
#ifdef REDEBUG
#define SP(t, s, c) print(m, t, s, c, stdout)
#define AT(t, p1, p2, s1, s2) at(m, t, p1, p2, s1, s2)
#define NOTE(s) /* nothing */
#endif
+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);
+#ifdef REDEBUG
+static void print(struct match *m, char *caption, states st,
+ int ch, FILE *d);
+static void at(struct match *m, char *title, char *start, char *stop,
+ sopno startst, sopno stopst);
+static char *pchar(int ch);
+#endif
+
+#define BOL (OUT+1)
+#define EOL (BOL+1)
+#define BOLEOL (BOL+2)
+#define NOTHING (BOL+3)
+#define BOW (BOL+4)
+#define EOW (BOL+5)
+#define CODEMAX (BOL+5) // highest code used
+#define NONCHAR(c) ((c) > CHAR_MAX)
+#define NNONCHAR (CODEMAX-CHAR_MAX)
+
/*
- matcher - the actual matching engine
- == static int matcher(register struct re_guts *g, char *string, \
- == 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;
+struct re_guts *g;
char *string;
size_t nmatch;
regmatch_t pmatch[];
int eflags;
{
- register char *endp;
- register size_t i;
+ char *endp;
+ int i;
struct match mv;
- register struct match *m = &mv;
- register char *dp;
- const register sopno gf = g->firststate+1; /* +1 for OEND */
- const register 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;
STATETEARDOWN(m);
return(REG_ESPACE);
}
- for (i = 1; i <= m->g->nsub; i++)
+ for (i = 1; (size_t) i <= m->g->nsub; i++)
m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
if (!g->backrefs && !(m->eflags®_BACKR)) {
NOTE("dissecting");
dp = dissect(m, m->coldp, endp, gf, gl);
} else {
if (g->nplus > 0 && m->lastpos == NULL)
- m->lastpos = (char **)malloc((g->nplus+1) *
+ m->lastpos = (char **)malloc(((size_t)g->nplus+1) *
sizeof(char *));
if (g->nplus > 0 && m->lastpos == NULL) {
free(m->pmatch);
break; /* defeat */
/* try it on a shorter possibility */
#ifndef NDEBUG
- for (i = 1; i <= m->g->nsub; i++) {
+ for (i = 1; (size_t) i <= m->g->nsub; i++) {
assert(m->pmatch[i].rm_so == -1);
assert(m->pmatch[i].rm_eo == -1);
}
/* fill in the details if requested */
if (nmatch > 0) {
- pmatch[0].rm_so = m->coldp - m->offp;
- pmatch[0].rm_eo = endp - m->offp;
+ pmatch[0].rm_so = (regoff_t)(m->coldp - m->offp);
+ pmatch[0].rm_eo = (regoff_t)(endp - m->offp);
}
if (nmatch > 1) {
assert(m->pmatch != NULL);
- for (i = 1; i < nmatch; i++)
- if (i <= m->g->nsub)
+ for (i = 1; (size_t) i < nmatch; i++)
+ if ((size_t) i <= m->g->nsub)
pmatch[i] = m->pmatch[i];
else {
pmatch[i].rm_so = -1;
/*
- dissect - figure out what matched what, no back references
- == static char *dissect(register struct match *m, char *start, \
- == char *stop, sopno startst, sopno stopst);
*/
static char * /* == stop (success) always */
dissect(m, start, stop, startst, stopst)
-register struct match *m;
+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;
break;
case OLPAREN:
i = OPND(m->g->strip[ss]);
- assert(0 < i && i <= m->g->nsub);
- m->pmatch[i].rm_so = sp - m->offp;
+ assert(0 < i && (size_t) i <= m->g->nsub);
+ m->pmatch[i].rm_so = (regoff_t)(sp - m->offp);
break;
case ORPAREN:
i = OPND(m->g->strip[ss]);
- assert(0 < i && i <= m->g->nsub);
- m->pmatch[i].rm_eo = sp - m->offp;
+ assert(0 < i && (size_t) i <= m->g->nsub);
+ m->pmatch[i].rm_eo = (regoff_t)(sp - m->offp);
break;
default: /* uh oh */
assert(nope);
/*
- backref - figure out what matched what, figuring in back references
- == static char *backref(register struct match *m, char *start, \
- == 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;
+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;
switch (OP(s)) {
case OBACK_: /* the vilest depths */
i = OPND(s);
- assert(0 < i && i <= m->g->nsub);
+ assert(0 < i && (size_t) i <= m->g->nsub);
if (m->pmatch[i].rm_eo == -1)
return(NULL);
assert(m->pmatch[i].rm_so != -1);
- len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
- assert(stop - m->beginp >= len);
+ len = (size_t)(m->pmatch[i].rm_eo - m->pmatch[i].rm_so);
+ assert((size_t) (stop - m->beginp) >= len);
if (sp > stop - len)
return(NULL); /* not enough left to match */
ssp = m->offp + m->pmatch[i].rm_so;
break;
case OLPAREN: /* must undo assignment if rest fails */
i = OPND(s);
- assert(0 < i && i <= m->g->nsub);
+ assert(0 < i && (size_t) i <= m->g->nsub);
offsave = m->pmatch[i].rm_so;
- m->pmatch[i].rm_so = sp - m->offp;
+ m->pmatch[i].rm_so = (regoff_t)(sp - m->offp);
dp = backref(m, sp, stop, ss+1, stopst, lev);
if (dp != NULL)
return(dp);
break;
case ORPAREN: /* must undo assignment if rest fails */
i = OPND(s);
- assert(0 < i && i <= m->g->nsub);
+ assert(0 < i && (size_t) i <= m->g->nsub);
offsave = m->pmatch[i].rm_eo;
- m->pmatch[i].rm_eo = sp - m->offp;
+ m->pmatch[i].rm_eo = (regoff_t)(sp - m->offp);
dp = backref(m, sp, stop, ss+1, stopst, lev);
if (dp != NULL)
return(dp);
/*
- fast - step through the string at top speed
- == static char *fast(register struct match *m, char *start, \
- == char *stop, sopno startst, sopno stopst);
*/
static char * /* where tentative match ended, or NULL */
fast(m, start, stop, startst, stopst)
-register struct match *m;
+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);
/*
- slow - step through the string more deliberately
- == static char *slow(register struct match *m, char *start, \
- == char *stop, sopno startst, sopno stopst);
*/
static char * /* where it ended */
slow(m, start, stop, startst, stopst)
-register struct match *m;
+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;
+ 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);
break; /* NOTE BREAK OUT */
/* no, we must deal with this character */
- ASSIGN(tmp, st);
- ASSIGN(st, empty);
assert(c != OUT);
- st = step(m->g, startst, stopst, tmp, c, st);
+ st = step(m->g, startst, stopst, st, c, empty);
SP("saft", st, c);
assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
p++;
/*
- step - map set of states reachable before char to set reachable after
- == static states step(register struct re_guts *g, sopno start, sopno stop, \
- == register states bef, int ch, register states aft);
- == #define BOL (OUT+1)
- == #define EOL (BOL+1)
- == #define BOLEOL (BOL+2)
- == #define NOTHING (BOL+3)
- == #define BOW (BOL+4)
- == #define EOW (BOL+5)
- == #define CODEMAX (BOL+5) // highest code used
- == #define NONCHAR(c) ((c) > CHAR_MAX)
- == #define NNONCHAR (CODEMAX-CHAR_MAX)
*/
static states
step(g, start, stop, bef, ch, aft)
-register struct re_guts *g;
+struct re_guts *g;
sopno start; /* start state within strip */
sopno stop; /* state after stop state within strip */
-register states bef; /* states reachable before */
+states bef; /* states reachable before */
int ch; /* character or NONCHAR code */
-register states aft; /* states already known reachable after */
+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 long i;
+ cset *cs;
+ sop s;
+ sopno pc;
+ onestate here; /* note, macros know this name */
+ sopno look;
+ long i;
for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
s = g->strip[pc];
#ifdef REDEBUG
/*
- print - print a set of states
- == #ifdef REDEBUG
- == static void print(struct match *m, char *caption, states st, \
- == int ch, FILE *d);
- == #endif
*/
static void
print(m, caption, st, ch, d)
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®_TRACE))
return;
/*
- at - print current situation
- == #ifdef REDEBUG
- == static void at(struct match *m, char *title, char *start, char *stop, \
- == sopno startst, sopno stopst);
- == #endif
*/
static void
at(m, title, start, stop, startst, stopst)
#define PCHARDONE /* never again */
/*
- pchar - make a character printable
- == #ifdef REDEBUG
- == static char *pchar(int ch);
- == #endif
*
* Is this identical to regchar() over in debug.c? Well, yes. But a
* duplicate here avoids having a debugging-capable regexec.o tied to
-LIBRARY regex\r
-VERSION 1.0\r
-EXPORTS\r
-regcomp\r
-regerror\r
-regexec\r
-regfree\r
+EXPORTS
+regcomp
+regerror
+regexec
+regfree
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
-#include <regex.h>
#include <assert.h>
-#include "main.ih"
+#include "regex.h"
-char *progname;
int debug = 0;
int line = 0;
int status = 0;
int copts = REG_EXTENDED;
int eopts = 0;
+char *fopts = 0;
regoff_t startoff = 0;
regoff_t endoff = 0;
-
extern int split();
extern void regprint();
+static void regress(FILE *in);
+static void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+static char *check(char *str, regmatch_t sub, char *should);
+static int parseopts(int argc, char *argv[]);
+static int options(int type, char *s);
+static int opt(int c, char *s);
+static void fixstr(char *p);
+static char *eprint(int err);
+static int efind(char *name);
+
/*
- main - do the simple case, hand off to regress() for regression
*/
+int
main(argc, argv)
int argc;
char *argv[];
regmatch_t subs[NS];
char erbuf[100];
int err;
- size_t len;
- int c;
- int errflg = 0;
- register int i;
- extern int optind;
- extern char *optarg;
-
- progname = argv[0];
-
- while ((c = getopt(argc, argv, "c:e:S:E:x")) != EOF)
- switch (c) {
- case 'c': /* compile options */
- copts = options('c', optarg);
- break;
- case 'e': /* execute options */
- eopts = options('e', optarg);
- break;
- case 'S': /* start offset */
- startoff = (regoff_t)atoi(optarg);
- break;
- case 'E': /* end offset */
- endoff = (regoff_t)atoi(optarg);
- break;
- case 'x': /* Debugging. */
- debug++;
- break;
- case '?':
- default:
- errflg++;
- break;
+ int i;
+ int optind = parseopts(argc, argv);
+
+ if (fopts != 0) {
+ FILE *f = fopen(fopts, "r");
+ if (f == NULL) {
+ fputs("unable to open input\n", stderr);
+ exit(1);
}
- if (errflg) {
- fprintf(stderr, "usage: %s ", progname);
- fprintf(stderr, "[-c copt][-C][-d] [re]\n");
- exit(2);
+ regress(f);
+ exit(status);
}
-
+
if (optind >= argc) {
regress(stdin);
exit(status);
err = regcomp(&re, argv[optind++], copts);
if (err) {
- len = regerror(err, &re, erbuf, sizeof(erbuf));
- fprintf(stderr, "error %s, %d/%d `%s'\n",
- eprint(err), len, sizeof(erbuf), erbuf);
+ size_t len = regerror(err, &re, erbuf, sizeof(erbuf));
+ fprintf(stderr, "error %s, %lu/%d `%s'\n",
+ eprint(err), (unsigned long)len, (int)sizeof(erbuf), erbuf);
exit(status);
}
regprint(&re, stdout);
if (eopts®_STARTEND) {
subs[0].rm_so = startoff;
- subs[0].rm_eo = strlen(argv[optind]) - endoff;
+ subs[0].rm_eo = (regoff_t)strlen(argv[optind]) - endoff;
}
err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
if (err) {
- len = regerror(err, &re, erbuf, sizeof(erbuf));
- fprintf(stderr, "error %s, %d/%d `%s'\n",
- eprint(err), len, sizeof(erbuf), erbuf);
+ size_t len = regerror(err, &re, erbuf, sizeof(erbuf));
+ fprintf(stderr, "error %s, %lu/%d `%s'\n",
+ eprint(err), (unsigned long)len, (int)sizeof(erbuf), erbuf);
exit(status);
}
if (!(copts®_NOSUB)) {
- len = (int)(subs[0].rm_eo - subs[0].rm_so);
+ int len = (int)(subs[0].rm_eo - subs[0].rm_so);
if (subs[0].rm_so != -1) {
if (len != 0)
printf("match `%.*s'\n", len,
/*
- regress - main loop of regression test
- == void regress(FILE *in);
*/
-void
+static void
regress(in)
FILE *in;
{
/*
- try - try it, and report on problems
- == void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
*/
-void
+static void
try(f0, f1, f2, f3, f4, opts)
char *f0;
char *f1;
int nshould;
char erbuf[100];
int err;
- int len;
+ size_t len;
char *type = (opts & REG_EXTENDED) ? "ERE" : "BRE";
- register int i;
+ int i;
char *grump;
char f0copy[1000];
char f2copy[1000];
if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
/* unexpected error or wrong error */
len = regerror(err, &re, erbuf, sizeof(erbuf));
- fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
- line, type, eprint(err), len,
- sizeof(erbuf), erbuf);
+ fprintf(stderr, "%d: %s error %s, %lu/%d `%s'\n",
+ line, type, eprint(err), (unsigned long)len,
+ (int)sizeof(erbuf), erbuf);
status = 1;
} else if (err == 0 && opt('C', f1)) {
/* unexpected success */
if (options('e', f1)®_STARTEND) {
if (strchr(f2, '(') == NULL || strchr(f2, ')') == NULL)
fprintf(stderr, "%d: bad STARTEND syntax\n", line);
- subs[0].rm_so = strchr(f2, '(') - f2 + 1;
- subs[0].rm_eo = strchr(f2, ')') - f2;
+ subs[0].rm_so = (regoff_t)(strchr(f2, '(') - f2 + 1);
+ subs[0].rm_eo = (regoff_t)(strchr(f2, ')') - f2);
}
err = regexec(&re, f2copy, NSUBS, subs, options('e', f1));
if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
/* unexpected error or wrong error */
len = regerror(err, &re, erbuf, sizeof(erbuf));
- fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
- line, type, eprint(err), len,
- sizeof(erbuf), erbuf);
+ fprintf(stderr, "%d: %s exec error %s, %lu/%d `%s'\n",
+ line, type, eprint(err), (unsigned long)len,
+ (int)sizeof(erbuf), erbuf);
status = 1;
} else if (err != 0) {
/* nothing more to check */
regfree(&re);
}
+/*
+ - parseopts - half-baked option processing to avoid using getopt, which isn't always available on Windows.
+ */
+static int
+parseopts(argc, argv)
+int argc;
+char *argv[];
+{
+ int i, j;
+ for (i = 1; i < argc; i++) {
+ if (argv[i][0] != '-' || argv[i][1] == 0) {
+ break;
+ }
+ for (j = 1; argv[i][j] != 0; j++) {
+ char opt = argv[i][j];
+ if (opt == 'x') {
+ debug++;
+ } else {
+ char *arg;
+ if (argv[i][j+1] != 0) {
+ arg = argv[i] + j+1;
+ } else {
+ if (i == argc-1) {
+ fprintf(stderr, "option requires an argument -- '%c'\n", opt);
+ exit(2);
+ }
+ arg = argv[i+1];
+ i++;
+ }
+ switch (opt) {
+ case 'c':
+ copts = options(opt, arg);
+ break;
+ case 'e':
+ eopts = options(opt, arg);
+ break;
+ case 'f':
+ fopts = arg;
+ break;
+ case 'S':
+ startoff = (regoff_t)atoi(arg);
+ break;
+ case 'E':
+ endoff = (regoff_t)atoi(arg);
+ break;
+ default:
+ fprintf(stderr, "usage: %s ", argv[0]);
+ fprintf(stderr, "[-x][-c copt][-e eopt][-f file][-S startoff][-E endoff] [re]\n");
+ exit(2);
+ }
+ break;
+ }
+ }
+ }
+ return i;
+}
+
/*
- options - pick options out of a regression-test string
- == int options(int type, char *s);
*/
-int
+static int
options(type, s)
int type; /* 'c' compile, 'e' exec */
char *s;
{
- register char *p;
- register int o = (type == 'c') ? copts : eopts;
- register char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
+ char *p;
+ int o = (type == 'c') ? copts : eopts;
+ char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
for (p = s; *p != '\0'; p++)
if (strchr(legal, *p) != NULL)
/*
- opt - is a particular option in a regression string?
- == int opt(int c, char *s);
*/
-int /* predicate */
+static int /* predicate */
opt(c, s)
int c;
char *s;
/*
- fixstr - transform magic characters in strings
- == void fixstr(register char *p);
*/
-void
+static void
fixstr(p)
-register char *p;
+char *p;
{
if (p == NULL)
return;
/*
- check - check a substring match
- == char *check(char *str, regmatch_t sub, char *should);
*/
-char * /* NULL or complaint */
+static char * /* NULL or complaint */
check(str, sub, should)
char *str;
regmatch_t sub;
char *should;
{
- register int len;
- register int shlen;
- register char *p;
+ int len;
+ size_t shlen;
+ char *p;
static char grump[500];
- register char *at = NULL;
+ char *at = NULL;
if (should != NULL && strcmp(should, "-") == 0)
should = NULL;
return("did not match");
/* check for in range */
- if (sub.rm_eo > strlen(str)) {
+ if ((size_t) sub.rm_eo > strlen(str)) {
sprintf(grump, "start %ld end %ld, past end of string",
(long)sub.rm_so, (long)sub.rm_eo);
return(grump);
}
len = (int)(sub.rm_eo - sub.rm_so);
- shlen = (int)strlen(should);
p = str + sub.rm_so;
/* check for not supposed to match */
return(grump);
}
+ shlen = strlen(should);
/* check for wrong match */
- if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
+ if ((size_t)len != shlen || strncmp(p, should, shlen) != 0) {
sprintf(grump, "matched `%.*s' instead", len, p);
return(grump);
}
/*
- eprint - convert error number to name
- == static char *eprint(int err);
*/
static char *
eprint(err)
/*
- efind - convert error name to number
- == static int efind(char *name);
*/
static int
efind(name)
char *name;
{
static char efbuf[100];
- size_t n;
regex_t re;
sprintf(efbuf, "REG_%s", name);
+#include <assert.h>
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <stdlib.h>
-#include <regex.h>
-#include "utils.h"
+#include "regex.h"
#include "regex2.h"
-#include "cclass.h"
-#include "cname.h"
+#ifdef _POSIX2_RE_DUP_MAX
+#define DUPMAX _POSIX2_RE_DUP_MAX
+#else
+#define DUPMAX 255
+#endif
+#define INFINITY (DUPMAX + 1)
/*
* parse structure, passed up and down to avoid global variables and
sopno pend[NPAREN]; /* -> ) ([0] unused) */
};
-#include "regcomp.ih"
-
static char nuls[10]; /* place to point scanner in event of error */
+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 void 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 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, sop opnd);
+static void doinsert(struct parse *p, sop op, sopno 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 sopno pluscount(struct parse *p, struct re_guts *g);
+
/*
* macros for use with parse structure
* BEWARE: these know that the parse structure is named `p' !!!
#define NEXT2() (p->next += 2)
#define NEXTn(n) (p->next += (n))
#define GETNEXT() (*p->next++)
-#define SETERROR(e) seterr(p, (e))
-#define REQUIRE(co, e) ((co) || SETERROR(e))
-#define MUSTSEE(c, e) (REQUIRE(MORE() && PEEK() == (c), e))
+#define REQUIRE(co, e) ((co) ? (void) 0 : seterr(p, (e)))
#define MUSTEAT(c, e) (REQUIRE(MORE() && GETNEXT() == (c), e))
-#define MUSTNOTSEE(c, e) (REQUIRE(!MORE() || PEEK() != (c), e))
-#define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd))
+#define EMIT(op, sopnd) doemit(p, (sop)(op), (sop)(sopnd))
#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(pos)+1, pos)
#define AHEAD(pos) dofwd(p, pos, HERE()-(pos))
#define ASTERN(sop, pos) EMIT(sop, HERE()-pos)
#define never 0 /* some <assert.h>s have bugs too */
#endif
-/*
- - regcomp - interface for parser and compilation
- = extern int regcomp(regex_t *, const char *, int);
- = #define REG_BASIC 0000
- = #define REG_EXTENDED 0001
- = #define REG_ICASE 0002
- = #define REG_NOSUB 0004
- = #define REG_NEWLINE 0010
- = #define REG_NOSPEC 0020
- = #define REG_PEND 0040
- = #define REG_DUMP 0200
- */
int /* 0 success, otherwise REG_something */
regcomp(preg, pattern, cflags)
regex_t *preg;
int cflags;
{
struct parse pa;
- register struct re_guts *g;
- register struct parse *p = &pa;
- register int i;
- register size_t len;
-#ifdef REDEBUG
-# define GOODFLAGS(f) (f)
-#else
-# define GOODFLAGS(f) ((f)&~REG_DUMP)
-#endif
+ struct re_guts *g;
+ struct parse *p = &pa;
+ int i;
+ size_t len;
- cflags = GOODFLAGS(cflags);
if ((cflags®_EXTENDED) && (cflags®_NOSPEC))
return(REG_INVARG);
if (cflags®_PEND) {
if (preg->re_endp < pattern)
return(REG_INVARG);
- len = preg->re_endp - pattern;
+ len = (size_t) (preg->re_endp - pattern);
} else
len = strlen((char *)pattern);
(NC-1)*sizeof(cat_t));
if (g == NULL)
return(REG_ESPACE);
- p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */
- p->strip = (sop *)malloc(p->ssize * sizeof(sop));
+ {
+ /* Patched for CERT Vulnerability Note VU#695940, Feb 2015. */
+ size_t new_ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */
+ if (new_ssize < len || new_ssize > LONG_MAX / sizeof(sop)) {
+ free((char *) g);
+ return REG_INVARG;
+ }
+ p->ssize = (sopno)new_ssize;
+ }
+ p->strip = (sop *)malloc((size_t)p->ssize * sizeof(sop));
p->slen = 0;
if (p->strip == NULL) {
free((char *)g);
#ifndef REDEBUG
/* not debugging, so can't rely on the assert() in regexec() */
if (g->iflags&BAD)
- SETERROR(REG_ASSERT);
+ seterr(p, REG_ASSERT);
#endif
/* win or lose, we're done */
/*
- p_ere - ERE parser top level, concatenation and alternation
- == static void p_ere(register struct parse *p, int stop);
*/
static void
p_ere(p, stop)
-register struct parse *p;
+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 */
/*
- p_ere_exp - parse one subERE, an atom possibly followed by a repetition op
- == static void p_ere_exp(register struct parse *p);
*/
static void
p_ere_exp(p)
-register struct parse *p;
+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 */
case '(':
REQUIRE(MORE(), REG_EPAREN);
p->g->nsub++;
- subno = p->g->nsub;
+ subno = (sopno)p->g->nsub;
if (subno < NPAREN)
p->pbegin[subno] = HERE();
EMIT(OLPAREN, subno);
* all. So an unmatched ) is legal POSIX, at least until
* we can get it fixed.
*/
- SETERROR(REG_EPAREN);
+ seterr(p, REG_EPAREN);
break;
#endif
case '^':
p->g->neol++;
break;
case '|':
- SETERROR(REG_EMPTY);
+ seterr(p, REG_EMPTY);
break;
case '*':
case '+':
case '?':
- SETERROR(REG_BADRPT);
+ seterr(p, REG_BADRPT);
break;
case '.':
if (p->g->cflags®_NEWLINE)
while (MORE() && PEEK() != '}')
NEXT();
REQUIRE(MORE(), REG_EBRACE);
- SETERROR(REG_BADBR);
+ seterr(p, REG_BADBR);
}
break;
}
if (!( c == '*' || c == '+' || c == '?' ||
(c == '{' && MORE2() && isdigit(PEEK2())) ) )
return;
- SETERROR(REG_BADRPT);
+ seterr(p, REG_BADRPT);
}
/*
- p_str - string (no metacharacters) "parser"
- == static void p_str(register struct parse *p);
*/
static void
p_str(p)
-register struct parse *p;
+struct parse *p;
{
REQUIRE(MORE(), REG_EMPTY);
while (MORE())
/*
- p_bre - BRE parser top level, anchoring and concatenation
- == static void p_bre(register struct parse *p, register int end1, \
- == register int end2);
* Giving end1 as OUT essentially eliminates the end1/end2 check.
*
* This implementation is a bit of a kludge, in that a trailing $ is first
*/
static void
p_bre(p, end1, end2)
-register struct parse *p;
-register int end1; /* first terminating character */
-register int end2; /* second terminating character */
+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);
/*
- p_simp_re - parse a simple RE, an atom possibly followed by a repetition
- == 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;
+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 */
p_bracket(p);
break;
case BACKSL|'{':
- SETERROR(REG_BADRPT);
+ seterr(p, REG_BADRPT);
break;
case BACKSL|'(':
p->g->nsub++;
- subno = p->g->nsub;
+ subno = (sopno)p->g->nsub;
if (subno < NPAREN)
p->pbegin[subno] = HERE();
EMIT(OLPAREN, subno);
break;
case BACKSL|')': /* should not get here -- must be user */
case BACKSL|'}':
- SETERROR(REG_EPAREN);
+ seterr(p, REG_EPAREN);
break;
case BACKSL|'1':
case BACKSL|'2':
i = (c&~BACKSL) - '0';
assert(i < NPAREN);
if (p->pend[i] != 0) {
- assert(i <= p->g->nsub);
+ assert((size_t) i <= p->g->nsub);
EMIT(OBACK_, i);
assert(p->pbegin[i] != 0);
assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
(void) dupl(p, p->pbegin[i]+1, p->pend[i]);
EMIT(O_BACK, i);
} else
- SETERROR(REG_ESUBREG);
+ seterr(p, REG_ESUBREG);
p->g->backrefs = 1;
break;
case '*':
while (MORE() && !SEETWO('\\', '}'))
NEXT();
REQUIRE(MORE(), REG_EBRACE);
- SETERROR(REG_BADBR);
+ seterr(p, REG_BADBR);
}
} else if (c == (unsigned char)'$') /* $ (but not \$) ends it */
return(1);
/*
- p_count - parse a repetition count
- == static int p_count(register struct parse *p);
*/
static int /* the value */
p_count(p)
-register struct parse *p;
+struct parse *p;
{
- register int count = 0;
- register int ndigits = 0;
+ int count = 0;
+ int ndigits = 0;
while (MORE() && isdigit(PEEK()) && count <= DUPMAX) {
count = count*10 + (GETNEXT() - '0');
/*
- p_bracket - parse a bracketed character list
- == static void p_bracket(register struct parse *p);
*
- * Note a significant property of this code: if the allocset() did SETERROR,
+ * Note a significant property of this code: if the allocset() did seterr,
* no set operations are done.
*/
static void
p_bracket(p)
-register struct parse *p;
+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) {
return;
if (p->g->cflags®_ICASE) {
- register int i;
- register int ci;
+ int i;
+ int ci;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i) && isalpha(i)) {
if (ci != i)
CHadd(cs, ci);
}
+ assert(cs->multis == NULL); /* xxx */
+#if 0
if (cs->multis != NULL)
mccase(p, cs);
+#endif
}
if (invert) {
- register int i;
+ int i;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i))
CHadd(cs, i);
if (p->g->cflags®_NEWLINE)
CHsub(cs, '\n');
+ assert(cs->multis == NULL); /* xxx */
+#if 0
if (cs->multis != NULL)
mcinvert(p, cs);
+#endif
}
assert(cs->multis == NULL); /* xxx */
/*
- p_b_term - parse one term of a bracketed character list
- == 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;
+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') {
c = (MORE2()) ? PEEK2() : '\0';
break;
case '-':
- SETERROR(REG_ERANGE);
+ seterr(p, REG_ERANGE);
return; /* NOTE RETURN */
break;
default:
}
}
+/* Character-class table. */
+static struct cclass {
+ char *name;
+ char *chars;
+ char *multis;
+} cclasses[] = {
+ {"alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", ""},
+ {"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ""},
+ {"blank", " \t", ""},
+ {"cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177", ""},
+ {"digit", "0123456789", ""},
+ {"graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", ""},
+ {"lower", "abcdefghijklmnopqrstuvwxyz", ""},
+ {"print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ", ""},
+ {"punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", ""},
+ {"space", "\t\n\v\f\r ", ""},
+ {"upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", ""},
+ {"xdigit", "0123456789ABCDEFabcdef", ""},
+ {NULL, 0, ""}
+};
+
/*
- p_b_cclass - parse a character-class name and deal with it
- == 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;
+struct parse *p;
+cset *cs;
{
- register char *sp = p->next;
- register struct cclass *cp;
- register size_t len;
- register char *u;
- register char c;
+ char *sp = p->next;
+ struct cclass *cp;
+ size_t len;
+ char *u;
+ char c;
while (MORE() && isalpha(PEEK()))
NEXT();
- len = p->next - sp;
+ len = (size_t)(p->next - sp);
for (cp = cclasses; cp->name != NULL; cp++)
if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
break;
if (cp->name == NULL) {
/* oops, didn't find it */
- SETERROR(REG_ECTYPE);
+ seterr(p, REG_ECTYPE);
return;
}
/*
- p_b_eclass - parse an equivalence-class name and deal with it
- == static void p_b_eclass(register struct parse *p, register cset *cs);
*
* This implementation is incomplete. xxx
*/
static void
p_b_eclass(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
{
- register char c;
+ char c;
c = p_b_coll_elem(p, '=');
CHadd(cs, c);
/*
- p_b_symbol - parse a character or [..]ed multicharacter collating symbol
- == static char p_b_symbol(register struct parse *p);
*/
static char /* value of symbol */
p_b_symbol(p)
-register struct parse *p;
+struct parse *p;
{
- register char value;
+ char value;
REQUIRE(MORE(), REG_EBRACK);
if (!EATTWO('[', '.'))
return(value);
}
+/* character-name table */
+static struct cname {
+ char *name;
+ char code;
+} cnames[] = {
+ {"NUL", '\0'},
+ {"SOH", '\001'},
+ {"STX", '\002'},
+ {"ETX", '\003'},
+ {"EOT", '\004'},
+ {"ENQ", '\005'},
+ {"ACK", '\006'},
+ {"BEL", '\007'},
+ {"alert", '\007'},
+ {"BS", '\010'},
+ {"backspace", '\b'},
+ {"HT", '\011'},
+ {"tab", '\t'},
+ {"LF", '\012'},
+ {"newline", '\n'},
+ {"VT", '\013'},
+ {"vertical-tab", '\v'},
+ {"FF", '\014'},
+ {"form-feed", '\f'},
+ {"CR", '\015'},
+ {"carriage-return", '\r'},
+ {"SO", '\016'},
+ {"SI", '\017'},
+ {"DLE", '\020'},
+ {"DC1", '\021'},
+ {"DC2", '\022'},
+ {"DC3", '\023'},
+ {"DC4", '\024'},
+ {"NAK", '\025'},
+ {"SYN", '\026'},
+ {"ETB", '\027'},
+ {"CAN", '\030'},
+ {"EM", '\031'},
+ {"SUB", '\032'},
+ {"ESC", '\033'},
+ {"IS4", '\034'},
+ {"FS", '\034'},
+ {"IS3", '\035'},
+ {"GS", '\035'},
+ {"IS2", '\036'},
+ {"RS", '\036'},
+ {"IS1", '\037'},
+ {"US", '\037'},
+ {"space", ' '},
+ {"exclamation-mark", '!'},
+ {"quotation-mark", '"'},
+ {"number-sign", '#'},
+ {"dollar-sign", '$'},
+ {"percent-sign", '%'},
+ {"ampersand", '&'},
+ {"apostrophe", '\''},
+ {"left-parenthesis", '('},
+ {"right-parenthesis", ')'},
+ {"asterisk", '*'},
+ {"plus-sign", '+'},
+ {"comma", ','},
+ {"hyphen", '-'},
+ {"hyphen-minus", '-'},
+ {"period", '.'},
+ {"full-stop", '.'},
+ {"slash", '/'},
+ {"solidus", '/'},
+ {"zero", '0'},
+ {"one", '1'},
+ {"two", '2'},
+ {"three", '3'},
+ {"four", '4'},
+ {"five", '5'},
+ {"six", '6'},
+ {"seven", '7'},
+ {"eight", '8'},
+ {"nine", '9'},
+ {"colon", ':'},
+ {"semicolon", ';'},
+ {"less-than-sign", '<'},
+ {"equals-sign", '='},
+ {"greater-than-sign", '>'},
+ {"question-mark", '?'},
+ {"commercial-at", '@'},
+ {"left-square-bracket", '['},
+ {"backslash", '\\'},
+ {"reverse-solidus", '\\'},
+ {"right-square-bracket", ']'},
+ {"circumflex", '^'},
+ {"circumflex-accent", '^'},
+ {"underscore", '_'},
+ {"low-line", '_'},
+ {"grave-accent", '`'},
+ {"left-brace", '{'},
+ {"left-curly-bracket", '{'},
+ {"vertical-line", '|'},
+ {"right-brace", '}'},
+ {"right-curly-bracket", '}'},
+ {"tilde", '~'},
+ {"DEL", '\177'},
+ {NULL, 0},
+};
+
/*
- p_b_coll_elem - parse a collating-element name and look it up
- == 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;
+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;
+ size_t len;
while (MORE() && !SEETWO(endc, ']'))
NEXT();
if (!MORE()) {
- SETERROR(REG_EBRACK);
+ seterr(p, REG_EBRACK);
return(0);
}
- len = p->next - sp;
+ len = (size_t)(p->next - sp);
for (cp = cnames; cp->name != NULL; cp++)
if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
return(cp->code); /* known name */
if (len == 1)
return(*sp); /* single character */
- SETERROR(REG_ECOLLATE); /* neither */
+ seterr(p, REG_ECOLLATE); /* neither */
return(0);
}
/*
- othercase - return the case counterpart of an alphabetic
- == static char othercase(int ch);
*/
static char /* if no counterpart, return ch */
othercase(ch)
{
assert(isalpha(ch));
if (isupper(ch))
- return(tolower(ch));
+ return((char)tolower(ch));
else if (islower(ch))
- return(toupper(ch));
+ return((char)toupper(ch));
else /* peculiar, but could happen */
- return(ch);
+ return((char)ch);
}
/*
- bothcases - emit a dualcase version of a two-case character
- == static void bothcases(register struct parse *p, int ch);
*
* Boy, is this implementation ever a kludge...
*/
static void
bothcases(p, ch)
-register struct parse *p;
+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];
assert(othercase(ch) != ch); /* p_bracket() would recurse */
p->next = bracket;
p->end = bracket+2;
- bracket[0] = ch;
+ bracket[0] = (char)ch;
bracket[1] = ']';
bracket[2] = '\0';
p_bracket(p);
/*
- ordinary - emit an ordinary character
- == static void ordinary(register struct parse *p, register int ch);
*/
static void
ordinary(p, ch)
-register struct parse *p;
-register int ch;
+struct parse *p;
+int ch;
{
- register cat_t *cap = p->g->categories;
+ cat_t *cap = p->g->categories;
if ((p->g->cflags®_ICASE) && isalpha(ch) && othercase(ch) != ch)
bothcases(p, ch);
else {
- EMIT(OCHAR, (unsigned char)ch);
+ EMIT(OCHAR, (sopno)ch);
if (cap[ch] == 0)
- cap[ch] = p->g->ncategories++;
+ cap[ch] = (cat_t)(p->g->ncategories++);
}
}
/*
- nonnewline - emit REG_NEWLINE version of OANY
- == static void nonnewline(register struct parse *p);
*
* Boy, is this implementation ever a kludge...
*/
static void
nonnewline(p)
-register struct parse *p;
+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;
/*
- repeat - generate code for a bounded repetition, recursively if needed
- == static void repeat(register struct parse *p, sopno start, int from, int to);
*/
static void
repeat(p, start, from, to)
-register struct parse *p;
+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;
repeat(p, copy, from-1, to);
break;
default: /* "can't happen" */
- SETERROR(REG_ASSERT); /* just in case */
+ seterr(p, REG_ASSERT); /* just in case */
break;
}
}
/*
- seterr - set an error condition
- == static int seterr(register struct parse *p, int e);
*/
-static int /* useless but makes type checking happy */
+static void
seterr(p, e)
-register struct parse *p;
+struct parse *p;
int e;
{
if (p->error == 0) /* keep earliest error condition */
p->error = e;
p->next = nuls; /* try to bring things to a halt */
p->end = nuls;
- return(0); /* make the return value well-defined */
}
/*
- allocset - allocate a set of characters for []
- == static cset *allocset(register struct parse *p);
*/
static cset *
allocset(p)
-register struct parse *p;
+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++;
+ int nc;
+ int nbytes;
+ cset *cs;
+ int css = p->g->csetsize;
+ int i;
if (no >= p->ncsalloc) { /* need another column of space */
p->ncsalloc += CHAR_BIT;
assert(nc % CHAR_BIT == 0);
nbytes = nc / CHAR_BIT * css;
if (p->g->sets == NULL)
- p->g->sets = (cset *)malloc(nc * sizeof(cset));
+ p->g->sets = (cset *)malloc((size_t)nc * sizeof(cset));
else
p->g->sets = (cset *)realloc((char *)p->g->sets,
- nc * sizeof(cset));
+ (size_t)nc * sizeof(cset));
if (p->g->setbits == NULL)
- p->g->setbits = (uch *)malloc(nbytes);
+ p->g->setbits = (uch *)malloc((size_t)nbytes);
else {
p->g->setbits = (uch *)realloc((char *)p->g->setbits,
- nbytes);
+ (size_t)nbytes);
/* xxx this isn't right if setbits is now NULL */
for (i = 0; i < no; i++)
p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
}
if (p->g->sets != NULL && p->g->setbits != NULL)
(void) memset((char *)p->g->setbits + (nbytes - css),
- 0, css);
+ 0, (size_t)css);
else {
no = 0;
- SETERROR(REG_ESPACE);
+ seterr(p, REG_ESPACE);
/* caller's responsibility not to do set ops */
}
}
assert(p->g->sets != NULL); /* xxx */
cs = &p->g->sets[no];
cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);
- cs->mask = 1 << ((no) % CHAR_BIT);
+ cs->mask = (uch) (1 << ((no) % CHAR_BIT));
cs->hash = 0;
cs->smultis = 0;
cs->multis = NULL;
/*
- freeset - free a now-unused set
- == static void freeset(register struct parse *p, register cset *cs);
*/
static void
freeset(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
{
- register size_t i;
- register cset *top = &p->g->sets[p->g->ncsets];
- register size_t css = (size_t)p->g->csetsize;
+ size_t 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);
/*
- freezeset - final processing on a set of characters
- == static int freezeset(register struct parse *p, register cset *cs);
*
* The main task here is merging identical sets. This is usually a waste
* of time (although the hash code minimizes the overhead), but can win
*/
static int /* set number */
freezeset(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
{
- register uch h = cs->hash;
- register size_t i;
- register cset *top = &p->g->sets[p->g->ncsets];
- register cset *cs2;
- register size_t css = (size_t)p->g->csetsize;
+ uch h = cs->hash;
+ size_t 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++)
/*
- firstch - return first character in a set (which must have at least one)
- == 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;
+struct parse *p;
+cset *cs;
{
- register size_t i;
- register size_t css = (size_t)p->g->csetsize;
+ size_t i;
+ size_t css = (size_t)p->g->csetsize;
for (i = 0; i < css; i++)
if (CHIN(cs, i))
/*
- nch - number of characters in a set
- == static int nch(register struct parse *p, register cset *cs);
*/
static int
nch(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
{
- register size_t i;
- register size_t css = (size_t)p->g->csetsize;
- register int n = 0;
+ size_t i;
+ size_t css = (size_t)p->g->csetsize;
+ int n = 0;
for (i = 0; i < css; i++)
if (CHIN(cs, i))
/*
- mcadd - add a collating element to a cset
- == static void mcadd(register struct parse *p, register cset *cs, \
- == register char *cp);
*/
static void
mcadd(p, cs, cp)
-register struct parse *p;
-register cset *cs;
-register char *cp;
+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)
else
cs->multis = realloc(cs->multis, cs->smultis);
if (cs->multis == NULL) {
- SETERROR(REG_ESPACE);
+ seterr(p, REG_ESPACE);
return;
}
cs->multis[cs->smultis - 1] = '\0';
}
+#if 0
/*
- mcsub - subtract a collating element from a cset
- == static void mcsub(register cset *cs, register char *cp);
*/
static void
mcsub(cs, cp)
-register cset *cs;
-register char *cp;
+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,
/*
- mcin - is a collating element in a cset?
- == static int mcin(register cset *cs, register char *cp);
*/
static int
mcin(cs, cp)
-register cset *cs;
-register char *cp;
+cset *cs;
+char *cp;
{
return(mcfind(cs, cp) != NULL);
}
/*
- mcfind - find a collating element in a cset
- == static char *mcfind(register cset *cs, register char *cp);
*/
static char *
mcfind(cs, cp)
-register cset *cs;
-register char *cp;
+cset *cs;
+char *cp;
{
- register char *p;
+ char *p;
if (cs->multis == NULL)
return(NULL);
/*
- mcinvert - invert the list of collating elements in a cset
- == static void mcinvert(register struct parse *p, register cset *cs);
*
* This would have to know the set of possibilities. Implementation
* is deferred.
*/
static void
mcinvert(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
{
assert(cs->multis == NULL); /* xxx */
}
/*
- mccase - add case counterparts of the list of collating elements in a cset
- == static void mccase(register struct parse *p, register cset *cs);
*
* This would have to know the set of possibilities. Implementation
* is deferred.
*/
static void
mccase(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
{
assert(cs->multis == NULL); /* xxx */
}
+#endif
/*
- isinsets - is this character in any sets?
- == static int isinsets(register struct re_guts *g, int c);
*/
static int /* predicate */
isinsets(g, c)
-register struct re_guts *g;
+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 = (unsigned char)c;
+ uch *col;
+ int i;
+ int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+ unsigned uc = (unsigned char)c;
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
if (col[uc] != 0)
/*
- samesets - are these two characters in exactly the same sets?
- == static int samesets(register struct re_guts *g, int c1, int c2);
*/
static int /* predicate */
samesets(g, c1, c2)
-register struct re_guts *g;
+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 = (unsigned char)c1;
- register unsigned uc2 = (unsigned char)c2;
+ uch *col;
+ int i;
+ int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+ unsigned uc1 = (unsigned char)c1;
+ unsigned uc2 = (unsigned char)c2;
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
if (col[uc1] != col[uc2])
/*
- categorize - sort out character categories
- == static void categorize(struct parse *p, register struct re_guts *g);
*/
static void
categorize(p, g)
struct parse *p;
-register struct re_guts *g;
+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)
for (c = CHAR_MIN; c <= CHAR_MAX; c++)
if (cats[c] == 0 && isinsets(g, c)) {
- cat = g->ncategories++;
+ cat = (cat_t)g->ncategories++;
cats[c] = cat;
for (c2 = c+1; c2 <= CHAR_MAX; c2++)
if (cats[c2] == 0 && samesets(g, c, c2))
/*
- dupl - emit a duplicate of a bunch of sops
- == static sopno dupl(register struct parse *p, sopno start, sopno finish);
*/
static sopno /* start of duplicate */
dupl(p, start, finish)
-register struct parse *p;
+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)
return(ret);
enlarge(p, p->ssize + len); /* this many unexpected additions */
assert(p->ssize >= p->slen + len);
- (void) memmove((char *)(p->strip + p->slen),
+ (void) memcpy((char *)(p->strip + p->slen),
(char *)(p->strip + start), (size_t)len*sizeof(sop));
p->slen += len;
return(ret);
/*
- doemit - emit a strip operator
- == static void doemit(register struct parse *p, sop op, size_t opnd);
*
* It might seem better to implement this as a macro with a function as
* hard-case backup, but it's just too big and messy unless there are
*/
static void
doemit(p, op, opnd)
-register struct parse *p;
+struct parse *p;
sop op;
-size_t opnd;
+sop opnd;
{
/* avoid making error situations worse */
if (p->error != 0)
/*
- doinsert - insert a sop into the strip
- == 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;
+struct parse *p;
sop op;
-size_t opnd;
+sopno 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)
}
memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],
- (HERE()-pos-1)*sizeof(sop));
+ (size_t)(HERE()-pos-1)*sizeof(sop));
p->strip[pos] = s;
}
/*
- dofwd - complete a forward reference
- == static void dofwd(register struct parse *p, sopno pos, sop value);
*/
static void
dofwd(p, pos, value)
-register struct parse *p;
-register sopno pos;
+struct parse *p;
+sopno pos;
sop value;
{
/* avoid making error situations worse */
/*
- enlarge - enlarge the strip
- == static void enlarge(register struct parse *p, sopno size);
*/
static void
enlarge(p, size)
-register struct parse *p;
-register sopno size;
+struct parse *p;
+sopno size;
{
- register sop *sp;
+ sop *sp;
if (p->ssize >= size)
return;
- sp = (sop *)realloc(p->strip, size*sizeof(sop));
+ sp = (sop *)realloc(p->strip, (size_t)size*sizeof(sop));
if (sp == NULL) {
- SETERROR(REG_ESPACE);
+ seterr(p, REG_ESPACE);
return;
}
p->strip = sp;
/*
- stripsnug - compact the strip
- == 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;
+struct parse *p;
+struct re_guts *g;
{
g->nstates = p->slen;
- g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
+ g->strip = (sop *)realloc((char *)p->strip, (size_t)p->slen * sizeof(sop));
if (g->strip == NULL) {
- SETERROR(REG_ESPACE);
+ seterr(p, REG_ESPACE);
g->strip = p->strip;
}
}
/*
- findmust - fill in must and mlen with longest mandatory literal string
- == static void findmust(register struct parse *p, register struct re_guts *g);
*
* This algorithm could do fancy things like analyzing the operands of |
* for common subsequences. Someday. This code is simple and finds most
static void
findmust(p, g)
struct parse *p;
-register struct re_guts *g;
+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;
+ int newlen;
+ sop s;
+ char *cp;
+ sopno i;
/* avoid making error situations worse */
if (p->error != 0)
/*
- pluscount - count + nesting
- == 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;
+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 */
-#include <sys/types.h>
+#include <stddef.h>
#include <stdio.h>
#include <string.h>
-#include <ctype.h>
-#include <limits.h>
-#include <stdlib.h>
-#include <regex.h>
-#include "utils.h"
-#include "regerror.ih"
+#include "regex.h"
-/*
- = #define REG_OKAY 0
- = #define REG_NOMATCH 1
- = #define REG_BADPAT 2
- = #define REG_ECOLLATE 3
- = #define REG_ECTYPE 4
- = #define REG_EESCAPE 5
- = #define REG_ESUBREG 6
- = #define REG_EBRACK 7
- = #define REG_EPAREN 8
- = #define REG_EBRACE 9
- = #define REG_BADBR 10
- = #define REG_ERANGE 11
- = #define REG_ESPACE 12
- = #define REG_BADRPT 13
- = #define REG_EMPTY 14
- = #define REG_ASSERT 15
- = #define REG_INVARG 16
- = #define REG_ATOI 255 // convert name to number (!)
- = #define REG_ITOA 0400 // convert number to name (!)
- */
static struct rerr {
int code;
char *name;
char *explain;
} rerrs[] = {
- REG_OKAY, "REG_OKAY", "no errors detected",
- REG_NOMATCH, "REG_NOMATCH", "regexec() failed to match",
- REG_BADPAT, "REG_BADPAT", "invalid regular expression",
- REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element",
- REG_ECTYPE, "REG_ECTYPE", "invalid character class",
- REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)",
- REG_ESUBREG, "REG_ESUBREG", "invalid backreference number",
- REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced",
- REG_EPAREN, "REG_EPAREN", "parentheses not balanced",
- REG_EBRACE, "REG_EBRACE", "braces not balanced",
- REG_BADBR, "REG_BADBR", "invalid repetition count(s)",
- REG_ERANGE, "REG_ERANGE", "invalid character range",
- REG_ESPACE, "REG_ESPACE", "out of memory",
- REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid",
- REG_EMPTY, "REG_EMPTY", "empty (sub)expression",
- REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug",
- REG_INVARG, "REG_INVARG", "invalid argument to regex routine",
- -1, "", "*** unknown regexp error code ***",
+ {REG_OKAY, "REG_OKAY", "no errors detected"},
+ {REG_NOMATCH, "REG_NOMATCH", "regexec() failed to match"},
+ {REG_BADPAT, "REG_BADPAT", "invalid regular expression"},
+ {REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element"},
+ {REG_ECTYPE, "REG_ECTYPE", "invalid character class"},
+ {REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)"},
+ {REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"},
+ {REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced"},
+ {REG_EPAREN, "REG_EPAREN", "parentheses not balanced"},
+ {REG_EBRACE, "REG_EBRACE", "braces not balanced"},
+ {REG_BADBR, "REG_BADBR", "invalid repetition count(s)"},
+ {REG_ERANGE, "REG_ERANGE", "invalid character range"},
+ {REG_ESPACE, "REG_ESPACE", "out of memory"},
+ {REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid"},
+ {REG_EMPTY, "REG_EMPTY", "empty (sub)expression"},
+ {REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug"},
+ {REG_INVARG, "REG_INVARG", "invalid argument to regex routine"},
+ {-1, "", "*** unknown regexp error code ***"},
};
+static size_t
+set_result(char *errbuf, size_t errbuf_size, char *result) {
+ size_t result_len = strlen(result);
+ if (errbuf_size > 0) {
+ size_t copy_len = result_len < errbuf_size ? result_len : errbuf_size - 1;
+ memcpy(errbuf, result, copy_len);
+ errbuf[copy_len] = 0;
+ }
+ return result_len + 1;
+}
+
/*
- regerror - the interface to error numbers
- = extern size_t regerror(int, const regex_t *, char *, size_t);
*/
-/* ARGSUSED */
size_t
-regerror(
-int errcode,
-const regex_t *preg,
-char *errbuf,
-size_t errbuf_size)
+regerror(int errorcode, 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;
char convbuf[50];
- if (errcode == REG_ATOI)
- s = regatoi(preg, convbuf);
+ if (errorcode == REG_ATOI) {
+ if (preg == NULL || preg->re_endp == NULL)
+ return set_result(errbuf, errbuf_size, "0");
+ for (r = rerrs; r->code >= 0; r++)
+ if (strcmp(r->name, preg->re_endp) == 0)
+ break;
+ if (r->code < 0)
+ return set_result(errbuf, errbuf_size, "0");
+ snprintf(convbuf, sizeof convbuf, "%d", r->code);
+ return set_result(errbuf, errbuf_size, convbuf);
+ }
else {
+ int target = errorcode &~ REG_ITOA;
+
for (r = rerrs; r->code >= 0; r++)
if (r->code == target)
break;
-
- if (errcode®_ITOA) {
+ if (errorcode & REG_ITOA) {
if (r->code >= 0)
- (void) strcpy(convbuf, r->name);
- else
- sprintf(convbuf, "REG_0x%x", target);
- assert(strlen(convbuf) < sizeof(convbuf));
- s = convbuf;
- } else
- s = r->explain;
- }
-
- len = strlen(s) + 1;
- if (errbuf_size > 0) {
- if (errbuf_size > len)
- (void) strcpy(errbuf, s);
- else {
- (void) strncpy(errbuf, s, errbuf_size-1);
- errbuf[errbuf_size-1] = '\0';
+ return set_result(errbuf, errbuf_size, r->name);
+ snprintf(convbuf, sizeof convbuf, "REG_0x%x", target);
+ return set_result(errbuf, errbuf_size, convbuf);
}
+ return set_result(errbuf, errbuf_size, r->explain);
}
-
- return(len);
-}
-
-/*
- - regatoi - internal routine to implement REG_ATOI
- == static char *regatoi(const regex_t *preg, char *localbuf);
- */
-static char *
-regatoi(preg, localbuf)
-const regex_t *preg;
-char *localbuf;
-{
- register struct rerr *r;
-
- for (r = rerrs; r->code >= 0; r++)
- if (strcmp(r->name, preg->re_endp) == 0)
- break;
- if (r->code < 0)
- return("0");
-
- sprintf(localbuf, "%d", r->code);
- return(localbuf);
}
#ifndef _REGEX_H_
-#define _REGEX_H_ /* never again */
-/* ========= begin header generated by ./mkh ========= */
+#define _REGEX_H_
+
#ifdef __cplusplus
extern "C" {
#endif
-/* === regex2.h === */
-typedef long regoff_t;
+#include <sys/types.h>
+
+typedef off_t regoff_t;
+
typedef struct {
int re_magic;
size_t re_nsub; /* number of parenthesized subexpressions */
const char *re_endp; /* end pointer for REG_PEND */
struct re_guts *re_g; /* none of your business :-) */
} regex_t;
+
typedef struct {
regoff_t rm_so; /* start of match */
regoff_t rm_eo; /* end of match */
} regmatch_t;
-
-/* === regcomp.c === */
extern int regcomp(regex_t *, const char *, int);
+extern size_t regerror(int, const regex_t *, char *, size_t);
+extern int regexec(const regex_t *, const char *, size_t, regmatch_t [], int);
+extern void regfree(regex_t *);
+
#define REG_BASIC 0000
#define REG_EXTENDED 0001
#define REG_ICASE 0002
#define REG_NEWLINE 0010
#define REG_NOSPEC 0020
#define REG_PEND 0040
-#define REG_DUMP 0200
-
-
-/* === regerror.c === */
#define REG_OKAY 0
#define REG_NOMATCH 1
#define REG_BADPAT 2
#define REG_INVARG 16
#define REG_ATOI 255 /* convert name to number (!) */
#define REG_ITOA 0400 /* convert number to name (!) */
-extern size_t regerror(int, const regex_t *, char *, size_t);
-
-
-/* === regexec.c === */
-extern int regexec(const regex_t *, const char *, size_t, regmatch_t [], int);
#define REG_NOTBOL 00001
#define REG_NOTEOL 00002
#define REG_STARTEND 00004
#define REG_LARGE 01000 /* force large representation */
#define REG_BACKR 02000 /* force use of backref code */
-
-/* === regfree.c === */
-extern void regfree(regex_t *);
-
#ifdef __cplusplus
}
#endif
-/* ========= end header generated by ./mkh ========= */
#endif
-/*
- * First, the stuff that ends up in the outside-world include file
- = typedef off_t regoff_t;
- = typedef struct {
- = int re_magic;
- = size_t re_nsub; // number of parenthesized subexpressions
- = const char *re_endp; // end pointer for REG_PEND
- = struct re_guts *re_g; // none of your business :-)
- = } regex_t;
- = typedef struct {
- = regoff_t rm_so; // start of match
- = regoff_t rm_eo; // end of match
- = } regmatch_t;
- */
/*
* internals of regex_t
*/
*/
typedef long sop; /* strip operator */
typedef long sopno;
+typedef unsigned char uch;
+
#define OPRMASK 0x7c000000
#define OPDMASK 0x03ffffff
#define OPSHIFT (26)
#define OP(n) ((n)&OPRMASK)
#define OPND(n) ((n)&OPDMASK)
#define SOP(op, opnd) ((op)|(opnd))
+
/* operators meaning operand */
/* (back, fwd are offsets) */
#define OEND (1<<OPSHIFT) /* endmarker - */
size_t smultis;
char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */
} cset;
+
/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
-#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
-#define CHsub(cs, c) ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
+#define CHadd(cs, c) ((cs)->ptr[(int)(c)] |= (cs)->mask, (cs)->hash = (uch)((cs)->hash + (c)))
+#define CHsub(cs, c) ((cs)->ptr[(int)(c)] &= (uch)~(cs)->mask, (cs)->hash = (uch)((cs)->hash - (c)))
#define CHIN(cs, c) ((cs)->ptr[(uch)(c)] & (cs)->mask)
#define MCadd(p, cs, cp) mcadd(p, cs, cp) /* regcomp() internal fns */
#define MCsub(p, cs, cp) mcsub(p, cs, cp)
#define MCin(p, cs, cp) mcin(p, cs, cp)
+#define NC (CHAR_MAX - CHAR_MIN + 1)
/* stuff for character categories */
typedef unsigned char cat_t;
/* misc utilities */
#define OUT (CHAR_MAX+1) /* a non-character value */
#define ISWORD(c) (isalnum(c) || (c) == '_')
+
+/* switch off assertions (if not already off) if no REDEBUG */
+#ifndef REDEBUG
+#ifndef NDEBUG
+#define NDEBUG /* no assertions please */
+#endif
+#endif
* macros that code uses. This lets the same code operate on two different
* representations for state sets.
*/
+#include <assert.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>
-#include <regex.h>
-#include "utils.h"
+#include "regex.h"
#include "regex2.h"
static int nope = 0; /* for use in asserts; shuts lint up */
/* macros for manipulating states, large version */
#define states char *
-#define CLEAR(v) memset(v, 0, m->g->nstates)
+#define CLEAR(v) memset(v, 0, (size_t)m->g->nstates)
#define SET0(v, n) ((v)[n] = 0)
#define SET1(v, n) ((v)[n] = 1)
#define ISSET(v, n) ((v)[n])
-#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)
-#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)
+#define ASSIGN(d, s) memcpy(d, s, (size_t)m->g->nstates)
+#define EQ(a, b) (memcmp(a, b, (size_t)m->g->nstates) == 0)
#define STATEVARS int vn; char *space
-#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \
+#define STATESETUP(m, nv) { (m)->space = malloc((size_t)((nv)*(m)->g->nstates)); \
if ((m)->space == NULL) return(REG_ESPACE); \
(m)->vn = 0; }
#define STATETEARDOWN(m) { free((m)->space); }
#define SETUP(v) ((v) = &m->space[m->vn++ * m->g->nstates])
#define onestate int
-#define INIT(o, n) ((o) = (n))
+#define INIT(o, n) ((o) = (int)(n))
#define INC(o) ((o)++)
#define ISSTATEIN(v, o) ((v)[o])
/* some abbreviations; note that some of these know variable names! */
/*
- regexec - interface for matching
- = extern int regexec(const regex_t *, const char *, size_t, \
- = regmatch_t [], int);
- = #define REG_NOTBOL 00001
- = #define REG_NOTEOL 00002
- = #define REG_STARTEND 00004
- = #define REG_TRACE 00400 // tracing of execution
- = #define REG_LARGE 01000 // force large representation
- = #define REG_BACKR 02000 // force use of backref code
*
* We put this here so we can exploit knowledge of the state representation
* when choosing which matcher to call. Also, by this point the matchers
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
return(REG_BADPAT);
eflags = GOODFLAGS(eflags);
- if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
+ if ((size_t) g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
else
return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
-#include <regex.h>
-#include "utils.h"
+#include "regex.h"
#include "regex2.h"
/*
- regfree - free everything
- = extern void regfree(regex_t *);
*/
void
regfree(preg)
regex_t *preg;
{
- register struct re_guts *g;
+ struct re_guts *g;
if (preg->re_magic != MAGIC1) /* oops */
return; /* nice to complain, but hard */
.BY "Henry Spencer"
.de ZR
.\" one other place knows this name: the SEE ALSO section
-.IR regex (7) \\$1
+.IR rxspencer (7) \\$1
..
.SH NAME
regcomp, regexec, regerror, regfree \- regular-expression library
`^' and `$' beginning and ending subexpressions in obsolete (``basic'')
REs are anchors, not ordinary characters.
.SH SEE ALSO
-grep(1), regex(7)
+grep(1), rxspencer(7)
.PP
POSIX 1003.2, sections 2.8 (Regular Expression Notation)
and
left to right),
so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
.SH SEE ALSO
-regex(3)
+rxspencer(3)
.PP
POSIX 1003.2, section 2.8 (Regular Expression Notation).
.SH HISTORY
int nfields; /* number of entries available in fields[] */
char *sep; /* "" white, "c" single char, "ab" [ab]+ */
{
- register char *p = string;
- register char c; /* latest character */
- register char sepc = sep[0];
- register char sepc2;
- register int fn;
- register char **fp = fields;
- register char *sepp;
- register int trimtrail;
+ char *p = string;
+ char c; /* latest character */
+ char sepc = sep[0];
+ char sepc2;
+ int fn;
+ char **fp = fields;
+ char *sepp;
+ int trimtrail;
/* white space */
if (sepc == '\0') {
char *argv[];
{
char buf[512];
- register int n;
+ int n;
# define MNF 10
char *fields[MNF];
exit(0);
}
+static void
dosplit(string, seps)
char *string;
char *seps;
{
# define NF 5
char *fields[NF];
- register int nf;
+ int nf;
nf = split(string, fields, NF, seps);
print(nf, NF, fields);
}
+static void
print(nf, nfp, fields)
int nf;
int nfp;
char *fields[];
{
- register int fn;
- register int bound;
+ int fn;
+ int bound;
bound = (nf > nfp) ? nfp : nf;
printf("%d:\t", nf);
NULL, NULL, 0, { NULL },
};
+static void
regress()
{
char buf[512];
- register int n;
+ int n;
char *fields[RNF+1];
- register int nf;
- register int i;
- register int printit;
- register char *f;
+ int nf;
+ int i;
+ int printit;
+ char *f;
for (n = 0; tests[n].str != NULL; n++) {
(void) strcpy(buf, tests[n].str);
projects / thirdparty / cups.git / commitdiff
