xref: /freebsd/usr.bin/m4/main.c (revision d1fea89caedd6a3e1561bb5606fede3329f53a9e)
1bd2bfb58SJuli Mallett /*	$OpenBSD: main.c,v 1.53 2002/04/26 16:15:16 espie Exp $	*/
2acc9d408SJuli Mallett /*	$NetBSD: main.c,v 1.12 1997/02/08 23:54:49 cgd Exp $	*/
3acc9d408SJuli Mallett 
49b50d902SRodney W. Grimes /*-
59b50d902SRodney W. Grimes  * Copyright (c) 1989, 1993
69b50d902SRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
79b50d902SRodney W. Grimes  *
89b50d902SRodney W. Grimes  * This code is derived from software contributed to Berkeley by
99b50d902SRodney W. Grimes  * Ozan Yigit at York University.
109b50d902SRodney W. Grimes  *
119b50d902SRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
129b50d902SRodney W. Grimes  * modification, are permitted provided that the following conditions
139b50d902SRodney W. Grimes  * are met:
149b50d902SRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
159b50d902SRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
169b50d902SRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
179b50d902SRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
189b50d902SRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
199b50d902SRodney W. Grimes  * 3. All advertising materials mentioning features or use of this software
209b50d902SRodney W. Grimes  *    must display the following acknowledgement:
219b50d902SRodney W. Grimes  *	This product includes software developed by the University of
229b50d902SRodney W. Grimes  *	California, Berkeley and its contributors.
239b50d902SRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
249b50d902SRodney W. Grimes  *    may be used to endorse or promote products derived from this software
259b50d902SRodney W. Grimes  *    without specific prior written permission.
269b50d902SRodney W. Grimes  *
279b50d902SRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
289b50d902SRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
299b50d902SRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
309b50d902SRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
319b50d902SRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
329b50d902SRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
339b50d902SRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
349b50d902SRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
359b50d902SRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
369b50d902SRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
379b50d902SRodney W. Grimes  * SUCH DAMAGE.
389b50d902SRodney W. Grimes  */
399b50d902SRodney W. Grimes 
4090432ef8SJuli Mallett #ifndef lint
4190432ef8SJuli Mallett static char copyright[] =
4290432ef8SJuli Mallett "@(#) Copyright (c) 1989, 1993\n\
4390432ef8SJuli Mallett 	The Regents of the University of California.  All rights reserved.\n";
4490432ef8SJuli Mallett #endif /* not lint */
4590432ef8SJuli Mallett 
4690432ef8SJuli Mallett #ifndef lint
4790432ef8SJuli Mallett #if 0
4890432ef8SJuli Mallett static char sccsid[] = "@(#)main.c	8.1 (Berkeley) 6/6/93";
4990432ef8SJuli Mallett #else
5090432ef8SJuli Mallett #if 0
5190432ef8SJuli Mallett static char rcsid[] = "$OpenBSD: main.c,v 1.53 2002/04/26 16:15:16 espie Exp $";
5290432ef8SJuli Mallett #endif
5390432ef8SJuli Mallett #endif
5490432ef8SJuli Mallett #endif /* not lint */
5590432ef8SJuli Mallett 
56acc9d408SJuli Mallett #include <sys/cdefs.h>
57acc9d408SJuli Mallett __FBSDID("$FreeBSD$");
589b50d902SRodney W. Grimes 
599b50d902SRodney W. Grimes /*
609b50d902SRodney W. Grimes  * main.c
619b50d902SRodney W. Grimes  * Facility: m4 macro processor
629b50d902SRodney W. Grimes  * by: oz
639b50d902SRodney W. Grimes  */
649b50d902SRodney W. Grimes 
659b50d902SRodney W. Grimes #include <sys/types.h>
66acc9d408SJuli Mallett #include <assert.h>
6795105358SPhilippe Charnier #include <signal.h>
68acc9d408SJuli Mallett #include <errno.h>
6995105358SPhilippe Charnier #include <unistd.h>
70acc9d408SJuli Mallett #include <stdio.h>
71acc9d408SJuli Mallett #include <ctype.h>
72acc9d408SJuli Mallett #include <string.h>
73acc9d408SJuli Mallett #include <stddef.h>
74acc9d408SJuli Mallett #include <stdlib.h>
75acc9d408SJuli Mallett #include <err.h>
769b50d902SRodney W. Grimes #include "mdef.h"
779b50d902SRodney W. Grimes #include "stdd.h"
789b50d902SRodney W. Grimes #include "extern.h"
799b50d902SRodney W. Grimes #include "pathnames.h"
809b50d902SRodney W. Grimes 
819b50d902SRodney W. Grimes ndptr hashtab[HASHSIZE];	/* hash table for macros etc.  */
82acc9d408SJuli Mallett stae *mstack;		 	/* stack of m4 machine         */
83acc9d408SJuli Mallett char *sstack;		 	/* shadow stack, for string space extension */
84acc9d408SJuli Mallett static size_t STACKMAX;		/* current maximum size of stack */
859b50d902SRodney W. Grimes int sp; 			/* current m4  stack pointer   */
869b50d902SRodney W. Grimes int fp; 			/* m4 call frame pointer       */
87acc9d408SJuli Mallett struct input_file infile[MAXINP];/* input file stack (0=stdin)  */
88b1ea3d46SJuli Mallett char *inname[MAXINP];		/* names of these input files */
89acc9d408SJuli Mallett int inlineno[MAXINP];		/* current number in each input file */
90acc9d408SJuli Mallett FILE **outfile;			/* diversion array(0=bitbucket)*/
91acc9d408SJuli Mallett int maxout;
929b50d902SRodney W. Grimes FILE *active;			/* active output file pointer  */
939b50d902SRodney W. Grimes int ilevel = 0; 		/* input file stack pointer    */
949b50d902SRodney W. Grimes int oindex = 0; 		/* diversion index..	       */
95ccc5b4e6SJuli Mallett const char *null = "";          /* as it says.. just a null..  */
96ccc5b4e6SJuli Mallett const char *m4wraps = "";       /* m4wrap string default..     */
97acc9d408SJuli Mallett char lquote[MAXCCHARS+1] = {LQUOTE};	/* left quote character  (`)   */
98acc9d408SJuli Mallett char rquote[MAXCCHARS+1] = {RQUOTE};	/* right quote character (')   */
99acc9d408SJuli Mallett char scommt[MAXCCHARS+1] = {SCOMMT};	/* start character for comment */
100acc9d408SJuli Mallett char ecommt[MAXCCHARS+1] = {ECOMMT};	/* end character for comment   */
101b1ea3d46SJuli Mallett int synccpp;			/* Line synchronisation for C preprocessor */
1029b50d902SRodney W. Grimes 
1039b50d902SRodney W. Grimes struct keyblk keywrds[] = {	/* m4 keywords to be installed */
104acc9d408SJuli Mallett 	{ "include",      INCLTYPE },
105acc9d408SJuli Mallett 	{ "sinclude",     SINCTYPE },
106acc9d408SJuli Mallett 	{ "define",       DEFITYPE },
107acc9d408SJuli Mallett 	{ "defn",         DEFNTYPE },
108acc9d408SJuli Mallett 	{ "divert",       DIVRTYPE | NOARGS },
109acc9d408SJuli Mallett 	{ "expr",         EXPRTYPE },
110acc9d408SJuli Mallett 	{ "eval",         EXPRTYPE },
111acc9d408SJuli Mallett 	{ "substr",       SUBSTYPE },
112acc9d408SJuli Mallett 	{ "ifelse",       IFELTYPE },
113acc9d408SJuli Mallett 	{ "ifdef",        IFDFTYPE },
114acc9d408SJuli Mallett 	{ "len",          LENGTYPE },
115acc9d408SJuli Mallett 	{ "incr",         INCRTYPE },
116acc9d408SJuli Mallett 	{ "decr",         DECRTYPE },
117acc9d408SJuli Mallett 	{ "dnl",          DNLNTYPE | NOARGS },
118acc9d408SJuli Mallett 	{ "changequote",  CHNQTYPE | NOARGS },
119acc9d408SJuli Mallett 	{ "changecom",    CHNCTYPE | NOARGS },
120acc9d408SJuli Mallett 	{ "index",        INDXTYPE },
1219b50d902SRodney W. Grimes #ifdef EXTENDED
122acc9d408SJuli Mallett 	{ "paste",        PASTTYPE },
123acc9d408SJuli Mallett 	{ "spaste",       SPASTYPE },
124acc9d408SJuli Mallett     	/* Newer extensions, needed to handle gnu-m4 scripts */
125acc9d408SJuli Mallett 	{ "indir",        INDIRTYPE},
126acc9d408SJuli Mallett 	{ "builtin",      BUILTINTYPE},
127acc9d408SJuli Mallett 	{ "patsubst",	  PATSTYPE},
128acc9d408SJuli Mallett 	{ "regexp",	  REGEXPTYPE},
129acc9d408SJuli Mallett 	{ "esyscmd",	  ESYSCMDTYPE},
130acc9d408SJuli Mallett 	{ "__file__",	  FILENAMETYPE | NOARGS},
131acc9d408SJuli Mallett 	{ "__line__",	  LINETYPE | NOARGS},
1329b50d902SRodney W. Grimes #endif
133acc9d408SJuli Mallett 	{ "popdef",       POPDTYPE },
134acc9d408SJuli Mallett 	{ "pushdef",      PUSDTYPE },
135acc9d408SJuli Mallett 	{ "dumpdef",      DUMPTYPE | NOARGS },
136acc9d408SJuli Mallett 	{ "shift",        SHIFTYPE | NOARGS },
137acc9d408SJuli Mallett 	{ "translit",     TRNLTYPE },
138acc9d408SJuli Mallett 	{ "undefine",     UNDFTYPE },
139acc9d408SJuli Mallett 	{ "undivert",     UNDVTYPE | NOARGS },
140acc9d408SJuli Mallett 	{ "divnum",       DIVNTYPE | NOARGS },
141acc9d408SJuli Mallett 	{ "maketemp",     MKTMTYPE },
142acc9d408SJuli Mallett 	{ "errprint",     ERRPTYPE | NOARGS },
143acc9d408SJuli Mallett 	{ "m4wrap",       M4WRTYPE | NOARGS },
144acc9d408SJuli Mallett 	{ "m4exit",       EXITTYPE | NOARGS },
145acc9d408SJuli Mallett 	{ "syscmd",       SYSCTYPE },
146acc9d408SJuli Mallett 	{ "sysval",       SYSVTYPE | NOARGS },
147acc9d408SJuli Mallett 	{ "traceon",	  TRACEONTYPE | NOARGS },
148acc9d408SJuli Mallett 	{ "traceoff",	  TRACEOFFTYPE | NOARGS },
1499b50d902SRodney W. Grimes 
150acc9d408SJuli Mallett #if defined(unix) || defined(__unix__)
151acc9d408SJuli Mallett 	{ "unix",         SELFTYPE | NOARGS },
1529b50d902SRodney W. Grimes #else
1539b50d902SRodney W. Grimes #ifdef vms
154acc9d408SJuli Mallett 	{ "vms",          SELFTYPE | NOARGS },
1559b50d902SRodney W. Grimes #endif
1569b50d902SRodney W. Grimes #endif
1579b50d902SRodney W. Grimes };
1589b50d902SRodney W. Grimes 
1599b50d902SRodney W. Grimes #define MAXKEYS	(sizeof(keywrds)/sizeof(struct keyblk))
1609b50d902SRodney W. Grimes 
161acc9d408SJuli Mallett #define MAXRECORD 50
162acc9d408SJuli Mallett static struct position {
163acc9d408SJuli Mallett 	char *name;
164acc9d408SJuli Mallett 	unsigned long line;
165acc9d408SJuli Mallett } quotes[MAXRECORD], paren[MAXRECORD];
166acc9d408SJuli Mallett 
167acc9d408SJuli Mallett static void record(struct position *, int);
168acc9d408SJuli Mallett static void dump_stack(struct position *, int);
169acc9d408SJuli Mallett 
170acc9d408SJuli Mallett static void macro(void);
171acc9d408SJuli Mallett static void initkwds(void);
172acc9d408SJuli Mallett static ndptr inspect(int, char *);
173acc9d408SJuli Mallett static int do_look_ahead(int, const char *);
174acc9d408SJuli Mallett 
175acc9d408SJuli Mallett static void enlarge_stack(void);
176acc9d408SJuli Mallett 
1779b50d902SRodney W. Grimes int
178bd2bfb58SJuli Mallett main(int argc, char *argv[])
1799b50d902SRodney W. Grimes {
180acc9d408SJuli Mallett 	int c;
181acc9d408SJuli Mallett 	int n;
182456fc9e5STim J. Robbins 	int rval;
1839b50d902SRodney W. Grimes 	char *p;
184acc9d408SJuli Mallett 
185acc9d408SJuli Mallett 	traceout = stderr;
1869b50d902SRodney W. Grimes 
1879b50d902SRodney W. Grimes 	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
1889b50d902SRodney W. Grimes 		signal(SIGINT, onintr);
1899b50d902SRodney W. Grimes 
1909b50d902SRodney W. Grimes 	initkwds();
191acc9d408SJuli Mallett 	initspaces();
192acc9d408SJuli Mallett 	STACKMAX = INITSTACKMAX;
1939b50d902SRodney W. Grimes 
194acc9d408SJuli Mallett 	mstack = (stae *)xalloc(sizeof(stae) * STACKMAX);
195acc9d408SJuli Mallett 	sstack = (char *)xalloc(STACKMAX);
196acc9d408SJuli Mallett 
197acc9d408SJuli Mallett 	maxout = 0;
198acc9d408SJuli Mallett 	outfile = NULL;
199acc9d408SJuli Mallett 	resizedivs(MAXOUT);
200acc9d408SJuli Mallett 
201acc9d408SJuli Mallett 	while ((c = getopt(argc, argv, "gst:d:D:U:o:I:")) != -1)
2029b50d902SRodney W. Grimes 		switch(c) {
2039b50d902SRodney W. Grimes 
2049b50d902SRodney W. Grimes 		case 'D':               /* define something..*/
2059b50d902SRodney W. Grimes 			for (p = optarg; *p; p++)
2069b50d902SRodney W. Grimes 				if (*p == '=')
2079b50d902SRodney W. Grimes 					break;
2089b50d902SRodney W. Grimes 			if (*p)
2099b50d902SRodney W. Grimes 				*p++ = EOS;
2109b50d902SRodney W. Grimes 			dodefine(optarg, p);
2119b50d902SRodney W. Grimes 			break;
212acc9d408SJuli Mallett 		case 'I':
213acc9d408SJuli Mallett 			addtoincludepath(optarg);
214acc9d408SJuli Mallett 			break;
2159b50d902SRodney W. Grimes 		case 'U':               /* undefine...       */
2169b50d902SRodney W. Grimes 			remhash(optarg, TOP);
2179b50d902SRodney W. Grimes 			break;
218acc9d408SJuli Mallett 		case 'g':
219acc9d408SJuli Mallett 			mimic_gnu = 1;
220acc9d408SJuli Mallett 			break;
221acc9d408SJuli Mallett 		case 'd':
222acc9d408SJuli Mallett 			set_trace_flags(optarg);
223acc9d408SJuli Mallett 			break;
224b1ea3d46SJuli Mallett 		case 's':
225b1ea3d46SJuli Mallett 			synccpp = 1;
226b1ea3d46SJuli Mallett 			break;
227acc9d408SJuli Mallett 		case 't':
228acc9d408SJuli Mallett 			mark_traced(optarg, 1);
229acc9d408SJuli Mallett 			break;
230acc9d408SJuli Mallett 		case 'o':
231acc9d408SJuli Mallett 			trace_file(optarg);
232acc9d408SJuli Mallett                         break;
2339b50d902SRodney W. Grimes 		case '?':
2349b50d902SRodney W. Grimes 			usage();
2359b50d902SRodney W. Grimes 		}
2369b50d902SRodney W. Grimes 
2379b50d902SRodney W. Grimes         argc -= optind;
2389b50d902SRodney W. Grimes         argv += optind;
2399b50d902SRodney W. Grimes 
240456fc9e5STim J. Robbins 	rval = 0;
2419b50d902SRodney W. Grimes 	active = stdout;		/* default active output     */
2429b50d902SRodney W. Grimes 	bbase[0] = bufbase;
2439b50d902SRodney W. Grimes         if (!argc) {
2449b50d902SRodney W. Grimes  		sp = -1;		/* stack pointer initialized */
2459b50d902SRodney W. Grimes 		fp = 0; 		/* frame pointer initialized */
246acc9d408SJuli Mallett 		set_input(infile+0, stdin, "stdin");
247acc9d408SJuli Mallett 					/* default input (naturally) */
248b1ea3d46SJuli Mallett 		if ((inname[0] = strdup("-")) == NULL)
249b1ea3d46SJuli Mallett 			err(1, NULL);
250b1ea3d46SJuli Mallett 		inlineno[0] = 1;
251b1ea3d46SJuli Mallett 		emitline();
2529b50d902SRodney W. Grimes 		macro();
2539b50d902SRodney W. Grimes 	} else
2549b50d902SRodney W. Grimes 		for (; argc--; ++argv) {
2559b50d902SRodney W. Grimes 			p = *argv;
256acc9d408SJuli Mallett 			if (p[0] == '-' && p[1] == EOS)
257acc9d408SJuli Mallett 				set_input(infile, stdin, "stdin");
258456fc9e5STim J. Robbins 			else if (fopen_trypath(infile, p) == NULL) {
259456fc9e5STim J. Robbins 				warn("%s", p);
260456fc9e5STim J. Robbins 				rval = 1;
261456fc9e5STim J. Robbins 				continue;
262456fc9e5STim J. Robbins 			}
2639b50d902SRodney W. Grimes 			sp = -1;
2649b50d902SRodney W. Grimes 			fp = 0;
265b1ea3d46SJuli Mallett 			if ((inname[0] = strdup(p)) == NULL)
266b1ea3d46SJuli Mallett 				err(1, NULL);
267b1ea3d46SJuli Mallett 			inlineno[0] = 1;
268b1ea3d46SJuli Mallett 			emitline();
2699b50d902SRodney W. Grimes 			macro();
270acc9d408SJuli Mallett 		    	release_input(infile);
2719b50d902SRodney W. Grimes 		}
2729b50d902SRodney W. Grimes 
2739b50d902SRodney W. Grimes 	if (*m4wraps) { 		/* anything for rundown ??   */
2749b50d902SRodney W. Grimes 		ilevel = 0;		/* in case m4wrap includes.. */
2759b50d902SRodney W. Grimes 		bufbase = bp = buf;	/* use the entire buffer   */
2769b50d902SRodney W. Grimes 		pbstr(m4wraps); 	/* user-defined wrapup act   */
2779b50d902SRodney W. Grimes 		macro();		/* last will and testament   */
2789b50d902SRodney W. Grimes 	}
2799b50d902SRodney W. Grimes 
2809b50d902SRodney W. Grimes 	if (active != stdout)
2819b50d902SRodney W. Grimes 		active = stdout;	/* reset output just in case */
282acc9d408SJuli Mallett 	for (n = 1; n < maxout; n++)	/* default wrap-up: undivert */
2839b50d902SRodney W. Grimes 		if (outfile[n] != NULL)
2849b50d902SRodney W. Grimes 			getdiv(n);
2859b50d902SRodney W. Grimes 					/* remove bitbucket if used  */
286acc9d408SJuli Mallett 	if (outfile[0] != NULL) {
287acc9d408SJuli Mallett 		(void) fclose(outfile[0]);
288acc9d408SJuli Mallett 	}
289acc9d408SJuli Mallett 
290456fc9e5STim J. Robbins 	exit(rval);
2919b50d902SRodney W. Grimes }
2929b50d902SRodney W. Grimes 
293acc9d408SJuli Mallett /*
294acc9d408SJuli Mallett  * Look ahead for `token'.
295acc9d408SJuli Mallett  * (on input `t == token[0]')
296acc9d408SJuli Mallett  * Used for comment and quoting delimiters.
297acc9d408SJuli Mallett  * Returns 1 if `token' present; copied to output.
298acc9d408SJuli Mallett  *         0 if `token' not found; all characters pushed back
299acc9d408SJuli Mallett  */
300acc9d408SJuli Mallett static int
301bd2bfb58SJuli Mallett do_look_ahead(int t, const char *token)
302acc9d408SJuli Mallett {
303acc9d408SJuli Mallett 	int i;
304acc9d408SJuli Mallett 
305acc9d408SJuli Mallett 	assert((unsigned char)t == (unsigned char)token[0]);
306acc9d408SJuli Mallett 
307acc9d408SJuli Mallett 	for (i = 1; *++token; i++) {
308acc9d408SJuli Mallett 		t = gpbc();
309acc9d408SJuli Mallett 		if (t == EOF || (unsigned char)t != (unsigned char)*token) {
310acc9d408SJuli Mallett 			putback(t);
311acc9d408SJuli Mallett 			while (--i)
312acc9d408SJuli Mallett 				putback(*--token);
313acc9d408SJuli Mallett 			return 0;
314acc9d408SJuli Mallett 		}
315acc9d408SJuli Mallett 	}
316acc9d408SJuli Mallett 	return 1;
317acc9d408SJuli Mallett }
318acc9d408SJuli Mallett 
319acc9d408SJuli Mallett #define LOOK_AHEAD(t, token) (t != EOF && 		\
320acc9d408SJuli Mallett     (unsigned char)(t)==(unsigned char)(token)[0] && 	\
321acc9d408SJuli Mallett     do_look_ahead(t,token))
3229b50d902SRodney W. Grimes 
3239b50d902SRodney W. Grimes /*
3249b50d902SRodney W. Grimes  * macro - the work horse..
3259b50d902SRodney W. Grimes  */
326acc9d408SJuli Mallett static void
327d1fea89cSJuli Mallett macro(void)
328acc9d408SJuli Mallett {
329acc9d408SJuli Mallett 	char token[MAXTOK+1];
330acc9d408SJuli Mallett 	int t, l;
331acc9d408SJuli Mallett 	ndptr p;
332acc9d408SJuli Mallett 	int  nlpar;
3339b50d902SRodney W. Grimes 
3349b50d902SRodney W. Grimes 	cycle {
335acc9d408SJuli Mallett 		t = gpbc();
336acc9d408SJuli Mallett 		if (t == '_' || isalpha(t)) {
337acc9d408SJuli Mallett 			p = inspect(t, token);
338acc9d408SJuli Mallett 			if (p != nil)
339acc9d408SJuli Mallett 				putback(l = gpbc());
340acc9d408SJuli Mallett 			if (p == nil || (l != LPAREN &&
341acc9d408SJuli Mallett 			    (p->type & NEEDARGS) != 0))
342acc9d408SJuli Mallett 				outputstr(token);
3439b50d902SRodney W. Grimes 			else {
3449b50d902SRodney W. Grimes 		/*
3459b50d902SRodney W. Grimes 		 * real thing.. First build a call frame:
3469b50d902SRodney W. Grimes 		 */
3479b50d902SRodney W. Grimes 				pushf(fp);	/* previous call frm */
3489b50d902SRodney W. Grimes 				pushf(p->type); /* type of the call  */
3499b50d902SRodney W. Grimes 				pushf(0);	/* parenthesis level */
3509b50d902SRodney W. Grimes 				fp = sp;	/* new frame pointer */
3519b50d902SRodney W. Grimes 		/*
3529b50d902SRodney W. Grimes 		 * now push the string arguments:
3539b50d902SRodney W. Grimes 		 */
354acc9d408SJuli Mallett 				pushs1(p->defn);	/* defn string */
355acc9d408SJuli Mallett 				pushs1(p->name);	/* macro name  */
3569b50d902SRodney W. Grimes 				pushs(ep);	      	/* start next..*/
3579b50d902SRodney W. Grimes 
358acc9d408SJuli Mallett 				if (l != LPAREN && PARLEV == 0)  {
359acc9d408SJuli Mallett 				    /* no bracks  */
360acc9d408SJuli Mallett 					chrsave(EOS);
361acc9d408SJuli Mallett 
362d40d348cSJuli Mallett 					if ((uintptr_t)sp == STACKMAX)
363acc9d408SJuli Mallett 						errx(1, "internal stack overflow");
364acc9d408SJuli Mallett 					eval((const char **) mstack+fp+1, 2,
365acc9d408SJuli Mallett 					    CALTYP);
366acc9d408SJuli Mallett 
367acc9d408SJuli Mallett 					ep = PREVEP;	/* flush strspace */
368acc9d408SJuli Mallett 					sp = PREVSP;	/* previous sp..  */
369acc9d408SJuli Mallett 					fp = PREVFP;	/* rewind stack...*/
3709b50d902SRodney W. Grimes 				}
3719b50d902SRodney W. Grimes 			}
372acc9d408SJuli Mallett 		} else if (t == EOF) {
373acc9d408SJuli Mallett 			if (sp > -1) {
374acc9d408SJuli Mallett 				warnx( "unexpected end of input, unclosed parenthesis:");
375acc9d408SJuli Mallett 				dump_stack(paren, PARLEV);
376acc9d408SJuli Mallett 				exit(1);
3779b50d902SRodney W. Grimes 			}
3789b50d902SRodney W. Grimes 			if (ilevel <= 0)
3799b50d902SRodney W. Grimes 				break;			/* all done thanks.. */
380acc9d408SJuli Mallett 			release_input(infile+ilevel--);
381b1ea3d46SJuli Mallett 			free(inname[ilevel+1]);
3829b50d902SRodney W. Grimes 			bufbase = bbase[ilevel];
383b1ea3d46SJuli Mallett 			emitline();
3849b50d902SRodney W. Grimes 			continue;
3859b50d902SRodney W. Grimes 		}
3869b50d902SRodney W. Grimes 	/*
387acc9d408SJuli Mallett 	 * non-alpha token possibly seen..
3889b50d902SRodney W. Grimes 	 * [the order of else if .. stmts is important.]
3899b50d902SRodney W. Grimes 	 */
390acc9d408SJuli Mallett 		else if (LOOK_AHEAD(t,lquote)) {	/* strip quotes */
391acc9d408SJuli Mallett 			nlpar = 0;
392acc9d408SJuli Mallett 			record(quotes, nlpar++);
393acc9d408SJuli Mallett 			/*
394acc9d408SJuli Mallett 			 * Opening quote: scan forward until matching
395acc9d408SJuli Mallett 			 * closing quote has been found.
396acc9d408SJuli Mallett 			 */
3979b50d902SRodney W. Grimes 			do {
398acc9d408SJuli Mallett 
399acc9d408SJuli Mallett 				l = gpbc();
400acc9d408SJuli Mallett 				if (LOOK_AHEAD(l,rquote)) {
401acc9d408SJuli Mallett 					if (--nlpar > 0)
402acc9d408SJuli Mallett 						outputstr(rquote);
403acc9d408SJuli Mallett 				} else if (LOOK_AHEAD(l,lquote)) {
404acc9d408SJuli Mallett 					record(quotes, nlpar++);
405acc9d408SJuli Mallett 					outputstr(lquote);
406acc9d408SJuli Mallett 				} else if (l == EOF) {
407acc9d408SJuli Mallett 					if (nlpar == 1)
408acc9d408SJuli Mallett 						warnx("unclosed quote:");
409acc9d408SJuli Mallett 					else
410acc9d408SJuli Mallett 						warnx("%d unclosed quotes:", nlpar);
411acc9d408SJuli Mallett 					dump_stack(quotes, nlpar);
412acc9d408SJuli Mallett 					exit(1);
413acc9d408SJuli Mallett 				} else {
4149b50d902SRodney W. Grimes 					if (nlpar > 0) {
4159b50d902SRodney W. Grimes 						if (sp < 0)
4169b50d902SRodney W. Grimes 							putc(l, active);
4179b50d902SRodney W. Grimes 						else
418acc9d408SJuli Mallett 							CHRSAVE(l);
419acc9d408SJuli Mallett 					}
4209b50d902SRodney W. Grimes 				}
4219b50d902SRodney W. Grimes 			}
4229b50d902SRodney W. Grimes 			while (nlpar != 0);
4239b50d902SRodney W. Grimes 		}
4249b50d902SRodney W. Grimes 
425acc9d408SJuli Mallett 		else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
426acc9d408SJuli Mallett 			fputs(scommt, active);
427acc9d408SJuli Mallett 
428acc9d408SJuli Mallett 			for(;;) {
429acc9d408SJuli Mallett 				t = gpbc();
430acc9d408SJuli Mallett 				if (LOOK_AHEAD(t, ecommt)) {
431acc9d408SJuli Mallett 					fputs(ecommt, active);
432acc9d408SJuli Mallett 					break;
433acc9d408SJuli Mallett 				}
434acc9d408SJuli Mallett 				if (t == EOF)
435acc9d408SJuli Mallett 					break;
4369b50d902SRodney W. Grimes 				putc(t, active);
4379b50d902SRodney W. Grimes 			}
438acc9d408SJuli Mallett 		}
439acc9d408SJuli Mallett 
440acc9d408SJuli Mallett 		else if (sp < 0) {		/* not in a macro at all */
4419b50d902SRodney W. Grimes 			putc(t, active);	/* output directly..	 */
4429b50d902SRodney W. Grimes 		}
4439b50d902SRodney W. Grimes 
4449b50d902SRodney W. Grimes 		else switch(t) {
4459b50d902SRodney W. Grimes 
4469b50d902SRodney W. Grimes 		case LPAREN:
4479b50d902SRodney W. Grimes 			if (PARLEV > 0)
4489b50d902SRodney W. Grimes 				chrsave(t);
449acc9d408SJuli Mallett 			while (isspace(l = gpbc()))
4509b50d902SRodney W. Grimes 				;		/* skip blank, tab, nl.. */
4519b50d902SRodney W. Grimes 			putback(l);
452acc9d408SJuli Mallett 			record(paren, PARLEV++);
4539b50d902SRodney W. Grimes 			break;
4549b50d902SRodney W. Grimes 
4559b50d902SRodney W. Grimes 		case RPAREN:
4569b50d902SRodney W. Grimes 			if (--PARLEV > 0)
4579b50d902SRodney W. Grimes 				chrsave(t);
4589b50d902SRodney W. Grimes 			else {			/* end of argument list */
4599b50d902SRodney W. Grimes 				chrsave(EOS);
4609b50d902SRodney W. Grimes 
461d40d348cSJuli Mallett 				if ((uintptr_t)sp == STACKMAX)
46295105358SPhilippe Charnier 					errx(1, "internal stack overflow");
4639b50d902SRodney W. Grimes 
464acc9d408SJuli Mallett 				eval((const char **) mstack+fp+1, sp-fp,
465acc9d408SJuli Mallett 				    CALTYP);
4669b50d902SRodney W. Grimes 
4679b50d902SRodney W. Grimes 				ep = PREVEP;	/* flush strspace */
4689b50d902SRodney W. Grimes 				sp = PREVSP;	/* previous sp..  */
4699b50d902SRodney W. Grimes 				fp = PREVFP;	/* rewind stack...*/
4709b50d902SRodney W. Grimes 			}
4719b50d902SRodney W. Grimes 			break;
4729b50d902SRodney W. Grimes 
4739b50d902SRodney W. Grimes 		case COMMA:
4749b50d902SRodney W. Grimes 			if (PARLEV == 1) {
4759b50d902SRodney W. Grimes 				chrsave(EOS);		/* new argument   */
476acc9d408SJuli Mallett 				while (isspace(l = gpbc()))
4779b50d902SRodney W. Grimes 					;
4789b50d902SRodney W. Grimes 				putback(l);
4799b50d902SRodney W. Grimes 				pushs(ep);
4809b50d902SRodney W. Grimes 			} else
4819b50d902SRodney W. Grimes 				chrsave(t);
4829b50d902SRodney W. Grimes 			break;
4839b50d902SRodney W. Grimes 
4849b50d902SRodney W. Grimes 		default:
485acc9d408SJuli Mallett 			if (LOOK_AHEAD(t, scommt)) {
486ccc5b4e6SJuli Mallett 				char *pc;
487ccc5b4e6SJuli Mallett 				for (pc = scommt; *pc; pc++)
488ccc5b4e6SJuli Mallett 					chrsave(*pc);
489acc9d408SJuli Mallett 				for(;;) {
490acc9d408SJuli Mallett 					t = gpbc();
491acc9d408SJuli Mallett 					if (LOOK_AHEAD(t, ecommt)) {
492ccc5b4e6SJuli Mallett 						for (pc = ecommt; *pc; pc++)
493ccc5b4e6SJuli Mallett 							chrsave(*pc);
494acc9d408SJuli Mallett 						break;
495acc9d408SJuli Mallett 					}
496acc9d408SJuli Mallett 					if (t == EOF)
497acc9d408SJuli Mallett 					    break;
498acc9d408SJuli Mallett 					CHRSAVE(t);
499acc9d408SJuli Mallett 				}
500acc9d408SJuli Mallett 			} else
501acc9d408SJuli Mallett 				CHRSAVE(t);		/* stack the char */
5029b50d902SRodney W. Grimes 			break;
5039b50d902SRodney W. Grimes 		}
5049b50d902SRodney W. Grimes 	}
5059b50d902SRodney W. Grimes }
5069b50d902SRodney W. Grimes 
5079b50d902SRodney W. Grimes /*
508acc9d408SJuli Mallett  * output string directly, without pushing it for reparses.
509acc9d408SJuli Mallett  */
510acc9d408SJuli Mallett void
511bd2bfb58SJuli Mallett outputstr(const char *s)
512acc9d408SJuli Mallett {
513acc9d408SJuli Mallett 	if (sp < 0)
514acc9d408SJuli Mallett 		while (*s)
515acc9d408SJuli Mallett 			putc(*s++, active);
516acc9d408SJuli Mallett 	else
517acc9d408SJuli Mallett 		while (*s)
518acc9d408SJuli Mallett 			CHRSAVE(*s++);
519acc9d408SJuli Mallett }
520acc9d408SJuli Mallett 
521acc9d408SJuli Mallett /*
5229b50d902SRodney W. Grimes  * build an input token..
5239b50d902SRodney W. Grimes  * consider only those starting with _ or A-Za-z. This is a
5249b50d902SRodney W. Grimes  * combo with lookup to speed things up.
5259b50d902SRodney W. Grimes  */
526acc9d408SJuli Mallett static ndptr
527bd2bfb58SJuli Mallett inspect(int c, char *tp)
5289b50d902SRodney W. Grimes {
529acc9d408SJuli Mallett 	char *name = tp;
530acc9d408SJuli Mallett 	char *etp = tp+MAXTOK;
531acc9d408SJuli Mallett 	ndptr p;
532acc9d408SJuli Mallett 	unsigned int h;
5339b50d902SRodney W. Grimes 
534acc9d408SJuli Mallett 	h = *tp++ = c;
535acc9d408SJuli Mallett 
536acc9d408SJuli Mallett 	while ((isalnum(c = gpbc()) || c == '_') && tp < etp)
5379b50d902SRodney W. Grimes 		h = (h << 5) + h + (*tp++ = c);
538acc9d408SJuli Mallett 	if (c != EOF)
539acc9d408SJuli Mallett 		PUTBACK(c);
5409b50d902SRodney W. Grimes 	*tp = EOS;
541acc9d408SJuli Mallett 	/* token is too long, it won't match anything, but it can still
542acc9d408SJuli Mallett 	 * be output. */
543acc9d408SJuli Mallett 	if (tp == ep) {
544acc9d408SJuli Mallett 		outputstr(name);
545acc9d408SJuli Mallett 		while (isalnum(c = gpbc()) || c == '_') {
546acc9d408SJuli Mallett 			if (sp < 0)
547acc9d408SJuli Mallett 				putc(c, active);
548acc9d408SJuli Mallett 			else
549acc9d408SJuli Mallett 				CHRSAVE(c);
550acc9d408SJuli Mallett 		}
551acc9d408SJuli Mallett 		*name = EOS;
552acc9d408SJuli Mallett 		return nil;
553acc9d408SJuli Mallett 	}
5549b50d902SRodney W. Grimes 
5559b50d902SRodney W. Grimes 	for (p = hashtab[h % HASHSIZE]; p != nil; p = p->nxtptr)
556acc9d408SJuli Mallett 		if (h == p->hv && STREQ(name, p->name))
5579b50d902SRodney W. Grimes 			break;
5589b50d902SRodney W. Grimes 	return p;
5599b50d902SRodney W. Grimes }
5609b50d902SRodney W. Grimes 
5619b50d902SRodney W. Grimes /*
5629b50d902SRodney W. Grimes  * initkwds - initialise m4 keywords as fast as possible.
5639b50d902SRodney W. Grimes  * This very similar to install, but without certain overheads,
5649b50d902SRodney W. Grimes  * such as calling lookup. Malloc is not used for storing the
5659b50d902SRodney W. Grimes  * keyword strings, since we simply use the static pointers
5669b50d902SRodney W. Grimes  * within keywrds block.
5679b50d902SRodney W. Grimes  */
568acc9d408SJuli Mallett static void
569d1fea89cSJuli Mallett initkwds(void)
570acc9d408SJuli Mallett {
571acc9d408SJuli Mallett 	size_t i;
572acc9d408SJuli Mallett 	unsigned int h;
573acc9d408SJuli Mallett 	ndptr p;
5749b50d902SRodney W. Grimes 
5759b50d902SRodney W. Grimes 	for (i = 0; i < MAXKEYS; i++) {
5769b50d902SRodney W. Grimes 		h = hash(keywrds[i].knam);
577acc9d408SJuli Mallett 		p = (ndptr) xalloc(sizeof(struct ndblock));
578acc9d408SJuli Mallett 		p->nxtptr = hashtab[h % HASHSIZE];
579acc9d408SJuli Mallett 		hashtab[h % HASHSIZE] = p;
580acc9d408SJuli Mallett 		p->name = xstrdup(keywrds[i].knam);
581ccc5b4e6SJuli Mallett 		p->defn = xstrdup(null);
582acc9d408SJuli Mallett 		p->hv = h;
583acc9d408SJuli Mallett 		p->type = keywrds[i].ktyp & TYPEMASK;
584acc9d408SJuli Mallett 		if ((keywrds[i].ktyp & NOARGS) == 0)
585acc9d408SJuli Mallett 			p->type |= NEEDARGS;
5869b50d902SRodney W. Grimes 	}
5879b50d902SRodney W. Grimes }
588b1ea3d46SJuli Mallett 
589acc9d408SJuli Mallett /* Look up a builtin type, even if overridden by the user */
590acc9d408SJuli Mallett int
591bd2bfb58SJuli Mallett builtin_type(const char *key)
592acc9d408SJuli Mallett {
593acc9d408SJuli Mallett 	int i;
594acc9d408SJuli Mallett 
595acc9d408SJuli Mallett 	for (i = 0; i != MAXKEYS; i++)
596acc9d408SJuli Mallett 		if (STREQ(keywrds[i].knam, key))
597acc9d408SJuli Mallett 			return keywrds[i].ktyp;
598acc9d408SJuli Mallett 	return -1;
599acc9d408SJuli Mallett }
600acc9d408SJuli Mallett 
601ccc5b4e6SJuli Mallett const char *
602bd2bfb58SJuli Mallett builtin_realname(int n)
603acc9d408SJuli Mallett {
604acc9d408SJuli Mallett 	int i;
605acc9d408SJuli Mallett 
606acc9d408SJuli Mallett 	for (i = 0; i != MAXKEYS; i++)
607acc9d408SJuli Mallett 		if (((keywrds[i].ktyp ^ n) & TYPEMASK) == 0)
608acc9d408SJuli Mallett 			return keywrds[i].knam;
609acc9d408SJuli Mallett 	return NULL;
610acc9d408SJuli Mallett }
611acc9d408SJuli Mallett 
612acc9d408SJuli Mallett static void
613bd2bfb58SJuli Mallett record(struct position *t, int lev)
614acc9d408SJuli Mallett {
615acc9d408SJuli Mallett 	if (lev < MAXRECORD) {
616acc9d408SJuli Mallett 		t[lev].name = CURRENT_NAME;
617acc9d408SJuli Mallett 		t[lev].line = CURRENT_LINE;
618acc9d408SJuli Mallett 	}
619acc9d408SJuli Mallett }
620acc9d408SJuli Mallett 
621acc9d408SJuli Mallett static void
622bd2bfb58SJuli Mallett dump_stack(struct position *t, int lev)
623acc9d408SJuli Mallett {
624acc9d408SJuli Mallett 	int i;
625acc9d408SJuli Mallett 
626acc9d408SJuli Mallett 	for (i = 0; i < lev; i++) {
627acc9d408SJuli Mallett 		if (i == MAXRECORD) {
628acc9d408SJuli Mallett 			fprintf(stderr, "   ...\n");
629acc9d408SJuli Mallett 			break;
630acc9d408SJuli Mallett 		}
631acc9d408SJuli Mallett 		fprintf(stderr, "   %s at line %lu\n",
632acc9d408SJuli Mallett 			t[i].name, t[i].line);
633acc9d408SJuli Mallett 	}
634acc9d408SJuli Mallett }
635acc9d408SJuli Mallett 
636acc9d408SJuli Mallett 
637acc9d408SJuli Mallett static void
638d1fea89cSJuli Mallett enlarge_stack(void)
639acc9d408SJuli Mallett {
640acc9d408SJuli Mallett 	STACKMAX *= 2;
641acc9d408SJuli Mallett 	mstack = realloc(mstack, sizeof(stae) * STACKMAX);
642acc9d408SJuli Mallett 	sstack = realloc(sstack, STACKMAX);
643acc9d408SJuli Mallett 	if (mstack == NULL || sstack == NULL)
644acc9d408SJuli Mallett 		errx(1, "Evaluation stack overflow (%lu)",
645acc9d408SJuli Mallett 		    (unsigned long)STACKMAX);
646acc9d408SJuli Mallett }
647acc9d408SJuli Mallett 
648b1ea3d46SJuli Mallett /* Emit preprocessor #line directive if -s option used. */
649b1ea3d46SJuli Mallett void
650b1ea3d46SJuli Mallett emitline(void)
651b1ea3d46SJuli Mallett {
652acc9d408SJuli Mallett 
653b1ea3d46SJuli Mallett 	if (synccpp)
654b1ea3d46SJuli Mallett 		fprintf(active, "#line %d \"%s\"\n", inlineno[ilevel],
655b1ea3d46SJuli Mallett 			inname[ilevel]);
656b1ea3d46SJuli Mallett }
657