 @@ -103,29 +103,29 @@ do \
 #define YYSTACKSIZE YYMAXDEPTH
 #else
 #define YYSTACKSIZE 10000
 #define YYMAXDEPTH  10000
 #endif
 #endif
 #ifndef YYINITSTACKSIZE
 #define YYINITSTACKSIZE 200
 #endif
 typedef struct {
     unsigned stacksize;
-    short    *s_base;
+    YYINT    *s_base;
-    short    *s_mark;
+    YYINT    *s_mark;
-    short    *s_last;
+    YYINT    *s_last;
     YYSTYPE  *l_base;
     YYSTYPE  *l_mark;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
     YYLTYPE  *p_base;
     YYLTYPE  *p_mark;
 #endif
 } YYSTACKDATA;
 %%ifdef YYBTYACC
 struct YYParseState_s
+{
     struct YYParseState_s *save;    /* Previously saved parser state */
     YYSTACKDATA            yystack; /* saved parser stack */
 @@ -164,29 +164,29 @@ static YYSTYPE *yylvlim = 0;
 static YYLTYPE *yylpsns = 0;
 /* Current position at lexical position queue */
 static YYLTYPE *yylpp = 0;
 /* End position of lexical position queue */
 static YYLTYPE *yylpe = 0;
 /* The last allocated position at the lexical position queue */
 static YYLTYPE *yylplim = 0;
 #endif
 /* Current position at lexical token queue */
-static short  *yylexp = 0;
+static YYINT  *yylexp = 0;
-static short  *yylexemes = 0;
+static YYINT  *yylexemes = 0;
 %%endif YYBTYACC
 %% body_vars
     int      yyerrflag;
     int      yychar;
     YYSTYPE  yyval;
     YYSTYPE  yylval;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
     YYLTYPE  yyloc; /* position returned by actions */
     YYLTYPE  yylloc; /* position from the lexer */
 #endif
     /* variables for the parser stack */
     YYSTACKDATA yystack;
 @@ -215,65 +215,65 @@ static short  *yylexemes = 0;
     static YYLTYPE *yylpsns = 0;
     /* Current position at lexical position queue */
     static YYLTYPE *yylpp = 0;
     /* End position of lexical position queue */
     static YYLTYPE *yylpe = 0;
     /* The last allocated position at the lexical position queue */
     static YYLTYPE *yylplim = 0;
 #endif
     /* Current position at lexical token queue */
-    static short  *yylexp = 0;
+    static YYINT  *yylexp = 0;
-    static short  *yylexemes = 0;
+    static YYINT  *yylexemes = 0;
 %%endif YYBTYACC
 %% body_1
 /* For use in generated program */
 #define yydepth (int)(yystack.s_mark - yystack.s_base)
 %%ifdef YYBTYACC
 #define yytrial (yyps->save)
 %%endif
 #if YYDEBUG
 #include <stdio.h>		/* needed for printf */
 #endif
 #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)
+{
     int i;
     unsigned newsize;
-    short *newss;
+    YYINT *newss;
     YYSTYPE *newvs;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
     YYLTYPE *newps;
 #endif
     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 = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    newss = realloc(data->s_base, newsize * sizeof(*newss));
     if (newss == 0)
         return YYENOMEM;
     data->s_base = newss;
     data->s_mark = newss + i;
     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
     if (newvs == 0)
         return YYENOMEM;
     data->l_base = newvs;
     data->l_mark = newvs + i;
 @@ -317,33 +317,33 @@ yyNewState(unsigned size)
     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;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
         p->yystack.p_base = NULL;
 #endif
         return p;
+    }
-    p->yystack.s_base    = (short *) malloc(size * sizeof(short));
+    p->yystack.s_base    = malloc(size * sizeof(YYINT));
     if (p->yystack.s_base == NULL) return NULL;
-    p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
+    p->yystack.l_base    = 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));
+    p->yystack.p_base    = malloc(size * sizeof(YYLTYPE));
     if (p->yystack.p_base == NULL) return NULL;
     memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
 #endif
     return p;
+}
 static void
 yyFreeState(YYParseState *p)
+{
     yyfreestack(&p->yystack);
     free(p);
+}
 @@ -421,40 +421,40 @@ yyloop:
 #endif
             yychar = *yylexp++;
             break;
+        }
         if (yyps->save)
+        {
             /* in trial mode; save scanner results for future parse attempts */
             if (yylvp == yylvlim)
             {   /* Enlarge lexical value queue */
                 int p = yylvp - yylvals;
                 int s = yylvlim - yylvals;
                 s += YYLVQUEUEGROWTH;
-                if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
+                if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
-                if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
+                if ((yylvals   = 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;
+                if ((yylpsns   = 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 = (short) YYLEX;
+            *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;
 %%ifdef YYBTYACC
 @@ -514,73 +514,73 @@ yyloop:
                 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, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
+            memcpy (save->yystack.s_base, yystack.s_base, (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, (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, (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++;
+            }
             save->ctry = ctry;
             if (yyps->save == NULL)
+            {
                 /* If this is a first conflict in the stack, start saving lexemes */
                 if (!yylexemes)
+                {
-                    yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
+                    yylexemes = 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
+                }
                 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)
                         *yylpe++ = yylloc;
 #endif
-                        *yylexp  = (short) yychar;
+                        *yylexp  = (YYINT) yychar;
                         yychar   = YYEMPTY;
+                    }
+                }
+            }
             if (yychar >= YYEOF)
+            {
                 yylvp--;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
                 yylpp--;
 #endif
                 yylexp--;
                 yychar = YYEMPTY;
+            }
 @@ -595,27 +595,27 @@ yyloop:
                                 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 = (short) yystate;
+            *++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;
+        }
 @@ -668,43 +668,43 @@ yyerrhandler:
 #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, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
+            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (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, (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, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 #endif
             yyerrctx->lexeme         = 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, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
+        memcpy (yystack.s_base, save->yystack.s_base, (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, (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, (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);
 @@ -719,27 +719,27 @@ yyerrhandler:
 #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, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
+            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (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, (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, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 #endif
             yystate        = yyerrctx->state;
             yyFreeState(yyerrctx);
             yyerrctx       = NULL;
+        }
         yynewerrflag = 1;
+    }
     if (yynewerrflag == 0) goto yyinrecovery;
 @@ -932,43 +932,43 @@ yyreduce:
 #endif
                 yychar = *yylexp++;
                 break;
+            }
             if (yyps->save)
+            {
                 /* in trial mode; save scanner results for future parse attempts */
                 if (yylvp == yylvlim)
                 {   /* Enlarge lexical value queue */
                     int p = yylvp - yylvals;
                     int s = yylvlim - yylvals;
                     s += YYLVQUEUEGROWTH;
-                    if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL)
+                    if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
                         goto yyenomem;
-                    if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
+                    if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
                         goto yyenomem;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
-                    if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
+                    if ((yylpsns   = 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 = (short) YYLEX;
+                *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;
 %%ifdef YYBTYACC
 @@ -997,27 +997,27 @@ yyreduce:
     if (yydebug)
+    {
         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
 #ifdef YYSTYPE_TOSTRING
 %%ifdef YYBTYACC
         if (!yytrial)
 %%endif
             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 = (short) yystate;
+    *++yystack.s_mark = (YYINT) yystate;
     *++yystack.l_mark = yyval;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
     *++yystack.p_mark = yyloc;
 #endif
     goto yyloop;
 %%ifdef YYBTYACC
     /* 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;
 @@ -1032,27 +1032,27 @@ yyvalid:
 #endif
     if (yyerrctx)
+    {
         yyFreeState(yyerrctx);
         yyerrctx = NULL;
+    }
     yylvp          = yylvals + yypath->lexeme;
 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
     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, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
+    memcpy (yystack.s_base, yypath->yystack.s_base, (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, (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, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 #endif
     yystate        = yypath->state;
     goto yyloop;
 %%endif YYBTYACC
 yyoverflow:
     YYERROR_CALL("yacc stack overflow");
 %%ifdef YYBTYACC