Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/rdist/gram.y	Lines:	0	173	0.0 %
Date:	2017-11-07	Branches:	0	150	0.0 %


%{
/*	$OpenBSD: gram.y,v 1.12 2015/01/20 09:00:16 guenther Exp $	*/

/*
 * Copyright (c) 1993 Michael A. Cooper
 * Copyright (c) 1993 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "client.h"

static struct namelist *addnl(struct namelist *, struct namelist *);
static struct namelist *subnl(struct namelist *, struct namelist *);
static struct namelist *andnl(struct namelist *, struct namelist *);
static int innl(struct namelist *nl, char *p);

struct	cmd *cmds = NULL;
struct	cmd *last_cmd;
struct	namelist *last_n;
struct	subcmd *last_sc;
int	parendepth = 0;

%}

%term ARROW		1
%term COLON		2
%term DCOLON		3
%term NAME		4
%term STRING		5
%term INSTALL		6
%term NOTIFY		7
%term EXCEPT		8
%term PATTERN		9
%term SPECIAL		10
%term CMDSPECIAL	11
%term OPTION		12

%union {
	opt_t 			optval;
	char 		       *string;
	struct subcmd 	       *subcmd;
	struct namelist        *namel;
}

%type <optval> OPTION, options
%type <string> NAME, STRING
%type <subcmd> INSTALL, NOTIFY, EXCEPT, PATTERN, SPECIAL, CMDSPECIAL, cmdlist, cmd
%type <namel> namelist, names, opt_namelist nlist

%%

file:		  /* VOID */
		| file command
		;

command:	  NAME '=' namelist = {
			(void) lookup($1, INSERT, $3);
		}
		| namelist ARROW namelist cmdlist = {
			insert((char *)NULL, $1, $3, $4);
		}
		| NAME COLON namelist ARROW namelist cmdlist = {
			insert($1, $3, $5, $6);
		}
		| namelist DCOLON NAME cmdlist = {
			append((char *)NULL, $1, $3, $4);
		}
		| NAME COLON namelist DCOLON NAME cmdlist = {
			append($1, $3, $5, $6);
		}
		| error
		;

namelist: 	nlist {
			$$ = $1;
		}
		| nlist '-' nlist {
			$$ = subnl($1, $3);
		}
		| nlist '+' nlist {
			$$ = addnl($1, $3);
		}
		| nlist '&' nlist {
			$$ = andnl($1, $3);
		}
		;

nlist:	  NAME = {
			$$ = makenl($1);
		}
		| '(' names ')' = {
			$$ = $2;
		}
		;

names:		  /* VOID */ {
			$$ = last_n = NULL;
		}
		| names NAME = {
			if (last_n == NULL)
				$$ = last_n = makenl($2);
			else {
				last_n->n_next = makenl($2);
				last_n = last_n->n_next;
				$$ = $1;
			}
		}
		;

cmdlist:	  /* VOID */ {
			$$ = last_sc = NULL;
		}
		| cmdlist cmd = {
			if (last_sc == NULL)
				$$ = last_sc = $2;
			else {
				last_sc->sc_next = $2;
				last_sc = $2;
				$$ = $1;
			}
		}
		;

cmd:		  INSTALL options opt_namelist ';' = {
			struct namelist *nl;

			$1->sc_options = $2 | options;
			if ($3 != NULL) {
				nl = expand($3, E_VARS);
				if (nl) {
					if (nl->n_next != NULL)
					    yyerror("only one name allowed\n");
					$1->sc_name = nl->n_name;
					free(nl);
				} else
					$1->sc_name = NULL;
			}
			$$ = $1;
		}
		| NOTIFY namelist ';' = {
			if ($2 != NULL)
				$1->sc_args = expand($2, E_VARS);
			$$ = $1;
		}
		| EXCEPT namelist ';' = {
			if ($2 != NULL)
				$1->sc_args = expand($2, E_ALL);
			$$ = $1;
		}
		| PATTERN namelist ';' = {
			struct namelist *nl;
			char ebuf[BUFSIZ];
			regex_t reg;
			int ecode;

			for (nl = $2; nl != NULL; nl = nl->n_next) {
				/* check for a valid regex */
				ecode = regcomp(&reg, nl->n_name, REG_NOSUB);
				if (ecode) {
					regerror(ecode, &reg, ebuf,
					    sizeof(ebuf));
					yyerror(ebuf);
				}
				regfree(&reg);
			}
			$1->sc_args = expand($2, E_VARS);
			$$ = $1;
		}
		| SPECIAL opt_namelist STRING ';' = {
			if ($2 != NULL)
				$1->sc_args = expand($2, E_ALL);
			$1->sc_name = $3;
			$$ = $1;
		}
		| CMDSPECIAL opt_namelist STRING ';' = {
			if ($2 != NULL)
				$1->sc_args = expand($2, E_ALL);
			$1->sc_name = $3;
			$$ = $1;
		}
		;

options:	  /* VOID */ = {
			$$ = 0;
		}
		| options OPTION = {
			$$ |= $2;
		}
		;

opt_namelist:	  /* VOID */ = {
			$$ = NULL;
		}
		| namelist = {
			$$ = $1;
		}
		;

%%

int	yylineno = 1;
extern	FILE *fin;

int
yylex(void)
{
	static char yytext[INMAX];
	int c;
	char *cp1, *cp2;
	static char quotechars[] = "[]{}*?$";

again:
	switch (c = getc(fin)) {
	case EOF:  /* end of file */
		return(0);

	case '#':  /* start of comment */
		while ((c = getc(fin)) != EOF && c != '\n')
			;
		if (c == EOF)
			return(0);
	case '\n':
		yylineno++;
	case ' ':
	case '\t':  /* skip blanks */
		goto again;

	case '=':  /* EQUAL */
	case ';':  /* SM */
	case '+':
	case '&':
		return(c);

	case '(':  /* LP */
		++parendepth;
		return(c);

	case ')':  /* RP */
		--parendepth;
		return(c);

	case '-':  /* -> */
		if ((c = getc(fin)) == '>')
			return(ARROW);
		(void) ungetc(c, fin);
		c = '-';
		break;

	case '"':  /* STRING */
		cp1 = yytext;
		cp2 = &yytext[INMAX - 1];
		for (;;) {
			if (cp1 >= cp2) {
				yyerror("command string too long\n");
				break;
			}
			c = getc(fin);
			if (c == EOF || c == '"')
				break;
			if (c == '\\') {
				if ((c = getc(fin)) == EOF) {
					*cp1++ = '\\';
					break;
				}
			}
			if (c == '\n') {
				yylineno++;
				c = ' '; /* can't send '\n' */
			}
			*cp1++ = c;
		}
		if (c != '"')
			yyerror("missing closing '\"'\n");
		*cp1 = '\0';
		yylval.string = xstrdup(yytext);
		return(STRING);

	case ':':  /* : or :: */
		if ((c = getc(fin)) == ':')
			return(DCOLON);
		(void) ungetc(c, fin);
		return(COLON);
	}
	cp1 = yytext;
	cp2 = &yytext[INMAX - 1];
	for (;;) {
		if (cp1 >= cp2) {
			yyerror("input line too long\n");
			break;
		}
		if (c == '\\') {
			if ((c = getc(fin)) != EOF) {
				if (any(c, quotechars))
					*cp1++ = QUOTECHAR;
			} else {
				*cp1++ = '\\';
				break;
			}
		}
		*cp1++ = c;
		c = getc(fin);
		if (c == EOF || any(c, " \"'\t()=;:\n")) {
			(void) ungetc(c, fin);
			break;
		}
	}
	*cp1 = '\0';
	if (yytext[0] == '-' && yytext[1] == CNULL)
		return '-';
	if (yytext[0] == '-' && parendepth <= 0) {
		opt_t opt = 0;
		static char ebuf[BUFSIZ];

		switch (yytext[1]) {
		case 'o':
			if (parsedistopts(&yytext[2], &opt, TRUE)) {
				(void) snprintf(ebuf, sizeof(ebuf),
					        "Bad distfile options \"%s\".",
					        &yytext[2]);
				yyerror(ebuf);
			}
			break;

			/*
			 * These options are obsoleted by -o.
			 */
		case 'b':	opt = DO_COMPARE;		break;
		case 'R':	opt = DO_REMOVE;		break;
		case 'v':	opt = DO_VERIFY;		break;
		case 'w':	opt = DO_WHOLE;			break;
		case 'y':	opt = DO_YOUNGER;		break;
		case 'h':	opt = DO_FOLLOW;		break;
		case 'i':	opt = DO_IGNLNKS;		break;
		case 'q':	opt = DO_QUIET;			break;
		case 'x':	opt = DO_NOEXEC;		break;
		case 'N':	opt = DO_CHKNFS;		break;
		case 'O':	opt = DO_CHKREADONLY;		break;
		case 's':	opt = DO_SAVETARGETS;		break;
		case 'r':	opt = DO_NODESCEND;		break;

		default:
			(void) snprintf(ebuf, sizeof(ebuf),
					"Unknown option \"%s\".", yytext);
			yyerror(ebuf);
		}

		yylval.optval = opt;
		return(OPTION);
	}
	if (!strcmp(yytext, "install"))
		c = INSTALL;
	else if (!strcmp(yytext, "notify"))
		c = NOTIFY;
	else if (!strcmp(yytext, "except"))
		c = EXCEPT;
	else if (!strcmp(yytext, "except_pat"))
		c = PATTERN;
	else if (!strcmp(yytext, "special"))
		c = SPECIAL;
	else if (!strcmp(yytext, "cmdspecial"))
		c = CMDSPECIAL;
	else {
		yylval.string = xstrdup(yytext);
		return(NAME);
	}
	yylval.subcmd = makesubcmd(c);
	return(c);
}

/*
 * XXX We should use strchr(), but most versions can't handle
 * some of the characters we use.
 */
int any(int c, char *str)
{
	while (*str)
		if (c == *str++)
			return(1);
	return(0);
}

/*
 * Insert or append ARROW command to list of hosts to be updated.
 */
void
insert(char *label, struct namelist *files, struct namelist *hosts,
    struct subcmd *scmds)
{
	struct cmd *c, *prev, *nc;
	struct namelist *h, *lasth;

	debugmsg(DM_CALL, "insert(%s, %p, %p, %p) start, files = %s",
		 label == NULL ? "(null)" : label,
		 files, hosts, scmds, getnlstr(files));

	files = expand(files, E_VARS|E_SHELL);
	hosts = expand(hosts, E_ALL);
	for (h = hosts; h != NULL; lasth = h, h = h->n_next,
	     free((char *)lasth)) {
		/*
		 * Search command list for an update to the same host.
		 */
		for (prev = NULL, c = cmds; c!=NULL; prev = c, c = c->c_next) {
			if (strcmp(c->c_name, h->n_name) == 0) {
				do {
					prev = c;
					c = c->c_next;
				} while (c != NULL &&
					strcmp(c->c_name, h->n_name) == 0);
				break;
			}
		}
		/*
		 * Insert new command to update host.
		 */
		nc = ALLOC(cmd);
		nc->c_type = ARROW;
		nc->c_name = h->n_name;
		nc->c_label = label;
		nc->c_files = files;
		nc->c_cmds = scmds;
		nc->c_flags = 0;
		nc->c_next = c;
		if (prev == NULL)
			cmds = nc;
		else
			prev->c_next = nc;
		/* update last_cmd if appending nc to cmds */
		if (c == NULL)
			last_cmd = nc;
	}
}

/*
 * Append DCOLON command to the end of the command list since these are always
 * executed in the order they appear in the distfile.
 */
void
append(char *label, struct namelist *files, char *stamp, struct subcmd *scmds)
{
	struct cmd *c;

	c = ALLOC(cmd);
	c->c_type = DCOLON;
	c->c_name = stamp;
	c->c_label = label;
	c->c_files = expand(files, E_ALL);
	c->c_cmds = scmds;
	c->c_next = NULL;
	if (cmds == NULL)
		cmds = last_cmd = c;
	else {
		last_cmd->c_next = c;
		last_cmd = c;
	}
}

/*
 * Error printing routine in parser.
 */
void
yyerror(char *s)
{
	error("Error in distfile: line %d: %s", yylineno, s);
}

/*
 * Allocate a namelist structure.
 */
struct namelist *
makenl(char *name)
{
	struct namelist *nl;

	debugmsg(DM_CALL, "makenl(%s)", name == NULL ? "null" : name);

	nl = ALLOC(namelist);
	nl->n_name = name;
	nl->n_regex = NULL;
	nl->n_next = NULL;

	return(nl);
}


/*
 * Is the name p in the namelist nl?
 */
static int
innl(struct namelist *nl, char *p)
{
	for ( ; nl; nl = nl->n_next)
		if (!strcmp(p, nl->n_name))
			return(1);
	return(0);
}

/*
 * Join two namelists.
 */
static struct namelist *
addnl(struct namelist *n1, struct namelist *n2)
{
	struct namelist *nl, *prev;

	n1 = expand(n1, E_VARS);
	n2 = expand(n2, E_VARS);
	for (prev = NULL, nl = NULL; n1; n1 = n1->n_next, prev = nl) {
		nl = makenl(n1->n_name);
		nl->n_next = prev;
	}
	for (; n2; n2 = n2->n_next)
		if (!innl(nl, n2->n_name)) {
			nl = makenl(n2->n_name);
			nl->n_next = prev;
			prev = nl;
		}
	return(prev);
}

/*
 * Copy n1 except for elements that are in n2.
 */
static struct namelist *
subnl(struct namelist *n1, struct namelist *n2)
{
	struct namelist *nl, *prev;

	n1 = expand(n1, E_VARS);
	n2 = expand(n2, E_VARS);
	for (prev = NULL; n1; n1 = n1->n_next)
		if (!innl(n2, n1->n_name)) {
			nl = makenl(n1->n_name);
			nl->n_next = prev;
			prev = nl;
		}
	return(prev);
}

/*
 * Copy all items of n1 that are also in n2.
 */
static struct namelist *
andnl(struct namelist *n1, struct namelist *n2)
{
	struct namelist *nl, *prev;

	n1 = expand(n1, E_VARS);
	n2 = expand(n2, E_VARS);
	for (prev = NULL; n1; n1 = n1->n_next)
		if (innl(n2, n1->n_name)) {
			nl = makenl(n1->n_name);
			nl->n_next = prev;
			prev = nl;
		}
	return(prev);
}

/*
 * Make a sub command for lists of variables, commands, etc.
 */
struct subcmd *
makesubcmd(int type)
{
	struct subcmd *sc;

	sc = ALLOC(subcmd);
	sc->sc_type = type;
	sc->sc_args = NULL;
	sc->sc_next = NULL;
	sc->sc_name = NULL;

	return(sc);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			%{
2			/* $OpenBSD: gram.y,v 1.12 2015/01/20 09:00:16 guenther Exp $ */
3
4			/*
5			* Copyright (c) 1993 Michael A. Cooper
6			* Copyright (c) 1993 Regents of the University of California.
7			* All rights reserved.
8			*
9			* Redistribution and use in source and binary forms, with or without
10			* modification, are permitted provided that the following conditions
11			* are met:
12			* 1. Redistributions of source code must retain the above copyright
13			* notice, this list of conditions and the following disclaimer.
14			* 2. Redistributions in binary form must reproduce the above copyright
15			* notice, this list of conditions and the following disclaimer in the
16			* documentation and/or other materials provided with the distribution.
17			* 3. Neither the name of the University nor the names of its contributors
18			* may be used to endorse or promote products derived from this software
19			* without specific prior written permission.
20			*
21			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31			* SUCH DAMAGE.
32			*/
33
34			#include "client.h"
35
36			static struct namelist addnl(struct namelist , struct namelist *);
37			static struct namelist subnl(struct namelist , struct namelist *);
38			static struct namelist andnl(struct namelist , struct namelist *);
39			static int innl(struct namelist nl, char p);
40
41			struct cmd *cmds = NULL;
42			struct cmd *last_cmd;
43			struct namelist *last_n;
44			struct subcmd *last_sc;
45			int parendepth = 0;
46
47			%}
48
49			%term ARROW 1
50			%term COLON 2
51			%term DCOLON 3
52			%term NAME 4
53			%term STRING 5
54			%term INSTALL 6
55			%term NOTIFY 7
56			%term EXCEPT 8
57			%term PATTERN 9
58			%term SPECIAL 10
59			%term CMDSPECIAL 11
60			%term OPTION 12
61
62			%union {
63			opt_t optval;
64			char *string;
65			struct subcmd *subcmd;
66			struct namelist *namel;
67			}
68
69			%type <optval> OPTION, options
70			%type <string> NAME, STRING
71			%type <subcmd> INSTALL, NOTIFY, EXCEPT, PATTERN, SPECIAL, CMDSPECIAL, cmdlist, cmd
72			%type <namel> namelist, names, opt_namelist nlist
73
74			%%
75
76			file: /* VOID */
77			\| file command
78			;
79
80			command: NAME '=' namelist = {
81			(void) lookup($1, INSERT, $3);
82			}
83			\| namelist ARROW namelist cmdlist = {
84			insert((char *)NULL, $1, $3, $4);
85			}
86			\| NAME COLON namelist ARROW namelist cmdlist = {
87			insert($1, $3, $5, $6);
88			}
89			\| namelist DCOLON NAME cmdlist = {
90			append((char *)NULL, $1, $3, $4);
91			}
92			\| NAME COLON namelist DCOLON NAME cmdlist = {
93			append($1, $3, $5, $6);
94			}
95			\| error
96			;
97
98			namelist: nlist {
99			$$ = $1;
100			}
101			\| nlist '-' nlist {
102			$$ = subnl($1, $3);
103			}
104			\| nlist '+' nlist {
105			$$ = addnl($1, $3);
106			}
107			\| nlist '&' nlist {
108			$$ = andnl($1, $3);
109			}
110			;
111
112			nlist: NAME = {
113			$$ = makenl($1);
114			}
115			\| '(' names ')' = {
116			$$ = $2;
117			}
118			;
119
120			names: /* VOID */ {
121			$$ = last_n = NULL;
122			}
123			\| names NAME = {
124			if (last_n == NULL)
125			$$ = last_n = makenl($2);
126			else {
127			last_n->n_next = makenl($2);
128			last_n = last_n->n_next;
129			$$ = $1;
130			}
131			}
132			;
133
134			cmdlist: /* VOID */ {
135			$$ = last_sc = NULL;
136			}
137			\| cmdlist cmd = {
138			if (last_sc == NULL)
139			$$ = last_sc = $2;
140			else {
141			last_sc->sc_next = $2;
142			last_sc = $2;
143			$$ = $1;
144			}
145			}
146			;
147
148			cmd: INSTALL options opt_namelist ';' = {
149			struct namelist *nl;
150
151			$1->sc_options = $2 \| options;
152			if ($3 != NULL) {
153			nl = expand($3, E_VARS);
154			if (nl) {
155			if (nl->n_next != NULL)
156			yyerror("only one name allowed\n");
157			$1->sc_name = nl->n_name;
158			free(nl);
159			} else
160			$1->sc_name = NULL;
161			}
162			$$ = $1;
163			}
164			\| NOTIFY namelist ';' = {
165			if ($2 != NULL)
166			$1->sc_args = expand($2, E_VARS);
167			$$ = $1;
168			}
169			\| EXCEPT namelist ';' = {
170			if ($2 != NULL)
171			$1->sc_args = expand($2, E_ALL);
172			$$ = $1;
173			}
174			\| PATTERN namelist ';' = {
175			struct namelist *nl;
176			char ebuf[BUFSIZ];
177			regex_t reg;
178			int ecode;
179
180			for (nl = $2; nl != NULL; nl = nl->n_next) {
181			/* check for a valid regex */
182			ecode = regcomp(&reg, nl->n_name, REG_NOSUB);
183			if (ecode) {
184			regerror(ecode, &reg, ebuf,
185			sizeof(ebuf));
186			yyerror(ebuf);
187			}
188			regfree(&reg);
189			}
190			$1->sc_args = expand($2, E_VARS);
191			$$ = $1;
192			}
193			\| SPECIAL opt_namelist STRING ';' = {
194			if ($2 != NULL)
195			$1->sc_args = expand($2, E_ALL);
196			$1->sc_name = $3;
197			$$ = $1;
198			}
199			\| CMDSPECIAL opt_namelist STRING ';' = {
200			if ($2 != NULL)
201			$1->sc_args = expand($2, E_ALL);
202			$1->sc_name = $3;
203			$$ = $1;
204			}
205			;
206
207			options: /* VOID */ = {
208			$$ = 0;
209			}
210			\| options OPTION = {
211			$$ \|= $2;
212			}
213			;
214
215			opt_namelist: /* VOID */ = {
216			$$ = NULL;
217			}
218			\| namelist = {
219			$$ = $1;
220			}
221			;
222
223			%%
224
225			int yylineno = 1;
226			extern FILE *fin;
227
228			int
229			yylex(void)
230			{
231			static char yytext[INMAX];
232			int c;
233			char cp1, cp2;
234			static char quotechars[] = "[]{}*?$";
235
236			again:
237			switch (c = getc(fin)) {
238			case EOF: /* end of file */
239			return(0);
240
241			case '#': /* start of comment */
242			while ((c = getc(fin)) != EOF && c != '\n')
243			;
244			if (c == EOF)
245			return(0);
246			case '\n':
247			yylineno++;
248			case ' ':
249			case '\t': /* skip blanks */
250			goto again;
251
252			case '=': /* EQUAL */
253			case ';': /* SM */
254			case '+':
255			case '&':
256			return(c);
257
258			case '(': /* LP */
259			++parendepth;
260			return(c);
261
262			case ')': /* RP */
263			--parendepth;
264			return(c);
265
266			case '-': /* -> */
267			if ((c = getc(fin)) == '>')
268			return(ARROW);
269			(void) ungetc(c, fin);
270			c = '-';
271			break;
272
273			case '"': /* STRING */
274			cp1 = yytext;
275			cp2 = &yytext[INMAX - 1];
276			for (;;) {
277			if (cp1 >= cp2) {
278			yyerror("command string too long\n");
279			break;
280			}
281			c = getc(fin);
282			if (c == EOF \|\| c == '"')
283			break;
284			if (c == '\\') {
285			if ((c = getc(fin)) == EOF) {
286			*cp1++ = '\\';
287			break;
288			}
289			}
290			if (c == '\n') {
291			yylineno++;
292			c = ' '; /* can't send '\n' */
293			}
294			*cp1++ = c;
295			}
296			if (c != '"')
297			yyerror("missing closing '\"'\n");
298			*cp1 = '\0';
299			yylval.string = xstrdup(yytext);
300			return(STRING);
301
302			case ':': /* : or :: */
303			if ((c = getc(fin)) == ':')
304			return(DCOLON);
305			(void) ungetc(c, fin);
306			return(COLON);
307			}
308			cp1 = yytext;
309			cp2 = &yytext[INMAX - 1];
310			for (;;) {
311			if (cp1 >= cp2) {
312			yyerror("input line too long\n");
313			break;
314			}
315			if (c == '\\') {
316			if ((c = getc(fin)) != EOF) {
317			if (any(c, quotechars))
318			*cp1++ = QUOTECHAR;
319			} else {
320			*cp1++ = '\\';
321			break;
322			}
323			}
324			*cp1++ = c;
325			c = getc(fin);
326			if (c == EOF \|\| any(c, " \"'\t()=;:\n")) {
327			(void) ungetc(c, fin);
328			break;
329			}
330			}
331			*cp1 = '\0';
332			if (yytext[0] == '-' && yytext[1] == CNULL)
333			return '-';
334			if (yytext[0] == '-' && parendepth <= 0) {
335			opt_t opt = 0;
336			static char ebuf[BUFSIZ];
337
338			switch (yytext[1]) {
339			case 'o':
340			if (parsedistopts(&yytext[2], &opt, TRUE)) {
341			(void) snprintf(ebuf, sizeof(ebuf),
342			"Bad distfile options \"%s\".",
343			&yytext[2]);
344			yyerror(ebuf);
345			}
346			break;
347
348			/*
349			* These options are obsoleted by -o.
350			*/
351			case 'b': opt = DO_COMPARE; break;
352			case 'R': opt = DO_REMOVE; break;
353			case 'v': opt = DO_VERIFY; break;
354			case 'w': opt = DO_WHOLE; break;
355			case 'y': opt = DO_YOUNGER; break;
356			case 'h': opt = DO_FOLLOW; break;
357			case 'i': opt = DO_IGNLNKS; break;
358			case 'q': opt = DO_QUIET; break;
359			case 'x': opt = DO_NOEXEC; break;
360			case 'N': opt = DO_CHKNFS; break;
361			case 'O': opt = DO_CHKREADONLY; break;
362			case 's': opt = DO_SAVETARGETS; break;
363			case 'r': opt = DO_NODESCEND; break;
364
365			default:
366			(void) snprintf(ebuf, sizeof(ebuf),
367			"Unknown option \"%s\".", yytext);
368			yyerror(ebuf);
369			}
370
371			yylval.optval = opt;
372			return(OPTION);
373			}
374			if (!strcmp(yytext, "install"))
375			c = INSTALL;
376			else if (!strcmp(yytext, "notify"))
377			c = NOTIFY;
378			else if (!strcmp(yytext, "except"))
379			c = EXCEPT;
380			else if (!strcmp(yytext, "except_pat"))
381			c = PATTERN;
382			else if (!strcmp(yytext, "special"))
383			c = SPECIAL;
384			else if (!strcmp(yytext, "cmdspecial"))
385			c = CMDSPECIAL;
386			else {
387			yylval.string = xstrdup(yytext);
388			return(NAME);
389			}
390			yylval.subcmd = makesubcmd(c);
391			return(c);
392			}
393
394			/*
395			* XXX We should use strchr(), but most versions can't handle
396			* some of the characters we use.
397			*/
398			int any(int c, char *str)
399			{
400			while (*str)
401			if (c == *str++)
402			return(1);
403			return(0);
404			}
405
406			/*
407			* Insert or append ARROW command to list of hosts to be updated.
408			*/
409			void
410			insert(char label, struct namelist files, struct namelist *hosts,
411			struct subcmd *scmds)
412			{
413			struct cmd c, prev, *nc;
414			struct namelist h, lasth;
415
416			debugmsg(DM_CALL, "insert(%s, %p, %p, %p) start, files = %s",
417			label == NULL ? "(null)" : label,
418			files, hosts, scmds, getnlstr(files));
419
420			files = expand(files, E_VARS\|E_SHELL);
421			hosts = expand(hosts, E_ALL);
422			for (h = hosts; h != NULL; lasth = h, h = h->n_next,
423			free((char *)lasth)) {
424			/*
425			* Search command list for an update to the same host.
426			*/
427			for (prev = NULL, c = cmds; c!=NULL; prev = c, c = c->c_next) {
428			if (strcmp(c->c_name, h->n_name) == 0) {
429			do {
430			prev = c;
431			c = c->c_next;
432			} while (c != NULL &&
433			strcmp(c->c_name, h->n_name) == 0);
434			break;
435			}
436			}
437			/*
438			* Insert new command to update host.
439			*/
440			nc = ALLOC(cmd);
441			nc->c_type = ARROW;
442			nc->c_name = h->n_name;
443			nc->c_label = label;
444			nc->c_files = files;
445			nc->c_cmds = scmds;
446			nc->c_flags = 0;
447			nc->c_next = c;
448			if (prev == NULL)
449			cmds = nc;
450			else
451			prev->c_next = nc;
452			/* update last_cmd if appending nc to cmds */
453			if (c == NULL)
454			last_cmd = nc;
455			}
456			}
457
458			/*
459			* Append DCOLON command to the end of the command list since these are always
460			* executed in the order they appear in the distfile.
461			*/
462			void
463			append(char label, struct namelist files, char stamp, struct subcmd scmds)
464			{
465			struct cmd *c;
466
467			c = ALLOC(cmd);
468			c->c_type = DCOLON;
469			c->c_name = stamp;
470			c->c_label = label;
471			c->c_files = expand(files, E_ALL);
472			c->c_cmds = scmds;
473			c->c_next = NULL;
474			if (cmds == NULL)
475			cmds = last_cmd = c;
476			else {
477			last_cmd->c_next = c;
478			last_cmd = c;
479			}
480			}
481
482			/*
483			* Error printing routine in parser.
484			*/
485			void
486			yyerror(char *s)
487			{
488			error("Error in distfile: line %d: %s", yylineno, s);
489			}
490
491			/*
492			* Allocate a namelist structure.
493			*/
494			struct namelist *
495			makenl(char *name)
496			{
497			struct namelist *nl;
498
499			debugmsg(DM_CALL, "makenl(%s)", name == NULL ? "null" : name);
500
501			nl = ALLOC(namelist);
502			nl->n_name = name;
503			nl->n_regex = NULL;
504			nl->n_next = NULL;
505
506			return(nl);
507			}
508
509
510			/*
511			* Is the name p in the namelist nl?
512			*/
513			static int
514			innl(struct namelist nl, char p)
515			{
516			for ( ; nl; nl = nl->n_next)
517			if (!strcmp(p, nl->n_name))
518			return(1);
519			return(0);
520			}
521
522			/*
523			* Join two namelists.
524			*/
525			static struct namelist *
526			addnl(struct namelist n1, struct namelist n2)
527			{
528			struct namelist nl, prev;
529
530			n1 = expand(n1, E_VARS);
531			n2 = expand(n2, E_VARS);
532			for (prev = NULL, nl = NULL; n1; n1 = n1->n_next, prev = nl) {
533			nl = makenl(n1->n_name);
534			nl->n_next = prev;
535			}
536			for (; n2; n2 = n2->n_next)
537			if (!innl(nl, n2->n_name)) {
538			nl = makenl(n2->n_name);
539			nl->n_next = prev;
540			prev = nl;
541			}
542			return(prev);
543			}
544
545			/*
546			* Copy n1 except for elements that are in n2.
547			*/
548			static struct namelist *
549			subnl(struct namelist n1, struct namelist n2)
550			{
551			struct namelist nl, prev;
552
553			n1 = expand(n1, E_VARS);
554			n2 = expand(n2, E_VARS);
555			for (prev = NULL; n1; n1 = n1->n_next)
556			if (!innl(n2, n1->n_name)) {
557			nl = makenl(n1->n_name);
558			nl->n_next = prev;
559			prev = nl;
560			}
561			return(prev);
562			}
563
564			/*
565			* Copy all items of n1 that are also in n2.
566			*/
567			static struct namelist *
568			andnl(struct namelist n1, struct namelist n2)
569			{
570			struct namelist nl, prev;
571
572			n1 = expand(n1, E_VARS);
573			n2 = expand(n2, E_VARS);
574			for (prev = NULL; n1; n1 = n1->n_next)
575			if (innl(n2, n1->n_name)) {
576			nl = makenl(n1->n_name);
577			nl->n_next = prev;
578			prev = nl;
579			}
580			return(prev);
581			}
582
583			/*
584			* Make a sub command for lists of variables, commands, etc.
585			*/
586			struct subcmd *
587			makesubcmd(int type)
588			{
589			struct subcmd *sc;
590
591			sc = ALLOC(subcmd);
592			sc->sc_type = type;
593			sc->sc_args = NULL;
594			sc->sc_next = NULL;
595			sc->sc_name = NULL;
596
597			return(sc);
598			}