changeset 59:71d7a5e06997

y.tab: commit (forgot if this is generated or not)
author ng0@n0.is
date Fri, 03 May 2019 21:14:56 +0000
parents 27fe66ab381f
children e403b9515091
files y.tab.c y.tab.h
diffstat 2 files changed, 2244 insertions(+), 1627 deletions(-) [+]
line wrap: on
line diff
--- a/y.tab.c	Fri May 03 21:13:40 2019 +0000
+++ b/y.tab.c	Fri May 03 21:14:56 2019 +0000
@@ -6,12 +6,12 @@
 #define YYMAJOR 1
 #define YYMINOR 9
 
-#define YYEMPTY        (-1)
-#define yyclearin      (yychar = YYEMPTY)
-#define yyerrok        (yyerrflag = 0)
+#define YYEMPTY (-1)
+#define yyclearin (yychar = YYEMPTY)
+#define yyerrok (yyerrflag = 0)
 #define YYRECOVERING() (yyerrflag != 0)
-#define YYENOMEM       (-2)
-#define YYEOF          0
+#define YYENOMEM (-2)
+#define YYEOF 0
 #undef YYBTYACC
 #define YYBTYACC 0
 #define YYDEBUGSTR YYPREFIX "debug"
@@ -44,47 +44,55 @@
 #include <stdbool.h>
 #include "uwm.h"
 
-extern char* strconcat(char* s1, char* s2);
-extern MenuLine* AllocMenuLine(void);
-extern MenuLine* StashMenuLine(int type, char* string);
-extern MenuInfo* stashmenuinfo(char* name, MenuLine* line, char* colors[]);
-extern MenuLink* stashmenulink(MenuInfo* menuinfo);
-extern MenuLine* appendmenuline(MenuLine* list, MenuLine* line);
-extern MenuLink* appendmenulink(MenuLink* list, MenuLink* link);
- 
+extern char *
+strconcat (char *s1, char *s2);
+extern MenuLine *
+AllocMenuLine (void);
+extern MenuLine *
+StashMenuLine (int type, char *string);
+extern MenuInfo *
+stashmenuinfo (char *name, MenuLine *line, char *colors[]);
+extern MenuLink *
+stashmenulink (MenuInfo *menuinfo);
+extern MenuLine *
+appendmenuline (MenuLine *list, MenuLine *line);
+extern MenuLink *
+appendmenulink (MenuLink *list, MenuLink *link);
+
 /*
  * Values returned by complex expression parser.
  */
-#define C_STRING	1	/* IsString. */
-#define C_MENU		2	/* IsMenu. */
-#define C_MAP		3	/* IsMap. */
-#define C_MENUMAP	4	/* IsMenuMap. */
+#define C_STRING 1 /* IsString. */
+#define C_MENU 2 /* IsMenu. */
+#define C_MAP 3 /* IsMap. */
+#define C_MENUMAP 4 /* IsMenuMap. */
 
-static int ki;				/* Keyword index. */
-static int bkmask;			/* Button/key mask. */
-static int cmask;			/* Context mask. */
-static char msg[BUFSIZ];		/* Error message buffer. */
-static char *menu_name;			/* Menu name. */
-static MenuInfo *menu_info;		/* Menu info. */
-static MenuLine *ml_ptr;		/* Temporary menu line pointer. */
-static char *hcolors[4];		/* Color values used in menu hdrs. */
-static char *mcolors[2];		/* Color values used in menus. */
-MenuLink *menu_link;			/* Temporary menu link pointer. */
+static int ki; /* Keyword index. */
+static int bkmask; /* Button/key mask. */
+static int cmask; /* Context mask. */
+static char msg[BUFSIZ]; /* Error message buffer. */
+static char *menu_name; /* Menu name. */
+static MenuInfo *menu_info; /* Menu info. */
+static MenuLine *ml_ptr; /* Temporary menu line pointer. */
+static char *hcolors[4]; /* Color values used in menu hdrs. */
+static char *mcolors[2]; /* Color values used in menus. */
+MenuLink *menu_link; /* Temporary menu link pointer. */
 
 #ifdef YYSTYPE
-#undef  YYSTYPE_IS_DECLARED
+#undef YYSTYPE_IS_DECLARED
 #define YYSTYPE_IS_DECLARED 1
 #endif
 #ifndef YYSTYPE_IS_DECLARED
 #define YYSTYPE_IS_DECLARED 1
 #line 90 "gram.y"
-typedef union {
-    char *sval;
-    int ival;
-    short shval;
-    struct _menuline *mlval;
-    struct _menuinfo *mival;
-    char **cval;
+typedef union
+{
+        char *sval;
+        int ival;
+        short shval;
+        struct _menuline *mlval;
+        struct _menuinfo *mival;
+        char **cval;
 } YYSTYPE;
 #endif /* !YYSTYPE_IS_DECLARED */
 #line 91 "y.tab.c"
@@ -92,204 +100,148 @@
 /* compatibility with bison */
 #ifdef YYPARSE_PARAM
 /* compatibility with FreeBSD */
-# ifdef YYPARSE_PARAM_TYPE
-#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
-# else
-#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
-# endif
+#ifdef YYPARSE_PARAM_TYPE
+#define YYPARSE_DECL() yyparse (YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 #else
-# define YYPARSE_DECL() yyparse(void)
+#define YYPARSE_DECL() yyparse (void *YYPARSE_PARAM)
+#endif
+#else
+#define YYPARSE_DECL() yyparse (void)
 #endif
 
 /* Parameters sent to lex. */
 #ifdef YYLEX_PARAM
-# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
-# define YYLEX yylex(YYLEX_PARAM)
+#define YYLEX_DECL() yylex (void *YYLEX_PARAM)
+#define YYLEX yylex (YYLEX_PARAM)
 #else
-# define YYLEX_DECL() yylex(void)
-# define YYLEX yylex()
+#define YYLEX_DECL() yylex (void)
+#define YYLEX yylex ()
 #endif
 
-#if !(defined(yylex) || defined(YYSTATE))
-int YYLEX_DECL();
+#if ! (defined(yylex) || defined(YYSTATE))
+int
+YYLEX_DECL ();
 #endif
 
 /* Parameters sent to yyerror. */
 #ifndef YYERROR_DECL
-#define YYERROR_DECL() yyerror(const char *s)
+#define YYERROR_DECL() yyerror (const char *s)
 #endif
 #ifndef YYERROR_CALL
-#define YYERROR_CALL(msg) yyerror(msg)
+#define YYERROR_CALL(msg) yyerror (msg)
 #endif
 
-extern int YYPARSE_DECL();
+extern int
+YYPARSE_DECL ();
 
 #define NL 257
 #define STRING 258
 #define COMMENT 259
 #define YYERRCODE 256
 typedef int YYINT;
-static const YYINT yylhs[] = {                           -1,
-    0,    0,    0,   19,   19,   19,   19,   21,   21,   22,
-    2,    2,    2,    2,   20,    1,    3,    3,    3,    5,
-    5,    5,    9,    4,    6,    7,    7,    8,   10,   15,
-   16,   16,   16,   16,   16,   16,   16,   17,   18,   18,
-   18,   18,   18,   11,   11,   14,   14,   13,   13,   12,
-   12,
+static const YYINT yylhs[] = {
+  -1, 0,  0,  0,  19, 19, 19, 19, 21, 21, 22, 2,  2,  2,  2,  20, 1,  3,
+  3,  3,  5,  5,  5,  9,  4,  6,  7,  7,  8,  10, 15, 16, 16, 16, 16, 16,
+  16, 16, 17, 18, 18, 18, 18, 18, 11, 11, 14, 14, 13, 13, 12, 12,
 };
-static const YYINT yylen[] = {                            2,
-    0,    2,    3,    2,    2,    1,    1,    1,    1,    3,
-    5,    7,    3,    1,    1,    1,    0,    1,    3,    0,
-    1,    3,    1,    1,    1,    1,    2,    1,    1,    3,
-    1,    2,    2,    1,    1,    2,    2,    5,    1,    3,
-    2,    2,    2,    1,    2,    9,    0,    6,    0,    1,
-    0,
+static const YYINT yylen[] = {
+  2, 0, 2, 3, 2, 2, 1, 1, 1, 1, 3, 5, 7, 3, 1, 1, 1, 0, 1, 3, 0, 1, 3, 1, 1, 1,
+  1, 2, 1, 1, 3, 1, 2, 2, 1, 1, 2, 2, 5, 1, 3, 2, 2, 2, 1, 2, 9, 0, 6, 0, 1, 0,
 };
-static const YYINT yydefred[] = {                         1,
-    0,    0,    8,    0,    6,    9,    0,    2,    0,    7,
-    0,    3,    0,    4,    5,    0,   10,    0,    0,    0,
-    0,    0,    0,   50,    0,    0,   13,   25,    0,    0,
-   24,   19,    0,    0,   44,   34,    0,    0,   31,   35,
-    0,    0,    0,   37,   45,    0,   33,   30,   32,   36,
-   28,    0,   26,    0,   22,    0,    0,    0,   27,    0,
-    0,    0,    0,    0,    0,    0,    0,   29,   12,    0,
-    0,    0,    0,    0,    0,   38,    0,    0,   40,   46,
-    0,   48,
+static const YYINT yydefred[] = {
+  1, 0, 0,  8,  0, 6,  9,  0,  2,  0,  7,  0,  3, 0,  4,  5,  0,  10, 0,  0,  0,
+  0, 0, 0,  50, 0, 0,  13, 25, 0,  0,  24, 19, 0, 0,  44, 34, 0,  0,  31, 35, 0,
+  0, 0, 37, 45, 0, 33, 30, 32, 36, 28, 0,  26, 0, 22, 0,  0,  0,  27, 0,  0,  0,
+  0, 0, 0,  0,  0, 29, 12, 0,  0,  0,  0,  0,  0, 38, 0,  0,  40, 46, 0,  48,
 };
 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
-static const YYINT yystos[] = {                           0,
-  261,  256,  257,  258,  259,   59,  262,  280,  281,  282,
-  283,  280,   61,  282,  282,  258,  263,  264,  265,   40,
-  275,   58,  124,  258,  273,  123,  276,  258,  266,  267,
-  258,  264,   58,  256,  258,  259,  272,  277,  278,  282,
-   58,  124,  273,  282,  258,   58,  259,  125,  278,  282,
-  258,  268,  269,  270,  266,   58,   40,  274,  269,   58,
-  273,  273,  258,  124,   33,   94,  279,  258,  271,   58,
-   58,   58,  272,  272,  272,  282,  273,  273,  271,   41,
-   41,   58,
+static const YYINT yystos[] = {
+  0,   261, 256, 257, 258, 259, 59,  262, 280, 281, 282, 283, 280, 61,
+  282, 282, 258, 263, 264, 265, 40,  275, 58,  124, 258, 273, 123, 276,
+  258, 266, 267, 258, 264, 58,  256, 258, 259, 272, 277, 278, 282, 58,
+  124, 273, 282, 258, 58,  259, 125, 278, 282, 258, 268, 269, 270, 266,
+  58,  40,  274, 269, 58,  273, 273, 258, 124, 33,  94,  279, 258, 271,
+  58,  58,  58,  272, 272, 272, 282, 273, 273, 271, 41,  41,  58,
 };
 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
-static const YYINT yydgoto[] = {                          1,
-    7,   17,   18,   19,   29,   30,   52,   53,   54,   69,
-   37,   25,   58,   21,   27,   38,   39,   67,    8,    9,
-   10,   11,
+static const YYINT yydgoto[] = {
+  1,  7,  17, 18, 19, 29, 30, 52, 53, 54, 69, 37,
+  25, 58, 21, 27, 38, 39, 67, 8,  9,  10, 11,
 };
-static const YYINT yysindex[] = {                         0,
-  -57,  -47,    0,    0,    0,    0,  -51,    0,  -39,    0,
-  -39,    0, -250,    0,    0,  -29,    0,  -44,  -97, -226,
-  -90, -224, -223,    0,  -22,  -53,    0,    0,  -21,  -86,
-    0,    0, -226,  -39,    0,    0,  -45,  -50,    0,    0,
- -219, -224,  -18,    0,    0,    1,    0,    0,    0,    0,
-    0, -219,    0,  -16,    0, -226, -226,  -33,    0, -212,
-  -11,  -10,   -9, -208, -208, -208,  -39,    0,    0, -226,
- -226, -212, -206, -206, -206,    0,   12,   13,    0,    0,
-   -2,    0,
+static const YYINT yysindex[] = {
+  0,    -57,  -47,  0,    0,    0,    0,    -51, 0,    -39,  0,    -39,
+  0,    -250, 0,    0,    -29,  0,    -44,  -97, -226, -90,  -224, -223,
+  0,    -22,  -53,  0,    0,    -21,  -86,  0,   0,    -226, -39,  0,
+  0,    -45,  -50,  0,    0,    -219, -224, -18, 0,    0,    1,    0,
+  0,    0,    0,    0,    -219, 0,    -16,  0,   -226, -226, -33,  0,
+  -212, -11,  -10,  -9,   -208, -208, -208, -39, 0,    0,    -226, -226,
+  -212, -206, -206, -206, 0,    12,   13,   0,   0,    -2,   0,
 };
-static const YYINT yyrindex[] = {                         0,
-    0,    0,    0,  -40,    0,    0,    0,    0,    0,    0,
-    0,    0,   -1,    0,    0,  -43,    0,    0,    2,    5,
-    0,    6,   -1,    0,    0,    0,    0,    0,    0,    7,
-    0,    0,    5,    0,    0,    0,    0,    0,    0,    0,
-    0,    6,    0,    0,    0,  -32,    0,    0,    0,    0,
-    0,  -41,    0,  -37,    0,    5,    5,    0,    0,    0,
-    0,    0,  -36,    0,    0,    0,    0,    0,    0,   18,
-   18,    0,  -35,  -34,  -30,    0,    0,    0,    0,    0,
-    0,    0,
+static const YYINT yyrindex[] = {
+  0,   0, 0,  0, -40, 0, 0, 0,  0,  0, 0,   0,   0,   -1, 0, 0, -43, 0, 0, 2, 5,
+  0,   6, -1, 0, 0,   0, 0, 0,  0,  7, 0,   0,   5,   0,  0, 0, 0,   0, 0, 0, 0,
+  6,   0, 0,  0, -32, 0, 0, 0,  0,  0, -41, 0,   -37, 0,  5, 5, 0,   0, 0, 0, 0,
+  -36, 0, 0,  0, 0,   0, 0, 18, 18, 0, -35, -34, -30, 0,  0, 0, 0,   0, 0, 0,
 };
 #if YYBTYACC
-static const YYINT yycindex[] = {                         0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,
+static const YYINT yycindex[] = {
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 };
 #endif
-static const YYINT yygindex[] = {                         0,
-    0,    0,   35,    0,   24,    0,    0,   15,    0,   -4,
-  -61,  -26,    0,    0,    0,    0,   31,    0,   68,    0,
-   17,    0,
+static const YYINT yygindex[] = {
+  0,   0, 0, 35, 0, 24, 0, 0,  15, 0,  -4, -61,
+  -26, 0, 0, 0,  0, 31, 0, 68, 0,  17, 0,
 };
 #define YYTABLESIZE 227
-static const YYINT yytable[] = {                         65,
-   49,    6,   73,   74,   75,    6,   43,   16,    6,   13,
-   20,    6,   46,   22,   24,   14,   23,   23,   15,    6,
-   16,   11,   39,   43,   41,   14,   23,   15,   42,   61,
-   62,   24,   26,   28,   31,   33,   41,   42,   51,   56,
-   57,   60,   40,   77,   78,   68,   70,   71,   72,   35,
-   44,   45,   80,   81,   50,   82,   17,   32,   51,   18,
-   66,   49,   51,   20,   21,   55,   59,   79,   49,   12,
-    0,    0,    0,    0,   48,    0,    0,    0,    0,   47,
-   24,    0,    0,   76,    0,    0,    0,    0,    0,    0,
-   64,   49,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    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,    3,
-    4,    5,   34,    3,   35,   36,    3,   35,   47,    3,
-    4,    5,   45,   14,    0,   23,   15,    3,    0,   11,
-   39,   43,   41,    0,   63,   49,   42,
+static const YYINT yytable[] = {
+  65, 49, 6,  73, 74, 75, 6,  43, 16, 6,  13, 20, 6,  46, 22, 24, 14, 23, 23,
+  15, 6,  16, 11, 39, 43, 41, 14, 23, 15, 42, 61, 62, 24, 26, 28, 31, 33, 41,
+  42, 51, 56, 57, 60, 40, 77, 78, 68, 70, 71, 72, 35, 44, 45, 80, 81, 50, 82,
+  17, 32, 51, 18, 66, 49, 51, 20, 21, 55, 59, 79, 49, 12, 0,  0,  0,  0,  48,
+  0,  0,  0,  0,  47, 24, 0,  0,  76, 0,  0,  0,  0,  0,  0,  64, 49, 0,  0,
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+  0,  0,  0,  0,  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,  3,  4,  5,  34, 3,  35, 36, 3,  35,
+  47, 3,  4,  5,  45, 14, 0,  23, 15, 3,  0,  11, 39, 43, 41, 0,  63, 49, 42,
 };
-static const YYINT yycheck[] = {                         33,
-   33,   59,   64,   65,   66,   59,   33,  258,   59,   61,
-   40,   59,   58,   58,   58,   59,   58,   59,   59,   59,
-   61,   59,   59,   59,   59,    9,  124,   11,   59,   56,
-   57,  258,  123,  258,  258,   58,   58,  124,  258,   58,
-   40,   58,   26,   70,   71,  258,   58,   58,   58,  258,
-   34,  258,   41,   41,   38,   58,   58,   23,   41,   58,
-   94,   94,   58,   58,   58,   42,   52,   72,   38,    2,
-   -1,   -1,   -1,   -1,  125,   -1,   -1,   -1,   -1,  123,
-  124,   -1,   -1,   67,   -1,   -1,   -1,   -1,   -1,   -1,
-  124,  124,   -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,   -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,  256,  257,
-  258,  259,  256,  257,  258,  259,  257,  258,  259,  257,
-  258,  259,  258,  257,   -1,  257,  257,  257,   -1,  257,
-  257,  257,  257,   -1,  258,  258,  257,
+static const YYINT yycheck[] = {
+  33,  33,  59,  64,  65,  66,  59,  33,  258, 59,  61,  40,  59,  58,  58,
+  58,  59,  58,  59,  59,  59,  61,  59,  59,  59,  59,  9,   124, 11,  59,
+  56,  57,  258, 123, 258, 258, 58,  58,  124, 258, 58,  40,  58,  26,  70,
+  71,  258, 58,  58,  58,  258, 34,  258, 41,  41,  38,  58,  58,  23,  41,
+  58,  94,  94,  58,  58,  58,  42,  52,  72,  38,  2,   -1,  -1,  -1,  -1,
+  125, -1,  -1,  -1,  -1,  123, 124, -1,  -1,  67,  -1,  -1,  -1,  -1,  -1,
+  -1,  124, 124, -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,  -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,  256, 257, 258, 259, 256, 257, 258, 259, 257, 258, 259,
+  257, 258, 259, 258, 257, -1,  257, 257, 257, -1,  257, 257, 257, 257, -1,
+  258, 258, 257,
 };
 #if YYBTYACC
-static const YYINT yyctable[] = {                        -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,   -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,   -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,   -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,
+static const YYINT yyctable[] = {
+  -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, -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, -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, -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,
 };
 #endif
 #define YYFINAL 1
@@ -302,110 +254,384 @@
 #if YYDEBUG
 static const char *const yyname[] = {
 
-"$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'!'",0,
-0,0,0,0,0,"'('","')'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"':'","';'",0,"'='",0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'^'",0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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","NL","STRING","COMMENT","$accept","input","keyword","compexpr",
-"keyexpr","kmask","contexpr","contmask","buttmodexpr","buttmodifier","buttexpr",
-"menuname","strings","color","color2","color4","menuexpr","menulist","menuline",
-"menuaction","command","boolvar","term","expr","illegal-symbol",
+  "$end",
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  "'!'",
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  "'('",
+  "')'",
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  "':'",
+  "';'",
+  0,
+  "'='",
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  "'^'",
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  "'{'",
+  "'|'",
+  "'}'",
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  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",
+  "NL",
+  "STRING",
+  "COMMENT",
+  "$accept",
+  "input",
+  "keyword",
+  "compexpr",
+  "keyexpr",
+  "kmask",
+  "contexpr",
+  "contmask",
+  "buttmodexpr",
+  "buttmodifier",
+  "buttexpr",
+  "menuname",
+  "strings",
+  "color",
+  "color2",
+  "color4",
+  "menuexpr",
+  "menulist",
+  "menuline",
+  "menuaction",
+  "command",
+  "boolvar",
+  "term",
+  "expr",
+  "illegal-symbol",
 };
 static const char *const yyrule[] = {
-"$accept : input",
-"input :",
-"input : input command",
-"input : input error command",
-"command : boolvar term",
-"command : expr term",
-"command : COMMENT",
-"command : term",
-"term : NL",
-"term : ';'",
-"expr : keyword '=' compexpr",
-"compexpr : keyexpr ':' contexpr ':' buttexpr",
-"compexpr : keyexpr ':' contexpr ':' buttexpr ':' menuname",
-"compexpr : STRING color4 menuexpr",
-"compexpr : STRING",
-"boolvar : STRING",
-"keyword : STRING",
-"keyexpr :",
-"keyexpr : kmask",
-"keyexpr : kmask '|' keyexpr",
-"contexpr :",
-"contexpr : contmask",
-"contexpr : contmask '|' contexpr",
-"buttexpr : buttmodexpr",
-"kmask : STRING",
-"contmask : STRING",
-"buttmodexpr : buttmodifier",
-"buttmodexpr : buttmodexpr buttmodifier",
-"buttmodifier : STRING",
-"menuname : STRING",
-"menuexpr : '{' menulist '}'",
-"menulist : menuline",
-"menulist : menulist menuline",
-"menulist : menulist COMMENT",
-"menulist : COMMENT",
-"menulist : term",
-"menulist : menulist term",
-"menulist : error term",
-"menuline : strings ':' color2 menuaction term",
-"menuaction : STRING",
-"menuaction : STRING ':' menuname",
-"menuaction : '!' strings",
-"menuaction : '^' strings",
-"menuaction : '|' strings",
-"strings : STRING",
-"strings : strings STRING",
-"color4 : '(' color ':' color ':' color ':' color ')'",
-"color4 :",
-"color2 : '(' color ':' color ')' ':'",
-"color2 :",
-"color : STRING",
-"color :",
+  "$accept : input",
+  "input :",
+  "input : input command",
+  "input : input error command",
+  "command : boolvar term",
+  "command : expr term",
+  "command : COMMENT",
+  "command : term",
+  "term : NL",
+  "term : ';'",
+  "expr : keyword '=' compexpr",
+  "compexpr : keyexpr ':' contexpr ':' buttexpr",
+  "compexpr : keyexpr ':' contexpr ':' buttexpr ':' menuname",
+  "compexpr : STRING color4 menuexpr",
+  "compexpr : STRING",
+  "boolvar : STRING",
+  "keyword : STRING",
+  "keyexpr :",
+  "keyexpr : kmask",
+  "keyexpr : kmask '|' keyexpr",
+  "contexpr :",
+  "contexpr : contmask",
+  "contexpr : contmask '|' contexpr",
+  "buttexpr : buttmodexpr",
+  "kmask : STRING",
+  "contmask : STRING",
+  "buttmodexpr : buttmodifier",
+  "buttmodexpr : buttmodexpr buttmodifier",
+  "buttmodifier : STRING",
+  "menuname : STRING",
+  "menuexpr : '{' menulist '}'",
+  "menulist : menuline",
+  "menulist : menulist menuline",
+  "menulist : menulist COMMENT",
+  "menulist : COMMENT",
+  "menulist : term",
+  "menulist : menulist term",
+  "menulist : error term",
+  "menuline : strings ':' color2 menuaction term",
+  "menuaction : STRING",
+  "menuaction : STRING ':' menuname",
+  "menuaction : '!' strings",
+  "menuaction : '^' strings",
+  "menuaction : '|' strings",
+  "strings : STRING",
+  "strings : strings STRING",
+  "color4 : '(' color ':' color ':' color ':' color ')'",
+  "color4 :",
+  "color2 : '(' color ':' color ')' ':'",
+  "color2 :",
+  "color : STRING",
+  "color :",
 
 };
 #endif
 
 #if YYDEBUG
-int      yydebug;
+int yydebug;
 #endif
 
-int      yyerrflag;
-int      yychar;
-YYSTYPE  yyval;
-YYSTYPE  yylval;
-int      yynerrs;
+int yyerrflag;
+int yychar;
+YYSTYPE yyval;
+YYSTYPE yylval;
+int yynerrs;
 
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-YYLTYPE  yyloc; /* position returned by actions */
-YYLTYPE  yylloc; /* position from the lexer */
+YYLTYPE yyloc; /* position returned by actions */
+YYLTYPE yylloc; /* position from the lexer */
 #endif
 
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 #ifndef YYLLOC_DEFAULT
-#define YYLLOC_DEFAULT(loc, rhs, n) \
-do \
-{ \
-    if (n == 0) \
-    { \
-        (loc).first_line   = YYRHSLOC(rhs, 0).last_line; \
-        (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
-        (loc).last_line    = YYRHSLOC(rhs, 0).last_line; \
-        (loc).last_column  = YYRHSLOC(rhs, 0).last_column; \
-    } \
-    else \
-    { \
-        (loc).first_line   = YYRHSLOC(rhs, 1).first_line; \
-        (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
-        (loc).last_line    = YYRHSLOC(rhs, n).last_line; \
-        (loc).last_column  = YYRHSLOC(rhs, n).last_column; \
-    } \
-} while (0)
+#define YYLLOC_DEFAULT(loc, rhs, n)                                          \
+        do                                                                   \
+        {                                                                    \
+                if (n == 0)                                                  \
+                {                                                            \
+                        (loc).first_line = YYRHSLOC (rhs, 0).last_line;      \
+                        (loc).first_column = YYRHSLOC (rhs, 0).last_column;  \
+                        (loc).last_line = YYRHSLOC (rhs, 0).last_line;       \
+                        (loc).last_column = YYRHSLOC (rhs, 0).last_column;   \
+                }                                                            \
+                else                                                         \
+                {                                                            \
+                        (loc).first_line = YYRHSLOC (rhs, 1).first_line;     \
+                        (loc).first_column = YYRHSLOC (rhs, 1).first_column; \
+                        (loc).last_line = YYRHSLOC (rhs, n).last_line;       \
+                        (loc).last_column = YYRHSLOC (rhs, n).last_column;   \
+                }                                                            \
+        } while (0)
 #endif /* YYLLOC_DEFAULT */
 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 #if YYBTYACC
@@ -418,13 +644,13 @@
 /* define the initial stack-sizes */
 #ifdef YYSTACKSIZE
 #undef YYMAXDEPTH
-#define YYMAXDEPTH  YYSTACKSIZE
+#define YYMAXDEPTH YYSTACKSIZE
 #else
 #ifdef YYMAXDEPTH
 #define YYSTACKSIZE YYMAXDEPTH
 #else
 #define YYSTACKSIZE 10000
-#define YYMAXDEPTH  10000
+#define YYMAXDEPTH 10000
 #endif
 #endif
 
@@ -432,28 +658,30 @@
 #define YYINITSTACKSIZE 200
 #endif
 
-typedef struct {
-    unsigned stacksize;
-    YYINT    *s_base;
-    YYINT    *s_mark;
-    YYINT    *s_last;
-    YYSTYPE  *l_base;
-    YYSTYPE  *l_mark;
+typedef struct
+{
+        unsigned stacksize;
+        YYINT *s_base;
+        YYINT *s_mark;
+        YYINT *s_last;
+        YYSTYPE *l_base;
+        YYSTYPE *l_mark;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    YYLTYPE  *p_base;
-    YYLTYPE  *p_mark;
+        YYLTYPE *p_base;
+        YYLTYPE *p_mark;
 #endif
 } YYSTACKDATA;
 #if YYBTYACC
 
 struct YYParseState_s
 {
-    struct YYParseState_s *save;    /* Previously saved parser state */
-    YYSTACKDATA            yystack; /* saved parser stack */
-    int                    state;   /* saved parser state */
-    int                    errflag; /* saved error recovery status */
-    int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
-    YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
+        struct YYParseState_s *save; /* Previously saved parser state */
+        YYSTACKDATA yystack; /* saved parser stack */
+        int state; /* saved parser state */
+        int errflag; /* saved error recovery status */
+        int
+          lexeme; /* saved index of the conflict lexeme in the lexical queue */
+        YYINT ctry; /* saved index in yyctable[] for this conflict */
 };
 typedef struct YYParseState_s YYParseState;
 #endif /* YYBTYACC */
@@ -494,9 +722,9 @@
 #endif
 
 /* Current position at lexical token queue */
-static YYINT  *yylexp = 0;
+static YYINT *yylexp = 0;
 
-static YYINT  *yylexemes = 0;
+static YYINT *yylexemes = 0;
 #endif /* YYBTYACC */
 #line 414 "gram.y"
 
@@ -504,522 +732,542 @@
  * Look up a string in the keyword table and return its index, else
  * return -1.
  */
-keywordlookup(string)
-char *string;
+keywordlookup (string) char *string;
 {
-    int i;
+        int i;
 
-    for (i = 0; KeywordTable[i].name; i++) {
-        if (!strcmp(KeywordTable[i].name, string)) {
-            free(string);
-            return(i);
+        for (i = 0; KeywordTable[i].name; i++)
+        {
+                if (! strcmp (KeywordTable[i].name, string))
+                {
+                        free (string);
+                        return (i);
+                }
         }
-    }
-    sprintf(msg,"keyword error: \"%s\"", string);
-    yyerror(msg);
-    free(string);
-    return(-1);
+        sprintf (msg, "keyword error: \"%s\"", string);
+        yyerror (msg);
+        free (string);
+        return (-1);
 }
 
 /*
  * Look up a string in the key expression table and return its mask, else
  * return -1.
  */
-int keyexprlookup(string)
-char *string;
+int keyexprlookup (string) char *string;
 {
-    int i;
+        int i;
 
-    for (i = 0; KeyExprTbl[i].name; i++) {
-        if (!strcmp(KeyExprTbl[i].name, string)) {
-            free(string);
-            return(KeyExprTbl[i].mask);
+        for (i = 0; KeyExprTbl[i].name; i++)
+        {
+                if (! strcmp (KeyExprTbl[i].name, string))
+                {
+                        free (string);
+                        return (KeyExprTbl[i].mask);
+                }
         }
-    }
-    sprintf(msg,"key expression error: \"%s\"", string);
-    yyerror(msg);
-    free(string);
-    return(-1);
+        sprintf (msg, "key expression error: \"%s\"", string);
+        yyerror (msg);
+        free (string);
+        return (-1);
 }
 
 /*
  * Look up a string in the context expression table and return its mask, else
  * return -1.
  */
-contexprlookup(string)
-char *string;
+contexprlookup (string) char *string;
 {
-    int i;
+        int i;
 
-    for (i = 0; ContExprTbl[i].name; i++) {
-        if (!strcmp(ContExprTbl[i].name, string)) {
-            free(string);
-            return(ContExprTbl[i].mask);
+        for (i = 0; ContExprTbl[i].name; i++)
+        {
+                if (! strcmp (ContExprTbl[i].name, string))
+                {
+                        free (string);
+                        return (ContExprTbl[i].mask);
+                }
         }
-    }
-    sprintf(msg,"context expression error: \"%s\"", string);
-    yyerror(msg);
-    free(string);
-    return(-1);
+        sprintf (msg, "context expression error: \"%s\"", string);
+        yyerror (msg);
+        free (string);
+        return (-1);
 }
 /*
  * Look up a string in the button expression table and return its mask, else
  * return -1.
  */
-buttexprlookup(string)
-char *string;
+buttexprlookup (string) char *string;
 {
-    int i;
+        int i;
 
-    for (i = 0; ButtModTbl[i].name; i++) {
-        if (!strcmp(ButtModTbl[i].name, string)) {
-            free(string);
-            return(ButtModTbl[i].mask);
+        for (i = 0; ButtModTbl[i].name; i++)
+        {
+                if (! strcmp (ButtModTbl[i].name, string))
+                {
+                        free (string);
+                        return (ButtModTbl[i].mask);
+                }
         }
-    }
-    sprintf(msg,"button modifier error: \"%s\"", string);
-    yyerror(msg);
-    free(string);
-    return(-1);
+        sprintf (msg, "button modifier error: \"%s\"", string);
+        yyerror (msg);
+        free (string);
+        return (-1);
 }
 
 /*
  * Scan a string and return an integer.  Report an error if any
  * non-numeric characters are found.
  */
-y_atoi(s)
-char *s;
+y_atoi (s) char *s;
 {
-    int n = 0;
+        int n = 0;
 
-    while (*s) {
-        if (*s >= '0' && *s <= '9')
-            n = 10 * n + *s - '0';
-        else {
-            yyerror("non-numeric argument");
-            return(-1);
+        while (*s)
+        {
+                if (*s >= '0' && *s <= '9')
+                        n = 10 * n + *s - '0';
+                else
+                {
+                        yyerror ("non-numeric argument");
+                        return (-1);
+                }
+                s++;
         }
-        s++;
-    }
-    return(n);
+        return (n);
 }
 
 /*
  * Append s2 to s1, extending s1 as necessary.
  */
-char *
-strconcat(s1, s2)
-char *s1, *s2;
+char *strconcat (s1, s2) char *s1, *s2;
 {
-    char *p;
+        char *p;
 
-    p = malloc(strlen(s1) + strlen(s2) + 2);
-    sprintf(p, "%s %s", s1, s2);
-    free(s1);
-    free(s2);
-    s1 = p;
-    return(s1);
+        p = malloc (strlen (s1) + strlen (s2) + 2);
+        sprintf (p, "%s %s", s1, s2);
+        free (s1);
+        free (s2);
+        s1 = p;
+        return (s1);
 }
 
 /*
  * Check a button expression for errors.
  */
-int
-CheckButtonState(expr)
-int expr;
+int CheckButtonState (expr) int expr;
 {
-    /*
-     * Check for one (and only one) button.
-     */
-    switch (expr & (LeftMask | MiddleMask | RightMask)) {
-    case 0:
-        yyerror("no button specified");
-        break;
-    case LeftMask:
-        break;
-    case MiddleMask:
-        break;
-    case RightMask:
-        break;
-    default:
-        yyerror("more than one button specified");
-    }
+        /*
+         * Check for one (and only one) button.
+         */
+        switch (expr & (LeftMask | MiddleMask | RightMask))
+        {
+        case 0:
+                yyerror ("no button specified");
+                break;
+        case LeftMask:
+                break;
+        case MiddleMask:
+                break;
+        case RightMask:
+                break;
+        default:
+                yyerror ("more than one button specified");
+        }
 
-    /*
-     * Check for one (and only one) up/down/motion modifier.
-     */
-    switch (expr & (ButtonUp | ButtonDown | DeltaMotion)) {
-    case 0:
-        yyerror("no button action specified");
-        break;
-    case ButtonUp:
-        break;
-    case ButtonDown:
-        break;
-    case DeltaMotion:
-        break;
-    default:
-        yyerror("only one of up/down/motion may be specified");
-    }
-    return(expr);
+        /*
+         * Check for one (and only one) up/down/motion modifier.
+         */
+        switch (expr & (ButtonUp | ButtonDown | DeltaMotion))
+        {
+        case 0:
+                yyerror ("no button action specified");
+                break;
+        case ButtonUp:
+                break;
+        case ButtonDown:
+                break;
+        case DeltaMotion:
+                break;
+        default:
+                yyerror ("only one of up/down/motion may be specified");
+        }
+        return (expr);
 }
 
 /*
  * Bind button/key/context to a function.
  */
-bindtofunc(index, mask, context, name)
-int index;		/* Index into keyword table. */
-int mask;		/* Button/key/modifier mask. */
-int context;		/* ROOT, WINDOW, or ICON. */
-char *name;		/* Menu, if needed. */
+bindtofunc (index,
+            mask,
+            context,
+            name) int index; /* Index into keyword table. */
+int mask; /* Button/key/modifier mask. */
+int context; /* ROOT, WINDOW, or ICON. */
+char *name; /* Menu, if needed. */
 {
-    if (context & ROOT)
-        setbinding(ROOT, index, mask, name);
-    if (context & ICON)
-        setbinding(ICON, index, mask, name);
-    if (context & WINDOW)
-        setbinding(WINDOW, index, mask, name);
+        if (context & ROOT)
+                setbinding (ROOT, index, mask, name);
+        if (context & ICON)
+                setbinding (ICON, index, mask, name);
+        if (context & WINDOW)
+                setbinding (WINDOW, index, mask, name);
 }
 
 /*
  * Allocate a Binding type and return a pointer.
  */
 Binding *
-AllocBinding()
+AllocBinding ()
 {
-    Binding *ptr;
+        Binding *ptr;
 
-    if (!(ptr = (Binding *)calloc(1, sizeof(Binding)))) {
-        fprintf(stderr, "Can't allocate binding--out of space\n");
-        exit(1);
-    }
-    return(ptr);
+        if (! (ptr = (Binding *) calloc (1, sizeof (Binding))))
+        {
+                fprintf (stderr, "Can't allocate binding--out of space\n");
+                exit (1);
+        }
+        return (ptr);
 }
 
 /*
  * Stash the data in a Binding.
  */
-setbinding(cont, i, m, mname)
-int cont;		/* Context: ROOT, WINDOW, or ICON. */
-int i;			/* Keyword table index. */
-int m;		/* Key/button/modifier mask. */
-char *mname;		/* Pointer to menu name, if needed. */
+setbinding (cont, i, m, mname) int cont; /* Context: ROOT, WINDOW, or ICON. */
+int i; /* Keyword table index. */
+int m; /* Key/button/modifier mask. */
+char *mname; /* Pointer to menu name, if needed. */
 {
-    Binding *ptr;
+        Binding *ptr;
+
+        ptr = AllocBinding ();
+        ptr->context = cont;
+        ptr->mask = m;
+        ptr->func = KeywordTable[i].fptr;
+        ptr->menuname = mname;
 
-    ptr = AllocBinding();
-    ptr->context = cont;
-    ptr->mask = m;
-    ptr->func = KeywordTable[i].fptr;
-    ptr->menuname = mname;
-
-    switch (m & (LeftMask | MiddleMask | RightMask)) {
-    case LeftMask:
-        ptr->button = LeftButton;
-        break;
-    case MiddleMask:
-        ptr->button = MiddleButton;
-        break;
-    case RightMask:
-        ptr->button = RightButton;
-        break;
-    }
-    appendbinding(ptr);
+        switch (m & (LeftMask | MiddleMask | RightMask))
+        {
+        case LeftMask:
+                ptr->button = LeftButton;
+                break;
+        case MiddleMask:
+                ptr->button = MiddleButton;
+                break;
+        case RightMask:
+                ptr->button = RightButton;
+                break;
+        }
+        appendbinding (ptr);
 }
 
 /*
  * Append a Binding to the Bindings list.
  */
-appendbinding(binding)
-Binding *binding;
+appendbinding (binding) Binding *binding;
 {
-    Binding *ptr;
+        Binding *ptr;
 
-    if (Blist == NULL)
-        Blist = binding;
-    else {
-        for(ptr = Blist; ptr->next; ptr = ptr->next) /* NULL */;
-        ptr->next = binding;
-        ptr = ptr->next;
-        ptr->next = NULL;
-    }
+        if (Blist == NULL)
+                Blist = binding;
+        else
+        {
+                for (ptr = Blist; ptr->next; ptr = ptr->next) /* NULL */
+                        ;
+                ptr->next = binding;
+                ptr = ptr->next;
+                ptr->next = NULL;
+        }
 }
 
 /*
  * Allocate a menu line and return a pointer.
  */
 MenuLine *
-AllocMenuLine()
+AllocMenuLine ()
 {
-    MenuLine *ptr;
+        MenuLine *ptr;
 
-    if (!(ptr = (MenuLine *)calloc(1, sizeof(MenuLine)))) {
-        fprintf(stderr, "Can't allocate menu line--out of space\n");
-        exit(1);
-    }
-    return(ptr);
+        if (! (ptr = (MenuLine *) calloc (1, sizeof (MenuLine))))
+        {
+                fprintf (stderr, "Can't allocate menu line--out of space\n");
+                exit (1);
+        }
+        return (ptr);
 }
 
 /*
  * Allocate a MenuInfo structure and return a pointer.
  */
 MenuInfo *
-AllocMenuInfo()
+AllocMenuInfo ()
 {
-    MenuInfo *ptr;
+        MenuInfo *ptr;
 
-    if (!(ptr = (MenuInfo *)calloc(1, sizeof(MenuInfo)))) {
-        fprintf(stderr, "Can't allocate menu storage--out of space\n");
-        exit(1);
-    }
-    return(ptr);
+        if (! (ptr = (MenuInfo *) calloc (1, sizeof (MenuInfo))))
+        {
+                fprintf (stderr, "Can't allocate menu storage--out of space\n");
+                exit (1);
+        }
+        return (ptr);
 }
 
 /*
  * Allocate a MenuLink structure and return a pointer.
  */
 MenuLink *
-AllocMenuLink()
+AllocMenuLink ()
 {
-    MenuLink *ptr;
+        MenuLink *ptr;
 
-    if (!(ptr = (MenuLink *)calloc(1, sizeof(MenuLink)))) {
-        fprintf(stderr, "Can't allocate menu linked list storage--out of space\n");
-        exit(1);
-    }
-    return(ptr);
+        if (! (ptr = (MenuLink *) calloc (1, sizeof (MenuLink))))
+        {
+                fprintf (stderr,
+                         "Can't allocate menu linked list storage--out of space\n");
+                exit (1);
+        }
+        return (ptr);
 }
 
 /*
  * Stash the data in a menu line.
  */
-MenuLine *
-StashMenuLine(type, string)
-int type;
+MenuLine *StashMenuLine (type, string) int type;
 char *string;
 {
-    MenuLine *ptr;
+        MenuLine *ptr;
 
-    ptr = AllocMenuLine();
-    ptr->type = type;
-    ptr->text = string;
-    return(ptr);
+        ptr = AllocMenuLine ();
+        ptr->type = type;
+        ptr->text = string;
+        return (ptr);
 }
 
 /*
  * Stash menu data in a MenuInfo structure;
  */
-MenuInfo *
-stashmenuinfo(name, line, colors)
-char *name;
+MenuInfo *stashmenuinfo (name, line, colors) char *name;
 MenuLine *line;
 char *colors[];
 {
-    MenuInfo *ptr;
+        MenuInfo *ptr;
 
-    ptr = AllocMenuInfo();
-    ptr->name = name;
-    ptr->line = line;
-    ptr->foreground = colors[1];
-    ptr->background = colors[0];
-    ptr->fghighlight = colors[2];
-    ptr->bghighlight = colors[3];
-    return(ptr);
+        ptr = AllocMenuInfo ();
+        ptr->name = name;
+        ptr->line = line;
+        ptr->foreground = colors[1];
+        ptr->background = colors[0];
+        ptr->fghighlight = colors[2];
+        ptr->bghighlight = colors[3];
+        return (ptr);
 }
 
 /*
  * Stash menu info data in a MenuLink structure;
  */
-MenuLink *
-stashmenulink(menuinfo)
-MenuInfo *menuinfo;
+MenuLink *stashmenulink (menuinfo) MenuInfo *menuinfo;
 {
-    MenuLink *ptr;
+        MenuLink *ptr;
 
-    ptr = AllocMenuLink();
-    ptr->next = NULL;
-    ptr->menu = menuinfo;
-    return(ptr);
+        ptr = AllocMenuLink ();
+        ptr->next = NULL;
+        ptr->menu = menuinfo;
+        return (ptr);
 }
 
 /*
  * Append a menu line to a linked list of menu lines.
  */
-MenuLine *
-appendmenuline(list, line)
-MenuLine *list;
+MenuLine *appendmenuline (list, line) MenuLine *list;
 MenuLine *line;
 {
-    MenuLine *ptr;
+        MenuLine *ptr;
 
-    if (list == NULL)
-        list = line;
-    else {
-        for(ptr = list; ptr->next; ptr = ptr->next) /* NULL */;
-        ptr->next = line;
-        ptr = ptr->next;
-        ptr->next = NULL;
-    }
-    return(list);
+        if (list == NULL)
+                list = line;
+        else
+        {
+                for (ptr = list; ptr->next; ptr = ptr->next) /* NULL */
+                        ;
+                ptr->next = line;
+                ptr = ptr->next;
+                ptr->next = NULL;
+        }
+        return (list);
 }
 
 /*
  * Append a menu to a linked list of menus.
  */
-MenuLink *
-appendmenulink(list, link)
-MenuLink *list;
+MenuLink *appendmenulink (list, link) MenuLink *list;
 MenuLink *link;
 {
-    MenuLink *ptr;
+        MenuLink *ptr;
 
-    if (list == NULL)
-        list = link;
-    else {
-        for(ptr = list; ptr->next; ptr = ptr->next) /* NULL */;
-        ptr->next = link;
-        ptr = ptr->next;
-        ptr->next = NULL;
-    }
-    return(list);
+        if (list == NULL)
+                list = link;
+        else
+        {
+                for (ptr = list; ptr->next; ptr = ptr->next) /* NULL */
+                        ;
+                ptr->next = link;
+                ptr = ptr->next;
+                ptr->next = NULL;
+        }
+        return (list);
 }
 
 /*
  * Reset all previous bindings and free the space allocated to them.
  */
-bool ResetBindings()
+bool
+ResetBindings ()
 {
-    Binding *ptr, *nextptr;
+        Binding *ptr, *nextptr;
 
-    for(ptr = Blist; ptr; ptr = nextptr) {
-        if(ptr->menuname) free(ptr->menuname);
-        nextptr = ptr->next;
-        free(ptr);
-    }
-    Blist = NULL;
+        for (ptr = Blist; ptr; ptr = nextptr)
+        {
+                if (ptr->menuname)
+                        free (ptr->menuname);
+                nextptr = ptr->next;
+                free (ptr);
+        }
+        Blist = NULL;
 }
 
 /*
  * De-allocate all menus.
  */
-bool ResetMenus()
+bool
+ResetMenus ()
 {
-    MenuLink *mptr, *next_mptr;
-    register MenuLine *lptr, *next_lptr;
+        MenuLink *mptr, *next_mptr;
+        register MenuLine *lptr, *next_lptr;
 
-    for(mptr = Menus; mptr; mptr = next_mptr) {
-        free(mptr->menu->name);
-        for(lptr = mptr->menu->line; lptr; lptr = next_lptr) {
-            free(lptr->name);
-            if (lptr->text) free(lptr->text);
-            next_lptr = lptr->next;
-            free(lptr);
+        for (mptr = Menus; mptr; mptr = next_mptr)
+        {
+                free (mptr->menu->name);
+                for (lptr = mptr->menu->line; lptr; lptr = next_lptr)
+                {
+                        free (lptr->name);
+                        if (lptr->text)
+                                free (lptr->text);
+                        next_lptr = lptr->next;
+                        free (lptr);
+                }
+                next_mptr = mptr->next;
+                free (mptr);
         }
-        next_mptr = mptr->next;
-        free(mptr);
-    }
-    Menus = NULL;
+        Menus = NULL;
 }
 
 /*
  * Set all numeric variables to zero and all boolean variables to FALSE.
  */
-bool ResetVariables()
+bool
+ResetVariables ()
 {
-    register int i;
+        register int i;
 
-    for (i = 0; KeywordTable[i].name; i++) {
-        switch (KeywordTable[i].type) {
-        case IsBoolTrue:
-        case IsBoolFalse:
-            *(KeywordTable[i].bptr) = FALSE;
-            break;
-        case IsNumeric:
-            *(KeywordTable[i].nptr) = 0;
-            break;
-        default:
-            break;
+        for (i = 0; KeywordTable[i].name; i++)
+        {
+                switch (KeywordTable[i].type)
+                {
+                case IsBoolTrue:
+                case IsBoolFalse:
+                        *(KeywordTable[i].bptr) = FALSE;
+                        break;
+                case IsNumeric:
+                        *(KeywordTable[i].nptr) = 0;
+                        break;
+                default:
+                        break;
+                }
         }
-    }
-    SetVarDefaults();
-    LoadXDefaults();
+        SetVarDefaults ();
+        LoadXDefaults ();
 }
 #line 948 "y.tab.c"
 
 /* For use in generated program */
-#define yydepth (int)(yystack.s_mark - yystack.s_base)
+#define yydepth (int) (yystack.s_mark - yystack.s_base)
 #if YYBTYACC
 #define yytrial (yyps->save)
 #endif /* YYBTYACC */
 
 #if YYDEBUG
-#include <stdio.h>	/* needed for printf */
+#include <stdio.h> /* needed for printf */
 #endif
 
-#include <stdlib.h>	/* needed for malloc, etc */
-#include <string.h>	/* needed for memset */
+#include <stdlib.h> /* needed for malloc, etc */
+#include <string.h> /* needed for memset */
 
 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
-static int yygrowstack(YYSTACKDATA *data)
+static int
+yygrowstack (YYSTACKDATA *data)
 {
-    int i;
-    unsigned newsize;
-    YYINT *newss;
-    YYSTYPE *newvs;
+        int i;
+        unsigned newsize;
+        YYINT *newss;
+        YYSTYPE *newvs;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    YYLTYPE *newps;
+        YYLTYPE *newps;
 #endif
 
-    if ((newsize = data->stacksize) == 0)
-        newsize = YYINITSTACKSIZE;
-    else if (newsize >= YYMAXDEPTH)
-        return YYENOMEM;
-    else if ((newsize *= 2) > YYMAXDEPTH)
-        newsize = YYMAXDEPTH;
+        if ((newsize = data->stacksize) == 0)
+                newsize = YYINITSTACKSIZE;
+        else if (newsize >= YYMAXDEPTH)
+                return YYENOMEM;
+        else if ((newsize *= 2) > YYMAXDEPTH)
+                newsize = YYMAXDEPTH;
 
-    i = (int) (data->s_mark - data->s_base);
-    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
-    if (newss == 0)
-        return YYENOMEM;
+        i = (int) (data->s_mark - data->s_base);
+        newss = (YYINT *) realloc (data->s_base, newsize * sizeof (*newss));
+        if (newss == 0)
+                return YYENOMEM;
 
-    data->s_base = newss;
-    data->s_mark = newss + i;
+        data->s_base = newss;
+        data->s_mark = newss + i;
 
-    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
-    if (newvs == 0)
-        return YYENOMEM;
+        newvs = (YYSTYPE *) realloc (data->l_base, newsize * sizeof (*newvs));
+        if (newvs == 0)
+                return YYENOMEM;
 
-    data->l_base = newvs;
-    data->l_mark = newvs + i;
+        data->l_base = newvs;
+        data->l_mark = newvs + i;
 
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
-    if (newps == 0)
-        return YYENOMEM;
+        newps = (YYLTYPE *) realloc (data->p_base, newsize * sizeof (*newps));
+        if (newps == 0)
+                return YYENOMEM;
 
-    data->p_base = newps;
-    data->p_mark = newps + i;
+        data->p_base = newps;
+        data->p_mark = newps + i;
 #endif
 
-    data->stacksize = newsize;
-    data->s_last = data->s_base + newsize - 1;
+        data->stacksize = newsize;
+        data->s_last = data->s_base + newsize - 1;
 
 #if YYDEBUG
-    if (yydebug)
-        fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
+        if (yydebug)
+                fprintf (stderr,
+                         "%sdebug: stack size increased to %d\n",
+                         YYPREFIX,
+                         newsize);
 #endif
-    return 0;
+        return 0;
 }
 
 #if YYPURE || defined(YY_NO_LEAKS)
-static void yyfreestack(YYSTACKDATA *data)
+static void
+yyfreestack (YYSTACKDATA *data)
 {
-    free(data->s_base);
-    free(data->l_base);
+        free (data->s_base);
+        free (data->l_base);
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    free(data->p_base);
+        free (data->p_base);
 #endif
-    memset(data, 0, sizeof(*data));
+        memset (data, 0, sizeof (*data));
 }
 #else
 #define yyfreestack(data) /* nothing */
@@ -1027,1166 +1275,1534 @@
 #if YYBTYACC
 
 static YYParseState *
-yyNewState(unsigned size)
+yyNewState (unsigned size)
 {
-    YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
-    if (p == NULL) return NULL;
+        YYParseState *p = (YYParseState *) malloc (sizeof (YYParseState));
+        if (p == NULL)
+                return NULL;
 
-    p->yystack.stacksize = size;
-    if (size == 0)
-    {
-        p->yystack.s_base = NULL;
-        p->yystack.l_base = NULL;
+        p->yystack.stacksize = size;
+        if (size == 0)
+        {
+                p->yystack.s_base = NULL;
+                p->yystack.l_base = NULL;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-        p->yystack.p_base = NULL;
+                p->yystack.p_base = NULL;
 #endif
-        return p;
-    }
-    p->yystack.s_base    = (YYINT *) malloc(size * sizeof(YYINT));
-    if (p->yystack.s_base == NULL) return NULL;
-    p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
-    if (p->yystack.l_base == NULL) return NULL;
-    memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
+                return p;
+        }
+        p->yystack.s_base = (YYINT *) malloc (size * sizeof (YYINT));
+        if (p->yystack.s_base == NULL)
+                return NULL;
+        p->yystack.l_base = (YYSTYPE *) malloc (size * sizeof (YYSTYPE));
+        if (p->yystack.l_base == NULL)
+                return NULL;
+        memset (p->yystack.l_base, 0, size * sizeof (YYSTYPE));
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
-    if (p->yystack.p_base == NULL) return NULL;
-    memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
+        p->yystack.p_base = (YYLTYPE *) malloc (size * sizeof (YYLTYPE));
+        if (p->yystack.p_base == NULL)
+                return NULL;
+        memset (p->yystack.p_base, 0, size * sizeof (YYLTYPE));
 #endif
 
-    return p;
+        return p;
 }
 
 static void
-yyFreeState(YYParseState *p)
+yyFreeState (YYParseState *p)
 {
-    yyfreestack(&p->yystack);
-    free(p);
+        yyfreestack (&p->yystack);
+        free (p);
 }
 #endif /* YYBTYACC */
 
-#define YYABORT  goto yyabort
+#define YYABORT goto yyabort
 #define YYREJECT goto yyabort
 #define YYACCEPT goto yyaccept
-#define YYERROR  goto yyerrlab
+#define YYERROR goto yyerrlab
 #if YYBTYACC
-#define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
-#define YYVALID_NESTED do { if (yyps->save && \
-                                yyps->save->save == 0) goto yyvalid; } while(0)
+#define YYVALID                       \
+        do                            \
+        {                             \
+                if (yyps->save)       \
+                        goto yyvalid; \
+        } while (0)
+#define YYVALID_NESTED                                   \
+        do                                               \
+        {                                                \
+                if (yyps->save && yyps->save->save == 0) \
+                        goto yyvalid;                    \
+        } while (0)
 #endif /* YYBTYACC */
 
 int
-YYPARSE_DECL()
+YYPARSE_DECL ()
 {
-    int yym, yyn, yystate, yyresult;
+        int yym, yyn, yystate, yyresult;
 #if YYBTYACC
-    int yynewerrflag;
-    YYParseState *yyerrctx = NULL;
+        int yynewerrflag;
+        YYParseState *yyerrctx = NULL;
 #endif /* YYBTYACC */
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    YYLTYPE  yyerror_loc_range[3]; /* position of error start/end (0 unused) */
+        YYLTYPE
+          yyerror_loc_range[3]; /* position of error start/end (0 unused) */
 #endif
 #if YYDEBUG
-    const char *yys;
+        const char *yys;
 
-    if ((yys = getenv("YYDEBUG")) != 0)
-    {
-        yyn = *yys;
-        if (yyn >= '0' && yyn <= '9')
-            yydebug = yyn - '0';
-    }
-    if (yydebug)
-        fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
+        if ((yys = getenv ("YYDEBUG")) != 0)
+        {
+                yyn = *yys;
+                if (yyn >= '0' && yyn <= '9')
+                        yydebug = yyn - '0';
+        }
+        if (yydebug)
+                fprintf (stderr,
+                         "%sdebug[<# of symbols on state stack>]\n",
+                         YYPREFIX);
 #endif
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
+        memset (yyerror_loc_range, 0, sizeof (yyerror_loc_range));
 #endif
 
 #if YYBTYACC
-    yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
-    yyps->save = 0;
+        yyps = yyNewState (0);
+        if (yyps == 0)
+                goto yyenomem;
+        yyps->save = 0;
 #endif /* YYBTYACC */
-    yym = 0;
-    yyn = 0;
-    yynerrs = 0;
-    yyerrflag = 0;
-    yychar = YYEMPTY;
-    yystate = 0;
+        yym = 0;
+        yyn = 0;
+        yynerrs = 0;
+        yyerrflag = 0;
+        yychar = YYEMPTY;
+        yystate = 0;
 
 #if YYPURE
-    memset(&yystack, 0, sizeof(yystack));
+        memset (&yystack, 0, sizeof (yystack));
 #endif
 
-    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
-    yystack.s_mark = yystack.s_base;
-    yystack.l_mark = yystack.l_base;
+        if (yystack.s_base == NULL && yygrowstack (&yystack) == YYENOMEM)
+                goto yyoverflow;
+        yystack.s_mark = yystack.s_base;
+        yystack.l_mark = yystack.l_base;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    yystack.p_mark = yystack.p_base;
+        yystack.p_mark = yystack.p_base;
 #endif
-    yystate = 0;
-    *yystack.s_mark = 0;
+        yystate = 0;
+        *yystack.s_mark = 0;
 
 yyloop:
-    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
-    if (yychar < 0)
-    {
+        if ((yyn = yydefred[yystate]) != 0)
+                goto yyreduce;
+        if (yychar < 0)
+        {
 #if YYBTYACC
-        do {
-        if (yylvp < yylve)
-        {
-            /* we're currently re-reading tokens */
-            yylval = *yylvp++;
+                do
+                {
+                        if (yylvp < yylve)
+                        {
+                                /* we're currently re-reading tokens */
+                                yylval = *yylvp++;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            yylloc = *yylpp++;
-#endif
-            yychar = *yylexp++;
-            break;
-        }
-        if (yyps->save)
-        {
-            /* in trial mode; save scanner results for future parse attempts */
-            if (yylvp == yylvlim)
-            {   /* Enlarge lexical value queue */
-                size_t p = (size_t) (yylvp - yylvals);
-                size_t s = (size_t) (yylvlim - yylvals);
-
-                s += YYLVQUEUEGROWTH;
-                if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
-                if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
+                                yylloc = *yylpp++;
 #endif
-                yylvp   = yylve = yylvals + p;
-                yylvlim = yylvals + s;
+                                yychar = *yylexp++;
+                                break;
+                        }
+                        if (yyps->save)
+                        {
+                                /* in trial mode; save scanner results for
+                                 * future parse attempts */
+                                if (yylvp == yylvlim)
+                                { /* Enlarge lexical value queue */
+                                        size_t p = (size_t) (yylvp - yylvals);
+                                        size_t s = (size_t) (yylvlim - yylvals);
+
+                                        s += YYLVQUEUEGROWTH;
+                                        if ((yylexemes = (YYINT *)
+                                               realloc (yylexemes,
+                                                        s * sizeof (YYINT))) ==
+                                            NULL)
+                                                goto yyenomem;
+                                        if ((yylvals = (YYSTYPE *)
+                                               realloc (yylvals,
+                                                        s *
+                                                          sizeof (YYSTYPE))) ==
+                                            NULL)
+                                                goto yyenomem;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                yylpp   = yylpe = yylpsns + p;
-                yylplim = yylpsns + s;
-#endif
-                yylexp  = yylexemes + p;
-            }
-            *yylexp = (YYINT) YYLEX;
-            *yylvp++ = yylval;
-            yylve++;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            *yylpp++ = yylloc;
-            yylpe++;
+                                        if ((yylpsns = (YYLTYPE *)
+                                               realloc (yylpsns,
+                                                        s *
+                                                          sizeof (YYLTYPE))) ==
+                                            NULL)
+                                                goto yyenomem;
 #endif
-            yychar = *yylexp++;
-            break;
-        }
-        /* normal operation, no conflict encountered */
+                                        yylvp = yylve = yylvals + p;
+                                        yylvlim = yylvals + s;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                        yylpp = yylpe = yylpsns + p;
+                                        yylplim = yylpsns + s;
+#endif
+                                        yylexp = yylexemes + p;
+                                }
+                                *yylexp = (YYINT) YYLEX;
+                                *yylvp++ = yylval;
+                                yylve++;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                *yylpp++ = yylloc;
+                                yylpe++;
+#endif
+                                yychar = *yylexp++;
+                                break;
+                        }
+                        /* normal operation, no conflict encountered */
 #endif /* YYBTYACC */
-        yychar = YYLEX;
+                        yychar = YYLEX;
 #if YYBTYACC
-        } while (0);
+                } while (0);
 #endif /* YYBTYACC */
-        if (yychar < 0) yychar = YYEOF;
+                if (yychar < 0)
+                        yychar = YYEOF;
 #if YYDEBUG
-        if (yydebug)
-        {
-            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
-            fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
-                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
+                if (yydebug)
+                {
+                        if ((yys = yyname[YYTRANSLATE (yychar)]) == NULL)
+                                yys = yyname[YYUNDFTOKEN];
+                        fprintf (stderr,
+                                 "%s[%d]: state %d, reading token %d (%s)",
+                                 YYDEBUGSTR,
+                                 yydepth,
+                                 yystate,
+                                 yychar,
+                                 yys);
 #ifdef YYSTYPE_TOSTRING
 #if YYBTYACC
-            if (!yytrial)
+                        if (! yytrial)
 #endif /* YYBTYACC */
-                fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
+                                fprintf (stderr,
+                                         " <%s>",
+                                         YYSTYPE_TOSTRING (yychar, yylval));
 #endif
-            fputc('\n', stderr);
+                        fputc ('\n', stderr);
+                }
+#endif
         }
-#endif
-    }
 #if YYBTYACC
 
-    /* Do we have a conflict? */
-    if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
-        yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
-    {
-        YYINT ctry;
-
-        if (yypath)
-        {
-            YYParseState *save;
-#if YYDEBUG
-            if (yydebug)
-                fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
-                                YYDEBUGSTR, yydepth, yystate);
-#endif
-            /* Switch to the next conflict context */
-            save = yypath;
-            yypath = save->save;
-            save->save = NULL;
-            ctry = save->ctry;
-            if (save->state != yystate) YYABORT;
-            yyFreeState(save);
-
-        }
-        else
+        /* Do we have a conflict? */
+        if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
         {
+                YYINT ctry;
 
-            /* Unresolved conflict - start/continue trial parse */
-            YYParseState *save;
+                if (yypath)
+                {
+                        YYParseState *save;
 #if YYDEBUG
-            if (yydebug)
-            {
-                fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
-                if (yyps->save)
-                    fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
-                else
-                    fputs("Starting trial parse.\n", stderr);
-            }
+                        if (yydebug)
+                                fprintf (
+                                  stderr,
+                                  "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
+                                  YYDEBUGSTR,
+                                  yydepth,
+                                  yystate);
 #endif
-            save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
-            if (save == NULL) goto yyenomem;
-            save->save            = yyps->save;
-            save->state           = yystate;
-            save->errflag         = yyerrflag;
-            save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
-            memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
-            save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
-            memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
+                        /* Switch to the next conflict context */
+                        save = yypath;
+                        yypath = save->save;
+                        save->save = NULL;
+                        ctry = save->ctry;
+                        if (save->state != yystate)
+                                YYABORT;
+                        yyFreeState (save);
+                }
+                else
+                {
+
+                        /* Unresolved conflict - start/continue trial parse */
+                        YYParseState *save;
+#if YYDEBUG
+                        if (yydebug)
+                        {
+                                fprintf (stderr,
+                                         "%s[%d]: CONFLICT in state %d. ",
+                                         YYDEBUGSTR,
+                                         yydepth,
+                                         yystate);
+                                if (yyps->save)
+                                        fputs ("ALREADY in conflict, continuing trial parse.\n",
+                                               stderr);
+                                else
+                                        fputs ("Starting trial parse.\n",
+                                               stderr);
+                        }
+#endif
+                        save = yyNewState (
+                          (unsigned) (yystack.s_mark - yystack.s_base + 1));
+                        if (save == NULL)
+                                goto yyenomem;
+                        save->save = yyps->save;
+                        save->state = yystate;
+                        save->errflag = yyerrflag;
+                        save->yystack.s_mark =
+                          save->yystack.s_base +
+                          (yystack.s_mark - yystack.s_base);
+                        memcpy (save->yystack.s_base,
+                                yystack.s_base,
+                                (size_t) (yystack.s_mark - yystack.s_base + 1) *
+                                  sizeof (YYINT));
+                        save->yystack.l_mark =
+                          save->yystack.l_base +
+                          (yystack.l_mark - yystack.l_base);
+                        memcpy (save->yystack.l_base,
+                                yystack.l_base,
+                                (size_t) (yystack.l_mark - yystack.l_base + 1) *
+                                  sizeof (YYSTYPE));
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
-            memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
+                        save->yystack.p_mark =
+                          save->yystack.p_base +
+                          (yystack.p_mark - yystack.p_base);
+                        memcpy (save->yystack.p_base,
+                                yystack.p_base,
+                                (size_t) (yystack.p_mark - yystack.p_base + 1) *
+                                  sizeof (YYLTYPE));
+#endif
+                        ctry = yytable[yyn];
+                        if (yyctable[ctry] == -1)
+                        {
+#if YYDEBUG
+                                if (yydebug && yychar >= YYEOF)
+                                        fprintf (stderr,
+                                                 "%s[%d]: backtracking 1 token\n",
+                                                 YYDEBUGSTR,
+                                                 yydepth);
 #endif
-            ctry                  = yytable[yyn];
-            if (yyctable[ctry] == -1)
-            {
-#if YYDEBUG
-                if (yydebug && yychar >= YYEOF)
-                    fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
+                                ctry++;
+                        }
+                        save->ctry = ctry;
+                        if (yyps->save == NULL)
+                        {
+                                /* If this is a first conflict in the stack,
+                                 * start saving lexemes */
+                                if (! yylexemes)
+                                {
+                                        yylexemes = (YYINT *) malloc (
+                                          (YYLVQUEUEGROWTH) * sizeof (YYINT));
+                                        if (yylexemes == NULL)
+                                                goto yyenomem;
+                                        yylvals = (YYSTYPE *) malloc (
+                                          (YYLVQUEUEGROWTH) * sizeof (YYSTYPE));
+                                        if (yylvals == NULL)
+                                                goto yyenomem;
+                                        yylvlim = yylvals + YYLVQUEUEGROWTH;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                        yylpsns = (YYLTYPE *) malloc (
+                                          (YYLVQUEUEGROWTH) * sizeof (YYLTYPE));
+                                        if (yylpsns == NULL)
+                                                goto yyenomem;
+                                        yylplim = yylpsns + YYLVQUEUEGROWTH;
 #endif
-                ctry++;
-            }
-            save->ctry = ctry;
-            if (yyps->save == NULL)
-            {
-                /* If this is a first conflict in the stack, start saving lexemes */
-                if (!yylexemes)
-                {
-                    yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
-                    if (yylexemes == NULL) goto yyenomem;
-                    yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
-                    if (yylvals == NULL) goto yyenomem;
-                    yylvlim   = yylvals + YYLVQUEUEGROWTH;
+                                }
+                                if (yylvp == yylve)
+                                {
+                                        yylvp = yylve = yylvals;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                        yylpp = yylpe = yylpsns;
+#endif
+                                        yylexp = yylexemes;
+                                        if (yychar >= YYEOF)
+                                        {
+                                                *yylve++ = yylval;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                    yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
-                    if (yylpsns == NULL) goto yyenomem;
-                    yylplim   = yylpsns + YYLVQUEUEGROWTH;
+                                                *yylpe++ = yylloc;
 #endif
+                                                *yylexp = (YYINT) yychar;
+                                                yychar = YYEMPTY;
+                                        }
+                                }
+                        }
+                        if (yychar >= YYEOF)
+                        {
+                                yylvp--;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                yylpp--;
+#endif
+                                yylexp--;
+                                yychar = YYEMPTY;
+                        }
+                        save->lexeme = (int) (yylvp - yylvals);
+                        yyps->save = save;
                 }
-                if (yylvp == yylve)
+                if (yytable[yyn] == ctry)
                 {
-                    yylvp  = yylve = yylvals;
+#if YYDEBUG
+                        if (yydebug)
+                                fprintf (stderr,
+                                         "%s[%d]: state %d, shifting to state %d\n",
+                                         YYDEBUGSTR,
+                                         yydepth,
+                                         yystate,
+                                         yyctable[ctry]);
+#endif
+                        if (yychar < 0)
+                        {
+                                yylvp++;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                    yylpp  = yylpe = yylpsns;
+                                yylpp++;
 #endif
-                    yylexp = yylexemes;
-                    if (yychar >= YYEOF)
-                    {
-                        *yylve++ = yylval;
+                                yylexp++;
+                        }
+                        if (yystack.s_mark >= yystack.s_last &&
+                            yygrowstack (&yystack) == YYENOMEM)
+                                goto yyoverflow;
+                        yystate = yyctable[ctry];
+                        *++yystack.s_mark = (YYINT) yystate;
+                        *++yystack.l_mark = yylval;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                        *yylpe++ = yylloc;
+                        *++yystack.p_mark = yylloc;
 #endif
-                        *yylexp  = (YYINT) yychar;
-                        yychar   = YYEMPTY;
-                    }
+                        yychar = YYEMPTY;
+                        if (yyerrflag > 0)
+                                --yyerrflag;
+                        goto yyloop;
                 }
-            }
-            if (yychar >= YYEOF)
-            {
-                yylvp--;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                yylpp--;
-#endif
-                yylexp--;
-                yychar = YYEMPTY;
-            }
-            save->lexeme = (int) (yylvp - yylvals);
-            yyps->save   = save;
-        }
-        if (yytable[yyn] == ctry)
+                else
+                {
+                        yyn = yyctable[ctry];
+                        goto yyreduce;
+                }
+        } /* End of code dealing with conflicts */
+#endif /* YYBTYACC */
+        if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
         {
 #if YYDEBUG
-            if (yydebug)
-                fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
-                                YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
-#endif
-            if (yychar < 0)
-            {
-                yylvp++;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                yylpp++;
-#endif
-                yylexp++;
-            }
-            if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
-                goto yyoverflow;
-            yystate = yyctable[ctry];
-            *++yystack.s_mark = (YYINT) yystate;
-            *++yystack.l_mark = yylval;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            *++yystack.p_mark = yylloc;
-#endif
-            yychar  = YYEMPTY;
-            if (yyerrflag > 0) --yyerrflag;
-            goto yyloop;
-        }
-        else
-        {
-            yyn = yyctable[ctry];
-            goto yyreduce;
-        }
-    } /* End of code dealing with conflicts */
-#endif /* YYBTYACC */
-    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
-            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
-    {
-#if YYDEBUG
-        if (yydebug)
-            fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
-                            YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
-#endif
-        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
-        yystate = yytable[yyn];
-        *++yystack.s_mark = yytable[yyn];
-        *++yystack.l_mark = yylval;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-        *++yystack.p_mark = yylloc;
-#endif
-        yychar = YYEMPTY;
-        if (yyerrflag > 0)  --yyerrflag;
-        goto yyloop;
-    }
-    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
-            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
-    {
-        yyn = yytable[yyn];
-        goto yyreduce;
-    }
-    if (yyerrflag != 0) goto yyinrecovery;
-#if YYBTYACC
-
-    yynewerrflag = 1;
-    goto yyerrhandler;
-    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
-
-yyerrlab:
-    /* explicit YYERROR from an action -- pop the rhs of the rule reduced
-     * before looking for error recovery */
-    yystack.s_mark -= yym;
-    yystate = *yystack.s_mark;
-    yystack.l_mark -= yym;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    yystack.p_mark -= yym;
-#endif
-
-    yynewerrflag = 0;
-yyerrhandler:
-    while (yyps->save)
-    {
-        int ctry;
-        YYParseState *save = yyps->save;
-#if YYDEBUG
-        if (yydebug)
-            fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
-                            YYDEBUGSTR, yydepth, yystate, yyps->save->state,
-                    (int)(yylvp - yylvals - yyps->save->lexeme));
+                if (yydebug)
+                        fprintf (stderr,
+                                 "%s[%d]: state %d, shifting to state %d\n",
+                                 YYDEBUGSTR,
+                                 yydepth,
+                                 yystate,
+                                 yytable[yyn]);
 #endif
-        /* Memorize most forward-looking error state in case it's really an error. */
-        if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
-        {
-            /* Free old saved error context state */
-            if (yyerrctx) yyFreeState(yyerrctx);
-            /* Create and fill out new saved error context state */
-            yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
-            if (yyerrctx == NULL) goto yyenomem;
-            yyerrctx->save           = yyps->save;
-            yyerrctx->state          = yystate;
-            yyerrctx->errflag        = yyerrflag;
-            yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
-            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
-            yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
-            memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
-            memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
-#endif
-            yyerrctx->lexeme         = (int) (yylvp - yylvals);
-        }
-        yylvp          = yylvals   + save->lexeme;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-        yylpp          = yylpsns   + save->lexeme;
-#endif
-        yylexp         = yylexemes + save->lexeme;
-        yychar         = YYEMPTY;
-        yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
-        memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
-        yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
-        memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-        yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
-        memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
-#endif
-        ctry           = ++save->ctry;
-        yystate        = save->state;
-        /* We tried shift, try reduce now */
-        if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
-        yyps->save     = save->save;
-        save->save     = NULL;
-        yyFreeState(save);
-
-        /* Nothing left on the stack -- error */
-        if (!yyps->save)
-        {
-#if YYDEBUG
-            if (yydebug)
-                fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
-                                YYPREFIX, yydepth);
-#endif
-            /* Restore state as it was in the most forward-advanced error */
-            yylvp          = yylvals   + yyerrctx->lexeme;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            yylpp          = yylpsns   + yyerrctx->lexeme;
-#endif
-            yylexp         = yylexemes + yyerrctx->lexeme;
-            yychar         = yylexp[-1];
-            yylval         = yylvp[-1];
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            yylloc         = yylpp[-1];
-#endif
-            yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
-            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
-            yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
-            memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
-            memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
-#endif
-            yystate        = yyerrctx->state;
-            yyFreeState(yyerrctx);
-            yyerrctx       = NULL;
-        }
-        yynewerrflag = 1;
-    }
-    if (yynewerrflag == 0) goto yyinrecovery;
-#endif /* YYBTYACC */
-
-    YYERROR_CALL("syntax error");
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
-#endif
-
-#if !YYBTYACC
-    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
-yyerrlab:
-#endif
-    ++yynerrs;
-
-yyinrecovery:
-    if (yyerrflag < 3)
-    {
-        yyerrflag = 3;
-        for (;;)
-        {
-            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
-                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
-            {
-#if YYDEBUG
-                if (yydebug)
-                    fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
-                                    YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
-#endif
-                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
+                if (yystack.s_mark >= yystack.s_last &&
+                    yygrowstack (&yystack) == YYENOMEM)
+                        goto yyoverflow;
                 yystate = yytable[yyn];
                 *++yystack.s_mark = yytable[yyn];
                 *++yystack.l_mark = yylval;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                /* lookahead position is error end position */
-                yyerror_loc_range[2] = yylloc;
-                YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
-                *++yystack.p_mark = yyloc;
+                *++yystack.p_mark = yylloc;
 #endif
+                yychar = YYEMPTY;
+                if (yyerrflag > 0)
+                        --yyerrflag;
                 goto yyloop;
-            }
-            else
-            {
+        }
+        if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
+        {
+                yyn = yytable[yyn];
+                goto yyreduce;
+        }
+        if (yyerrflag != 0)
+                goto yyinrecovery;
+#if YYBTYACC
+
+        yynewerrflag = 1;
+        goto yyerrhandler;
+        goto yyerrlab; /* redundant goto avoids 'unused label' warning */
+
+yyerrlab:
+        /* explicit YYERROR from an action -- pop the rhs of the rule reduced
+         * before looking for error recovery */
+        yystack.s_mark -= yym;
+        yystate = *yystack.s_mark;
+        yystack.l_mark -= yym;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+        yystack.p_mark -= yym;
+#endif
+
+        yynewerrflag = 0;
+yyerrhandler:
+        while (yyps->save)
+        {
+                int ctry;
+                YYParseState *save = yyps->save;
 #if YYDEBUG
                 if (yydebug)
-                    fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
-                                    YYDEBUGSTR, yydepth, *yystack.s_mark);
+                        fprintf (
+                          stderr,
+                          "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
+                          YYDEBUGSTR,
+                          yydepth,
+                          yystate,
+                          yyps->save->state,
+                          (int) (yylvp - yylvals - yyps->save->lexeme));
+#endif
+                /* Memorize most forward-looking error state in case it's really
+                 * an error. */
+                if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
+                {
+                        /* Free old saved error context state */
+                        if (yyerrctx)
+                                yyFreeState (yyerrctx);
+                        /* Create and fill out new saved error context state */
+                        yyerrctx = yyNewState (
+                          (unsigned) (yystack.s_mark - yystack.s_base + 1));
+                        if (yyerrctx == NULL)
+                                goto yyenomem;
+                        yyerrctx->save = yyps->save;
+                        yyerrctx->state = yystate;
+                        yyerrctx->errflag = yyerrflag;
+                        yyerrctx->yystack.s_mark =
+                          yyerrctx->yystack.s_base +
+                          (yystack.s_mark - yystack.s_base);
+                        memcpy (yyerrctx->yystack.s_base,
+                                yystack.s_base,
+                                (size_t) (yystack.s_mark - yystack.s_base + 1) *
+                                  sizeof (YYINT));
+                        yyerrctx->yystack.l_mark =
+                          yyerrctx->yystack.l_base +
+                          (yystack.l_mark - yystack.l_base);
+                        memcpy (yyerrctx->yystack.l_base,
+                                yystack.l_base,
+                                (size_t) (yystack.l_mark - yystack.l_base + 1) *
+                                  sizeof (YYSTYPE));
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                        yyerrctx->yystack.p_mark =
+                          yyerrctx->yystack.p_base +
+                          (yystack.p_mark - yystack.p_base);
+                        memcpy (yyerrctx->yystack.p_base,
+                                yystack.p_base,
+                                (size_t) (yystack.p_mark - yystack.p_base + 1) *
+                                  sizeof (YYLTYPE));
+#endif
+                        yyerrctx->lexeme = (int) (yylvp - yylvals);
+                }
+                yylvp = yylvals + save->lexeme;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                yylpp = yylpsns + save->lexeme;
+#endif
+                yylexp = yylexemes + save->lexeme;
+                yychar = YYEMPTY;
+                yystack.s_mark = yystack.s_base +
+                                 (save->yystack.s_mark - save->yystack.s_base);
+                memcpy (yystack.s_base,
+                        save->yystack.s_base,
+                        (size_t) (yystack.s_mark - yystack.s_base + 1) *
+                          sizeof (YYINT));
+                yystack.l_mark = yystack.l_base +
+                                 (save->yystack.l_mark - save->yystack.l_base);
+                memcpy (yystack.l_base,
+                        save->yystack.l_base,
+                        (size_t) (yystack.l_mark - yystack.l_base + 1) *
+                          sizeof (YYSTYPE));
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                yystack.p_mark = yystack.p_base +
+                                 (save->yystack.p_mark - save->yystack.p_base);
+                memcpy (yystack.p_base,
+                        save->yystack.p_base,
+                        (size_t) (yystack.p_mark - yystack.p_base + 1) *
+                          sizeof (YYLTYPE));
+#endif
+                ctry = ++save->ctry;
+                yystate = save->state;
+                /* We tried shift, try reduce now */
+                if ((yyn = yyctable[ctry]) >= 0)
+                        goto yyreduce;
+                yyps->save = save->save;
+                save->save = NULL;
+                yyFreeState (save);
+
+                /* Nothing left on the stack -- error */
+                if (! yyps->save)
+                {
+#if YYDEBUG
+                        if (yydebug)
+                                fprintf (
+                                  stderr,
+                                  "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
+                                  YYPREFIX,
+                                  yydepth);
+#endif
+                        /* Restore state as it was in the most forward-advanced
+                         * error */
+                        yylvp = yylvals + yyerrctx->lexeme;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                        yylpp = yylpsns + yyerrctx->lexeme;
 #endif
-                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                        yylexp = yylexemes + yyerrctx->lexeme;
+                        yychar = yylexp[-1];
+                        yylval = yylvp[-1];
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                        yylloc = yylpp[-1];
+#endif
+                        yystack.s_mark =
+                          yystack.s_base +
+                          (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
+                        memcpy (yystack.s_base,
+                                yyerrctx->yystack.s_base,
+                                (size_t) (yystack.s_mark - yystack.s_base + 1) *
+                                  sizeof (YYINT));
+                        yystack.l_mark =
+                          yystack.l_base +
+                          (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
+                        memcpy (yystack.l_base,
+                                yyerrctx->yystack.l_base,
+                                (size_t) (yystack.l_mark - yystack.l_base + 1) *
+                                  sizeof (YYSTYPE));
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                        yystack.p_mark =
+                          yystack.p_base +
+                          (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
+                        memcpy (yystack.p_base,
+                                yyerrctx->yystack.p_base,
+                                (size_t) (yystack.p_mark - yystack.p_base + 1) *
+                                  sizeof (YYLTYPE));
+#endif
+                        yystate = yyerrctx->state;
+                        yyFreeState (yyerrctx);
+                        yyerrctx = NULL;
+                }
+                yynewerrflag = 1;
+        }
+        if (yynewerrflag == 0)
+                goto yyinrecovery;
+#endif /* YYBTYACC */
+
+        YYERROR_CALL ("syntax error");
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                /* the current TOS position is the error start position */
-                yyerror_loc_range[1] = *yystack.p_mark;
+        yyerror_loc_range[1] =
+          yylloc; /* lookahead position is error start position */
+#endif
+
+#if ! YYBTYACC
+        goto yyerrlab; /* redundant goto avoids 'unused label' warning */
+yyerrlab:
+#endif
+        ++yynerrs;
+
+yyinrecovery:
+        if (yyerrflag < 3)
+        {
+                yyerrflag = 3;
+                for (;;)
+                {
+                        if (((yyn = yysindex[*yystack.s_mark]) != 0) &&
+                            (yyn += YYERRCODE) >= 0 && yyn <= YYTABLESIZE &&
+                            yycheck[yyn] == (YYINT) YYERRCODE)
+                        {
+#if YYDEBUG
+                                if (yydebug)
+                                        fprintf (
+                                          stderr,
+                                          "%s[%d]: state %d, error recovery shifting to state %d\n",
+                                          YYDEBUGSTR,
+                                          yydepth,
+                                          *yystack.s_mark,
+                                          yytable[yyn]);
+#endif
+                                if (yystack.s_mark >= yystack.s_last &&
+                                    yygrowstack (&yystack) == YYENOMEM)
+                                        goto yyoverflow;
+                                yystate = yytable[yyn];
+                                *++yystack.s_mark = yytable[yyn];
+                                *++yystack.l_mark = yylval;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                /* lookahead position is error end position */
+                                yyerror_loc_range[2] = yylloc;
+                                YYLLOC_DEFAULT (yyloc,
+                                                yyerror_loc_range,
+                                                2); /* position of error span */
+                                *++yystack.p_mark = yyloc;
+#endif
+                                goto yyloop;
+                        }
+                        else
+                        {
+#if YYDEBUG
+                                if (yydebug)
+                                        fprintf (
+                                          stderr,
+                                          "%s[%d]: error recovery discarding state %d\n",
+                                          YYDEBUGSTR,
+                                          yydepth,
+                                          *yystack.s_mark);
+#endif
+                                if (yystack.s_mark <= yystack.s_base)
+                                        goto yyabort;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                /* the current TOS position is the error start
+                                 * position */
+                                yyerror_loc_range[1] = *yystack.p_mark;
 #endif
 #if defined(YYDESTRUCT_CALL)
 #if YYBTYACC
-                if (!yytrial)
+                                if (! yytrial)
 #endif /* YYBTYACC */
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                    YYDESTRUCT_CALL("error: discarding state",
-                                    yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
+                                        YYDESTRUCT_CALL ("error: discarding state",
+                                                         yystos[*yystack
+                                                                   .s_mark],
+                                                         yystack.l_mark,
+                                                         yystack.p_mark);
 #else
-                    YYDESTRUCT_CALL("error: discarding state",
-                                    yystos[*yystack.s_mark], yystack.l_mark);
+                                YYDESTRUCT_CALL ("error: discarding state",
+                                                 yystos[*yystack.s_mark],
+                                                 yystack.l_mark);
 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 #endif /* defined(YYDESTRUCT_CALL) */
-                --yystack.s_mark;
-                --yystack.l_mark;
+                                --yystack.s_mark;
+                                --yystack.l_mark;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                --yystack.p_mark;
+                                --yystack.p_mark;
 #endif
-            }
+                        }
+                }
         }
-    }
-    else
-    {
-        if (yychar == YYEOF) goto yyabort;
+        else
+        {
+                if (yychar == YYEOF)
+                        goto yyabort;
 #if YYDEBUG
-        if (yydebug)
-        {
-            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
-            fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
-                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
-        }
+                if (yydebug)
+                {
+                        if ((yys = yyname[YYTRANSLATE (yychar)]) == NULL)
+                                yys = yyname[YYUNDFTOKEN];
+                        fprintf (
+                          stderr,
+                          "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
+                          YYDEBUGSTR,
+                          yydepth,
+                          yystate,
+                          yychar,
+                          yys);
+                }
 #endif
 #if defined(YYDESTRUCT_CALL)
 #if YYBTYACC
-        if (!yytrial)
+                if (! yytrial)
 #endif /* YYBTYACC */
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
+                        YYDESTRUCT_CALL ("error: discarding token",
+                                         yychar,
+                                         &yylval,
+                                         &yylloc);
 #else
-            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
+                YYDESTRUCT_CALL ("error: discarding token", yychar, &yylval);
 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 #endif /* defined(YYDESTRUCT_CALL) */
-        yychar = YYEMPTY;
-        goto yyloop;
-    }
+                yychar = YYEMPTY;
+                goto yyloop;
+        }
 
 yyreduce:
-    yym = yylen[yyn];
-#if YYDEBUG
-    if (yydebug)
-    {
-        fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
-                        YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
-#ifdef YYSTYPE_TOSTRING
-#if YYBTYACC
-        if (!yytrial)
-#endif /* YYBTYACC */
-            if (yym > 0)
-            {
-                int i;
-                fputc('<', stderr);
-                for (i = yym; i > 0; i--)
-                {
-                    if (i != yym) fputs(", ", stderr);
-                    fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
-                                           yystack.l_mark[1-i]), stderr);
-                }
-                fputc('>', stderr);
-            }
-#endif
-        fputc('\n', stderr);
-    }
-#endif
-    if (yym > 0)
-        yyval = yystack.l_mark[1-yym];
-    else
-        memset(&yyval, 0, sizeof yyval);
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-
-    /* Perform position reduction */
-    memset(&yyloc, 0, sizeof(yyloc));
-#if YYBTYACC
-    if (!yytrial)
-#endif /* YYBTYACC */
-    {
-        YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
-        /* just in case YYERROR is invoked within the action, save
-           the start of the rhs as the error start position */
-        yyerror_loc_range[1] = yystack.p_mark[1-yym];
-    }
-#endif
-
-    switch (yyn)
-    {
-case 3:
-#line 124 "gram.y"
-	{ yyerrok; }
-break;
-case 6:
-#line 129 "gram.y"
-	{ Lineno++; }
-break;
-case 8:
-#line 133 "gram.y"
-	{ Lineno++; }
-break;
-case 10:
-#line 138 "gram.y"
-	{
-			    switch (KeywordTable[yystack.l_mark[-2].ival].type) {
-			        case IsString:
-			            if (yystack.l_mark[0].ival == C_STRING) {
-			                strcpy(KeywordTable[yystack.l_mark[-2].ival].sptr,
-			                        yylval.sval);
-			            } else {
-			                yyerror("illegal construct");
-			            }
-			            free(yylval.sval);
-			            break;
-			        case IsNumeric:
-			            if (yystack.l_mark[0].ival == C_STRING) {
-			                *(KeywordTable[yystack.l_mark[-2].ival].nptr) =
-			                                   y_atoi(yylval.sval);
-			            } else yyerror("illegal construct");
-			            free(yylval.sval);
-			            break;
-			        case IsBoolTrue:
-			        case IsBoolFalse:
-			            yyerror("illegal value assignment");
-			            break;
-			        case IsQuitFunction:
-			        case IsFunction:
-			            if (yystack.l_mark[0].ival == C_MAP) {
-			                bindtofunc(yystack.l_mark[-2].ival, bkmask, cmask, NULL);
-			            } else yyerror("illegal construct");
-			            break;
-			        case IsDownFunction:
-			            if (bkmask & ButtonUp) {
-			                sprintf(msg,
-			                        "cannot bind %s to button up",
-			                        KeywordTable[yystack.l_mark[-2].ival].name);
-			                yyerror(msg);
-			            }
-			            if (yystack.l_mark[0].ival == C_MAP) {
-			                bindtofunc(yystack.l_mark[-2].ival, bkmask, cmask, NULL);
-			            } else yyerror("illegal construct");
-			            break;
-			        case IsMenuMap:
-			            if (bkmask & ButtonUp) {
-			                sprintf(msg,
-			                        "cannot bind %s to button up",
-			                        KeywordTable[yystack.l_mark[-2].ival].name);
-			                yyerror(msg);
-			            }
-			            if (yystack.l_mark[0].ival == C_MENUMAP) {
-			                bindtofunc(yystack.l_mark[-2].ival, bkmask, cmask, menu_name);
-			            } else yyerror("illegal construct");
-			            break;
-			        case IsMenu:
-			            if (yystack.l_mark[0].ival == C_MENU) {
-			                menu_info = stashmenuinfo(menu_name, ml_ptr, hcolors);
-			                menu_link = stashmenulink(menu_info);
-			                Menus = appendmenulink(Menus, menu_link);
-			            } else yyerror("illegal menu construct");
-			            break;
-			        default:
-			            yyerror("internal binding error");
-			            break;
-			    }
-			}
-break;
-case 11:
-#line 203 "gram.y"
-	{
-			    yyval.ival = C_MAP;
-			    bkmask = yystack.l_mark[-4].ival | yystack.l_mark[0].ival;
-			    cmask = yystack.l_mark[-2].ival;
-			}
-break;
-case 12:
-#line 209 "gram.y"
-	{
-			    yyval.ival = C_MENUMAP;
-			    bkmask = yystack.l_mark[-6].ival | yystack.l_mark[-2].ival;
-			    cmask = yystack.l_mark[-4].ival;
-			    menu_name = yystack.l_mark[0].sval;
-			}
-break;
-case 13:
-#line 216 "gram.y"
-	{
-			    yyval.ival = C_MENU;
-			    menu_name = yystack.l_mark[-2].sval;
-			    ml_ptr = yystack.l_mark[0].mlval;
-			}
-break;
-case 14:
-#line 222 "gram.y"
-	{ yyval.ival = C_STRING; }
-break;
-case 15:
-#line 226 "gram.y"
-	{
-			    ki = keywordlookup(yylval.sval);
-			    switch (KeywordTable[ki].type) {
-			    case IsBoolTrue:
-			        *(KeywordTable[ki].bptr) = TRUE;
-			        break;
-			    case IsBoolFalse:
-			        *(KeywordTable[ki].bptr) = FALSE;
-			        break;
-			    case IsParser:
-			        (*KeywordTable[ki].fptr)();
-			        break;
-			    default:
-			        yyerror("keyword error");
-			    }
-			}
-break;
-case 16:
-#line 244 "gram.y"
-	{
-			    yyval.ival = keywordlookup(yylval.sval);
-			}
-break;
-case 17:
-#line 250 "gram.y"
-	{ yyval.ival = 0; }
-break;
-case 18:
-#line 252 "gram.y"
-	{ yyval.ival = yystack.l_mark[0].ival; }
-break;
-case 19:
-#line 254 "gram.y"
-	{ yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
-break;
-case 20:
-#line 258 "gram.y"
-	{ yyval.ival = ROOT | WINDOW | ICON; }
-break;
-case 21:
-#line 260 "gram.y"
-	{ yyval.ival = yystack.l_mark[0].ival; }
-break;
-case 22:
-#line 262 "gram.y"
-	{ yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
-break;
-case 23:
-#line 266 "gram.y"
-	{ yyval.ival = CheckButtonState(yystack.l_mark[0].ival); }
-break;
-case 24:
-#line 269 "gram.y"
-	{ yyval.ival = keyexprlookup(yylval.sval); }
-break;
-case 25:
-#line 271 "gram.y"
-	{ yyval.ival = contexprlookup(yylval.sval); }
-break;
-case 26:
-#line 274 "gram.y"
-	{ yyval.ival = yystack.l_mark[0].ival; }
-break;
-case 27:
-#line 276 "gram.y"
-	{ yyval.ival = yystack.l_mark[-1].ival | yystack.l_mark[0].ival; }
-break;
-case 28:
-#line 280 "gram.y"
-	{ yyval.ival = buttexprlookup(yylval.sval); }
-break;
-case 29:
-#line 284 "gram.y"
-	{ yyval.sval = yystack.l_mark[0].sval; }
-break;
-case 30:
-#line 288 "gram.y"
-	{ yyval.mlval = yystack.l_mark[-1].mlval; }
-break;
-case 31:
-#line 292 "gram.y"
-	{ yyval.mlval = yystack.l_mark[0].mlval; }
-break;
-case 32:
-#line 294 "gram.y"
-	{ yyval.mlval = appendmenuline(yystack.l_mark[-1].mlval, yystack.l_mark[0].mlval); }
-break;
-case 33:
-#line 296 "gram.y"
-	{
-			    Lineno++;
-			    yyval.mlval = yystack.l_mark[-1].mlval;
-			}
-break;
-case 34:
-#line 301 "gram.y"
-	{
-			    Lineno++;
-			    yyval.mlval = NULL;
-			}
-break;
-case 35:
-#line 306 "gram.y"
-	{ yyval.mlval = NULL; }
-break;
-case 36:
-#line 308 "gram.y"
-	{ yyval.mlval = yystack.l_mark[-1].mlval; }
-break;
-case 37:
-#line 310 "gram.y"
-	{
-			  yyval.mlval = NULL;
-			  yyerrok;
-			}
-break;
-case 38:
-#line 317 "gram.y"
-	{
-			    yystack.l_mark[-1].mlval->name = yystack.l_mark[-4].sval;
-			    yystack.l_mark[-1].mlval->foreground = mcolors[0];
-			    yystack.l_mark[-1].mlval->background = mcolors[1];
-			    yyval.mlval = yystack.l_mark[-1].mlval;
-			}
-break;
-case 39:
-#line 326 "gram.y"
-	{
-			    ki = keywordlookup(yylval.sval);
-			    if ((ki != -1) &&
-			        (KeywordTable[ki].type != IsFunction) &&
-			        (KeywordTable[ki].type != IsQuitFunction) &&
-			        (KeywordTable[ki].type != IsDownFunction)) {
-			        sprintf(msg,
-			                "menu action \"%s\" not a function",
-				        KeywordTable[ki].name);
-			        yyerror(msg);
-			    }
-			    ml_ptr = AllocMenuLine();
-			    if (KeywordTable[ki].type == IsQuitFunction)
-			        ml_ptr->type = IsImmFunction;
-			    else ml_ptr->type = IsUwmFunction;
-			    ml_ptr->func = KeywordTable[ki].fptr;
-			    yyval.mlval = ml_ptr;
-			}
-break;
-case 40:
-#line 345 "gram.y"
-	{
-			    ki = keywordlookup(yystack.l_mark[-2].sval);
-			    if (ki != -1 &&
-			        KeywordTable[ki].type != IsMenuMap) {
-			        sprintf(msg,
-			               "menu action \"%s\" not a menu function",
-				        KeywordTable[ki].name);
-			        yyerror(msg);
-			    }
-			    ml_ptr = AllocMenuLine();
-			    ml_ptr->type = IsMenuFunction;
-			    ml_ptr->text = yystack.l_mark[0].sval;
-			    yyval.mlval = ml_ptr;
-			}
-break;
-case 41:
-#line 360 "gram.y"
-	{
-			    yyval.mlval = StashMenuLine(IsShellCommand, yystack.l_mark[0].sval);
-			}
-break;
-case 42:
-#line 364 "gram.y"
-	{
-			    yyval.mlval = StashMenuLine(IsTextNL, yystack.l_mark[0].sval);
-			}
-break;
-case 43:
-#line 368 "gram.y"
-	{
-			    yyval.mlval = StashMenuLine(IsText, yystack.l_mark[0].sval);
-			}
-break;
-case 44:
-#line 373 "gram.y"
-	{ yyval.sval = yylval.sval; }
-break;
-case 45:
-#line 375 "gram.y"
-	{ yyval.sval = strconcat(yystack.l_mark[-1].sval, yystack.l_mark[0].sval); }
-break;
-case 46:
-#line 379 "gram.y"
-	{
-			    hcolors[0] = yystack.l_mark[-7].sval;
-			    hcolors[1] = yystack.l_mark[-5].sval;
-			    hcolors[2] = yystack.l_mark[-3].sval;
-			    hcolors[3] = yystack.l_mark[-1].sval;
-			    yyval.cval = hcolors;
-			}
-break;
-case 47:
-#line 387 "gram.y"
-	{
-			    hcolors[0] = NULL;
-			    hcolors[1] = NULL;
-			    hcolors[2] = NULL;
-			    hcolors[3] = NULL;
-			    yyval.cval = hcolors;
-			}
-break;
-case 48:
-#line 397 "gram.y"
-	{
-			    mcolors[0] = yystack.l_mark[-4].sval;
-			    mcolors[1] = yystack.l_mark[-2].sval;
-			    yyval.cval = mcolors;
-			}
-break;
-case 49:
-#line 403 "gram.y"
-	{
-			    mcolors[0] = NULL;
-			    mcolors[1] = NULL;
-			    yyval.cval = mcolors;
-			}
-break;
-case 50:
-#line 410 "gram.y"
-	{ yyval.sval = yylval.sval; }
-break;
-case 51:
-#line 411 "gram.y"
-	{ yyval.sval = NULL; }
-break;
-#line 1959 "y.tab.c"
-    default:
-        break;
-    }
-    yystack.s_mark -= yym;
-    yystate = *yystack.s_mark;
-    yystack.l_mark -= yym;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    yystack.p_mark -= yym;
-#endif
-    yym = yylhs[yyn];
-    if (yystate == 0 && yym == 0)
-    {
+        yym = yylen[yyn];
 #if YYDEBUG
         if (yydebug)
         {
-            fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
+                fprintf (stderr,
+                         "%s[%d]: state %d, reducing by rule %d (%s)",
+                         YYDEBUGSTR,
+                         yydepth,
+                         yystate,
+                         yyn,
+                         yyrule[yyn]);
 #ifdef YYSTYPE_TOSTRING
 #if YYBTYACC
-            if (!yytrial)
+                if (! yytrial)
 #endif /* YYBTYACC */
-                fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
+                        if (yym > 0)
+                        {
+                                int i;
+                                fputc ('<', stderr);
+                                for (i = yym; i > 0; i--)
+                                {
+                                        if (i != yym)
+                                                fputs (", ", stderr);
+                                        fputs (YYSTYPE_TOSTRING (yystos
+                                                                   [yystack
+                                                                      .s_mark
+                                                                        [1 -
+                                                                         i]],
+                                                                 yystack
+                                                                   .l_mark[1 -
+                                                                           i]),
+                                               stderr);
+                                }
+                                fputc ('>', stderr);
+                        }
 #endif
-            fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
+                fputc ('\n', stderr);
+        }
+#endif
+        if (yym > 0)
+                yyval = yystack.l_mark[1 - yym];
+        else
+                memset (&yyval, 0, sizeof yyval);
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+
+        /* Perform position reduction */
+        memset (&yyloc, 0, sizeof (yyloc));
+#if YYBTYACC
+        if (! yytrial)
+#endif /* YYBTYACC */
+        {
+                YYLLOC_DEFAULT (yyloc, &yystack.p_mark[-yym], yym);
+                /* just in case YYERROR is invoked within the action, save
+                   the start of the rhs as the error start position */
+                yyerror_loc_range[1] = yystack.p_mark[1 - yym];
         }
 #endif
-        yystate = YYFINAL;
-        *++yystack.s_mark = YYFINAL;
+
+        switch (yyn)
+        {
+        case 3:
+#line 124 "gram.y"
+        {
+                yyerrok;
+        }
+        break;
+        case 6:
+#line 129 "gram.y"
+        {
+                Lineno++;
+        }
+        break;
+        case 8:
+#line 133 "gram.y"
+        {
+                Lineno++;
+        }
+        break;
+        case 10:
+#line 138 "gram.y"
+        {
+                switch (KeywordTable[yystack.l_mark[-2].ival].type)
+                {
+                case IsString:
+                        if (yystack.l_mark[0].ival == C_STRING)
+                        {
+                                strcpy (KeywordTable[yystack.l_mark[-2].ival]
+                                          .sptr,
+                                        yylval.sval);
+                        }
+                        else
+                        {
+                                yyerror ("illegal construct");
+                        }
+                        free (yylval.sval);
+                        break;
+                case IsNumeric:
+                        if (yystack.l_mark[0].ival == C_STRING)
+                        {
+                                *(KeywordTable[yystack.l_mark[-2].ival].nptr) =
+                                  y_atoi (yylval.sval);
+                        }
+                        else
+                                yyerror ("illegal construct");
+                        free (yylval.sval);
+                        break;
+                case IsBoolTrue:
+                case IsBoolFalse:
+                        yyerror ("illegal value assignment");
+                        break;
+                case IsQuitFunction:
+                case IsFunction:
+                        if (yystack.l_mark[0].ival == C_MAP)
+                        {
+                                bindtofunc (yystack.l_mark[-2].ival,
+                                            bkmask,
+                                            cmask,
+                                            NULL);
+                        }
+                        else
+                                yyerror ("illegal construct");
+                        break;
+                case IsDownFunction:
+                        if (bkmask & ButtonUp)
+                        {
+                                sprintf (msg,
+                                         "cannot bind %s to button up",
+                                         KeywordTable[yystack.l_mark[-2].ival]
+                                           .name);
+                                yyerror (msg);
+                        }
+                        if (yystack.l_mark[0].ival == C_MAP)
+                        {
+                                bindtofunc (yystack.l_mark[-2].ival,
+                                            bkmask,
+                                            cmask,
+                                            NULL);
+                        }
+                        else
+                                yyerror ("illegal construct");
+                        break;
+                case IsMenuMap:
+                        if (bkmask & ButtonUp)
+                        {
+                                sprintf (msg,
+                                         "cannot bind %s to button up",
+                                         KeywordTable[yystack.l_mark[-2].ival]
+                                           .name);
+                                yyerror (msg);
+                        }
+                        if (yystack.l_mark[0].ival == C_MENUMAP)
+                        {
+                                bindtofunc (yystack.l_mark[-2].ival,
+                                            bkmask,
+                                            cmask,
+                                            menu_name);
+                        }
+                        else
+                                yyerror ("illegal construct");
+                        break;
+                case IsMenu:
+                        if (yystack.l_mark[0].ival == C_MENU)
+                        {
+                                menu_info =
+                                  stashmenuinfo (menu_name, ml_ptr, hcolors);
+                                menu_link = stashmenulink (menu_info);
+                                Menus = appendmenulink (Menus, menu_link);
+                        }
+                        else
+                                yyerror ("illegal menu construct");
+                        break;
+                default:
+                        yyerror ("internal binding error");
+                        break;
+                }
+        }
+        break;
+        case 11:
+#line 203 "gram.y"
+        {
+                yyval.ival = C_MAP;
+                bkmask = yystack.l_mark[-4].ival | yystack.l_mark[0].ival;
+                cmask = yystack.l_mark[-2].ival;
+        }
+        break;
+        case 12:
+#line 209 "gram.y"
+        {
+                yyval.ival = C_MENUMAP;
+                bkmask = yystack.l_mark[-6].ival | yystack.l_mark[-2].ival;
+                cmask = yystack.l_mark[-4].ival;
+                menu_name = yystack.l_mark[0].sval;
+        }
+        break;
+        case 13:
+#line 216 "gram.y"
+        {
+                yyval.ival = C_MENU;
+                menu_name = yystack.l_mark[-2].sval;
+                ml_ptr = yystack.l_mark[0].mlval;
+        }
+        break;
+        case 14:
+#line 222 "gram.y"
+        {
+                yyval.ival = C_STRING;
+        }
+        break;
+        case 15:
+#line 226 "gram.y"
+        {
+                ki = keywordlookup (yylval.sval);
+                switch (KeywordTable[ki].type)
+                {
+                case IsBoolTrue:
+                        *(KeywordTable[ki].bptr) = TRUE;
+                        break;
+                case IsBoolFalse:
+                        *(KeywordTable[ki].bptr) = FALSE;
+                        break;
+                case IsParser:
+                        (*KeywordTable[ki].fptr) ();
+                        break;
+                default:
+                        yyerror ("keyword error");
+                }
+        }
+        break;
+        case 16:
+#line 244 "gram.y"
+        {
+                yyval.ival = keywordlookup (yylval.sval);
+        }
+        break;
+        case 17:
+#line 250 "gram.y"
+        {
+                yyval.ival = 0;
+        }
+        break;
+        case 18:
+#line 252 "gram.y"
+        {
+                yyval.ival = yystack.l_mark[0].ival;
+        }
+        break;
+        case 19:
+#line 254 "gram.y"
+        {
+                yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival;
+        }
+        break;
+        case 20:
+#line 258 "gram.y"
+        {
+                yyval.ival = ROOT | WINDOW | ICON;
+        }
+        break;
+        case 21:
+#line 260 "gram.y"
+        {
+                yyval.ival = yystack.l_mark[0].ival;
+        }
+        break;
+        case 22:
+#line 262 "gram.y"
+        {
+                yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival;
+        }
+        break;
+        case 23:
+#line 266 "gram.y"
+        {
+                yyval.ival = CheckButtonState (yystack.l_mark[0].ival);
+        }
+        break;
+        case 24:
+#line 269 "gram.y"
+        {
+                yyval.ival = keyexprlookup (yylval.sval);
+        }
+        break;
+        case 25:
+#line 271 "gram.y"
+        {
+                yyval.ival = contexprlookup (yylval.sval);
+        }
+        break;
+        case 26:
+#line 274 "gram.y"
+        {
+                yyval.ival = yystack.l_mark[0].ival;
+        }
+        break;
+        case 27:
+#line 276 "gram.y"
+        {
+                yyval.ival = yystack.l_mark[-1].ival | yystack.l_mark[0].ival;
+        }
+        break;
+        case 28:
+#line 280 "gram.y"
+        {
+                yyval.ival = buttexprlookup (yylval.sval);
+        }
+        break;
+        case 29:
+#line 284 "gram.y"
+        {
+                yyval.sval = yystack.l_mark[0].sval;
+        }
+        break;
+        case 30:
+#line 288 "gram.y"
+        {
+                yyval.mlval = yystack.l_mark[-1].mlval;
+        }
+        break;
+        case 31:
+#line 292 "gram.y"
+        {
+                yyval.mlval = yystack.l_mark[0].mlval;
+        }
+        break;
+        case 32:
+#line 294 "gram.y"
+        {
+                yyval.mlval = appendmenuline (yystack.l_mark[-1].mlval,
+                                              yystack.l_mark[0].mlval);
+        }
+        break;
+        case 33:
+#line 296 "gram.y"
+        {
+                Lineno++;
+                yyval.mlval = yystack.l_mark[-1].mlval;
+        }
+        break;
+        case 34:
+#line 301 "gram.y"
+        {
+                Lineno++;
+                yyval.mlval = NULL;
+        }
+        break;
+        case 35:
+#line 306 "gram.y"
+        {
+                yyval.mlval = NULL;
+        }
+        break;
+        case 36:
+#line 308 "gram.y"
+        {
+                yyval.mlval = yystack.l_mark[-1].mlval;
+        }
+        break;
+        case 37:
+#line 310 "gram.y"
+        {
+                yyval.mlval = NULL;
+                yyerrok;
+        }
+        break;
+        case 38:
+#line 317 "gram.y"
+        {
+                yystack.l_mark[-1].mlval->name = yystack.l_mark[-4].sval;
+                yystack.l_mark[-1].mlval->foreground = mcolors[0];
+                yystack.l_mark[-1].mlval->background = mcolors[1];
+                yyval.mlval = yystack.l_mark[-1].mlval;
+        }
+        break;
+        case 39:
+#line 326 "gram.y"
+        {
+                ki = keywordlookup (yylval.sval);
+                if ((ki != -1) && (KeywordTable[ki].type != IsFunction) &&
+                    (KeywordTable[ki].type != IsQuitFunction) &&
+                    (KeywordTable[ki].type != IsDownFunction))
+                {
+                        sprintf (msg,
+                                 "menu action \"%s\" not a function",
+                                 KeywordTable[ki].name);
+                        yyerror (msg);
+                }
+                ml_ptr = AllocMenuLine ();
+                if (KeywordTable[ki].type == IsQuitFunction)
+                        ml_ptr->type = IsImmFunction;
+                else
+                        ml_ptr->type = IsUwmFunction;
+                ml_ptr->func = KeywordTable[ki].fptr;
+                yyval.mlval = ml_ptr;
+        }
+        break;
+        case 40:
+#line 345 "gram.y"
+        {
+                ki = keywordlookup (yystack.l_mark[-2].sval);
+                if (ki != -1 && KeywordTable[ki].type != IsMenuMap)
+                {
+                        sprintf (msg,
+                                 "menu action \"%s\" not a menu function",
+                                 KeywordTable[ki].name);
+                        yyerror (msg);
+                }
+                ml_ptr = AllocMenuLine ();
+                ml_ptr->type = IsMenuFunction;
+                ml_ptr->text = yystack.l_mark[0].sval;
+                yyval.mlval = ml_ptr;
+        }
+        break;
+        case 41:
+#line 360 "gram.y"
+        {
+                yyval.mlval =
+                  StashMenuLine (IsShellCommand, yystack.l_mark[0].sval);
+        }
+        break;
+        case 42:
+#line 364 "gram.y"
+        {
+                yyval.mlval = StashMenuLine (IsTextNL, yystack.l_mark[0].sval);
+        }
+        break;
+        case 43:
+#line 368 "gram.y"
+        {
+                yyval.mlval = StashMenuLine (IsText, yystack.l_mark[0].sval);
+        }
+        break;
+        case 44:
+#line 373 "gram.y"
+        {
+                yyval.sval = yylval.sval;
+        }
+        break;
+        case 45:
+#line 375 "gram.y"
+        {
+                yyval.sval =
+                  strconcat (yystack.l_mark[-1].sval, yystack.l_mark[0].sval);
+        }
+        break;
+        case 46:
+#line 379 "gram.y"
+        {
+                hcolors[0] = yystack.l_mark[-7].sval;
+                hcolors[1] = yystack.l_mark[-5].sval;
+                hcolors[2] = yystack.l_mark[-3].sval;
+                hcolors[3] = yystack.l_mark[-1].sval;
+                yyval.cval = hcolors;
+        }
+        break;
+        case 47:
+#line 387 "gram.y"
+        {
+                hcolors[0] = NULL;
+                hcolors[1] = NULL;
+                hcolors[2] = NULL;
+                hcolors[3] = NULL;
+                yyval.cval = hcolors;
+        }
+        break;
+        case 48:
+#line 397 "gram.y"
+        {
+                mcolors[0] = yystack.l_mark[-4].sval;
+                mcolors[1] = yystack.l_mark[-2].sval;
+                yyval.cval = mcolors;
+        }
+        break;
+        case 49:
+#line 403 "gram.y"
+        {
+                mcolors[0] = NULL;
+                mcolors[1] = NULL;
+                yyval.cval = mcolors;
+        }
+        break;
+        case 50:
+#line 410 "gram.y"
+        {
+                yyval.sval = yylval.sval;
+        }
+        break;
+        case 51:
+#line 411 "gram.y"
+        {
+                yyval.sval = NULL;
+        }
+        break;
+#line 1959 "y.tab.c"
+        default:
+                break;
+        }
+        yystack.s_mark -= yym;
+        yystate = *yystack.s_mark;
+        yystack.l_mark -= yym;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+        yystack.p_mark -= yym;
+#endif
+        yym = yylhs[yyn];
+        if (yystate == 0 && yym == 0)
+        {
+#if YYDEBUG
+                if (yydebug)
+                {
+                        fprintf (stderr,
+                                 "%s[%d]: after reduction, ",
+                                 YYDEBUGSTR,
+                                 yydepth);
+#ifdef YYSTYPE_TOSTRING
+#if YYBTYACC
+                        if (! yytrial)
+#endif /* YYBTYACC */
+                                fprintf (stderr,
+                                         "result is <%s>, ",
+                                         YYSTYPE_TOSTRING (yystos[YYFINAL],
+                                                           yyval));
+#endif
+                        fprintf (stderr,
+                                 "shifting from state 0 to final state %d\n",
+                                 YYFINAL);
+                }
+#endif
+                yystate = YYFINAL;
+                *++yystack.s_mark = YYFINAL;
+                *++yystack.l_mark = yyval;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                *++yystack.p_mark = yyloc;
+#endif
+                if (yychar < 0)
+                {
+#if YYBTYACC
+                        do
+                        {
+                                if (yylvp < yylve)
+                                {
+                                        /* we're currently re-reading tokens */
+                                        yylval = *yylvp++;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                        yylloc = *yylpp++;
+#endif
+                                        yychar = *yylexp++;
+                                        break;
+                                }
+                                if (yyps->save)
+                                {
+                                        /* in trial mode; save scanner results
+                                         * for future parse attempts */
+                                        if (yylvp == yylvlim)
+                                        { /* Enlarge lexical value queue */
+                                                size_t p =
+                                                  (size_t) (yylvp - yylvals);
+                                                size_t s =
+                                                  (size_t) (yylvlim - yylvals);
+
+                                                s += YYLVQUEUEGROWTH;
+                                                if ((yylexemes = (YYINT *)
+                                                       realloc (yylexemes,
+                                                                s *
+                                                                  sizeof (
+                                                                    YYINT))) ==
+                                                    NULL)
+                                                        goto yyenomem;
+                                                if (
+                                                  (yylvals = (YYSTYPE *)
+                                                     realloc (yylvals,
+                                                              s *
+                                                                sizeof (
+                                                                  YYSTYPE))) ==
+                                                  NULL)
+                                                        goto yyenomem;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                                if (
+                                                  (yylpsns = (YYLTYPE *)
+                                                     realloc (yylpsns,
+                                                              s *
+                                                                sizeof (
+                                                                  YYLTYPE))) ==
+                                                  NULL)
+                                                        goto yyenomem;
+#endif
+                                                yylvp = yylve = yylvals + p;
+                                                yylvlim = yylvals + s;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                                yylpp = yylpe = yylpsns + p;
+                                                yylplim = yylpsns + s;
+#endif
+                                                yylexp = yylexemes + p;
+                                        }
+                                        *yylexp = (YYINT) YYLEX;
+                                        *yylvp++ = yylval;
+                                        yylve++;
+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
+                                        *yylpp++ = yylloc;
+                                        yylpe++;
+#endif
+                                        yychar = *yylexp++;
+                                        break;
+                                }
+                                /* normal operation, no conflict encountered */
+#endif /* YYBTYACC */
+                                yychar = YYLEX;
+#if YYBTYACC
+                        } while (0);
+#endif /* YYBTYACC */
+                        if (yychar < 0)
+                                yychar = YYEOF;
+#if YYDEBUG
+                        if (yydebug)
+                        {
+                                if ((yys = yyname[YYTRANSLATE (yychar)]) ==
+                                    NULL)
+                                        yys = yyname[YYUNDFTOKEN];
+                                fprintf (stderr,
+                                         "%s[%d]: state %d, reading token %d (%s)\n",
+                                         YYDEBUGSTR,
+                                         yydepth,
+                                         YYFINAL,
+                                         yychar,
+                                         yys);
+                        }
+#endif
+                }
+                if (yychar == YYEOF)
+                        goto yyaccept;
+                goto yyloop;
+        }
+        if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
+                yystate = yytable[yyn];
+        else
+                yystate = yydgoto[yym];
+#if YYDEBUG
+        if (yydebug)
+        {
+                fprintf (stderr,
+                         "%s[%d]: after reduction, ",
+                         YYDEBUGSTR,
+                         yydepth);
+#ifdef YYSTYPE_TOSTRING
+#if YYBTYACC
+                if (! yytrial)
+#endif /* YYBTYACC */
+                        fprintf (stderr,
+                                 "result is <%s>, ",
+                                 YYSTYPE_TOSTRING (yystos[yystate], yyval));
+#endif
+                fprintf (stderr,
+                         "shifting from state %d to state %d\n",
+                         *yystack.s_mark,
+                         yystate);
+        }
+#endif
+        if (yystack.s_mark >= yystack.s_last &&
+            yygrowstack (&yystack) == YYENOMEM)
+                goto yyoverflow;
+        *++yystack.s_mark = (YYINT) yystate;
         *++yystack.l_mark = yyval;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
         *++yystack.p_mark = yyloc;
 #endif
-        if (yychar < 0)
-        {
-#if YYBTYACC
-            do {
-            if (yylvp < yylve)
-            {
-                /* we're currently re-reading tokens */
-                yylval = *yylvp++;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                yylloc = *yylpp++;
-#endif
-                yychar = *yylexp++;
-                break;
-            }
-            if (yyps->save)
-            {
-                /* in trial mode; save scanner results for future parse attempts */
-                if (yylvp == yylvlim)
-                {   /* Enlarge lexical value queue */
-                    size_t p = (size_t) (yylvp - yylvals);
-                    size_t s = (size_t) (yylvlim - yylvals);
-
-                    s += YYLVQUEUEGROWTH;
-                    if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
-                        goto yyenomem;
-                    if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
-                        goto yyenomem;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                    if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
-                        goto yyenomem;
-#endif
-                    yylvp   = yylve = yylvals + p;
-                    yylvlim = yylvals + s;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                    yylpp   = yylpe = yylpsns + p;
-                    yylplim = yylpsns + s;
-#endif
-                    yylexp  = yylexemes + p;
-                }
-                *yylexp = (YYINT) YYLEX;
-                *yylvp++ = yylval;
-                yylve++;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                *yylpp++ = yylloc;
-                yylpe++;
-#endif
-                yychar = *yylexp++;
-                break;
-            }
-            /* normal operation, no conflict encountered */
-#endif /* YYBTYACC */
-            yychar = YYLEX;
-#if YYBTYACC
-            } while (0);
-#endif /* YYBTYACC */
-            if (yychar < 0) yychar = YYEOF;
-#if YYDEBUG
-            if (yydebug)
-            {
-                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
-                fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
-                                YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
-            }
-#endif
-        }
-        if (yychar == YYEOF) goto yyaccept;
         goto yyloop;
-    }
-    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
-            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
-        yystate = yytable[yyn];
-    else
-        yystate = yydgoto[yym];
-#if YYDEBUG
-    if (yydebug)
-    {
-        fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
-#ifdef YYSTYPE_TOSTRING
-#if YYBTYACC
-        if (!yytrial)
-#endif /* YYBTYACC */
-            fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
-#endif
-        fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
-    }
-#endif
-    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
-    *++yystack.s_mark = (YYINT) yystate;
-    *++yystack.l_mark = yyval;
-#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    *++yystack.p_mark = yyloc;
-#endif
-    goto yyloop;
 #if YYBTYACC
 
-    /* Reduction declares that this path is valid. Set yypath and do a full parse */
+        /* Reduction declares that this path is valid. Set yypath and do a full
+         * parse */
 yyvalid:
-    if (yypath) YYABORT;
-    while (yyps->save)
-    {
-        YYParseState *save = yyps->save;
-        yyps->save = save->save;
-        save->save = yypath;
-        yypath = save;
-    }
+        if (yypath)
+                YYABORT;
+        while (yyps->save)
+        {
+                YYParseState *save = yyps->save;
+                yyps->save = save->save;
+                save->save = yypath;
+                yypath = save;
+        }
 #if YYDEBUG
-    if (yydebug)
-        fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
-                        YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
+        if (yydebug)
+                fprintf (
+                  stderr,
+                  "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
+                  YYDEBUGSTR,
+                  yydepth,
+                  yystate,
+                  yypath->state,
+                  (int) (yylvp - yylvals - yypath->lexeme));
 #endif
-    if (yyerrctx)
-    {
-        yyFreeState(yyerrctx);
-        yyerrctx = NULL;
-    }
-    yylvp          = yylvals + yypath->lexeme;
+        if (yyerrctx)
+        {
+                yyFreeState (yyerrctx);
+                yyerrctx = NULL;
+        }
+        yylvp = yylvals + yypath->lexeme;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    yylpp          = yylpsns + yypath->lexeme;
+        yylpp = yylpsns + yypath->lexeme;
 #endif
-    yylexp         = yylexemes + yypath->lexeme;
-    yychar         = YYEMPTY;
-    yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
-    memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
-    yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
-    memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
+        yylexp = yylexemes + yypath->lexeme;
+        yychar = YYEMPTY;
+        yystack.s_mark =
+          yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
+        memcpy (yystack.s_base,
+                yypath->yystack.s_base,
+                (size_t) (yystack.s_mark - yystack.s_base + 1) *
+                  sizeof (YYINT));
+        yystack.l_mark =
+          yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
+        memcpy (yystack.l_base,
+                yypath->yystack.l_base,
+                (size_t) (yystack.l_mark - yystack.l_base + 1) *
+                  sizeof (YYSTYPE));
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-    yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
-    memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
+        yystack.p_mark =
+          yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
+        memcpy (yystack.p_base,
+                yypath->yystack.p_base,
+                (size_t) (yystack.p_mark - yystack.p_base + 1) *
+                  sizeof (YYLTYPE));
 #endif
-    yystate        = yypath->state;
-    goto yyloop;
+        yystate = yypath->state;
+        goto yyloop;
 #endif /* YYBTYACC */
 
 yyoverflow:
-    YYERROR_CALL("yacc stack overflow");
+        YYERROR_CALL ("yacc stack overflow");
 #if YYBTYACC
-    goto yyabort_nomem;
+        goto yyabort_nomem;
 yyenomem:
-    YYERROR_CALL("memory exhausted");
+        YYERROR_CALL ("memory exhausted");
 yyabort_nomem:
 #endif /* YYBTYACC */
-    yyresult = 2;
-    goto yyreturn;
+        yyresult = 2;
+        goto yyreturn;
 
 yyabort:
-    yyresult = 1;
-    goto yyreturn;
+        yyresult = 1;
+        goto yyreturn;
 
 yyaccept:
 #if YYBTYACC
-    if (yyps->save) goto yyvalid;
+        if (yyps->save)
+                goto yyvalid;
 #endif /* YYBTYACC */
-    yyresult = 0;
+        yyresult = 0;
 
 yyreturn:
 #if defined(YYDESTRUCT_CALL)
-    if (yychar != YYEOF && yychar != YYEMPTY)
+        if (yychar != YYEOF && yychar != YYEMPTY)
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
+                YYDESTRUCT_CALL ("cleanup: discarding token",
+                                 yychar,
+                                 &yylval,
+                                 &yylloc);
 #else
-        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
+                YYDESTRUCT_CALL ("cleanup: discarding token", yychar, &yylval);
 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 
-    {
-        YYSTYPE *pv;
+        {
+                YYSTYPE *pv;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-        YYLTYPE *pp;
+                YYLTYPE *pp;
 
-        for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
-             YYDESTRUCT_CALL("cleanup: discarding state",
-                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
+                for (pv = yystack.l_base, pp = yystack.p_base;
+                     pv <= yystack.l_mark;
+                     ++pv, ++pp)
+                        YYDESTRUCT_CALL ("cleanup: discarding state",
+                                         yystos[*(yystack.s_base +
+                                                  (pv - yystack.l_base))],
+                                         pv,
+                                         pp);
 #else
-        for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
-             YYDESTRUCT_CALL("cleanup: discarding state",
-                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
+                for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
+                        YYDESTRUCT_CALL ("cleanup: discarding state",
+                                         yystos[*(yystack.s_base +
+                                                  (pv - yystack.l_base))],
+                                         pv);
 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
-    }
+        }
 #endif /* defined(YYDESTRUCT_CALL) */
 
 #if YYBTYACC
-    if (yyerrctx)
-    {
-        yyFreeState(yyerrctx);
-        yyerrctx = NULL;
-    }
-    while (yyps)
-    {
-        YYParseState *save = yyps;
-        yyps = save->save;
-        save->save = NULL;
-        yyFreeState(save);
-    }
-    while (yypath)
-    {
-        YYParseState *save = yypath;
-        yypath = save->save;
-        save->save = NULL;
-        yyFreeState(save);
-    }
+        if (yyerrctx)
+        {
+                yyFreeState (yyerrctx);
+                yyerrctx = NULL;
+        }
+        while (yyps)
+        {
+                YYParseState *save = yyps;
+                yyps = save->save;
+                save->save = NULL;
+                yyFreeState (save);
+        }
+        while (yypath)
+        {
+                YYParseState *save = yypath;
+                yypath = save->save;
+                save->save = NULL;
+                yyFreeState (save);
+        }
 #endif /* YYBTYACC */
-    yyfreestack(&yystack);
-    return (yyresult);
+        yyfreestack (&yystack);
+        return (yyresult);
 }
--- a/y.tab.h	Fri May 03 21:13:40 2019 +0000
+++ b/y.tab.h	Fri May 03 21:14:56 2019 +0000
@@ -5,18 +5,19 @@
 #define STRING 258
 #define COMMENT 259
 #ifdef YYSTYPE
-#undef  YYSTYPE_IS_DECLARED
+#undef YYSTYPE_IS_DECLARED
 #define YYSTYPE_IS_DECLARED 1
 #endif
 #ifndef YYSTYPE_IS_DECLARED
 #define YYSTYPE_IS_DECLARED 1
-typedef union {
-    char *sval;
-    int ival;
-    short shval;
-    struct _menuline *mlval;
-    struct _menuinfo *mival;
-    char **cval;
+typedef union
+{
+        char *sval;
+        int ival;
+        short shval;
+        struct _menuline *mlval;
+        struct _menuinfo *mival;
+        char **cval;
 } YYSTYPE;
 #endif /* !YYSTYPE_IS_DECLARED */
 extern YYSTYPE yylval;