main.c revision 250226 
1/*	$OpenBSD: main.c,v 1.81 2012/04/12 17:00:11 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 250226 2013-05-03 23:29:38Z jkim $");
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
88static struct 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 exit_code = 0;
168
169int
170main(int argc, char *argv[])
171{
172	int c;
173	int n;
174	char *p;
175
176	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
177		signal(SIGINT, onintr);
178
179	init_macros();
180	initspaces();
181	STACKMAX = INITSTACKMAX;
182
183	mstack = (stae *)xalloc(sizeof(stae) * STACKMAX, NULL);
184	sstack = (char *)xalloc(STACKMAX, NULL);
185
186	maxout = 0;
187	outfile = NULL;
188	resizedivs(MAXOUT);
189
190	while ((c = getopt(argc, argv, "gst:d:D:U:o:I:P")) != -1)
191		switch(c) {
192
193		case 'D':               /* define something..*/
194			for (p = optarg; *p; p++)
195				if (*p == '=')
196					break;
197			if (*p)
198				*p++ = EOS;
199			dodefine(optarg, p);
200			break;
201		case 'I':
202			addtoincludepath(optarg);
203			break;
204		case 'P':
205			prefix_builtins = 1;
206			break;
207		case 'U':               /* undefine...       */
208			macro_popdef(optarg);
209			break;
210		case 'g':
211			mimic_gnu = 1;
212			break;
213		case 'd':
214			set_trace_flags(optarg);
215			break;
216		case 's':
217			synch_lines = 1;
218			break;
219		case 't':
220			mark_traced(optarg, 1);
221			break;
222		case 'o':
223			trace_file(optarg);
224                        break;
225		case '?':
226			usage();
227		}
228
229        argc -= optind;
230        argv += optind;
231
232	initkwds();
233	if (mimic_gnu)
234		setup_builtin("format", FORMATTYPE);
235
236	active = stdout;		/* default active output     */
237	bbase[0] = bufbase;
238        if (!argc) {
239		sp = -1;		/* stack pointer initialized */
240		fp = 0;			/* frame pointer initialized */
241		set_input(infile+0, stdin, "stdin");
242					/* default input (naturally) */
243		macro();
244	} else
245		for (; argc--; ++argv) {
246			p = *argv;
247			if (p[0] == '-' && p[1] == EOS)
248				set_input(infile, stdin, "stdin");
249			else if (fopen_trypath(infile, p) == NULL)
250				err(1, "%s", p);
251			sp = -1;
252			fp = 0;
253			macro();
254			release_input(infile);
255		}
256
257	if (wrapindex) {
258		int i;
259
260		ilevel = 0;		/* in case m4wrap includes.. */
261		bufbase = bp = buf;	/* use the entire buffer   */
262		if (mimic_gnu) {
263			while (wrapindex != 0) {
264				for (i = 0; i < wrapindex; i++)
265					pbstr(m4wraps[i]);
266				wrapindex =0;
267				macro();
268			}
269		} else {
270			for (i = 0; i < wrapindex; i++) {
271				pbstr(m4wraps[i]);
272				macro();
273			}
274		}
275	}
276
277	if (active != stdout)
278		active = stdout;	/* reset output just in case */
279	for (n = 1; n < maxout; n++)	/* default wrap-up: undivert */
280		if (outfile[n] != NULL)
281			getdiv(n);
282					/* remove bitbucket if used  */
283	if (outfile[0] != NULL) {
284		(void) fclose(outfile[0]);
285	}
286
287	return exit_code;
288}
289
290/*
291 * Look ahead for `token'.
292 * (on input `t == token[0]')
293 * Used for comment and quoting delimiters.
294 * Returns 1 if `token' present; copied to output.
295 *         0 if `token' not found; all characters pushed back
296 */
297static int
298do_look_ahead(int t, const char *token)
299{
300	int i;
301
302	assert((unsigned char)t == (unsigned char)token[0]);
303
304	for (i = 1; *++token; i++) {
305		t = gpbc();
306		if (t == EOF || (unsigned char)t != (unsigned char)*token) {
307			pushback(t);
308			while (--i)
309				pushback(*--token);
310			return 0;
311		}
312	}
313	return 1;
314}
315
316#define LOOK_AHEAD(t, token) (t != EOF &&		\
317    (unsigned char)(t)==(unsigned char)(token)[0] &&	\
318    do_look_ahead(t,token))
319
320/*
321 * macro - the work horse..
322 */
323static void
324macro(void)
325{
326	char token[MAXTOK+1];
327	int t, l;
328	ndptr p;
329	int  nlpar;
330
331	cycle {
332		t = gpbc();
333
334		if (LOOK_AHEAD(t,lquote)) {	/* strip quotes */
335			nlpar = 0;
336			record(quotes, nlpar++);
337			/*
338			 * Opening quote: scan forward until matching
339			 * closing quote has been found.
340			 */
341			do {
342
343				l = gpbc();
344				if (LOOK_AHEAD(l,rquote)) {
345					if (--nlpar > 0)
346						outputstr(rquote);
347				} else if (LOOK_AHEAD(l,lquote)) {
348					record(quotes, nlpar++);
349					outputstr(lquote);
350				} else if (l == EOF) {
351					if (nlpar == 1)
352						warnx("unclosed quote:");
353					else
354						warnx("%d unclosed quotes:", nlpar);
355					dump_stack(quotes, nlpar);
356					exit(1);
357				} else {
358					if (nlpar > 0) {
359						if (sp < 0)
360							reallyputchar(l);
361						else
362							CHRSAVE(l);
363					}
364				}
365			}
366			while (nlpar != 0);
367		} else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
368			reallyoutputstr(scommt);
369
370			for(;;) {
371				t = gpbc();
372				if (LOOK_AHEAD(t, ecommt)) {
373					reallyoutputstr(ecommt);
374					break;
375				}
376				if (t == EOF)
377					break;
378				reallyputchar(t);
379			}
380		} else if (t == '_' || isalpha(t)) {
381			p = inspect(t, token);
382			if (p != NULL)
383				pushback(l = gpbc());
384			if (p == NULL || (l != LPAREN &&
385			    (macro_getdef(p)->type & NEEDARGS) != 0))
386				outputstr(token);
387			else {
388		/*
389		 * real thing.. First build a call frame:
390		 */
391				pushf(fp);	/* previous call frm */
392				pushf(macro_getdef(p)->type); /* type of the call  */
393				pushf(is_traced(p));
394				pushf(0);	/* parenthesis level */
395				fp = sp;	/* new frame pointer */
396		/*
397		 * now push the string arguments:
398		 */
399				pushs1(macro_getdef(p)->defn);	/* defn string */
400				pushs1((char *)macro_name(p));	/* macro name  */
401				pushs(ep);			/* start next..*/
402
403				if (l != LPAREN && PARLEV == 0) {
404				    /* no bracks  */
405					chrsave(EOS);
406
407					if (sp == (int)STACKMAX)
408						errx(1, "internal stack overflow");
409					eval((const char **) mstack+fp+1, 2,
410					    CALTYP, TRACESTATUS);
411
412					ep = PREVEP;	/* flush strspace */
413					sp = PREVSP;	/* previous sp..  */
414					fp = PREVFP;	/* rewind stack...*/
415				}
416			}
417		} else if (t == EOF) {
418			if (sp > -1 && ilevel <= 0) {
419				warnx( "unexpected end of input, unclosed parenthesis:");
420				dump_stack(paren, PARLEV);
421				exit(1);
422			}
423			if (ilevel <= 0)
424				break;			/* all done thanks.. */
425			release_input(infile+ilevel--);
426			emit_synchline();
427			bufbase = bbase[ilevel];
428			continue;
429		} else if (sp < 0) {		/* not in a macro at all */
430			reallyputchar(t);	/* output directly..	 */
431		}
432
433		else switch(t) {
434
435		case LPAREN:
436			if (PARLEV > 0)
437				chrsave(t);
438			while (isspace(l = gpbc())) /* skip blank, tab, nl.. */
439				if (PARLEV > 0)
440					chrsave(l);
441			pushback(l);
442			record(paren, PARLEV++);
443			break;
444
445		case RPAREN:
446			if (--PARLEV > 0)
447				chrsave(t);
448			else {			/* end of argument list */
449				chrsave(EOS);
450
451				if (sp == (int)STACKMAX)
452					errx(1, "internal stack overflow");
453
454				eval((const char **) mstack+fp+1, sp-fp,
455				    CALTYP, TRACESTATUS);
456
457				ep = PREVEP;	/* flush strspace */
458				sp = PREVSP;	/* previous sp..  */
459				fp = PREVFP;	/* rewind stack...*/
460			}
461			break;
462
463		case COMMA:
464			if (PARLEV == 1) {
465				chrsave(EOS);		/* new argument   */
466				while (isspace(l = gpbc()))
467					;
468				pushback(l);
469				pushs(ep);
470			} else
471				chrsave(t);
472			break;
473
474		default:
475			if (LOOK_AHEAD(t, scommt)) {
476				char *cp;
477				for (cp = scommt; *cp; cp++)
478					chrsave(*cp);
479				for(;;) {
480					t = gpbc();
481					if (LOOK_AHEAD(t, ecommt)) {
482						for (cp = ecommt; *cp; cp++)
483							chrsave(*cp);
484						break;
485					}
486					if (t == EOF)
487					    break;
488					CHRSAVE(t);
489				}
490			} else
491				CHRSAVE(t);		/* stack the char */
492			break;
493		}
494	}
495}
496
497/*
498 * output string directly, without pushing it for reparses.
499 */
500void
501outputstr(const char *s)
502{
503	if (sp < 0)
504		reallyoutputstr(s);
505	else
506		while (*s)
507			CHRSAVE(*s++);
508}
509
510void
511reallyoutputstr(const char *s)
512{
513	if (synch_lines) {
514		while (*s) {
515			fputc(*s, active);
516			if (*s++ == '\n') {
517				infile[ilevel].synch_lineno++;
518				if (infile[ilevel].synch_lineno !=
519				    infile[ilevel].lineno)
520					do_emit_synchline();
521			}
522		}
523	} else
524		fputs(s, active);
525}
526
527void
528reallyputchar(int c)
529{
530	putc(c, active);
531	if (synch_lines && c == '\n') {
532		infile[ilevel].synch_lineno++;
533		if (infile[ilevel].synch_lineno != infile[ilevel].lineno)
534			do_emit_synchline();
535	}
536}
537
538/*
539 * build an input token..
540 * consider only those starting with _ or A-Za-z.
541 */
542static ndptr
543inspect(int c, char *tp)
544{
545	char *name = tp;
546	char *etp = tp+MAXTOK;
547	ndptr p;
548
549	*tp++ = c;
550
551	while ((isalnum(c = gpbc()) || c == '_') && tp < etp)
552		*tp++ = c;
553	if (c != EOF)
554		PUSHBACK(c);
555	*tp = EOS;
556	/* token is too long, it won't match anything, but it can still
557	 * be output. */
558	if (tp == ep) {
559		outputstr(name);
560		while (isalnum(c = gpbc()) || c == '_') {
561			if (sp < 0)
562				reallyputchar(c);
563			else
564				CHRSAVE(c);
565		}
566		*name = EOS;
567		return NULL;
568	}
569
570	p = ohash_find(&macros, ohash_qlookupi(&macros, name, (const char **)&tp));
571	if (p == NULL)
572		return NULL;
573	if (macro_getdef(p) == NULL)
574		return NULL;
575	return p;
576}
577
578/*
579 * initkwds - initialise m4 keywords as fast as possible.
580 * This very similar to install, but without certain overheads,
581 * such as calling lookup. Malloc is not used for storing the
582 * keyword strings, since we simply use the static pointers
583 * within keywrds block.
584 */
585static void
586initkwds(void)
587{
588	unsigned int type;
589	int i;
590
591	for (i = 0; i < (int)MAXKEYS; i++) {
592		type = keywrds[i].ktyp & TYPEMASK;
593		if ((keywrds[i].ktyp & NOARGS) == 0)
594			type |= NEEDARGS;
595		setup_builtin(keywrds[i].knam, type);
596	}
597}
598
599static void
600record(struct position *t, int lev)
601{
602	if (lev < MAXRECORD) {
603		t[lev].name = CURRENT_NAME;
604		t[lev].line = CURRENT_LINE;
605	}
606}
607
608static void
609dump_stack(struct position *t, int lev)
610{
611	int i;
612
613	for (i = 0; i < lev; i++) {
614		if (i == MAXRECORD) {
615			fprintf(stderr, "   ...\n");
616			break;
617		}
618		fprintf(stderr, "   %s at line %lu\n",
619			t[i].name, t[i].line);
620	}
621}
622
623
624static void
625enlarge_stack(void)
626{
627	STACKMAX += STACKMAX/2;
628	mstack = xrealloc(mstack, sizeof(stae) * STACKMAX,
629	    "Evaluation stack overflow (%lu)",
630	    (unsigned long)STACKMAX);
631	sstack = xrealloc(sstack, STACKMAX,
632	    "Evaluation stack overflow (%lu)",
633	    (unsigned long)STACKMAX);
634}
635