contrib/byacc/test/btyacc/btyacc_demo.tab.c

   1 /* original parser id follows */
   2 /* yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93" */
   3 /* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
   4
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8 #define YYCHECK "yyyymmdd"
   9
  10 #define YYEMPTY        (-1)
  11 #define yyclearin      (yychar = YYEMPTY)
  12 #define yyerrok        (yyerrflag = 0)
  13 #define YYRECOVERING() (yyerrflag != 0)
  14 #define YYENOMEM       (-2)
  15 #define YYEOF          0
  16 #undef YYBTYACC
  17 #define YYBTYACC 1
  18 #define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug")
  19
  20 #ifndef yyparse
  21 #define yyparse    demo_parse
  22 #endif /* yyparse */
  23
  24 #ifndef yylex
  25 #define yylex      demo_lex
  26 #endif /* yylex */
  27
  28 #ifndef yyerror
  29 #define yyerror    demo_error
  30 #endif /* yyerror */
  31
  32 #ifndef yychar
  33 #define yychar     demo_char
  34 #endif /* yychar */
  35
  36 #ifndef yyval
  37 #define yyval      demo_val
  38 #endif /* yyval */
  39
  40 #ifndef yylval
  41 #define yylval     demo_lval
  42 #endif /* yylval */
  43
  44 #ifndef yydebug
  45 #define yydebug    demo_debug
  46 #endif /* yydebug */
  47
  48 #ifndef yynerrs
  49 #define yynerrs    demo_nerrs
  50 #endif /* yynerrs */
  51
  52 #ifndef yyerrflag
  53 #define yyerrflag  demo_errflag
  54 #endif /* yyerrflag */
  55
  56 #ifndef yylhs
  57 #define yylhs      demo_lhs
  58 #endif /* yylhs */
  59
  60 #ifndef yylen
  61 #define yylen      demo_len
  62 #endif /* yylen */
  63
  64 #ifndef yydefred
  65 #define yydefred   demo_defred
  66 #endif /* yydefred */
  67
  68 #ifndef yystos
  69 #define yystos     demo_stos
  70 #endif /* yystos */
  71
  72 #ifndef yydgoto
  73 #define yydgoto    demo_dgoto
  74 #endif /* yydgoto */
  75
  76 #ifndef yysindex
  77 #define yysindex   demo_sindex
  78 #endif /* yysindex */
  79
  80 #ifndef yyrindex
  81 #define yyrindex   demo_rindex
  82 #endif /* yyrindex */
  83
  84 #ifndef yygindex
  85 #define yygindex   demo_gindex
  86 #endif /* yygindex */
  87
  88 #ifndef yytable
  89 #define yytable    demo_table
  90 #endif /* yytable */
  91
  92 #ifndef yycheck
  93 #define yycheck    demo_check
  94 #endif /* yycheck */
  95
  96 #ifndef yyname
  97 #define yyname     demo_name
  98 #endif /* yyname */
  99
 100 #ifndef yyrule
 101 #define yyrule     demo_rule
 102 #endif /* yyrule */
 103
 104 #ifndef yyloc
 105 #define yyloc      demo_loc
 106 #endif /* yyloc */
 107
 108 #ifndef yylloc
 109 #define yylloc     demo_lloc
 110 #endif /* yylloc */
 111
 112 #if YYBTYACC
 113
 114 #ifndef yycindex
 115 #define yycindex   demo_cindex
 116 #endif /* yycindex */
 117
 118 #ifndef yyctable
 119 #define yyctable   demo_ctable
 120 #endif /* yyctable */
 121
 122 #endif /* YYBTYACC */
 123
 124 #define YYPREFIX "demo_"
 125
 126 #define YYPURE 0
 127
 128 #line 15 "btyacc_demo.y"
 129 /* dummy types just for compile check */
 130 typedef int Code;
 131 typedef int Decl_List;
 132 typedef int Expr;
 133 typedef int Expr_List;
 134 typedef int Scope;
 135 typedef int Type;
 136 enum Operator { ADD, SUB, MUL, MOD, DIV, DEREF };
 137
 138 typedef unsigned char bool;
 139 typedef struct Decl {
 140     Scope *scope;
 141     Type  *type;
 142     bool (*istype)(void);
 143 } Decl;
 144
 145 #include "btyacc_demo.tab.h"
 146 #include <stdlib.h>
 147 #include <stdio.h>
 148 #line 36 "btyacc_demo.y"
 149 #ifdef YYSTYPE
 150 #undef  YYSTYPE_IS_DECLARED
 151 #define YYSTYPE_IS_DECLARED 1
 152 #endif
 153 #ifndef YYSTYPE_IS_DECLARED
 154 #define YYSTYPE_IS_DECLARED 1
 155 typedef union {
 156     Scope       *scope;
 157     Expr        *expr;
 158     Expr_List   *elist;
 159     Type        *type;
 160     Decl        *decl;
 161     Decl_List   *dlist;
 162     Code        *code;
 163     char        *id;
 164     } YYSTYPE;
 165 #endif /* !YYSTYPE_IS_DECLARED */
 166 #line 167 "btyacc_demo.tab.c"
 167
 168 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 169 /* Default: YYLTYPE is the text position type. */
 170 typedef struct YYLTYPE
 171 {
 172     int first_line;
 173     int first_column;
 174     int last_line;
 175     int last_column;
 176 } YYLTYPE;
 177 #define YYLTYPE_IS_DECLARED 1
 178 #endif
 179
 180 /* compatibility with bison */
 181 #ifdef YYPARSE_PARAM
 182 /* compatibility with FreeBSD */
 183 # ifdef YYPARSE_PARAM_TYPE
 184 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 185 # else
 186 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 187 # endif
 188 #else
 189 # define YYPARSE_DECL() yyparse(void)
 190 #endif
 191
 192 /* Parameters sent to lex. */
 193 #ifdef YYLEX_PARAM
 194 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 195 # define YYLEX yylex(YYLEX_PARAM)
 196 #else
 197 # define YYLEX_DECL() yylex(void)
 198 # define YYLEX yylex()
 199 #endif
 200
 201 /* Parameters sent to yyerror. */
 202 #ifndef YYERROR_DECL
 203 #define YYERROR_DECL() yyerror(YYLTYPE loc, const char *s)
 204 #endif
 205 #ifndef YYERROR_CALL
 206 #define YYERROR_CALL(msg) yyerror(yylloc, msg)
 207 #endif
 208
 209 #ifndef YYDESTRUCT_DECL
 210 #define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, YYLTYPE *loc)
 211 #endif
 212 #ifndef YYDESTRUCT_CALL
 213 #define YYDESTRUCT_CALL(msg, psymb, val, loc) yydestruct(msg, psymb, val, loc)
 214 #endif
 215
 216 extern int YYPARSE_DECL();
 217
 218 #define PREFIX 257
 219 #define POSTFIX 258
 220 #define ID 259
 221 #define CONSTANT 260
 222 #define EXTERN 261
 223 #define REGISTER 262
 224 #define STATIC 263
 225 #define CONST 264
 226 #define VOLATILE 265
 227 #define IF 266
 228 #define THEN 267
 229 #define ELSE 268
 230 #define CLCL 269
 231 #define YYERRCODE 256
 232 typedef short YYINT;
 233 static const YYINT demo_lhs[] = {                        -1,
 234    15,   15,   15,   12,   18,    0,    4,   19,    4,   20,
 235     2,   21,    2,   10,   10,   13,   13,   11,   11,   11,
 236    11,   11,   14,   14,   22,   23,    3,    3,    8,    8,
 237    24,   25,    8,    8,    8,    8,   16,   16,   17,   17,
 238     9,    1,    1,    1,    1,    1,    1,    1,    1,    5,
 239    26,    5,   27,   28,    5,    5,   29,    5,    6,    6,
 240     7,
 241 };
 242 static const YYINT demo_len[] = {                         2,
 243     0,    1,    3,    2,    0,    2,    0,    0,    3,    0,
 244     5,    0,    6,    1,    3,    0,    2,    1,    1,    1,
 245     1,    1,    1,    1,    0,    0,    5,    1,    0,    1,
 246     0,    0,    5,    5,    5,    6,    0,    1,    4,    1,
 247     4,    4,    4,    4,    4,    4,    3,    1,    1,    1,
 248     0,    3,    0,    0,   11,    8,    0,    2,    0,    3,
 249     4,
 250 };
 251 static const YYINT demo_defred[] = {                      5,
 252     0,    7,    0,    0,   20,   21,   22,   23,   24,    2,
 253     9,    8,   14,   19,   18,    0,    0,    0,   15,    0,
 254     3,   16,   31,   30,    0,    0,    0,   32,   11,   25,
 255    25,   25,    0,   17,   26,    0,   26,    0,    0,    8,
 256    13,    0,    0,    0,   40,    8,    0,    0,    8,   48,
 257    49,    0,   59,    0,   33,    0,    0,   16,   31,    0,
 258    31,   31,   31,   31,   31,   35,    0,    0,    0,    0,
 259    47,    0,    0,    0,    0,    0,   61,    0,    0,   39,
 260     0,    0,   44,   46,   45,    0,   50,   60,    0,    0,
 261    31,    0,   58,    0,   52,    0,    0,   53,    0,    0,
 262    54,    0,   55,
 263 };
 264 static const YYINT demo_stos[] = {                        0,
 265   271,  289,  275,  290,  261,  262,  263,  264,  265,  269,
 266   273,  281,  282,  283,  285,  286,  290,  259,  282,  291,
 267   269,   42,   40,  259,  274,  279,  284,  295,   59,   44,
 268    40,   91,  292,  285,  293,  296,  293,  293,  293,  123,
 269   278,  294,  279,  294,  280,  281,  287,  288,   42,  259,
 270   260,  272,  290,  279,   41,  279,  290,   41,   44,  290,
 271    43,   45,   42,   47,   37,   93,  277,  291,  284,  295,
 272   272,  295,  295,  295,  295,  295,  125,  290,  279,  280,
 273   272,  272,  272,  272,  272,  266,  273,  276,  297,  300,
 274    40,  272,  278,  295,   59,  272,   41,  267,  298,  276,
 275   268,  299,  276,
 276 };
 277 static const YYINT demo_dgoto[] = {                       1,
 278    52,   87,   25,    3,   88,   67,   41,   26,   45,   12,
 279    13,   14,   27,   15,   16,   47,   48,    2,    4,   20,
 280    33,   35,   42,   28,   36,   89,   99,  102,   90,
 281 };
 282 static const YYINT demo_sindex[] = {                      0,
 283     0,    0,    0, -124,    0,    0,    0,    0,    0,    0,
 284     0,    0,    0,    0,    0, -256, -124,    0,    0,  -33,
 285     0,    0,    0,    0,   34,   -4, -205,    0,    0,    0,
 286     0,    0, -110,    0,    0,  -33,    0, -124,  -15,    0,
 287     0,  -33,  -36,  -33,    0,    0,    4,    7,    0,    0,
 288     0,    5,    0,   -4,    0,   -4, -124,    0,    0,  -15,
 289     0,    0,    0,    0,    0,    0,  -46,  -33, -205, -124,
 290     0,  -15,  -15,  -15,  -15,  -15,    0,  -91,   -4,    0,
 291   122,  122,    0,    0,    0,   40,    0,    0,  -15, -110,
 292     0,  106,    0,  -15,    0,  113, -183,    0,  -91,    0,
 293     0,  -91,    0,
 294 };
 295 static const YYINT demo_rindex[] = {                      0,
 296     0,    0,    1, -157,    0,    0,    0,    0,    0,    0,
 297     0,    0,    0,    0,    0,    0,  -28,  -22,    0,  -29,
 298     0,    0,    0,    0,    0,  -27,  -34,    0,    0,    0,
 299     0,    0,    0,    0,    0,    8,    0,  -12,    0,    0,
 300     0,  -20,    0,   32,    0,    0,    0,   69,    0,    0,
 301     0,    0,    0,  -18,    0,   56,   33,    0,    0,    0,
 302     0,    0,    0,    0,    0,    0,  -31,   -1,   -6, -157,
 303     0,    0,    0,    0,    0,    0,    0,  -14,   63,    0,
 304    13,   23,    0,    0,    0,    0,    0,    0,    0,    0,
 305     0,    0,    0,    0,    0,    0,    0,    0,  -14,  -42,
 306     0,  -14,    0,
 307 };
 308 #if YYBTYACC
 309 static const YYINT demo_cindex[] = {                      0,
 310     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 311     0,    0,    0,    0,    0,    0, -145, -150,    0,   81,
 312     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 313     0,    0,    0,    0,    0,   82,    0,    0,    0,    0,
 314     0,   91,    0,  112,    0,    0,    0,    0,    0,    0,
 315     0,    0,    0,    0,    0,    0, -113,    0,    0,    0,
 316     0,    0,    0,    0,    0,    0,    0,  117,    0,    0,
 317     0,    0,    0,    0,    0,    0,    0,  -98,    0,    0,
 318     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 319     0,    0,    0,    0,    0,    0,    0,    0,  -96,  -92,
 320     0,  -82,    0,
 321 };
 322 #endif
 323 static const YYINT demo_gindex[] = {                      0,
 324    53,  175,    0,    0,    9,    0,   90,   76,  111,   27,
 325    29,    0,  124,  -25,    0,    0,    0,    0,   21,  126,
 326     0,  136,  147,   71,    0,    0,    0,    0,    0,
 327 };
 328 #define YYTABLESIZE 270
 329 static const YYINT demo_table[] = {                      56,
 330     6,   34,   18,   31,   55,   25,   25,   25,   22,   25,
 331     8,   10,   40,   10,   29,   10,   28,    4,    4,    4,
 332    29,    4,   34,   29,   25,   34,   49,   51,   37,   29,
 333    10,   28,   17,   36,   36,   31,    4,   36,   29,   29,
 334    34,   65,   29,   34,   58,   19,   63,   61,   29,   62,
 335    59,   64,   36,   42,   32,   42,   25,   42,    8,    9,
 336    53,   29,   10,   43,   46,   43,   57,   43,    4,   60,
 337    29,   42,   10,   10,   10,   29,   10,   30,   77,   91,
 338    56,   43,   56,   98,   36,   19,   32,   78,   25,   29,
 339    29,    8,   29,   29,   10,   12,   46,   66,   29,   27,
 340     4,    1,   29,   41,   34,   42,   41,  100,   57,   38,
 341   103,   43,   71,    0,   27,   43,   36,   54,    4,   56,
 342     7,    7,   29,   10,   81,   82,   83,   84,   85,   70,
 343     7,   72,   73,   74,   75,   76,    5,    6,    7,    8,
 344     9,   92,   65,   79,   10,    0,   96,   63,   61,   65,
 345    62,    7,   64,   97,   63,   61,    7,   62,   65,   64,
 346     9,   94,    9,   63,   95,   37,   38,   39,   64,    5,
 347     6,    7,    8,    9,   86,   13,    9,   10,   11,   93,
 348    80,   69,   68,   44,    0,    0,    0,    0,    0,    0,
 349     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 350     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 351     0,    0,    0,    0,    0,    0,   56,   56,   56,   56,
 352    56,   56,   56,   56,   25,   24,   56,    8,    8,    8,
 353     8,    8,    8,    8,    8,    0,    4,    8,    4,    4,
 354     4,    4,    4,   50,   51,   51,    1,    0,    0,    0,
 355     0,    0,    0,    0,    0,    0,    0,    0,    0,    8,
 356     0,    8,    8,    8,    8,    8,    0,    0,    0,    8,
 357 };
 358 static const YYINT demo_check[] = {                      42,
 359     0,   27,  259,   40,   41,   40,   41,   42,   42,   44,
 360    42,   40,  123,   42,   44,   44,   44,   40,   41,   42,
 361    41,   44,   41,   44,   59,   44,   42,   42,   41,   59,
 362    59,   59,   12,   40,   41,   40,   59,   44,   59,   41,
 363    59,   37,   44,   69,   41,   17,   42,   43,   41,   45,
 364    44,   47,   59,   41,   91,   43,   91,   45,  264,  265,
 365    40,   91,   91,   41,   38,   43,   46,   45,   91,   49,
 366    91,   59,   40,   41,   42,   44,   44,   44,  125,   40,
 367   123,   59,  125,  267,   91,   57,   91,   67,  123,   91,
 368    59,  123,   59,  123,  123,  123,   70,   93,   91,   44,
 369   123,  259,  123,   41,  123,   93,   44,   99,  123,   41,
 370   102,   36,   60,  259,   59,   93,  123,   42,  269,   44,
 371    40,   40,   91,   91,   72,   73,   74,   75,   76,   59,
 372    40,   61,   62,   63,   64,   65,  261,  262,  263,  264,
 373   265,   89,   37,   68,  269,  259,   94,   42,   43,   37,
 374    45,   40,   47,   41,   42,   43,   40,   45,   37,   47,
 375   259,   91,  259,   42,   59,   30,   31,   32,   47,  261,
 376   262,  263,  264,  265,  266,  268,  259,  269,    4,   90,
 377    70,   58,   57,   37,   -1,   -1,   -1,   -1,   -1,   -1,
 378    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 379    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 380    -1,   -1,   -1,   -1,   -1,   -1,  259,  260,  261,  262,
 381   263,  264,  265,  266,  259,  259,  269,  259,  260,  261,
 382   262,  263,  264,  265,  266,   -1,  259,  269,  261,  262,
 383   263,  264,  265,  259,  260,  260,  259,   -1,   -1,   -1,
 384    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  259,
 385    -1,  261,  262,  263,  264,  265,   -1,   -1,   -1,  269,
 386 };
 387 #if YYBTYACC
 388 static const YYINT demo_ctable[] = {                     -1,
 389     1,   10,   -1,   21,    4,   -1,   23,   29,   -1,    1,
 390    51,   -1,  101,   56,   -1,   -1,   -1,   -1,   -1,   -1,
 391    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 392    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 393    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 394    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 395    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 396    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 397    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 398    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 399    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 400    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 401    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 402    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 403    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 404    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 405    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 406    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 407    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 408    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 409    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 410    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 411    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 412    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 413    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 414    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 415    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 416 };
 417 #endif
 418 #define YYFINAL 1
 419 #ifndef YYDEBUG
 420 #define YYDEBUG 0
 421 #endif
 422 #define YYMAXTOKEN 269
 423 #define YYUNDFTOKEN 301
 424 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 425 #if YYDEBUG
 426 static const char *const demo_name[] = {
 427
 428 "$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,
 429 "'%'",0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,0,0,0,0,0,0,0,0,0,
 430 "';'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'['",0,
 431 "']'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,
 432 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 433 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 434 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 435 0,0,0,0,0,0,0,0,0,"error","PREFIX","POSTFIX","ID","CONSTANT","EXTERN",
 436 "REGISTER","STATIC","CONST","VOLATILE","IF","THEN","ELSE","CLCL","$accept",
 437 "input","expr","decl","declarator_list","decl_list","statement",
 438 "statement_list","block_statement","declarator","formal_arg","decl_specs",
 439 "decl_spec","typename","cv_quals","cv_qual","opt_scope","formal_arg_list",
 440 "nonempty_formal_arg_list","$$1","$$2","$$3","$$4","$$5","$$6","$$7","$$8",
 441 "$$9","$$10","$$11","$$12","illegal-symbol",
 442 };
 443 static const char *const demo_rule[] = {
 444 "$accept : input",
 445 "opt_scope :",
 446 "opt_scope : CLCL",
 447 "opt_scope : opt_scope ID CLCL",
 448 "typename : opt_scope ID",
 449 "$$1 :",
 450 "input : $$1 decl_list",
 451 "decl_list :",
 452 "$$2 :",
 453 "decl_list : decl_list $$2 decl",
 454 "$$3 :",
 455 "decl : decl_specs $$2 $$3 declarator_list ';'",
 456 "$$4 :",
 457 "decl : decl_specs $$2 $$3 declarator $$4 block_statement",
 458 "decl_specs : decl_spec",
 459 "decl_specs : decl_specs $$2 decl_spec",
 460 "cv_quals :",
 461 "cv_quals : cv_quals cv_qual",
 462 "decl_spec : cv_qual",
 463 "decl_spec : typename",
 464 "decl_spec : EXTERN",
 465 "decl_spec : REGISTER",
 466 "decl_spec : STATIC",
 467 "cv_qual : CONST",
 468 "cv_qual : VOLATILE",
 469 "$$5 :",
 470 "$$6 :",
 471 "declarator_list : declarator_list ',' $$5 $$6 declarator",
 472 "declarator_list : declarator",
 473 "declarator :",
 474 "declarator : ID",
 475 "$$7 :",
 476 "$$8 :",
 477 "declarator : '(' $$7 $$8 declarator ')'",
 478 "declarator : '*' cv_quals $$5 $$6 declarator",
 479 "declarator : declarator '[' $$5 expr ']'",
 480 "declarator : declarator '(' $$5 formal_arg_list ')' cv_quals",
 481 "formal_arg_list :",
 482 "formal_arg_list : nonempty_formal_arg_list",
 483 "nonempty_formal_arg_list : nonempty_formal_arg_list ',' $$7 formal_arg",
 484 "nonempty_formal_arg_list : formal_arg",
 485 "formal_arg : decl_specs $$2 $$3 declarator",
 486 "expr : expr '+' $$7 expr",
 487 "expr : expr '-' $$7 expr",
 488 "expr : expr '*' $$7 expr",
 489 "expr : expr '%' $$7 expr",
 490 "expr : expr '/' $$7 expr",
 491 "expr : '*' $$2 expr",
 492 "expr : ID",
 493 "expr : CONSTANT",
 494 "statement : decl",
 495 "$$9 :",
 496 "statement : $$9 expr ';'",
 497 "$$10 :",
 498 "$$11 :",
 499 "statement : IF '(' $$7 expr ')' THEN $$10 statement ELSE $$11 statement",
 500 "statement : IF '(' $$7 expr ')' THEN $$10 statement",
 501 "$$12 :",
 502 "statement : $$12 block_statement",
 503 "statement_list :",
 504 "statement_list : statement_list $$2 statement",
 505 "block_statement : '{' $$2 statement_list '}'",
 506
 507 };
 508 #endif
 509
 510 int      yydebug;
 511 int      yynerrs;
 512
 513 int      yyerrflag;
 514 int      yychar;
 515 YYSTYPE  yyval;
 516 YYSTYPE  yylval;
 517 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 518 YYLTYPE  yyloc; /* position returned by actions */
 519 YYLTYPE  yylloc; /* position from the lexer */
 520 #endif
 521
 522 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 523 #ifndef YYLLOC_DEFAULT
 524 #define YYLLOC_DEFAULT(loc, rhs, n) \
 525 do \
 526 { \
 527     if (n == 0) \
 528     { \
 529         (loc).first_line   = ((rhs)[-1]).last_line; \
 530         (loc).first_column = ((rhs)[-1]).last_column; \
 531         (loc).last_line    = ((rhs)[-1]).last_line; \
 532         (loc).last_column  = ((rhs)[-1]).last_column; \
 533     } \
 534     else \
 535     { \
 536         (loc).first_line   = ((rhs)[ 0 ]).first_line; \
 537         (loc).first_column = ((rhs)[ 0 ]).first_column; \
 538         (loc).last_line    = ((rhs)[n-1]).last_line; \
 539         (loc).last_column  = ((rhs)[n-1]).last_column; \
 540     } \
 541 } while (0)
 542 #endif /* YYLLOC_DEFAULT */
 543 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 544 #if YYBTYACC
 545
 546 #ifndef YYLVQUEUEGROWTH
 547 #define YYLVQUEUEGROWTH 32
 548 #endif
 549 #endif /* YYBTYACC */
 550
 551 /* define the initial stack-sizes */
 552 #ifdef YYSTACKSIZE
 553 #undef YYMAXDEPTH
 554 #define YYMAXDEPTH  YYSTACKSIZE
 555 #else
 556 #ifdef YYMAXDEPTH
 557 #define YYSTACKSIZE YYMAXDEPTH
 558 #else
 559 #define YYSTACKSIZE 10000
 560 #define YYMAXDEPTH  10000
 561 #endif
 562 #endif
 563
 564 #ifndef YYINITSTACKSIZE
 565 #define YYINITSTACKSIZE 200
 566 #endif
 567
 568 typedef struct {
 569     unsigned stacksize;
 570     short    *s_base;
 571     short    *s_mark;
 572     short    *s_last;
 573     YYSTYPE  *l_base;
 574     YYSTYPE  *l_mark;
 575 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 576     YYLTYPE  *p_base;
 577     YYLTYPE  *p_mark;
 578 #endif
 579 } YYSTACKDATA;
 580 #if YYBTYACC
 581
 582 struct YYParseState_s
 583 {
 584     struct YYParseState_s *save;    /* Previously saved parser state */
 585     YYSTACKDATA            yystack; /* saved parser stack */
 586     int                    state;   /* saved parser state */
 587     int                    errflag; /* saved error recovery status */
 588     int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
 589     YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
 590 };
 591 typedef struct YYParseState_s YYParseState;
 592 #endif /* YYBTYACC */
 593 /* variables for the parser stack */
 594 static YYSTACKDATA yystack;
 595 #if YYBTYACC
 596
 597 /* Current parser state */
 598 static YYParseState *yyps = 0;
 599
 600 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
 601 static YYParseState *yypath = 0;
 602
 603 /* Base of the lexical value queue */
 604 static YYSTYPE *yylvals = 0;
 605
 606 /* Current position at lexical value queue */
 607 static YYSTYPE *yylvp = 0;
 608
 609 /* End position of lexical value queue */
 610 static YYSTYPE *yylve = 0;
 611
 612 /* The last allocated position at the lexical value queue */
 613 static YYSTYPE *yylvlim = 0;
 614
 615 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 616 /* Base of the lexical position queue */
 617 static YYLTYPE *yylpsns = 0;
 618
 619 /* Current position at lexical position queue */
 620 static YYLTYPE *yylpp = 0;
 621
 622 /* End position of lexical position queue */
 623 static YYLTYPE *yylpe = 0;
 624
 625 /* The last allocated position at the lexical position queue */
 626 static YYLTYPE *yylplim = 0;
 627 #endif
 628
 629 /* Current position at lexical token queue */
 630 static short  *yylexp = 0;
 631
 632 static short  *yylexemes = 0;
 633 #endif /* YYBTYACC */
 634 #line 200 "btyacc_demo.y"
 635
 636 extern int YYLEX_DECL();
 637 extern void YYERROR_DECL();
 638
 639 extern Scope *global_scope;
 640
 641 extern Decl * lookup(Scope *scope, char *id);
 642 extern Scope * new_scope(Scope *outer_scope);
 643 extern Scope * start_fn_def(Scope *scope, Decl *fn_decl);
 644 extern void finish_fn_def(Decl *fn_decl, Code *block);
 645 extern Type * type_combine(Type *specs, Type *spec);
 646 extern Type * bare_extern(void);
 647 extern Type * bare_register(void);
 648 extern Type * bare_static(void);
 649 extern Type * bare_const(void);
 650 extern Type * bare_volatile(void);
 651 extern Decl * declare(Scope *scope, char *id, Type *type);
 652 extern Decl * make_pointer(Decl *decl, Type *type);
 653 extern Decl * make_array(Type *type, Expr *expr);
 654 extern Decl * build_function(Decl *decl, Decl_List *dlist, Type *type);
 655 extern Decl_List * append_dlist(Decl_List *dlist, Decl *decl);
 656 extern Decl_List * build_dlist(Decl *decl);
 657 extern Expr * build_expr(Expr *left, enum Operator op, Expr *right);
 658 extern Expr * var_expr(Scope *scope, char *id);
 659 extern Code * build_expr_code(Expr *expr);
 660 extern Code * build_if(Expr *cond_expr, Code *then_stmt, Code *else_stmt);
 661 extern Code * code_append(Code *stmt_list, Code *stmt);
 662 #line 663 "btyacc_demo.tab.c"
 663
 664 /* Release memory associated with symbol. */
 665 #if ! defined YYDESTRUCT_IS_DECLARED
 666 static void
 667 YYDESTRUCT_DECL()
 668 {
 669     switch (psymb)
 670     {
 671         case 43:
 672 #line 83 "btyacc_demo.y"
 673         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 674                          msg,
 675                          (*loc).first_line, (*loc).first_column,
 676                          (*loc).last_line, (*loc).last_column);
 677                   /* in this example, we don't know what to do here */ }
 678         break;
 679 #line 680 "btyacc_demo.tab.c"
 680         case 45:
 681 #line 83 "btyacc_demo.y"
 682         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 683                          msg,
 684                          (*loc).first_line, (*loc).first_column,
 685                          (*loc).last_line, (*loc).last_column);
 686                   /* in this example, we don't know what to do here */ }
 687         break;
 688 #line 689 "btyacc_demo.tab.c"
 689         case 42:
 690 #line 83 "btyacc_demo.y"
 691         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 692                          msg,
 693                          (*loc).first_line, (*loc).first_column,
 694                          (*loc).last_line, (*loc).last_column);
 695                   /* in this example, we don't know what to do here */ }
 696         break;
 697 #line 698 "btyacc_demo.tab.c"
 698         case 47:
 699 #line 83 "btyacc_demo.y"
 700         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 701                          msg,
 702                          (*loc).first_line, (*loc).first_column,
 703                          (*loc).last_line, (*loc).last_column);
 704                   /* in this example, we don't know what to do here */ }
 705         break;
 706 #line 707 "btyacc_demo.tab.c"
 707         case 37:
 708 #line 83 "btyacc_demo.y"
 709         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 710                          msg,
 711                          (*loc).first_line, (*loc).first_column,
 712                          (*loc).last_line, (*loc).last_column);
 713                   /* in this example, we don't know what to do here */ }
 714         break;
 715 #line 716 "btyacc_demo.tab.c"
 716         case 257:
 717 #line 83 "btyacc_demo.y"
 718         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 719                          msg,
 720                          (*loc).first_line, (*loc).first_column,
 721                          (*loc).last_line, (*loc).last_column);
 722                   /* in this example, we don't know what to do here */ }
 723         break;
 724 #line 725 "btyacc_demo.tab.c"
 725         case 258:
 726 #line 83 "btyacc_demo.y"
 727         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 728                          msg,
 729                          (*loc).first_line, (*loc).first_column,
 730                          (*loc).last_line, (*loc).last_column);
 731                   /* in this example, we don't know what to do here */ }
 732         break;
 733 #line 734 "btyacc_demo.tab.c"
 734         case 40:
 735 #line 83 "btyacc_demo.y"
 736         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 737                          msg,
 738                          (*loc).first_line, (*loc).first_column,
 739                          (*loc).last_line, (*loc).last_column);
 740                   /* in this example, we don't know what to do here */ }
 741         break;
 742 #line 743 "btyacc_demo.tab.c"
 743         case 91:
 744 #line 83 "btyacc_demo.y"
 745         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 746                          msg,
 747                          (*loc).first_line, (*loc).first_column,
 748                          (*loc).last_line, (*loc).last_column);
 749                   /* in this example, we don't know what to do here */ }
 750         break;
 751 #line 752 "btyacc_demo.tab.c"
 752         case 46:
 753 #line 83 "btyacc_demo.y"
 754         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 755                          msg,
 756                          (*loc).first_line, (*loc).first_column,
 757                          (*loc).last_line, (*loc).last_column);
 758                   /* in this example, we don't know what to do here */ }
 759         break;
 760 #line 761 "btyacc_demo.tab.c"
 761         case 259:
 762 #line 78 "btyacc_demo.y"
 763         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
 764                          msg,
 765                          (*loc).first_line, (*loc).first_column,
 766                          (*loc).last_line, (*loc).last_column);
 767                   free((*val).id); }
 768         break;
 769 #line 770 "btyacc_demo.tab.c"
 770         case 260:
 771 #line 78 "btyacc_demo.y"
 772         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
 773                          msg,
 774                          (*loc).first_line, (*loc).first_column,
 775                          (*loc).last_line, (*loc).last_column);
 776                   free((*val).expr); }
 777         break;
 778 #line 779 "btyacc_demo.tab.c"
 779         case 261:
 780 #line 83 "btyacc_demo.y"
 781         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 782                          msg,
 783                          (*loc).first_line, (*loc).first_column,
 784                          (*loc).last_line, (*loc).last_column);
 785                   /* in this example, we don't know what to do here */ }
 786         break;
 787 #line 788 "btyacc_demo.tab.c"
 788         case 262:
 789 #line 83 "btyacc_demo.y"
 790         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 791                          msg,
 792                          (*loc).first_line, (*loc).first_column,
 793                          (*loc).last_line, (*loc).last_column);
 794                   /* in this example, we don't know what to do here */ }
 795         break;
 796 #line 797 "btyacc_demo.tab.c"
 797         case 263:
 798 #line 83 "btyacc_demo.y"
 799         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 800                          msg,
 801                          (*loc).first_line, (*loc).first_column,
 802                          (*loc).last_line, (*loc).last_column);
 803                   /* in this example, we don't know what to do here */ }
 804         break;
 805 #line 806 "btyacc_demo.tab.c"
 806         case 264:
 807 #line 83 "btyacc_demo.y"
 808         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 809                          msg,
 810                          (*loc).first_line, (*loc).first_column,
 811                          (*loc).last_line, (*loc).last_column);
 812                   /* in this example, we don't know what to do here */ }
 813         break;
 814 #line 815 "btyacc_demo.tab.c"
 815         case 265:
 816 #line 83 "btyacc_demo.y"
 817         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 818                          msg,
 819                          (*loc).first_line, (*loc).first_column,
 820                          (*loc).last_line, (*loc).last_column);
 821                   /* in this example, we don't know what to do here */ }
 822         break;
 823 #line 824 "btyacc_demo.tab.c"
 824         case 266:
 825 #line 83 "btyacc_demo.y"
 826         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 827                          msg,
 828                          (*loc).first_line, (*loc).first_column,
 829                          (*loc).last_line, (*loc).last_column);
 830                   /* in this example, we don't know what to do here */ }
 831         break;
 832 #line 833 "btyacc_demo.tab.c"
 833         case 267:
 834 #line 83 "btyacc_demo.y"
 835         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 836                          msg,
 837                          (*loc).first_line, (*loc).first_column,
 838                          (*loc).last_line, (*loc).last_column);
 839                   /* in this example, we don't know what to do here */ }
 840         break;
 841 #line 842 "btyacc_demo.tab.c"
 842         case 268:
 843 #line 83 "btyacc_demo.y"
 844         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 845                          msg,
 846                          (*loc).first_line, (*loc).first_column,
 847                          (*loc).last_line, (*loc).last_column);
 848                   /* in this example, we don't know what to do here */ }
 849         break;
 850 #line 851 "btyacc_demo.tab.c"
 851         case 269:
 852 #line 83 "btyacc_demo.y"
 853         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 854                          msg,
 855                          (*loc).first_line, (*loc).first_column,
 856                          (*loc).last_line, (*loc).last_column);
 857                   /* in this example, we don't know what to do here */ }
 858         break;
 859 #line 860 "btyacc_demo.tab.c"
 860         case 59:
 861 #line 83 "btyacc_demo.y"
 862         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 863                          msg,
 864                          (*loc).first_line, (*loc).first_column,
 865                          (*loc).last_line, (*loc).last_column);
 866                   /* in this example, we don't know what to do here */ }
 867         break;
 868 #line 869 "btyacc_demo.tab.c"
 869         case 44:
 870 #line 83 "btyacc_demo.y"
 871         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 872                          msg,
 873                          (*loc).first_line, (*loc).first_column,
 874                          (*loc).last_line, (*loc).last_column);
 875                   /* in this example, we don't know what to do here */ }
 876         break;
 877 #line 878 "btyacc_demo.tab.c"
 878         case 41:
 879 #line 83 "btyacc_demo.y"
 880         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 881                          msg,
 882                          (*loc).first_line, (*loc).first_column,
 883                          (*loc).last_line, (*loc).last_column);
 884                   /* in this example, we don't know what to do here */ }
 885         break;
 886 #line 887 "btyacc_demo.tab.c"
 887         case 93:
 888 #line 83 "btyacc_demo.y"
 889         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 890                          msg,
 891                          (*loc).first_line, (*loc).first_column,
 892                          (*loc).last_line, (*loc).last_column);
 893                   /* in this example, we don't know what to do here */ }
 894         break;
 895 #line 896 "btyacc_demo.tab.c"
 896         case 123:
 897 #line 83 "btyacc_demo.y"
 898         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 899                          msg,
 900                          (*loc).first_line, (*loc).first_column,
 901                          (*loc).last_line, (*loc).last_column);
 902                   /* in this example, we don't know what to do here */ }
 903         break;
 904 #line 905 "btyacc_demo.tab.c"
 905         case 125:
 906 #line 83 "btyacc_demo.y"
 907         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 908                          msg,
 909                          (*loc).first_line, (*loc).first_column,
 910                          (*loc).last_line, (*loc).last_column);
 911                   /* in this example, we don't know what to do here */ }
 912         break;
 913 #line 914 "btyacc_demo.tab.c"
 914         case 270:
 915 #line 83 "btyacc_demo.y"
 916         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 917                          msg,
 918                          (*loc).first_line, (*loc).first_column,
 919                          (*loc).last_line, (*loc).last_column);
 920                   /* in this example, we don't know what to do here */ }
 921         break;
 922 #line 923 "btyacc_demo.tab.c"
 923         case 271:
 924 #line 83 "btyacc_demo.y"
 925         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 926                          msg,
 927                          (*loc).first_line, (*loc).first_column,
 928                          (*loc).last_line, (*loc).last_column);
 929                   /* in this example, we don't know what to do here */ }
 930         break;
 931 #line 932 "btyacc_demo.tab.c"
 932         case 272:
 933 #line 78 "btyacc_demo.y"
 934         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
 935                          msg,
 936                          (*loc).first_line, (*loc).first_column,
 937                          (*loc).last_line, (*loc).last_column);
 938                   free((*val).expr); }
 939         break;
 940 #line 941 "btyacc_demo.tab.c"
 941         case 273:
 942 #line 67 "btyacc_demo.y"
 943         { /* 'msg' is a 'char *' indicating the context of destructor invocation*/
 944                   printf("%s accessed by symbol \"decl\" (case s.b. 273) @ position[%d,%d..%d,%d]\n",
 945                          msg,
 946                          (*loc).first_line, (*loc).first_column,
 947                          (*loc).last_line, (*loc).last_column);
 948                   free((*val).decl->scope); free((*val).decl->type); }
 949         break;
 950 #line 951 "btyacc_demo.tab.c"
 951         case 274:
 952 #line 83 "btyacc_demo.y"
 953         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 954                          msg,
 955                          (*loc).first_line, (*loc).first_column,
 956                          (*loc).last_line, (*loc).last_column);
 957                   /* in this example, we don't know what to do here */ }
 958         break;
 959 #line 960 "btyacc_demo.tab.c"
 960         case 275:
 961 #line 83 "btyacc_demo.y"
 962         { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
 963                          msg,
 964                          (*loc).first_line, (*loc).first_column,
 965                          (*loc).last_line, (*loc).last_column);
 966                   /* in this example, we don't know what to do here */ }
 967         break;
 968 #line 969 "btyacc_demo.tab.c"
 969         case 276:
 970 #line 78 "btyacc_demo.y"
 971         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
 972                          msg,
 973                          (*loc).first_line, (*loc).first_column,
 974                          (*loc).last_line, (*loc).last_column);
 975                   free((*val).code); }
 976         break;
 977 #line 978 "btyacc_demo.tab.c"
 978         case 277:
 979 #line 78 "btyacc_demo.y"
 980         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
 981                          msg,
 982                          (*loc).first_line, (*loc).first_column,
 983                          (*loc).last_line, (*loc).last_column);
 984                   free((*val).code); }
 985         break;
 986 #line 987 "btyacc_demo.tab.c"
 987         case 278:
 988 #line 78 "btyacc_demo.y"
 989         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
 990                          msg,
 991                          (*loc).first_line, (*loc).first_column,
 992                          (*loc).last_line, (*loc).last_column);
 993                   free((*val).code); }
 994         break;
 995 #line 996 "btyacc_demo.tab.c"
 996         case 279:
 997 #line 73 "btyacc_demo.y"
 998         { printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n",
 999                          msg,
1000                          (*loc).first_line, (*loc).first_column,
1001                          (*loc).last_line, (*loc).last_column);
1002                   free((*val).decl); }
1003         break;
1004 #line 1005 "btyacc_demo.tab.c"
1005         case 280:
1006 #line 73 "btyacc_demo.y"
1007         { printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n",
1008                          msg,
1009                          (*loc).first_line, (*loc).first_column,
1010                          (*loc).last_line, (*loc).last_column);
1011                   free((*val).decl); }
1012         break;
1013 #line 1014 "btyacc_demo.tab.c"
1014         case 281:
1015 #line 78 "btyacc_demo.y"
1016         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1017                          msg,
1018                          (*loc).first_line, (*loc).first_column,
1019                          (*loc).last_line, (*loc).last_column);
1020                   free((*val).type); }
1021         break;
1022 #line 1023 "btyacc_demo.tab.c"
1023         case 282:
1024 #line 78 "btyacc_demo.y"
1025         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1026                          msg,
1027                          (*loc).first_line, (*loc).first_column,
1028                          (*loc).last_line, (*loc).last_column);
1029                   free((*val).type); }
1030         break;
1031 #line 1032 "btyacc_demo.tab.c"
1032         case 283:
1033 #line 78 "btyacc_demo.y"
1034         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1035                          msg,
1036                          (*loc).first_line, (*loc).first_column,
1037                          (*loc).last_line, (*loc).last_column);
1038                   free((*val).type); }
1039         break;
1040 #line 1041 "btyacc_demo.tab.c"
1041         case 284:
1042 #line 78 "btyacc_demo.y"
1043         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1044                          msg,
1045                          (*loc).first_line, (*loc).first_column,
1046                          (*loc).last_line, (*loc).last_column);
1047                   free((*val).type); }
1048         break;
1049 #line 1050 "btyacc_demo.tab.c"
1050         case 285:
1051 #line 78 "btyacc_demo.y"
1052         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1053                          msg,
1054                          (*loc).first_line, (*loc).first_column,
1055                          (*loc).last_line, (*loc).last_column);
1056                   free((*val).type); }
1057         break;
1058 #line 1059 "btyacc_demo.tab.c"
1059         case 286:
1060 #line 78 "btyacc_demo.y"
1061         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1062                          msg,
1063                          (*loc).first_line, (*loc).first_column,
1064                          (*loc).last_line, (*loc).last_column);
1065                   free((*val).scope); }
1066         break;
1067 #line 1068 "btyacc_demo.tab.c"
1068         case 287:
1069 #line 78 "btyacc_demo.y"
1070         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1071                          msg,
1072                          (*loc).first_line, (*loc).first_column,
1073                          (*loc).last_line, (*loc).last_column);
1074                   free((*val).dlist); }
1075         break;
1076 #line 1077 "btyacc_demo.tab.c"
1077         case 288:
1078 #line 78 "btyacc_demo.y"
1079         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1080                          msg,
1081                          (*loc).first_line, (*loc).first_column,
1082                          (*loc).last_line, (*loc).last_column);
1083                   free((*val).dlist); }
1084         break;
1085 #line 1086 "btyacc_demo.tab.c"
1086         case 289:
1087 #line 78 "btyacc_demo.y"
1088         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1089                          msg,
1090                          (*loc).first_line, (*loc).first_column,
1091                          (*loc).last_line, (*loc).last_column);
1092                   free((*val).scope); }
1093         break;
1094 #line 1095 "btyacc_demo.tab.c"
1095         case 290:
1096 #line 78 "btyacc_demo.y"
1097         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1098                          msg,
1099                          (*loc).first_line, (*loc).first_column,
1100                          (*loc).last_line, (*loc).last_column);
1101                   free((*val).scope); }
1102         break;
1103 #line 1104 "btyacc_demo.tab.c"
1104         case 291:
1105 #line 78 "btyacc_demo.y"
1106         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1107                          msg,
1108                          (*loc).first_line, (*loc).first_column,
1109                          (*loc).last_line, (*loc).last_column);
1110                   free((*val).type); }
1111         break;
1112 #line 1113 "btyacc_demo.tab.c"
1113         case 292:
1114 #line 78 "btyacc_demo.y"
1115         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1116                          msg,
1117                          (*loc).first_line, (*loc).first_column,
1118                          (*loc).last_line, (*loc).last_column);
1119                   free((*val).scope); }
1120         break;
1121 #line 1122 "btyacc_demo.tab.c"
1122         case 293:
1123 #line 78 "btyacc_demo.y"
1124         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1125                          msg,
1126                          (*loc).first_line, (*loc).first_column,
1127                          (*loc).last_line, (*loc).last_column);
1128                   free((*val).scope); }
1129         break;
1130 #line 1131 "btyacc_demo.tab.c"
1131         case 294:
1132 #line 78 "btyacc_demo.y"
1133         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1134                          msg,
1135                          (*loc).first_line, (*loc).first_column,
1136                          (*loc).last_line, (*loc).last_column);
1137                   free((*val).type); }
1138         break;
1139 #line 1140 "btyacc_demo.tab.c"
1140         case 295:
1141 #line 78 "btyacc_demo.y"
1142         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1143                          msg,
1144                          (*loc).first_line, (*loc).first_column,
1145                          (*loc).last_line, (*loc).last_column);
1146                   free((*val).scope); }
1147         break;
1148 #line 1149 "btyacc_demo.tab.c"
1149         case 296:
1150 #line 78 "btyacc_demo.y"
1151         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1152                          msg,
1153                          (*loc).first_line, (*loc).first_column,
1154                          (*loc).last_line, (*loc).last_column);
1155                   free((*val).type); }
1156         break;
1157 #line 1158 "btyacc_demo.tab.c"
1158         case 297:
1159 #line 78 "btyacc_demo.y"
1160         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1161                          msg,
1162                          (*loc).first_line, (*loc).first_column,
1163                          (*loc).last_line, (*loc).last_column);
1164                   free((*val).scope); }
1165         break;
1166 #line 1167 "btyacc_demo.tab.c"
1167         case 298:
1168 #line 78 "btyacc_demo.y"
1169         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1170                          msg,
1171                          (*loc).first_line, (*loc).first_column,
1172                          (*loc).last_line, (*loc).last_column);
1173                   free((*val).scope); }
1174         break;
1175 #line 1176 "btyacc_demo.tab.c"
1176         case 299:
1177 #line 78 "btyacc_demo.y"
1178         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1179                          msg,
1180                          (*loc).first_line, (*loc).first_column,
1181                          (*loc).last_line, (*loc).last_column);
1182                   free((*val).scope); }
1183         break;
1184 #line 1185 "btyacc_demo.tab.c"
1185         case 300:
1186 #line 78 "btyacc_demo.y"
1187         { printf("%s accessed by symbol of any type other than <decl>  @ position[%d,%d..%d,%d]\n",
1188                          msg,
1189                          (*loc).first_line, (*loc).first_column,
1190                          (*loc).last_line, (*loc).last_column);
1191                   free((*val).scope); }
1192         break;
1193 #line 1194 "btyacc_demo.tab.c"
1194     }
1195 }
1196 #define YYDESTRUCT_IS_DECLARED 1
1197 #endif
1198
1199 /* For use in generated program */
1200 #define yydepth (int)(yystack.s_mark - yystack.s_base)
1201 #if YYBTYACC
1202 #define yytrial (yyps->save)
1203 #endif /* YYBTYACC */
1204
1205 #if YYDEBUG
1206 #include <stdio.h>         /* needed for printf */
1207 #endif
1208
1209 #include <stdlib.h>        /* needed for malloc, etc */
1210 #include <string.h>        /* needed for memset */
1211
1212 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
1213 static int yygrowstack(YYSTACKDATA *data)
1214 {
1215     int i;
1216     unsigned newsize;
1217     short *newss;
1218     YYSTYPE *newvs;
1219 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1220     YYLTYPE *newps;
1221 #endif
1222
1223     if ((newsize = data->stacksize) == 0)
1224         newsize = YYINITSTACKSIZE;
1225     else if (newsize >= YYMAXDEPTH)
1226         return YYENOMEM;
1227     else if ((newsize *= 2) > YYMAXDEPTH)
1228         newsize = YYMAXDEPTH;
1229
1230     i = (int) (data->s_mark - data->s_base);
1231     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
1232     if (newss == 0)
1233         return YYENOMEM;
1234
1235     data->s_base = newss;
1236     data->s_mark = newss + i;
1237
1238     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1239     if (newvs == 0)
1240         return YYENOMEM;
1241
1242     data->l_base = newvs;
1243     data->l_mark = newvs + i;
1244
1245 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1246     newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
1247     if (newps == 0)
1248         return YYENOMEM;
1249
1250     data->p_base = newps;
1251     data->p_mark = newps + i;
1252 #endif
1253
1254     data->stacksize = newsize;
1255     data->s_last = data->s_base + newsize - 1;
1256
1257 #if YYDEBUG
1258     if (yydebug)
1259         fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
1260 #endif
1261     return 0;
1262 }
1263
1264 #if YYPURE || defined(YY_NO_LEAKS)
1265 static void yyfreestack(YYSTACKDATA *data)
1266 {
1267     free(data->s_base);
1268     free(data->l_base);
1269 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1270     free(data->p_base);
1271 #endif
1272     memset(data, 0, sizeof(*data));
1273 }
1274 #else
1275 #define yyfreestack(data) /* nothing */
1276 #endif /* YYPURE || defined(YY_NO_LEAKS) */
1277 #if YYBTYACC
1278
1279 static YYParseState *
1280 yyNewState(unsigned size)
1281 {
1282     YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
1283     if (p == NULL) return NULL;
1284
1285     p->yystack.stacksize = size;
1286     if (size == 0)
1287     {
1288         p->yystack.s_base = NULL;
1289         p->yystack.l_base = NULL;
1290 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1291         p->yystack.p_base = NULL;
1292 #endif
1293         return p;
1294     }
1295     p->yystack.s_base    = (short *) malloc(size * sizeof(short));
1296     if (p->yystack.s_base == NULL) return NULL;
1297     p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
1298     if (p->yystack.l_base == NULL) return NULL;
1299     memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
1300 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1301     p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
1302     if (p->yystack.p_base == NULL) return NULL;
1303     memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
1304 #endif
1305
1306     return p;
1307 }
1308
1309 static void
1310 yyFreeState(YYParseState *p)
1311 {
1312     yyfreestack(&p->yystack);
1313     free(p);
1314 }
1315 #endif /* YYBTYACC */
1316
1317 #define YYABORT  goto yyabort
1318 #define YYREJECT goto yyabort
1319 #define YYACCEPT goto yyaccept
1320 #define YYERROR  goto yyerrlab
1321 #if YYBTYACC
1322 #define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
1323 #define YYVALID_NESTED do { if (yyps->save && \
1324                                 yyps->save->save == 0) goto yyvalid; } while(0)
1325 #endif /* YYBTYACC */
1326
1327 int
1328 YYPARSE_DECL()
1329 {
1330     int yym, yyn, yystate, yyresult;
1331 #if YYBTYACC
1332     int yynewerrflag;
1333     YYParseState *yyerrctx = NULL;
1334 #endif /* YYBTYACC */
1335 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1336     YYLTYPE  yyerror_loc_range[2]; /* position of error start & end */
1337 #endif
1338 #if YYDEBUG
1339     const char *yys;
1340
1341     if ((yys = getenv("YYDEBUG")) != 0)
1342     {
1343         yyn = *yys;
1344         if (yyn >= '0' && yyn <= '9')
1345             yydebug = yyn - '0';
1346     }
1347     if (yydebug)
1348         fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
1349 #endif
1350
1351 #if YYBTYACC
1352     yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
1353     yyps->save = 0;
1354 #endif /* YYBTYACC */
1355     yynerrs = 0;
1356     yyerrflag = 0;
1357     yychar = YYEMPTY;
1358     yystate = 0;
1359
1360 #if YYPURE
1361     memset(&yystack, 0, sizeof(yystack));
1362 #endif
1363
1364     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1365     yystack.s_mark = yystack.s_base;
1366     yystack.l_mark = yystack.l_base;
1367 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1368     yystack.p_mark = yystack.p_base;
1369 #endif
1370     yystate = 0;
1371     *yystack.s_mark = 0;
1372
1373 yyloop:
1374     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1375     if (yychar < 0)
1376     {
1377 #if YYBTYACC
1378         do {
1379         if (yylvp < yylve)
1380         {
1381             /* we're currently re-reading tokens */
1382             yylval = *yylvp++;
1383 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1384             yylloc = *yylpp++;
1385 #endif
1386             yychar = *yylexp++;
1387             break;
1388         }
1389         if (yyps->save)
1390         {
1391             /* in trial mode; save scanner results for future parse attempts */
1392             if (yylvp == yylvlim)
1393             {   /* Enlarge lexical value queue */
1394                 size_t p = (size_t) (yylvp - yylvals);
1395                 size_t s = (size_t) (yylvlim - yylvals);
1396
1397                 s += YYLVQUEUEGROWTH;
1398                 if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
1399                 if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
1400 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1401                 if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
1402 #endif
1403                 yylvp   = yylve = yylvals + p;
1404                 yylvlim = yylvals + s;
1405 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1406                 yylpp   = yylpe = yylpsns + p;
1407                 yylplim = yylpsns + s;
1408 #endif
1409                 yylexp  = yylexemes + p;
1410             }
1411             *yylexp = (short) YYLEX;
1412             *yylvp++ = yylval;
1413             yylve++;
1414 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1415             *yylpp++ = yylloc;
1416             yylpe++;
1417 #endif
1418             yychar = *yylexp++;
1419             break;
1420         }
1421         /* normal operation, no conflict encountered */
1422 #endif /* YYBTYACC */
1423         yychar = YYLEX;
1424 #if YYBTYACC
1425         } while (0);
1426 #endif /* YYBTYACC */
1427         if (yychar < 0) yychar = YYEOF;
1428         /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1429 #if YYDEBUG
1430         if (yydebug)
1431         {
1432             yys = yyname[YYTRANSLATE(yychar)];
1433             fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
1434                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
1435 #ifdef YYSTYPE_TOSTRING
1436 #if YYBTYACC
1437             if (!yytrial)
1438 #endif /* YYBTYACC */
1439                 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
1440 #endif
1441             fputc('\n', stderr);
1442         }
1443 #endif
1444     }
1445 #if YYBTYACC
1446
1447     /* Do we have a conflict? */
1448     if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1449         yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1450     {
1451         YYINT ctry;
1452
1453         if (yypath)
1454         {
1455             YYParseState *save;
1456 #if YYDEBUG
1457             if (yydebug)
1458                 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
1459                                 YYDEBUGSTR, yydepth, yystate);
1460 #endif
1461             /* Switch to the next conflict context */
1462             save = yypath;
1463             yypath = save->save;
1464             save->save = NULL;
1465             ctry = save->ctry;
1466             if (save->state != yystate) YYABORT;
1467             yyFreeState(save);
1468
1469         }
1470         else
1471         {
1472
1473             /* Unresolved conflict - start/continue trial parse */
1474             YYParseState *save;
1475 #if YYDEBUG
1476             if (yydebug)
1477             {
1478                 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
1479                 if (yyps->save)
1480                     fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
1481                 else
1482                     fputs("Starting trial parse.\n", stderr);
1483             }
1484 #endif
1485             save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1486             if (save == NULL) goto yyenomem;
1487             save->save            = yyps->save;
1488             save->state           = yystate;
1489             save->errflag         = yyerrflag;
1490             save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
1491             memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1492             save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
1493             memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1494 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1495             save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
1496             memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1497 #endif
1498             ctry                  = yytable[yyn];
1499             if (yyctable[ctry] == -1)
1500             {
1501 #if YYDEBUG
1502                 if (yydebug && yychar >= YYEOF)
1503                     fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
1504 #endif
1505                 ctry++;
1506             }
1507             save->ctry = ctry;
1508             if (yyps->save == NULL)
1509             {
1510                 /* If this is a first conflict in the stack, start saving lexemes */
1511                 if (!yylexemes)
1512                 {
1513                     yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
1514                     if (yylexemes == NULL) goto yyenomem;
1515                     yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
1516                     if (yylvals == NULL) goto yyenomem;
1517                     yylvlim   = yylvals + YYLVQUEUEGROWTH;
1518 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1519                     yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
1520                     if (yylpsns == NULL) goto yyenomem;
1521                     yylplim   = yylpsns + YYLVQUEUEGROWTH;
1522 #endif
1523                 }
1524                 if (yylvp == yylve)
1525                 {
1526                     yylvp  = yylve = yylvals;
1527 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1528                     yylpp  = yylpe = yylpsns;
1529 #endif
1530                     yylexp = yylexemes;
1531                     if (yychar >= YYEOF)
1532                     {
1533                         *yylve++ = yylval;
1534 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1535                         *yylpe++ = yylloc;
1536 #endif
1537                         *yylexp  = (short) yychar;
1538                         yychar   = YYEMPTY;
1539                     }
1540                 }
1541             }
1542             if (yychar >= YYEOF)
1543             {
1544                 yylvp--;
1545 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1546                 yylpp--;
1547 #endif
1548                 yylexp--;
1549                 yychar = YYEMPTY;
1550             }
1551             save->lexeme = (int) (yylvp - yylvals);
1552             yyps->save   = save;
1553         }
1554         if (yytable[yyn] == ctry)
1555         {
1556 #if YYDEBUG
1557             if (yydebug)
1558                 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1559                                 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1560 #endif
1561             if (yychar < 0)
1562             {
1563                 yylvp++;
1564 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1565                 yylpp++;
1566 #endif
1567                 yylexp++;
1568             }
1569             if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1570                 goto yyoverflow;
1571             yystate = yyctable[ctry];
1572             *++yystack.s_mark = (short) yystate;
1573             *++yystack.l_mark = yylval;
1574 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1575             *++yystack.p_mark = yylloc;
1576 #endif
1577             yychar  = YYEMPTY;
1578             if (yyerrflag > 0) --yyerrflag;
1579             goto yyloop;
1580         }
1581         else
1582         {
1583             yyn = yyctable[ctry];
1584             goto yyreduce;
1585         }
1586     } /* End of code dealing with conflicts */
1587 #endif /* YYBTYACC */
1588     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1589             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1590     {
1591 #if YYDEBUG
1592         if (yydebug)
1593             fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1594                             YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1595 #endif
1596         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1597         yystate = yytable[yyn];
1598         *++yystack.s_mark = yytable[yyn];
1599         *++yystack.l_mark = yylval;
1600 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1601         *++yystack.p_mark = yylloc;
1602 #endif
1603         yychar = YYEMPTY;
1604         if (yyerrflag > 0)  --yyerrflag;
1605         goto yyloop;
1606     }
1607     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1608             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1609     {
1610         yyn = yytable[yyn];
1611         goto yyreduce;
1612     }
1613     if (yyerrflag != 0) goto yyinrecovery;
1614 #if YYBTYACC
1615
1616     yynewerrflag = 1;
1617     goto yyerrhandler;
1618     goto yyerrlab;
1619
1620 yyerrlab:
1621     yynewerrflag = 0;
1622 yyerrhandler:
1623     while (yyps->save)
1624     {
1625         int ctry;
1626         YYParseState *save = yyps->save;
1627 #if YYDEBUG
1628         if (yydebug)
1629             fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1630                             YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1631                     (int)(yylvp - yylvals - yyps->save->lexeme));
1632 #endif
1633         /* Memorize most forward-looking error state in case it's really an error. */
1634         if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1635         {
1636             /* Free old saved error context state */
1637             if (yyerrctx) yyFreeState(yyerrctx);
1638             /* Create and fill out new saved error context state */
1639             yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1640             if (yyerrctx == NULL) goto yyenomem;
1641             yyerrctx->save           = yyps->save;
1642             yyerrctx->state          = yystate;
1643             yyerrctx->errflag        = yyerrflag;
1644             yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1645             memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1646             yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1647             memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1648 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1649             yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1650             memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1651 #endif
1652             yyerrctx->lexeme         = (int) (yylvp - yylvals);
1653         }
1654         yylvp          = yylvals   + save->lexeme;
1655 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1656         yylpp          = yylpsns   + save->lexeme;
1657 #endif
1658         yylexp         = yylexemes + save->lexeme;
1659         yychar         = YYEMPTY;
1660         yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1661         memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1662         yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1663         memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1664 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1665         yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1666         memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1667 #endif
1668         ctry           = ++save->ctry;
1669         yystate        = save->state;
1670         /* We tried shift, try reduce now */
1671         if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1672         yyps->save     = save->save;
1673         save->save     = NULL;
1674         yyFreeState(save);
1675
1676         /* Nothing left on the stack -- error */
1677         if (!yyps->save)
1678         {
1679 #if YYDEBUG
1680             if (yydebug)
1681                 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1682                                 YYPREFIX, yydepth);
1683 #endif
1684             /* Restore state as it was in the most forward-advanced error */
1685             yylvp          = yylvals   + yyerrctx->lexeme;
1686 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1687             yylpp          = yylpsns   + yyerrctx->lexeme;
1688 #endif
1689             yylexp         = yylexemes + yyerrctx->lexeme;
1690             yychar         = yylexp[-1];
1691             yylval         = yylvp[-1];
1692 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1693             yylloc         = yylpp[-1];
1694 #endif
1695             yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1696             memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1697             yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1698             memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1699 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1700             yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1701             memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1702 #endif
1703             yystate        = yyerrctx->state;
1704             yyFreeState(yyerrctx);
1705             yyerrctx       = NULL;
1706         }
1707         yynewerrflag = 1;
1708     }
1709     if (yynewerrflag == 0) goto yyinrecovery;
1710 #endif /* YYBTYACC */
1711
1712     YYERROR_CALL("syntax error");
1713 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1714     yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1715 #endif
1716
1717 #if !YYBTYACC
1718     goto yyerrlab;
1719 yyerrlab:
1720 #endif
1721     ++yynerrs;
1722
1723 yyinrecovery:
1724     if (yyerrflag < 3)
1725     {
1726         yyerrflag = 3;
1727         for (;;)
1728         {
1729             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1730                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1731             {
1732 #if YYDEBUG
1733                 if (yydebug)
1734                     fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1735                                     YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1736 #endif
1737                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1738                 yystate = yytable[yyn];
1739                 *++yystack.s_mark = yytable[yyn];
1740                 *++yystack.l_mark = yylval;
1741 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1742                 /* lookahead position is error end position */
1743                 yyerror_loc_range[1] = yylloc;
1744                 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1745                 *++yystack.p_mark = yyloc;
1746 #endif
1747                 goto yyloop;
1748             }
1749             else
1750             {
1751 #if YYDEBUG
1752                 if (yydebug)
1753                     fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1754                                     YYDEBUGSTR, yydepth, *yystack.s_mark);
1755 #endif
1756                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1757 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1758                 /* the current TOS position is the error start position */
1759                 yyerror_loc_range[0] = *yystack.p_mark;
1760 #endif
1761 #if defined(YYDESTRUCT_CALL)
1762 #if YYBTYACC
1763                 if (!yytrial)
1764 #endif /* YYBTYACC */
1765 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1766                     YYDESTRUCT_CALL("error: discarding state",
1767                                     yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1768 #else
1769                     YYDESTRUCT_CALL("error: discarding state",
1770                                     yystos[*yystack.s_mark], yystack.l_mark);
1771 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1772 #endif /* defined(YYDESTRUCT_CALL) */
1773                 --yystack.s_mark;
1774                 --yystack.l_mark;
1775 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1776                 --yystack.p_mark;
1777 #endif
1778             }
1779         }
1780     }
1781     else
1782     {
1783         if (yychar == YYEOF) goto yyabort;
1784 #if YYDEBUG
1785         if (yydebug)
1786         {
1787             yys = yyname[YYTRANSLATE(yychar)];
1788             fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1789                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
1790         }
1791 #endif
1792 #if defined(YYDESTRUCT_CALL)
1793 #if YYBTYACC
1794         if (!yytrial)
1795 #endif /* YYBTYACC */
1796 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1797             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1798 #else
1799             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1800 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1801 #endif /* defined(YYDESTRUCT_CALL) */
1802         yychar = YYEMPTY;
1803         goto yyloop;
1804     }
1805
1806 yyreduce:
1807     yym = yylen[yyn];
1808 #if YYDEBUG
1809     if (yydebug)
1810     {
1811         fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1812                         YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1813 #ifdef YYSTYPE_TOSTRING
1814 #if YYBTYACC
1815         if (!yytrial)
1816 #endif /* YYBTYACC */
1817             if (yym > 0)
1818             {
1819                 int i;
1820                 fputc('<', stderr);
1821                 for (i = yym; i > 0; i--)
1822                 {
1823                     if (i != yym) fputs(", ", stderr);
1824                     fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1825                                            yystack.l_mark[1-i]), stderr);
1826                 }
1827                 fputc('>', stderr);
1828             }
1829 #endif
1830         fputc('\n', stderr);
1831     }
1832 #endif
1833     if (yym > 0)
1834         yyval = yystack.l_mark[1-yym];
1835     else
1836         memset(&yyval, 0, sizeof yyval);
1837 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1838
1839     /* Perform position reduction */
1840     memset(&yyloc, 0, sizeof(yyloc));
1841 #if YYBTYACC
1842     if (!yytrial)
1843 #endif /* YYBTYACC */
1844     {
1845         YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1846         /* just in case YYERROR is invoked within the action, save
1847            the start of the rhs as the error start position */
1848         yyerror_loc_range[0] = yystack.p_mark[1-yym];
1849     }
1850 #endif
1851
1852     switch (yyn)
1853     {
1854 case 1:
1855 #line 93 "btyacc_demo.y"
1856 { yyval.scope = yystack.l_mark[0].scope; }
1857 break;
1858 case 2:
1859 #line 94 "btyacc_demo.y"
1860 { yyval.scope = global_scope; }
1861 break;
1862 case 3:
1863 #line 95 "btyacc_demo.y"
1864 { Decl *d = lookup(yystack.l_mark[-2].scope, yystack.l_mark[-1].id);
1865                           if (!d || !d->scope) YYERROR;
1866                           yyval.scope = d->scope; }
1867 break;
1868 case 4:
1869 #line 101 "btyacc_demo.y"
1870 { Decl *d = lookup(yystack.l_mark[-1].scope, yystack.l_mark[0].id);
1871         if (d == NULL || d->istype() == 0) YYERROR;
1872         yyval.type = d->type; }
1873 break;
1874 case 5:
1875 #line 106 "btyacc_demo.y"
1876 yyval.scope = global_scope = new_scope(0);
1877 break;
1878 case 8:
1879 #line 107 "btyacc_demo.y"
1880 yyval.scope = yystack.l_mark[-1].scope;
1881 break;
1882 case 10:
1883 #line 109 "btyacc_demo.y"
1884 yyval.type = yystack.l_mark[-1].type;
1885 break;
1886 case 11:
1887 #line 109 "btyacc_demo.y"
1888 {YYVALID;}
1889 break;
1890 case 12:
1891 #line 110 "btyacc_demo.y"
1892 yyval.scope = start_fn_def(yystack.l_mark[-4].scope, yystack.l_mark[0].decl);
1893 break;
1894 case 13:
1895   if (!yytrial)
1896 #line 111 "btyacc_demo.y"
1897         { /* demonstrate use of @$ & @N, although this is just the
1898            default computation and so is not necessary */
1899         yyloc.first_line   = yystack.p_mark[-5].first_line;
1900         yyloc.first_column = yystack.p_mark[-5].first_column;
1901         yyloc.last_line    = yystack.p_mark[0].last_line;
1902         yyloc.last_column  = yystack.p_mark[0].last_column;
1903         finish_fn_def(yystack.l_mark[-2].decl, yystack.l_mark[0].code); }
1904 break;
1905 case 14:
1906 #line 121 "btyacc_demo.y"
1907 { yyval.type = yystack.l_mark[0].type; }
1908 break;
1909 case 15:
1910 #line 122 "btyacc_demo.y"
1911 { yyval.type = type_combine(yystack.l_mark[-2].type, yystack.l_mark[0].type); }
1912 break;
1913 case 16:
1914 #line 125 "btyacc_demo.y"
1915 { yyval.type = 0; }
1916 break;
1917 case 17:
1918 #line 126 "btyacc_demo.y"
1919 { yyval.type = type_combine(yystack.l_mark[-1].type, yystack.l_mark[0].type); }
1920 break;
1921 case 18:
1922 #line 130 "btyacc_demo.y"
1923 { yyval.type = yystack.l_mark[0].type; }
1924 break;
1925 case 19:
1926 #line 131 "btyacc_demo.y"
1927 { yyval.type = yystack.l_mark[0].type; }
1928 break;
1929 case 20:
1930 #line 132 "btyacc_demo.y"
1931 { yyval.type = bare_extern(); }
1932 break;
1933 case 21:
1934 #line 133 "btyacc_demo.y"
1935 { yyval.type = bare_register(); }
1936 break;
1937 case 22:
1938 #line 134 "btyacc_demo.y"
1939 { yyval.type = bare_static(); }
1940 break;
1941 case 23:
1942 #line 138 "btyacc_demo.y"
1943 { yyval.type = bare_const(); }
1944 break;
1945 case 24:
1946 #line 139 "btyacc_demo.y"
1947 { yyval.type = bare_volatile(); }
1948 break;
1949 case 25:
1950 #line 143 "btyacc_demo.y"
1951 yyval.scope = yystack.l_mark[-3].scope;
1952 break;
1953 case 26:
1954 #line 143 "btyacc_demo.y"
1955 yyval.type =  yystack.l_mark[-3].type;
1956 break;
1957 case 29:
1958 #line 148 "btyacc_demo.y"
1959 { if (!yystack.l_mark[0].type) YYERROR; }  if (!yytrial)
1960 #line 149 "btyacc_demo.y"
1961 { yyval.decl = declare(yystack.l_mark[-1].scope, 0, yystack.l_mark[0].type); }
1962 break;
1963 case 30:
1964   if (!yytrial)
1965 #line 150 "btyacc_demo.y"
1966         { yyval.decl = declare(yystack.l_mark[-2].scope, yystack.l_mark[0].id, yystack.l_mark[-1].type); }
1967 break;
1968 case 31:
1969 #line 151 "btyacc_demo.y"
1970 yyval.scope = yystack.l_mark[-2].scope;
1971 break;
1972 case 32:
1973 #line 151 "btyacc_demo.y"
1974 yyval.type =  yystack.l_mark[-2].type;
1975 break;
1976 case 33:
1977   if (!yytrial)
1978 #line 151 "btyacc_demo.y"
1979         { yyval.decl = yystack.l_mark[-1].decl; }
1980 break;
1981 case 34:
1982   if (!yytrial)
1983 #line 153 "btyacc_demo.y"
1984         { yyval.decl = make_pointer(yystack.l_mark[0].decl, yystack.l_mark[-3].type); }
1985 break;
1986 case 35:
1987   if (!yytrial)
1988 #line 155 "btyacc_demo.y"
1989         { yyval.decl = make_array(yystack.l_mark[-4].decl->type, yystack.l_mark[-1].expr); }
1990 break;
1991 case 36:
1992   if (!yytrial)
1993 #line 157 "btyacc_demo.y"
1994         { yyval.decl = build_function(yystack.l_mark[-5].decl, yystack.l_mark[-2].dlist, yystack.l_mark[0].type); }
1995 break;
1996 case 37:
1997   if (!yytrial)
1998 #line 160 "btyacc_demo.y"
1999         { yyval.dlist = 0; }
2000 break;
2001 case 38:
2002   if (!yytrial)
2003 #line 161 "btyacc_demo.y"
2004         { yyval.dlist = yystack.l_mark[0].dlist; }
2005 break;
2006 case 39:
2007   if (!yytrial)
2008 #line 164 "btyacc_demo.y"
2009         { yyval.dlist = append_dlist(yystack.l_mark[-3].dlist, yystack.l_mark[0].decl); }
2010 break;
2011 case 40:
2012   if (!yytrial)
2013 #line 165 "btyacc_demo.y"
2014         { yyval.dlist = build_dlist(yystack.l_mark[0].decl); }
2015 break;
2016 case 41:
2017   if (!yytrial)
2018 #line 168 "btyacc_demo.y"
2019         { yyval.decl = yystack.l_mark[0].decl; }
2020 break;
2021 case 42:
2022   if (!yytrial)
2023 #line 172 "btyacc_demo.y"
2024         { yyval.expr = build_expr(yystack.l_mark[-3].expr, ADD, yystack.l_mark[0].expr); }
2025 break;
2026 case 43:
2027   if (!yytrial)
2028 #line 173 "btyacc_demo.y"
2029         { yyval.expr = build_expr(yystack.l_mark[-3].expr, SUB, yystack.l_mark[0].expr); }
2030 break;
2031 case 44:
2032   if (!yytrial)
2033 #line 174 "btyacc_demo.y"
2034         { yyval.expr = build_expr(yystack.l_mark[-3].expr, MUL, yystack.l_mark[0].expr); }
2035 break;
2036 case 45:
2037   if (!yytrial)
2038 #line 175 "btyacc_demo.y"
2039         { yyval.expr = build_expr(yystack.l_mark[-3].expr, MOD, yystack.l_mark[0].expr); }
2040 break;
2041 case 46:
2042   if (!yytrial)
2043 #line 176 "btyacc_demo.y"
2044         { yyval.expr = build_expr(yystack.l_mark[-3].expr, DIV, yystack.l_mark[0].expr); }
2045 break;
2046 case 47:
2047   if (!yytrial)
2048 #line 177 "btyacc_demo.y"
2049         { yyval.expr = build_expr(0, DEREF, yystack.l_mark[0].expr); }
2050 break;
2051 case 48:
2052   if (!yytrial)
2053 #line 178 "btyacc_demo.y"
2054         { yyval.expr = var_expr(yystack.l_mark[-1].scope, yystack.l_mark[0].id); }
2055 break;
2056 case 49:
2057   if (!yytrial)
2058 #line 179 "btyacc_demo.y"
2059         { yyval.expr = yystack.l_mark[0].expr; }
2060 break;
2061 case 50:
2062   if (!yytrial)
2063 #line 183 "btyacc_demo.y"
2064         { yyval.code = 0; }
2065 break;
2066 case 51:
2067 #line 184 "btyacc_demo.y"
2068 yyval.scope = yystack.l_mark[0].scope;
2069 break;
2070 case 52:
2071 #line 184 "btyacc_demo.y"
2072 {YYVALID;}  if (!yytrial)
2073 #line 184 "btyacc_demo.y"
2074 { yyval.code = build_expr_code(yystack.l_mark[-1].expr); }
2075 break;
2076 case 53:
2077 #line 185 "btyacc_demo.y"
2078 yyval.scope = yystack.l_mark[-6].scope;
2079 break;
2080 case 54:
2081 #line 185 "btyacc_demo.y"
2082 yyval.scope = yystack.l_mark[-9].scope;
2083 break;
2084 case 55:
2085 #line 185 "btyacc_demo.y"
2086 {YYVALID;}  if (!yytrial)
2087 #line 186 "btyacc_demo.y"
2088 { yyval.code = build_if(yystack.l_mark[-7].expr, yystack.l_mark[-3].code, yystack.l_mark[0].code); }
2089 break;
2090 case 56:
2091 #line 187 "btyacc_demo.y"
2092 {YYVALID;}  if (!yytrial)
2093 #line 188 "btyacc_demo.y"
2094 { yyval.code = build_if(yystack.l_mark[-4].expr, yystack.l_mark[0].code, 0); }
2095 break;
2096 case 57:
2097 #line 189 "btyacc_demo.y"
2098 yyval.scope = new_scope(yystack.l_mark[0].scope);
2099 break;
2100 case 58:
2101 #line 189 "btyacc_demo.y"
2102 {YYVALID;}  if (!yytrial)
2103 #line 189 "btyacc_demo.y"
2104 { yyval.code = yystack.l_mark[0].code; }
2105 break;
2106 case 59:
2107   if (!yytrial)
2108 #line 192 "btyacc_demo.y"
2109         { yyval.code = 0; }
2110 break;
2111 case 60:
2112   if (!yytrial)
2113 #line 193 "btyacc_demo.y"
2114         { yyval.code = code_append(yystack.l_mark[-2].code, yystack.l_mark[0].code); }
2115 break;
2116 case 61:
2117   if (!yytrial)
2118 #line 197 "btyacc_demo.y"
2119         { yyval.code = yystack.l_mark[-1].code; }
2120 break;
2121 #line 2122 "btyacc_demo.tab.c"
2122     default:
2123         break;
2124     }
2125     yystack.s_mark -= yym;
2126     yystate = *yystack.s_mark;
2127     yystack.l_mark -= yym;
2128 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2129     yystack.p_mark -= yym;
2130 #endif
2131     yym = yylhs[yyn];
2132     if (yystate == 0 && yym == 0)
2133     {
2134 #if YYDEBUG
2135         if (yydebug)
2136         {
2137             fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2138 #ifdef YYSTYPE_TOSTRING
2139 #if YYBTYACC
2140             if (!yytrial)
2141 #endif /* YYBTYACC */
2142                 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
2143 #endif
2144             fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
2145         }
2146 #endif
2147         yystate = YYFINAL;
2148         *++yystack.s_mark = YYFINAL;
2149         *++yystack.l_mark = yyval;
2150 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2151         *++yystack.p_mark = yyloc;
2152 #endif
2153         if (yychar < 0)
2154         {
2155 #if YYBTYACC
2156             do {
2157             if (yylvp < yylve)
2158             {
2159                 /* we're currently re-reading tokens */
2160                 yylval = *yylvp++;
2161 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2162                 yylloc = *yylpp++;
2163 #endif
2164                 yychar = *yylexp++;
2165                 break;
2166             }
2167             if (yyps->save)
2168             {
2169                 /* in trial mode; save scanner results for future parse attempts */
2170                 if (yylvp == yylvlim)
2171                 {   /* Enlarge lexical value queue */
2172                     size_t p = (size_t) (yylvp - yylvals);
2173                     size_t s = (size_t) (yylvlim - yylvals);
2174
2175                     s += YYLVQUEUEGROWTH;
2176                     if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL)
2177                         goto yyenomem;
2178                     if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
2179                         goto yyenomem;
2180 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2181                     if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
2182                         goto yyenomem;
2183 #endif
2184                     yylvp   = yylve = yylvals + p;
2185                     yylvlim = yylvals + s;
2186 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2187                     yylpp   = yylpe = yylpsns + p;
2188                     yylplim = yylpsns + s;
2189 #endif
2190                     yylexp  = yylexemes + p;
2191                 }
2192                 *yylexp = (short) YYLEX;
2193                 *yylvp++ = yylval;
2194                 yylve++;
2195 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2196                 *yylpp++ = yylloc;
2197                 yylpe++;
2198 #endif
2199                 yychar = *yylexp++;
2200                 break;
2201             }
2202             /* normal operation, no conflict encountered */
2203 #endif /* YYBTYACC */
2204             yychar = YYLEX;
2205 #if YYBTYACC
2206             } while (0);
2207 #endif /* YYBTYACC */
2208             if (yychar < 0) yychar = YYEOF;
2209             /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
2210 #if YYDEBUG
2211             if (yydebug)
2212             {
2213                 yys = yyname[YYTRANSLATE(yychar)];
2214                 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
2215                                 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
2216             }
2217 #endif
2218         }
2219         if (yychar == YYEOF) goto yyaccept;
2220         goto yyloop;
2221     }
2222     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
2223             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
2224         yystate = yytable[yyn];
2225     else
2226         yystate = yydgoto[yym];
2227 #if YYDEBUG
2228     if (yydebug)
2229     {
2230         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2231 #ifdef YYSTYPE_TOSTRING
2232 #if YYBTYACC
2233         if (!yytrial)
2234 #endif /* YYBTYACC */
2235             fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
2236 #endif
2237         fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
2238     }
2239 #endif
2240     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2241     *++yystack.s_mark = (short) yystate;
2242     *++yystack.l_mark = yyval;
2243 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2244     *++yystack.p_mark = yyloc;
2245 #endif
2246     goto yyloop;
2247 #if YYBTYACC
2248
2249     /* Reduction declares that this path is valid. Set yypath and do a full parse */
2250 yyvalid:
2251     if (yypath) YYABORT;
2252     while (yyps->save)
2253     {
2254         YYParseState *save = yyps->save;
2255         yyps->save = save->save;
2256         save->save = yypath;
2257         yypath = save;
2258     }
2259 #if YYDEBUG
2260     if (yydebug)
2261         fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
2262                         YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
2263 #endif
2264     if (yyerrctx)
2265     {
2266         yyFreeState(yyerrctx);
2267         yyerrctx = NULL;
2268     }
2269     yylvp          = yylvals + yypath->lexeme;
2270 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2271     yylpp          = yylpsns + yypath->lexeme;
2272 #endif
2273     yylexp         = yylexemes + yypath->lexeme;
2274     yychar         = YYEMPTY;
2275     yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
2276     memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
2277     yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
2278     memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2279 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2280     yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
2281     memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2282 #endif
2283     yystate        = yypath->state;
2284     goto yyloop;
2285 #endif /* YYBTYACC */
2286
2287 yyoverflow:
2288     YYERROR_CALL("yacc stack overflow");
2289 #if YYBTYACC
2290     goto yyabort_nomem;
2291 yyenomem:
2292     YYERROR_CALL("memory exhausted");
2293 yyabort_nomem:
2294 #endif /* YYBTYACC */
2295     yyresult = 2;
2296     goto yyreturn;
2297
2298 yyabort:
2299     yyresult = 1;
2300     goto yyreturn;
2301
2302 yyaccept:
2303 #if YYBTYACC
2304     if (yyps->save) goto yyvalid;
2305 #endif /* YYBTYACC */
2306     yyresult = 0;
2307
2308 yyreturn:
2309 #if defined(YYDESTRUCT_CALL)
2310     if (yychar != YYEOF && yychar != YYEMPTY)
2311 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2312         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
2313 #else
2314         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
2315 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2316
2317     {
2318         YYSTYPE *pv;
2319 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2320         YYLTYPE *pp;
2321
2322         for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
2323              YYDESTRUCT_CALL("cleanup: discarding state",
2324                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
2325 #else
2326         for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
2327              YYDESTRUCT_CALL("cleanup: discarding state",
2328                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
2329 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2330     }
2331 #endif /* defined(YYDESTRUCT_CALL) */
2332
2333 #if YYBTYACC
2334     if (yyerrctx)
2335     {
2336         yyFreeState(yyerrctx);
2337         yyerrctx = NULL;
2338     }
2339     while (yyps)
2340     {
2341         YYParseState *save = yyps;
2342         yyps = save->save;
2343         save->save = NULL;
2344         yyFreeState(save);
2345     }
2346     while (yypath)
2347     {
2348         YYParseState *save = yypath;
2349         yypath = save->save;
2350         save->save = NULL;
2351         yyFreeState(save);
2352     }
2353 #endif /* YYBTYACC */
2354     yyfreestack(&yystack);
2355     return (yyresult);
2356 }