Import OpenBSD m4 as of today.

7 files changed, 1907 insertions, 446 deletions

diff --git a/usr.bin/m4/eval.c b/usr.bin/m4/eval.c
index aa3da5e..870bffd 100644
--- a/usr.bin/m4/eval.c
+++ b/usr.bin/m4/eval.c
@@ -1,3 +1,6 @@
+/*	$OpenBSD: eval.c,v 1.43 2002/02/16 21:27:48 millert Exp $	*/
+/*	$NetBSD: eval.c,v 1.7 1996/11/10 21:21:29 pk Exp $	*/
+
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
@@ -35,7 +38,11 @@
  */
 
 #ifndef lint
+#if 0
 static char sccsid[] = "@(#)eval.c	8.2 (Berkeley) 4/27/95";
+#else
+static char rcsid[] = "$OpenBSD: eval.c,v 1.43 2002/02/16 21:27:48 millert Exp $";
+#endif
 #endif /* not lint */
 
 /*
@@ -49,14 +56,41 @@ static char sccsid[] = "@(#)eval.c	8.2 (Berkeley) 4/27/95";
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <stddef.h>
 #include <string.h>
+#include <fcntl.h>
+#include <err.h>
 #include "mdef.h"
 #include "stdd.h"
 #include "extern.h"
 #include "pathnames.h"
 
+#define BUILTIN_MARKER	"__builtin_"
+
+static void	dodefn(const char *);
+static void	dopushdef(const char *, const char *);
+static void	dodump(const char *[], int);
+static void	dotrace(const char *[], int, int);
+static void	doifelse(const char *[], int);
+static int	doincl(const char *);
+static int	dopaste(const char *);
+static void	gnu_dochq(const char *[], int);
+static void	dochq(const char *[], int);
+static void	gnu_dochc(const char *[], int);
+static void	dochc(const char *[], int);
+static void	dodiv(int);
+static void	doundiv(const char *[], int);
+static void	dosub(const char *[], int);
+static void	map(char *, const char *, const char *, const char *);
+static const char *handledash(char *, char *, const char *);
+static void	expand_builtin(const char *[], int, int);
+static void	expand_macro(const char *[], int);
+static void	dump_one_def(ndptr);
+
+unsigned long	expansion_id;
+
 /*
- * eval - evaluate built-in macros.
+ * eval - eval all macros and builtins calls
  *	  argc - number of elements in argv.
  *	  argv - element vector :
  *			argv[0] = definition of a user
@@ -67,36 +101,66 @@ static char sccsid[] = "@(#)eval.c	8.2 (Berkeley) 4/27/95";
  *			   .	  macro or built-in.
  *			   .
  *
- * Note that the minimum value for argc is 3. A call in the form
- * of macro-or-builtin() will result in:
+ * A call in the form of macro-or-builtin() will result in:
  *			argv[0] = nullstr
  *			argv[1] = macro-or-builtin
  *			argv[2] = nullstr
+ *
+ * argc is 3 for macro-or-builtin() and 2 for macro-or-builtin
  */
-
 void
 eval(argv, argc, td)
-register char *argv[];
-register int argc;
-register int td;
+	const char *argv[];
+	int argc;
+	int td;
+{
+	ssize_t mark = -1;
+
+	expansion_id++;
+	if (td & RECDEF) 
+		errx(1, "%s at line %lu: expanding recursive definition for %s",
+			CURRENT_NAME, CURRENT_LINE, argv[1]);
+	if (traced_macros && is_traced(argv[1]))
+		mark = trace(argv, argc, infile+ilevel);
+	if (td == MACRTYPE)
+		expand_macro(argv, argc);
+	else
+		expand_builtin(argv, argc, td);
+    	if (mark != -1)
+		finish_trace(mark);
+}
+
+/*
+ * expand_builtin - evaluate built-in macros.
+ */
+void
+expand_builtin(argv, argc, td)
+	const char *argv[];
+	int argc;
+	int td;
 {
-	register int c, n;
+	int c, n;
+	int ac;
 	static int sysval = 0;
 
 #ifdef DEBUG
 	printf("argc = %d\n", argc);
 	for (n = 0; n < argc; n++)
 		printf("argv[%d] = %s\n", n, argv[n]);
+	fflush(stdout);
 #endif
+
  /*
   * if argc == 3 and argv[2] is null, then we
   * have macro-or-builtin() type call. We adjust
   * argc to avoid further checking..
   */
+  	ac = argc;
+
 	if (argc == 3 && !*(argv[2]))
 		argc--;
 
-	switch (td & ~STATIC) {
+	switch (td & TYPEMASK) {
 
 	case DEFITYPE:
 		if (argc > 2)
@@ -112,6 +176,14 @@ register int td;
 		dodump(argv, argc);
 		break;
 
+	case TRACEONTYPE:
+		dotrace(argv, argc, 1);
+		break;
+
+	case TRACEOFFTYPE:
+		dotrace(argv, argc, 0);
+		break;
+
 	case EXPRTYPE:
 	/*
 	 * doexpr - evaluate arithmetic
@@ -145,8 +217,7 @@ register int td;
 	 * dolen - find the length of the
 	 * argument
 	 */
-		if (argc > 2)
-			pbnum((argc > 2) ? strlen(argv[2]) : 0);
+		pbnum((argc > 2) ? strlen(argv[2]) : 0);
 		break;
 
 	case INCRTYPE:
@@ -184,10 +255,15 @@ register int td;
 		pbnum(sysval);
 		break;
 
+	case ESYSCMDTYPE:
+		if (argc > 2)
+			doesyscmd(argv[2]);
+	    	break;
 	case INCLTYPE:
 		if (argc > 2)
 			if (!doincl(argv[2]))
-				oops("%s: %s", argv[2], strerror(errno));
+				err(1, "%s at line %lu: include(%s)",
+				    CURRENT_NAME, CURRENT_LINE, argv[2]);
 		break;
 
 	case SINCTYPE:
@@ -198,7 +274,8 @@ register int td;
 	case PASTTYPE:
 		if (argc > 2)
 			if (!dopaste(argv[2]))
-				oops("%s: %s", argv[2], strerror(errno));
+				err(1, "%s at line %lu: paste(%s)", 
+				    CURRENT_NAME, CURRENT_LINE, argv[2]);
 		break;
 
 	case SPASTYPE:
@@ -207,11 +284,17 @@ register int td;
 		break;
 #endif
 	case CHNQTYPE:
-		dochq(argv, argc);
+		if (mimic_gnu)
+			gnu_dochq(argv, ac);
+		else
+			dochq(argv, argc);
 		break;
 
 	case CHNCTYPE:
-		dochc(argv, argc);
+		if (mimic_gnu)
+			gnu_dochc(argv, ac);
+		else
+			dochc(argv, argc);
 		break;
 
 	case SUBSTYPE:
@@ -231,14 +314,14 @@ register int td;
 	 */
 		if (argc > 3) {
 			for (n = argc - 1; n > 3; n--) {
-				putback(rquote);
+				pbstr(rquote);
 				pbstr(argv[n]);
-				putback(lquote);
-				putback(',');
+				pbstr(lquote);
+				putback(COMMA);
 			}
-			putback(rquote);
+			pbstr(rquote);
 			pbstr(argv[3]);
-			putback(lquote);
+			pbstr(lquote);
 		}
 		break;
 
@@ -288,8 +371,21 @@ register int td;
 	/*
 	 * dotemp - create a temporary file
 	 */
-		if (argc > 2)
-			pbstr(mktemp(argv[2]));
+		if (argc > 2) {
+			int fd;
+			char *temp;
+
+			temp = xstrdup(argv[2]);
+			
+			fd = mkstemp(temp);
+			if (fd == -1)
+				err(1, 
+	    "%s at line %lu: couldn't make temp file %s", 
+	    CURRENT_NAME, CURRENT_LINE, argv[2]);
+			close(fd);
+			pbstr(temp);
+			free(temp);
+		}
 		break;
 
 	case TRNLTYPE:
@@ -300,14 +396,16 @@ register int td;
 	 * characters in the "to" string.
 	 */
 		if (argc > 3) {
-			char temp[MAXTOK];
+			char *temp;
+
+			temp = xalloc(strlen(argv[2])+1);
 			if (argc > 4)
 				map(temp, argv[2], argv[3], argv[4]);
 			else
 				map(temp, argv[2], argv[3], null);
 			pbstr(temp);
-		}
-		else if (argc > 2)
+			free(temp);
+		} else if (argc > 2)
 			pbstr(argv[2]);
 		break;
 
@@ -363,26 +461,54 @@ register int td;
 				dodefn(argv[n]);
 		break;
 
+	case INDIRTYPE:	/* Indirect call */
+		if (argc > 2)
+			doindir(argv, argc);
+		break;
+	
+	case BUILTINTYPE: /* Builtins only */
+		if (argc > 2)
+			dobuiltin(argv, argc);
+		break;
+
+	case PATSTYPE:
+		if (argc > 2)
+			dopatsubst(argv, argc);
+		break;
+	case REGEXPTYPE:
+		if (argc > 2)
+			doregexp(argv, argc);
+		break;
+	case LINETYPE:
+		doprintlineno(infile+ilevel);
+		break;
+	case FILENAMETYPE:
+		doprintfilename(infile+ilevel);
+		break;
+	case SELFTYPE:
+		pbstr(rquote);
+		pbstr(argv[1]);
+		pbstr(lquote);
+		break;
 	default:
-		oops("%s: major botch.", "eval");
+		errx(1, "%s at line %lu: eval: major botch.",
+			CURRENT_NAME, CURRENT_LINE);
 		break;
 	}
 }
 
-char *dumpfmt = "`%s'\t`%s'\n";	       /* format string for dumpdef   */
-
 /*
- * expand - user-defined macro expansion
+ * expand_macro - user-defined macro expansion
  */
 void
-expand(argv, argc)
-register char *argv[];
-register int argc;
+expand_macro(argv, argc)
+	const char *argv[];
+	int argc;
 {
-	register char *t;
-	register char *p;
-	register int n;
-	register int argno;
+	const char *t;
+	const char *p;
+	int n;
+	int argno;
 
 	t = argv[0];		       /* defn string as a whole */
 	p = t;
@@ -391,7 +517,7 @@ register int argc;
 	p--;			       /* last character of defn */
 	while (p > t) {
 		if (*(p - 1) != ARGFLAG)
-			putback(*p);
+			PUTBACK(*p);
 		else {
 			switch (*p) {
 
@@ -412,15 +538,30 @@ register int argc;
 					pbstr(argv[argno + 1]);
 				break;
 			case '*':
-				for (n = argc - 1; n > 2; n--) {
-					pbstr(argv[n]);
-					putback(',');
-				}
-				pbstr(argv[2]);
+				if (argc > 2) {
+					for (n = argc - 1; n > 2; n--) {
+						pbstr(argv[n]);
+						putback(COMMA);
+					}
+					pbstr(argv[2]);
+			    	}
 				break;
+                        case '@':
+				if (argc > 2) {
+					for (n = argc - 1; n > 2; n--) {
+						pbstr(rquote);
+						pbstr(argv[n]);
+						pbstr(lquote);
+						putback(COMMA);
+					}
+					pbstr(rquote);
+					pbstr(argv[2]);
+					pbstr(lquote);
+				}
+                                break;
 			default:
-				putback(*p);
-				putback('$');
+				PUTBACK(*p);
+				PUTBACK('$');
 				break;
 			}
 			p--;
@@ -428,7 +569,7 @@ register int argc;
 		p--;
 	}
 	if (p == t)		       /* do last character */
-		putback(*p);
+		PUTBACK(*p);
 }
 
 /*
@@ -436,40 +577,58 @@ register int argc;
  */
 void
 dodefine(name, defn)
-register char *name;
-register char *defn;
+	const char *name;
+	const char *defn;
 {
-	register ndptr p;
+	ndptr p;
+	int n;
 
 	if (!*name)
-		oops("null definition.");
-	if (STREQ(name, defn))
-		oops("%s: recursive definition.", name);
+		errx(1, "%s at line %lu: null definition.", CURRENT_NAME,
+		    CURRENT_LINE);
 	if ((p = lookup(name)) == nil)
 		p = addent(name);
 	else if (p->defn != null)
 		free((char *) p->defn);
+	if (strncmp(defn, BUILTIN_MARKER, sizeof(BUILTIN_MARKER)-1) == 0) {
+		n = builtin_type(defn+sizeof(BUILTIN_MARKER)-1);
+		if (n != -1) {
+			p->type = n & TYPEMASK;
+			if ((n & NOARGS) == 0)
+				p->type |= NEEDARGS;
+			p->defn = null;
+			return;
+		}
+	}
 	if (!*defn)
 		p->defn = null;
 	else
 		p->defn = xstrdup(defn);
 	p->type = MACRTYPE;
+	if (STREQ(name, defn))
+		p->type |= RECDEF;
 }
 
 /*
  * dodefn - push back a quoted definition of
  *      the given name.
  */
-void
+static void
 dodefn(name)
-char *name;
+	const char *name;
 {
-	register ndptr p;
-
-	if ((p = lookup(name)) != nil && p->defn != null) {
-		putback(rquote);
-		pbstr(p->defn);
-		putback(lquote);
+	ndptr p;
+	char *real;
+
+	if ((p = lookup(name)) != nil) {
+		if (p->defn != null) {
+			pbstr(rquote);
+			pbstr(p->defn);
+			pbstr(lquote);
+		} else if ((real = builtin_realname(p->type)) != NULL) {
+			pbstr(real);
+			pbstr(BUILTIN_MARKER);
+		}
 	}
 }
 
@@ -480,23 +639,46 @@ char *name;
  *      hash bucket, it hides a previous definition from
  *      lookup.
  */
-void
+static void
 dopushdef(name, defn)
-register char *name;
-register char *defn;
+	const char *name;
+	const char *defn;
 {
-	register ndptr p;
+	ndptr p;
 
 	if (!*name)
-		oops("null definition");
-	if (STREQ(name, defn))
-		oops("%s: recursive definition.", name);
+		errx(1, "%s at line %lu: null definition", CURRENT_NAME,
+		    CURRENT_LINE);
 	p = addent(name);
 	if (!*defn)
 		p->defn = null;
 	else
 		p->defn = xstrdup(defn);
 	p->type = MACRTYPE;
+	if (STREQ(name, defn))
+		p->type |= RECDEF;
+}
+
+/*
+ * dump_one_def - dump the specified definition.
+ */
+static void
+dump_one_def(p)
+	ndptr p;
+{
+	char *real;
+
+	if (mimic_gnu) {
+		if ((p->type & TYPEMASK) == MACRTYPE)
+			fprintf(traceout, "%s:\t%s\n", p->name, p->defn);
+		else {
+			real = builtin_realname(p->type);
+			if (real == NULL)
+				real = null;
+			fprintf(traceout, "%s:\t<%s>\n", p->name, real);
+	    	}
+	} else
+		fprintf(traceout, "`%s'\t`%s'\n", p->name, p->defn);
 }
 
 /*
@@ -504,35 +686,50 @@ register char *defn;
  *      table to stderr. If nothing is specified, the entire
  *      hash table is dumped.
  */
-void
+static void
 dodump(argv, argc)
-register char *argv[];
-register int argc;
+	const char *argv[];
+	int argc;
 {
-	register int n;
+	int n;
 	ndptr p;
 
 	if (argc > 2) {
 		for (n = 2; n < argc; n++)
 			if ((p = lookup(argv[n])) != nil)
-				fprintf(stderr, dumpfmt, p->name,
-					p->defn);
-	}
-	else {
+				dump_one_def(p);
+	} else {
 		for (n = 0; n < HASHSIZE; n++)
 			for (p = hashtab[n]; p != nil; p = p->nxtptr)
-				fprintf(stderr, dumpfmt, p->name,
-					p->defn);
+				dump_one_def(p);
 	}
 }
 
 /*
+ * dotrace - mark some macros as traced/untraced depending upon on.
+ */
+static void
+dotrace(argv, argc, on)
+	const char *argv[];
+	int argc;
+	int on;
+{
+	int n;
+
+	if (argc > 2) {
+		for (n = 2; n < argc; n++)
+			mark_traced(argv[n], on);
+	} else
+		mark_traced(NULL, on);
+}
+
+/*
  * doifelse - select one of two alternatives - loop.
  */
-void
+static void
 doifelse(argv, argc)
-register char *argv[];
-register int argc;
+	const char *argv[];
+	int argc;
 {
 	cycle {
 		if (STREQ(argv[2], argv[3]))
@@ -551,18 +748,18 @@ register int argc;
 /*
  * doinclude - include a given file.
  */
-int
+static int
 doincl(ifile)
-char *ifile;
+	const char *ifile;
 {
 	if (ilevel + 1 == MAXINP)
-		oops("too many include files.");
-	if ((infile[ilevel + 1] = fopen(ifile, "r")) != NULL) {
+		errx(1, "%s at line %lu: too many include files.",
+		    CURRENT_NAME, CURRENT_LINE);
+	if (fopen_trypath(infile+ilevel+1, ifile) != NULL) {
 		ilevel++;
 		bbase[ilevel] = bufbase = bp;
 		return (1);
-	}
-	else
+	} else
 		return (0);
 }
 
@@ -571,87 +768,141 @@ char *ifile;
  * dopaste - include a given file without any
  *           macro processing.
  */
-int
+static int
 dopaste(pfile)
-char *pfile;
+	const char *pfile;
 {
 	FILE *pf;
-	register int c;
+	int c;
 
 	if ((pf = fopen(pfile, "r")) != NULL) {
 		while ((c = getc(pf)) != EOF)
 			putc(c, active);
 		(void) fclose(pf);
 		return (1);
-	}
-	else
+	} else
 		return (0);
 }
 #endif
 
+static void
+gnu_dochq(argv, ac)
+	const char *argv[];
+	int ac;
+{
+	/* In gnu-m4 mode, the only way to restore quotes is to have no
+	 * arguments at all. */
+	if (ac == 2) {
+		lquote[0] = LQUOTE, lquote[1] = EOS;
+		rquote[0] = RQUOTE, rquote[1] = EOS;
+	} else {
+		strlcpy(lquote, argv[2], sizeof(lquote));
+		if(ac > 3)
+			strlcpy(rquote, argv[3], sizeof(rquote));
+		else
+			rquote[0] = EOS;
+	}
+}
+
 /*
  * dochq - change quote characters
  */
-void
+static void
 dochq(argv, argc)
-register char *argv[];
-register int argc;
+	const char *argv[];
+	int argc;
 {
 	if (argc > 2) {
 		if (*argv[2])
-			lquote = *argv[2];
+			strlcpy(lquote, argv[2], sizeof(lquote));
+		else {
+			lquote[0] = LQUOTE;
+			lquote[1] = EOS;
+		}
 		if (argc > 3) {
 			if (*argv[3])
-				rquote = *argv[3];
-		}
-		else
-			rquote = lquote;
-	}
-	else {
-		lquote = LQUOTE;
-		rquote = RQUOTE;
+				strlcpy(rquote, argv[3], sizeof(rquote));
+		} else
+			strcpy(rquote, lquote);
+	} else {
+		lquote[0] = LQUOTE, lquote[1] = EOS;
+		rquote[0] = RQUOTE, rquote[1] = EOS;
 	}
 }
 
+static void
+gnu_dochc(argv, ac)
+	const char *argv[];
+	int ac;
+{
+	/* In gnu-m4 mode, no arguments mean no comment
+	 * arguments at all. */
+	if (ac == 2) {
+		scommt[0] = EOS;
+		ecommt[0] = EOS;
+	} else {
+		if (*argv[2])
+			strlcpy(scommt, argv[2], sizeof(scommt));
+		else
+			scommt[0] = SCOMMT, scommt[1] = EOS;
+		if(ac > 3 && *argv[3])
+			strlcpy(ecommt, argv[3], sizeof(ecommt));
+		else
+			ecommt[0] = ECOMMT, ecommt[1] = EOS;
+	}
+}
 /*
  * dochc - change comment characters
  */
-void
+static void
 dochc(argv, argc)
-register char *argv[];
-register int argc;
+	const char *argv[];
+	int argc;
 {
 	if (argc > 2) {
 		if (*argv[2])
-			scommt = *argv[2];
+			strlcpy(scommt, argv[2], sizeof(scommt));
 		if (argc > 3) {
 			if (*argv[3])
-				ecommt = *argv[3];
+				strlcpy(ecommt, argv[3], sizeof(ecommt));
 		}
 		else
-			ecommt = ECOMMT;
+			ecommt[0] = ECOMMT, ecommt[1] = EOS;
 	}
 	else {
-		scommt = SCOMMT;
-		ecommt = ECOMMT;
+		scommt[0] = SCOMMT, scommt[1] = EOS;
+		ecommt[0] = ECOMMT, ecommt[1] = EOS;
 	}
 }
 
 /*
  * dodivert - divert the output to a temporary file
  */
-void
+static void
 dodiv(n)
-register int n;
+	int n;
 {
-	if (n < 0 || n >= MAXOUT)
+	int fd;
+
+	oindex = n;
+	if (n >= maxout) {
+		if (mimic_gnu)
+			resizedivs(n + 10);
+		else
+			n = 0;		/* bitbucket */
+    	}
+
+	if (n < 0)
 		n = 0;		       /* bitbucket */
 	if (outfile[n] == NULL) {
-		m4temp[UNIQUE] = n + '0';
-		if ((outfile[n] = fopen(m4temp, "w")) == NULL)
-			oops("%s: cannot divert.", m4temp);
+		char fname[] = _PATH_DIVNAME;
+
+		if ((fd = mkstemp(fname)) < 0 || 
+			(outfile[n] = fdopen(fd, "w+")) == NULL)
+				err(1, "%s: cannot divert", fname);
+		if (unlink(fname) == -1)
+			err(1, "%s: cannot unlink", fname);
 	}
-	oindex = n;
 	active = outfile[n];
 }
 
@@ -659,24 +910,24 @@ register int n;
  * doundivert - undivert a specified output, or all
  *              other outputs, in numerical order.
  */
-void
+static void
 doundiv(argv, argc)
-register char *argv[];
-register int argc;
+	const char *argv[];
+	int argc;
 {
-	register int ind;
-	register int n;
+	int ind;
+	int n;
 
 	if (argc > 2) {
 		for (ind = 2; ind < argc; ind++) {
 			n = atoi(argv[ind]);
-			if (n > 0 && n < MAXOUT && outfile[n] != NULL)
+			if (n > 0 && n < maxout && outfile[n] != NULL)
 				getdiv(n);
 
 		}
 	}
 	else
-		for (n = 1; n < MAXOUT; n++)
+		for (n = 1; n < maxout; n++)
 			if (outfile[n] != NULL)
 				getdiv(n);
 }
@@ -684,30 +935,29 @@ register int argc;
 /*
  * dosub - select substring
  */
-void
+static void
 dosub(argv, argc)
-register char *argv[];
-register int argc;
+	const char *argv[];
+	int argc;
 {
-	register char *ap, *fc, *k;
-	register int nc;
+	const char *ap, *fc, *k;
+	int nc;
 
-	if (argc < 5)
-		nc = MAXTOK;
-	else
-#ifdef EXPR
-		nc = expr(argv[4]);
-#else
-		nc = atoi(argv[4]);
-#endif
 	ap = argv[2];		       /* target string */
 #ifdef EXPR
 	fc = ap + expr(argv[3]);       /* first char */
 #else
 	fc = ap + atoi(argv[3]);       /* first char */
 #endif
+	nc = strlen(fc);
+	if (argc >= 5)
+#ifdef EXPR
+		nc = min(nc, expr(argv[4]));
+#else
+		nc = min(nc, atoi(argv[4]));
+#endif
 	if (fc >= ap && fc < ap + strlen(ap))
-		for (k = fc + min(nc, strlen(fc)) - 1; k >= fc; k--)
+		for (k = fc + nc - 1; k >= fc; k--)
 			putback(*k);
 }
 
@@ -736,55 +986,109 @@ register int argc;
  * about 5 times faster than any algorithm that makes multiple passes over
  * destination string.
  */
-void
+static void
 map(dest, src, from, to)
-register char *dest;
-register char *src;
-register char *from;
-register char *to;
+	char *dest;
+	const char *src;
+	const char *from;
+	const char *to;
 {
-	register char *tmp;
-	register char sch, dch;
-	static char mapvec[128] = {
-		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-		12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-		24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
-		36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
-		60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
-		72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
-		84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
-		96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
-		108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
-		120, 121, 122, 123, 124, 125, 126, 127
+	const char *tmp;
+	unsigned char sch, dch;
+	static char frombis[257];
+	static char tobis[257];
+	static unsigned char mapvec[256] = {
+	    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+	    19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+	    36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+	    53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+	    70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+	    87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+	    103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+	    116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
+	    129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
+	    142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
+	    155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
+	    168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
+	    181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
+	    194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
+	    207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
+	    220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
+	    233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
+	    246, 247, 248, 249, 250, 251, 252, 253, 254, 255
 	};
 
 	if (*src) {
+		if (mimic_gnu) {
+			/*
+			 * expand character ranges on the fly
+			 */
+			from = handledash(frombis, frombis + 256, from);
+			to = handledash(tobis, tobis + 256, to);
+		}
 		tmp = from;
 	/*
 	 * create a mapping between "from" and
 	 * "to"
 	 */
 		while (*from)
-			mapvec[*from++] = (*to) ? *to++ : (char) 0;
+			mapvec[(unsigned char)(*from++)] = (*to) ? 
+				(unsigned char)(*to++) : 0;
 
 		while (*src) {
-			sch = *src++;
+			sch = (unsigned char)(*src++);
 			dch = mapvec[sch];
 			while (dch != sch) {
 				sch = dch;
 				dch = mapvec[sch];
 			}
-			if (*dest = dch)
+			if ((*dest = (char)dch))
 				dest++;
 		}
 	/*
 	 * restore all the changed characters
 	 */
 		while (*tmp) {
-			mapvec[*tmp] = *tmp;
+			mapvec[(unsigned char)(*tmp)] = (unsigned char)(*tmp);
 			tmp++;
 		}
 	}
-	*dest = (char) 0;
+	*dest = '\0';
+}
+
+
+/*
+ * handledash:
+ *  use buffer to copy the src string, expanding character ranges
+ * on the way.
+ */
+static const char *
+handledash(buffer, end, src)
+	char *buffer;
+	char *end;
+	const char *src;
+{
+	char *p;
+	
+	p = buffer;
+	while(*src) {
+		if (src[1] == '-' && src[2]) {
+			unsigned char i;
+			for (i = (unsigned char)src[0]; 
+			    i <= (unsigned char)src[2]; i++) {
+				*p++ = i;
+				if (p == end) {
+					*p = '\0';
+					return buffer;
+				}
+			}
+			src += 3;
+		} else
+			*p++ = *src++;
+		if (p == end)
+			break;
+	}
+	*p = '\0';
+	return buffer;
 }
+			    
diff --git a/usr.bin/m4/expr.c b/usr.bin/m4/expr.c
index 8ee66b6..d73e712 100644
--- a/usr.bin/m4/expr.c
+++ b/usr.bin/m4/expr.c
@@ -1,3 +1,6 @@
+/*	$OpenBSD: expr.c,v 1.12 2002/02/16 21:27:48 millert Exp $	*/
+/*	$NetBSD: expr.c,v 1.7 1995/09/28 05:37:31 tls Exp $	*/
+
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
@@ -35,11 +38,20 @@
  */
 
 #ifndef lint
+#if 0
 static char sccsid[] = "@(#)expr.c	8.2 (Berkeley) 4/29/95";
+#else
+static char rcsid[] = "$OpenBSD: expr.c,v 1.12 2002/02/16 21:27:48 millert Exp $";
+#endif
 #endif /* not lint */
 
 #include <sys/cdefs.h>
+#include <ctype.h>
+#include <err.h>
+#include <stddef.h>
 #include <stdio.h>
+#include "mdef.h"
+#include "extern.h"
 
 /*
  *      expression evaluator: performs a standard recursive
@@ -85,9 +97,6 @@ static char sccsid[] = "@(#)expr.c	8.2 (Berkeley) 4/29/95";
  *                      Bob Harper
  */
 
-#define TRUE    1
-#define FALSE   0
-#define EOS     (char) 0
 #define EQL     0
 #define NEQ     1
 #define LSS     2
@@ -96,25 +105,27 @@ static char sccsid[] = "@(#)expr.c	8.2 (Berkeley) 4/29/95";
 #define GEQ     5
 #define OCTAL   8
 #define DECIMAL 10
-
-static char *nxtch;		       /* Parser scan pointer */
-
-static int query __P((void));
-static int lor __P((void));
-static int land __P((void));
-static int not __P((void));
-static int eqrel __P((void));
-static int shift __P((void));
-static int primary __P((void));
-static int term __P((void));
-static int exp __P((void));
-static int unary __P((void));
-static int factor __P((void));
-static int constant __P((void));
-static int num __P((void));
-static int geteqrel __P((void));
-static int skipws __P((void));
-static void experr __P((char *));
+#define HEX	16
+
+static const char *nxtch;		       /* Parser scan pointer */
+static const char *where;
+
+static int query(void);
+static int lor(void);
+static int land(void);
+static int not(void);
+static int eqrel(void);
+static int shift(void);
+static int primary(void);
+static int term(void);
+static int exp(void);
+static int unary(void);
+static int factor(void);
+static int constant(void);
+static int num(void);
+static int geteqrel(void);
+static int skipws(void);
+static void experr(const char *);
 
 /*
  * For longjmp
@@ -132,11 +143,12 @@ static jmp_buf expjump;
 
 int
 expr(expbuf)
-char *expbuf;
+	const char *expbuf;
 {
-	register int rval;
+	int rval;
 
 	nxtch = expbuf;
+	where = expbuf;
 	if (setjmp(expjump) != 0)
 		return FALSE;
 
@@ -154,7 +166,7 @@ char *expbuf;
 static int
 query()
 {
-	register int bool, true_val, false_val;
+	int bool, true_val, false_val;
 
 	bool = lor();
 	if (skipws() != '?') {
@@ -176,7 +188,7 @@ query()
 static int
 lor()
 {
-	register int c, vl, vr;
+	int c, vl, vr;
 
 	vl = land();
 	while ((c = skipws()) == '|') {
@@ -196,7 +208,7 @@ lor()
 static int
 land()
 {
-	register int c, vl, vr;
+	int c, vl, vr;
 
 	vl = not();
 	while ((c = skipws()) == '&') {
@@ -216,7 +228,7 @@ land()
 static int
 not()
 {
-	register int val, c;
+	int val, c;
 
 	if ((c = skipws()) == '!' && getch() != '=') {
 		ungetch();
@@ -236,7 +248,7 @@ not()
 static int
 eqrel()
 {
-	register int vl, vr, eqrel;
+	int vl, vr, eqrel;
 
 	vl = shift();
 	while ((eqrel = geteqrel()) != -1) {
@@ -274,7 +286,7 @@ eqrel()
 static int
 shift()
 {
-	register int vl, vr, c;
+	int vl, vr, c;
 
 	vl = primary();
 	while (((c = skipws()) == '<' || c == '>') && getch() == c) {
@@ -298,7 +310,7 @@ shift()
 static int
 primary()
 {
-	register int c, vl, vr;
+	int c, vl, vr;
 
 	vl = term();
 	while ((c = skipws()) == '+' || c == '-') {
@@ -320,7 +332,7 @@ primary()
 static int
 term()
 {
-	register int c, vl, vr;
+	int c, vl, vr;
 
 	vl = exp();
 	while ((c = skipws()) == '*' || c == '/' || c == '%') {
@@ -331,10 +343,16 @@ term()
 			vl *= vr;
 			break;
 		case '/':
-			vl /= vr;
+			if (vr == 0)
+				errx(1, "division by zero in eval.");
+			else
+				vl /= vr;
 			break;
 		case '%':
-			vl %= vr;
+			if (vr == 0)
+				errx(1, "modulo zero in eval.");
+			else
+				vl %= vr;
 			break;
 		}
 	}
@@ -348,7 +366,7 @@ term()
 static int
 exp()
 {
-	register c, vl, vr, n;
+	int c, vl, vr, n;
 
 	vl = unary();
 	switch (c = skipws()) {
@@ -377,7 +395,7 @@ exp()
 static int
 unary()
 {
-	register int val, c;
+	int val, c;
 
 	if ((c = skipws()) == '+' || c == '-' || c == '~') {
 		val = unary();
@@ -402,7 +420,7 @@ unary()
 static int
 factor()
 {
-	register int val;
+	int val;
 
 	if (skipws() == '(') {
 		val = query();
@@ -422,9 +440,9 @@ factor()
 static int
 constant()
 {
-	register int i;
-	register int value;
-	register char c;
+	int i;
+	int value;
+	int c;
 	int v[sizeof(int)];
 
 	if (skipws() != '\'') {
@@ -483,25 +501,56 @@ constant()
 static int
 num()
 {
-	register int rval, c, base;
+	int rval, c, base;
 	int ndig;
 
-	base = ((c = skipws()) == '0') ? OCTAL : DECIMAL;
 	rval = 0;
 	ndig = 0;
-	while (c >= '0' && c <= (base == OCTAL ? '7' : '9')) {
-		rval *= base;
-		rval += (c - '0');
+	c = skipws();
+	if (c == '0') {
+		c = skipws();
+		if (c == 'x' || c == 'X') {
+			base = HEX;
+			c = skipws();
+		} else {
+			base = OCTAL;
+			ndig++;
+		}
+	} else
+		base = DECIMAL;
+	for(;;) {
+		switch(c) {
+			case '8': case '9':
+				if (base == OCTAL) 
+					goto bad_digit;
+				/*FALLTHRU*/
+			case '0': case '1': case '2': case '3': 
+			case '4': case '5': case '6': case '7':
+				rval *= base;
+				rval += c - '0';
+				break;
+			case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+				c = tolower(c);
+			case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+				if (base == HEX) {
+					rval *= base;
+					rval += c - 'a' + 10;
+					break;
+				}
+				/*FALLTHRU*/
+			default:
+				goto bad_digit;
+		}
 		c = getch();
 		ndig++;
 	}
+bad_digit:
 	ungetch();
 	
 	if (ndig == 0)
 		experr("bad constant");
 	
 	return rval;
-
 }
 
 /*
@@ -510,7 +559,7 @@ num()
 static int
 geteqrel()
 {
-	register int c1, c2;
+	int c1, c2;
 
 	c1 = skipws();
 	c2 = getch();
@@ -554,7 +603,7 @@ geteqrel()
 static int
 skipws()
 {
-	register char c;
+	int c;
 
 	while ((c = getch()) <= ' ' && c > EOS)
 		;
@@ -567,8 +616,8 @@ skipws()
  */
 static void
 experr(msg)
-char *msg;
+	const char *msg;
 {
-	printf("m4: %s in expr.\n", msg);
+	printf("m4: %s in expr %s.\n", msg, where);
 	longjmp(expjump, -1);
 }
diff --git a/usr.bin/m4/extern.h b/usr.bin/m4/extern.h
index b54a9b9..9170fa8 100644
--- a/usr.bin/m4/extern.h
+++ b/usr.bin/m4/extern.h
@@ -1,3 +1,6 @@
+/*	$OpenBSD: extern.h,v 1.29 2002/02/16 21:27:48 millert Exp $	*/
+/*	$NetBSD: extern.h,v 1.3 1996/01/13 23:25:24 pk Exp $	*/
+
 /*-
  * Copyright (c) 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
@@ -36,61 +39,114 @@
  *	@(#)extern.h	8.1 (Berkeley) 6/6/93
  */
 
-char	*basename __P((char *));
-char	*xalloc __P((unsigned long));
-int	expr __P((char *));
-ndptr	addent __P((char *));
-void	chrsave __P((int));
-void	dochc __P((char *[], int));
-void	dochq __P((char *[], int));
-void	dodefine __P((char *, char *));
-void	dodefn __P((char *));
-void	dodiv __P((int));
-void	dodump __P((char *[], int));
-void	doifelse __P((char *[], int));
-int	doincl __P((char *));
-int	dopaste __P((char *));
-void	dopushdef __P((char *, char *));
-void	dosub __P((char *[], int));
-void	doundiv __P((char *[], int));
-void	eval __P((char *[], int, int));
-void	expand __P((char *[], int));
-void	getdiv __P((int));
-char	*xstrdup __P((const char *));
-int	hash __P((char *));
-int	indx __P((char *, char *));
-void	killdiv __P((void));
-ndptr	lookup __P((char *));
-void	map __P((char *, char *, char *, char *));
-void	onintr __P((int));
-void	oops __P((const char *, ...));
-void	pbnum __P((int));
-void	pbstr __P((char *));
-void	putback __P((int));
-void	remhash __P((char *, int));
-void	usage __P((void));
+/* eval.c */
+extern void	eval(const char *[], int, int);
+extern void	dodefine(const char *, const char *);
+extern unsigned long expansion_id;
+
+/* expr.c */
+extern int	expr(const char *);
+
+/* gnum4.c */
+extern void 	addtoincludepath(const char *);
+extern struct input_file *fopen_trypath(struct input_file *, const char *);
+extern void doindir(const char *[], int);
+extern void dobuiltin(const char *[], int);
+extern void dopatsubst(const char *[], int);
+extern void doregexp(const char *[], int);
+
+extern void doprintlineno(struct input_file *);
+extern void doprintfilename(struct input_file *);
+
+extern void doesyscmd(const char *);
+ 
+
+/* look.c */
+extern ndptr	addent(const char *);
+extern unsigned	hash(const char *);
+extern ndptr	lookup(const char *);
+extern void	remhash(const char *, int);
+
+/* main.c */
+extern void outputstr(const char *);
+extern int builtin_type(const char *);
+extern char *builtin_realname(int);
+
+/* misc.c */
+extern void	chrsave(int);
+extern char 	*compute_prevep(void);
+extern void	getdiv(int);
+extern ptrdiff_t indx(const char *, const char *);
+extern void 	initspaces(void);
+extern void	killdiv(void);
+extern void	onintr(int);
+extern void	pbnum(int);
+extern void	pbunsigned(unsigned long);
+extern void	pbstr(const char *);
+extern void	putback(int);
+extern void	*xalloc(size_t);
+extern char	*xstrdup(const char *);
+extern void	usage(void);
+extern void	resizedivs(int);
+extern size_t	buffer_mark(void);
+extern void	dump_buffer(FILE *, size_t);
+
+extern int 	obtain_char(struct input_file *);
+extern void	set_input(struct input_file *, FILE *, const char *);
+extern void	release_input(struct input_file *);
+
+/* speeded-up versions of chrsave/putback */
+#define PUTBACK(c)				\
+	do {					\
+		if (bp >= endpbb)		\
+			enlarge_bufspace();	\
+		*bp++ = (c);			\
+	} while(0)
+	
+#define CHRSAVE(c)				\
+	do {					\
+		if (ep >= endest)		\
+			enlarge_strspace();	\
+		*ep++ = (c);			\
+	} while(0)
+
+/* and corresponding exposure for local symbols */
+extern void enlarge_bufspace(void);
+extern void enlarge_strspace(void);
+extern char *endpbb;
+extern char *endest;
+
+/* trace.c */
+extern void mark_traced(const char *, int);
+extern int is_traced(const char *);
+extern void trace_file(const char *);
+extern ssize_t trace(const char **, int, struct input_file *);
+extern void finish_trace(size_t);
+extern int traced_macros;
+extern void set_trace_flags(const char *);
+extern FILE *traceout;
 
 extern ndptr hashtab[];		/* hash table for macros etc. */
-extern stae mstack[];		/* stack of m4 machine */
+extern stae *mstack;		/* stack of m4 machine */
+extern char *sstack;		/* shadow stack, for string space extension */
 extern FILE *active;		/* active output file pointer */
-extern FILE *infile[];		/* input file stack (0=stdin) */
-extern FILE *outfile[];		/* diversion array(0=bitbucket) */
+extern struct input_file infile[];/* input file stack (0=stdin) */
+extern FILE **outfile;		/* diversion array(0=bitbucket) */
+extern int maxout;		/* maximum number of diversions */
 extern int fp; 			/* m4 call frame pointer */
 extern int ilevel;		/* input file stack pointer */
 extern int oindex;		/* diversion index. */
 extern int sp;			/* current m4 stack pointer */
 extern char *bp;		/* first available character */
-extern char buf[];		/* push-back buffer */
+extern char *buf;		/* push-back buffer */
 extern char *bufbase;		/* buffer base for this ilevel */
 extern char *bbase[];		/* buffer base per ilevel */
-extern char ecommt;		/* end character for comment */
-extern char *endest;		/* end of string space */
-extern char *endpbb;		/* end of push-back buffer */
+extern char ecommt[MAXCCHARS+1];/* end character for comment */
 extern char *ep;		/* first free char in strspace */
-extern char lquote;		/* left quote character (`) */
-extern char *m4temp;		/* filename for diversions */
+extern char lquote[MAXCCHARS+1];/* left quote character (`) */
 extern char *m4wraps;		/* m4wrap string default. */
 extern char *null;		/* as it says.. just a null. */
-extern char *progname;		/* program name */
-extern char rquote;		/* right quote character (') */
-extern char scommt;		/* start character for comment */
+extern char rquote[MAXCCHARS+1];/* right quote character (') */
+extern char scommt[MAXCCHARS+1];/* start character for comment */
+
+extern int mimic_gnu;		/* behaves like gnu-m4 */
diff --git a/usr.bin/m4/gnum4.c b/usr.bin/m4/gnum4.c
new file mode 100644
index 0000000..782090d
--- /dev/null
+++ b/usr.bin/m4/gnum4.c
@@ -0,0 +1,563 @@
+/* $OpenBSD: gnum4.c,v 1.16 2002/02/16 21:27:48 millert Exp $ */
+
+/*
+ * Copyright (c) 1999 Marc Espie
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* 
+ * functions needed to support gnu-m4 extensions, including a fake freezing
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <ctype.h>
+#include <paths.h>
+#include <regex.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <err.h>
+#include <errno.h>
+#include <unistd.h>
+#include "mdef.h"
+#include "stdd.h"
+#include "extern.h"
+
+
+int mimic_gnu = 0;
+
+/*
+ * Support for include path search
+ * First search in the the current directory.
+ * If not found, and the path is not absolute, include path kicks in.
+ * First, -I options, in the order found on the command line.
+ * Then M4PATH env variable
+ */
+
+struct path_entry {
+	char *name;
+	struct path_entry *next;
+} *first, *last;
+
+static struct path_entry *new_path_entry(const char *);
+static void ensure_m4path(void);
+static struct input_file *dopath(struct input_file *, const char *);
+
+static struct path_entry *
+new_path_entry(dirname)
+	const char *dirname;
+{
+	struct path_entry *n;
+
+	n = malloc(sizeof(struct path_entry));
+	if (!n)
+		errx(1, "out of memory");
+	n->name = strdup(dirname);
+	if (!n->name)
+		errx(1, "out of memory");
+	n->next = 0;
+	return n;
+}
+	
+void 
+addtoincludepath(dirname)
+	const char *dirname;
+{
+	struct path_entry *n;
+
+	n = new_path_entry(dirname);
+
+	if (last) {
+		last->next = n;
+		last = n;
+	}
+	else
+		last = first = n;
+}
+
+static void
+ensure_m4path()
+{
+	static int envpathdone = 0;
+	char *envpath;
+	char *sweep;
+	char *path;
+
+	if (envpathdone)
+		return;
+	envpathdone = TRUE;
+	envpath = getenv("M4PATH");
+	if (!envpath) 
+		return;
+	/* for portability: getenv result is read-only */
+	envpath = strdup(envpath);
+	if (!envpath)
+		errx(1, "out of memory");
+	for (sweep = envpath; 
+	    (path = strsep(&sweep, ":")) != NULL;)
+	    addtoincludepath(path);
+	free(envpath);
+}
+
+static
+struct input_file *
+dopath(i, filename)
+	struct input_file *i;
+	const char *filename;
+{
+	char path[MAXPATHLEN];
+	struct path_entry *pe;
+	FILE *f;
+
+	for (pe = first; pe; pe = pe->next) {
+		snprintf(path, sizeof(path), "%s/%s", pe->name, filename);
+		if ((f = fopen(path, "r")) != 0) {
+			set_input(i, f, path);
+			return i;
+		}
+	}
+	return NULL;
+}
+
+struct input_file *
+fopen_trypath(i, filename)
+	struct input_file *i;
+	const char *filename;
+{
+	FILE *f;
+
+	f = fopen(filename, "r");
+	if (f != NULL) {
+		set_input(i, f, filename);
+		return i;
+	}
+	if (filename[0] == '/')
+		return NULL;
+
+	ensure_m4path();
+
+	return dopath(i, filename);
+}
+
+void 
+doindir(argv, argc)
+	const char *argv[];
+	int argc;
+{
+	ndptr p;
+
+	p = lookup(argv[2]);
+	if (p == NULL)
+		errx(1, "undefined macro %s", argv[2]);
+	argv[1] = p->defn;
+	eval(argv+1, argc-1, p->type);
+}
+
+void 
+dobuiltin(argv, argc)
+	const char *argv[];
+	int argc;
+{
+	int n;
+	argv[1] = NULL;
+	n = builtin_type(argv[2]);
+	if (n != -1)
+		eval(argv+1, argc-1, n);
+	else
+		errx(1, "unknown builtin %s", argv[2]);
+} 
+
+
+/* We need some temporary buffer space, as pb pushes BACK and substitution
+ * proceeds forward... */
+static char *buffer;
+static size_t bufsize = 0;
+static size_t current = 0;
+
+static void addchars(const char *, size_t);
+static void addchar(char);
+static char *twiddle(const char *);
+static char *getstring(void);
+static void exit_regerror(int, regex_t *);
+static void do_subst(const char *, regex_t *, const char *, regmatch_t *);
+static void do_regexpindex(const char *, regex_t *, regmatch_t *);
+static void do_regexp(const char *, regex_t *, const char *, regmatch_t *);
+static void add_sub(int, const char *, regex_t *, regmatch_t *);
+static void add_replace(const char *, regex_t *, const char *, regmatch_t *);
+#define addconstantstring(s) addchars((s), sizeof(s)-1)
+
+static void 
+addchars(c, n)
+	const char *c;
+	size_t n;
+{
+	if (n == 0)
+		return;
+	while (current + n > bufsize) {
+		if (bufsize == 0)
+			bufsize = 1024;
+		else
+			bufsize *= 2;
+		buffer = realloc(buffer, bufsize);
+		if (buffer == NULL)
+			errx(1, "out of memory");
+	}
+	memcpy(buffer+current, c, n);
+	current += n;
+}
+
+static void 
+addchar(c)
+	char c;
+{
+	if (current +1 > bufsize) {
+		if (bufsize == 0)
+			bufsize = 1024;
+		else
+			bufsize *= 2;
+		buffer = realloc(buffer, bufsize);
+		if (buffer == NULL)
+			errx(1, "out of memory");
+	}
+	buffer[current++] = c;
+}
+
+static char *
+getstring()
+{
+	addchar('\0');
+	current = 0;
+	return buffer;
+}
+
+
+static void 
+exit_regerror(er, re)
+	int er;
+	regex_t *re;
+{
+	size_t 	errlen;
+	char 	*errbuf;
+
+	errlen = regerror(er, re, NULL, 0);
+	errbuf = xalloc(errlen);
+	regerror(er, re, errbuf, errlen);
+	errx(1, "regular expression error: %s", errbuf);
+}
+
+static void
+add_sub(n, string, re, pm)
+	int n;
+	const char *string;
+	regex_t *re;
+	regmatch_t *pm;
+{
+	if (n > re->re_nsub)
+		warnx("No subexpression %d", n);
+	/* Subexpressions that did not match are
+	 * not an error.  */
+	else if (pm[n].rm_so != -1 &&
+	    pm[n].rm_eo != -1) {
+		addchars(string + pm[n].rm_so,
+			pm[n].rm_eo - pm[n].rm_so);
+	}
+}
+
+/* Add replacement string to the output buffer, recognizing special
+ * constructs and replacing them with substrings of the original string.
+ */
+static void 
+add_replace(string, re, replace, pm)
+	const char *string;
+	regex_t *re;
+	const char *replace;
+	regmatch_t *pm;
+{
+	const char *p;
+
+	for (p = replace; *p != '\0'; p++) {
+		if (*p == '&' && !mimic_gnu) {
+			add_sub(0, string, re, pm);
+			continue;
+		}
+		if (*p == '\\') {
+			if (p[1] == '\\') {
+				addchar(p[1]);
+				p++;
+				continue;
+			}
+			if (p[1] == '&') {
+				if (mimic_gnu)
+					add_sub(0, string, re, pm);
+				else
+					addchar(p[1]);
+				p++;
+				continue;
+			}
+			if (isdigit(p[1])) {
+				add_sub(*(++p) - '0', string, re, pm);
+				continue;
+			}
+		}
+	    	addchar(*p);
+	}
+}
+
+static void 
+do_subst(string, re, replace, pm)
+	const char *string;
+	regex_t *re;
+	const char *replace;
+	regmatch_t *pm;
+{
+	int error;
+	int flags = 0;
+	const char *last_match = NULL;
+
+	while ((error = regexec(re, string, re->re_nsub+1, pm, flags)) == 0) {
+		if (pm[0].rm_eo != 0) {
+			if (string[pm[0].rm_eo-1] == '\n')
+				flags = 0;
+			else
+				flags = REG_NOTBOL;
+		}
+
+		/* NULL length matches are special... We use the `vi-mode' 
+		 * rule: don't allow a NULL-match at the last match
+		 * position. 
+		 */
+		if (pm[0].rm_so == pm[0].rm_eo && 
+		    string + pm[0].rm_so == last_match) {
+			if (*string == '\0')
+				return;
+			addchar(*string);
+			if (*string++ == '\n')
+				flags = 0;
+			else
+				flags = REG_NOTBOL;
+			continue;
+		}
+		last_match = string + pm[0].rm_so;
+		addchars(string, pm[0].rm_so);
+		add_replace(string, re, replace, pm);
+		string += pm[0].rm_eo;
+	}
+	if (error != REG_NOMATCH)
+		exit_regerror(error, re);
+	pbstr(string);
+}
+
+static void 
+do_regexp(string, re, replace, pm)
+	const char *string;
+	regex_t *re;
+	const char *replace;
+	regmatch_t *pm;
+{
+	int error;
+
+	switch(error = regexec(re, string, re->re_nsub+1, pm, 0)) {
+	case 0: 
+		add_replace(string, re, replace, pm);
+		pbstr(getstring());
+		break;
+	case REG_NOMATCH:
+		break;
+	default:
+		exit_regerror(error, re);
+	}
+}
+
+static void 
+do_regexpindex(string, re, pm)
+	const char *string;
+	regex_t *re;
+	regmatch_t *pm;
+{
+	int error;
+
+	switch(error = regexec(re, string, re->re_nsub+1, pm, 0)) {
+	case 0:
+		pbunsigned(pm[0].rm_so);
+		break;
+	case REG_NOMATCH:
+		pbnum(-1);
+		break;
+	default:
+		exit_regerror(error, re);
+	}
+}
+
+/* In Gnu m4 mode, parentheses for backmatch don't work like POSIX 1003.2
+ * says. So we twiddle with the regexp before passing it to regcomp.
+ */
+static char *
+twiddle(p)
+	const char *p;
+{
+	/* This could use strcspn for speed... */
+	while (*p != '\0') {
+		if (*p == '\\') {
+			switch(p[1]) {
+			case '(':
+			case ')':
+			case '|':
+				addchar(p[1]);
+				break;
+			case 'w':
+				addconstantstring("[_a-zA-Z0-9]");
+				break;
+			case 'W':
+				addconstantstring("[^_a-zA-Z0-9]");
+				break;
+			case '<':
+				addconstantstring("[[:<:]]");
+				break;
+			case '>':
+				addconstantstring("[[:>:]]");
+				break;
+			default:
+				addchars(p, 2);
+				break;
+			}
+			p+=2;
+			continue;
+		}
+		if (*p == '(' || *p == ')' || *p == '|')
+			addchar('\\');
+
+		addchar(*p);
+		p++;
+	}
+	return getstring();
+}
+
+/* patsubst(string, regexp, opt replacement) */
+/* argv[2]: string
+ * argv[3]: regexp
+ * argv[4]: opt rep
+ */
+void
+dopatsubst(argv, argc)
+	const char *argv[];
+	int argc;
+{
+	int error;
+	regex_t re;
+	regmatch_t *pmatch;
+
+	if (argc <= 3) {
+		warnx("Too few arguments to patsubst");
+		return;
+	}
+	error = regcomp(&re, mimic_gnu ? twiddle(argv[3]) : argv[3], 
+	    REG_NEWLINE | REG_EXTENDED);
+	if (error != 0)
+		exit_regerror(error, &re);
+	
+	pmatch = xalloc(sizeof(regmatch_t) * (re.re_nsub+1));
+	do_subst(argv[2], &re, 
+	    argc != 4 && argv[4] != NULL ? argv[4] : "", pmatch);
+	pbstr(getstring());
+	free(pmatch);
+	regfree(&re);
+}
+
+void
+doregexp(argv, argc)
+	const char *argv[];
+	int argc;
+{
+	int error;
+	regex_t re;
+	regmatch_t *pmatch;
+
+	if (argc <= 3) {
+		warnx("Too few arguments to regexp");
+		return;
+	}
+	error = regcomp(&re, mimic_gnu ? twiddle(argv[3]) : argv[3], 
+	    REG_EXTENDED);
+	if (error != 0)
+		exit_regerror(error, &re);
+	
+	pmatch = xalloc(sizeof(regmatch_t) * (re.re_nsub+1));
+	if (argv[4] == NULL || argc == 4)
+		do_regexpindex(argv[2], &re, pmatch);
+	else
+		do_regexp(argv[2], &re, argv[4], pmatch);
+	free(pmatch);
+	regfree(&re);
+}
+
+void
+doesyscmd(cmd)
+	const char *cmd;
+{
+	int p[2];
+	pid_t pid, cpid;
+	char *argv[4];
+	int cc;
+	int status;
+
+	/* Follow gnu m4 documentation: first flush buffers. */
+	fflush(NULL);
+
+	argv[0] = "sh";
+	argv[1] = "-c";
+	argv[2] = (char *)cmd;
+	argv[3] = NULL;
+
+	/* Just set up standard output, share stderr and stdin with m4 */
+	if (pipe(p) == -1)
+		err(1, "bad pipe");
+	switch(cpid = fork()) {
+	case -1:
+		err(1, "bad fork");
+		/* NOTREACHED */
+	case 0:
+		(void) close(p[0]);
+		(void) dup2(p[1], 1);
+		(void) close(p[1]);
+		execv(_PATH_BSHELL, argv);
+		exit(1);
+	default:
+		/* Read result in two stages, since m4's buffer is
+		 * pushback-only. */
+		(void) close(p[1]);
+		do {
+			char result[BUFSIZE];
+			cc = read(p[0], result, sizeof result);
+			if (cc > 0)
+				addchars(result, cc);
+		} while (cc > 0 || (cc == -1 && errno == EINTR));
+
+		(void) close(p[0]);
+		while ((pid = wait(&status)) != cpid && pid >= 0)
+			continue;
+		pbstr(getstring());
+	}
+}
diff --git a/usr.bin/m4/look.c b/usr.bin/m4/look.c
index 7c750b0..ffb58e0 100644
--- a/usr.bin/m4/look.c
+++ b/usr.bin/m4/look.c
@@ -1,3 +1,5 @@
+/*	$OpenBSD: look.c,v 1.9 2002/02/16 21:27:48 millert Exp $	*/
+
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
@@ -47,19 +49,22 @@ static char sccsid[] = "@(#)look.c	8.1 (Berkeley) 6/6/93";
 #include <sys/types.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <stddef.h>
 #include <string.h>
 #include "mdef.h"
 #include "stdd.h"
 #include "extern.h"
 
-int
+static void freent(ndptr);
+
+unsigned
 hash(name)
-register char *name;
+	const char *name;
 {
-	register unsigned long h = 0;
+	unsigned int h = 0;
 	while (*name)
 		h = (h << 5) + h + *name++;
-	return (h % HASHSIZE);
+	return (h);
 }
 
 /*
@@ -67,12 +72,14 @@ register char *name;
  */
 ndptr 
 lookup(name)
-char *name;
+	const char *name;
 {
-	register ndptr p;
+	ndptr p;
+	unsigned int h;
 
-	for (p = hashtab[hash(name)]; p != nil; p = p->nxtptr)
-		if (STREQ(name, p->name))
+	h = hash(name);
+	for (p = hashtab[h % HASHSIZE]; p != nil; p = p->nxtptr)
+		if (h == p->hv && STREQ(name, p->name))
 			break;
 	return (p);
 }
@@ -83,28 +90,27 @@ char *name;
  */
 ndptr 
 addent(name)
-char *name;
+	const char *name;
 {
-	register int h;
+	unsigned int h;
 	ndptr p;
 
 	h = hash(name);
 	p = (ndptr) xalloc(sizeof(struct ndblock));
-	p->nxtptr = hashtab[h];
-	hashtab[h] = p;
+	p->nxtptr = hashtab[h % HASHSIZE];
+	hashtab[h % HASHSIZE] = p;
 	p->name = xstrdup(name);
+	p->hv = h;
 	return p;
 }
 
 static void
 freent(p)
-ndptr p;
+	ndptr p;
 {
-	if (!(p->type & STATIC)) {
-		free((char *) p->name);
-		if (p->defn != null)
-			free((char *) p->defn);
-	}
+	free((char *) p->name);
+	if (p->defn != null)
+		free((char *) p->defn);
 	free((char *) p);
 }
 
@@ -113,21 +119,21 @@ ndptr p;
  */
 void
 remhash(name, all)
-char *name;
-int all;
+	const char *name;
+	int all;
 {
-	register int h;
-	register ndptr xp, tp, mp;
+	unsigned int h;
+	ndptr xp, tp, mp;
 
 	h = hash(name);
-	mp = hashtab[h];
+	mp = hashtab[h % HASHSIZE];
 	tp = nil;
 	while (mp != nil) {
-		if (STREQ(mp->name, name)) {
+		if (mp->hv == h && STREQ(mp->name, name)) {
 			mp = mp->nxtptr;
 			if (tp == nil) {
-				freent(hashtab[h]);
-				hashtab[h] = mp;
+				freent(hashtab[h % HASHSIZE]);
+				hashtab[h % HASHSIZE] = mp;
 			}
 			else {
 				xp = tp->nxtptr;
diff --git a/usr.bin/m4/main.c b/usr.bin/m4/main.c
index 221b865..644b897 100644
--- a/usr.bin/m4/main.c
+++ b/usr.bin/m4/main.c
@@ -1,3 +1,6 @@
+/*	$OpenBSD: main.c,v 1.52 2002/02/16 21:27:48 millert Exp $	*/
+/*	$NetBSD: main.c,v 1.12 1997/02/08 23:54:49 cgd Exp $	*/
+
 /*-
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
@@ -41,7 +44,11 @@ static char copyright[] =
 #endif /* not lint */
 
 #ifndef lint
+#if 0
 static char sccsid[] = "@(#)main.c	8.1 (Berkeley) 6/6/93";
+#else
+static char rcsid[] = "$OpenBSD: main.c,v 1.52 2002/02/16 21:27:48 millert Exp $";
+#endif
 #endif /* not lint */
 
 /*
@@ -51,85 +58,92 @@ static char sccsid[] = "@(#)main.c	8.1 (Berkeley) 6/6/93";
  */
 
 #include <sys/types.h>
+#include <assert.h>
 #include <signal.h>
 #include <errno.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <err.h>
 #include "mdef.h"
 #include "stdd.h"
 #include "extern.h"
 #include "pathnames.h"
 
 ndptr hashtab[HASHSIZE];	/* hash table for macros etc.  */
-char buf[BUFSIZE];		/* push-back buffer	       */
-char *bufbase = buf;		/* the base for current ilevel */
-char *bbase[MAXINP];		/* the base for each ilevel    */
-char *bp = buf; 		/* first available character   */
-char *endpbb = buf+BUFSIZE;	/* end of push-back buffer     */
-stae mstack[STACKMAX+1]; 	/* stack of m4 machine         */
-char strspace[STRSPMAX+1];	/* string space for evaluation */
-char *ep = strspace;		/* first free char in strspace */
-char *endest= strspace+STRSPMAX;/* end of string space	       */
+stae *mstack;		 	/* stack of m4 machine         */
+char *sstack;		 	/* shadow stack, for string space extension */
+static size_t STACKMAX;		/* current maximum size of stack */
 int sp; 			/* current m4  stack pointer   */
 int fp; 			/* m4 call frame pointer       */
-FILE *infile[MAXINP];		/* input file stack (0=stdin)  */
-FILE *outfile[MAXOUT];		/* diversion array(0=bitbucket)*/
+struct input_file infile[MAXINP];/* input file stack (0=stdin)  */
+FILE **outfile;			/* diversion array(0=bitbucket)*/
+int maxout;
 FILE *active;			/* active output file pointer  */
-char *m4temp;			/* filename for diversions     */
 int ilevel = 0; 		/* input file stack pointer    */
 int oindex = 0; 		/* diversion index..	       */
 char *null = "";                /* as it says.. just a null..  */
 char *m4wraps = "";             /* m4wrap string default..     */
-char *progname;			/* name of this program        */
-char lquote = LQUOTE;		/* left quote character  (`)   */
-char rquote = RQUOTE;		/* right quote character (')   */
-char scommt = SCOMMT;		/* start character for comment */
-char ecommt = ECOMMT;		/* end character for comment   */
+char lquote[MAXCCHARS+1] = {LQUOTE};	/* left quote character  (`)   */
+char rquote[MAXCCHARS+1] = {RQUOTE};	/* right quote character (')   */
+char scommt[MAXCCHARS+1] = {SCOMMT};	/* start character for comment */
+char ecommt[MAXCCHARS+1] = {ECOMMT};	/* end character for comment   */
 
 struct keyblk keywrds[] = {	/* m4 keywords to be installed */
-	"include",      INCLTYPE,
-	"sinclude",     SINCTYPE,
-	"define",       DEFITYPE,
-	"defn",         DEFNTYPE,
-	"divert",       DIVRTYPE,
-	"expr",         EXPRTYPE,
-	"eval",         EXPRTYPE,
-	"substr",       SUBSTYPE,
-	"ifelse",       IFELTYPE,
-	"ifdef",        IFDFTYPE,
-	"len",          LENGTYPE,
-	"incr",         INCRTYPE,
-	"decr",         DECRTYPE,
-	"dnl",          DNLNTYPE,
-	"changequote",  CHNQTYPE,
-	"changecom",    CHNCTYPE,
-	"index",        INDXTYPE,
+	{ "include",      INCLTYPE },
+	{ "sinclude",     SINCTYPE },
+	{ "define",       DEFITYPE },
+	{ "defn",         DEFNTYPE },
+	{ "divert",       DIVRTYPE | NOARGS },
+	{ "expr",         EXPRTYPE },
+	{ "eval",         EXPRTYPE },
+	{ "substr",       SUBSTYPE },
+	{ "ifelse",       IFELTYPE },
+	{ "ifdef",        IFDFTYPE },
+	{ "len",          LENGTYPE },
+	{ "incr",         INCRTYPE },
+	{ "decr",         DECRTYPE },
+	{ "dnl",          DNLNTYPE | NOARGS },
+	{ "changequote",  CHNQTYPE | NOARGS },
+	{ "changecom",    CHNCTYPE | NOARGS },
+	{ "index",        INDXTYPE },
 #ifdef EXTENDED
-	"paste",        PASTTYPE,
-	"spaste",       SPASTYPE,
+	{ "paste",        PASTTYPE },
+	{ "spaste",       SPASTYPE },
+    	/* Newer extensions, needed to handle gnu-m4 scripts */
+	{ "indir",        INDIRTYPE},
+	{ "builtin",      BUILTINTYPE},
+	{ "patsubst",	  PATSTYPE},
+	{ "regexp",	  REGEXPTYPE},
+	{ "esyscmd",	  ESYSCMDTYPE},
+	{ "__file__",	  FILENAMETYPE | NOARGS},
+	{ "__line__",	  LINETYPE | NOARGS},
 #endif
-	"popdef",       POPDTYPE,
-	"pushdef",      PUSDTYPE,
-	"dumpdef",      DUMPTYPE,
-	"shift",        SHIFTYPE,
-	"translit",     TRNLTYPE,
-	"undefine",     UNDFTYPE,
-	"undivert",     UNDVTYPE,
-	"divnum",       DIVNTYPE,
-	"maketemp",     MKTMTYPE,
-	"errprint",     ERRPTYPE,
-	"m4wrap",       M4WRTYPE,
-	"m4exit",       EXITTYPE,
-	"syscmd",       SYSCTYPE,
-	"sysval",       SYSVTYPE,
-
-#ifdef unix
-	"unix",         MACRTYPE,
+	{ "popdef",       POPDTYPE },
+	{ "pushdef",      PUSDTYPE },
+	{ "dumpdef",      DUMPTYPE | NOARGS },
+	{ "shift",        SHIFTYPE | NOARGS },
+	{ "translit",     TRNLTYPE },
+	{ "undefine",     UNDFTYPE },
+	{ "undivert",     UNDVTYPE | NOARGS },
+	{ "divnum",       DIVNTYPE | NOARGS },
+	{ "maketemp",     MKTMTYPE },
+	{ "errprint",     ERRPTYPE | NOARGS },
+	{ "m4wrap",       M4WRTYPE | NOARGS },
+	{ "m4exit",       EXITTYPE | NOARGS },
+	{ "syscmd",       SYSCTYPE },
+	{ "sysval",       SYSVTYPE | NOARGS },
+	{ "traceon",	  TRACEONTYPE | NOARGS },
+	{ "traceoff",	  TRACEOFFTYPE | NOARGS },
+
+#if defined(unix) || defined(__unix__) 
+	{ "unix",         SELFTYPE | NOARGS },
 #else
 #ifdef vms
-	"vms",          MACRTYPE,
+	{ "vms",          SELFTYPE | NOARGS },
 #endif
 #endif
 };
@@ -139,28 +153,48 @@ struct keyblk keywrds[] = {	/* m4 keywords to be installed */
 extern int optind;
 extern char *optarg;
 
-void macro();
-void initkwds();
-extern int getopt();
+#define MAXRECORD 50
+static struct position {
+	char *name;
+	unsigned long line;
+} quotes[MAXRECORD], paren[MAXRECORD];
+
+static void record(struct position *, int);
+static void dump_stack(struct position *, int);
+
+static void macro(void);
+static void initkwds(void);
+static ndptr inspect(int, char *);
+static int do_look_ahead(int, const char *);
+
+static void enlarge_stack(void);
+
+int main(int, char *[]);
 
 int
 main(argc,argv)
 	int argc;
 	char *argv[];
 {
-	register int c;
-	register int n;
+	int c;
+	int n;
 	char *p;
-	register FILE *ifp;
-
-	progname = basename(argv[0]);
 
 	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 		signal(SIGINT, onintr);
 
 	initkwds();
+	initspaces();
+	STACKMAX = INITSTACKMAX;
+
+	mstack = (stae *)xalloc(sizeof(stae) * STACKMAX);
+	sstack = (char *)xalloc(STACKMAX);
 
-	while ((c = getopt(argc, argv, "tD:U:o:")) != EOF)
+	maxout = 0;
+	outfile = NULL;
+	resizedivs(MAXOUT);
+
+	while ((c = getopt(argc, argv, "gt:d:D:U:o:I:")) != -1)
 		switch(c) {
 
 		case 'D':               /* define something..*/
@@ -171,10 +205,24 @@ main(argc,argv)
 				*p++ = EOS;
 			dodefine(optarg, p);
 			break;
+		case 'I':
+			addtoincludepath(optarg);
+			break;
 		case 'U':               /* undefine...       */
 			remhash(optarg, TOP);
 			break;
-		case 'o':		/* specific output   */
+		case 'g':
+			mimic_gnu = 1;
+			break;
+		case 'd':
+			set_trace_flags(optarg);
+			break;
+		case 't':
+			mark_traced(optarg, 1);
+			break;
+		case 'o':
+			trace_file(optarg);
+                        break;
 		case '?':
 			usage();
 		}
@@ -183,81 +231,98 @@ main(argc,argv)
         argv += optind;
 
 	active = stdout;		/* default active output     */
-					/* filename for diversions   */
-	m4temp = mktemp(xstrdup(_PATH_DIVNAME));
-
 	bbase[0] = bufbase;
         if (!argc) {
  		sp = -1;		/* stack pointer initialized */
 		fp = 0; 		/* frame pointer initialized */
-		infile[0] = stdin;	/* default input (naturally) */
+		set_input(infile+0, stdin, "stdin");
+					/* default input (naturally) */
 		macro();
 	} else
 		for (; argc--; ++argv) {
 			p = *argv;
-			if (p[0] == '-' && p[1] == '\0')
-				ifp = stdin;
-			else if ((ifp = fopen(p, "r")) == NULL)
-				oops("%s: %s", p, strerror(errno));
+			if (p[0] == '-' && p[1] == EOS)
+				set_input(infile, stdin, "stdin");
+			else if (fopen_trypath(infile, p) == NULL)
+				err(1, "%s", p);
 			sp = -1;
 			fp = 0; 
-			infile[0] = ifp;
 			macro();
-			if (ifp != stdin)
-				(void)fclose(ifp);
+		    	release_input(infile);
 		}
 
 	if (*m4wraps) { 		/* anything for rundown ??   */
 		ilevel = 0;		/* in case m4wrap includes.. */
 		bufbase = bp = buf;	/* use the entire buffer   */
-		putback(EOF);		/* eof is a must !!	     */
 		pbstr(m4wraps); 	/* user-defined wrapup act   */
 		macro();		/* last will and testament   */
 	}
 
 	if (active != stdout)
 		active = stdout;	/* reset output just in case */
-	for (n = 1; n < MAXOUT; n++)	/* default wrap-up: undivert */
+	for (n = 1; n < maxout; n++)	/* default wrap-up: undivert */
 		if (outfile[n] != NULL)
 			getdiv(n);
 					/* remove bitbucket if used  */
 	if (outfile[0] != NULL) {
 		(void) fclose(outfile[0]);
-		m4temp[UNIQUE] = '0';
-#ifdef vms
-		(void) remove(m4temp);
-#else
-		(void) unlink(m4temp);
-#endif
 	}
 
 	return 0;
 }
 
-ndptr inspect();
+/*
+ * Look ahead for `token'.
+ * (on input `t == token[0]')
+ * Used for comment and quoting delimiters.
+ * Returns 1 if `token' present; copied to output.
+ *         0 if `token' not found; all characters pushed back
+ */
+static int
+do_look_ahead(t, token)
+	int	t;
+	const char	*token;
+{
+	int i;
+
+	assert((unsigned char)t == (unsigned char)token[0]);
+
+	for (i = 1; *++token; i++) {
+		t = gpbc();
+		if (t == EOF || (unsigned char)t != (unsigned char)*token) {
+			putback(t);
+			while (--i)
+				putback(*--token);
+			return 0;
+		}
+	}
+	return 1;
+}
+
+#define LOOK_AHEAD(t, token) (t != EOF && 		\
+    (unsigned char)(t)==(unsigned char)(token)[0] && 	\
+    do_look_ahead(t,token))
 
 /*
  * macro - the work horse..
  */
-void
-macro() {
-	char token[MAXTOK];
-	register char *s;
-	register int t, l;
-	register ndptr p;
-	register int  nlpar;
+static void
+macro()
+{
+	char token[MAXTOK+1];
+	int t, l;
+	ndptr p;
+	int  nlpar;
 
 	cycle {
-		if ((t = gpbc()) == '_' || isalpha(t)) {
-			putback(t);
-			if ((p = inspect(s = token)) == nil) {
-				if (sp < 0)
-					while (*s)
-						putc(*s++, active);
-				else
-					while (*s)
-						chrsave(*s++);
-			}
+		t = gpbc();
+		if (t == '_' || isalpha(t)) {
+			p = inspect(t, token);
+			if (p != nil)
+				putback(l = gpbc());
+			if (p == nil || (l != LPAREN && 
+			    (p->type & NEEDARGS) != 0))
+				outputstr(token);
 			else {
 		/*
 		 * real thing.. First build a call frame:
@@ -269,56 +334,91 @@ macro() {
 		/*
 		 * now push the string arguments:
 		 */
-				pushs(p->defn);	      /* defn string */
-				pushs(p->name);	      /* macro name  */
-				pushs(ep);	      /* start next..*/
-
-				putback(l = gpbc());
-				if (l != LPAREN)  {   /* add bracks  */
-					putback(RPAREN);
-					putback(LPAREN);
+				pushs1(p->defn);	/* defn string */
+				pushs1(p->name);	/* macro name  */
+				pushs(ep);	      	/* start next..*/
+
+				if (l != LPAREN && PARLEV == 0)  {   
+				    /* no bracks  */
+					chrsave(EOS);
+
+					if (sp == STACKMAX)
+						errx(1, "internal stack overflow");
+					eval((const char **) mstack+fp+1, 2, 
+					    CALTYP);
+
+					ep = PREVEP;	/* flush strspace */
+					sp = PREVSP;	/* previous sp..  */
+					fp = PREVFP;	/* rewind stack...*/
 				}
 			}
-		}
-		else if (t == EOF) {
-			if (sp > -1)
-				oops("unexpected end of input", "");
+		} else if (t == EOF) {
+			if (sp > -1) {
+				warnx( "unexpected end of input, unclosed parenthesis:");
+				dump_stack(paren, PARLEV);
+				exit(1);
+			}
 			if (ilevel <= 0)
 				break;			/* all done thanks.. */
-			--ilevel;
-			(void) fclose(infile[ilevel+1]);
+			release_input(infile+ilevel--);
 			bufbase = bbase[ilevel];
 			continue;
 		}
 	/*
-	 * non-alpha single-char token seen..
+	 * non-alpha token possibly seen..
 	 * [the order of else if .. stmts is important.]
 	 */
-		else if (t == lquote) { 		/* strip quotes */
-			nlpar = 1;
+		else if (LOOK_AHEAD(t,lquote)) {	/* strip quotes */
+			nlpar = 0;
+			record(quotes, nlpar++);
+			/*
+			 * Opening quote: scan forward until matching
+			 * closing quote has been found.
+			 */
 			do {
-				if ((l = gpbc()) == rquote)
-					nlpar--;
-				else if (l == lquote)
-					nlpar++;
-				else if (l == EOF)
-					oops("missing right quote", "");
-				if (nlpar > 0) {
-					if (sp < 0)
-						putc(l, active);
+
+				l = gpbc();
+				if (LOOK_AHEAD(l,rquote)) {
+					if (--nlpar > 0)
+						outputstr(rquote);
+				} else if (LOOK_AHEAD(l,lquote)) {
+					record(quotes, nlpar++);
+					outputstr(lquote);
+				} else if (l == EOF) {
+					if (nlpar == 1)
+						warnx("unclosed quote:");
 					else
-						chrsave(l);
+						warnx("%d unclosed quotes:", nlpar);
+					dump_stack(quotes, nlpar);
+					exit(1);
+				} else {
+					if (nlpar > 0) {
+						if (sp < 0)
+							putc(l, active);
+						else
+							CHRSAVE(l);
+					}
 				}
 			}
 			while (nlpar != 0);
 		}
 
-		else if (sp < 0) {		/* not in a macro at all */
-			if (t == scommt) {	/* comment handling here */
+		else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
+			fputs(scommt, active);
+
+			for(;;) {
+				t = gpbc();
+				if (LOOK_AHEAD(t, ecommt)) {
+					fputs(ecommt, active);
+					break;
+				}
+				if (t == EOF)
+					break;
 				putc(t, active);
-				while ((t = gpbc()) != ecommt)
-					putc(t, active);
 			}
+		}
+
+		else if (sp < 0) {		/* not in a macro at all */
 			putc(t, active);	/* output directly..	 */
 		}
 
@@ -330,7 +430,7 @@ macro() {
 			while (isspace(l = gpbc()))
 				;		/* skip blank, tab, nl.. */
 			putback(l);
-			PARLEV++;
+			record(paren, PARLEV++);
 			break;
 
 		case RPAREN:
@@ -340,12 +440,10 @@ macro() {
 				chrsave(EOS);
 
 				if (sp == STACKMAX)
-					oops("internal stack overflow", "");
+					errx(1, "internal stack overflow");
 
-				if (CALTYP == MACRTYPE)
-					expand((char **) mstack+fp+1, sp-fp);
-				else
-					eval((char **) mstack+fp+1, sp-fp, CALTYP);
+				eval((const char **) mstack+fp+1, sp-fp, 
+				    CALTYP);
 
 				ep = PREVEP;	/* flush strspace */
 				sp = PREVSP;	/* previous sp..  */
@@ -365,37 +463,81 @@ macro() {
 			break;
 
 		default:
-			chrsave(t);			/* stack the char */
+			if (LOOK_AHEAD(t, scommt)) {
+				char *p;
+				for (p = scommt; *p; p++)
+					chrsave(*p);
+				for(;;) {
+					t = gpbc();
+					if (LOOK_AHEAD(t, ecommt)) {
+						for (p = ecommt; *p; p++)
+							chrsave(*p);
+						break;
+					}
+					if (t == EOF)
+					    break;
+					CHRSAVE(t);
+				}
+			} else
+				CHRSAVE(t);		/* stack the char */
 			break;
 		}
 	}
 }
 
+/* 
+ * output string directly, without pushing it for reparses. 
+ */
+void
+outputstr(s)
+	const char *s;
+{
+	if (sp < 0)
+		while (*s)
+			putc(*s++, active);
+	else
+		while (*s)
+			CHRSAVE(*s++);
+}
+
 /*
  * build an input token..
  * consider only those starting with _ or A-Za-z. This is a
  * combo with lookup to speed things up.
  */
-ndptr
-inspect(tp) 
-register char *tp;
+static ndptr
+inspect(c, tp) 
+	int c;
+	char *tp;
 {
-	register char c;
-	register char *name = tp;
-	register char *etp = tp+MAXTOK;
-	register ndptr p;
-	register unsigned long h = 0;
+	char *name = tp;
+	char *etp = tp+MAXTOK;
+	ndptr p;
+	unsigned int h;
+	
+	h = *tp++ = c;
 
 	while ((isalnum(c = gpbc()) || c == '_') && tp < etp)
 		h = (h << 5) + h + (*tp++ = c);
-	putback(c);
-	if (tp == etp)
-		oops("token too long", "");
-
+	if (c != EOF)
+		PUTBACK(c);
 	*tp = EOS;
+	/* token is too long, it won't match anything, but it can still
+	 * be output. */
+	if (tp == ep) {
+		outputstr(name);
+		while (isalnum(c = gpbc()) || c == '_') {
+			if (sp < 0)
+				putc(c, active);
+			else
+				CHRSAVE(c);
+		}
+		*name = EOS;
+		return nil;
+	}
 
-	for (p = hashtab[h%HASHSIZE]; p != nil; p = p->nxtptr)
-		if (STREQ(name, p->name))
+	for (p = hashtab[h % HASHSIZE]; p != nil; p = p->nxtptr)
+		if (h == p->hv && STREQ(name, p->name))
 			break;
 	return p;
 }
@@ -404,22 +546,91 @@ register char *tp;
  * initkwds - initialise m4 keywords as fast as possible. 
  * This very similar to install, but without certain overheads,
  * such as calling lookup. Malloc is not used for storing the 
- * keyword strings, since we simply use the static  pointers
+ * keyword strings, since we simply use the static pointers
  * within keywrds block.
  */
-void
-initkwds() {
-	register int i;
-	register int h;
-	register ndptr p;
+static void
+initkwds()
+{
+	size_t i;
+	unsigned int h;
+	ndptr p;
 
 	for (i = 0; i < MAXKEYS; i++) {
 		h = hash(keywrds[i].knam);
 		p = (ndptr) xalloc(sizeof(struct ndblock));
-		p->nxtptr = hashtab[h];
-		hashtab[h] = p;
-		p->name = keywrds[i].knam;
+		p->nxtptr = hashtab[h % HASHSIZE];
+		hashtab[h % HASHSIZE] = p;
+		p->name = xstrdup(keywrds[i].knam);
 		p->defn = null;
-		p->type = keywrds[i].ktyp | STATIC;
+		p->hv = h;
+		p->type = keywrds[i].ktyp & TYPEMASK;
+		if ((keywrds[i].ktyp & NOARGS) == 0)
+			p->type |= NEEDARGS;
+	}
+}
+
+/* Look up a builtin type, even if overridden by the user */
+int 
+builtin_type(key)
+	const char *key;
+{
+	int i;
+
+	for (i = 0; i != MAXKEYS; i++)
+		if (STREQ(keywrds[i].knam, key))
+			return keywrds[i].ktyp;
+	return -1;
+}
+
+char *
+builtin_realname(n)
+	int n;
+{
+	int i;
+
+	for (i = 0; i != MAXKEYS; i++)
+		if (((keywrds[i].ktyp ^ n) & TYPEMASK) == 0)
+			return keywrds[i].knam;
+	return NULL;
+}
+
+static void
+record(t, lev)
+	struct position *t;
+	int lev;
+{
+	if (lev < MAXRECORD) {
+		t[lev].name = CURRENT_NAME;
+		t[lev].line = CURRENT_LINE;
+	}
+}
+
+static void
+dump_stack(t, lev)
+	struct position *t;
+	int lev;
+{
+	int i;
+
+	for (i = 0; i < lev; i++) {
+		if (i == MAXRECORD) {
+			fprintf(stderr, "   ...\n");
+			break;
+		}
+		fprintf(stderr, "   %s at line %lu\n", 
+			t[i].name, t[i].line);
 	}
 }
+
+
+static void 
+enlarge_stack()
+{
+	STACKMAX *= 2;
+	mstack = realloc(mstack, sizeof(stae) * STACKMAX);
+	sstack = realloc(sstack, STACKMAX);
+	if (mstack == NULL || sstack == NULL)
+		errx(1, "Evaluation stack overflow (%lu)", 
+		    (unsigned long)STACKMAX);
+}
diff --git a/usr.bin/m4/trace.c b/usr.bin/m4/trace.c
new file mode 100644
index 0000000..231667e
--- /dev/null
+++ b/usr.bin/m4/trace.c
@@ -0,0 +1,272 @@
+/* $OpenBSD: trace.c,v 1.4 2002/02/16 21:27:48 millert Exp $ */
+/*
+ * Copyright (c) 2001 Marc Espie.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OPENBSD PROJECT AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OPENBSD
+ * PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <err.h>
+#include <stdlib.h>
+#include "mdef.h"
+#include "stdd.h"
+#include "extern.h"
+
+FILE *traceout = stderr;
+
+int traced_macros = 0;
+
+#define TRACE_ARGS 	1
+#define TRACE_EXPANSION 2
+#define TRACE_QUOTE	4
+#define TRACE_FILENAME	8
+#define TRACE_LINENO	16
+#define TRACE_CONT	32
+#define TRACE_ID	64
+#define TRACE_NEWFILE	128	/* not implemented yet */
+#define TRACE_INPUT	256	/* not implemented yet */
+#define TRACE_ALL	512
+
+static struct t {
+	struct t *next;
+	char 	 *name;
+	int	  on;
+} *l;
+
+static unsigned int letter_to_flag(int);
+static void print_header(struct input_file *);
+static struct t *find_trace_entry(const char *);
+static int frame_level(void);
+
+static unsigned int flags = TRACE_QUOTE | TRACE_EXPANSION;
+
+static struct t *
+find_trace_entry(name)
+	const char *name;
+{
+	struct t *n;
+
+	for (n = l; n != NULL; n = n->next)
+		if (STREQ(n->name, name))
+			return n;
+	return NULL;
+}
+
+
+void
+mark_traced(name, on)
+	const char *name;
+	int on;
+{
+	struct t *n, *n2;
+
+	traced_macros = 1;
+
+	if (name == NULL) {
+		if (on)
+			flags |= TRACE_ALL;
+		else {
+			flags &= ~TRACE_ALL;
+			traced_macros = 0;
+		}
+		for (n = l; n != NULL; n = n2) {
+			n2 = n->next;
+			free(n->name);
+			free(n);
+		}
+		l = NULL;
+	} else {
+	    n = find_trace_entry(name);
+	    if (n == NULL) {
+	n = xalloc(sizeof(struct t));
+	n->name = xstrdup(name);
+	n->next = l;
+	l = n;
+	    }
+	    n->on = on;
+	}
+}
+
+int 
+is_traced(name)
+	const char *name;
+{
+	struct t *n;
+
+	for (n = l; n != NULL; n = n->next)
+		if (STREQ(n->name, name))
+			return n->on;
+	return (flags & TRACE_ALL) ? 1 : 0;
+}
+
+void
+trace_file(name)
+	const char *name;
+{
+
+	if (traceout != stderr)
+		fclose(traceout);
+	traceout = fopen(name, "w");
+	if (!traceout)
+		err(1, "can't open %s", name);
+}
+
+static unsigned int
+letter_to_flag(c)
+	int c;
+{
+	switch(c) {
+	case 'a':
+		return TRACE_ARGS;
+	case 'e':
+		return TRACE_EXPANSION;
+	case 'q':
+		return TRACE_QUOTE;
+	case 'c':
+		return TRACE_CONT;
+	case 'x':
+		return TRACE_ID;
+	case 'f':
+		return TRACE_FILENAME;
+	case 'l':
+		return TRACE_LINENO;
+	case 'p':
+		return TRACE_NEWFILE;
+	case 'i':
+		return TRACE_INPUT;
+	case 't':
+		return TRACE_ALL;
+	case 'V':
+		return ~0;
+	default:
+		return 0;
+	}
+}
+
+void
+set_trace_flags(s)
+	const char *s;
+{
+	char mode = 0;
+	unsigned int f = 0;
+
+	traced_macros = 1;
+
+	if (*s == '+' || *s == '-')
+		mode = *s++;
+	while (*s)
+		f |= letter_to_flag(*s++);
+	switch(mode) {
+	case 0:
+		flags = f;
+		break;
+	case '+':
+		flags |= f;
+		break;
+	case '-':
+		flags &= ~f;
+		break;
+	}
+}
+
+static int
+frame_level()
+{
+	int level;
+	int framep;
+
+	for (framep = fp, level = 0; framep != 0; 
+		level++,framep = mstack[framep-2].sfra)
+		;
+	return level;
+}
+
+static void
+print_header(inp)
+	struct input_file *inp;
+{
+	fprintf(traceout, "m4trace:");
+	if (flags & TRACE_FILENAME)
+		fprintf(traceout, "%s:", inp->name);
+	if (flags & TRACE_LINENO)
+		fprintf(traceout, "%lu:", inp->lineno);
+	fprintf(traceout, " -%d- ", frame_level());
+	if (flags & TRACE_ID)
+		fprintf(traceout, "id %lu: ", expansion_id);
+}
+
+ssize_t 
+trace(argv, argc, inp)
+	const char **argv;
+	int argc;
+	struct input_file *inp;
+{
+	print_header(inp);
+	if (flags & TRACE_CONT) {
+		fprintf(traceout, "%s ...\n", argv[1]);
+		print_header(inp);
+	}
+	fprintf(traceout, "%s", argv[1]);
+	if ((flags & TRACE_ARGS) && argc > 2) {
+		char delim[3];
+		int i;
+
+		delim[0] = LPAREN;
+		delim[1] = EOS;
+		for (i = 2; i < argc; i++) {
+			fprintf(traceout, "%s%s%s%s", delim, 
+			    (flags & TRACE_QUOTE) ? lquote : "", 
+			    argv[i], 
+			    (flags & TRACE_QUOTE) ? rquote : "");
+			delim[0] = COMMA;
+			delim[1] = ' ';
+			delim[2] = EOS;
+		}
+		fprintf(traceout, "%c", RPAREN);
+	}
+	if (flags & TRACE_CONT) {
+		fprintf(traceout, " -> ???\n");
+		print_header(inp);
+		fprintf(traceout, argc > 2 ? "%s(...)" : "%s", argv[1]);
+	}
+	if (flags & TRACE_EXPANSION)
+		return buffer_mark();
+	else {
+		fprintf(traceout, "\n");
+		return -1;
+	}
+}
+
+void 
+finish_trace(mark)
+size_t mark;
+{
+	fprintf(traceout, " -> ");
+	if (flags & TRACE_QUOTE)
+		fprintf(traceout, "%s", lquote);
+	dump_buffer(traceout, mark);
+	if (flags & TRACE_QUOTE)
+		fprintf(traceout, "%s", rquote);
+	fprintf(traceout, "\n");
+}