GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.bin/sed/compile.c Lines: 342 408 83.8 %
Date: 2017-11-13 Branches: 303 416 72.8 %

Line Branch Exec Source
1
/*	$OpenBSD: compile.c,v 1.42 2017/08/01 18:05:53 martijn 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
8016
	*compile_stream(&prog) = NULL;
129
4008
	fixuplabel(prog, NULL);
130
4008
	uselabel();
131
4008
	appends = xreallocarray(NULL, appendnum, sizeof(struct s_appends));
132
4008
	match = xreallocarray(NULL, maxnsub + 1, sizeof(regmatch_t));
133
4008
}
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
8016
	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
12048
	for (;;) {
154
22092
		if ((p = cu_fgets(&lbuf, &bufsize)) == NULL) {
155
3916
			if (stack != 0)
156
				error(COMPILE, "unexpected EOF (pending }'s)");
157
3908
			return (link);
158
		}
159
160

46124
semicolon:	EATSPACE();
161

17768
		if (*p == '#' || *p == '\0')
162
960
			continue;
163
8168
		if (*p == ';') {
164
			p++;
165
			goto semicolon;
166
		}
167
8168
		*link = cmd = xmalloc(sizeof(struct s_command));
168
8168
		link = &cmd->next;
169
8168
		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
16332
		if (addrchar(*p)) {
176
			naddr++;
177
940
			cmd->a1 = xmalloc(sizeof(struct s_addr));
178
940
			p = compile_addr(p, cmd->a1);
179

4552
			EATSPACE();				/* EXTENSION */
180
940
			if (*p == ',') {
181
122
				p++;
182

488
				EATSPACE();			/* EXTENSION */
183
				naddr++;
184
122
				cmd->a2 = xmalloc(sizeof(struct s_addr));
185
122
				p = compile_addr(p, cmd->a2);
186

548
				EATSPACE();
187
			} else {
188
818
				cmd->a2 = 0;
189
			}
190
		} else {
191
7224
			cmd->a1 = cmd->a2 = 0;
192
		}
193
194
nonsel:		/* Now parse the command */
195
8220
		if (!*p)
196
			error(COMPILE, "command expected");
197
8208
		cmd->code = *p;
198
270456
		for (fp = cmd_fmts; fp->code; fp++)
199
135220
			if (fp->code == *p)
200
				break;
201
8208
		if (!fp->code)
202
			error(COMPILE, "invalid command code %c", *p);
203
8200
		if (naddr > fp->naddr)
204
			error(COMPILE,
205
			    "command %c expects up to %d address(es), found %d",
206
			    *p, fp->naddr, naddr);
207



16760
		switch (fp->args) {
208
		case NONSEL:			/* ! */
209
56
			p++;
210

224
			EATSPACE();
211
56
			cmd->nonsel = 1;
212
56
			goto nonsel;
213
		case GROUP:			/* { */
214
528
			p++;
215

3636
			EATSPACE();
216
528
			cmd->next = stack;
217
			stack = cmd;
218
528
			link = &cmd->u.c;
219
528
			if (*p)
220
12
				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
520
			cmd->nonsel = 1;
228
520
			if (stack == 0)
229
				error(COMPILE, "unexpected }");
230
			cmd2 = stack;
231
520
			stack = cmd2->next;
232
520
			cmd2->next = cmd;
233
			/*FALLTHROUGH*/
234
		case EMPTY:		/* d D g G h H l n N p P q x = \0 */
235
1310
			p++;
236

8498
			EATSPACE();
237
1310
			if (*p == ';') {
238
4
				p++;
239
				link = &cmd->next;
240
4
				goto semicolon;
241
			}
242
1306
			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
84
			p++;
248

360
			EATSPACE();
249
84
			if (*p != '\\')
250
				error(COMPILE, "command %c expects \\ followed by"
251
				    " text", cmd->code);
252
80
			p++;
253

560
			EATSPACE();
254
80
			if (*p)
255
				error(COMPILE, "extra characters after \\ at the"
256
				    " end of %c command", cmd->code);
257
76
			cmd->t = compile_text();
258
76
			break;
259
		case COMMENT:			/* \0 # */
260
			break;
261
		case WFILE:			/* w */
262
248
			p++;
263

1736
			EATSPACE();
264
248
			if (*p == '\0')
265
				error(COMPILE, "filename expected");
266
248
			cmd->t = duptoeol(p, "w command", NULL);
267
248
			if (aflag) {
268
				cmd->u.fd = -1;
269
				pledge_wpath = 1;
270
			}
271
496
			else if ((cmd->u.fd = open(p,
272
			    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
273
248
			    DEFFILEMODE)) == -1)
274
				error(FATAL, "%s: %s", p, strerror(errno));
275
			break;
276
		case RFILE:			/* r */
277
12
			pledge_rpath = 1;
278
12
			p++;
279

84
			EATSPACE();
280
12
			cmd->t = duptoeol(p, "read command", NULL);
281
12
			break;
282
		case BRANCH:			/* b t */
283
326
			p++;
284

2150
			EATSPACE();
285
326
			if (*p == '\0')
286
16
				cmd->t = NULL;
287
			else
288
310
				cmd->t = duptoeol(p, "branch", &p);
289
326
			if (*p == ';') {
290
				p++;
291
				goto semicolon;
292
			}
293
			break;
294
		case LABEL:			/* : */
295
112
			p++;
296

544
			EATSPACE();
297
112
			cmd->t = duptoeol(p, "label", &p);
298
112
			if (strlen(cmd->t) == 0)
299
				error(COMPILE, "empty label");
300
112
			enterlabel(cmd);
301
112
			if (*p == ';') {
302
				p++;
303
				goto semicolon;
304
			}
305
			break;
306
		case SUBST:			/* s */
307
5488
			p++;
308

10976
			if (*p == '\0' || *p == '\\')
309
				error(COMPILE, "substitute pattern can not be"
310
				    " delimited by newline or backslash");
311
5488
			cmd->u.s = xmalloc(sizeof(struct s_subst));
312
5488
			p = compile_re(p, &cmd->u.s->re);
313
5488
			if (p == NULL)
314
				error(COMPILE, "unterminated substitute pattern");
315
5456
			--p;
316
5456
			p = compile_subst(p, cmd->u.s);
317
5456
			p = compile_flags(p, cmd->u.s);
318

24224
			EATSPACE();
319
5456
			if (*p == ';') {
320
24
				p++;
321
				link = &cmd->next;
322
24
				goto semicolon;
323
			}
324
			break;
325
		case TR:			/* y */
326
20
			p++;
327
20
			p = compile_tr(p, (char **)&cmd->u.y);
328

80
			EATSPACE();
329
20
			if (*p == ';') {
330
				p++;
331
				link = &cmd->next;
332
				goto semicolon;
333
			}
334
20
			if (*p)
335
				error(COMPILE, "extra text at the end of a"
336
				    " transform command");
337
			break;
338
		}
339
	}
340
3908
}
341
342
/*
343
 * Get a delimited string.  P points to the delimeter of the string; d points
344
 * to a buffer area.  Newline and delimiter escapes are processed; other
345
 * escapes are ignored.
346
 *
347
 * Returns a pointer to the first character after the final delimiter or NULL
348
 * in the case of a non-terminated string.  The character array d is filled
349
 * with the processed string.
350
 */
351
static char *
352
compile_delimited(char *p, char *d, int is_tr)
353
{
354
	char c;
355
356
12596
	c = *p++;
357
6298
	if (c == '\0')
358
		return (NULL);
359
6298
	else if (c == '\\')
360
		error(COMPILE, "\\ can not be used as a string delimiter");
361
6298
	else if (c == '\n')
362
		error(COMPILE, "newline can not be used as a string delimiter");
363
83542
	while (*p) {
364

45340
		if (*p == '[' && *p != c) {
365
2366
			if ((d = compile_ccl(&p, d)) == NULL)
366
				error(COMPILE, "unbalanced brackets ([])");
367
2366
			continue;
368

44549
		} else if (*p == '\\' && p[1] == '[') {
369
24
			*d++ = *p++;
370

44525
		} else if (*p == '\\' && p[1] == c) {
371
1390
			p++;
372

43111
		} else if (*p == '\\' && p[1] == 'n') {
373
56
			*d++ = '\n';
374
56
			p += 2;
375
56
			continue;
376

41609
		} else if (*p == '\\' && p[1] == '\\') {
377
4
			if (is_tr)
378
				p++;
379
			else
380
				*d++ = *p++;
381
39122
		} else if (*p == c) {
382
6278
			*d = '\0';
383
6278
			return (p + 1);
384
		}
385
34262
		*d++ = *p++;
386
	}
387
20
	return (NULL);
388
6298
}
389
390
391
/* compile_ccl: expand a POSIX character class */
392
static char *
393
compile_ccl(char **sp, char *t)
394
{
395
	int c, d;
396
4732
	char *s = *sp;
397
398
2366
	*t++ = *s++;
399
2366
	if (*s == '^')
400
862
		*t++ = *s++;
401
2366
	if (*s == ']')
402
		*t++ = *s++;
403

32688
	for (; *s && (*t = *s) != ']'; s++, t++)
404

5834
		if (*s == '[' && ((d = *(s+1)) == '.' || d == ':' || d == '=')) {
405
28
			*++t = *++s, t++, s++;
406

420
			for (c = *s; (*t = *s) != ']' || c != d; s++, t++)
407
168
				if ((c = *s) == '\0')
408
					return NULL;
409

5790
		} else if (*s == '\\' && s[1] == 'n') {
410
			*t = '\n';
411
			s++;
412
		}
413
2366
	if (*s == ']') {
414
2366
		*sp = ++s;
415
2366
		return (++t);
416
	} else {
417
		return (NULL);
418
	}
419
2366
}
420
421
/*
422
 * Get a regular expression.  P points to the delimiter of the regular
423
 * expression; repp points to the address of a regexp pointer.  Newline
424
 * and delimiter escapes are processed; other escapes are ignored.
425
 * Returns a pointer to the first character after the final delimiter
426
 * or NULL in the case of a non terminated regular expression.  The regexp
427
 * pointer is set to the compiled regular expression.
428
 * Cflags are passed to regcomp.
429
 */
430
static char *
431
compile_re(char *p, regex_t **repp)
432
{
433
	int eval;
434
	char *re;
435
436
12460
	re = xmalloc(strlen(p) + 1); /* strlen(re) <= strlen(p) */
437
6230
	p = compile_delimited(p, re, 0);
438

12452
	if (p && strlen(re) == 0) {
439
180
		*repp = NULL;
440
180
		free(re);
441
180
		return (p);
442
	}
443
6050
	*repp = xmalloc(sizeof(regex_t));
444

12092
	if (p && (eval = regcomp(*repp, re, Eflag ? REG_EXTENDED : 0)) != 0)
445
		error(COMPILE, "RE error: %s", strregerror(eval, *repp));
446
6050
	if (maxnsub < (*repp)->re_nsub)
447
363
		maxnsub = (*repp)->re_nsub;
448
6050
	free(re);
449
6050
	return (p);
450
6230
}
451
452
/*
453
 * Compile the substitution string of a regular expression and set res to
454
 * point to a saved copy of it.  Nsub is the number of parenthesized regular
455
 * expressions.
456
 */
457
static char *
458
compile_subst(char *p, struct s_subst *s)
459
{
460
	static char *lbuf;
461
	static size_t bufsize;
462
	int asize, ref, size;
463
	char c, *text, *op, *sp;
464
	int sawesc = 0;
465
466
10968
	c = *p++;			/* Terminator character */
467
5484
	if (c == '\0')
468
		return (NULL);
469
470
5484
	s->maxbref = 0;
471
5484
	s->linenum = linenum;
472
	text = NULL;
473
	asize = size = 0;
474
5484
	do {
475
5492
		size_t len = ROUNDLEN(strlen(p) + 1);
476
5492
		if (asize - size < len) {
477
5488
			do {
478
5488
				asize += len;
479
5488
			} while (asize - size < len);
480
5488
			text = xrealloc(text, asize);
481
5488
		}
482
5492
		op = sp = text + size;
483
53958
		for (; *p; p++) {
484
26963
			if (*p == '\\' || sawesc) {
485
				/*
486
				 * If this is a continuation from the last
487
				 * buffer, we won't have a character to
488
				 * skip over.
489
				 */
490
1199
				if (sawesc)
491
					sawesc = 0;
492
				else
493
1199
					p++;
494
495
1199
				if (*p == '\0') {
496
					/*
497
					 * This escaped character is continued
498
					 * in the next part of the line.  Note
499
					 * this fact, then cause the loop to
500
					 * exit w/ normal EOL case and reenter
501
					 * above with the new buffer.
502
					 */
503
					sawesc = 1;
504
					p--;
505
					continue;
506
1199
				} else if (strchr("123456789", *p) != NULL) {
507
1167
					*sp++ = '\\';
508
1167
					ref = *p - '0';
509

2030
					if (s->re != NULL &&
510
863
					    ref > s->re->re_nsub)
511
						error(COMPILE,
512
"\\%c not defined in the RE", *p);
513
1167
					if (s->maxbref < ref)
514
745
						s->maxbref = ref;
515

60
				} else if (*p == '&' || *p == '\\')
516
4
					*sp++ = '\\';
517
25764
			} else if (*p == c) {
518
5476
				p++;
519
5476
				*sp++ = '\0';
520
5476
				size += sp - op;
521
5476
				s->new = xrealloc(text, size);
522
5476
				return (p);
523
20288
			} else if (*p == '\n') {
524
				error(COMPILE,
525
"unescaped newline inside substitute pattern");
526
			}
527
21487
			*sp++ = *p;
528
21487
		}
529
16
		size += sp - op;
530

32
	} while ((p = cu_fgets(&lbuf, &bufsize)));
531
	error(COMPILE, "unterminated substitute in regular expression");
532
5476
}
533
534
/*
535
 * Compile the flags of the s command
536
 */
537
static char *
538
compile_flags(char *p, struct s_subst *s)
539
{
540
	int gn;			/* True if we have seen g or n */
541
	long l;
542
5476
	char wfile[PATH_MAX], *q, *eq;
543
544
5476
	s->n = 1;				/* Default */
545
5476
	s->p = 0;
546
5476
	s->wfile = NULL;
547
5476
	s->wfd = -1;
548
7098
	for (gn = 0;;) {
549

35712
		EATSPACE();			/* EXTENSION */
550




8034
		switch (*p) {
551
		case 'g':
552
1414
			if (gn)
553
				error(COMPILE, "more than one number or 'g' in"
554
				    " substitute flags");
555
			gn = 1;
556
1410
			s->n = 0;
557
1410
			break;
558
		case '\0':
559
		case '\n':
560
		case ';':
561
4652
			return (p);
562
		case 'p':
563
212
			s->p = 1;
564
212
			break;
565
		case '1': case '2': case '3':
566
		case '4': case '5': case '6':
567
		case '7': case '8': case '9':
568
940
			if (gn)
569
				error(COMPILE, "more than one number or 'g' in"
570
				    " substitute flags");
571
			gn = 1;
572
936
			l = strtol(p, &p, 10);
573
936
			if (l <= 0 || l >= INT_MAX)
574
				error(COMPILE,
575
				    "number in substitute flags out of range");
576
936
			s->n = (int)l;
577
936
			continue;
578
		case 'w':
579
808
			p++;
580
#ifdef HISTORIC_PRACTICE
581
			if (*p != ' ') {
582
				warning("space missing before w wfile");
583
				return (p);
584
			}
585
#endif
586

5644
			EATSPACE();
587
808
			q = wfile;
588
808
			eq = wfile + sizeof(wfile) - 1;
589
25904
			while (*p) {
590
12944
				if (*p == '\n')
591
					break;
592
12144
				if (q >= eq)
593
					error(COMPILE, "wfile too long");
594
12144
				*q++ = *p++;
595
			}
596
808
			*q = '\0';
597
808
			if (q == wfile)
598
				error(COMPILE, "no wfile specified");
599
804
			s->wfile = strdup(wfile);
600
804
			if (aflag)
601
				pledge_wpath = 1;
602
1608
			else if ((s->wfd = open(wfile,
603
			    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
604
804
			    DEFFILEMODE)) == -1)
605
				error(FATAL, "%s: %s", wfile, strerror(errno));
606
804
			return (p);
607
		default:
608
			error(COMPILE,
609
			    "bad flag in substitute command: '%c'", *p);
610
			break;
611
		}
612
1622
		p++;
613
	}
614
5456
}
615
616
/*
617
 * Compile a translation set of strings into a lookup table.
618
 */
619
static char *
620
compile_tr(char *p, char **transtab)
621
{
622
	int i;
623
	char *lt, *op, *np;
624
	char *old = NULL, *new = NULL;
625
626

108
	if (*p == '\0' || *p == '\\')
627
		error(COMPILE,
628
"transform pattern can not be delimited by newline or backslash");
629
36
	old = xmalloc(strlen(p) + 1);
630
36
	p = compile_delimited(p, old, 1);
631
36
	if (p == NULL) {
632
		error(COMPILE, "unterminated transform source string");
633
		goto bad;
634
	}
635
32
	new = xmalloc(strlen(p) + 1);
636
32
	p = compile_delimited(--p, new, 1);
637
32
	if (p == NULL) {
638
		error(COMPILE, "unterminated transform target string");
639
		goto bad;
640
	}
641

96
	EATSPACE();
642
24
	if (strlen(new) != strlen(old)) {
643
		error(COMPILE, "transform strings are not the same length");
644
		goto bad;
645
	}
646
	/* We assume characters are 8 bits */
647
20
	lt = xmalloc(UCHAR_MAX + 1);
648
10280
	for (i = 0; i <= UCHAR_MAX; i++)
649
5120
		lt[i] = (char)i;
650
480
	for (op = old, np = new; *op; op++, np++)
651
220
		lt[(u_char)*op] = *np;
652
20
	*transtab = lt;
653
20
	free(old);
654
20
	free(new);
655
	return (p);
656
bad:
657
	free(old);
658
	free(new);
659
	return (NULL);
660
20
}
661
662
/*
663
 * Compile the text following an a, c, or i command.
664
 */
665
static char *
666
compile_text(void)
667
{
668
	int asize, esc_nl, size;
669
152
	char *lbuf, *text, *p, *op, *s;
670
76
	size_t bufsize;
671
672
76
	lbuf = text = NULL;
673
	asize = size = 0;
674
168
	while ((p = cu_fgets(&lbuf, &bufsize))) {
675
84
		size_t len = ROUNDLEN(strlen(p) + 1);
676
84
		if (asize - size < len) {
677
80
			do {
678
80
				asize += len;
679
80
			} while (asize - size < len);
680
80
			text = xrealloc(text, asize);
681
80
		}
682
84
		op = s = text + size;
683
3584
		for (esc_nl = 0; *p != '\0'; p++) {
684

1732
			if (*p == '\\' && p[1] != '\0' && *++p == '\n')
685
8
				esc_nl = 1;
686
1708
			*s++ = *p;
687
		}
688
84
		size += s - op;
689
84
		if (!esc_nl) {
690
76
			*s = '\0';
691
76
			break;
692
		}
693
8
	}
694
76
	free(lbuf);
695
76
	text = xrealloc(text, size + 1);
696
76
	text[size] = '\0';
697
76
	return (text);
698
76
}
699
700
/*
701
 * Get an address and return a pointer to the first character after
702
 * it.  Fill the structure pointed to according to the address.
703
 */
704
static char *
705
compile_addr(char *p, struct s_addr *a)
706
{
707
2136
	char *end;
708
709



1070
	switch (*p) {
710
	case '\\':				/* Context address */
711
4
		++p;
712
		/* FALLTHROUGH */
713
	case '/':				/* Context address */
714
742
		p = compile_re(p, &a->u.r);
715
742
		if (p == NULL)
716
			error(COMPILE, "unterminated regular expression");
717
738
		a->type = AT_RE;
718
738
		return (p);
719
720
	case '$':				/* Last line */
721
28
		a->type = AT_LAST;
722
28
		return (p + 1);
723
						/* Line number */
724
	case '0': case '1': case '2': case '3': case '4':
725
	case '5': case '6': case '7': case '8': case '9':
726
296
		a->type = AT_LINE;
727
296
		a->u.l = strtoul(p, &end, 10);
728
296
		return (end);
729
	default:
730
		error(COMPILE, "expected context address");
731
		return (NULL);
732
	}
733
1062
}
734
735
/*
736
 * duptoeol --
737
 *	Return a copy of all the characters up to \n or \0.
738
 */
739
static char *
740
duptoeol(char *s, char *ctype, char **semi)
741
{
742
	size_t len;
743
	int ws;
744
	char *start;
745
746
	ws = 0;
747
1364
	if (semi) {
748

7362
		for (start = s; *s != '\0' && *s != '\n' && *s != ';'; ++s)
749
1528
			ws = isspace((unsigned char)*s);
750
	} else {
751

24424
		for (start = s; *s != '\0' && *s != '\n'; ++s)
752
5850
			ws = isspace((unsigned char)*s);
753
260
		*s = '\0';
754
	}
755
682
	if (ws)
756
		warning("whitespace after %s", ctype);
757
682
	len = s - start + 1;
758
682
	if (semi)
759
422
		*semi = s;
760
682
	s = xmalloc(len);
761
682
	strlcpy(s, start, len);
762
682
	return (s);
763
}
764
765
/*
766
 * Convert goto label names to addresses, and count a and r commands, in
767
 * the given subset of the script.  Free the memory used by labels in b
768
 * and t commands (but not by :).
769
 *
770
 * TODO: Remove } nodes
771
 */
772
static void
773
fixuplabel(struct s_command *cp, struct s_command *end)
774
{
775
776
29420
	for (; cp != end; cp = cp->next)
777

8958
		switch (cp->code) {
778
		case 'a':
779
		case 'r':
780
44
			appendnum++;
781
44
			break;
782
		case 'b':
783
		case 't':
784
			/* Resolve branch target. */
785
326
			if (cp->t == NULL) {
786
16
				cp->u.c = NULL;
787
16
				break;
788
			}
789
310
			if ((cp->u.c = findlabel(cp->t)) == NULL)
790
				error(COMPILE, "undefined label '%s'", cp->t);
791
306
			free(cp->t);
792
306
			break;
793
		case '{':
794
			/* Do interior commands. */
795
520
			fixuplabel(cp->u.c, cp->next);
796
520
			break;
797
		}
798
4424
}
799
800
/*
801
 * Associate the given command label for later lookup.
802
 */
803
static void
804
enterlabel(struct s_command *cp)
805
{
806
	struct labhash **lhp, *lh;
807
	u_char *p;
808
	u_int h, c;
809
810
1104
	for (h = 0, p = (u_char *)cp->t; (c = *p) != 0; p++)
811
384
		h = (h << 5) + h + c;
812
112
	lhp = &labels[h & LHMASK];
813
224
	for (lh = *lhp; lh != NULL; lh = lh->lh_next)
814
		if (lh->lh_hash == h && strcmp(cp->t, lh->lh_cmd->t) == 0)
815
			error(COMPILE, "duplicate label '%s'", cp->t);
816
112
	lh = xmalloc(sizeof *lh);
817
112
	lh->lh_next = *lhp;
818
112
	lh->lh_hash = h;
819
112
	lh->lh_cmd = cp;
820
112
	lh->lh_ref = 0;
821
112
	*lhp = lh;
822
112
}
823
824
/*
825
 * Find the label contained in the command l in the command linked
826
 * list cp.  L is excluded from the search.  Return NULL if not found.
827
 */
828
static struct s_command *
829
findlabel(char *name)
830
{
831
	struct labhash *lh;
832
	u_char *p;
833
	u_int h, c;
834
835
3218
	for (h = 0, p = (u_char *)name; (c = *p) != 0; p++)
836
1144
		h = (h << 5) + h + c;
837
620
	for (lh = labels[h & LHMASK]; lh != NULL; lh = lh->lh_next) {
838

612
		if (lh->lh_hash == h && strcmp(name, lh->lh_cmd->t) == 0) {
839
306
			lh->lh_ref = 1;
840
306
			return (lh->lh_cmd);
841
		}
842
	}
843
4
	return (NULL);
844
310
}
845
846
/*
847
 * Warn about any unused labels.  As a side effect, release the label hash
848
 * table space.
849
 */
850
static void
851
uselabel(void)
852
{
853
	struct labhash *lh, *next;
854
	int i;
855
856
1011136
	for (i = 0; i < LHSZ; i++) {
857
999648
		for (lh = labels[i]; lh != NULL; lh = next) {
858
112
			next = lh->lh_next;
859
112
			if (!lh->lh_ref)
860
				warning("unused label '%s'",
861
				    lh->lh_cmd->t);
862
112
			free(lh);
863
		}
864
	}
865
3904
}