Initial import of the CDE 2.1.30 sources from the Open Group.

cde/programs/dtdocbook/lib/tptregexp/Imakefile

@@ -0,0 +1,17 @@
+XCOMM $XConsortium: Imakefile /main/2 1996/04/21 19:55:57 drk $
+#define DoNormalLib	YES
+#define DoSharedLib	NO
+#define DoDebugLib	NO
+#define DoProfileLib	NO
+#define LibName		tptregexp
+#define LibHeaders	NO
+#define LibInstall	NO
+
+SRCS = regexp.c regsub.c regerror.c
+OBJS = regexp.o regsub.o regerror.o
+
+INCLUDES = -I.
+
+#include <Library.tmpl>
+
+DependTarget()

cde/programs/dtdocbook/lib/tptregexp/README

@@ -0,0 +1,101 @@
+/* $XConsortium: README /main/2 1996/07/15 14:09:54 drk $ */
+#
+# Copyright (c) 1994  
+# Open Software Foundation, Inc. 
+#  
+# Permission is hereby granted to use, copy, modify and freely distribute 
+# the software in this file and its documentation for any purpose without 
+# fee, provided that the above copyright notice appears in all copies and 
+# that both the copyright notice and this permission notice appear in 
+# supporting documentation.  Further, provided that the name of Open 
+# Software Foundation, Inc. ("OSF") not be used in advertising or 
+# publicity pertaining to distribution of the software without prior 
+# written permission from OSF.  OSF makes no representations about the 
+# suitability of this software for any purpose.  It is provided "as is" 
+# without express or implied warranty. 
+#
+
+This is a nearly-public-domain reimplementation of the V8 regexp(3) package.
+It gives C programs the ability to use egrep-style regular expressions, and
+does it in a much cleaner fashion than the analogous routines in SysV.
+
+	Copyright (c) 1986 by University of Toronto.
+	Written by Henry Spencer.  Not derived from licensed software.
+
+	Permission is granted to anyone to use this software for any
+	purpose on any computer system, and to redistribute it freely,
+	subject to the following restrictions:
+
+	1. The author is not responsible for the consequences of use of
+		this software, no matter how awful, even if they arise
+		from defects in it.
+
+	2. The origin of this software must not be misrepresented, either
+		by explicit claim or by omission.
+
+	3. Altered versions must be plainly marked as such, and must not
+		be misrepresented as being the original software.
+
+Barring a couple of small items in the BUGS list, this implementation is
+believed 100% compatible with V8.  It should even be binary-compatible,
+sort of, since the only fields in a "struct regexp" that other people have
+any business touching are declared in exactly the same way at the same
+location in the struct (the beginning).
+
+This implementation is *NOT* AT&T/Bell code, and is not derived from licensed
+software.  Even though U of T is a V8 licensee.  This software is based on
+a V8 manual page sent to me by Dennis Ritchie (the manual page enclosed
+here is a complete rewrite and hence is not covered by AT&T copyright).
+The software was nearly complete at the time of arrival of our V8 tape.
+I haven't even looked at V8 yet, although a friend elsewhere at U of T has
+been kind enough to run a few test programs using the V8 regexp(3) to resolve
+a few fine points.  I admit to some familiarity with regular-expression
+implementations of the past, but the only one that this code traces any
+ancestry to is the one published in Kernighan & Plauger (from which this
+one draws ideas but not code).
+
+Simplistically:  put this stuff into a source directory, copy regexp.h into
+/usr/include, inspect Makefile for compilation options that need changing
+to suit your local environment, and then do "make r".  This compiles the
+regexp(3) functions, compiles a test program, and runs a large set of
+regression tests.  If there are no complaints, then put regexp.o, regsub.o,
+and regerror.o into your C library, and regexp.3 into your manual-pages
+directory.
+
+Note that if you don't put regexp.h into /usr/include *before* compiling,
+you'll have to add "-I." to CFLAGS before compiling.
+
+The files are:
+
+Makefile	instructions to make everything
+regexp.3	manual page
+regexp.h	header file, for /usr/include
+regexp.c	source for regcomp() and regexec()
+regsub.c	source for regsub()
+regerror.c	source for default regerror()
+regmagic.h	internal header file
+try.c		source for test program
+timer.c		source for timing program
+tests		test list for try and timer
+
+This implementation uses nondeterministic automata rather than the
+deterministic ones found in some other implementations, which makes it
+simpler, smaller, and faster at compiling regular expressions, but slower
+at executing them.  In theory, anyway.  This implementation does employ
+some special-case optimizations to make the simpler cases (which do make
+up the bulk of regular expressions actually used) run quickly.  In general,
+if you want blazing speed you're in the wrong place.  Replacing the insides
+of egrep with this stuff is probably a mistake; if you want your own egrep
+you're going to have to do a lot more work.  But if you want to use regular
+expressions a little bit in something else, you're in luck.  Note that many
+existing text editors use nondeterministic regular-expression implementations,
+so you're in good company.
+
+This stuff should be pretty portable, given appropriate option settings.
+If your chars have less than 8 bits, you're going to have to change the
+internal representation of the automaton, although knowledge of the details
+of this is fairly localized.  There are no "reserved" char values except for
+NUL, and no special significance is attached to the top bit of chars.
+The string(3) functions are used a fair bit, on the grounds that they are
+probably faster than coding the operations in line.  Some attempts at code
+tuning have been made, but this is invariably a bit machine-specific.

cde/programs/dtdocbook/lib/tptregexp/README.osf

@@ -0,0 +1,37 @@
+/* $XConsortium: README.osf /main/2 1996/07/15 14:10:16 drk $ */
+#
+# Copyright (c) 1994  
+# Open Software Foundation, Inc. 
+#  
+# Permission is hereby granted to use, copy, modify and freely distribute 
+# the software in this file and its documentation for any purpose without 
+# fee, provided that the above copyright notice appears in all copies and 
+# that both the copyright notice and this permission notice appear in 
+# supporting documentation.  Further, provided that the name of Open 
+# Software Foundation, Inc. ("OSF") not be used in advertising or 
+# publicity pertaining to distribution of the software without prior 
+# written permission from OSF.  OSF makes no representations about the 
+# suitability of this software for any purpose.  It is provided "as is" 
+# without express or implied warranty. 
+#
+
+OSF did not write this code.
+
+Changes made:
+
+    Renamed "regexp.h" to "tptregexp.h" to avoid conflicts with systems that
+    have a /usr/include/regexp.h.  Changed the *.c files in the appropriate
+    places.
+
+    Renamed these routines:
+	regcomp()  -> tpt_regcomp()
+	regexec()  -> tpt_regexec()
+	regsub()   -> tpt_regsub()
+	regerror() -> tpt_regerror()
+    This is to avoid conflicts in the standard C library.
+
+    In Makefile - wrote "all" and "install" targets.  Changed "regexp.h"
+    to "tptregexp.h", as appropriate.
+
+    In regexp.c - added #include <string.h> to keep compiler happy.
+

cde/programs/dtdocbook/lib/tptregexp/regerror.c

@@ -0,0 +1,15 @@
+/* $XConsortium: regerror.c /main/3 1996/06/19 17:13:36 drk $ */
+#include <stdio.h>
+
+void
+tpt_regerror(s)
+char *s;
+{
+#ifdef ERRAVAIL
+	error("tpt_regexp: %s", s);
+#else
+	fprintf(stderr, "tpt_regexp(3): %s", s);
+	exit(1);
+#endif
+	/* NOTREACHED */
+}

cde/programs/dtdocbook/lib/tptregexp/regexp.3

@@ -0,0 +1,180 @@
+.\" $XConsortium: regexp.3 /main/2 1996/10/29 15:06:28 drk $
+.TH REGEXP 3 local
+.DA 30 Nov 1985
+.SH NAME
+regcomp, regexec, regsub, regerror \- regular expression handler
+.SH SYNOPSIS
+.ft B
+.nf
+#include <regexp.h>
+
+regexp *regcomp(exp)
+char *exp;
+
+int regexec(prog, string)
+regexp *prog;
+char *string;
+
+regsub(prog, source, dest)
+regexp *prog;
+char *source;
+char *dest;
+
+regerror(msg)
+char *msg;
+.SH DESCRIPTION
+These functions implement
+.IR egrep (1)-style
+regular expressions and supporting facilities.
+.PP
+.I Regcomp
+compiles a regular expression into a structure of type
+.IR regexp ,
+and returns a pointer to it.
+The space has been allocated using
+.IR malloc (3)
+and may be released by
+.IR free .
+.PP
+.I Regexec
+matches a NUL-terminated \fIstring\fR against the compiled regular expression
+in \fIprog\fR.
+It returns 1 for success and 0 for failure, and adjusts the contents of
+\fIprog\fR's \fIstartp\fR and \fIendp\fR (see below) accordingly.
+.PP
+The members of a
+.I regexp
+structure include at least the following (not necessarily in order):
+.PP
+.RS
+char *startp[NSUBEXP];
+.br
+char *endp[NSUBEXP];
+.RE
+.PP
+where
+.I NSUBEXP
+is defined (as 10) in the header file.
+Once a successful \fIregexec\fR has been done using the \fIregexp\fR,
+each \fIstartp\fR-\fIendp\fR pair describes one substring
+within the \fIstring\fR,
+with the \fIstartp\fR pointing to the first character of the substring and
+the \fIendp\fR pointing to the first character following the substring.
+The 0th substring is the substring of \fIstring\fR that matched the whole
+regular expression.
+The others are those substrings that matched parenthesized expressions
+within the regular expression, with parenthesized expressions numbered
+in left-to-right order of their opening parentheses.
+.PP
+.I Regsub
+copies \fIsource\fR to \fIdest\fR, making substitutions according to the
+most recent \fIregexec\fR performed using \fIprog\fR.
+Each instance of `&' in \fIsource\fR is replaced by the substring
+indicated by \fIstartp\fR[\fI0\fR] and
+\fIendp\fR[\fI0\fR].
+Each instance of `\e\fIn\fR', where \fIn\fR is a digit, is replaced by
+the substring indicated by
+\fIstartp\fR[\fIn\fR] and
+\fIendp\fR[\fIn\fR].
+To get a literal `&' or `\e\fIn\fR' into \fIdest\fR, prefix it with `\e';
+to get a literal `\e' preceding `&' or `\e\fIn\fR', prefix it with
+another `\e'.
+.PP
+.I Regerror
+is called whenever an error is detected in \fIregcomp\fR, \fIregexec\fR,
+or \fIregsub\fR.
+The default \fIregerror\fR writes the string \fImsg\fR,
+with a suitable indicator of origin,
+on the standard
+error output
+and invokes \fIexit\fR(2).
+.I Regerror
+can be replaced by the user if other actions are desirable.
+.SH "REGULAR EXPRESSION SYNTAX"
+A regular expression is zero or more \fIbranches\fR, separated by `|'.
+It matches anything that matches one of the branches.
+.PP
+A branch is zero or more \fIpieces\fR, concatenated.
+It matches a match for the first, followed by a match for the second, etc.
+.PP
+A piece is an \fIatom\fR possibly followed by `*', `+', or `?'.
+An atom followed by `*' matches a sequence of 0 or more matches of the atom.
+An atom followed by `+' matches a sequence of 1 or more matches of the atom.
+An atom followed by `?' matches a match of the atom, or the null string.
+.PP
+An atom is a regular expression in parentheses (matching a match for the
+regular expression), a \fIrange\fR (see below), `.'
+(matching any single character), `^' (matching the null string at the
+beginning of the input string), `$' (matching the null string at the
+end of the input string), a `\e' followed by a single character (matching
+that character), or a single character with no other significance
+(matching that character).
+.PP
+A \fIrange\fR is a sequence of characters enclosed in `[]'.
+It normally matches any single character from the sequence.
+If the sequence begins with `^',
+it matches any single character \fInot\fR from the rest of the sequence.
+If two characters in the sequence are separated by `\-', this is shorthand
+for the full list of ASCII characters between them
+(e.g. `[0-9]' matches any decimal digit).
+To include a literal `]' in the sequence, make it the first character
+(following a possible `^').
+To include a literal `\-', make it the first or last character.
+.SH AMBIGUITY
+If a regular expression could match two different parts of the input string,
+it will match the one which begins earliest.
+If both begin in the same place	but match different lengths, or match
+the same length in different ways, life gets messier, as follows.
+.PP
+In general, the possibilities in a list of branches are considered in
+left-to-right order, the possibilities for `*', `+', and `?' are
+considered longest-first, nested constructs are considered from the
+outermost in, and concatenated constructs are considered leftmost-first.
+The match that will be chosen is the one that uses the earliest
+possibility in the first choice that has to be made.
+If there is more than one choice, the next will be made in the same manner
+(earliest possibility) subject to the decision on the first choice.
+And so forth.
+.PP
+For example, `(ab|a)b*c' could match `abc' in one of two ways.
+The first choice is between `ab' and `a'; since `ab' is earlier, and does
+lead to a successful overall match, it is chosen.
+Since the `b' is already spoken for,
+the `b*' must match its last possibility\(emthe empty string\(emsince
+it must respect the earlier choice.
+.PP
+In the particular case where no `|'s are present and there is only one
+`*', `+', or `?', the net effect is that the longest possible
+match will be chosen.
+So `ab*', presented with `xabbbby', will match `abbbb'.
+Note that if `ab*' is tried against `xabyabbbz', it
+will match `ab' just after `x', due to the begins-earliest rule.
+(In effect, the decision on where to start the match is the first choice
+to be made, hence subsequent choices must respect it even if this leads them
+to less-preferred alternatives.)
+.SH SEE ALSO
+egrep(1), expr(1)
+.SH DIAGNOSTICS
+\fIRegcomp\fR returns NULL for a failure
+(\fIregerror\fR permitting),
+where failures are syntax errors, exceeding implementation limits,
+or applying `+' or `*' to a possibly-null operand.
+.SH HISTORY
+Both code and manual page were
+written at U of T.
+They are intended to be compatible with the Bell V8 \fIregexp\fR(3),
+but are not derived from Bell code.
+.SH BUGS
+Empty branches and empty regular expressions are not portable to V8.
+.PP
+The restriction against
+applying `*' or `+' to a possibly-null operand is an artifact of the
+simplistic implementation.
+.PP
+Does not support \fIegrep\fR's newline-separated branches;
+neither does the V8 \fIregexp\fR(3), though.
+.PP
+Due to emphasis on
+compactness and simplicity,
+it's not strikingly fast.
+It does give special attention to handling simple cases quickly.

cde/programs/dtdocbook/lib/tptregexp/regmagic.h

@@ -0,0 +1,6 @@
+/* $XConsortium: regmagic.h /main/3 1996/06/19 17:13:41 drk $ */
+/*
+ * The first byte of the regexp internal "program" is actually this magic
+ * number; the start node begins in the second byte.
+ */
+#define	MAGIC	0234

cde/programs/dtdocbook/lib/tptregexp/regsub.c

@@ -0,0 +1,82 @@
+/* $XConsortium: regsub.c /main/3 1996/06/19 17:13:46 drk $ */
+/*
+ * regsub
+ *
+ *	Copyright (c) 1986 by University of Toronto.
+ *	Written by Henry Spencer.  Not derived from licensed software.
+ *
+ *	Permission is granted to anyone to use this software for any
+ *	purpose on any computer system, and to redistribute it freely,
+ *	subject to the following restrictions:
+ *
+ *	1. The author is not responsible for the consequences of use of
+ *		this software, no matter how awful, even if they arise
+ *		from defects in it.
+ *
+ *	2. The origin of this software must not be misrepresented, either
+ *		by explicit claim or by omission.
+ *
+ *	3. Altered versions must be plainly marked as such, and must not
+ *		be misrepresented as being the original software.
+ */
+#include <stdio.h>
+#include <tptregexp.h>
+#include "regmagic.h"
+
+#ifndef CHARBITS
+#define	UCHARAT(p)	((int)*(unsigned char *)(p))
+#else
+#define	UCHARAT(p)	((int)*(p)&CHARBITS)
+#endif
+
+/*
+ - regsub - perform substitutions after a regexp match
+ */
+void
+tpt_regsub(prog, source, dest)
+regexp *prog;
+char *source;
+char *dest;
+{
+	register char *src;
+	register char *dst;
+	register char c;
+	register int no;
+	register int len;
+	extern char *strncpy();
+
+	if (prog == NULL || source == NULL || dest == NULL) {
+		tpt_regerror("NULL parm to regsub");
+		return;
+	}
+	if (UCHARAT(prog->program) != MAGIC) {
+		tpt_regerror("damaged regexp fed to regsub");
+		return;
+	}
+
+	src = source;
+	dst = dest;
+	while ((c = *src++) != '\0') {
+		if (c == '&')
+			no = 0;
+		else if (c == '\\' && '0' <= *src && *src <= '9')
+			no = *src++ - '0';
+		else
+			no = -1;
+
+		if (no < 0) {	/* Ordinary character. */
+			if (c == '\\' && (*src == '\\' || *src == '&'))
+				c = *src++;
+			*dst++ = c;
+		} else if (prog->startp[no] != NULL && prog->endp[no] != NULL) {
+			len = prog->endp[no] - prog->startp[no];
+			(void) strncpy(dst, prog->startp[no], len);
+			dst += len;
+			if (len != 0 && *(dst-1) == '\0') {	/* strncpy hit NUL. */
+				tpt_regerror("damaged match string");
+				return;
+			}
+		}
+	}
+	*dst++ = '\0';
+}

cde/programs/dtdocbook/lib/tptregexp/tests

@@ -0,0 +1,127 @@
+abc	abc	y	&	abc
+abc	xbc	n	-	-
+abc	axc	n	-	-
+abc	abx	n	-	-
+abc	xabcy	y	&	abc
+abc	ababc	y	&	abc
+ab*c	abc	y	&	abc
+ab*bc	abc	y	&	abc
+ab*bc	abbc	y	&	abbc
+ab*bc	abbbbc	y	&	abbbbc
+ab+bc	abbc	y	&	abbc
+ab+bc	abc	n	-	-
+ab+bc	abq	n	-	-
+ab+bc	abbbbc	y	&	abbbbc
+ab?bc	abbc	y	&	abbc
+ab?bc	abc	y	&	abc
+ab?bc	abbbbc	n	-	-
+ab?c	abc	y	&	abc
+^abc$	abc	y	&	abc
+^abc$	abcc	n	-	-
+^abc	abcc	y	&	abc
+^abc$	aabc	n	-	-
+abc$	aabc	y	&	abc
+^	abc	y	&	
+$	abc	y	&	
+a.c	abc	y	&	abc
+a.c	axc	y	&	axc
+a.*c	axyzc	y	&	axyzc
+a.*c	axyzd	n	-	-
+a[bc]d	abc	n	-	-
+a[bc]d	abd	y	&	abd
+a[b-d]e	abd	n	-	-
+a[b-d]e	ace	y	&	ace
+a[b-d]	aac	y	&	ac
+a[-b]	a-	y	&	a-
+a[b-]	a-	y	&	a-
+a[b-a]	-	c	-	-
+a[]b	-	c	-	-
+a[	-	c	-	-
+a]	a]	y	&	a]
+a[]]b	a]b	y	&	a]b
+a[^bc]d	aed	y	&	aed
+a[^bc]d	abd	n	-	-
+a[^-b]c	adc	y	&	adc
+a[^-b]c	a-c	n	-	-
+a[^]b]c	a]c	n	-	-
+a[^]b]c	adc	y	&	adc
+ab|cd	abc	y	&	ab
+ab|cd	abcd	y	&	ab
+()ef	def	y	&-\1	ef-
+()*	-	c	-	-
+*a	-	c	-	-
+^*	-	c	-	-
+$*	-	c	-	-
+(*)b	-	c	-	-
+$b	b	n	-	-
+a\	-	c	-	-
+a\(b	a(b	y	&-\1	a(b-
+a\(*b	ab	y	&	ab
+a\(*b	a((b	y	&	a((b
+a\\b	a\b	y	&	a\b
+abc)	-	c	-	-
+(abc	-	c	-	-
+((a))	abc	y	&-\1-\2	a-a-a
+(a)b(c)	abc	y	&-\1-\2	abc-a-c
+a+b+c	aabbabc	y	&	abc
+a**	-	c	-	-
+a*?	-	c	-	-
+(a*)*	-	c	-	-
+(a*)+	-	c	-	-
+(a|)*	-	c	-	-
+(a*|b)*	-	c	-	-
+(a+|b)*	ab	y	&-\1	ab-b
+(a+|b)+	ab	y	&-\1	ab-b
+(a+|b)?	ab	y	&-\1	a-a
+[^ab]*	cde	y	&	cde
+(^)*	-	c	-	-
+(ab|)*	-	c	-	-
+)(	-	c	-	-
+	abc	y	&	
+abc		n	-	-
+a*		y	&	
+([abc])*d	abbbcd	y	&-\1	abbbcd-c
+([abc])*bcd	abcd	y	&-\1	abcd-a
+a|b|c|d|e	e	y	&	e
+(a|b|c|d|e)f	ef	y	&-\1	ef-e
+((a*|b))*	-	c	-	-
+abcd*efg	abcdefg	y	&	abcdefg
+ab*	xabyabbbz	y	&	ab
+ab*	xayabbbz	y	&	a
+(ab|cd)e	abcde	y	&-\1	cde-cd
+[abhgefdc]ij	hij	y	&	hij
+^(ab|cd)e	abcde	n	x\1y	xy
+(abc|)ef	abcdef	y	&-\1	ef-
+(a|b)c*d	abcd	y	&-\1	bcd-b
+(ab|ab*)bc	abc	y	&-\1	abc-a
+a([bc]*)c*	abc	y	&-\1	abc-bc
+a([bc]*)(c*d)	abcd	y	&-\1-\2	abcd-bc-d
+a([bc]+)(c*d)	abcd	y	&-\1-\2	abcd-bc-d
+a([bc]*)(c+d)	abcd	y	&-\1-\2	abcd-b-cd
+a[bcd]*dcdcde	adcdcde	y	&	adcdcde
+a[bcd]+dcdcde	adcdcde	n	-	-
+(ab|a)b*c	abc	y	&-\1	abc-ab
+((a)(b)c)(d)	abcd	y	\1-\2-\3-\4	abc-a-b-d
+[a-zA-Z_][a-zA-Z0-9_]*	alpha	y	&	alpha
+^a(bc+|b[eh])g|.h$	abh	y	&-\1	bh-
+(bc+d$|ef*g.|h?i(j|k))	effgz	y	&-\1-\2	effgz-effgz-
+(bc+d$|ef*g.|h?i(j|k))	ij	y	&-\1-\2	ij-ij-j
+(bc+d$|ef*g.|h?i(j|k))	effg	n	-	-
+(bc+d$|ef*g.|h?i(j|k))	bcdd	n	-	-
+(bc+d$|ef*g.|h?i(j|k))	reffgz	y	&-\1-\2	effgz-effgz-
+((((((((((a))))))))))	-	c	-	-
+(((((((((a)))))))))	a	y	&	a
+multiple words of text	uh-uh	n	-	-
+multiple words	multiple words, yeah	y	&	multiple words
+(.*)c(.*)	abcde	y	&-\1-\2	abcde-ab-de
+\((.*), (.*)\)	(a, b)	y	(\2, \1)	(b, a)
+[k]	ab	n	-	-
+abcd	abcd	y	&-\&-\\&	abcd-&-\abcd
+a(bc)d	abcd	y	\1-\\1-\\\1	bc-\1-\bc
+[ -~]*	abc	y	&	abc
+[ -~ -~]*	abc	y	&	abc
+[ -~ -~ -~]*	abc	y	&	abc
+[ -~ -~ -~ -~]*	abc	y	&	abc
+[ -~ -~ -~ -~ -~]*	abc	y	&	abc
+[ -~ -~ -~ -~ -~ -~]*	abc	y	&	abc
+[ -~ -~ -~ -~ -~ -~ -~]*	abc	y	&	abc

cde/programs/dtdocbook/lib/tptregexp/timer.c

@@ -0,0 +1,183 @@
+/* $XConsortium: timer.c /main/3 1996/06/19 17:13:50 drk $ */
+/*
+ * Simple timing program for regcomp().
+ *
+ *	Copyright (c) 1986 by University of Toronto.
+ *	Written by Henry Spencer.  Not derived from licensed software.
+ *
+ *	Permission is granted to anyone to use this software for any
+ *	purpose on any computer system, and to redistribute it freely,
+ *	subject to the following restrictions:
+ *
+ *	1. The author is not responsible for the consequences of use of
+ *		this software, no matter how awful, even if they arise
+ *		from defects in it.
+ *
+ *	2. The origin of this software must not be misrepresented, either
+ *		by explicit claim or by omission.
+ *
+ *	3. Altered versions must be plainly marked as such, and must not
+ *		be misrepresented as being the original software.
+ *
+ * Usage: timer ncomp nexec nsub
+ *	or
+ *	timer ncomp nexec nsub regexp string [ answer [ sub ] ]
+ *
+ * The second form is for timing repetitions of a single test case.
+ * The first form's test data is a compiled-in copy of the "tests" file.
+ * Ncomp, nexec, nsub are how many times to do each regcomp, regexec,
+ * and regsub.  The way to time an operation individually is to do something
+ * like "timer 1 50 1".
+ */
+#include <stdio.h>
+
+struct try {
+	char *re, *str, *ans, *src, *dst;
+} tests[] = {
+#include "timer.t.h"
+{ NULL, NULL, NULL, NULL, NULL }
+};
+
+#include <tptregexp.h>
+
+int errreport = 0;		/* Report errors via errseen? */
+char *errseen = NULL;		/* Error message. */
+
+char *progname;
+
+/* ARGSUSED */
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	int ncomp, nexec, nsub;
+	struct try one;
+	char dummy[512];
+
+	if (argc < 4) {
+		ncomp = 1;
+		nexec = 1;
+		nsub = 1;
+	} else {
+		ncomp = atoi(argv[1]);
+		nexec = atoi(argv[2]);
+		nsub = atoi(argv[3]);
+	}
+	
+	progname = argv[0];
+	if (argc > 5) {
+		one.re = argv[4];
+		one.str = argv[5];
+		if (argc > 6)
+			one.ans = argv[6];
+		else
+			one.ans = "y";
+		if (argc > 7) {	
+			one.src = argv[7];
+			one.dst = "xxx";
+		} else {
+			one.src = "x";
+			one.dst = "x";
+		}
+		errreport = 1;
+		try(one, ncomp, nexec, nsub);
+	} else
+		multiple(ncomp, nexec, nsub);
+	exit(0);
+}
+
+void
+tpt_regerror(s)
+char *s;
+{
+	if (errreport)
+		errseen = s;
+	else
+		error(s, "");
+}
+
+#ifndef ERRAVAIL
+error(s1, s2)
+char *s1;
+char *s2;
+{
+	fprintf(stderr, "regexp: ");
+	fprintf(stderr, s1, s2);
+	fprintf(stderr, "\n");
+	exit(1);
+}
+#endif
+
+int lineno = 0;
+
+multiple(ncomp, nexec, nsub)
+int ncomp, nexec, nsub;
+{
+	register int i;
+	extern char *strchr();
+
+	errreport = 1;
+	for (i = 0; tests[i].re != NULL; i++) {
+		lineno++;
+		try(tests[i], ncomp, nexec, nsub);
+	}
+}
+
+try(fields, ncomp, nexec, nsub)
+struct try fields;
+int ncomp, nexec, nsub;
+{
+	regexp *r;
+	char dbuf[BUFSIZ];
+	register int i;
+
+	errseen = NULL;
+	r = tpt_regcomp(fields.re);
+	if (r == NULL) {
+		if (*fields.ans != 'c')
+			complain("tpt_regcomp failure in `%s'", fields.re);
+		return;
+	}
+	if (*fields.ans == 'c') {
+		complain("unexpected tpt_regcomp success in `%s'", fields.re);
+		free((char *)r);
+		return;
+	}
+	for (i = ncomp-1; i > 0; i--) {
+		free((char *)r);
+		r = tpt_regcomp(fields.re);
+	}
+	if (!tpt_regexec(r, fields.str)) {
+		if (*fields.ans != 'n')
+			complain("tpt_regexec failure in `%s'", "");
+		free((char *)r);
+		return;
+	}
+	if (*fields.ans == 'n') {
+		complain("unexpected tpt_regexec success", "");
+		free((char *)r);
+		return;
+	}
+	for (i = nexec-1; i > 0; i--)
+		(void) tpt_regexec(r, fields.str);
+	errseen = NULL;
+	for (i = nsub; i > 0; i--)
+		tpt_regsub(r, fields.src, dbuf);
+	if (errseen != NULL) {	
+		complain("tpt_regsub complaint", "");
+		free((char *)r);
+		return;
+	}
+	if (strcmp(dbuf, fields.dst) != 0)
+		complain("tpt_regsub result `%s' wrong", dbuf);
+	free((char *)r);
+}
+
+complain(s1, s2)
+char *s1;
+char *s2;
+{
+	fprintf(stderr, "try: %d: ", lineno);
+	fprintf(stderr, s1, s2);
+	fprintf(stderr, " (%s)\n", (errseen != NULL) ? errseen : "");
+}

cde/programs/dtdocbook/lib/tptregexp/tptregexp.h

@@ -0,0 +1,22 @@
+/* $XConsortium: tptregexp.h /main/3 1996/06/19 17:13:54 drk $ */
+/*
+ * Definitions etc. for regexp(3) routines.
+ *
+ * Caveat:  this is V8 regexp(3) [actually, a reimplementation thereof],
+ * not the System V one.
+ */
+#define NSUBEXP  10
+typedef struct regexp {
+	char *startp[NSUBEXP];
+	char *endp[NSUBEXP];
+	char regstart;		/* Internal use only. */
+	char reganch;		/* Internal use only. */
+	char *regmust;		/* Internal use only. */
+	int regmlen;		/* Internal use only. */
+	char program[1];	/* Unwarranted chumminess with compiler. */
+} regexp;
+
+extern regexp *tpt_regcomp();
+extern int tpt_regexec();
+extern void tpt_regsub();
+extern void tpt_regerror();

cde/programs/dtdocbook/lib/tptregexp/try.c

@@ -0,0 +1,239 @@
+/* $XConsortium: try.c /main/3 1996/06/19 17:13:58 drk $ */
+/*
+ * Simple test program for regexp(3) stuff.  Knows about debugging hooks.
+ *
+ *	Copyright (c) 1986 by University of Toronto.
+ *	Written by Henry Spencer.  Not derived from licensed software.
+ *
+ *	Permission is granted to anyone to use this software for any
+ *	purpose on any computer system, and to redistribute it freely,
+ *	subject to the following restrictions:
+ *
+ *	1. The author is not responsible for the consequences of use of
+ *		this software, no matter how awful, even if they arise
+ *		from defects in it.
+ *
+ *	2. The origin of this software must not be misrepresented, either
+ *		by explicit claim or by omission.
+ *
+ *	3. Altered versions must be plainly marked as such, and must not
+ *		be misrepresented as being the original software.
+ *
+ * Usage: try re [string [output [-]]]
+ * The re is compiled and dumped, regexeced against the string, the result
+ * is applied to output using regsub().  The - triggers a running narrative
+ * from regexec().  Dumping and narrative don't happen unless DEBUG.
+ *
+ * If there are no arguments, stdin is assumed to be a stream of lines with
+ * five fields:  a r.e., a string to match it against, a result code, a
+ * source string for regsub, and the proper result.  Result codes are 'c'
+ * for compile failure, 'y' for match success, 'n' for match failure.
+ * Field separator is tab.
+ */
+#include <stdio.h>
+#include <tptregexp.h>
+
+#ifdef ERRAVAIL
+char *progname;
+extern char *mkprogname();
+#endif
+
+#ifdef DEBUG
+extern int regnarrate;
+#endif
+
+char buf[BUFSIZ];
+
+int errreport = 0;		/* Report errors via errseen? */
+char *errseen = NULL;		/* Error message. */
+int status = 0;			/* Exit status. */
+
+/* ARGSUSED */
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	regexp *r;
+	int i;
+
+#ifdef ERRAVAIL
+	progname = mkprogname(argv[0]);
+#endif
+
+	if (argc == 1) {
+		multiple();
+		exit(status);
+	}
+
+	r = tpt_regcomp(argv[1]);
+	if (r == NULL)
+		error("tpt_regcomp failure", "");
+#ifdef DEBUG
+	regdump(r);
+	if (argc > 4)
+		regnarrate++;
+#endif
+	if (argc > 2) {
+		i = tpt_regexec(r, argv[2]);
+		printf("%d", i);
+		for (i = 1; i < NSUBEXP; i++)
+			if (r->startp[i] != NULL && r->endp[i] != NULL)
+				printf(" \\%d", i);
+		printf("\n");
+	}
+	if (argc > 3) {
+		tpt_regsub(r, argv[3], buf);
+		printf("%s\n", buf);
+	}
+	exit(status);
+}
+
+void
+tpt_regerror(s)
+char *s;
+{
+	if (errreport)
+		errseen = s;
+	else
+		error(s, "");
+}
+
+#ifndef ERRAVAIL
+error(s1, s2)
+char *s1;
+char *s2;
+{
+	fprintf(stderr, "regexp: ");
+	fprintf(stderr, s1, s2);
+	fprintf(stderr, "\n");
+	exit(1);
+}
+#endif
+
+int lineno;
+
+regexp badregexp;		/* Implicit init to 0. */
+
+multiple()
+{
+	char rbuf[BUFSIZ];
+	char *field[5];
+	char *scan;
+	int i;
+	regexp *r;
+	extern char *strchr();
+
+	errreport = 1;
+	lineno = 0;
+	while (fgets(rbuf, sizeof(rbuf), stdin) != NULL) {
+		rbuf[strlen(rbuf)-1] = '\0';	/* Dispense with \n. */
+		lineno++;
+		scan = rbuf;
+		for (i = 0; i < 5; i++) {
+			field[i] = scan;
+			if (field[i] == NULL) {
+				complain("bad testfile format", "");
+				exit(1);
+			}
+			scan = strchr(scan, '\t');
+			if (scan != NULL)
+				*scan++ = '\0';
+		}
+		try(field);
+	}
+
+	/* And finish up with some internal testing... */
+	lineno = 9990;
+	errseen = NULL;
+	if (tpt_regcomp((char *)NULL) != NULL || errseen == NULL)
+		complain("tpt_regcomp(NULL) doesn't complain", "");
+	lineno = 9991;
+	errseen = NULL;
+	if (tpt_regexec((regexp *)NULL, "foo") || errseen == NULL)
+		complain("tpt_regexec(NULL, ...) doesn't complain", "");
+	lineno = 9992;
+	r = tpt_regcomp("foo");
+	if (r == NULL) {
+		complain("tpt_regcomp(\"foo\") fails", "");
+		return;
+	}
+	lineno = 9993;
+	errseen = NULL;
+	if (tpt_regexec(r, (char *)NULL) || errseen == NULL)
+		complain("tpt_regexec(..., NULL) doesn't complain", "");
+	lineno = 9994;
+	errseen = NULL;
+	tpt_regsub((regexp *)NULL, "foo", rbuf);
+	if (errseen == NULL)
+		complain("tpt_regsub(NULL, ..., ...) doesn't complain", "");
+	lineno = 9995;
+	errseen = NULL;
+	tpt_regsub(r, (char *)NULL, rbuf);
+	if (errseen == NULL)
+		complain("tpt_regsub(..., NULL, ...) doesn't complain", "");
+	lineno = 9996;
+	errseen = NULL;
+	tpt_regsub(r, "foo", (char *)NULL);
+	if (errseen == NULL)
+		complain("tpt_regsub(..., ..., NULL) doesn't complain", "");
+	lineno = 9997;
+	errseen = NULL;
+	if (tpt_regexec(&badregexp, "foo") || errseen == NULL)
+		complain("tpt_regexec(nonsense, ...) doesn't complain", "");
+	lineno = 9998;
+	errseen = NULL;
+	tpt_regsub(&badregexp, "foo", rbuf);
+	if (errseen == NULL)
+		complain("tpt_regsub(nonsense, ..., ...) doesn't complain", "");
+}
+
+try(fields)
+char **fields;
+{
+	regexp *r;
+	char dbuf[BUFSIZ];
+
+	errseen = NULL;
+	r = tpt_regcomp(fields[0]);
+	if (r == NULL) {
+		if (*fields[2] != 'c')
+			complain("tpt_regcomp failure in `%s'", fields[0]);
+		return;
+	}
+	if (*fields[2] == 'c') {
+		complain("unexpected tpt_regcomp success in `%s'", fields[0]);
+		free((char *)r);
+		return;
+	}
+	if (!tpt_regexec(r, fields[1])) {
+		if (*fields[2] != 'n')
+			complain("tpt_regexec failure in `%s'", "");
+		free((char *)r);
+		return;
+	}
+	if (*fields[2] == 'n') {
+		complain("unexpected tpt_regexec success", "");
+		free((char *)r);
+		return;
+	}
+	errseen = NULL;
+	tpt_regsub(r, fields[3], dbuf);
+	if (errseen != NULL) {
+		complain("tpt_regsub complaint", "");
+		free((char *)r);
+		return;
+	}
+	if (strcmp(dbuf, fields[4]) != 0)
+		complain("tpt_regsub result `%s' wrong", dbuf);
+	free((char *)r);
+}
+
+complain(s1, s2)
+char *s1;
+char *s2;
+{
+	fprintf(stderr, "try: %d: ", lineno);
+	fprintf(stderr, s1, s2);
+	fprintf(stderr, " (%s)\n", (errseen != NULL) ? errseen : "");
+	status = 1;
+}