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

   1 /* original parser id follows */
   2 /* yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93" */
   3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on 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 0
  18 #define YYDEBUGSTR YYPREFIX "debug"
  19
  20 #ifndef yyparse
  21 #define yyparse    ok_syntax1_parse
  22 #endif /* yyparse */
  23
  24 #ifndef yylex
  25 #define yylex      ok_syntax1_lex
  26 #endif /* yylex */
  27
  28 #ifndef yyerror
  29 #define yyerror    ok_syntax1_error
  30 #endif /* yyerror */
  31
  32 #ifndef yychar
  33 #define yychar     ok_syntax1_char
  34 #endif /* yychar */
  35
  36 #ifndef yyval
  37 #define yyval      ok_syntax1_val
  38 #endif /* yyval */
  39
  40 #ifndef yylval
  41 #define yylval     ok_syntax1_lval
  42 #endif /* yylval */
  43
  44 #ifndef yydebug
  45 #define yydebug    ok_syntax1_debug
  46 #endif /* yydebug */
  47
  48 #ifndef yynerrs
  49 #define yynerrs    ok_syntax1_nerrs
  50 #endif /* yynerrs */
  51
  52 #ifndef yyerrflag
  53 #define yyerrflag  ok_syntax1_errflag
  54 #endif /* yyerrflag */
  55
  56 #ifndef yylhs
  57 #define yylhs      ok_syntax1_lhs
  58 #endif /* yylhs */
  59
  60 #ifndef yylen
  61 #define yylen      ok_syntax1_len
  62 #endif /* yylen */
  63
  64 #ifndef yydefred
  65 #define yydefred   ok_syntax1_defred
  66 #endif /* yydefred */
  67
  68 #ifndef yystos
  69 #define yystos     ok_syntax1_stos
  70 #endif /* yystos */
  71
  72 #ifndef yydgoto
  73 #define yydgoto    ok_syntax1_dgoto
  74 #endif /* yydgoto */
  75
  76 #ifndef yysindex
  77 #define yysindex   ok_syntax1_sindex
  78 #endif /* yysindex */
  79
  80 #ifndef yyrindex
  81 #define yyrindex   ok_syntax1_rindex
  82 #endif /* yyrindex */
  83
  84 #ifndef yygindex
  85 #define yygindex   ok_syntax1_gindex
  86 #endif /* yygindex */
  87
  88 #ifndef yytable
  89 #define yytable    ok_syntax1_table
  90 #endif /* yytable */
  91
  92 #ifndef yycheck
  93 #define yycheck    ok_syntax1_check
  94 #endif /* yycheck */
  95
  96 #ifndef yyname
  97 #define yyname     ok_syntax1_name
  98 #endif /* yyname */
  99
 100 #ifndef yyrule
 101 #define yyrule     ok_syntax1_rule
 102 #endif /* yyrule */
 103
 104 #if YYBTYACC
 105
 106 #ifndef yycindex
 107 #define yycindex   ok_syntax1_cindex
 108 #endif /* yycindex */
 109
 110 #ifndef yyctable
 111 #define yyctable   ok_syntax1_ctable
 112 #endif /* yyctable */
 113
 114 #endif /* YYBTYACC */
 115
 116 #define YYPREFIX "ok_syntax1_"
 117
 118 #define YYPURE 1
 119
 120 #line 9 "ok_syntax1.y"
 121 # include <stdio.h>
 122 # include <ctype.h>
 123
 124 #ifdef YYBISON
 125 #define YYSTYPE int
 126 #define YYLEX_PARAM base
 127 #define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
 128 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
 129 int YYLEX_DECL();
 130 static void YYERROR_DECL();
 131 #endif
 132
 133 #ifdef YYSTYPE
 134 #undef  YYSTYPE_IS_DECLARED
 135 #define YYSTYPE_IS_DECLARED 1
 136 #endif
 137 #ifndef YYSTYPE_IS_DECLARED
 138 #define YYSTYPE_IS_DECLARED 1
 139 #line 43 "ok_syntax1.y"
 140 typedef union
 141 {
 142     char *      cval;
 143     int         ival;
 144     double      dval;
 145 } YYSTYPE;
 146 #endif /* !YYSTYPE_IS_DECLARED */
 147 #line 148 "ok_syntax1.tab.c"
 148
 149 /* compatibility with bison */
 150 #ifdef YYPARSE_PARAM
 151 /* compatibility with FreeBSD */
 152 # ifdef YYPARSE_PARAM_TYPE
 153 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 154 # else
 155 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 156 # endif
 157 #else
 158 # define YYPARSE_DECL() yyparse(int regs[26], int *base)
 159 #endif
 160
 161 /* Parameters sent to lex. */
 162 #ifdef YYLEX_PARAM
 163 # ifdef YYLEX_PARAM_TYPE
 164 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
 165 # else
 166 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
 167 # endif
 168 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 169 #else
 170 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
 171 # define YYLEX yylex(&yylval, base)
 172 #endif
 173
 174 /* Parameters sent to yyerror. */
 175 #ifndef YYERROR_DECL
 176 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
 177 #endif
 178 #ifndef YYERROR_CALL
 179 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
 180 #endif
 181
 182 extern int YYPARSE_DECL();
 183
 184 #define DIGIT 257
 185 #define LETTER 258
 186 #define OCT1 259
 187 #define HEX1 260
 188 #define HEX2 261
 189 #define HEX3 262
 190 #define STR1 263
 191 #define STR2 265
 192 #define BELL 266
 193 #define BS 267
 194 #define NL 268
 195 #define LF 269
 196 #define CR 270
 197 #define TAB 271
 198 #define VT 272
 199 #define UMINUS 273
 200 #define YYERRCODE 256
 201 typedef short YYINT;
 202 static const YYINT ok_syntax1_lhs[] = {                  -1,
 203     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 204     2,    2,    2,    2,    2,    2,    3,    3,
 205 };
 206 static const YYINT ok_syntax1_len[] = {                   2,
 207     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 208     3,    3,    3,    2,    1,    1,    1,    2,
 209 };
 210 static const YYINT ok_syntax1_defred[] = {                1,
 211     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 212     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 213     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 214    10,   11,
 215 };
 216 static const YYINT ok_syntax1_stos[] = {                  0,
 217   275,  256,  257,  258,   45,   40,  276,  277,  278,   10,
 218    61,  258,  277,  277,   10,  124,   38,   43,   45,   42,
 219    47,   37,  257,  277,   41,  277,  277,  277,  277,  277,
 220   277,  277,
 221 };
 222 static const YYINT ok_syntax1_dgoto[] = {                 1,
 223     7,    8,    9,
 224 };
 225 static const YYINT ok_syntax1_sindex[] = {                0,
 226   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 227   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 228   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 229     0,    0,
 230 };
 231 static const YYINT ok_syntax1_rindex[] = {                0,
 232     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 233     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 234     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 235     0,    0,
 236 };
 237 #if YYBTYACC
 238 static const YYINT ok_syntax1_cindex[] = {                0,
 239     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 240     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 241     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 242     0,    0,
 243 };
 244 #endif
 245 static const YYINT ok_syntax1_gindex[] = {                0,
 246     0,   65,    0,
 247 };
 248 #define YYTABLESIZE 220
 249 static const YYINT ok_syntax1_table[] = {                 6,
 250    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 251    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 252     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 253     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 254     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 255     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 256     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 257    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 258    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 259     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 260     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 261     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 262     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 263     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 264     0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
 265     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 266     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 267     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 268     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 269     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 270     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 271     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 272 };
 273 static const YYINT ok_syntax1_check[] = {                40,
 274    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 275    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 276    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 277    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 278    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 279    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 280    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 281     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 282    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 283    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 284    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 285    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 286    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 287    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 288    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
 289    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 290    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 291    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 292    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 293    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 294    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 295    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 296 };
 297 #if YYBTYACC
 298 static const YYINT ok_syntax1_ctable[] = {               -1,
 299    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 300    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 301    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 302    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 303    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 304    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 305    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 306    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 307    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 308    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 309    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 310    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 311    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 312    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 313    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 314    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 315    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 316    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 317    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 318    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 319    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 320    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 321 };
 322 #endif
 323 #define YYFINAL 1
 324 #ifndef YYDEBUG
 325 #define YYDEBUG 0
 326 #endif
 327 #define YYMAXTOKEN 273
 328 #define YYUNDFTOKEN 279
 329 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 330 #if YYDEBUG
 331 static const char *const ok_syntax1_name[] = {
 332
 333 "$end",0,0,0,0,0,0,"'\\a'","'\\b'","'\\t'","'\\n'","'\\v'","'\\f'","'\\r'",0,0,
 334 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'#'",0,"'%'","'&'",0,"'('","')'","'*'",
 335 "'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,"'='",0,0,"'@'",0,0,0,0,0,0,0,0,
 336 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 337 0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,"'~'","'\\177'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 338 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 339 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 340 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'\\377'",
 341 "error","DIGIT","LETTER","OCT1","HEX1","HEX2","HEX3","STR1",
 342 "\"\\177\\177\\\\\\n\"","STR2","BELL","BS","NL","LF","CR","TAB","VT","UMINUS",
 343 "$accept","list","stat","expr","number","illegal-symbol",
 344 };
 345 static const char *const ok_syntax1_rule[] = {
 346 "$accept : list",
 347 "list :",
 348 "list : list stat '\\n'",
 349 "list : list error '\\n'",
 350 "stat : expr",
 351 "stat : LETTER '=' expr",
 352 "expr : '(' expr ')'",
 353 "expr : expr '+' expr",
 354 "expr : expr '-' expr",
 355 "expr : expr '*' expr",
 356 "expr : expr '/' expr",
 357 "expr : expr '%' expr",
 358 "expr : expr '&' expr",
 359 "expr : expr '|' expr",
 360 "expr : '-' expr",
 361 "expr : LETTER",
 362 "expr : number",
 363 "number : DIGIT",
 364 "number : number DIGIT",
 365
 366 };
 367 #endif
 368
 369 int      yydebug;
 370 int      yynerrs;
 371
 372 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 373 #ifndef YYLLOC_DEFAULT
 374 #define YYLLOC_DEFAULT(loc, rhs, n) \
 375 do \
 376 { \
 377     if (n == 0) \
 378     { \
 379         (loc).first_line   = ((rhs)[-1]).last_line; \
 380         (loc).first_column = ((rhs)[-1]).last_column; \
 381         (loc).last_line    = ((rhs)[-1]).last_line; \
 382         (loc).last_column  = ((rhs)[-1]).last_column; \
 383     } \
 384     else \
 385     { \
 386         (loc).first_line   = ((rhs)[ 0 ]).first_line; \
 387         (loc).first_column = ((rhs)[ 0 ]).first_column; \
 388         (loc).last_line    = ((rhs)[n-1]).last_line; \
 389         (loc).last_column  = ((rhs)[n-1]).last_column; \
 390     } \
 391 } while (0)
 392 #endif /* YYLLOC_DEFAULT */
 393 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 394 #if YYBTYACC
 395
 396 #ifndef YYLVQUEUEGROWTH
 397 #define YYLVQUEUEGROWTH 32
 398 #endif
 399 #endif /* YYBTYACC */
 400
 401 /* define the initial stack-sizes */
 402 #ifdef YYSTACKSIZE
 403 #undef YYMAXDEPTH
 404 #define YYMAXDEPTH  YYSTACKSIZE
 405 #else
 406 #ifdef YYMAXDEPTH
 407 #define YYSTACKSIZE YYMAXDEPTH
 408 #else
 409 #define YYSTACKSIZE 10000
 410 #define YYMAXDEPTH  10000
 411 #endif
 412 #endif
 413
 414 #ifndef YYINITSTACKSIZE
 415 #define YYINITSTACKSIZE 200
 416 #endif
 417
 418 typedef struct {
 419     unsigned stacksize;
 420     YYINT    *s_base;
 421     YYINT    *s_mark;
 422     YYINT    *s_last;
 423     YYSTYPE  *l_base;
 424     YYSTYPE  *l_mark;
 425 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 426     YYLTYPE  *p_base;
 427     YYLTYPE  *p_mark;
 428 #endif
 429 } YYSTACKDATA;
 430 #if YYBTYACC
 431
 432 struct YYParseState_s
 433 {
 434     struct YYParseState_s *save;    /* Previously saved parser state */
 435     YYSTACKDATA            yystack; /* saved parser stack */
 436     int                    state;   /* saved parser state */
 437     int                    errflag; /* saved error recovery status */
 438     int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
 439     YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
 440 };
 441 typedef struct YYParseState_s YYParseState;
 442 #endif /* YYBTYACC */
 443 #line 104 "ok_syntax1.y"
 444  /* start of programs */
 445
 446 #ifdef YYBYACC
 447 extern int YYLEX_DECL();
 448 #endif
 449
 450 int
 451 main (void)
 452 {
 453     int regs[26];
 454     int base = 10;
 455
 456     while(!feof(stdin)) {
 457         yyparse(regs, &base);
 458     }
 459     return 0;
 460 }
 461
 462 #define UNUSED(x) ((void)(x))
 463
 464 static void
 465 YYERROR_DECL()
 466 {
 467     UNUSED(regs); /* %parse-param regs is not actually used here */
 468     UNUSED(base); /* %parse-param base is not actually used here */
 469     fprintf(stderr, "%s\n", s);
 470 }
 471
 472 int
 473 YYLEX_DECL()
 474 {
 475         /* lexical analysis routine */
 476         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 477         /* return DIGIT for a digit, yylval = 0 through 9 */
 478         /* all other characters are returned immediately */
 479
 480     int c;
 481
 482     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 483
 484     /* c is now nonblank */
 485
 486     if( islower( c )) {
 487         yylval->ival = (c - 'a');
 488         return ( LETTER );
 489     }
 490     if( isdigit( c )) {
 491         yylval->ival = (c - '0') % (*base);
 492         return ( DIGIT );
 493     }
 494     return( c );
 495 }
 496 #line 497 "ok_syntax1.tab.c"
 497
 498 /* For use in generated program */
 499 #define yydepth (int)(yystack.s_mark - yystack.s_base)
 500 #if YYBTYACC
 501 #define yytrial (yyps->save)
 502 #endif /* YYBTYACC */
 503
 504 #if YYDEBUG
 505 #include <stdio.h>      /* needed for printf */
 506 #endif
 507
 508 #include <stdlib.h>     /* needed for malloc, etc */
 509 #include <string.h>     /* needed for memset */
 510
 511 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 512 static int yygrowstack(YYSTACKDATA *data)
 513 {
 514     int i;
 515     unsigned newsize;
 516     YYINT *newss;
 517     YYSTYPE *newvs;
 518 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 519     YYLTYPE *newps;
 520 #endif
 521
 522     if ((newsize = data->stacksize) == 0)
 523         newsize = YYINITSTACKSIZE;
 524     else if (newsize >= YYMAXDEPTH)
 525         return YYENOMEM;
 526     else if ((newsize *= 2) > YYMAXDEPTH)
 527         newsize = YYMAXDEPTH;
 528
 529     i = (int) (data->s_mark - data->s_base);
 530     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
 531     if (newss == 0)
 532         return YYENOMEM;
 533
 534     data->s_base = newss;
 535     data->s_mark = newss + i;
 536
 537     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 538     if (newvs == 0)
 539         return YYENOMEM;
 540
 541     data->l_base = newvs;
 542     data->l_mark = newvs + i;
 543
 544 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 545     newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
 546     if (newps == 0)
 547         return YYENOMEM;
 548
 549     data->p_base = newps;
 550     data->p_mark = newps + i;
 551 #endif
 552
 553     data->stacksize = newsize;
 554     data->s_last = data->s_base + newsize - 1;
 555
 556 #if YYDEBUG
 557     if (yydebug)
 558         fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
 559 #endif
 560     return 0;
 561 }
 562
 563 #if YYPURE || defined(YY_NO_LEAKS)
 564 static void yyfreestack(YYSTACKDATA *data)
 565 {
 566     free(data->s_base);
 567     free(data->l_base);
 568 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 569     free(data->p_base);
 570 #endif
 571     memset(data, 0, sizeof(*data));
 572 }
 573 #else
 574 #define yyfreestack(data) /* nothing */
 575 #endif /* YYPURE || defined(YY_NO_LEAKS) */
 576 #if YYBTYACC
 577
 578 static YYParseState *
 579 yyNewState(unsigned size)
 580 {
 581     YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
 582     if (p == NULL) return NULL;
 583
 584     p->yystack.stacksize = size;
 585     if (size == 0)
 586     {
 587         p->yystack.s_base = NULL;
 588         p->yystack.l_base = NULL;
 589 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 590         p->yystack.p_base = NULL;
 591 #endif
 592         return p;
 593     }
 594     p->yystack.s_base    = (YYINT *) malloc(size * sizeof(YYINT));
 595     if (p->yystack.s_base == NULL) return NULL;
 596     p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
 597     if (p->yystack.l_base == NULL) return NULL;
 598     memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
 599 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 600     p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
 601     if (p->yystack.p_base == NULL) return NULL;
 602     memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
 603 #endif
 604
 605     return p;
 606 }
 607
 608 static void
 609 yyFreeState(YYParseState *p)
 610 {
 611     yyfreestack(&p->yystack);
 612     free(p);
 613 }
 614 #endif /* YYBTYACC */
 615
 616 #define YYABORT  goto yyabort
 617 #define YYREJECT goto yyabort
 618 #define YYACCEPT goto yyaccept
 619 #define YYERROR  goto yyerrlab
 620 #if YYBTYACC
 621 #define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
 622 #define YYVALID_NESTED do { if (yyps->save && \
 623                                 yyps->save->save == 0) goto yyvalid; } while(0)
 624 #endif /* YYBTYACC */
 625
 626 int
 627 YYPARSE_DECL()
 628 {
 629     int      yyerrflag;
 630     int      yychar;
 631     YYSTYPE  yyval;
 632     YYSTYPE  yylval;
 633 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 634     YYLTYPE  yyloc; /* position returned by actions */
 635     YYLTYPE  yylloc; /* position from the lexer */
 636 #endif
 637
 638     /* variables for the parser stack */
 639     YYSTACKDATA yystack;
 640 #if YYBTYACC
 641
 642     /* Current parser state */
 643     static YYParseState *yyps = 0;
 644
 645     /* yypath != NULL: do the full parse, starting at *yypath parser state. */
 646     static YYParseState *yypath = 0;
 647
 648     /* Base of the lexical value queue */
 649     static YYSTYPE *yylvals = 0;
 650
 651     /* Current position at lexical value queue */
 652     static YYSTYPE *yylvp = 0;
 653
 654     /* End position of lexical value queue */
 655     static YYSTYPE *yylve = 0;
 656
 657     /* The last allocated position at the lexical value queue */
 658     static YYSTYPE *yylvlim = 0;
 659
 660 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 661     /* Base of the lexical position queue */
 662     static YYLTYPE *yylpsns = 0;
 663
 664     /* Current position at lexical position queue */
 665     static YYLTYPE *yylpp = 0;
 666
 667     /* End position of lexical position queue */
 668     static YYLTYPE *yylpe = 0;
 669
 670     /* The last allocated position at the lexical position queue */
 671     static YYLTYPE *yylplim = 0;
 672 #endif
 673
 674     /* Current position at lexical token queue */
 675     static short  *yylexp = 0;
 676
 677     static short  *yylexemes = 0;
 678 #endif /* YYBTYACC */
 679     int yym, yyn, yystate, yyresult;
 680 #if YYBTYACC
 681     int yynewerrflag;
 682     YYParseState *yyerrctx = NULL;
 683 #endif /* YYBTYACC */
 684 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 685     YYLTYPE  yyerror_loc_range[2]; /* position of error start & end */
 686 #endif
 687 #if YYDEBUG
 688     const char *yys;
 689
 690     if ((yys = getenv("YYDEBUG")) != 0)
 691     {
 692         yyn = *yys;
 693         if (yyn >= '0' && yyn <= '9')
 694             yydebug = yyn - '0';
 695     }
 696     if (yydebug)
 697         fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
 698 #endif
 699
 700 #if YYBTYACC
 701     yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
 702     yyps->save = 0;
 703 #endif /* YYBTYACC */
 704     yym = 0;
 705     yyn = 0;
 706     yynerrs = 0;
 707     yyerrflag = 0;
 708     yychar = YYEMPTY;
 709     yystate = 0;
 710
 711 #if YYPURE
 712     memset(&yystack, 0, sizeof(yystack));
 713 #endif
 714
 715     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 716     yystack.s_mark = yystack.s_base;
 717     yystack.l_mark = yystack.l_base;
 718 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 719     yystack.p_mark = yystack.p_base;
 720 #endif
 721     yystate = 0;
 722     *yystack.s_mark = 0;
 723
 724 yyloop:
 725     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 726     if (yychar < 0)
 727     {
 728 #if YYBTYACC
 729         do {
 730         if (yylvp < yylve)
 731         {
 732             /* we're currently re-reading tokens */
 733             yylval = *yylvp++;
 734 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 735             yylloc = *yylpp++;
 736 #endif
 737             yychar = *yylexp++;
 738             break;
 739         }
 740         if (yyps->save)
 741         {
 742             /* in trial mode; save scanner results for future parse attempts */
 743             if (yylvp == yylvlim)
 744             {   /* Enlarge lexical value queue */
 745                 size_t p = (size_t) (yylvp - yylvals);
 746                 size_t s = (size_t) (yylvlim - yylvals);
 747
 748                 s += YYLVQUEUEGROWTH;
 749                 if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
 750                 if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
 751 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 752                 if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
 753 #endif
 754                 yylvp   = yylve = yylvals + p;
 755                 yylvlim = yylvals + s;
 756 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 757                 yylpp   = yylpe = yylpsns + p;
 758                 yylplim = yylpsns + s;
 759 #endif
 760                 yylexp  = yylexemes + p;
 761             }
 762             *yylexp = (short) YYLEX;
 763             *yylvp++ = yylval;
 764             yylve++;
 765 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 766             *yylpp++ = yylloc;
 767             yylpe++;
 768 #endif
 769             yychar = *yylexp++;
 770             break;
 771         }
 772         /* normal operation, no conflict encountered */
 773 #endif /* YYBTYACC */
 774         yychar = YYLEX;
 775 #if YYBTYACC
 776         } while (0);
 777 #endif /* YYBTYACC */
 778         if (yychar < 0) yychar = YYEOF;
 779 #if YYDEBUG
 780         if (yydebug)
 781         {
 782             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 783             fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
 784                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
 785 #ifdef YYSTYPE_TOSTRING
 786 #if YYBTYACC
 787             if (!yytrial)
 788 #endif /* YYBTYACC */
 789                 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
 790 #endif
 791             fputc('\n', stderr);
 792         }
 793 #endif
 794     }
 795 #if YYBTYACC
 796
 797     /* Do we have a conflict? */
 798     if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 799         yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 800     {
 801         YYINT ctry;
 802
 803         if (yypath)
 804         {
 805             YYParseState *save;
 806 #if YYDEBUG
 807             if (yydebug)
 808                 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
 809                                 YYDEBUGSTR, yydepth, yystate);
 810 #endif
 811             /* Switch to the next conflict context */
 812             save = yypath;
 813             yypath = save->save;
 814             save->save = NULL;
 815             ctry = save->ctry;
 816             if (save->state != yystate) YYABORT;
 817             yyFreeState(save);
 818
 819         }
 820         else
 821         {
 822
 823             /* Unresolved conflict - start/continue trial parse */
 824             YYParseState *save;
 825 #if YYDEBUG
 826             if (yydebug)
 827             {
 828                 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
 829                 if (yyps->save)
 830                     fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
 831                 else
 832                     fputs("Starting trial parse.\n", stderr);
 833             }
 834 #endif
 835             save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
 836             if (save == NULL) goto yyenomem;
 837             save->save            = yyps->save;
 838             save->state           = yystate;
 839             save->errflag         = yyerrflag;
 840             save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
 841             memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
 842             save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
 843             memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
 844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 845             save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
 846             memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 847 #endif
 848             ctry                  = yytable[yyn];
 849             if (yyctable[ctry] == -1)
 850             {
 851 #if YYDEBUG
 852                 if (yydebug && yychar >= YYEOF)
 853                     fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
 854 #endif
 855                 ctry++;
 856             }
 857             save->ctry = ctry;
 858             if (yyps->save == NULL)
 859             {
 860                 /* If this is a first conflict in the stack, start saving lexemes */
 861                 if (!yylexemes)
 862                 {
 863                     yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
 864                     if (yylexemes == NULL) goto yyenomem;
 865                     yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
 866                     if (yylvals == NULL) goto yyenomem;
 867                     yylvlim   = yylvals + YYLVQUEUEGROWTH;
 868 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 869                     yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
 870                     if (yylpsns == NULL) goto yyenomem;
 871                     yylplim   = yylpsns + YYLVQUEUEGROWTH;
 872 #endif
 873                 }
 874                 if (yylvp == yylve)
 875                 {
 876                     yylvp  = yylve = yylvals;
 877 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 878                     yylpp  = yylpe = yylpsns;
 879 #endif
 880                     yylexp = yylexemes;
 881                     if (yychar >= YYEOF)
 882                     {
 883                         *yylve++ = yylval;
 884 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 885                         *yylpe++ = yylloc;
 886 #endif
 887                         *yylexp  = (short) yychar;
 888                         yychar   = YYEMPTY;
 889                     }
 890                 }
 891             }
 892             if (yychar >= YYEOF)
 893             {
 894                 yylvp--;
 895 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 896                 yylpp--;
 897 #endif
 898                 yylexp--;
 899                 yychar = YYEMPTY;
 900             }
 901             save->lexeme = (int) (yylvp - yylvals);
 902             yyps->save   = save;
 903         }
 904         if (yytable[yyn] == ctry)
 905         {
 906 #if YYDEBUG
 907             if (yydebug)
 908                 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
 909                                 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
 910 #endif
 911             if (yychar < 0)
 912             {
 913                 yylvp++;
 914 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 915                 yylpp++;
 916 #endif
 917                 yylexp++;
 918             }
 919             if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 920                 goto yyoverflow;
 921             yystate = yyctable[ctry];
 922             *++yystack.s_mark = (YYINT) yystate;
 923             *++yystack.l_mark = yylval;
 924 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 925             *++yystack.p_mark = yylloc;
 926 #endif
 927             yychar  = YYEMPTY;
 928             if (yyerrflag > 0) --yyerrflag;
 929             goto yyloop;
 930         }
 931         else
 932         {
 933             yyn = yyctable[ctry];
 934             goto yyreduce;
 935         }
 936     } /* End of code dealing with conflicts */
 937 #endif /* YYBTYACC */
 938     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 939             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 940     {
 941 #if YYDEBUG
 942         if (yydebug)
 943             fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
 944                             YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
 945 #endif
 946         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 947         yystate = yytable[yyn];
 948         *++yystack.s_mark = yytable[yyn];
 949         *++yystack.l_mark = yylval;
 950 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 951         *++yystack.p_mark = yylloc;
 952 #endif
 953         yychar = YYEMPTY;
 954         if (yyerrflag > 0)  --yyerrflag;
 955         goto yyloop;
 956     }
 957     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 958             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 959     {
 960         yyn = yytable[yyn];
 961         goto yyreduce;
 962     }
 963     if (yyerrflag != 0) goto yyinrecovery;
 964 #if YYBTYACC
 965
 966     yynewerrflag = 1;
 967     goto yyerrhandler;
 968     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
 969
 970 yyerrlab:
 971     /* explicit YYERROR from an action -- pop the rhs of the rule reduced
 972      * before looking for error recovery */
 973     yystack.s_mark -= yym;
 974     yystate = *yystack.s_mark;
 975     yystack.l_mark -= yym;
 976 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 977     yystack.p_mark -= yym;
 978 #endif
 979
 980     yynewerrflag = 0;
 981 yyerrhandler:
 982     while (yyps->save)
 983     {
 984         int ctry;
 985         YYParseState *save = yyps->save;
 986 #if YYDEBUG
 987         if (yydebug)
 988             fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
 989                             YYDEBUGSTR, yydepth, yystate, yyps->save->state,
 990                     (int)(yylvp - yylvals - yyps->save->lexeme));
 991 #endif
 992         /* Memorize most forward-looking error state in case it's really an error. */
 993         if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
 994         {
 995             /* Free old saved error context state */
 996             if (yyerrctx) yyFreeState(yyerrctx);
 997             /* Create and fill out new saved error context state */
 998             yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
 999             if (yyerrctx == NULL) goto yyenomem;
1000             yyerrctx->save           = yyps->save;
1001             yyerrctx->state          = yystate;
1002             yyerrctx->errflag        = yyerrflag;
1003             yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1004             memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1005             yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1006             memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1007 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1008             yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1009             memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1010 #endif
1011             yyerrctx->lexeme         = (int) (yylvp - yylvals);
1012         }
1013         yylvp          = yylvals   + save->lexeme;
1014 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1015         yylpp          = yylpsns   + save->lexeme;
1016 #endif
1017         yylexp         = yylexemes + save->lexeme;
1018         yychar         = YYEMPTY;
1019         yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1020         memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1021         yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1022         memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1023 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1024         yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1025         memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1026 #endif
1027         ctry           = ++save->ctry;
1028         yystate        = save->state;
1029         /* We tried shift, try reduce now */
1030         if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1031         yyps->save     = save->save;
1032         save->save     = NULL;
1033         yyFreeState(save);
1034
1035         /* Nothing left on the stack -- error */
1036         if (!yyps->save)
1037         {
1038 #if YYDEBUG
1039             if (yydebug)
1040                 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1041                                 YYPREFIX, yydepth);
1042 #endif
1043             /* Restore state as it was in the most forward-advanced error */
1044             yylvp          = yylvals   + yyerrctx->lexeme;
1045 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1046             yylpp          = yylpsns   + yyerrctx->lexeme;
1047 #endif
1048             yylexp         = yylexemes + yyerrctx->lexeme;
1049             yychar         = yylexp[-1];
1050             yylval         = yylvp[-1];
1051 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1052             yylloc         = yylpp[-1];
1053 #endif
1054             yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1055             memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1056             yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1057             memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1058 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1059             yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1060             memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1061 #endif
1062             yystate        = yyerrctx->state;
1063             yyFreeState(yyerrctx);
1064             yyerrctx       = NULL;
1065         }
1066         yynewerrflag = 1;
1067     }
1068     if (yynewerrflag == 0) goto yyinrecovery;
1069 #endif /* YYBTYACC */
1070
1071     YYERROR_CALL("syntax error");
1072 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1073     yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1074 #endif
1075
1076 #if !YYBTYACC
1077     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1078 yyerrlab:
1079 #endif
1080     ++yynerrs;
1081
1082 yyinrecovery:
1083     if (yyerrflag < 3)
1084     {
1085         yyerrflag = 3;
1086         for (;;)
1087         {
1088             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1089                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1090             {
1091 #if YYDEBUG
1092                 if (yydebug)
1093                     fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1094                                     YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1095 #endif
1096                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1097                 yystate = yytable[yyn];
1098                 *++yystack.s_mark = yytable[yyn];
1099                 *++yystack.l_mark = yylval;
1100 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1101                 /* lookahead position is error end position */
1102                 yyerror_loc_range[1] = yylloc;
1103                 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1104                 *++yystack.p_mark = yyloc;
1105 #endif
1106                 goto yyloop;
1107             }
1108             else
1109             {
1110 #if YYDEBUG
1111                 if (yydebug)
1112                     fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1113                                     YYDEBUGSTR, yydepth, *yystack.s_mark);
1114 #endif
1115                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1116 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1117                 /* the current TOS position is the error start position */
1118                 yyerror_loc_range[0] = *yystack.p_mark;
1119 #endif
1120 #if defined(YYDESTRUCT_CALL)
1121 #if YYBTYACC
1122                 if (!yytrial)
1123 #endif /* YYBTYACC */
1124 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1125                     YYDESTRUCT_CALL("error: discarding state",
1126                                     yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1127 #else
1128                     YYDESTRUCT_CALL("error: discarding state",
1129                                     yystos[*yystack.s_mark], yystack.l_mark);
1130 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1131 #endif /* defined(YYDESTRUCT_CALL) */
1132                 --yystack.s_mark;
1133                 --yystack.l_mark;
1134 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1135                 --yystack.p_mark;
1136 #endif
1137             }
1138         }
1139     }
1140     else
1141     {
1142         if (yychar == YYEOF) goto yyabort;
1143 #if YYDEBUG
1144         if (yydebug)
1145         {
1146             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1147             fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1148                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
1149         }
1150 #endif
1151 #if defined(YYDESTRUCT_CALL)
1152 #if YYBTYACC
1153         if (!yytrial)
1154 #endif /* YYBTYACC */
1155 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1156             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1157 #else
1158             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1159 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1160 #endif /* defined(YYDESTRUCT_CALL) */
1161         yychar = YYEMPTY;
1162         goto yyloop;
1163     }
1164
1165 yyreduce:
1166     yym = yylen[yyn];
1167 #if YYDEBUG
1168     if (yydebug)
1169     {
1170         fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1171                         YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1172 #ifdef YYSTYPE_TOSTRING
1173 #if YYBTYACC
1174         if (!yytrial)
1175 #endif /* YYBTYACC */
1176             if (yym > 0)
1177             {
1178                 int i;
1179                 fputc('<', stderr);
1180                 for (i = yym; i > 0; i--)
1181                 {
1182                     if (i != yym) fputs(", ", stderr);
1183                     fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1184                                            yystack.l_mark[1-i]), stderr);
1185                 }
1186                 fputc('>', stderr);
1187             }
1188 #endif
1189         fputc('\n', stderr);
1190     }
1191 #endif
1192     if (yym > 0)
1193         yyval = yystack.l_mark[1-yym];
1194     else
1195         memset(&yyval, 0, sizeof yyval);
1196 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1197
1198     /* Perform position reduction */
1199     memset(&yyloc, 0, sizeof(yyloc));
1200 #if YYBTYACC
1201     if (!yytrial)
1202 #endif /* YYBTYACC */
1203     {
1204         YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1205         /* just in case YYERROR is invoked within the action, save
1206            the start of the rhs as the error start position */
1207         yyerror_loc_range[0] = yystack.p_mark[1-yym];
1208     }
1209 #endif
1210
1211     switch (yyn)
1212     {
1213 case 3:
1214 #line 66 "ok_syntax1.y"
1215         {  yyerrok ; }
1216 break;
1217 case 4:
1218 #line 70 "ok_syntax1.y"
1219         {  printf("%d\n",yystack.l_mark[0].ival);}
1220 break;
1221 case 5:
1222 #line 72 "ok_syntax1.y"
1223         {  regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
1224 break;
1225 case 6:
1226 #line 76 "ok_syntax1.y"
1227         {  yyval.ival = yystack.l_mark[-1].ival; }
1228 break;
1229 case 7:
1230 #line 78 "ok_syntax1.y"
1231         {  yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
1232 break;
1233 case 8:
1234 #line 80 "ok_syntax1.y"
1235         {  yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
1236 break;
1237 case 9:
1238 #line 82 "ok_syntax1.y"
1239         {  yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
1240 break;
1241 case 10:
1242 #line 84 "ok_syntax1.y"
1243         {  yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
1244 break;
1245 case 11:
1246 #line 86 "ok_syntax1.y"
1247         {  yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
1248 break;
1249 case 12:
1250 #line 88 "ok_syntax1.y"
1251         {  yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
1252 break;
1253 case 13:
1254 #line 90 "ok_syntax1.y"
1255         {  yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
1256 break;
1257 case 14:
1258 #line 92 "ok_syntax1.y"
1259         {  yyval.ival = - yystack.l_mark[0].ival; }
1260 break;
1261 case 15:
1262 #line 94 "ok_syntax1.y"
1263         {  yyval.ival = regs[yystack.l_mark[0].ival]; }
1264 break;
1265 case 17:
1266 #line 99 "ok_syntax1.y"
1267         {  yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
1268 break;
1269 case 18:
1270 #line 101 "ok_syntax1.y"
1271         {  yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
1272 break;
1273 #line 1274 "ok_syntax1.tab.c"
1274     default:
1275         break;
1276     }
1277     yystack.s_mark -= yym;
1278     yystate = *yystack.s_mark;
1279     yystack.l_mark -= yym;
1280 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1281     yystack.p_mark -= yym;
1282 #endif
1283     yym = yylhs[yyn];
1284     if (yystate == 0 && yym == 0)
1285     {
1286 #if YYDEBUG
1287         if (yydebug)
1288         {
1289             fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1290 #ifdef YYSTYPE_TOSTRING
1291 #if YYBTYACC
1292             if (!yytrial)
1293 #endif /* YYBTYACC */
1294                 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1295 #endif
1296             fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1297         }
1298 #endif
1299         yystate = YYFINAL;
1300         *++yystack.s_mark = YYFINAL;
1301         *++yystack.l_mark = yyval;
1302 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1303         *++yystack.p_mark = yyloc;
1304 #endif
1305         if (yychar < 0)
1306         {
1307 #if YYBTYACC
1308             do {
1309             if (yylvp < yylve)
1310             {
1311                 /* we're currently re-reading tokens */
1312                 yylval = *yylvp++;
1313 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1314                 yylloc = *yylpp++;
1315 #endif
1316                 yychar = *yylexp++;
1317                 break;
1318             }
1319             if (yyps->save)
1320             {
1321                 /* in trial mode; save scanner results for future parse attempts */
1322                 if (yylvp == yylvlim)
1323                 {   /* Enlarge lexical value queue */
1324                     size_t p = (size_t) (yylvp - yylvals);
1325                     size_t s = (size_t) (yylvlim - yylvals);
1326
1327                     s += YYLVQUEUEGROWTH;
1328                     if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL)
1329                         goto yyenomem;
1330                     if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1331                         goto yyenomem;
1332 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1333                     if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1334                         goto yyenomem;
1335 #endif
1336                     yylvp   = yylve = yylvals + p;
1337                     yylvlim = yylvals + s;
1338 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1339                     yylpp   = yylpe = yylpsns + p;
1340                     yylplim = yylpsns + s;
1341 #endif
1342                     yylexp  = yylexemes + p;
1343                 }
1344                 *yylexp = (short) YYLEX;
1345                 *yylvp++ = yylval;
1346                 yylve++;
1347 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1348                 *yylpp++ = yylloc;
1349                 yylpe++;
1350 #endif
1351                 yychar = *yylexp++;
1352                 break;
1353             }
1354             /* normal operation, no conflict encountered */
1355 #endif /* YYBTYACC */
1356             yychar = YYLEX;
1357 #if YYBTYACC
1358             } while (0);
1359 #endif /* YYBTYACC */
1360             if (yychar < 0) yychar = YYEOF;
1361 #if YYDEBUG
1362             if (yydebug)
1363             {
1364                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1365                 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1366                                 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1367             }
1368 #endif
1369         }
1370         if (yychar == YYEOF) goto yyaccept;
1371         goto yyloop;
1372     }
1373     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1374             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1375         yystate = yytable[yyn];
1376     else
1377         yystate = yydgoto[yym];
1378 #if YYDEBUG
1379     if (yydebug)
1380     {
1381         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1382 #ifdef YYSTYPE_TOSTRING
1383 #if YYBTYACC
1384         if (!yytrial)
1385 #endif /* YYBTYACC */
1386             fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1387 #endif
1388         fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1389     }
1390 #endif
1391     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1392     *++yystack.s_mark = (YYINT) yystate;
1393     *++yystack.l_mark = yyval;
1394 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1395     *++yystack.p_mark = yyloc;
1396 #endif
1397     goto yyloop;
1398 #if YYBTYACC
1399
1400     /* Reduction declares that this path is valid. Set yypath and do a full parse */
1401 yyvalid:
1402     if (yypath) YYABORT;
1403     while (yyps->save)
1404     {
1405         YYParseState *save = yyps->save;
1406         yyps->save = save->save;
1407         save->save = yypath;
1408         yypath = save;
1409     }
1410 #if YYDEBUG
1411     if (yydebug)
1412         fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1413                         YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1414 #endif
1415     if (yyerrctx)
1416     {
1417         yyFreeState(yyerrctx);
1418         yyerrctx = NULL;
1419     }
1420     yylvp          = yylvals + yypath->lexeme;
1421 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1422     yylpp          = yylpsns + yypath->lexeme;
1423 #endif
1424     yylexp         = yylexemes + yypath->lexeme;
1425     yychar         = YYEMPTY;
1426     yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1427     memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1428     yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1429     memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1430 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1431     yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1432     memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1433 #endif
1434     yystate        = yypath->state;
1435     goto yyloop;
1436 #endif /* YYBTYACC */
1437
1438 yyoverflow:
1439     YYERROR_CALL("yacc stack overflow");
1440 #if YYBTYACC
1441     goto yyabort_nomem;
1442 yyenomem:
1443     YYERROR_CALL("memory exhausted");
1444 yyabort_nomem:
1445 #endif /* YYBTYACC */
1446     yyresult = 2;
1447     goto yyreturn;
1448
1449 yyabort:
1450     yyresult = 1;
1451     goto yyreturn;
1452
1453 yyaccept:
1454 #if YYBTYACC
1455     if (yyps->save) goto yyvalid;
1456 #endif /* YYBTYACC */
1457     yyresult = 0;
1458
1459 yyreturn:
1460 #if defined(YYDESTRUCT_CALL)
1461     if (yychar != YYEOF && yychar != YYEMPTY)
1462 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1463         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1464 #else
1465         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1466 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1467
1468     {
1469         YYSTYPE *pv;
1470 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1471         YYLTYPE *pp;
1472
1473         for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1474              YYDESTRUCT_CALL("cleanup: discarding state",
1475                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1476 #else
1477         for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1478              YYDESTRUCT_CALL("cleanup: discarding state",
1479                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1480 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1481     }
1482 #endif /* defined(YYDESTRUCT_CALL) */
1483
1484 #if YYBTYACC
1485     if (yyerrctx)
1486     {
1487         yyFreeState(yyerrctx);
1488         yyerrctx = NULL;
1489     }
1490     while (yyps)
1491     {
1492         YYParseState *save = yyps;
1493         yyps = save->save;
1494         save->save = NULL;
1495         yyFreeState(save);
1496     }
1497     while (yypath)
1498     {
1499         YYParseState *save = yypath;
1500         yypath = save->save;
1501         save->save = NULL;
1502         yyFreeState(save);
1503     }
1504 #endif /* YYBTYACC */
1505     yyfreestack(&yystack);
1506     return (yyresult);
1507 }