#include <stdlib.h>

#include <string.h>

#define YYBYACC 1

#define YYMAJOR 1

#define YYMINOR 9

#define YYLEX yylex()

#define YYEMPTY -1

#define yyclearin (yychar=(YYEMPTY))

#define yyerrok (yyerrflag=0)

#define YYRECOVERING() (yyerrflag!=0)

#define YYPREFIX "yy"

#line 2 "gram.y"

/*	$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;

#line 62 "gram.y"

#ifndef YYSTYPE_DEFINED

#define YYSTYPE_DEFINED

typedef union {

	opt_t 			optval;

	char 		       *string;

	struct subcmd 	       *subcmd;

	struct namelist        *namel;

} YYSTYPE;

#endif /* YYSTYPE_DEFINED */

#line 69 "gram.c"

#define ARROW 1

#define COLON 2

#define DCOLON 3

#define NAME 4

#define STRING 5

#define INSTALL 6

#define NOTIFY 7

#define EXCEPT 8

#define PATTERN 9

#define SPECIAL 10

#define CMDSPECIAL 11

#define OPTION 12

const short yylhs[] =

    4,    4,    7,    7,    5,    5,    2,    2,    3,    3,

};

const short yylen[] =

    3,    3,    1,    3,    0,    2,    0,    2,    4,    3,

};

const short yydefred[] =

    0,    8,    0,   15,    0,    0,    2,    0,    0,    0,

    0,    0,    0,    0,    0,   13,    0,    3,   16,   14,

   17,   17,   10,   11,   12,    0,    0,    0,    0,   17,

    0,    0,    0,    0,   28,    0,    0,   26,    0,   20,

};

const short yydgoto[] =

};

   -4,    0,   19,    0,   70,  -15,    0,   23,   23,   -1,

    0,    0,    0,    0,    0,   23,   29,   37,   37,    0,

    0,    0,   23,   23,   23,   23,   23,    0,   37,   37,

    0,    0,    6,   24,    0,    0,    0,};

    0,    0,   21,    0,    0,    1,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,   13,   14,    0,

    0,    0,    0,    0,    0,   67,   67,    0,   15,   16,

    0,    0,    0,    0,    0,    0,    0,};

};

    9,    9,   19,    9,    9,    9,    9,    9,    9,    9,

    9,    9,    4,    6,    5,    7,    4,    6,    5,    7,

   47,   22,   31,   48,   49,    4,   39,   40,   51,   20,

    9,    5,   32,   33,   34,   35,   36,   37,   17,   18,

   55,    4,    4,   13,   56,   13,   30,   23,   24,   25,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

};

    0,    1,    4,    3,    4,    5,    6,    7,    8,    9,

    2,    1,   38,    3,   59,    4,    4,   43,   22,   45,

    1,    5,    3,   33,   34,   35,    1,   -1,    3,   61,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,

};

	{

"end-of-file","ARROW","COLON","DCOLON","NAME","STRING","INSTALL","NOTIFY",

};

	{"$accept : file",

"file : file command",

"command : NAME '=' namelist",

"command : NAME COLON namelist ARROW namelist cmdlist",

"command : error",

"namelist : nlist '-' nlist",

"namelist : nlist '+' nlist",

"nlist : NAME",

"names : names NAME",

"cmdlist : cmdlist cmd",

"cmd : INSTALL options opt_namelist ';'",

"cmd : NOTIFY namelist ';'",

"cmd : EXCEPT namelist ';'",

"cmd : PATTERN namelist ';'",

"cmd : SPECIAL opt_namelist STRING ';'",

"cmd : CMDSPECIAL opt_namelist STRING ';'",

"options :",

"options : options OPTION",

"opt_namelist :",

"opt_namelist : namelist",

};

#endif

#ifdef YYSTACKSIZE

#undef YYMAXDEPTH

#define YYMAXDEPTH YYSTACKSIZE

#else

#ifdef YYMAXDEPTH

#define YYSTACKSIZE YYMAXDEPTH

#else

#define YYSTACKSIZE 10000

#define YYMAXDEPTH 10000

#endif

#endif

#define YYINITSTACKSIZE 200

/* LINTUSED */

int yydebug;

int yynerrs;

int yyerrflag;

int yychar;

short *yyssp;

YYSTYPE *yyvsp;

YYSTYPE yyval;

YYSTYPE yylval;

short *yyss;

short *yysslim;

YYSTYPE *yyvs;

unsigned int yystacksize;

int yyparse(void);

#line 224 "gram.y"

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);

}

#line 630 "gram.c"

{

    short *newss;

    if ((newsize = yystacksize) == 0)

        newsize = YYINITSTACKSIZE;

    else if (newsize >= YYMAXDEPTH)

        return -1;

        newsize = YYMAXDEPTH;

#else

        goto bail;

        goto bail;

      (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */

            free(yyss);

    if (yyvs)

            free(yyvs);

    yyss = yyssp = NULL;

    yyvs = yyvsp = NULL;

    yystacksize = 0;

    return -1;

}

#define YYABORT goto yyabort

#define YYREJECT goto yyabort

#define YYACCEPT goto yyaccept

#define YYERROR goto yyerrlab

int

yyparse(void)

{

    int yym, yyn, yystate;

#if YYDEBUG

    const char *yys;

    {

        if (yyn >= '0' && yyn <= '9')

    }

    yynerrs = 0;

    yyerrflag = 0;

    if (yyss == NULL && yygrowstack()) goto yyoverflow;

    yyvsp = yyvs;

    *yyssp = yystate = 0;

yyloop:

    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;

    if (yychar < 0)

    {

        if ((yychar = yylex()) < 0) yychar = 0;

#if YYDEBUG

        if (yydebug)

        {

            if (!yys) yys = "illegal-symbol";

            printf("%sdebug: state %d, reading %d (%s)\n",

                    YYPREFIX, yystate, yychar, yys);

        }

#endif

    }

            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

    {

#if YYDEBUG

        {

        }

        *++yyssp = yystate = yytable[yyn];

        if (yyerrflag > 0)  --yyerrflag;

    }

    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&

            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

    {

        goto yyreduce;

    }

    if (yyerrflag) goto yyinrecovery;

#if defined(__GNUC__)

#endif

    yyerror("syntax error");

#endif

yyinrecovery:

    if (yyerrflag < 3)

    {

        yyerrflag = 3;

        for (;;)

        {

                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)

            {

#if YYDEBUG

#endif

                if (yyssp >= yysslim && yygrowstack())

                {

                    goto yyoverflow;

                }

                *++yyssp = yystate = yytable[yyn];

                *++yyvsp = yylval;

                goto yyloop;

            }

            else

            {

#if YYDEBUG

                if (yydebug)

                    printf("%sdebug: error recovery discarding state %d\n",

                            YYPREFIX, *yyssp);

#endif

                --yyssp;

                --yyvsp;

            }

        }

    }

    else

    {

        if (yychar == 0) goto yyabort;

#if YYDEBUG

        if (yydebug)

        {

            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];

            if (!yys) yys = "illegal-symbol";

            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",

                    YYPREFIX, yystate, yychar, yys);

        }

#endif

        yychar = (-1);

    }

#if YYDEBUG

                YYPREFIX, yystate, yyn, yyrule[yyn]);

#endif

    yym = yylen[yyn];

    if (yym)

        yyval = yyvsp[1-yym];

    else

        memset(&yyval, 0, sizeof yyval);

    switch (yyn)

    {

case 3:

#line 80 "gram.y"

 {

			(void) lookup(yyvsp[-2].string, INSERT, yyvsp[0].namel);

		}

break;

case 4:

#line 83 "gram.y"

 {

			insert((char *)NULL, yyvsp[-3].namel, yyvsp[-1].namel, yyvsp[0].subcmd);

		}

break;

case 5:

#line 86 "gram.y"

 {

			insert(yyvsp[-5].string, yyvsp[-3].namel, yyvsp[-1].namel, yyvsp[0].subcmd);

		}

break;

case 6:

#line 89 "gram.y"

 {

			append((char *)NULL, yyvsp[-3].namel, yyvsp[-1].string, yyvsp[0].subcmd);

		}

break;

case 7:

#line 92 "gram.y"

 {

			append(yyvsp[-5].string, yyvsp[-3].namel, yyvsp[-1].string, yyvsp[0].subcmd);

		}

break;

case 9:

#line 98 "gram.y"

{

			yyval.namel = yyvsp[0].namel;

		}

break;

case 10:

#line 101 "gram.y"

{

			yyval.namel = subnl(yyvsp[-2].namel, yyvsp[0].namel);

		}

break;

case 11:

#line 104 "gram.y"

{

			yyval.namel = addnl(yyvsp[-2].namel, yyvsp[0].namel);

		}

break;

case 12:

#line 107 "gram.y"

{

			yyval.namel = andnl(yyvsp[-2].namel, yyvsp[0].namel);

		}

break;

case 13:

#line 112 "gram.y"

 {

			yyval.namel = makenl(yyvsp[0].string);

		}

break;

case 14:

#line 115 "gram.y"

 {

			yyval.namel = yyvsp[-1].namel;

		}

break;

case 15:

#line 120 "gram.y"

{

			yyval.namel = last_n = NULL;

		}

break;

case 16:

#line 123 "gram.y"

 {

			if (last_n == NULL)

				yyval.namel = last_n = makenl(yyvsp[0].string);

			else {

				last_n->n_next = makenl(yyvsp[0].string);

				last_n = last_n->n_next;

				yyval.namel = yyvsp[-1].namel;

			}

		}

break;

case 17:

#line 134 "gram.y"

{

			yyval.subcmd = last_sc = NULL;

		}

break;

case 18:

#line 137 "gram.y"

 {

			if (last_sc == NULL)

				yyval.subcmd = last_sc = yyvsp[0].subcmd;

			else {

				last_sc->sc_next = yyvsp[0].subcmd;

				last_sc = yyvsp[0].subcmd;

				yyval.subcmd = yyvsp[-1].subcmd;

			}

		}

break;

case 19:

#line 148 "gram.y"

 {

			struct namelist *nl;

			yyvsp[-3].subcmd->sc_options = yyvsp[-2].optval | options;

			if (yyvsp[-1].namel != NULL) {

				nl = expand(yyvsp[-1].namel, E_VARS);

				if (nl) {

					if (nl->n_next != NULL)

					    yyerror("only one name allowed\n");

					yyvsp[-3].subcmd->sc_name = nl->n_name;

					free(nl);

				} else

					yyvsp[-3].subcmd->sc_name = NULL;

			}

			yyval.subcmd = yyvsp[-3].subcmd;

		}

break;

case 20:

#line 164 "gram.y"

 {

			if (yyvsp[-1].namel != NULL)

				yyvsp[-2].subcmd->sc_args = expand(yyvsp[-1].namel, E_VARS);

			yyval.subcmd = yyvsp[-2].subcmd;

		}

break;

case 21:

#line 169 "gram.y"

 {

			if (yyvsp[-1].namel != NULL)

				yyvsp[-2].subcmd->sc_args = expand(yyvsp[-1].namel, E_ALL);

			yyval.subcmd = yyvsp[-2].subcmd;

		}

break;

case 22:

#line 174 "gram.y"

 {

			struct namelist *nl;

			char ebuf[BUFSIZ];

			regex_t reg;

			int ecode;

			for (nl = yyvsp[-1].namel; 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);

			}

			yyvsp[-2].subcmd->sc_args = expand(yyvsp[-1].namel, E_VARS);

			yyval.subcmd = yyvsp[-2].subcmd;

		}

break;

case 23:

#line 193 "gram.y"

 {

			if (yyvsp[-2].namel != NULL)

				yyvsp[-3].subcmd->sc_args = expand(yyvsp[-2].namel, E_ALL);