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