main.c revision 228063 
1/*	$OpenBSD: main.c,v 1.80 2011/09/27 07:24:02 espie Exp $	*/
2/*	$NetBSD: main.c,v 1.12 1997/02/08 23:54:49 cgd Exp $	*/
3
4/*-
5 * Copyright (c) 1989, 1993
6 *	The Regents of the University of California.  All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by
9 * Ozan Yigit at York University.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its contributors
20 *    may be used to endorse or promote products derived from this software
21 *    without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36/*
37 * main.c
38 * Facility: m4 macro processor
39 * by: oz
40 */
41#include <sys/cdefs.h>
42__FBSDID("$FreeBSD: head/usr.bin/m4/main.c 228063 2011-11-28 13:32:39Z bapt $");
43
44#include <assert.h>
45#include <signal.h>
46#include <err.h>
47#include <errno.h>
48#include <unistd.h>
49#include <stdio.h>
50#include <ctype.h>
51#include <string.h>
52#include <stddef.h>
53#include <stdint.h>
54#include <stdlib.h>
55#include <ohash.h>
56#include "mdef.h"
57#include "stdd.h"
58#include "extern.h"
59#include "pathnames.h"
60
61stae *mstack;			/* stack of m4 machine         */
62char *sstack;			/* shadow stack, for string space extension */
63static size_t STACKMAX;		/* current maximum size of stack */
64int sp;				/* current m4  stack pointer   */
65int fp;				/* m4 call frame pointer       */
66struct input_file infile[MAXINP];/* input file stack (0=stdin)  */
67FILE **outfile;			/* diversion array(0=bitbucket)*/
68int maxout;
69FILE *active;			/* active output file pointer  */
70int ilevel = 0;			/* input file stack pointer    */
71int oindex = 0;			/* diversion index..	       */
72const char *null = "";                /* as it says.. just a null..  */
73char **m4wraps = NULL;		/* m4wraps array.	       */
74int maxwraps = 0;		/* size of m4wraps array       */
75int wrapindex = 0;		/* current offset in m4wraps   */
76char lquote[MAXCCHARS+1] = {LQUOTE};	/* left quote character  (`)   */
77char rquote[MAXCCHARS+1] = {RQUOTE};	/* right quote character (')   */
78char scommt[MAXCCHARS+1] = {SCOMMT};	/* start character for comment */
79char ecommt[MAXCCHARS+1] = {ECOMMT};	/* end character for comment   */
80int  synch_lines = 0;		/* line synchronisation for C preprocessor */
81int  prefix_builtins = 0;	/* -P option to prefix builtin keywords */
82
83struct keyblk {
84        const char    *knam;          /* keyword name */
85        int     ktyp;           /* keyword type */
86};
87
88struct keyblk keywrds[] = {	/* m4 keywords to be installed */
89	{ "include",      INCLTYPE },
90	{ "sinclude",     SINCTYPE },
91	{ "define",       DEFITYPE },
92	{ "defn",         DEFNTYPE },
93	{ "divert",       DIVRTYPE | NOARGS },
94	{ "expr",         EXPRTYPE },
95	{ "eval",         EXPRTYPE },
96	{ "substr",       SUBSTYPE },
97	{ "ifelse",       IFELTYPE },
98	{ "ifdef",        IFDFTYPE },
99	{ "len",          LENGTYPE },
100	{ "incr",         INCRTYPE },
101	{ "decr",         DECRTYPE },
102	{ "dnl",          DNLNTYPE | NOARGS },
103	{ "changequote",  CHNQTYPE | NOARGS },
104	{ "changecom",    CHNCTYPE | NOARGS },
105	{ "index",        INDXTYPE },
106#ifdef EXTENDED
107	{ "paste",        PASTTYPE },
108	{ "spaste",       SPASTYPE },
109	/* Newer extensions, needed to handle gnu-m4 scripts */
110	{ "indir",        INDIRTYPE},
111	{ "builtin",      BUILTINTYPE},
112	{ "patsubst",	  PATSTYPE},
113	{ "regexp",	  REGEXPTYPE},
114	{ "esyscmd",	  ESYSCMDTYPE},
115	{ "__file__",	  FILENAMETYPE | NOARGS},
116	{ "__line__",	  LINETYPE | NOARGS},
117#endif
118	{ "popdef",       POPDTYPE },
119	{ "pushdef",      PUSDTYPE },
120	{ "dumpdef",      DUMPTYPE | NOARGS },
121	{ "shift",        SHIFTYPE | NOARGS },
122	{ "translit",     TRNLTYPE },
123	{ "undefine",     UNDFTYPE },
124	{ "undivert",     UNDVTYPE | NOARGS },
125	{ "divnum",       DIVNTYPE | NOARGS },
126	{ "maketemp",     MKTMTYPE },
127	{ "mkstemp",      MKTMTYPE },
128	{ "errprint",     ERRPTYPE | NOARGS },
129	{ "m4wrap",       M4WRTYPE | NOARGS },
130	{ "m4exit",       EXITTYPE | NOARGS },
131	{ "syscmd",       SYSCTYPE },
132	{ "sysval",       SYSVTYPE | NOARGS },
133	{ "traceon",	  TRACEONTYPE | NOARGS },
134	{ "traceoff",	  TRACEOFFTYPE | NOARGS },
135
136#if defined(unix) || defined(__unix__)
137	{ "unix",         SELFTYPE | NOARGS },
138#else
139#ifdef vms
140	{ "vms",          SELFTYPE | NOARGS },
141#endif
142#endif
143};
144
145#define MAXKEYS	(sizeof(keywrds)/sizeof(struct keyblk))
146
147#define MAXRECORD 50
148static struct position {
149	char *name;
150	unsigned long line;
151} quotes[MAXRECORD], paren[MAXRECORD];
152
153static void record(struct position *, int);
154static void dump_stack(struct position *, int);
155
156static void macro(void);
157static void initkwds(void);
158static ndptr inspect(int, char *);
159static int do_look_ahead(int, const char *);
160static void reallyoutputstr(const char *);
161static void reallyputchar(int);
162
163static void enlarge_stack(void);
164
165int main(int, char *[]);
166
167int
168main(int argc, char *argv[])
169{
170	int c;
171	int n;
172	char *p;
173
174	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
175		signal(SIGINT, onintr);
176
177	init_macros();
178	initspaces();
179	STACKMAX = INITSTACKMAX;
180
181	mstack = (stae *)xalloc(sizeof(stae) * STACKMAX, NULL);
182	sstack = (char *)xalloc(STACKMAX, NULL);
183
184	maxout = 0;
185	outfile = NULL;
186	resizedivs(MAXOUT);
187
188	while ((c = getopt(argc, argv, "gst:d:D:U:o:I:P")) != -1)
189		switch(c) {
190
191		case 'D':               /* define something..*/
192			for (p = optarg; *p; p++)
193				if (*p == '=')
194					break;
195			if (*p)
196				*p++ = EOS;
197			dodefine(optarg, p);
198			break;
199		case 'I':
200			addtoincludepath(optarg);
201			break;
202		case 'P':
203			prefix_builtins = 1;
204			break;
205		case 'U':               /* undefine...       */
206			macro_popdef(optarg);
207			break;
208		case 'g':
209			mimic_gnu = 1;
210			break;
211		case 'd':
212			set_trace_flags(optarg);
213			break;
214		case 's':
215			synch_lines = 1;
216			break;
217		case 't':
218			mark_traced(optarg, 1);
219			break;
220		case 'o':
221			trace_file(optarg);
222                        break;
223		case '?':
224			usage();
225		}
226
227        argc -= optind;
228        argv += optind;
229
230	initkwds();
231	if (mimic_gnu)
232		setup_builtin("format", FORMATTYPE);
233
234	active = stdout;		/* default active output     */
235	bbase[0] = bufbase;
236        if (!argc) {
237		sp = -1;		/* stack pointer initialized */
238		fp = 0;			/* frame pointer initialized */
239		set_input(infile+0, stdin, "stdin");
240					/* default input (naturally) */
241		macro();
242	} else
243		for (; argc--; ++argv) {
244			p = *argv;
245			if (p[0] == '-' && p[1] == EOS)
246				set_input(infile, stdin, "stdin");
247			else if (fopen_trypath(infile, p) == NULL)
248				err(1, "%s", p);
249			sp = -1;
250			fp = 0;
251			macro();
252			release_input(infile);
253		}
254
255	if (wrapindex) {
256		int i;
257
258		ilevel = 0;		/* in case m4wrap includes.. */
259		bufbase = bp = buf;	/* use the entire buffer   */
260		if (mimic_gnu) {
261			while (wrapindex != 0) {
262				for (i = 0; i < wrapindex; i++)
263					pbstr(m4wraps[i]);
264				wrapindex =0;
265				macro();
266			}
267		} else {
268			for (i = 0; i < wrapindex; i++) {
269				pbstr(m4wraps[i]);
270				macro();
271			}
272		}
273	}
274
275	if (active != stdout)
276		active = stdout;	/* reset output just in case */
277	for (n = 1; n < maxout; n++)	/* default wrap-up: undivert */
278		if (outfile[n] != NULL)
279			getdiv(n);
280					/* remove bitbucket if used  */
281	if (outfile[0] != NULL) {
282		(void) fclose(outfile[0]);
283	}
284
285	return 0;
286}
287
288/*
289 * Look ahead for `token'.
290 * (on input `t == token[0]')
291 * Used for comment and quoting delimiters.
292 * Returns 1 if `token' present; copied to output.
293 *         0 if `token' not found; all characters pushed back
294 */
295static int
296do_look_ahead(int t, const char *token)
297{
298	int i;
299
300	assert((unsigned char)t == (unsigned char)token[0]);
301
302	for (i = 1; *++token; i++) {
303		t = gpbc();
304		if (t == EOF || (unsigned char)t != (unsigned char)*token) {
305			pushback(t);
306			while (--i)
307				pushback(*--token);
308			return 0;
309		}
310	}
311	return 1;
312}
313
314#define LOOK_AHEAD(t, token) (t != EOF &&		\
315    (unsigned char)(t)==(unsigned char)(token)[0] &&	\
316    do_look_ahead(t,token))
317
318/*
319 * macro - the work horse..
320 */
321static void
322macro(void)
323{
324	char token[MAXTOK+1];
325	int t, l;
326	ndptr p;
327	int  nlpar;
328
329	cycle {
330		t = gpbc();
331
332		if (LOOK_AHEAD(t,lquote)) {	/* strip quotes */
333			nlpar = 0;
334			record(quotes, nlpar++);
335			/*
336			 * Opening quote: scan forward until matching
337			 * closing quote has been found.
338			 */
339			do {
340
341				l = gpbc();
342				if (LOOK_AHEAD(l,rquote)) {
343					if (--nlpar > 0)
344						outputstr(rquote);
345				} else if (LOOK_AHEAD(l,lquote)) {
346					record(quotes, nlpar++);
347					outputstr(lquote);
348				} else if (l == EOF) {
349					if (nlpar == 1)
350						warnx("unclosed quote:");
351					else
352						warnx("%d unclosed quotes:", nlpar);
353					dump_stack(quotes, nlpar);
354					exit(1);
355				} else {
356					if (nlpar > 0) {
357						if (sp < 0)
358							reallyputchar(l);
359						else
360							CHRSAVE(l);
361					}
362				}
363			}
364			while (nlpar != 0);
365		} else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
366			reallyoutputstr(scommt);
367
368			for(;;) {
369				t = gpbc();
370				if (LOOK_AHEAD(t, ecommt)) {
371					reallyoutputstr(ecommt);
372					break;
373				}
374				if (t == EOF)
375					break;
376				reallyputchar(t);
377			}
378		} else if (t == '_' || isalpha(t)) {
379			p = inspect(t, token);
380			if (p != NULL)
381				pushback(l = gpbc());
382			if (p == NULL || (l != LPAREN &&
383			    (macro_getdef(p)->type & NEEDARGS) != 0))
384				outputstr(token);
385			else {
386		/*
387		 * real thing.. First build a call frame:
388		 */
389				pushf(fp);	/* previous call frm */
390				pushf(macro_getdef(p)->type); /* type of the call  */
391				pushf(is_traced(p));
392				pushf(0);	/* parenthesis level */
393				fp = sp;	/* new frame pointer */
394		/*
395		 * now push the string arguments:
396		 */
397				pushs1(macro_getdef(p)->defn);	/* defn string */
398				pushs1((char *)macro_name(p));	/* macro name  */
399				pushs(ep);			/* start next..*/
400
401				if (l != LPAREN && PARLEV == 0) {
402				    /* no bracks  */
403					chrsave(EOS);
404
405					if (sp == (int)STACKMAX)
406						errx(1, "internal stack overflow");
407					eval((const char **) mstack+fp+1, 2,
408					    CALTYP, TRACESTATUS);
409
410					ep = PREVEP;	/* flush strspace */
411					sp = PREVSP;	/* previous sp..  */
412					fp = PREVFP;	/* rewind stack...*/
413				}
414			}
415		} else if (t == EOF) {
416			if (sp > -1 && ilevel <= 0) {
417				warnx( "unexpected end of input, unclosed parenthesis:");
418				dump_stack(paren, PARLEV);
419				exit(1);
420			}
421			if (ilevel <= 0)
422				break;			/* all done thanks.. */
423			release_input(infile+ilevel--);
424			emit_synchline();
425			bufbase = bbase[ilevel];
426			continue;
427		} else if (sp < 0) {		/* not in a macro at all */
428			reallyputchar(t);	/* output directly..	 */
429		}
430
431		else switch(t) {
432
433		case LPAREN:
434			if (PARLEV > 0)
435				chrsave(t);
436			while (isspace(l = gpbc())) /* skip blank, tab, nl.. */
437				if (PARLEV > 0)
438					chrsave(l);
439			pushback(l);
440			record(paren, PARLEV++);
441			break;
442
443		case RPAREN:
444			if (--PARLEV > 0)
445				chrsave(t);
446			else {			/* end of argument list */
447				chrsave(EOS);
448
449				if (sp == (int)STACKMAX)
450					errx(1, "internal stack overflow");
451
452				eval((const char **) mstack+fp+1, sp-fp,
453				    CALTYP, TRACESTATUS);
454
455				ep = PREVEP;	/* flush strspace */
456				sp = PREVSP;	/* previous sp..  */
457				fp = PREVFP;	/* rewind stack...*/
458			}
459			break;
460
461		case COMMA:
462			if (PARLEV == 1) {
463				chrsave(EOS);		/* new argument   */
464				while (isspace(l = gpbc()))
465					;
466				pushback(l);
467				pushs(ep);
468			} else
469				chrsave(t);
470			break;
471
472		default:
473			if (LOOK_AHEAD(t, scommt)) {
474				char *cp;
475				for (cp = scommt; *cp; cp++)
476					chrsave(*cp);
477				for(;;) {
478					t = gpbc();
479					if (LOOK_AHEAD(t, ecommt)) {
480						for (cp = ecommt; *cp; cp++)
481							chrsave(*cp);
482						break;
483					}
484					if (t == EOF)
485					    break;
486					CHRSAVE(t);
487				}
488			} else
489				CHRSAVE(t);		/* stack the char */
490			break;
491		}
492	}
493}
494
495/*
496 * output string directly, without pushing it for reparses.
497 */
498void
499outputstr(const char *s)
500{
501	if (sp < 0)
502		reallyoutputstr(s);
503	else
504		while (*s)
505			CHRSAVE(*s++);
506}
507
508void
509reallyoutputstr(const char *s)
510{
511	if (synch_lines) {
512		while (*s) {
513			fputc(*s, active);
514			if (*s++ == '\n') {
515				infile[ilevel].synch_lineno++;
516				if (infile[ilevel].synch_lineno !=
517				    infile[ilevel].lineno)
518					do_emit_synchline();
519			}
520		}
521	} else
522		fputs(s, active);
523}
524
525void
526reallyputchar(int c)
527{
528	putc(c, active);
529	if (synch_lines && c == '\n') {
530		infile[ilevel].synch_lineno++;
531		if (infile[ilevel].synch_lineno != infile[ilevel].lineno)
532			do_emit_synchline();
533	}
534}
535
536/*
537 * build an input token..
538 * consider only those starting with _ or A-Za-z.
539 */
540static ndptr
541inspect(int c, char *tp)
542{
543	char *name = tp;
544	char *etp = tp+MAXTOK;
545	ndptr p;
546
547	*tp++ = c;
548
549	while ((isalnum(c = gpbc()) || c == '_') && tp < etp)
550		*tp++ = c;
551	if (c != EOF)
552		PUSHBACK(c);
553	*tp = EOS;
554	/* token is too long, it won't match anything, but it can still
555	 * be output. */
556	if (tp == ep) {
557		outputstr(name);
558		while (isalnum(c = gpbc()) || c == '_') {
559			if (sp < 0)
560				reallyputchar(c);
561			else
562				CHRSAVE(c);
563		}
564		*name = EOS;
565		return NULL;
566	}
567
568	p = ohash_find(&macros, ohash_qlookupi(&macros, name, (const char **)&tp));
569	if (p == NULL)
570		return NULL;
571	if (macro_getdef(p) == NULL)
572		return NULL;
573	return p;
574}
575
576/*
577 * initkwds - initialise m4 keywords as fast as possible.
578 * This very similar to install, but without certain overheads,
579 * such as calling lookup. Malloc is not used for storing the
580 * keyword strings, since we simply use the static pointers
581 * within keywrds block.
582 */
583static void
584initkwds(void)
585{
586	unsigned int type;
587	int i;
588
589	for (i = 0; i < (int)MAXKEYS; i++) {
590		type = keywrds[i].ktyp & TYPEMASK;
591		if ((keywrds[i].ktyp & NOARGS) == 0)
592			type |= NEEDARGS;
593		setup_builtin(keywrds[i].knam, type);
594	}
595}
596
597static void
598record(struct position *t, int lev)
599{
600	if (lev < MAXRECORD) {
601		t[lev].name = CURRENT_NAME;
602		t[lev].line = CURRENT_LINE;
603	}
604}
605
606static void
607dump_stack(struct position *t, int lev)
608{
609	int i;
610
611	for (i = 0; i < lev; i++) {
612		if (i == MAXRECORD) {
613			fprintf(stderr, "   ...\n");
614			break;
615		}
616		fprintf(stderr, "   %s at line %lu\n",
617			t[i].name, t[i].line);
618	}
619}
620
621
622static void
623enlarge_stack(void)
624{
625	STACKMAX += STACKMAX/2;
626	mstack = xrealloc(mstack, sizeof(stae) * STACKMAX,
627	    "Evaluation stack overflow (%lu)",
628	    (unsigned long)STACKMAX);
629	sstack = xrealloc(sstack, STACKMAX,
630	    "Evaluation stack overflow (%lu)",
631	    (unsigned long)STACKMAX);
632}
633