xref: /freebsd/usr.bin/m4/gnum4.c (revision e17f5b1d) 
1 /* $OpenBSD: gnum4.c,v 1.52 2017/08/21 21:41:13 deraadt Exp $ */
2 
3 /*-
4  * SPDX-License-Identifier: BSD-2-Clause
5  *
6  * Copyright (c) 1999 Marc Espie
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 /*
33  * functions needed to support gnu-m4 extensions, including a fake freezing
34  */
35 
36 #include <sys/types.h>
37 #include <sys/wait.h>
38 #include <ctype.h>
39 #include <err.h>
40 #include <paths.h>
41 #include <regex.h>
42 #include <stdarg.h>
43 #include <stddef.h>
44 #include <stdlib.h>
45 #include <stdint.h>
46 #include <stdio.h>
47 #include <string.h>
48 #include <errno.h>
49 #include <unistd.h>
50 #include <limits.h>
51 #include "mdef.h"
52 #include "stdd.h"
53 #include "extern.h"
54 
55 
56 int mimic_gnu = 0;
57 
58 /*
59  * Support for include path search
60  * First search in the current directory.
61  * If not found, and the path is not absolute, include path kicks in.
62  * First, -I options, in the order found on the command line.
63  * Then M4PATH env variable
64  */
65 
66 static struct path_entry {
67 	char *name;
68 	struct path_entry *next;
69 } *first, *last;
70 
71 static struct path_entry *new_path_entry(const char *);
72 static void ensure_m4path(void);
73 static struct input_file *dopath(struct input_file *, const char *);
74 
75 static struct path_entry *
76 new_path_entry(const char *dirname)
77 {
78 	struct path_entry *n;
79 
80 	n = malloc(sizeof(struct path_entry));
81 	if (!n)
82 		errx(1, "out of memory");
83 	n->name = xstrdup(dirname);
84 	n->next = 0;
85 	return n;
86 }
87 
88 void
89 addtoincludepath(const char *dirname)
90 {
91 	struct path_entry *n;
92 
93 	n = new_path_entry(dirname);
94 
95 	if (last) {
96 		last->next = n;
97 		last = n;
98 	}
99 	else
100 		last = first = n;
101 }
102 
103 static void
104 ensure_m4path(void)
105 {
106 	static int envpathdone = 0;
107 	char *envpath;
108 	char *sweep;
109 	char *path;
110 
111 	if (envpathdone)
112 		return;
113 	envpathdone = TRUE;
114 	envpath = getenv("M4PATH");
115 	if (!envpath)
116 		return;
117 	/* for portability: getenv result is read-only */
118 	envpath = xstrdup(envpath);
119 	for (sweep = envpath;
120 	    (path = strsep(&sweep, ":")) != NULL;)
121 	    addtoincludepath(path);
122 	free(envpath);
123 }
124 
125 static
126 struct input_file *
127 dopath(struct input_file *i, const char *filename)
128 {
129 	char path[PATH_MAX];
130 	struct path_entry *pe;
131 	FILE *f;
132 
133 	for (pe = first; pe; pe = pe->next) {
134 		snprintf(path, sizeof(path), "%s/%s", pe->name, filename);
135 		if ((f = fopen(path, "r")) != NULL) {
136 			set_input(i, f, path);
137 			return i;
138 		}
139 	}
140 	return NULL;
141 }
142 
143 struct input_file *
144 fopen_trypath(struct input_file *i, const char *filename)
145 {
146 	FILE *f;
147 
148 	f = fopen(filename, "r");
149 	if (f != NULL) {
150 		set_input(i, f, filename);
151 		return i;
152 	}
153 	if (filename[0] == '/')
154 		return NULL;
155 
156 	ensure_m4path();
157 
158 	return dopath(i, filename);
159 }
160 
161 void
162 doindir(const char *argv[], int argc)
163 {
164 	ndptr n;
165 	struct macro_definition *p = NULL;
166 
167 	n = lookup(argv[2]);
168 	if (n == NULL || (p = macro_getdef(n)) == NULL)
169 		m4errx(1, "indir: undefined macro %s.", argv[2]);
170 	argv[1] = p->defn;
171 
172 	eval(argv+1, argc-1, p->type, is_traced(n));
173 }
174 
175 void
176 dobuiltin(const char *argv[], int argc)
177 {
178 	ndptr p;
179 
180 	argv[1] = NULL;
181 	p = macro_getbuiltin(argv[2]);
182 	if (p != NULL)
183 		eval(argv+1, argc-1, macro_builtin_type(p), is_traced(p));
184 	else
185 		m4errx(1, "unknown builtin %s.", argv[2]);
186 }
187 
188 
189 /* We need some temporary buffer space, as pb pushes BACK and substitution
190  * proceeds forward... */
191 static char *buffer;
192 static size_t bufsize = 0;
193 static size_t current = 0;
194 
195 static void addchars(const char *, size_t);
196 static void addchar(int);
197 static char *twiddle(const char *);
198 static char *getstring(void);
199 static void exit_regerror(int, regex_t *, const char *);
200 static void do_subst(const char *, regex_t *, const char *, const char *,
201     regmatch_t *);
202 static void do_regexpindex(const char *, regex_t *, const char *, regmatch_t *);
203 static void do_regexp(const char *, regex_t *, const char *, const char *,
204     regmatch_t *);
205 static void add_sub(int, const char *, regex_t *, regmatch_t *);
206 static void add_replace(const char *, regex_t *, const char *, regmatch_t *);
207 #define addconstantstring(s) addchars((s), sizeof(s)-1)
208 
209 static void
210 addchars(const char *c, size_t n)
211 {
212 	if (n == 0)
213 		return;
214 	while (current + n > bufsize) {
215 		if (bufsize == 0)
216 			bufsize = 1024;
217 		else if (bufsize <= SIZE_MAX/2) {
218 			bufsize *= 2;
219 		} else {
220 			errx(1, "size overflow");
221 		}
222 		buffer = xrealloc(buffer, bufsize, NULL);
223 	}
224 	memcpy(buffer+current, c, n);
225 	current += n;
226 }
227 
228 static void
229 addchar(int c)
230 {
231 	if (current +1 > bufsize) {
232 		if (bufsize == 0)
233 			bufsize = 1024;
234 		else
235 			bufsize *= 2;
236 		buffer = xrealloc(buffer, bufsize, NULL);
237 	}
238 	buffer[current++] = c;
239 }
240 
241 static char *
242 getstring(void)
243 {
244 	addchar('\0');
245 	current = 0;
246 	return buffer;
247 }
248 
249 
250 static void
251 exit_regerror(int er, regex_t *re, const char *source)
252 {
253 	size_t	errlen;
254 	char	*errbuf;
255 
256 	errlen = regerror(er, re, NULL, 0);
257 	errbuf = xalloc(errlen,
258 	    "malloc in regerror: %lu", (unsigned long)errlen);
259 	regerror(er, re, errbuf, errlen);
260 	m4errx(1, "regular expression error in %s: %s.", source, errbuf);
261 }
262 
263 /* warnx() plus check to see if we need to change exit code or exit .
264  * -E flag functionality.
265  */
266 void
267 m4_warnx(const char *fmt, ...)
268 {
269 	va_list ap;
270 
271 	va_start(ap, fmt);
272 	warnx(fmt, ap);
273 	va_end(ap);
274 
275 	if (fatal_warns)
276 		exit(1);
277 	if (error_warns)
278 		exit_code = 1;
279 }
280 
281 static void
282 add_sub(int n, const char *string, regex_t *re, regmatch_t *pm)
283 {
284 	if (n > (int)re->re_nsub)
285 		m4_warnx("No subexpression %d", n);
286 	/* Subexpressions that did not match are
287 	 * not an error.  */
288 	else if (pm[n].rm_so != -1 &&
289 	    pm[n].rm_eo != -1) {
290 		addchars(string + pm[n].rm_so,
291 			pm[n].rm_eo - pm[n].rm_so);
292 	}
293 }
294 
295 /* Add replacement string to the output buffer, recognizing special
296  * constructs and replacing them with substrings of the original string.
297  */
298 static void
299 add_replace(const char *string, regex_t *re, const char *replace, regmatch_t *pm)
300 {
301 	const char *p;
302 
303 	for (p = replace; *p != '\0'; p++) {
304 		if (*p == '&' && !mimic_gnu) {
305 			add_sub(0, string, re, pm);
306 			continue;
307 		}
308 		if (*p == '\\') {
309 			if (p[1] == '\\') {
310 				addchar(p[1]);
311 				p++;
312 				continue;
313 			}
314 			if (p[1] == '&') {
315 				if (mimic_gnu)
316 					add_sub(0, string, re, pm);
317 				else
318 					addchar(p[1]);
319 				p++;
320 				continue;
321 			}
322 			if (isdigit((unsigned char)p[1])) {
323 				add_sub(*(++p) - '0', string, re, pm);
324 				continue;
325 			}
326 		}
327 		addchar(*p);
328 	}
329 }
330 
331 static void
332 do_subst(const char *string, regex_t *re, const char *source,
333     const char *replace, regmatch_t *pm)
334 {
335 	int error;
336 	int flags = 0;
337 	const char *last_match = NULL;
338 
339 	while ((error = regexec(re, string, re->re_nsub+1, pm, flags)) == 0) {
340 		if (pm[0].rm_eo != 0) {
341 			if (string[pm[0].rm_eo-1] == '\n')
342 				flags = 0;
343 			else
344 				flags = REG_NOTBOL;
345 		}
346 
347 		/* NULL length matches are special... We use the `vi-mode'
348 		 * rule: don't allow a NULL-match at the last match
349 		 * position.
350 		 */
351 		if (pm[0].rm_so == pm[0].rm_eo &&
352 		    string + pm[0].rm_so == last_match) {
353 			if (*string == '\0')
354 				return;
355 			addchar(*string);
356 			if (*string++ == '\n')
357 				flags = 0;
358 			else
359 				flags = REG_NOTBOL;
360 			continue;
361 		}
362 		last_match = string + pm[0].rm_so;
363 		addchars(string, pm[0].rm_so);
364 		add_replace(string, re, replace, pm);
365 		string += pm[0].rm_eo;
366 	}
367 	if (error != REG_NOMATCH)
368 		exit_regerror(error, re, source);
369 	pbstr(string);
370 }
371 
372 static void
373 do_regexp(const char *string, regex_t *re, const char *source,
374     const char *replace, regmatch_t *pm)
375 {
376 	int error;
377 
378 	switch(error = regexec(re, string, re->re_nsub+1, pm, 0)) {
379 	case 0:
380 		add_replace(string, re, replace, pm);
381 		pbstr(getstring());
382 		break;
383 	case REG_NOMATCH:
384 		break;
385 	default:
386 		exit_regerror(error, re, source);
387 	}
388 }
389 
390 static void
391 do_regexpindex(const char *string, regex_t *re, const char *source,
392     regmatch_t *pm)
393 {
394 	int error;
395 
396 	switch(error = regexec(re, string, re->re_nsub+1, pm, 0)) {
397 	case 0:
398 		pbunsigned(pm[0].rm_so);
399 		break;
400 	case REG_NOMATCH:
401 		pbnum(-1);
402 		break;
403 	default:
404 		exit_regerror(error, re, source);
405 	}
406 }
407 
408 /* In Gnu m4 mode, parentheses for backmatch don't work like POSIX 1003.2
409  * says. So we twiddle with the regexp before passing it to regcomp.
410  */
411 static char *
412 twiddle(const char *p)
413 {
414 	/* + at start of regexp is a normal character for Gnu m4 */
415 	if (*p == '^') {
416 		addchar(*p);
417 		p++;
418 	}
419 	if (*p == '+') {
420 		addchar('\\');
421 	}
422 	/* This could use strcspn for speed... */
423 	while (*p != '\0') {
424 		if (*p == '\\') {
425 			switch(p[1]) {
426 			case '(':
427 			case ')':
428 			case '|':
429 				addchar(p[1]);
430 				break;
431 			case 'w':
432 				addconstantstring("[_a-zA-Z0-9]");
433 				break;
434 			case 'W':
435 				addconstantstring("[^_a-zA-Z0-9]");
436 				break;
437 			case '<':
438 				addconstantstring("[[:<:]]");
439 				break;
440 			case '>':
441 				addconstantstring("[[:>:]]");
442 				break;
443 			default:
444 				addchars(p, 2);
445 				break;
446 			}
447 			p+=2;
448 			continue;
449 		}
450 		if (*p == '(' || *p == ')' || *p == '|')
451 			addchar('\\');
452 
453 		addchar(*p);
454 		p++;
455 	}
456 	return getstring();
457 }
458 
459 /* patsubst(string, regexp, opt replacement) */
460 /* argv[2]: string
461  * argv[3]: regexp
462  * argv[4]: opt rep
463  */
464 void
465 dopatsubst(const char *argv[], int argc)
466 {
467 	if (argc <= 3) {
468 		m4_warnx("Too few arguments to patsubst");
469 		return;
470 	}
471 	/* special case: empty regexp */
472 	if (argv[3][0] == '\0') {
473 		const char *s;
474 		size_t len;
475 		if (argc > 4 && argv[4])
476 			len = strlen(argv[4]);
477 		else
478 			len = 0;
479 		for (s = argv[2]; *s != '\0'; s++) {
480 			addchars(argv[4], len);
481 			addchar(*s);
482 		}
483 	} else {
484 		int error;
485 		regex_t re;
486 		regmatch_t *pmatch;
487 		int mode = REG_EXTENDED;
488 		const char *source;
489 		size_t l = strlen(argv[3]);
490 
491 		if (!mimic_gnu ||
492 		    (argv[3][0] == '^') ||
493 		    (l > 0 && argv[3][l-1] == '$'))
494 			mode |= REG_NEWLINE;
495 
496 		source = mimic_gnu ? twiddle(argv[3]) : argv[3];
497 		error = regcomp(&re, source, mode);
498 		if (error != 0)
499 			exit_regerror(error, &re, source);
500 
501 		pmatch = xreallocarray(NULL, re.re_nsub+1, sizeof(regmatch_t),
502 		    NULL);
503 		do_subst(argv[2], &re, source,
504 		    argc > 4 && argv[4] != NULL ? argv[4] : "", pmatch);
505 		free(pmatch);
506 		regfree(&re);
507 	}
508 	pbstr(getstring());
509 }
510 
511 void
512 doregexp(const char *argv[], int argc)
513 {
514 	int error;
515 	regex_t re;
516 	regmatch_t *pmatch;
517 	const char *source;
518 
519 	if (argc <= 3) {
520 		m4_warnx("Too few arguments to regexp");
521 		return;
522 	}
523 	/* special gnu case */
524 	if (argv[3][0] == '\0' && mimic_gnu) {
525 		if (argc == 4 || argv[4] == NULL)
526 			return;
527 		else
528 			pbstr(argv[4]);
529 	}
530 	source = mimic_gnu ? twiddle(argv[3]) : argv[3];
531 	error = regcomp(&re, source, REG_EXTENDED|REG_NEWLINE);
532 	if (error != 0)
533 		exit_regerror(error, &re, source);
534 
535 	pmatch = xreallocarray(NULL, re.re_nsub+1, sizeof(regmatch_t), NULL);
536 	if (argc == 4 || argv[4] == NULL)
537 		do_regexpindex(argv[2], &re, source, pmatch);
538 	else
539 		do_regexp(argv[2], &re, source, argv[4], pmatch);
540 	free(pmatch);
541 	regfree(&re);
542 }
543 
544 void
545 doformat(const char *argv[], int argc)
546 {
547 	const char *format = argv[2];
548 	int pos = 3;
549 	int left_padded;
550 	long width;
551 	size_t l;
552 	const char *thisarg = NULL;
553 	char temp[2];
554 	long extra;
555 
556 	while (*format != 0) {
557 		if (*format != '%') {
558 			addchar(*format++);
559 			continue;
560 		}
561 
562 		format++;
563 		if (*format == '%') {
564 			addchar(*format++);
565 			continue;
566 		}
567 		if (*format == 0) {
568 			addchar('%');
569 			break;
570 		}
571 
572 		if (*format == '*') {
573 			format++;
574 			if (pos >= argc)
575 				m4errx(1,
576 				    "Format with too many format specifiers.");
577 			width = strtol(argv[pos++], NULL, 10);
578 		} else {
579 			width = strtol(format, __DECONST(char **,&format), 10);
580 		}
581 		if (width < 0) {
582 			left_padded = 1;
583 			width = -width;
584 		} else {
585 			left_padded = 0;
586 		}
587 		if (*format == '.') {
588 			format++;
589 			if (*format == '*') {
590 				format++;
591 				if (pos >= argc)
592 					m4errx(1,
593 					    "Format with too many format specifiers.");
594 				extra = strtol(argv[pos++], NULL, 10);
595 			} else {
596 				extra = strtol(format, __DECONST(char **, &format), 10);
597 			}
598 		} else {
599 			extra = LONG_MAX;
600 		}
601 		if (pos >= argc)
602 			m4errx(1, "Format with too many format specifiers.");
603 		switch(*format) {
604 		case 's':
605 			thisarg = argv[pos++];
606 			break;
607 		case 'c':
608 			temp[0] = strtoul(argv[pos++], NULL, 10);
609 			temp[1] = 0;
610 			thisarg = temp;
611 			break;
612 		default:
613 			m4errx(1, "Unsupported format specification: %s.",
614 			    argv[2]);
615 		}
616 		format++;
617 		l = strlen(thisarg);
618 		if ((long)l > extra)
619 			l = extra;
620 		if (!left_padded) {
621 			while ((long)l < width--)
622 				addchar(' ');
623 		}
624 		addchars(thisarg, l);
625 		if (left_padded) {
626 			while ((long)l < width--)
627 				addchar(' ');
628 		}
629 	}
630 	pbstr(getstring());
631 }
632 
633 void
634 doesyscmd(const char *cmd)
635 {
636 	int p[2];
637 	pid_t cpid;
638 	char *argv[4];
639 	int cc;
640 	int status;
641 
642 	/* Follow gnu m4 documentation: first flush buffers. */
643 	fflush(NULL);
644 
645 	argv[0] = __DECONST(char *, "sh");
646 	argv[1] = __DECONST(char *, "-c");
647 	argv[2] = __DECONST(char *, cmd);
648 	argv[3] = NULL;
649 
650 	/* Just set up standard output, share stderr and stdin with m4 */
651 	if (pipe(p) == -1)
652 		err(1, "bad pipe");
653 	switch(cpid = fork()) {
654 	case -1:
655 		err(1, "bad fork");
656 		/* NOTREACHED */
657 	case 0:
658 		(void) close(p[0]);
659 		(void) dup2(p[1], 1);
660 		(void) close(p[1]);
661 		execv(_PATH_BSHELL, argv);
662 		exit(1);
663 	default:
664 		/* Read result in two stages, since m4's buffer is
665 		 * pushback-only. */
666 		(void) close(p[1]);
667 		do {
668 			char result[BUFSIZE];
669 			cc = read(p[0], result, sizeof result);
670 			if (cc > 0)
671 				addchars(result, cc);
672 		} while (cc > 0 || (cc == -1 && errno == EINTR));
673 
674 		(void) close(p[0]);
675 		while (waitpid(cpid, &status, 0) == -1) {
676 			if (errno != EINTR)
677 				break;
678 		}
679 		pbstr(getstring());
680 	}
681 }
682 
683 void
684 getdivfile(const char *name)
685 {
686 	FILE *f;
687 	int c;
688 
689 	f = fopen(name, "r");
690 	if (!f)
691 		return;
692 
693 	while ((c = getc(f))!= EOF)
694 		putc(c, active);
695 	(void) fclose(f);
696 }
697