xref: /netbsd/usr.bin/rdist/gram.y (revision bf9ec67e) 
1 %{
2 /*	$NetBSD: gram.y,v 1.8 1997/10/19 13:59:00 lukem Exp $	*/
3 
4 /*
5  * Copyright (c) 1983, 1993
6  *	The Regents of the University of California.  All rights reserved.
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  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by the University of
19  *	California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  */
36 
37 #include <sys/cdefs.h>
38 #ifndef lint
39 #if 0
40 static char sccsid[] = "@(#)gram.y	8.1 (Berkeley) 6/9/93";
41 #else
42 __RCSID("$NetBSD: gram.y,v 1.8 1997/10/19 13:59:00 lukem Exp $");
43 #endif
44 #endif /* not lint */
45 
46 #include "defs.h"
47 
48 struct	cmd *cmds = NULL;
49 struct	cmd *last_cmd;
50 struct	namelist *last_n;
51 struct	subcmd *last_sc;
52 
53 static char   *makestr __P((char *));
54 void	append __P((char *, struct namelist *, char *, struct subcmd *));
55 
56 %}
57 
58 %term EQUAL	1
59 %term LP	2
60 %term RP	3
61 %term SM	4
62 %term ARROW	5
63 %term COLON	6
64 %term DCOLON	7
65 %term NAME	8
66 %term STRING	9
67 %term INSTALL	10
68 %term NOTIFY	11
69 %term EXCEPT	12
70 %term PATTERN	13
71 %term SPECIAL	14
72 %term OPTION	15
73 
74 %union {
75 	int intval;
76 	char *string;
77 	struct subcmd *subcmd;
78 	struct namelist *namel;
79 }
80 
81 %type <intval> OPTION, options
82 %type <string> NAME, STRING
83 %type <subcmd> INSTALL, NOTIFY, EXCEPT, PATTERN, SPECIAL, cmdlist, cmd
84 %type <namel> namelist, names, opt_namelist
85 
86 %%
87 
88 file:		  /* VOID */
89 		| file command
90 		;
91 
92 command:	  NAME EQUAL namelist = {
93 			(void) lookup($1, INSERT, $3);
94 		}
95 		| namelist ARROW namelist cmdlist = {
96 			insert(NULL, $1, $3, $4);
97 		}
98 		| NAME COLON namelist ARROW namelist cmdlist = {
99 			insert($1, $3, $5, $6);
100 		}
101 		| namelist DCOLON NAME cmdlist = {
102 			append(NULL, $1, $3, $4);
103 		}
104 		| NAME COLON namelist DCOLON NAME cmdlist = {
105 			append($1, $3, $5, $6);
106 		}
107 		| error
108 		;
109 
110 namelist:	  NAME = {
111 			$$ = makenl($1);
112 		}
113 		| LP names RP = {
114 			$$ = $2;
115 		}
116 		;
117 
118 names:		  /* VOID */ {
119 			$$ = last_n = NULL;
120 		}
121 		| names NAME = {
122 			if (last_n == NULL)
123 				$$ = last_n = makenl($2);
124 			else {
125 				last_n->n_next = makenl($2);
126 				last_n = last_n->n_next;
127 				$$ = $1;
128 			}
129 		}
130 		;
131 
132 cmdlist:	  /* VOID */ {
133 			$$ = last_sc = NULL;
134 		}
135 		| cmdlist cmd = {
136 			if (last_sc == NULL)
137 				$$ = last_sc = $2;
138 			else {
139 				last_sc->sc_next = $2;
140 				last_sc = $2;
141 				$$ = $1;
142 			}
143 		}
144 		;
145 
146 cmd:		  INSTALL options opt_namelist SM = {
147 			struct namelist *nl;
148 
149 			$1->sc_options = $2 | options;
150 			if ($3 != NULL) {
151 				nl = expand($3, E_VARS);
152 				if (nl) {
153 					if (nl->n_next != NULL)
154 					    yyerror("only one name allowed\n");
155 					$1->sc_name = nl->n_name;
156 					free(nl);
157 				} else
158 					$1->sc_name = NULL;
159 			}
160 			$$ = $1;
161 		}
162 		| NOTIFY namelist SM = {
163 			if ($2 != NULL)
164 				$1->sc_args = expand($2, E_VARS);
165 			$$ = $1;
166 		}
167 		| EXCEPT namelist SM = {
168 			if ($2 != NULL)
169 				$1->sc_args = expand($2, E_ALL);
170 			$$ = $1;
171 		}
172 		| PATTERN namelist SM = {
173 			if ($2 != NULL)
174 				$1->sc_args = expand($2, E_VARS);
175 			$$ = $1;
176 		}
177 		| SPECIAL opt_namelist STRING SM = {
178 			if ($2 != NULL)
179 				$1->sc_args = expand($2, E_ALL);
180 			$1->sc_name = $3;
181 			$$ = $1;
182 		}
183 		;
184 
185 options:	  /* VOID */ = {
186 			$$ = 0;
187 		}
188 		| options OPTION = {
189 			$$ |= $2;
190 		}
191 		;
192 
193 opt_namelist:	  /* VOID */ = {
194 			$$ = NULL;
195 		}
196 		| namelist = {
197 			$$ = $1;
198 		}
199 		;
200 
201 %%
202 
203 int	yylineno = 1;
204 extern	FILE *fin;
205 
206 int	yylex __P((void));
207 
208 int
209 yylex()
210 {
211 	static char yytext[INMAX];
212 	int c;
213 	char *cp1, *cp2;
214 	static char quotechars[] = "[]{}*?$";
215 
216 again:
217 	switch (c = getc(fin)) {
218 	case EOF:  /* end of file */
219 		return(0);
220 
221 	case '#':  /* start of comment */
222 		while ((c = getc(fin)) != EOF && c != '\n')
223 			;
224 		if (c == EOF)
225 			return(0);
226 	case '\n':
227 		yylineno++;
228 	case ' ':
229 	case '\t':  /* skip blanks */
230 		goto again;
231 
232 	case '=':  /* EQUAL */
233 		return(EQUAL);
234 
235 	case '(':  /* LP */
236 		return(LP);
237 
238 	case ')':  /* RP */
239 		return(RP);
240 
241 	case ';':  /* SM */
242 		return(SM);
243 
244 	case '-':  /* -> */
245 		if ((c = getc(fin)) == '>')
246 			return(ARROW);
247 		ungetc(c, fin);
248 		c = '-';
249 		break;
250 
251 	case '"':  /* STRING */
252 		cp1 = yytext;
253 		cp2 = &yytext[INMAX - 1];
254 		for (;;) {
255 			if (cp1 >= cp2) {
256 				yyerror("command string too long\n");
257 				break;
258 			}
259 			c = getc(fin);
260 			if (c == EOF || c == '"')
261 				break;
262 			if (c == '\\') {
263 				if ((c = getc(fin)) == EOF) {
264 					*cp1++ = '\\';
265 					break;
266 				}
267 			}
268 			if (c == '\n') {
269 				yylineno++;
270 				c = ' '; /* can't send '\n' */
271 			}
272 			*cp1++ = c;
273 		}
274 		if (c != '"')
275 			yyerror("missing closing '\"'\n");
276 		*cp1 = '\0';
277 		yylval.string = makestr(yytext);
278 		return(STRING);
279 
280 	case ':':  /* : or :: */
281 		if ((c = getc(fin)) == ':')
282 			return(DCOLON);
283 		ungetc(c, fin);
284 		return(COLON);
285 	}
286 	cp1 = yytext;
287 	cp2 = &yytext[INMAX - 1];
288 	for (;;) {
289 		if (cp1 >= cp2) {
290 			yyerror("input line too long\n");
291 			break;
292 		}
293 		if (c == '\\') {
294 			if ((c = getc(fin)) != EOF) {
295 				if (any(c, quotechars))
296 					c |= QUOTE;
297 			} else {
298 				*cp1++ = '\\';
299 				break;
300 			}
301 		}
302 		*cp1++ = c;
303 		c = getc(fin);
304 		if (c == EOF || any(c, " \"'\t()=;:\n")) {
305 			ungetc(c, fin);
306 			break;
307 		}
308 	}
309 	*cp1 = '\0';
310 	if (yytext[0] == '-' && yytext[2] == '\0') {
311 		switch (yytext[1]) {
312 		case 'b':
313 			yylval.intval = COMPARE;
314 			return(OPTION);
315 
316 		case 'R':
317 			yylval.intval = REMOVE;
318 			return(OPTION);
319 
320 		case 'v':
321 			yylval.intval = VERIFY;
322 			return(OPTION);
323 
324 		case 'w':
325 			yylval.intval = WHOLE;
326 			return(OPTION);
327 
328 		case 'y':
329 			yylval.intval = YOUNGER;
330 			return(OPTION);
331 
332 		case 'h':
333 			yylval.intval = FOLLOW;
334 			return(OPTION);
335 
336 		case 'i':
337 			yylval.intval = IGNLNKS;
338 			return(OPTION);
339 		}
340 	}
341 	if (!strcmp(yytext, "install"))
342 		c = INSTALL;
343 	else if (!strcmp(yytext, "notify"))
344 		c = NOTIFY;
345 	else if (!strcmp(yytext, "except"))
346 		c = EXCEPT;
347 	else if (!strcmp(yytext, "except_pat"))
348 		c = PATTERN;
349 	else if (!strcmp(yytext, "special"))
350 		c = SPECIAL;
351 	else {
352 		yylval.string = makestr(yytext);
353 		return(NAME);
354 	}
355 	yylval.subcmd = makesubcmd(c);
356 	return(c);
357 }
358 
359 int
360 any(c, str)
361 	int c;
362 	char *str;
363 {
364 	while (*str)
365 		if (c == *str++)
366 			return(1);
367 	return(0);
368 }
369 
370 /*
371  * Insert or append ARROW command to list of hosts to be updated.
372  */
373 void
374 insert(label, files, hosts, subcmds)
375 	char *label;
376 	struct namelist *files, *hosts;
377 	struct subcmd *subcmds;
378 {
379 	struct cmd *c, *prev, *nc;
380 	struct namelist *h, *nexth;
381 
382 	files = expand(files, E_VARS|E_SHELL);
383 	hosts = expand(hosts, E_ALL);
384 	for (h = hosts; h != NULL; nexth = h->n_next, free(h), h = nexth) {
385 		/*
386 		 * Search command list for an update to the same host.
387 		 */
388 		for (prev = NULL, c = cmds; c!=NULL; prev = c, c = c->c_next) {
389 			if (strcmp(c->c_name, h->n_name) == 0) {
390 				do {
391 					prev = c;
392 					c = c->c_next;
393 				} while (c != NULL &&
394 					strcmp(c->c_name, h->n_name) == 0);
395 				break;
396 			}
397 		}
398 		/*
399 		 * Insert new command to update host.
400 		 */
401 		nc = ALLOC(cmd);
402 		if (nc == NULL)
403 			fatal("ran out of memory\n");
404 		nc->c_type = ARROW;
405 		nc->c_name = h->n_name;
406 		nc->c_label = label;
407 		nc->c_files = files;
408 		nc->c_cmds = subcmds;
409 		nc->c_next = c;
410 		if (prev == NULL)
411 			cmds = nc;
412 		else
413 			prev->c_next = nc;
414 		/* update last_cmd if appending nc to cmds */
415 		if (c == NULL)
416 			last_cmd = nc;
417 	}
418 }
419 
420 /*
421  * Append DCOLON command to the end of the command list since these are always
422  * executed in the order they appear in the distfile.
423  */
424 void
425 append(label, files, stamp, subcmds)
426 	char *label;
427 	struct namelist *files;
428 	char *stamp;
429 	struct subcmd *subcmds;
430 {
431 	struct cmd *c;
432 
433 	c = ALLOC(cmd);
434 	if (c == NULL)
435 		fatal("ran out of memory\n");
436 	c->c_type = DCOLON;
437 	c->c_name = stamp;
438 	c->c_label = label;
439 	c->c_files = expand(files, E_ALL);
440 	c->c_cmds = subcmds;
441 	c->c_next = NULL;
442 	if (cmds == NULL)
443 		cmds = last_cmd = c;
444 	else {
445 		last_cmd->c_next = c;
446 		last_cmd = c;
447 	}
448 }
449 
450 /*
451  * Error printing routine in parser.
452  */
453 void
454 yyerror(s)
455 	char *s;
456 {
457 
458 	++nerrs;
459 	fflush(stdout);
460 	fprintf(stderr, "rdist: line %d: %s\n", yylineno, s);
461 }
462 
463 /*
464  * Return a copy of the string.
465  */
466 static char *
467 makestr(str)
468 	char *str;
469 {
470 	char *cp, *s;
471 
472 	str = cp = malloc(strlen(s = str) + 1);
473 	if (cp == NULL)
474 		fatal("ran out of memory\n");
475 	while ((*cp++ = *s++) != NULL)
476 		;
477 	return(str);
478 }
479 
480 /*
481  * Allocate a namelist structure.
482  */
483 struct namelist *
484 makenl(name)
485 	char *name;
486 {
487 	struct namelist *nl;
488 
489 	nl = ALLOC(namelist);
490 	if (nl == NULL)
491 		fatal("ran out of memory\n");
492 	nl->n_name = name;
493 	nl->n_next = NULL;
494 	return(nl);
495 }
496 
497 /*
498  * Make a sub command for lists of variables, commands, etc.
499  */
500 struct subcmd *
501 makesubcmd(type)
502 	int	type;
503 {
504 	struct subcmd *sc;
505 
506 	sc = ALLOC(subcmd);
507 	if (sc == NULL)
508 		fatal("ran out of memory\n");
509 	sc->sc_type = type;
510 	sc->sc_args = NULL;
511 	sc->sc_next = NULL;
512 	sc->sc_name = NULL;
513 	return(sc);
514 }
515