lobase

Linux port of OpenBSDs userland.

compile.c (20065B)


      1 /*	$OpenBSD: compile.c,v 1.41 2017/01/20 10:26:16 krw Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1992 Diomidis Spinellis.
      5  * Copyright (c) 1992, 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  * Diomidis Spinellis of Imperial College, University of London.
     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 #include <sys/types.h>
     37 #include <sys/stat.h>
     38 
     39 #include <ctype.h>
     40 #include <errno.h>
     41 #include <fcntl.h>
     42 #include <limits.h>
     43 #include <regex.h>
     44 #include <stdio.h>
     45 #include <stdlib.h>
     46 #include <string.h>
     47 
     48 #include "defs.h"
     49 #include "extern.h"
     50 
     51 #define LHSZ	128
     52 #define	LHMASK	(LHSZ - 1)
     53 static struct labhash {
     54 	struct	labhash *lh_next;
     55 	u_int	lh_hash;
     56 	struct	s_command *lh_cmd;
     57 	int	lh_ref;
     58 } *labels[LHSZ];
     59 
     60 static char	 *compile_addr(char *, struct s_addr *);
     61 static char	 *compile_ccl(char **, char *);
     62 static char	 *compile_delimited(char *, char *, int);
     63 static char	 *compile_flags(char *, struct s_subst *);
     64 static char	 *compile_re(char *, regex_t **);
     65 static char	 *compile_subst(char *, struct s_subst *);
     66 static char	 *compile_text(void);
     67 static char	 *compile_tr(char *, char **);
     68 static struct s_command
     69 		**compile_stream(struct s_command **);
     70 static char	 *duptoeol(char *, char *, char **);
     71 static void	  enterlabel(struct s_command *);
     72 static struct s_command
     73 		 *findlabel(char *);
     74 static void	  fixuplabel(struct s_command *, struct s_command *);
     75 static void	  uselabel(void);
     76 
     77 /*
     78  * Command specification.  This is used to drive the command parser.
     79  */
     80 struct s_format {
     81 	char code;				/* Command code */
     82 	int naddr;				/* Number of address args */
     83 	enum e_args args;			/* Argument type */
     84 };
     85 
     86 static struct s_format cmd_fmts[] = {
     87 	{'{', 2, GROUP},
     88 	{'}', 0, ENDGROUP},
     89 	{'a', 1, TEXT},
     90 	{'b', 2, BRANCH},
     91 	{'c', 2, TEXT},
     92 	{'d', 2, EMPTY},
     93 	{'D', 2, EMPTY},
     94 	{'g', 2, EMPTY},
     95 	{'G', 2, EMPTY},
     96 	{'h', 2, EMPTY},
     97 	{'H', 2, EMPTY},
     98 	{'i', 1, TEXT},
     99 	{'l', 2, EMPTY},
    100 	{'n', 2, EMPTY},
    101 	{'N', 2, EMPTY},
    102 	{'p', 2, EMPTY},
    103 	{'P', 2, EMPTY},
    104 	{'q', 1, EMPTY},
    105 	{'r', 1, RFILE},
    106 	{'s', 2, SUBST},
    107 	{'t', 2, BRANCH},
    108 	{'w', 2, WFILE},
    109 	{'x', 2, EMPTY},
    110 	{'y', 2, TR},
    111 	{'!', 2, NONSEL},
    112 	{':', 0, LABEL},
    113 	{'#', 0, COMMENT},
    114 	{'=', 1, EMPTY},
    115 	{'\0', 0, COMMENT},
    116 };
    117 
    118 /* The compiled program. */
    119 struct s_command *prog;
    120 
    121 /*
    122  * Compile the program into prog.
    123  * Initialise appends.
    124  */
    125 void
    126 compile(void)
    127 {
    128 	*compile_stream(&prog) = NULL;
    129 	fixuplabel(prog, NULL);
    130 	uselabel();
    131 	appends = xreallocarray(NULL, appendnum, sizeof(struct s_appends));
    132 	match = xreallocarray(NULL, maxnsub + 1, sizeof(regmatch_t));
    133 }
    134 
    135 #define EATSPACE() do {							\
    136 	if (p)								\
    137 		while (isascii((unsigned char)*p) &&			\
    138 		    isspace((unsigned char)*p))				\
    139 			p++;						\
    140 	} while (0)
    141 
    142 static struct s_command **
    143 compile_stream(struct s_command **link)
    144 {
    145 	char *p;
    146 	static char *lbuf;	/* To avoid excessive malloc calls */
    147 	static size_t bufsize;
    148 	struct s_command *cmd, *cmd2, *stack;
    149 	struct s_format *fp;
    150 	int naddr;				/* Number of addresses */
    151 
    152 	stack = 0;
    153 	for (;;) {
    154 		if ((p = cu_fgets(&lbuf, &bufsize)) == NULL) {
    155 			if (stack != 0)
    156 				error(COMPILE, "unexpected EOF (pending }'s)");
    157 			return (link);
    158 		}
    159 
    160 semicolon:	EATSPACE();
    161 		if (*p == '#' || *p == '\0')
    162 			continue;
    163 		if (*p == ';') {
    164 			p++;
    165 			goto semicolon;
    166 		}
    167 		*link = cmd = xmalloc(sizeof(struct s_command));
    168 		link = &cmd->next;
    169 		cmd->nonsel = cmd->inrange = 0;
    170 		/* First parse the addresses */
    171 		naddr = 0;
    172 
    173 /* Valid characters to start an address */
    174 #define	addrchar(c)	(strchr("0123456789/\\$", (c)))
    175 		if (addrchar(*p)) {
    176 			naddr++;
    177 			cmd->a1 = xmalloc(sizeof(struct s_addr));
    178 			p = compile_addr(p, cmd->a1);
    179 			EATSPACE();				/* EXTENSION */
    180 			if (*p == ',') {
    181 				p++;
    182 				EATSPACE();			/* EXTENSION */
    183 				naddr++;
    184 				cmd->a2 = xmalloc(sizeof(struct s_addr));
    185 				p = compile_addr(p, cmd->a2);
    186 				EATSPACE();
    187 			} else {
    188 				cmd->a2 = 0;
    189 			}
    190 		} else {
    191 			cmd->a1 = cmd->a2 = 0;
    192 		}
    193 
    194 nonsel:		/* Now parse the command */
    195 		if (!*p)
    196 			error(COMPILE, "command expected");
    197 		cmd->code = *p;
    198 		for (fp = cmd_fmts; fp->code; fp++)
    199 			if (fp->code == *p)
    200 				break;
    201 		if (!fp->code)
    202 			error(COMPILE, "invalid command code %c", *p);
    203 		if (naddr > fp->naddr)
    204 			error(COMPILE,
    205 			    "command %c expects up to %d address(es), found %d",
    206 			    *p, fp->naddr, naddr);
    207 		switch (fp->args) {
    208 		case NONSEL:			/* ! */
    209 			p++;
    210 			EATSPACE();
    211 			cmd->nonsel = 1;
    212 			goto nonsel;
    213 		case GROUP:			/* { */
    214 			p++;
    215 			EATSPACE();
    216 			cmd->next = stack;
    217 			stack = cmd;
    218 			link = &cmd->u.c;
    219 			if (*p)
    220 				goto semicolon;
    221 			break;
    222 		case ENDGROUP:
    223 			/*
    224 			 * Short-circuit command processing, since end of
    225 			 * group is really just a noop.
    226 			 */
    227 			cmd->nonsel = 1;
    228 			if (stack == 0)
    229 				error(COMPILE, "unexpected }");
    230 			cmd2 = stack;
    231 			stack = cmd2->next;
    232 			cmd2->next = cmd;
    233 			/*FALLTHROUGH*/
    234 		case EMPTY:		/* d D g G h H l n N p P q x = \0 */
    235 			p++;
    236 			EATSPACE();
    237 			if (*p == ';') {
    238 				p++;
    239 				link = &cmd->next;
    240 				goto semicolon;
    241 			}
    242 			if (*p)
    243 				error(COMPILE,
    244 "extra characters at the end of %c command", cmd->code);
    245 			break;
    246 		case TEXT:			/* a c i */
    247 			p++;
    248 			EATSPACE();
    249 			if (*p != '\\')
    250 				error(COMPILE, "command %c expects \\ followed by"
    251 				    " text", cmd->code);
    252 			p++;
    253 			EATSPACE();
    254 			if (*p)
    255 				error(COMPILE, "extra characters after \\ at the"
    256 				    " end of %c command", cmd->code);
    257 			cmd->t = compile_text();
    258 			break;
    259 		case COMMENT:			/* \0 # */
    260 			break;
    261 		case WFILE:			/* w */
    262 			p++;
    263 			EATSPACE();
    264 			if (*p == '\0')
    265 				error(COMPILE, "filename expected");
    266 			cmd->t = duptoeol(p, "w command", NULL);
    267 			if (aflag)
    268 				cmd->u.fd = -1;
    269 			else if ((cmd->u.fd = open(p,
    270 			    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
    271 			    DEFFILEMODE)) == -1)
    272 				error(FATAL, "%s: %s", p, strerror(errno));
    273 			break;
    274 		case RFILE:			/* r */
    275 			p++;
    276 			EATSPACE();
    277 			cmd->t = duptoeol(p, "read command", NULL);
    278 			break;
    279 		case BRANCH:			/* b t */
    280 			p++;
    281 			EATSPACE();
    282 			if (*p == '\0')
    283 				cmd->t = NULL;
    284 			else
    285 				cmd->t = duptoeol(p, "branch", &p);
    286 			if (*p == ';') {
    287 				p++;
    288 				goto semicolon;
    289 			}
    290 			break;
    291 		case LABEL:			/* : */
    292 			p++;
    293 			EATSPACE();
    294 			cmd->t = duptoeol(p, "label", &p);
    295 			if (strlen(cmd->t) == 0)
    296 				error(COMPILE, "empty label");
    297 			enterlabel(cmd);
    298 			if (*p == ';') {
    299 				p++;
    300 				goto semicolon;
    301 			}
    302 			break;
    303 		case SUBST:			/* s */
    304 			p++;
    305 			if (*p == '\0' || *p == '\\')
    306 				error(COMPILE, "substitute pattern can not be"
    307 				    " delimited by newline or backslash");
    308 			cmd->u.s = xmalloc(sizeof(struct s_subst));
    309 			p = compile_re(p, &cmd->u.s->re);
    310 			if (p == NULL)
    311 				error(COMPILE, "unterminated substitute pattern");
    312 			--p;
    313 			p = compile_subst(p, cmd->u.s);
    314 			p = compile_flags(p, cmd->u.s);
    315 			EATSPACE();
    316 			if (*p == ';') {
    317 				p++;
    318 				link = &cmd->next;
    319 				goto semicolon;
    320 			}
    321 			break;
    322 		case TR:			/* y */
    323 			p++;
    324 			p = compile_tr(p, (char **)&cmd->u.y);
    325 			EATSPACE();
    326 			if (*p == ';') {
    327 				p++;
    328 				link = &cmd->next;
    329 				goto semicolon;
    330 			}
    331 			if (*p)
    332 				error(COMPILE, "extra text at the end of a"
    333 				    " transform command");
    334 			break;
    335 		}
    336 	}
    337 }
    338 
    339 /*
    340  * Get a delimited string.  P points to the delimeter of the string; d points
    341  * to a buffer area.  Newline and delimiter escapes are processed; other
    342  * escapes are ignored.
    343  *
    344  * Returns a pointer to the first character after the final delimiter or NULL
    345  * in the case of a non-terminated string.  The character array d is filled
    346  * with the processed string.
    347  */
    348 static char *
    349 compile_delimited(char *p, char *d, int is_tr)
    350 {
    351 	char c;
    352 
    353 	c = *p++;
    354 	if (c == '\0')
    355 		return (NULL);
    356 	else if (c == '\\')
    357 		error(COMPILE, "\\ can not be used as a string delimiter");
    358 	else if (c == '\n')
    359 		error(COMPILE, "newline can not be used as a string delimiter");
    360 	while (*p) {
    361 		if (*p == '[' && *p != c) {
    362 			if ((d = compile_ccl(&p, d)) == NULL)
    363 				error(COMPILE, "unbalanced brackets ([])");
    364 			continue;
    365 		} else if (*p == '\\' && p[1] == '[') {
    366 			*d++ = *p++;
    367 		} else if (*p == '\\' && p[1] == c) {
    368 			p++;
    369 		} else if (*p == '\\' && p[1] == 'n') {
    370 			*d++ = '\n';
    371 			p += 2;
    372 			continue;
    373 		} else if (*p == '\\' && p[1] == '\\') {
    374 			if (is_tr)
    375 				p++;
    376 			else
    377 				*d++ = *p++;
    378 		} else if (*p == c) {
    379 			*d = '\0';
    380 			return (p + 1);
    381 		}
    382 		*d++ = *p++;
    383 	}
    384 	return (NULL);
    385 }
    386 
    387 
    388 /* compile_ccl: expand a POSIX character class */
    389 static char *
    390 compile_ccl(char **sp, char *t)
    391 {
    392 	int c, d;
    393 	char *s = *sp;
    394 
    395 	*t++ = *s++;
    396 	if (*s == '^')
    397 		*t++ = *s++;
    398 	if (*s == ']')
    399 		*t++ = *s++;
    400 	for (; *s && (*t = *s) != ']'; s++, t++)
    401 		if (*s == '[' && ((d = *(s+1)) == '.' || d == ':' || d == '=')) {
    402 			*++t = *++s, t++, s++;
    403 			for (c = *s; (*t = *s) != ']' || c != d; s++, t++)
    404 				if ((c = *s) == '\0')
    405 					return NULL;
    406 		} else if (*s == '\\' && s[1] == 'n') {
    407 			*t = '\n';
    408 			s++;
    409 		}
    410 	if (*s == ']') {
    411 		*sp = ++s;
    412 		return (++t);
    413 	} else {
    414 		return (NULL);
    415 	}
    416 }
    417 
    418 /*
    419  * Get a regular expression.  P points to the delimiter of the regular
    420  * expression; repp points to the address of a regexp pointer.  Newline
    421  * and delimiter escapes are processed; other escapes are ignored.
    422  * Returns a pointer to the first character after the final delimiter
    423  * or NULL in the case of a non terminated regular expression.  The regexp
    424  * pointer is set to the compiled regular expression.
    425  * Cflags are passed to regcomp.
    426  */
    427 static char *
    428 compile_re(char *p, regex_t **repp)
    429 {
    430 	int eval;
    431 	char *re;
    432 
    433 	re = xmalloc(strlen(p) + 1); /* strlen(re) <= strlen(p) */
    434 	p = compile_delimited(p, re, 0);
    435 	if (p && strlen(re) == 0) {
    436 		*repp = NULL;
    437 		free(re);
    438 		return (p);
    439 	}
    440 	*repp = xmalloc(sizeof(regex_t));
    441 	if (p && (eval = regcomp(*repp, re, Eflag ? REG_EXTENDED : 0)) != 0)
    442 		error(COMPILE, "RE error: %s", strregerror(eval, *repp));
    443 	if (maxnsub < (*repp)->re_nsub)
    444 		maxnsub = (*repp)->re_nsub;
    445 	free(re);
    446 	return (p);
    447 }
    448 
    449 /*
    450  * Compile the substitution string of a regular expression and set res to
    451  * point to a saved copy of it.  Nsub is the number of parenthesized regular
    452  * expressions.
    453  */
    454 static char *
    455 compile_subst(char *p, struct s_subst *s)
    456 {
    457 	static char *lbuf;
    458 	static size_t bufsize;
    459 	int asize, ref, size;
    460 	char c, *text, *op, *sp;
    461 	int sawesc = 0;
    462 
    463 	c = *p++;			/* Terminator character */
    464 	if (c == '\0')
    465 		return (NULL);
    466 
    467 	s->maxbref = 0;
    468 	s->linenum = linenum;
    469 	text = NULL;
    470 	asize = size = 0;
    471 	do {
    472 		size_t len = ROUNDLEN(strlen(p) + 1);
    473 		if (asize - size < len) {
    474 			do {
    475 				asize += len;
    476 			} while (asize - size < len);
    477 			text = xrealloc(text, asize);
    478 		}
    479 		op = sp = text + size;
    480 		for (; *p; p++) {
    481 			if (*p == '\\' || sawesc) {
    482 				/*
    483 				 * If this is a continuation from the last
    484 				 * buffer, we won't have a character to
    485 				 * skip over.
    486 				 */
    487 				if (sawesc)
    488 					sawesc = 0;
    489 				else
    490 					p++;
    491 
    492 				if (*p == '\0') {
    493 					/*
    494 					 * This escaped character is continued
    495 					 * in the next part of the line.  Note
    496 					 * this fact, then cause the loop to
    497 					 * exit w/ normal EOL case and reenter
    498 					 * above with the new buffer.
    499 					 */
    500 					sawesc = 1;
    501 					p--;
    502 					continue;
    503 				} else if (strchr("123456789", *p) != NULL) {
    504 					*sp++ = '\\';
    505 					ref = *p - '0';
    506 					if (s->re != NULL &&
    507 					    ref > s->re->re_nsub)
    508 						error(COMPILE,
    509 "\\%c not defined in the RE", *p);
    510 					if (s->maxbref < ref)
    511 						s->maxbref = ref;
    512 				} else if (*p == '&' || *p == '\\')
    513 					*sp++ = '\\';
    514 			} else if (*p == c) {
    515 				p++;
    516 				*sp++ = '\0';
    517 				size += sp - op;
    518 				s->new = xrealloc(text, size);
    519 				return (p);
    520 			} else if (*p == '\n') {
    521 				error(COMPILE,
    522 "unescaped newline inside substitute pattern");
    523 			}
    524 			*sp++ = *p;
    525 		}
    526 		size += sp - op;
    527 	} while ((p = cu_fgets(&lbuf, &bufsize)));
    528 	error(COMPILE, "unterminated substitute in regular expression");
    529 }
    530 
    531 /*
    532  * Compile the flags of the s command
    533  */
    534 static char *
    535 compile_flags(char *p, struct s_subst *s)
    536 {
    537 	int gn;			/* True if we have seen g or n */
    538 	long l;
    539 	char wfile[PATH_MAX], *q, *eq;
    540 
    541 	s->n = 1;				/* Default */
    542 	s->p = 0;
    543 	s->wfile = NULL;
    544 	s->wfd = -1;
    545 	for (gn = 0;;) {
    546 		EATSPACE();			/* EXTENSION */
    547 		switch (*p) {
    548 		case 'g':
    549 			if (gn)
    550 				error(COMPILE, "more than one number or 'g' in"
    551 				    " substitute flags");
    552 			gn = 1;
    553 			s->n = 0;
    554 			break;
    555 		case '\0':
    556 		case '\n':
    557 		case ';':
    558 			return (p);
    559 		case 'p':
    560 			s->p = 1;
    561 			break;
    562 		case '1': case '2': case '3':
    563 		case '4': case '5': case '6':
    564 		case '7': case '8': case '9':
    565 			if (gn)
    566 				error(COMPILE, "more than one number or 'g' in"
    567 				    " substitute flags");
    568 			gn = 1;
    569 			l = strtol(p, &p, 10);
    570 			if (l <= 0 || l >= INT_MAX)
    571 				error(COMPILE,
    572 				    "number in substitute flags out of range");
    573 			s->n = (int)l;
    574 			continue;
    575 		case 'w':
    576 			p++;
    577 #ifdef HISTORIC_PRACTICE
    578 			if (*p != ' ') {
    579 				warning("space missing before w wfile");
    580 				return (p);
    581 			}
    582 #endif
    583 			EATSPACE();
    584 			q = wfile;
    585 			eq = wfile + sizeof(wfile) - 1;
    586 			while (*p) {
    587 				if (*p == '\n')
    588 					break;
    589 				if (q >= eq)
    590 					error(COMPILE, "wfile too long");
    591 				*q++ = *p++;
    592 			}
    593 			*q = '\0';
    594 			if (q == wfile)
    595 				error(COMPILE, "no wfile specified");
    596 			s->wfile = strdup(wfile);
    597 			if (!aflag && (s->wfd = open(wfile,
    598 			    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
    599 			    DEFFILEMODE)) == -1)
    600 				error(FATAL, "%s: %s", wfile, strerror(errno));
    601 			return (p);
    602 		default:
    603 			error(COMPILE,
    604 			    "bad flag in substitute command: '%c'", *p);
    605 			break;
    606 		}
    607 		p++;
    608 	}
    609 }
    610 
    611 /*
    612  * Compile a translation set of strings into a lookup table.
    613  */
    614 static char *
    615 compile_tr(char *p, char **transtab)
    616 {
    617 	int i;
    618 	char *lt, *op, *np;
    619 	char *old = NULL, *new = NULL;
    620 
    621 	if (*p == '\0' || *p == '\\')
    622 		error(COMPILE,
    623 "transform pattern can not be delimited by newline or backslash");
    624 	old = xmalloc(strlen(p) + 1);
    625 	p = compile_delimited(p, old, 1);
    626 	if (p == NULL) {
    627 		error(COMPILE, "unterminated transform source string");
    628 		goto bad;
    629 	}
    630 	new = xmalloc(strlen(p) + 1);
    631 	p = compile_delimited(--p, new, 1);
    632 	if (p == NULL) {
    633 		error(COMPILE, "unterminated transform target string");
    634 		goto bad;
    635 	}
    636 	EATSPACE();
    637 	if (strlen(new) != strlen(old)) {
    638 		error(COMPILE, "transform strings are not the same length");
    639 		goto bad;
    640 	}
    641 	/* We assume characters are 8 bits */
    642 	lt = xmalloc(UCHAR_MAX + 1);
    643 	for (i = 0; i <= UCHAR_MAX; i++)
    644 		lt[i] = (char)i;
    645 	for (op = old, np = new; *op; op++, np++)
    646 		lt[(u_char)*op] = *np;
    647 	*transtab = lt;
    648 	free(old);
    649 	free(new);
    650 	return (p);
    651 bad:
    652 	free(old);
    653 	free(new);
    654 	return (NULL);
    655 }
    656 
    657 /*
    658  * Compile the text following an a, c, or i command.
    659  */
    660 static char *
    661 compile_text(void)
    662 {
    663 	int asize, esc_nl, size;
    664 	char *lbuf, *text, *p, *op, *s;
    665 	size_t bufsize;
    666 
    667 	lbuf = text = NULL;
    668 	asize = size = 0;
    669 	while ((p = cu_fgets(&lbuf, &bufsize))) {
    670 		size_t len = ROUNDLEN(strlen(p) + 1);
    671 		if (asize - size < len) {
    672 			do {
    673 				asize += len;
    674 			} while (asize - size < len);
    675 			text = xrealloc(text, asize);
    676 		}
    677 		op = s = text + size;
    678 		for (esc_nl = 0; *p != '\0'; p++) {
    679 			if (*p == '\\' && p[1] != '\0' && *++p == '\n')
    680 				esc_nl = 1;
    681 			*s++ = *p;
    682 		}
    683 		size += s - op;
    684 		if (!esc_nl) {
    685 			*s = '\0';
    686 			break;
    687 		}
    688 	}
    689 	free(lbuf);
    690 	text = xrealloc(text, size + 1);
    691 	text[size] = '\0';
    692 	return (text);
    693 }
    694 
    695 /*
    696  * Get an address and return a pointer to the first character after
    697  * it.  Fill the structure pointed to according to the address.
    698  */
    699 static char *
    700 compile_addr(char *p, struct s_addr *a)
    701 {
    702 	char *end;
    703 
    704 	switch (*p) {
    705 	case '\\':				/* Context address */
    706 		++p;
    707 		/* FALLTHROUGH */
    708 	case '/':				/* Context address */
    709 		p = compile_re(p, &a->u.r);
    710 		if (p == NULL)
    711 			error(COMPILE, "unterminated regular expression");
    712 		a->type = AT_RE;
    713 		return (p);
    714 
    715 	case '$':				/* Last line */
    716 		a->type = AT_LAST;
    717 		return (p + 1);
    718 						/* Line number */
    719 	case '0': case '1': case '2': case '3': case '4':
    720 	case '5': case '6': case '7': case '8': case '9':
    721 		a->type = AT_LINE;
    722 		a->u.l = strtoul(p, &end, 10);
    723 		return (end);
    724 	default:
    725 		error(COMPILE, "expected context address");
    726 		return (NULL);
    727 	}
    728 }
    729 
    730 /*
    731  * duptoeol --
    732  *	Return a copy of all the characters up to \n or \0.
    733  */
    734 static char *
    735 duptoeol(char *s, char *ctype, char **semi)
    736 {
    737 	size_t len;
    738 	int ws;
    739 	char *start;
    740 
    741 	ws = 0;
    742 	if (semi) {
    743 		for (start = s; *s != '\0' && *s != '\n' && *s != ';'; ++s)
    744 			ws = isspace((unsigned char)*s);
    745 	} else {
    746 		for (start = s; *s != '\0' && *s != '\n'; ++s)
    747 			ws = isspace((unsigned char)*s);
    748 		*s = '\0';
    749 	}
    750 	if (ws)
    751 		warning("whitespace after %s", ctype);
    752 	len = s - start + 1;
    753 	if (semi)
    754 		*semi = s;
    755 	s = xmalloc(len);
    756 	strlcpy(s, start, len);
    757 	return (s);
    758 }
    759 
    760 /*
    761  * Convert goto label names to addresses, and count a and r commands, in
    762  * the given subset of the script.  Free the memory used by labels in b
    763  * and t commands (but not by :).
    764  *
    765  * TODO: Remove } nodes
    766  */
    767 static void
    768 fixuplabel(struct s_command *cp, struct s_command *end)
    769 {
    770 
    771 	for (; cp != end; cp = cp->next)
    772 		switch (cp->code) {
    773 		case 'a':
    774 		case 'r':
    775 			appendnum++;
    776 			break;
    777 		case 'b':
    778 		case 't':
    779 			/* Resolve branch target. */
    780 			if (cp->t == NULL) {
    781 				cp->u.c = NULL;
    782 				break;
    783 			}
    784 			if ((cp->u.c = findlabel(cp->t)) == NULL)
    785 				error(COMPILE, "undefined label '%s'", cp->t);
    786 			free(cp->t);
    787 			break;
    788 		case '{':
    789 			/* Do interior commands. */
    790 			fixuplabel(cp->u.c, cp->next);
    791 			break;
    792 		}
    793 }
    794 
    795 /*
    796  * Associate the given command label for later lookup.
    797  */
    798 static void
    799 enterlabel(struct s_command *cp)
    800 {
    801 	struct labhash **lhp, *lh;
    802 	u_char *p;
    803 	u_int h, c;
    804 
    805 	for (h = 0, p = (u_char *)cp->t; (c = *p) != 0; p++)
    806 		h = (h << 5) + h + c;
    807 	lhp = &labels[h & LHMASK];
    808 	for (lh = *lhp; lh != NULL; lh = lh->lh_next)
    809 		if (lh->lh_hash == h && strcmp(cp->t, lh->lh_cmd->t) == 0)
    810 			error(COMPILE, "duplicate label '%s'", cp->t);
    811 	lh = xmalloc(sizeof *lh);
    812 	lh->lh_next = *lhp;
    813 	lh->lh_hash = h;
    814 	lh->lh_cmd = cp;
    815 	lh->lh_ref = 0;
    816 	*lhp = lh;
    817 }
    818 
    819 /*
    820  * Find the label contained in the command l in the command linked
    821  * list cp.  L is excluded from the search.  Return NULL if not found.
    822  */
    823 static struct s_command *
    824 findlabel(char *name)
    825 {
    826 	struct labhash *lh;
    827 	u_char *p;
    828 	u_int h, c;
    829 
    830 	for (h = 0, p = (u_char *)name; (c = *p) != 0; p++)
    831 		h = (h << 5) + h + c;
    832 	for (lh = labels[h & LHMASK]; lh != NULL; lh = lh->lh_next) {
    833 		if (lh->lh_hash == h && strcmp(name, lh->lh_cmd->t) == 0) {
    834 			lh->lh_ref = 1;
    835 			return (lh->lh_cmd);
    836 		}
    837 	}
    838 	return (NULL);
    839 }
    840 
    841 /*
    842  * Warn about any unused labels.  As a side effect, release the label hash
    843  * table space.
    844  */
    845 static void
    846 uselabel(void)
    847 {
    848 	struct labhash *lh, *next;
    849 	int i;
    850 
    851 	for (i = 0; i < LHSZ; i++) {
    852 		for (lh = labels[i]; lh != NULL; lh = next) {
    853 			next = lh->lh_next;
    854 			if (!lh->lh_ref)
    855 				warning("unused label '%s'",
    856 				    lh->lh_cmd->t);
    857 			free(lh);
    858 		}
    859 	}
    860 }