Adding upstream version 3.3a.upstream/3.3a

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2229 insertions, 0 deletions

diff --git a/cmd-parse.c b/cmd-parse.c
new file mode 100644
index 0000000..309c6fe
--- /dev/null
+++ b/cmd-parse.c
@@ -0,0 +1,2229 @@
+#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 20 "cmd-parse.y"
+
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wchar.h>
+
+#include "tmux.h"
+
+static int			 yylex(void);
+static int			 yyparse(void);
+static int printflike(1,2)	 yyerror(const char *, ...);
+
+static char			*yylex_token(int);
+static char			*yylex_format(void);
+
+struct cmd_parse_scope {
+	int				 flag;
+	TAILQ_ENTRY (cmd_parse_scope)	 entry;
+};
+
+enum cmd_parse_argument_type {
+	CMD_PARSE_STRING,
+	CMD_PARSE_COMMANDS,
+	CMD_PARSE_PARSED_COMMANDS
+};
+
+struct cmd_parse_argument {
+	enum cmd_parse_argument_type	 type;
+	char				*string;
+	struct cmd_parse_commands	*commands;
+	struct cmd_list			*cmdlist;
+
+	TAILQ_ENTRY(cmd_parse_argument)	 entry;
+};
+TAILQ_HEAD(cmd_parse_arguments, cmd_parse_argument);
+
+struct cmd_parse_command {
+	u_int				 line;
+	struct cmd_parse_arguments	 arguments;
+
+	TAILQ_ENTRY(cmd_parse_command)	 entry;
+};
+TAILQ_HEAD(cmd_parse_commands, cmd_parse_command);
+
+struct cmd_parse_state {
+	FILE				*f;
+
+	const char			*buf;
+	size_t				 len;
+	size_t				 off;
+
+	int				 condition;
+	int				 eol;
+	int				 eof;
+	struct cmd_parse_input		*input;
+	u_int				 escapes;
+
+	char				*error;
+	struct cmd_parse_commands	*commands;
+
+	struct cmd_parse_scope		*scope;
+	TAILQ_HEAD(, cmd_parse_scope)	 stack;
+};
+static struct cmd_parse_state parse_state;
+
+static char	*cmd_parse_get_error(const char *, u_int, const char *);
+static void	 cmd_parse_free_command(struct cmd_parse_command *);
+static struct cmd_parse_commands *cmd_parse_new_commands(void);
+static void	 cmd_parse_free_commands(struct cmd_parse_commands *);
+static void	 cmd_parse_build_commands(struct cmd_parse_commands *,
+		     struct cmd_parse_input *, struct cmd_parse_result *);
+static void	 cmd_parse_print_commands(struct cmd_parse_input *,
+		     struct cmd_list *);
+
+#line 101 "cmd-parse.y"
+#ifndef YYSTYPE_DEFINED
+#define YYSTYPE_DEFINED
+typedef union
+{
+	char					 *token;
+	struct cmd_parse_arguments		 *arguments;
+	struct cmd_parse_argument		 *argument;
+	int					  flag;
+	struct {
+		int				  flag;
+		struct cmd_parse_commands	 *commands;
+	} elif;
+	struct cmd_parse_commands		 *commands;
+	struct cmd_parse_command		 *command;
+} YYSTYPE;
+#endif /* YYSTYPE_DEFINED */
+#line 110 "cmd-parse.c"
+#define ERROR 257
+#define HIDDEN 258
+#define IF 259
+#define ELSE 260
+#define ELIF 261
+#define ENDIF 262
+#define FORMAT 263
+#define TOKEN 264
+#define EQUALS 265
+#define YYERRCODE 256
+const short yylhs[] =
+	{                                        -1,
+    0,    0,   10,   10,   11,   11,   11,   11,    2,    2,
+    1,   17,   17,   18,   16,    5,   19,    6,   20,   13,
+   13,   13,   13,    7,    7,   12,   12,   12,   12,   12,
+   15,   15,   15,   14,   14,   14,   14,    8,    8,    3,
+    3,    4,    4,    4,    9,    9,
+};
+const short yylen[] =
+	{                                         2,
+    0,    1,    2,    3,    0,    1,    1,    1,    1,    1,
+    1,    0,    1,    1,    2,    2,    1,    2,    1,    4,
+    7,    5,    8,    3,    4,    1,    2,    3,    3,    1,
+    1,    2,    3,    3,    5,    4,    6,    2,    3,    1,
+    2,    1,    1,    2,    2,    3,
+};
+const short yydefred[] =
+	{                                      0,
+    0,    0,   14,    0,    0,    0,    0,    0,    7,   30,
+   26,    6,    0,    0,   15,    9,   10,   16,   11,    0,
+    0,    0,    0,    3,    0,    0,    0,   17,    0,   19,
+    0,    0,    0,   34,    4,   28,   29,   42,   43,    0,
+   33,    0,    0,    0,    0,   20,   18,    0,    0,   36,
+    0,   44,    0,    0,   41,    0,    0,   22,    0,   39,
+    0,   35,    0,   45,    0,    0,    0,   37,   46,   25,
+    0,   21,   23,
+};
+const short yydgoto[] =
+	{                                       4,
+   18,   19,   41,   42,    5,   31,   44,   32,   52,    6,
+    7,    8,    9,   10,   11,   12,   13,   14,   33,   34,
+};
+const short yysindex[] =
+	{                                   -175,
+ -227, -172,    0,    0,  -10, -175,   46,   10,    0,    0,
+    0,    0, -205,    0,    0,    0,    0,    0,    0, -175,
+ -238,  -56,   53,    0, -238, -118, -228,    0, -172,    0,
+ -238, -234, -238,    0,    0,    0,    0,    0,    0, -175,
+    0, -118,   63, -234,   66,    0,    0,  -52, -238,    0,
+  -55,    0, -175,    3,    0, -175,   68,    0, -175,    0,
+  -55,    0,    4,    0, -208, -175, -219,    0,    0,    0,
+ -219,    0,    0,};
+const short yyrindex[] =
+	{                                      1,
+    0,    0,    0,    0, -184,    2,    0,    5,    0,    0,
+    0,    0,    0,   -4,    0,    0,    0,    0,    0,    6,
+ -184,    0,    0,    0,    7,   12,    6,    0,    0,    0,
+ -184,    0, -184,    0,    0,    0,    0,    0,    0,   -2,
+    0,   15,    0,    0,    0,    0,    0, -215, -184,    0,
+    0,    0,   -2,    0,    0,    6,    0,    0,    6,    0,
+    0,    0,    0,    0,   -1,    6,    6,    0,    0,    0,
+    6,    0,    0,};
+const short yygindex[] =
+	{                                      0,
+   57,    0,   40,    0,   39,  -17,   28,   47,    0,    9,
+   14,   56,    0,   69,   71,    0,    0,    0,   -8,   -9,
+};
+#define YYTABLESIZE 277
+const short yytable[] =
+	{                                      20,
+    1,    2,   25,   25,   40,   31,   25,    5,    5,   43,
+    5,    5,   24,   35,    8,    5,   27,   46,   45,   23,
+    2,   32,   50,   49,   40,   28,    3,   30,   27,    1,
+    2,   28,   29,   30,   58,   57,    3,   15,    1,    2,
+   23,   62,   30,   21,   38,    3,   38,   43,   53,    1,
+    2,   68,   29,   54,   31,   24,    3,   72,   26,   21,
+   22,   73,   35,   21,   65,   27,   63,   67,   25,   21,
+   32,   21,   56,   40,   71,   59,   22,   66,   23,   12,
+   23,   55,    1,    2,   23,   47,   48,   21,   51,    3,
+   16,   17,   70,   36,   60,   37,    0,    0,    0,    0,
+    0,    0,    0,    0,   61,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   31,    0,    5,    0,    0,    0,    0,   64,   69,    8,
+    0,   27,    0,    0,    0,    0,   32,    0,    0,   40,
+    0,    0,    0,    0,    0,   38,   39,    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,   28,   29,   30,   30,    0,   29,    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,    2,    0,
+    0,    0,    0,    0,    3,   31,   31,   31,   24,   13,
+   24,   12,   12,    0,   12,   12,   27,   27,   27,   12,
+   12,   32,   32,   32,   40,   40,   40,
+};
+const short yycheck[] =
+	{                                      10,
+    0,    0,   59,   59,  123,   10,   59,   10,   10,   27,
+   10,   10,   10,   10,   10,   10,   10,   27,   27,    6,
+  259,   10,   32,   32,   10,  260,  265,  262,   20,  258,
+  259,  260,  261,  262,   44,   44,  265,  265,  258,  259,
+   27,   51,  262,    5,  260,  265,  262,   65,   40,  258,
+  259,   61,  261,   40,   59,   10,  265,   67,  264,   21,
+    5,   71,   10,   25,   56,   59,   53,   59,   59,   31,
+   59,   33,   10,   59,   66,   10,   21,   10,   65,  264,
+   67,   42,  258,  259,   71,   29,   31,   49,   33,  265,
+  263,  264,   65,   25,   48,   25,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   49,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  125,   -1,  125,   -1,   -1,   -1,   -1,  125,  125,  125,
+   -1,  125,   -1,   -1,   -1,   -1,  125,   -1,   -1,  125,
+   -1,   -1,   -1,   -1,   -1,  264,  265,   -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,  260,  261,  262,  262,   -1,  261,   -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,  259,   -1,
+   -1,   -1,   -1,   -1,  265,  260,  261,  262,  260,  264,
+  262,  264,  264,   -1,  264,  264,  260,  261,  262,  264,
+  264,  260,  261,  262,  260,  261,  262,
+};
+#define YYFINAL 4
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 265
+#if YYDEBUG
+const char * const yyname[] =
+	{
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",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,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,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,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,"ERROR",
+"HIDDEN","IF","ELSE","ELIF","ENDIF","FORMAT","TOKEN","EQUALS",
+};
+const char * const yyrule[] =
+	{"$accept : lines",
+"lines :",
+"lines : statements",
+"statements : statement '\\n'",
+"statements : statements statement '\\n'",
+"statement :",
+"statement : hidden_assignment",
+"statement : condition",
+"statement : commands",
+"format : FORMAT",
+"format : TOKEN",
+"expanded : format",
+"optional_assignment :",
+"optional_assignment : assignment",
+"assignment : EQUALS",
+"hidden_assignment : HIDDEN EQUALS",
+"if_open : IF expanded",
+"if_else : ELSE",
+"if_elif : ELIF expanded",
+"if_close : ENDIF",
+"condition : if_open '\\n' statements if_close",
+"condition : if_open '\\n' statements if_else '\\n' statements if_close",
+"condition : if_open '\\n' statements elif if_close",
+"condition : if_open '\\n' statements elif if_else '\\n' statements if_close",
+"elif : if_elif '\\n' statements",
+"elif : if_elif '\\n' statements elif",
+"commands : command",
+"commands : commands ';'",
+"commands : commands ';' condition1",
+"commands : commands ';' command",
+"commands : condition1",
+"command : assignment",
+"command : optional_assignment TOKEN",
+"command : optional_assignment TOKEN arguments",
+"condition1 : if_open commands if_close",
+"condition1 : if_open commands if_else commands if_close",
+"condition1 : if_open commands elif1 if_close",
+"condition1 : if_open commands elif1 if_else commands if_close",
+"elif1 : if_elif commands",
+"elif1 : if_elif commands elif1",
+"arguments : argument",
+"arguments : argument arguments",
+"argument : TOKEN",
+"argument : EQUALS",
+"argument : '{' argument_statements",
+"argument_statements : statement '}'",
+"argument_statements : statements statement '}'",
+};
+#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 575 "cmd-parse.y"
+
+static char *
+cmd_parse_get_error(const char *file, u_int line, const char *error)
+{
+	char	*s;
+
+	if (file == NULL)
+		s = xstrdup(error);
+	else
+		xasprintf(&s, "%s:%u: %s", file, line, error);
+	return (s);
+}
+
+static void
+cmd_parse_print_commands(struct cmd_parse_input *pi, struct cmd_list *cmdlist)
+{
+	char	*s;
+
+	if (pi->item == NULL || (~pi->flags & CMD_PARSE_VERBOSE))
+		return;
+	s = cmd_list_print(cmdlist, 0);
+	if (pi->file != NULL)
+		cmdq_print(pi->item, "%s:%u: %s", pi->file, pi->line, s);
+	else
+		cmdq_print(pi->item, "%u: %s", pi->line, s);
+	free(s);
+}
+
+static void
+cmd_parse_free_argument(struct cmd_parse_argument *arg)
+{
+	switch (arg->type) {
+	case CMD_PARSE_STRING:
+		free(arg->string);
+		break;
+	case CMD_PARSE_COMMANDS:
+		cmd_parse_free_commands(arg->commands);
+		break;
+	case CMD_PARSE_PARSED_COMMANDS:
+		cmd_list_free(arg->cmdlist);
+		break;
+	}
+	free(arg);
+}
+
+static void
+cmd_parse_free_arguments(struct cmd_parse_arguments *args)
+{
+	struct cmd_parse_argument	*arg, *arg1;
+
+	TAILQ_FOREACH_SAFE(arg, args, entry, arg1) {
+		TAILQ_REMOVE(args, arg, entry);
+		cmd_parse_free_argument(arg);
+	}
+}
+
+static void
+cmd_parse_free_command(struct cmd_parse_command *cmd)
+{
+	cmd_parse_free_arguments(&cmd->arguments);
+	free(cmd);
+}
+
+static struct cmd_parse_commands *
+cmd_parse_new_commands(void)
+{
+	struct cmd_parse_commands	*cmds;
+
+	cmds = xmalloc(sizeof *cmds);
+	TAILQ_INIT(cmds);
+	return (cmds);
+}
+
+static void
+cmd_parse_free_commands(struct cmd_parse_commands *cmds)
+{
+	struct cmd_parse_command	*cmd, *cmd1;
+
+	TAILQ_FOREACH_SAFE(cmd, cmds, entry, cmd1) {
+		TAILQ_REMOVE(cmds, cmd, entry);
+		cmd_parse_free_command(cmd);
+	}
+	free(cmds);
+}
+
+static struct cmd_parse_commands *
+cmd_parse_run_parser(char **cause)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+	struct cmd_parse_scope	*scope, *scope1;
+	int			 retval;
+
+	ps->commands = NULL;
+	TAILQ_INIT(&ps->stack);
+
+	retval = yyparse();
+	TAILQ_FOREACH_SAFE(scope, &ps->stack, entry, scope1) {
+		TAILQ_REMOVE(&ps->stack, scope, entry);
+		free(scope);
+	}
+	if (retval != 0) {
+		*cause = ps->error;
+		return (NULL);
+	}
+
+	if (ps->commands == NULL)
+		return (cmd_parse_new_commands());
+	return (ps->commands);
+}
+
+static struct cmd_parse_commands *
+cmd_parse_do_file(FILE *f, struct cmd_parse_input *pi, char **cause)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+
+	memset(ps, 0, sizeof *ps);
+	ps->input = pi;
+	ps->f = f;
+	return (cmd_parse_run_parser(cause));
+}
+
+static struct cmd_parse_commands *
+cmd_parse_do_buffer(const char *buf, size_t len, struct cmd_parse_input *pi,
+    char **cause)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+
+	memset(ps, 0, sizeof *ps);
+	ps->input = pi;
+	ps->buf = buf;
+	ps->len = len;
+	return (cmd_parse_run_parser(cause));
+}
+
+static void
+cmd_parse_log_commands(struct cmd_parse_commands *cmds, const char *prefix)
+{
+	struct cmd_parse_command	*cmd;
+	struct cmd_parse_argument	*arg;
+	u_int				 i, j;
+	char				*s;
+
+	i = 0;
+	TAILQ_FOREACH(cmd, cmds, entry) {
+		j = 0;
+		TAILQ_FOREACH(arg, &cmd->arguments, entry) {
+			switch (arg->type) {
+			case CMD_PARSE_STRING:
+				log_debug("%s %u:%u: %s", prefix, i, j,
+				    arg->string);
+				break;
+			case CMD_PARSE_COMMANDS:
+				xasprintf(&s, "%s %u:%u", prefix, i, j);
+				cmd_parse_log_commands(arg->commands, s);
+				free(s);
+				break;
+			case CMD_PARSE_PARSED_COMMANDS:
+				s = cmd_list_print(arg->cmdlist, 0);
+				log_debug("%s %u:%u: %s", prefix, i, j, s);
+				free(s);
+				break;
+			}
+			j++;
+		}
+		i++;
+	}
+}
+
+static int
+cmd_parse_expand_alias(struct cmd_parse_command *cmd,
+    struct cmd_parse_input *pi, struct cmd_parse_result *pr)
+{
+	struct cmd_parse_argument	*arg, *arg1, *first;
+	struct cmd_parse_commands	*cmds;
+	struct cmd_parse_command	*last;
+	char				*alias, *name, *cause;
+
+	if (pi->flags & CMD_PARSE_NOALIAS)
+		return (0);
+	memset(pr, 0, sizeof *pr);
+
+	first = TAILQ_FIRST(&cmd->arguments);
+	if (first == NULL || first->type != CMD_PARSE_STRING) {
+		pr->status = CMD_PARSE_SUCCESS;
+		pr->cmdlist = cmd_list_new();
+		return (1);
+	}
+	name = first->string;
+
+	alias = cmd_get_alias(name);
+	if (alias == NULL)
+		return (0);
+	log_debug("%s: %u alias %s = %s", __func__, pi->line, name, alias);
+
+	cmds = cmd_parse_do_buffer(alias, strlen(alias), pi, &cause);
+	free(alias);
+	if (cmds == NULL) {
+		pr->status = CMD_PARSE_ERROR;
+		pr->error = cause;
+		return (1);
+	}
+
+	last = TAILQ_LAST(cmds, cmd_parse_commands);
+	if (last == NULL) {
+		pr->status = CMD_PARSE_SUCCESS;
+		pr->cmdlist = cmd_list_new();
+		return (1);
+	}
+
+	TAILQ_REMOVE(&cmd->arguments, first, entry);
+	cmd_parse_free_argument(first);
+
+	TAILQ_FOREACH_SAFE(arg, &cmd->arguments, entry, arg1) {
+		TAILQ_REMOVE(&cmd->arguments, arg, entry);
+		TAILQ_INSERT_TAIL(&last->arguments, arg, entry);
+	}
+	cmd_parse_log_commands(cmds, __func__);
+
+	pi->flags |= CMD_PARSE_NOALIAS;
+	cmd_parse_build_commands(cmds, pi, pr);
+	pi->flags &= ~CMD_PARSE_NOALIAS;
+	return (1);
+}
+
+static void
+cmd_parse_build_command(struct cmd_parse_command *cmd,
+    struct cmd_parse_input *pi, struct cmd_parse_result *pr)
+{
+	struct cmd_parse_argument	*arg;
+	struct cmd			*add;
+	char				*cause;
+	struct args_value		*values = NULL;
+	u_int				 count = 0, idx;
+
+	memset(pr, 0, sizeof *pr);
+
+	if (cmd_parse_expand_alias(cmd, pi, pr))
+		return;
+
+	TAILQ_FOREACH(arg, &cmd->arguments, entry) {
+		values = xrecallocarray(values, count, count + 1,
+		    sizeof *values);
+		switch (arg->type) {
+		case CMD_PARSE_STRING:
+			values[count].type = ARGS_STRING;
+			values[count].string = xstrdup(arg->string);
+			break;
+		case CMD_PARSE_COMMANDS:
+			cmd_parse_build_commands(arg->commands, pi, pr);
+			if (pr->status != CMD_PARSE_SUCCESS)
+				goto out;
+			values[count].type = ARGS_COMMANDS;
+			values[count].cmdlist = pr->cmdlist;
+			break;
+		case CMD_PARSE_PARSED_COMMANDS:
+			values[count].type = ARGS_COMMANDS;
+			values[count].cmdlist = arg->cmdlist;
+			values[count].cmdlist->references++;
+			break;
+		}
+		count++;
+	}
+
+	add = cmd_parse(values, count, pi->file, pi->line, &cause);
+	if (add == NULL) {
+		pr->status = CMD_PARSE_ERROR;
+		pr->error = cmd_parse_get_error(pi->file, pi->line, cause);
+		free(cause);
+		goto out;
+	}
+	pr->status = CMD_PARSE_SUCCESS;
+	pr->cmdlist = cmd_list_new();
+	cmd_list_append(pr->cmdlist, add);
+
+out:
+	for (idx = 0; idx < count; idx++)
+		args_free_value(&values[idx]);
+	free(values);
+}
+
+static void
+cmd_parse_build_commands(struct cmd_parse_commands *cmds,
+    struct cmd_parse_input *pi, struct cmd_parse_result *pr)
+{
+	struct cmd_parse_command	*cmd;
+	u_int				 line = UINT_MAX;
+	struct cmd_list			*current = NULL, *result;
+	char				*s;
+
+	memset(pr, 0, sizeof *pr);
+
+	/* Check for an empty list. */
+	if (TAILQ_EMPTY(cmds)) {
+		pr->status = CMD_PARSE_SUCCESS;
+		pr->cmdlist = cmd_list_new();
+		return;
+	}
+	cmd_parse_log_commands(cmds, __func__);
+
+	/*
+	 * Parse each command into a command list. Create a new command list
+	 * for each line (unless the flag is set) so they get a new group (so
+	 * the queue knows which ones to remove if a command fails when
+	 * executed).
+	 */
+	result = cmd_list_new();
+	TAILQ_FOREACH(cmd, cmds, entry) {
+		if (((~pi->flags & CMD_PARSE_ONEGROUP) && cmd->line != line)) {
+			if (current != NULL) {
+				cmd_parse_print_commands(pi, current);
+				cmd_list_move(result, current);
+				cmd_list_free(current);
+			}
+			current = cmd_list_new();
+		}
+		if (current == NULL)
+			current = cmd_list_new();
+		line = pi->line = cmd->line;
+
+		cmd_parse_build_command(cmd, pi, pr);
+		if (pr->status != CMD_PARSE_SUCCESS) {
+			cmd_list_free(result);
+			cmd_list_free(current);
+			return;
+		}
+		cmd_list_append_all(current, pr->cmdlist);
+		cmd_list_free(pr->cmdlist);
+	}
+	if (current != NULL) {
+		cmd_parse_print_commands(pi, current);
+		cmd_list_move(result, current);
+		cmd_list_free(current);
+	}
+
+	s = cmd_list_print(result, 0);
+	log_debug("%s: %s", __func__, s);
+	free(s);
+
+	pr->status = CMD_PARSE_SUCCESS;
+	pr->cmdlist = result;
+}
+
+struct cmd_parse_result *
+cmd_parse_from_file(FILE *f, struct cmd_parse_input *pi)
+{
+	static struct cmd_parse_result	 pr;
+	struct cmd_parse_input		 input;
+	struct cmd_parse_commands	*cmds;
+	char				*cause;
+
+	if (pi == NULL) {
+		memset(&input, 0, sizeof input);
+		pi = &input;
+	}
+	memset(&pr, 0, sizeof pr);
+
+	cmds = cmd_parse_do_file(f, pi, &cause);
+	if (cmds == NULL) {
+		pr.status = CMD_PARSE_ERROR;
+		pr.error = cause;
+		return (&pr);
+	}
+	cmd_parse_build_commands(cmds, pi, &pr);
+	cmd_parse_free_commands(cmds);
+	return (&pr);
+
+}
+
+struct cmd_parse_result *
+cmd_parse_from_string(const char *s, struct cmd_parse_input *pi)
+{
+	struct cmd_parse_input	input;
+
+	if (pi == NULL) {
+		memset(&input, 0, sizeof input);
+		pi = &input;
+	}
+
+	/*
+	 * When parsing a string, put commands in one group even if there are
+	 * multiple lines. This means { a \n b } is identical to "a ; b" when
+	 * given as an argument to another command.
+	 */
+	pi->flags |= CMD_PARSE_ONEGROUP;
+	return (cmd_parse_from_buffer(s, strlen(s), pi));
+}
+
+enum cmd_parse_status
+cmd_parse_and_insert(const char *s, struct cmd_parse_input *pi,
+    struct cmdq_item *after, struct cmdq_state *state, char **error)
+{
+	struct cmd_parse_result	*pr;
+	struct cmdq_item	*item;
+
+	pr = cmd_parse_from_string(s, pi);
+	switch (pr->status) {
+	case CMD_PARSE_ERROR:
+		if (error != NULL)
+			*error = pr->error;
+		else
+			free(pr->error);
+		break;
+	case CMD_PARSE_SUCCESS:
+		item = cmdq_get_command(pr->cmdlist, state);
+		cmdq_insert_after(after, item);
+		cmd_list_free(pr->cmdlist);
+		break;
+	}
+	return (pr->status);
+}
+
+enum cmd_parse_status
+cmd_parse_and_append(const char *s, struct cmd_parse_input *pi,
+    struct client *c, struct cmdq_state *state, char **error)
+{
+	struct cmd_parse_result	*pr;
+	struct cmdq_item	*item;
+
+	pr = cmd_parse_from_string(s, pi);
+	switch (pr->status) {
+	case CMD_PARSE_ERROR:
+		if (error != NULL)
+			*error = pr->error;
+		else
+			free(pr->error);
+		break;
+	case CMD_PARSE_SUCCESS:
+		item = cmdq_get_command(pr->cmdlist, state);
+		cmdq_append(c, item);
+		cmd_list_free(pr->cmdlist);
+		break;
+	}
+	return (pr->status);
+}
+
+struct cmd_parse_result *
+cmd_parse_from_buffer(const void *buf, size_t len, struct cmd_parse_input *pi)
+{
+	static struct cmd_parse_result	 pr;
+	struct cmd_parse_input		 input;
+	struct cmd_parse_commands	*cmds;
+	char				*cause;
+
+	if (pi == NULL) {
+		memset(&input, 0, sizeof input);
+		pi = &input;
+	}
+	memset(&pr, 0, sizeof pr);
+
+	if (len == 0) {
+		pr.status = CMD_PARSE_SUCCESS;
+		pr.cmdlist = cmd_list_new();
+		return (&pr);
+	}
+
+	cmds = cmd_parse_do_buffer(buf, len, pi, &cause);
+	if (cmds == NULL) {
+		pr.status = CMD_PARSE_ERROR;
+		pr.error = cause;
+		return (&pr);
+	}
+	cmd_parse_build_commands(cmds, pi, &pr);
+	cmd_parse_free_commands(cmds);
+	return (&pr);
+}
+
+struct cmd_parse_result *
+cmd_parse_from_arguments(struct args_value *values, u_int count,
+    struct cmd_parse_input *pi)
+{
+	static struct cmd_parse_result	 pr;
+	struct cmd_parse_input		 input;
+	struct cmd_parse_commands	*cmds;
+	struct cmd_parse_command	*cmd;
+	struct cmd_parse_argument	*arg;
+	u_int				 i;
+	char				*copy;
+	size_t				 size;
+	int				 end;
+
+	/*
+	 * The commands are already split up into arguments, so just separate
+	 * into a set of commands by ';'.
+	 */
+
+	if (pi == NULL) {
+		memset(&input, 0, sizeof input);
+		pi = &input;
+	}
+	memset(&pr, 0, sizeof pr);
+
+	cmds = cmd_parse_new_commands();
+
+	cmd = xcalloc(1, sizeof *cmd);
+	cmd->line = pi->line;
+	TAILQ_INIT(&cmd->arguments);
+
+	for (i = 0; i < count; i++) {
+		end = 0;
+		if (values[i].type == ARGS_STRING) {
+			copy = xstrdup(values[i].string);
+			size = strlen(copy);
+			if (size != 0 && copy[size - 1] == ';') {
+				copy[--size] = '\0';
+				if (size > 0 && copy[size - 1] == '\\')
+					copy[size - 1] = ';';
+				else
+					end = 1;
+			}
+			if (!end || size != 0) {
+				arg = xcalloc(1, sizeof *arg);
+				arg->type = CMD_PARSE_STRING;
+				arg->string = copy;
+				TAILQ_INSERT_TAIL(&cmd->arguments, arg, entry);
+			}
+		} else if (values[i].type == ARGS_COMMANDS) {
+			arg = xcalloc(1, sizeof *arg);
+			arg->type = CMD_PARSE_PARSED_COMMANDS;
+			arg->cmdlist = values[i].cmdlist;
+			arg->cmdlist->references++;
+			TAILQ_INSERT_TAIL(&cmd->arguments, arg, entry);
+		} else
+			fatalx("unknown argument type");
+		if (end) {
+			TAILQ_INSERT_TAIL(cmds, cmd, entry);
+			cmd = xcalloc(1, sizeof *cmd);
+			cmd->line = pi->line;
+			TAILQ_INIT(&cmd->arguments);
+		}
+	}
+	if (!TAILQ_EMPTY(&cmd->arguments))
+		TAILQ_INSERT_TAIL(cmds, cmd, entry);
+	else
+		free(cmd);
+
+	cmd_parse_build_commands(cmds, pi, &pr);
+	cmd_parse_free_commands(cmds);
+	return (&pr);
+}
+
+static int printflike(1, 2)
+yyerror(const char *fmt, ...)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+	struct cmd_parse_input	*pi = ps->input;
+	va_list			 ap;
+	char			*error;
+
+	if (ps->error != NULL)
+		return (0);
+
+	va_start(ap, fmt);
+	xvasprintf(&error, fmt, ap);
+	va_end(ap);
+
+	ps->error = cmd_parse_get_error(pi->file, pi->line, error);
+	free(error);
+	return (0);
+}
+
+static int
+yylex_is_var(char ch, int first)
+{
+	if (ch == '=')
+		return (0);
+	if (first && isdigit((u_char)ch))
+		return (0);
+	return (isalnum((u_char)ch) || ch == '_');
+}
+
+static void
+yylex_append(char **buf, size_t *len, const char *add, size_t addlen)
+{
+	if (addlen > SIZE_MAX - 1 || *len > SIZE_MAX - 1 - addlen)
+		fatalx("buffer is too big");
+	*buf = xrealloc(*buf, (*len) + 1 + addlen);
+	memcpy((*buf) + *len, add, addlen);
+	(*len) += addlen;
+}
+
+static void
+yylex_append1(char **buf, size_t *len, char add)
+{
+	yylex_append(buf, len, &add, 1);
+}
+
+static int
+yylex_getc1(void)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+	int			 ch;
+
+	if (ps->f != NULL)
+		ch = getc(ps->f);
+	else {
+		if (ps->off == ps->len)
+			ch = EOF;
+		else
+			ch = ps->buf[ps->off++];
+	}
+	return (ch);
+}
+
+static void
+yylex_ungetc(int ch)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+
+	if (ps->f != NULL)
+		ungetc(ch, ps->f);
+	else if (ps->off > 0 && ch != EOF)
+		ps->off--;
+}
+
+static int
+yylex_getc(void)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+	int			 ch;
+
+	if (ps->escapes != 0) {
+		ps->escapes--;
+		return ('\\');
+	}
+	for (;;) {
+		ch = yylex_getc1();
+		if (ch == '\\') {
+			ps->escapes++;
+			continue;
+		}
+		if (ch == '\n' && (ps->escapes % 2) == 1) {
+			ps->input->line++;
+			ps->escapes--;
+			continue;
+		}
+
+		if (ps->escapes != 0) {
+			yylex_ungetc(ch);
+			ps->escapes--;
+			return ('\\');
+		}
+		return (ch);
+	}
+}
+
+static char *
+yylex_get_word(int ch)
+{
+	char	*buf;
+	size_t	 len;
+
+	len = 0;
+	buf = xmalloc(1);
+
+	do
+		yylex_append1(&buf, &len, ch);
+	while ((ch = yylex_getc()) != EOF && strchr(" \t\n", ch) == NULL);
+	yylex_ungetc(ch);
+
+	buf[len] = '\0';
+	log_debug("%s: %s", __func__, buf);
+	return (buf);
+}
+
+static int
+yylex(void)
+{
+	struct cmd_parse_state	*ps = &parse_state;
+	char			*token, *cp;
+	int			 ch, next, condition;
+
+	if (ps->eol)
+		ps->input->line++;
+	ps->eol = 0;
+
+	condition = ps->condition;
+	ps->condition = 0;
+
+	for (;;) {
+		ch = yylex_getc();
+
+		if (ch == EOF) {
+			/*
+			 * Ensure every file or string is terminated by a
+			 * newline. This keeps the parser simpler and avoids
+			 * having to add a newline to each string.
+			 */
+			if (ps->eof)
+				break;
+			ps->eof = 1;
+			return ('\n');
+		}
+
+		if (ch == ' ' || ch == '\t') {
+			/*
+			 * Ignore whitespace.
+			 */
+			continue;
+		}
+
+		if (ch == '\n') {
+			/*
+			 * End of line. Update the line number.
+			 */
+			ps->eol = 1;
+			return ('\n');
+		}
+
+		if (ch == ';' || ch == '{' || ch == '}') {
+			/*
+			 * A semicolon or { or } is itself.
+			 */
+			return (ch);
+		}
+
+		if (ch == '#') {
+			/*
+			 * #{ after a condition opens a format; anything else
+			 * is a comment, ignore up to the end of the line.
+			 */
+			next = yylex_getc();
+			if (condition && next == '{') {
+				yylval.token = yylex_format();
+				if (yylval.token == NULL)
+					return (ERROR);
+				return (FORMAT);
+			}
+			while (next != '\n' && next != EOF)
+				next = yylex_getc();
+			if (next == '\n') {
+				ps->input->line++;
+				return ('\n');
+			}
+			continue;
+		}
+
+		if (ch == '%') {
+			/*
+			 * % is a condition unless it is all % or all numbers,
+			 * then it is a token.
+			 */
+			yylval.token = yylex_get_word('%');
+			for (cp = yylval.token; *cp != '\0'; cp++) {
+				if (*cp != '%' && !isdigit((u_char)*cp))
+					break;
+			}
+			if (*cp == '\0')
+				return (TOKEN);
+			ps->condition = 1;
+			if (strcmp(yylval.token, "%hidden") == 0) {
+				free(yylval.token);
+				return (HIDDEN);
+			}
+			if (strcmp(yylval.token, "%if") == 0) {
+				free(yylval.token);
+				return (IF);
+			}
+			if (strcmp(yylval.token, "%else") == 0) {
+				free(yylval.token);
+				return (ELSE);
+			}
+			if (strcmp(yylval.token, "%elif") == 0) {
+				free(yylval.token);
+				return (ELIF);
+			}
+			if (strcmp(yylval.token, "%endif") == 0) {
+				free(yylval.token);
+				return (ENDIF);
+			}
+			free(yylval.token);
+			return (ERROR);
+		}
+
+		/*
+		 * Otherwise this is a token.
+		 */
+		token = yylex_token(ch);
+		if (token == NULL)
+			return (ERROR);
+		yylval.token = token;
+
+		if (strchr(token, '=') != NULL && yylex_is_var(*token, 1)) {
+			for (cp = token + 1; *cp != '='; cp++) {
+				if (!yylex_is_var(*cp, 0))
+					break;
+			}
+			if (*cp == '=')
+				return (EQUALS);
+		}
+		return (TOKEN);
+	}
+	return (0);
+}
+
+static char *
+yylex_format(void)
+{
+	char	*buf;
+	size_t	 len;
+	int	 ch, brackets = 1;
+
+	len = 0;
+	buf = xmalloc(1);
+
+	yylex_append(&buf, &len, "#{", 2);
+	for (;;) {
+		if ((ch = yylex_getc()) == EOF || ch == '\n')
+			goto error;
+		if (ch == '#') {
+			if ((ch = yylex_getc()) == EOF || ch == '\n')
+				goto error;
+			if (ch == '{')
+				brackets++;
+			yylex_append1(&buf, &len, '#');
+		} else if (ch == '}') {
+			if (brackets != 0 && --brackets == 0) {
+				yylex_append1(&buf, &len, ch);
+				break;
+			}
+		}
+		yylex_append1(&buf, &len, ch);
+	}
+	if (brackets != 0)
+		goto error;
+
+	buf[len] = '\0';
+	log_debug("%s: %s", __func__, buf);
+	return (buf);
+
+error:
+	free(buf);
+	return (NULL);
+}
+
+static int
+yylex_token_escape(char **buf, size_t *len)
+{
+	int	 ch, type, o2, o3, mlen;
+	u_int	 size, i, tmp;
+	char	 s[9], m[MB_LEN_MAX];
+
+	ch = yylex_getc();
+
+	if (ch >= '4' && ch <= '7') {
+		yyerror("invalid octal escape");
+		return (0);
+	}
+	if (ch >= '0' && ch <= '3') {
+		o2 = yylex_getc();
+		if (o2 >= '0' && o2 <= '7') {
+			o3 = yylex_getc();
+			if (o3 >= '0' && o3 <= '7') {
+				ch = 64 * (ch - '0') +
+				      8 * (o2 - '0') +
+					  (o3 - '0');
+				yylex_append1(buf, len, ch);
+				return (1);
+			}
+		}
+		yyerror("invalid octal escape");
+		return (0);
+	}
+
+	switch (ch) {
+	case EOF:
+		return (0);
+	case 'a':
+		ch = '\a';
+		break;
+	case 'b':
+		ch = '\b';
+		break;
+	case 'e':
+		ch = '\033';
+		break;
+	case 'f':
+		ch = '\f';
+		break;
+	case 's':
+		ch = ' ';
+		break;
+	case 'v':
+		ch = '\v';
+		break;
+	case 'r':
+		ch = '\r';
+		break;
+	case 'n':
+		ch = '\n';
+		break;
+	case 't':
+		ch = '\t';
+		break;
+	case 'u':
+		type = 'u';
+		size = 4;
+		goto unicode;
+	case 'U':
+		type = 'U';
+		size = 8;
+		goto unicode;
+	}
+
+	yylex_append1(buf, len, ch);
+	return (1);
+
+unicode:
+	for (i = 0; i < size; i++) {
+		ch = yylex_getc();
+		if (ch == EOF || ch == '\n')
+			return (0);
+		if (!isxdigit((u_char)ch)) {
+			yyerror("invalid \\%c argument", type);
+			return (0);
+		}
+		s[i] = ch;
+	}
+	s[i] = '\0';
+
+	if ((size == 4 && sscanf(s, "%4x", &tmp) != 1) ||
+	    (size == 8 && sscanf(s, "%8x", &tmp) != 1)) {
+		yyerror("invalid \\%c argument", type);
+		return (0);
+	}
+	mlen = wctomb(m, tmp);
+	if (mlen <= 0 || mlen > (int)sizeof m) {
+		yyerror("invalid \\%c argument", type);
+		return (0);
+	}
+	yylex_append(buf, len, m, mlen);
+	return (1);
+}
+
+static int
+yylex_token_variable(char **buf, size_t *len)
+{
+	struct environ_entry	*envent;
+	int			 ch, brackets = 0;
+	char			 name[1024];
+	size_t			 namelen = 0;
+	const char		*value;
+
+	ch = yylex_getc();
+	if (ch == EOF)
+		return (0);
+	if (ch == '{')
+		brackets = 1;
+	else {
+		if (!yylex_is_var(ch, 1)) {
+			yylex_append1(buf, len, '$');
+			yylex_ungetc(ch);
+			return (1);
+		}
+		name[namelen++] = ch;
+	}
+
+	for (;;) {
+		ch = yylex_getc();
+		if (brackets && ch == '}')
+			break;
+		if (ch == EOF || !yylex_is_var(ch, 0)) {
+			if (!brackets) {
+				yylex_ungetc(ch);
+				break;
+			}
+			yyerror("invalid environment variable");
+			return (0);
+		}
+		if (namelen == (sizeof name) - 2) {
+			yyerror("environment variable is too long");
+			return (0);
+		}
+		name[namelen++] = ch;
+	}
+	name[namelen] = '\0';
+
+	envent = environ_find(global_environ, name);
+	if (envent != NULL && envent->value != NULL) {
+		value = envent->value;
+		log_debug("%s: %s -> %s", __func__, name, value);
+		yylex_append(buf, len, value, strlen(value));
+	}
+	return (1);
+}
+
+static int
+yylex_token_tilde(char **buf, size_t *len)
+{
+	struct environ_entry	*envent;
+	int			 ch;
+	char			 name[1024];
+	size_t			 namelen = 0;
+	struct passwd		*pw;
+	const char		*home = NULL;
+
+	for (;;) {
+		ch = yylex_getc();
+		if (ch == EOF || strchr("/ \t\n\"'", ch) != NULL) {
+			yylex_ungetc(ch);
+			break;
+		}
+		if (namelen == (sizeof name) - 2) {
+			yyerror("user name is too long");
+			return (0);
+		}
+		name[namelen++] = ch;
+	}
+	name[namelen] = '\0';
+
+	if (*name == '\0') {
+		envent = environ_find(global_environ, "HOME");
+		if (envent != NULL && *envent->value != '\0')
+			home = envent->value;
+		else if ((pw = getpwuid(getuid())) != NULL)
+			home = pw->pw_dir;
+	} else {
+		if ((pw = getpwnam(name)) != NULL)
+			home = pw->pw_dir;
+	}
+	if (home == NULL)
+		return (0);
+
+	log_debug("%s: ~%s -> %s", __func__, name, home);
+	yylex_append(buf, len, home, strlen(home));
+	return (1);
+}
+
+static char *
+yylex_token(int ch)
+{
+	char			*buf;
+	size_t			 len;
+	enum { START,
+	       NONE,
+	       DOUBLE_QUOTES,
+	       SINGLE_QUOTES }	 state = NONE, last = START;
+
+	len = 0;
+	buf = xmalloc(1);
+
+	for (;;) {
+		/* EOF or \n are always the end of the token. */
+		if (ch == EOF || (state == NONE && ch == '\n'))
+			break;
+
+		/* Whitespace or ; or } ends a token unless inside quotes. */
+		if ((ch == ' ' || ch == '\t' || ch == ';' || ch == '}') &&
+		    state == NONE)
+			break;
+
+		/*
+		 * Spaces and comments inside quotes after \n are removed but
+		 * the \n is left.
+		 */
+		if (ch == '\n' && state != NONE) {
+			yylex_append1(&buf, &len, '\n');
+			while ((ch = yylex_getc()) == ' ' || ch == '\t')
+				/* nothing */;
+			if (ch != '#')
+				continue;
+			ch = yylex_getc();
+			if (strchr(",#{}:", ch) != NULL) {
+				yylex_ungetc(ch);
+				ch = '#';
+			} else {
+				while ((ch = yylex_getc()) != '\n' && ch != EOF)
+					/* nothing */;
+			}
+			continue;
+		}
+
+		/* \ ~ and $ are expanded except in single quotes. */
+		if (ch == '\\' && state != SINGLE_QUOTES) {
+			if (!yylex_token_escape(&buf, &len))
+				goto error;
+			goto skip;
+		}
+		if (ch == '~' && last != state && state != SINGLE_QUOTES) {
+			if (!yylex_token_tilde(&buf, &len))
+				goto error;
+			goto skip;
+		}
+		if (ch == '$' && state != SINGLE_QUOTES) {
+			if (!yylex_token_variable(&buf, &len))
+				goto error;
+			goto skip;
+		}
+		if (ch == '}' && state == NONE)
+			goto error;  /* unmatched (matched ones were handled) */
+
+		/* ' and " starts or end quotes (and is consumed). */
+		if (ch == '\'') {
+			if (state == NONE) {
+				state = SINGLE_QUOTES;
+				goto next;
+			}
+			if (state == SINGLE_QUOTES) {
+				state = NONE;
+				goto next;
+			}
+		}
+		if (ch == '"') {
+			if (state == NONE) {
+				state = DOUBLE_QUOTES;
+				goto next;
+			}
+			if (state == DOUBLE_QUOTES) {
+				state = NONE;
+				goto next;
+			}
+		}
+
+		/* Otherwise add the character to the buffer. */
+		yylex_append1(&buf, &len, ch);
+
+	skip:
+		last = state;
+
+	next:
+		ch = yylex_getc();
+	}
+	yylex_ungetc(ch);
+
+	buf[len] = '\0';
+	log_debug("%s: %s", __func__, buf);
+	return (buf);
+
+error:
+	free(buf);
+	return (NULL);
+}
+#line 1458 "cmd-parse.c"
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(void)
+{
+    unsigned int newsize;
+    long sslen;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = yystacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+    sslen = yyssp - yyss;
+#ifdef SIZE_MAX
+#define YY_SIZE_MAX SIZE_MAX
+#else
+#define YY_SIZE_MAX 0xffffffffU
+#endif
+    if (newsize && YY_SIZE_MAX / newsize < sizeof *newss)
+        goto bail;
+    newss = (short *)realloc(yyss, newsize * sizeof *newss);
+    if (newss == NULL)
+        goto bail;
+    yyss = newss;
+    yyssp = newss + sslen;
+    if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs)
+        goto bail;
+    newvs = (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs);
+    if (newvs == NULL)
+        goto bail;
+    yyvs = newvs;
+    yyvsp = newvs + sslen;
+    yystacksize = newsize;
+    yysslim = yyss + newsize - 1;
+    return 0;
+bail:
+    if (yyss)
+            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 ((yys = getenv("YYDEBUG")))
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif /* YYDEBUG */
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = (-1);
+
+    if (yyss == NULL && yygrowstack()) goto yyoverflow;
+    yyssp = yyss;
+    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)
+        {
+            yys = 0;
+            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+            if (!yys) yys = "illegal-symbol";
+            printf("%sdebug: state %d, reading %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+    }
+    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
+    {
+#if YYDEBUG
+        if (yydebug)
+            printf("%sdebug: state %d, shifting to state %d\n",
+                    YYPREFIX, yystate, yytable[yyn]);
+#endif
+        if (yyssp >= yysslim && yygrowstack())
+        {
+            goto yyoverflow;
+        }
+        *++yyssp = yystate = yytable[yyn];
+        *++yyvsp = yylval;
+        yychar = (-1);
+        if (yyerrflag > 0)  --yyerrflag;
+        goto yyloop;
+    }
+    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
+    {
+        yyn = yytable[yyn];
+        goto yyreduce;
+    }
+    if (yyerrflag) goto yyinrecovery;
+#if defined(__GNUC__)
+    goto yynewerror;
+#endif
+yynewerror:
+    yyerror("syntax error");
+#if defined(__GNUC__)
+    goto yyerrlab;
+#endif
+yyerrlab:
+    ++yynerrs;
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
+#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
+                if (yyssp <= yyss) goto yyabort;
+                --yyssp;
+                --yyvsp;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = 0;
+            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);
+        goto yyloop;
+    }
+yyreduce:
+#if YYDEBUG
+    if (yydebug)
+        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
+                YYPREFIX, yystate, yyn, yyrule[yyn]);
+#endif
+    yym = yylen[yyn];
+    if (yym)
+        yyval = yyvsp[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 2:
+#line 136 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+
+			ps->commands = yyvsp[0].commands;
+		}
+break;
+case 3:
+#line 143 "cmd-parse.y"
+{
+			yyval.commands = yyvsp[-1].commands;
+		}
+break;
+case 4:
+#line 147 "cmd-parse.y"
+{
+			yyval.commands = yyvsp[-2].commands;
+			TAILQ_CONCAT(yyval.commands, yyvsp[-1].commands, entry);
+			free(yyvsp[-1].commands);
+		}
+break;
+case 5:
+#line 154 "cmd-parse.y"
+{
+			yyval.commands = xmalloc (sizeof *yyval.commands);
+			TAILQ_INIT(yyval.commands);
+		}
+break;
+case 6:
+#line 159 "cmd-parse.y"
+{
+			yyval.commands = xmalloc (sizeof *yyval.commands);
+			TAILQ_INIT(yyval.commands);
+		}
+break;
+case 7:
+#line 164 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+
+			if (ps->scope == NULL || ps->scope->flag)
+				yyval.commands = yyvsp[0].commands;
+			else {
+				yyval.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[0].commands);
+			}
+		}
+break;
+case 8:
+#line 175 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+
+			if (ps->scope == NULL || ps->scope->flag)
+				yyval.commands = yyvsp[0].commands;
+			else {
+				yyval.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[0].commands);
+			}
+		}
+break;
+case 9:
+#line 187 "cmd-parse.y"
+{
+			yyval.token = yyvsp[0].token;
+		}
+break;
+case 10:
+#line 191 "cmd-parse.y"
+{
+			yyval.token = yyvsp[0].token;
+		}
+break;
+case 11:
+#line 196 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+			struct cmd_parse_input	*pi = ps->input;
+			struct format_tree	*ft;
+			struct client		*c = pi->c;
+			struct cmd_find_state	*fsp;
+			struct cmd_find_state	 fs;
+			int			 flags = FORMAT_NOJOBS;
+
+			if (cmd_find_valid_state(&pi->fs))
+				fsp = &pi->fs;
+			else {
+				cmd_find_from_client(&fs, c, 0);
+				fsp = &fs;
+			}
+			ft = format_create(NULL, pi->item, FORMAT_NONE, flags);
+			format_defaults(ft, c, fsp->s, fsp->wl, fsp->wp);
+
+			yyval.token = format_expand(ft, yyvsp[0].token);
+			format_free(ft);
+			free(yyvsp[0].token);
+		}
+break;
+case 14:
+#line 223 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+			int			 flags = ps->input->flags;
+
+			if ((~flags & CMD_PARSE_PARSEONLY) &&
+			    (ps->scope == NULL || ps->scope->flag))
+				environ_put(global_environ, yyvsp[0].token, 0);
+			free(yyvsp[0].token);
+		}
+break;
+case 15:
+#line 234 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+			int			 flags = ps->input->flags;
+
+			if ((~flags & CMD_PARSE_PARSEONLY) &&
+			    (ps->scope == NULL || ps->scope->flag))
+				environ_put(global_environ, yyvsp[0].token, ENVIRON_HIDDEN);
+			free(yyvsp[0].token);
+		}
+break;
+case 16:
+#line 245 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+			struct cmd_parse_scope	*scope;
+
+			scope = xmalloc(sizeof *scope);
+			yyval.flag = scope->flag = format_true(yyvsp[0].token);
+			free(yyvsp[0].token);
+
+			if (ps->scope != NULL)
+				TAILQ_INSERT_HEAD(&ps->stack, ps->scope, entry);
+			ps->scope = scope;
+		}
+break;
+case 17:
+#line 259 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+			struct cmd_parse_scope	*scope;
+
+			scope = xmalloc(sizeof *scope);
+			scope->flag = !ps->scope->flag;
+
+			free(ps->scope);
+			ps->scope = scope;
+		}
+break;
+case 18:
+#line 271 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+			struct cmd_parse_scope	*scope;
+
+			scope = xmalloc(sizeof *scope);
+			yyval.flag = scope->flag = format_true(yyvsp[0].token);
+			free(yyvsp[0].token);
+
+			free(ps->scope);
+			ps->scope = scope;
+		}
+break;
+case 19:
+#line 284 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+
+			free(ps->scope);
+			ps->scope = TAILQ_FIRST(&ps->stack);
+			if (ps->scope != NULL)
+				TAILQ_REMOVE(&ps->stack, ps->scope, entry);
+		}
+break;
+case 20:
+#line 294 "cmd-parse.y"
+{
+			if (yyvsp[-3].flag)
+				yyval.commands = yyvsp[-1].commands;
+			else {
+				yyval.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			}
+		}
+break;
+case 21:
+#line 303 "cmd-parse.y"
+{
+			if (yyvsp[-6].flag) {
+				yyval.commands = yyvsp[-4].commands;
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else {
+				yyval.commands = yyvsp[-1].commands;
+				cmd_parse_free_commands(yyvsp[-4].commands);
+			}
+		}
+break;
+case 22:
+#line 313 "cmd-parse.y"
+{
+			if (yyvsp[-4].flag) {
+				yyval.commands = yyvsp[-2].commands;
+				cmd_parse_free_commands(yyvsp[-1].elif.commands);
+			} else if (yyvsp[-1].elif.flag) {
+				yyval.commands = yyvsp[-1].elif.commands;
+				cmd_parse_free_commands(yyvsp[-2].commands);
+			} else {
+				yyval.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[-2].commands);
+				cmd_parse_free_commands(yyvsp[-1].elif.commands);
+			}
+		}
+break;
+case 23:
+#line 327 "cmd-parse.y"
+{
+			if (yyvsp[-7].flag) {
+				yyval.commands = yyvsp[-5].commands;
+				cmd_parse_free_commands(yyvsp[-4].elif.commands);
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else if (yyvsp[-4].elif.flag) {
+				yyval.commands = yyvsp[-4].elif.commands;
+				cmd_parse_free_commands(yyvsp[-5].commands);
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else {
+				yyval.commands = yyvsp[-1].commands;
+				cmd_parse_free_commands(yyvsp[-5].commands);
+				cmd_parse_free_commands(yyvsp[-4].elif.commands);
+			}
+		}
+break;
+case 24:
+#line 344 "cmd-parse.y"
+{
+			if (yyvsp[-2].flag) {
+				yyval.elif.flag = 1;
+				yyval.elif.commands = yyvsp[0].commands;
+			} else {
+				yyval.elif.flag = 0;
+				yyval.elif.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[0].commands);
+			}
+		}
+break;
+case 25:
+#line 355 "cmd-parse.y"
+{
+			if (yyvsp[-3].flag) {
+				yyval.elif.flag = 1;
+				yyval.elif.commands = yyvsp[-1].commands;
+				cmd_parse_free_commands(yyvsp[0].elif.commands);
+			} else if (yyvsp[0].elif.flag) {
+				yyval.elif.flag = 1;
+				yyval.elif.commands = yyvsp[0].elif.commands;
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else {
+				yyval.elif.flag = 0;
+				yyval.elif.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[-1].commands);
+				cmd_parse_free_commands(yyvsp[0].elif.commands);
+			}
+		}
+break;
+case 26:
+#line 373 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+
+			yyval.commands = cmd_parse_new_commands();
+			if (!TAILQ_EMPTY(&yyvsp[0].command->arguments) &&
+			    (ps->scope == NULL || ps->scope->flag))
+				TAILQ_INSERT_TAIL(yyval.commands, yyvsp[0].command, entry);
+			else
+				cmd_parse_free_command(yyvsp[0].command);
+		}
+break;
+case 27:
+#line 384 "cmd-parse.y"
+{
+			yyval.commands = yyvsp[-1].commands;
+		}
+break;
+case 28:
+#line 388 "cmd-parse.y"
+{
+			yyval.commands = yyvsp[-2].commands;
+			TAILQ_CONCAT(yyval.commands, yyvsp[0].commands, entry);
+			free(yyvsp[0].commands);
+		}
+break;
+case 29:
+#line 394 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+
+			if (!TAILQ_EMPTY(&yyvsp[0].command->arguments) &&
+			    (ps->scope == NULL || ps->scope->flag)) {
+				yyval.commands = yyvsp[-2].commands;
+				TAILQ_INSERT_TAIL(yyval.commands, yyvsp[0].command, entry);
+			} else {
+				yyval.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[-2].commands);
+				cmd_parse_free_command(yyvsp[0].command);
+			}
+		}
+break;
+case 30:
+#line 408 "cmd-parse.y"
+{
+			yyval.commands = yyvsp[0].commands;
+		}
+break;
+case 31:
+#line 413 "cmd-parse.y"
+{
+			struct cmd_parse_state	*ps = &parse_state;
+
+			yyval.command = xcalloc(1, sizeof *yyval.command);
+			yyval.command->line = ps->input->line;
+			TAILQ_INIT(&yyval.command->arguments);
+		}
+break;
+case 32:
+#line 421 "cmd-parse.y"
+{
+			struct cmd_parse_state		*ps = &parse_state;
+			struct cmd_parse_argument	*arg;
+
+			yyval.command = xcalloc(1, sizeof *yyval.command);
+			yyval.command->line = ps->input->line;
+			TAILQ_INIT(&yyval.command->arguments);
+
+			arg = xcalloc(1, sizeof *arg);
+			arg->type = CMD_PARSE_STRING;
+			arg->string = yyvsp[0].token;
+			TAILQ_INSERT_HEAD(&yyval.command->arguments, arg, entry);
+		}
+break;
+case 33:
+#line 435 "cmd-parse.y"
+{
+			struct cmd_parse_state		*ps = &parse_state;
+			struct cmd_parse_argument	*arg;
+
+			yyval.command = xcalloc(1, sizeof *yyval.command);
+			yyval.command->line = ps->input->line;
+			TAILQ_INIT(&yyval.command->arguments);
+
+			TAILQ_CONCAT(&yyval.command->arguments, yyvsp[0].arguments, entry);
+			free(yyvsp[0].arguments);
+
+			arg = xcalloc(1, sizeof *arg);
+			arg->type = CMD_PARSE_STRING;
+			arg->string = yyvsp[-1].token;
+			TAILQ_INSERT_HEAD(&yyval.command->arguments, arg, entry);
+		}
+break;
+case 34:
+#line 453 "cmd-parse.y"
+{
+			if (yyvsp[-2].flag)
+				yyval.commands = yyvsp[-1].commands;
+			else {
+				yyval.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			}
+		}
+break;
+case 35:
+#line 462 "cmd-parse.y"
+{
+			if (yyvsp[-4].flag) {
+				yyval.commands = yyvsp[-3].commands;
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else {
+				yyval.commands = yyvsp[-1].commands;
+				cmd_parse_free_commands(yyvsp[-3].commands);
+			}
+		}
+break;
+case 36:
+#line 472 "cmd-parse.y"
+{
+			if (yyvsp[-3].flag) {
+				yyval.commands = yyvsp[-2].commands;
+				cmd_parse_free_commands(yyvsp[-1].elif.commands);
+			} else if (yyvsp[-1].elif.flag) {
+				yyval.commands = yyvsp[-1].elif.commands;
+				cmd_parse_free_commands(yyvsp[-2].commands);
+			} else {
+				yyval.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[-2].commands);
+				cmd_parse_free_commands(yyvsp[-1].elif.commands);
+			}
+		}
+break;
+case 37:
+#line 486 "cmd-parse.y"
+{
+			if (yyvsp[-5].flag) {
+				yyval.commands = yyvsp[-4].commands;
+				cmd_parse_free_commands(yyvsp[-3].elif.commands);
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else if (yyvsp[-3].elif.flag) {
+				yyval.commands = yyvsp[-3].elif.commands;
+				cmd_parse_free_commands(yyvsp[-4].commands);
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else {
+				yyval.commands = yyvsp[-1].commands;
+				cmd_parse_free_commands(yyvsp[-4].commands);
+				cmd_parse_free_commands(yyvsp[-3].elif.commands);
+			}
+		}
+break;
+case 38:
+#line 503 "cmd-parse.y"
+{
+			if (yyvsp[-1].flag) {
+				yyval.elif.flag = 1;
+				yyval.elif.commands = yyvsp[0].commands;
+			} else {
+				yyval.elif.flag = 0;
+				yyval.elif.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[0].commands);
+			}
+		}
+break;
+case 39:
+#line 514 "cmd-parse.y"
+{
+			if (yyvsp[-2].flag) {
+				yyval.elif.flag = 1;
+				yyval.elif.commands = yyvsp[-1].commands;
+				cmd_parse_free_commands(yyvsp[0].elif.commands);
+			} else if (yyvsp[0].elif.flag) {
+				yyval.elif.flag = 1;
+				yyval.elif.commands = yyvsp[0].elif.commands;
+				cmd_parse_free_commands(yyvsp[-1].commands);
+			} else {
+				yyval.elif.flag = 0;
+				yyval.elif.commands = cmd_parse_new_commands();
+				cmd_parse_free_commands(yyvsp[-1].commands);
+				cmd_parse_free_commands(yyvsp[0].elif.commands);
+			}
+		}
+break;
+case 40:
+#line 532 "cmd-parse.y"
+{
+			yyval.arguments = xcalloc(1, sizeof *yyval.arguments);
+			TAILQ_INIT(yyval.arguments);
+
+			TAILQ_INSERT_HEAD(yyval.arguments, yyvsp[0].argument, entry);
+		}
+break;
+case 41:
+#line 539 "cmd-parse.y"
+{
+			TAILQ_INSERT_HEAD(yyvsp[0].arguments, yyvsp[-1].argument, entry);
+			yyval.arguments = yyvsp[0].arguments;
+		}
+break;
+case 42:
+#line 545 "cmd-parse.y"
+{
+			yyval.argument = xcalloc(1, sizeof *yyval.argument);
+			yyval.argument->type = CMD_PARSE_STRING;
+			yyval.argument->string = yyvsp[0].token;
+		}
+break;
+case 43:
+#line 551 "cmd-parse.y"
+{
+			yyval.argument = xcalloc(1, sizeof *yyval.argument);
+			yyval.argument->type = CMD_PARSE_STRING;
+			yyval.argument->string = yyvsp[0].token;
+		}
+break;
+case 44:
+#line 557 "cmd-parse.y"
+{
+			yyval.argument = xcalloc(1, sizeof *yyval.argument);
+			yyval.argument->type = CMD_PARSE_COMMANDS;
+			yyval.argument->commands = yyvsp[0].commands;
+		}
+break;
+case 45:
+#line 564 "cmd-parse.y"
+{
+				yyval.commands = yyvsp[-1].commands;
+			}
+break;
+case 46:
+#line 568 "cmd-parse.y"
+{
+				yyval.commands = yyvsp[-2].commands;
+				TAILQ_CONCAT(yyval.commands, yyvsp[-1].commands, entry);
+				free(yyvsp[-1].commands);
+			}
+break;
+#line 2152 "cmd-parse.c"
+    }
+    yyssp -= yym;
+    yystate = *yyssp;
+    yyvsp -= yym;
+    yym = yylhs[yyn];
+    if (yystate == 0 && yym == 0)
+    {
+#if YYDEBUG
+        if (yydebug)
+            printf("%sdebug: after reduction, shifting from state 0 to\
+ state %d\n", YYPREFIX, YYFINAL);
+#endif
+        yystate = YYFINAL;
+        *++yyssp = YYFINAL;
+        *++yyvsp = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = yylex()) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = 0;
+                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+                if (!yys) yys = "illegal-symbol";
+                printf("%sdebug: state %d, reading %d (%s)\n",
+                        YYPREFIX, YYFINAL, yychar, yys);
+            }
+#endif
+        }
+        if (yychar == 0) goto yyaccept;
+        goto yyloop;
+    }
+    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
+        yystate = yytable[yyn];
+    else
+        yystate = yydgoto[yym];
+#if YYDEBUG
+    if (yydebug)
+        printf("%sdebug: after reduction, shifting from state %d \
+to state %d\n", YYPREFIX, *yyssp, yystate);
+#endif
+    if (yyssp >= yysslim && yygrowstack())
+    {
+        goto yyoverflow;
+    }
+    *++yyssp = yystate;
+    *++yyvsp = yyval;
+    goto yyloop;
+yyoverflow:
+    yyerror("yacc stack overflow");
+yyabort:
+    if (yyss)
+            free(yyss);
+    if (yyvs)
+            free(yyvs);
+    yyss = yyssp = NULL;
+    yyvs = yyvsp = NULL;
+    yystacksize = 0;
+    return (1);
+yyaccept:
+    if (yyss)
+            free(yyss);
+    if (yyvs)
+            free(yyvs);
+    yyss = yyssp = NULL;
+    yyvs = yyvsp = NULL;
+    yystacksize = 0;
+    return (0);
+}