parse.c

/* original parser id follows */
/* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */

#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYPATCH 20140422

#define YYEMPTY        (-1)
#define yyclearin      (yychar = YYEMPTY)
#define yyerrok        (yyerrflag = 0)
#define YYRECOVERING() (yyerrflag != 0)
#define YYENOMEM       (-2)
#define YYEOF          0
#define YYPREFIX "yy"

#define YYPURE 0

#line 82 "parse.y"

#include <stdio.h>
#include "mawk.h"
#include "symtype.h"
#include "code.h"
#include "memory.h"
#include "bi_funct.h"
#include "bi_vars.h"
#include "jmp.h"
#include "field.h"
#include "files.h"

#define  YYMAXDEPTH	200

extern void eat_nl(void);
static SYMTAB *save_arglist(const char *);
static int init_arglist(void);
static void RE_as_arg(void);
static void check_array(SYMTAB *);
static void check_var(SYMTAB *);
static void code_array(SYMTAB *);
static void code_call_id(CA_REC *, SYMTAB *);
static void field_A2I(void);
static void free_arglist(void);
static void improve_arglist(const char *);
static void resize_fblock(FBLOCK *);
static void switch_code_to_main(void);

static int scope;
static FBLOCK *active_funct;
static CA_REC *active_arglist;
      /* when scope is SCOPE_FUNCT  */

#define  code_address(x)  if( is_local(x) ) \
                             code2op(L_PUSHA, (x)->offset) ;\
                          else  code2(_PUSHA, (x)->stval.cp)

#define  CDP(x)  (code_base+(x))
/* WARNING: These CDP() calculations become invalid after calls
   that might change code_base.  Which are:  code2(), code2op(),
   code_jmp() and code_pop().
*/

/* this nonsense caters to MSDOS large model */
#define  CODE_FE_PUSHA()  code_ptr->ptr = (PTR) 0 ; code1(FE_PUSHA)

#line 130 "parse.y"
#ifdef YYSTYPE
#undef  YYSTYPE_IS_DECLARED
#define YYSTYPE_IS_DECLARED 1
#endif
#ifndef YYSTYPE_IS_DECLARED
#define YYSTYPE_IS_DECLARED 1
typedef union{
  CELL     *cp ;
  SYMTAB   *stp ;
  int      start ;   /* code starting address as offset from code_base */
  PF_CP    fp ;      /* ptr to a (print/printf) or (sub/gsub) function */
  BI_REC   *bip ;    /* ptr to info about a builtin */
  FBLOCK   *fbp  ;   /* ptr to a function block */
  ARG2_REC *arg2p ;
  CA_REC   *ca_p  ;
  int      ival ;
  PTR      ptr ;
} YYSTYPE;
#endif /* !YYSTYPE_IS_DECLARED */
#line 88 "parse.c"

/* compatibility with bison */
#ifdef YYPARSE_PARAM
/* compatibility with FreeBSD */
# ifdef YYPARSE_PARAM_TYPE
#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
# else
#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif
#else
# define YYPARSE_DECL() yyparse(void)
#endif

/* Parameters sent to lex. */
#ifdef YYLEX_PARAM
# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
# define YYLEX yylex(YYLEX_PARAM)
#else
# define YYLEX_DECL() yylex(void)
# define YYLEX yylex()
#endif

/* Parameters sent to yyerror. */
#ifndef YYERROR_DECL
#define YYERROR_DECL() yyerror(const char *s)
#endif
#ifndef YYERROR_CALL
#define YYERROR_CALL(msg) yyerror(msg)
#endif

extern int YYPARSE_DECL();

#define UNEXPECTED 257
#define BAD_DECIMAL 258
#define NL 259
#define SEMI_COLON 260
#define LBRACE 261
#define RBRACE 262
#define LBOX 263
#define RBOX 264
#define COMMA 265
#define IO_OUT 266
#define ASSIGN 267
#define ADD_ASG 268
#define SUB_ASG 269
#define MUL_ASG 270
#define DIV_ASG 271
#define MOD_ASG 272
#define POW_ASG 273
#define QMARK 274
#define COLON 275
#define OR 276
#define AND 277
#define IN 278
#define MATCH 279
#define EQ 280
#define NEQ 281
#define LT 282
#define LTE 283
#define GT 284
#define GTE 285
#define CAT 286
#define GETLINE 287
#define PLUS 288
#define MINUS 289
#define MUL 290
#define DIV 291
#define MOD 292
#define NOT 293
#define UMINUS 294
#define IO_IN 295
#define PIPE 296
#define POW 297
#define INC_or_DEC 298
#define DOLLAR 299
#define FIELD 300
#define LPAREN 301
#define RPAREN 302
#define DOUBLE 303
#define STRING_ 304
#define RE 305
#define ID 306
#define D_ID 307
#define FUNCT_ID 308
#define BUILTIN 309
#define LENGTH 310
#define PRINT 311
#define PRINTF 312
#define SPLIT 313
#define MATCH_FUNC 314
#define SUB 315
#define GSUB 316
#define DO 317
#define WHILE 318
#define FOR 319
#define BREAK 320
#define CONTINUE 321
#define IF 322
#define ELSE 323
#define DELETE 324
#define BEGIN 325
#define END 326
#define EXIT 327
#define NEXT 328
#define NEXTFILE 329
#define RETURN 330
#define FUNCTION 331
#define YYERRCODE 256
typedef short YYINT;
static const YYINT yylhs[] = {                           -1,
    0,    0,   36,   36,   36,   37,   40,   37,   41,   37,
   42,   37,   43,   44,   37,    1,    1,    2,    2,    3,
    3,    4,    4,    4,    4,    4,    4,    4,    4,    4,
   45,   45,   13,   13,   13,   13,   13,   13,   13,   13,
   13,   13,   13,   13,   13,   13,   13,   46,   13,   47,
   13,   48,   49,   13,   14,   14,   15,   15,   15,   15,
   15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
   15,   15,   15,   15,   15,   10,   25,   25,   26,   26,
    8,    8,    8,    5,    4,   27,   27,    6,    6,    6,
    7,    7,   50,   50,   17,    4,   51,    4,   52,    4,
   16,    4,    4,   18,   18,   19,   19,   53,   53,   13,
   13,   10,   15,   15,    4,    4,   20,    4,   11,   11,
   11,   11,   11,   15,   13,   13,   13,   13,   13,   13,
   13,   15,   22,   54,   54,   15,   23,    4,    4,   21,
   21,   15,   15,   15,   15,   15,   55,   12,   12,    9,
    9,   15,   28,   28,   24,   24,   38,   29,   30,   30,
   34,   34,   35,   35,   39,   15,   31,   31,   32,   32,
   32,   33,   33,
};
static const YYINT yylen[] = {                            2,
    1,    2,    1,    1,    2,    1,    0,    3,    0,    3,
    0,    3,    0,    0,    6,    3,    3,    1,    1,    1,
    2,    1,    2,    1,    2,    2,    2,    1,    2,    2,
    1,    1,    1,    3,    3,    3,    3,    3,    3,    3,
    3,    3,    3,    3,    3,    3,    3,    0,    4,    0,
    4,    0,    0,    7,    1,    2,    1,    1,    1,    3,
    1,    3,    3,    3,    3,    3,    3,    2,    2,    2,
    1,    2,    2,    2,    2,    1,    0,    1,    1,    3,
    5,    5,    1,    0,    5,    1,    1,    1,    3,    2,
    3,    3,    0,    2,    4,    2,    1,    4,    1,    7,
    4,    2,    4,    3,    4,    1,    2,    1,    2,    3,
    5,    5,    5,    6,    7,    3,    6,    2,    1,    2,
    6,    2,    3,    1,    3,    3,    3,    3,    3,    3,
    3,    2,    5,    1,    3,    6,    1,    2,    3,    2,
    3,    1,    2,    2,    3,    4,    1,    1,    1,    2,
    3,    6,    1,    1,    1,    3,    2,    4,    2,    2,
    0,    1,    1,    3,    1,    3,    2,    2,    1,    3,
    3,    2,    2,
};
static const YYINT yydefred[] = {                         0,
  165,    0,  147,    0,    0,    0,    0,    0,  119,    0,
   57,   58,   61,    0,   84,   84,   83,    0,    0,  153,
  154,    7,    9,    0,    0,    6,   71,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    1,    3,    4,
    0,    0,    0,   31,   32,   86,   87,   99,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   22,    0,
   20,    0,    0,    0,    0,    0,   28,   84,   24,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   73,   75,
    0,  122,    0,    0,    0,   72,    0,    0,    0,    0,
    0,    0,    0,  159,  160,    2,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,   74,   13,   52,   48,   50,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,  134,  132,    0,  157,    0,    5,
  150,  148,  149,    0,   17,   25,    0,    0,   26,   27,
    0,    0,    0,  138,   29,   30,    0,  140,    0,   16,
   21,   23,  102,    0,  106,    0,    0,  118,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  123,    0,   60,
    0,    0,  166,    0,    0,    0,    0,    8,   10,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  110,    0,   41,
   42,   43,   44,   45,   46,   18,   12,   19,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  163,    0,
    0,  151,    0,  104,    0,    0,    0,    0,  116,  139,
  141,   97,    0,  107,  108,    0,    0,    0,    0,    0,
   88,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  167,    0,    0,  168,    0,    0,    0,    0,    0,    0,
    0,    0,  146,  135,    0,  158,    0,  101,    0,  105,
   95,    0,   98,  109,  103,   90,    0,    0,    0,    0,
    0,    0,    0,    0,  111,    0,  171,  173,  170,  172,
   81,   82,  133,    0,    0,   53,    0,  164,    0,    0,
    0,    0,   85,    0,    0,    0,  112,  121,  114,  136,
   15,    0,    0,  155,  152,  117,    0,    0,    0,    0,
  115,  100,  156,
};
static const YYINT yydgoto[] = {                         25,
   59,  217,   60,   61,   87,  249,   83,   27,   28,   29,
   30,  144,   62,   32,   33,   63,   64,   65,  167,   66,
   67,   34,  228,  325,  251,  252,   68,   35,   36,   37,
  183,  184,  264,  230,  231,   38,   39,   40,   41,   92,
   93,  125,  204,  305,   69,  206,  207,  205,  322,  289,
  243,   70,  247,  136,   42,
};
static const YYINT yysindex[] = {                       -73,
    0,  203,    0, 2293, 2293, 2293,  -88, 2203,    0, 2323,
    0,    0,    0, -286,    0,    0,    0, -276, -273,    0,
    0,    0,    0, -291,  -73,    0,    0, 2293, 2576,   62,
 2627, 2293,  263, -263, -243, -192, -226,    0,    0,    0,
 -192,  -22, -123,    0,    0,    0,    0,    0, -208, -137,
 -178, -178, -125, -128, 1656, -178, -178, 1656,    0,   53,
    0, 2579,  278,  278, 1747,  278,    0,    0,    0,  278,
 2323, -286, -111, -200, -200, -200, -110,    0,    0,    0,
    0,    0, -257, 2197, 2144,    0,  -79, -109, -107, 2323,
 2323, -192, -192,    0,    0,    0,  -87, 2323, 2323, 2323,
 2323, 2323, 2323, 2323, 2323, 2323, 2323, 2323, 2323, 2323,
 2323,    0,    0,    0,    0,    0,  -82, 2323, 2323, 2323,
 2323, 2323, 2323, 2323,    2,  263, 2293, 2293, 2293, 2293,
 2293,  -68, 2293, 2323,    0,    0, 2323,    0,  -77,    0,
    0,    0,    0,  -56,    0,    0, 2323, 1777,    0,    0,
 2323, -178, 2579,    0,    0,    0, 2579,    0, -178,    0,
    0,    0,    0,  -89,    0, 2591, 2233,    0, 2353,  -70,
 2486,   -9,  -42,   -4,    5, 2323,  -14,    0, 2323,    0,
 2323,  -12,    0, 2383, 2413, 2648, 2669,    0,    0, 2693,
 2693, 2693, 2693, 2693, 2693, 2693, 2693, 2693, 2693, 2693,
 2693, 2693, 2693, 2323, 2323, 2323, 2323,    0, -127,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  -46,  -46,
 -200, -200, -200,  -88,  -87, 2498, 2693,   23,    0,   -5,
   28,    0, 2513,    0, -210, 2606, 2525,   42,    0,    0,
    0,    0,  278,    0,    0, 2540,  278, 2263,   40, 2693,
    0,   33,   16, 2323, 2323, 2323, 2693,   12, 2693, -120,
    0, -247, 2171,    0, -215,   18,   13, 2323, 2693, 2681,
 2702, 2159,    0,    0, 2323,    0,   19,    0,   30,    0,
    0, 2323,    0,    0,    0,    0, -241, 2323, -178, 2323,
 2323, -114,  -66,  -61,    0,    9,    0,    0,    0,    0,
    0,    0,    0,   36,    2,    0, 2198,    0,   37,  -43,
  -14, 2693,    0, 2693, 2552,    9,    0,    0,    0,    0,
    0, 2323,  -88,    0,    0,    0, -178, -178, 2693,   41,
    0,    0,    0,
};
static const YYINT yyrindex[] = {                         0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,  524,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0, 1510,
   26, 1989, 1568,    0,    0,    0,    0,    0,    0,    0,
    0, 1336,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  466,  582,  814,  872,  930,    0,  350,    0,    0,
  408,    0,    0, 1931,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  988,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0, 1626,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   45,    0,
    0,    0,    0,  640,    0,    0,    0,    0,    0,    0,
    0,   58,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,  128,    0,    0,    0,    0, -237,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0, 2443,    0,    0,   46,    0,    0,    0,    0, -212,
   35,  283, 2017, 2029, 2037, 2049, 2057, 2069, 2077, 2089,
 2097, 2109, 2117,    0,    0,    0,    0,    0,  133,    0,
    0,    0,    0,    0,    0,    0,    0,    0, 1394, 1452,
 1046, 1104, 1162, 1278,  698,    0, -235,    0,    0,    0,
   74,    0,    0,    0, 1713,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0, -118,  -93,
    0, -216,    0,    0,    0,    0, -231,    0, -171,    0,
    0, 1885,    0,    0, 1831,    0,    0,    0,   43,    0,
    6,  208,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0, 1220,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -126,   15,    0,  -64,    0,  756,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0, 2129,    0,
    0,    0,    0,
};
static const YYINT yygindex[] = {                         0,
   21,   39,    0,  -50,   17,    0,   76,    0,    0,   -7,
   -1, -205,    1,    0,   32,    0,    0,    0,    0,    0,
    0,    0,   60,    0,  160, -139,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  330,    0,    0,    0,    0,
    0,    0,    0,    0,   22,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,
};
#define YYTABLESIZE 2987
static const YYINT yytable[] = {                         79,
   31,  134,   73,   73,   73,   80,   73,  176,   84,  161,
   85,   86,  163,  164,   94,  168,   95,  297,  273,  170,
   26,   77,   77,  176,   90,   31,   73,   91,   77,  137,
   73,   88,   89,   92,  142,   74,   75,   76,  135,   82,
  143,  260,   78,   78,  177,   26,   34,   34,   34,   78,
   86,   34,   34,   34,  298,  153,  138,  137,  157,   97,
  311,  140,   34,  126,  146,  166,  137,  279,    2,   84,
   92,  171,  149,  150,  139,  173,  154,  155,  156,  158,
   44,   45,   86,  162,  169,   78,  301,   86,  172,   34,
  186,  187,  147,   91,  174,  132,  133,  175,  190,  191,
  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,
  202,  203,  188,  189,  292,  293,  294,  330,  209,  210,
  211,  212,  213,  214,  215,   73,   73,   73,   73,   73,
   91,   73,   89,   89,  226,   44,   45,  227,  145,   89,
   93,   93,  310,  296,  290,  216,  218,  233,  236,  316,
  290,  237,  119,  120,  121,  122,  123,  124,  219,  220,
  221,  222,  223,  148,  225,   79,   79,  246,  238,  250,
   79,   79,   79,  239,  240,  151,  257,  152,  241,  259,
  146,  250,    1,  181,  263,  250,  112,    2,    8,    9,
   77,  182,  283,  185,   80,   80,  285,  317,  290,   80,
   80,   80,  318,  290,  269,  270,  271,  272,   79,  133,
    8,    9,   77,    3,    4,    5,  142,   78,  224,    6,
  327,  290,  143,  208,    7,    8,    9,   10,  229,   11,
   12,   13,   14,  242,   15,   16,   17,   80,  232,   18,
   19,   20,   21,  129,  130,  131,   84,  253,   85,  132,
  133,   22,   23,  254,  250,  250,  250,   24,  255,  178,
   44,   45,    2,  258,   49,   49,   49,  256,  227,   49,
   49,   49,  141,   94,   94,  307,    8,    9,   77,   49,
   49,   49,  250,   78,   11,   11,   11,  275,  312,  261,
  314,  315,  277,   35,   35,   35,  276,  290,   35,   35,
   35,   14,   14,   14,  282,  288,  319,   49,  159,   35,
  313,   44,   45,    2,  160,  142,  291,  295,  303,  302,
   84,  143,  329,  287,  308,  216,  218,  304,  105,  106,
  107,  108,  109,  110,  111,  309,   35,  320,  326,    3,
    4,    5,  333,  321,  266,    6,  161,   77,  331,  332,
    7,    8,    9,   10,   96,   11,   12,   13,   14,  112,
   15,   16,   17,   46,   47,   18,   19,   20,   21,   48,
   49,   50,   51,   52,   53,  162,   54,    0,    0,   55,
   56,   57,   58,   96,    0,    0,   96,   96,   96,   96,
    0,   47,   47,   47,    0,    0,   47,   47,   47,    0,
    0,    0,    0,    0,    0,    0,   47,   47,   47,   47,
   47,   47,    0,    0,   96,   96,   96,    0,    0,    0,
   96,    0,    0,    0,    0,   96,   96,   96,   96,    0,
   96,   96,   96,   96,   47,   96,   96,   96,   96,   96,
   96,   96,   96,   96,   96,   96,   96,   96,   96,   96,
    0,   96,    0,    0,   96,   96,   96,   96,   43,    0,
    0,   44,   45,    2,    0,    0,   51,   51,   51,    0,
    0,   51,   51,   51,    0,    0,    0,    0,    0,    0,
    0,   51,   51,   51,   51,    0,    0,    0,    0,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,   10,    0,   11,   12,   13,   14,   51,
   15,   16,   17,   46,   47,   18,   19,   20,   21,   48,
   49,   50,   51,   52,   53,    0,   54,    0,    0,   55,
   56,   57,   58,  159,    0,    0,   44,   45,    2,    0,
    0,   36,   36,   36,    0,    0,   36,   36,   36,    0,
  127,  128,  129,  130,  131,    0,    0,   36,  132,  133,
    0,    0,    0,    0,    3,    4,    5,    0,    0,    0,
    6,    0,    0,    0,    0,    7,    8,    9,   10,    0,
   11,   12,   13,   14,   36,   15,   16,   17,   46,   47,
   18,   19,   20,   21,   48,   49,   50,   51,   52,   53,
    0,   54,    0,    0,   55,   56,   57,   58,   76,   76,
   76,    0,   84,   76,   76,   76,   76,   76,   76,   76,
   76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
   76,   76,   76,   76,   76,    0,   76,   76,   76,   76,
   76,   76,   76,    0,   76,   76,   76,   76,   76,   76,
   76,   76,   76,   76,   76,   76,    0,   76,   76,   76,
    0,    0,   76,   76,   76,   76,  120,  120,  120,    0,
   84,  120,  120,  120,  120,  120,  120,  120,  120,  120,
  120,  120,  120,  120,  120,  120,  120,  120,  120,  120,
  120,  120,  120,    0,  120,  120,  120,  120,  120,  120,
  120,    0,  120,  120,  120,  120,  120,  120,  120,  120,
  120,  120,  120,  120,    0,  120,  120,  120,    0,    0,
  120,  120,  120,  120,   59,   59,   59,    0,   84,   59,
   59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
   59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
   59,    0,   59,   59,   59,   59,   59,   59,   59,    0,
   59,   59,   59,    0,   59,   59,   59,   59,   59,   59,
   59,   59,    0,   59,   59,   59,    0,    0,   59,   59,
   59,   59,   59,   59,   59,    0,   84,   59,   59,   59,
   76,   76,   76,   76,   76,   76,   76,   59,   59,   59,
   59,   59,   59,   59,   59,   59,   59,   59,   59,    0,
   59,   59,   59,   59,   59,   59,   59,    0,    0,   59,
   59,    0,   59,   59,   59,   59,   59,   59,   59,   59,
    0,   59,   59,   59,    0,    0,   59,   59,   59,   59,
  124,  124,  124,    0,    0,  124,  124,  124,  124,  124,
  124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
  124,  124,  124,  124,  124,  124,  124,    0,  124,  124,
  124,  124,  124,  124,  124,    0,  124,  124,  124,    0,
  124,  124,  124,  124,  124,  124,  124,  124,    0,  124,
  124,  124,    0,    0,  124,  124,  124,  124,  143,  143,
  143,    0,    0,  143,  143,  143,  143,  143,  143,  143,
  143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
  143,  143,  143,  143,  143,    0,  143,  143,  143,  143,
  143,  143,  143,    0,    0,  143,  143,  143,  143,  143,
  143,  143,  143,  143,  143,  143,    0,  143,  143,  143,
    0,    0,  143,  143,  143,  143,   67,   67,   67,    0,
    0,   67,   67,   67,   67,   67,   67,   67,   67,   67,
   67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
   67,   67,   67,    0,   67,   67,   67,   67,   67,   67,
   67,    0,   67,   67,    0,   67,   67,   67,   67,   67,
   67,   67,   67,   67,    0,   67,   67,   67,    0,    0,
   67,   67,   67,   67,  113,  113,  113,    0,    0,  113,
  113,  113,  113,  113,  113,  113,  113,  113,  113,  113,
  113,  113,  113,  113,  113,  113,  113,  113,  113,  113,
  113,    0,  113,  113,  113,  113,  113,  113,  113,    0,
  113,  113,  113,    0,  113,  113,  113,  113,  113,  113,
  113,  113,    0,  113,  113,  113,    0,    0,  113,  113,
  113,  113,   69,   69,   69,    0,    0,   69,   69,   69,
   69,   69,   69,   69,   69,   69,   69,   69,   69,   69,
   69,   69,   69,   69,   69,   69,   69,   69,   69,    0,
   69,   69,   69,   69,   69,   69,   69,    0,   69,    0,
    0,   69,   69,   69,   69,   69,   69,   69,   69,   69,
    0,   69,   69,   69,    0,    0,   69,   69,   69,   69,
   70,   70,   70,    0,    0,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,    0,   70,   70,
   70,   70,   70,   70,   70,    0,   70,    0,    0,   70,
   70,   70,   70,   70,   70,   70,   70,   70,    0,   70,
   70,   70,    0,    0,   70,   70,   70,   70,   68,   68,
   68,    0,    0,   68,   68,   68,   68,   68,   68,   68,
   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
   68,   68,   68,   68,   68,    0,   68,   68,   68,   68,
   68,   68,   68,    0,   68,    0,    0,   68,   68,   68,
   68,   68,   68,   68,   68,   68,    0,   68,   68,   68,
    0,    0,   68,   68,   68,   68,  144,  144,  144,    0,
    0,  144,  144,  144,  144,  144,  144,  144,  144,  144,
  144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
  144,  144,  144,    0,  144,  144,  144,  144,  144,  144,
  144,    0,  144,    0,    0,  144,  144,  144,  144,  144,
  144,  144,  144,  144,    0,  144,  144,  144,    0,    0,
  144,  144,  144,  144,   64,   64,   64,    0,    0,   64,
   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
   64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
   64,    0,   64,   64,   64,   64,   64,   64,   64,    0,
   64,    0,    0,   64,   64,   64,   64,   64,   64,   64,
   64,   64,    0,   64,   64,   64,    0,    0,   64,   64,
   64,   64,   65,   65,   65,    0,    0,   65,   65,   65,
   65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
   65,   65,   65,   65,   65,   65,   65,   65,   65,    0,
   65,   65,   65,   65,   65,   65,   65,    0,   65,    0,
    0,   65,   65,   65,   65,   65,   65,   65,   65,   65,
    0,   65,   65,   65,    0,    0,   65,   65,   65,   65,
   66,   66,   66,    0,    0,   66,   66,   66,   66,   66,
   66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
   66,   66,   66,   66,   66,   66,   66,    0,   66,   66,
   66,   66,   66,   66,   66,    0,   66,    0,    0,   66,
   66,   66,   66,   66,   66,   66,   66,   66,    0,   66,
   66,   66,    0,    0,   66,   66,   66,   66,  113,  113,
  113,    0,    0,  113,  113,  113,  112,  112,  112,  112,
  112,  112,  112,  113,  113,  113,  113,  113,  113,  113,
  113,  113,  113,  113,  113,    0,  113,  113,  113,  113,
  113,  113,  113,    0,    0,  113,  113,    0,  113,  113,
  113,  113,  113,  113,  113,  113,    0,  113,  113,  113,
    0,    0,  113,  113,  113,  113,  145,  145,  145,    0,
    0,  145,  145,  145,  145,  145,  145,  145,  145,  145,
  145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
  145,  145,  145,    0,  145,  145,  145,  145,  145,  145,
  145,    0,  145,  145,  145,  145,    0,    0,    0,  145,
  145,  145,  145,    0,    0,  145,  145,  145,    0,    0,
  145,  145,  145,  145,  142,  142,  142,    0,    0,  142,
  142,  142,  142,  142,  142,  142,  142,  142,  142,  142,
  142,  142,  142,  142,  142,  142,  142,  142,  142,  142,
  142,    0,  142,  142,  142,  142,  142,  142,  142,    0,
    0,  142,  142,  142,    0,    0,    0,  142,  142,  142,
  142,    0,    0,  142,  142,  142,    0,    0,  142,  142,
  142,  142,   62,   62,   62,    0,    0,   62,   62,   62,
   62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
   62,   62,   62,   62,   62,   62,   62,   62,   62,    0,
   62,   62,   62,    0,    0,    0,   62,    0,   62,    0,
    0,   62,   62,   62,   62,   62,   62,   62,   62,   62,
    0,   62,   62,   62,    0,    0,   62,   62,   62,   62,
   63,   63,   63,    0,    0,   63,   63,   63,   63,   63,
   63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
   63,   63,   63,   63,   63,   63,   63,    0,   63,   63,
   63,    0,    0,    0,   63,    0,   63,    0,    0,   63,
   63,   63,   63,   63,   63,   63,   63,   63,    0,   63,
   63,   63,    0,    0,   63,   63,   63,   63,  124,  124,
  124,    0,    0,  124,  124,  124,    0,    0,    0,    0,
    0,    0,    0,  124,  124,  124,  124,  124,  124,  124,
  124,  124,  124,  124,  124,    0,  124,  124,  124,  124,
  124,  124,  124,    0,    0,  124,  124,    0,  124,  124,
  124,  124,  124,  124,  124,  124,    0,  124,  124,  124,
    0,    0,  124,  124,  124,  124,   55,   55,   55,    0,
    0,   55,   55,   55,    0,    0,    0,    0,    0,    0,
    0,   55,   55,   55,   55,   55,   55,   55,   55,   55,
   55,   55,   55,    0,   55,    0,    0,    0,    0,    0,
   55,    0,    0,    0,    0,   55,   55,   55,   55,   55,
   55,   55,   55,   55,    0,   55,   55,   55,    0,    0,
   55,   55,   55,   55,   56,   56,   56,    0,    0,   56,
   56,   56,    0,    0,    0,    0,    0,    0,    0,   56,
   56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
   56,    0,   56,    0,   44,   45,    0,    0,   56,    0,
    0,    0,    0,   56,   56,   56,   56,   56,   56,   56,
   56,   56,    0,   56,   56,   56,    0,    0,   56,   56,
   56,   56,    3,    4,    5,    0,    0,    0,    6,    0,
    0,    0,    0,    7,    8,    9,   10,    0,   11,   12,
   13,   14,    0,   15,   16,   17,    0,    0,   18,   19,
   20,   21,   59,    0,    0,   84,    0,    0,    0,   76,
   76,   76,   76,   76,   76,   76,   59,    0,   59,   59,
    0,   59,   59,   59,   59,   59,   59,   59,    0,   59,
   59,   59,   59,   59,   59,   59,  165,    0,   59,   59,
    0,   59,   59,   59,    0,   59,   59,   59,   59,    0,
   59,   59,   59,    0,    0,   59,   59,   59,   59,    0,
    0,    0,    0,    3,    4,    5,  234,    0,    0,    6,
    0,    0,    0,    0,    7,    8,    9,   10,    0,   11,
   12,   13,   14,    0,   15,   16,   17,    0,    0,   18,
   19,   20,   21,    3,    4,    5,    0,    0,    0,    6,
    0,    0,    0,    0,    7,    8,    9,   10,    0,   11,
   12,   13,  235,    0,   15,   16,   17,    0,    0,   18,
   19,   20,   21,   84,    0,   59,    0,   76,   76,   76,
   76,   76,   76,   76,   59,    0,   59,   59,   59,   59,
   59,   59,   59,   59,   59,   59,    0,   59,   59,   59,
   59,   59,   59,   59,    0,    0,   59,   59,    0,   59,
   59,   59,    0,   59,   59,   59,   59,    0,   59,   59,
   59,    0,    0,   59,   59,   59,   59,   84,    0,    0,
    0,   76,   76,   76,   76,   76,   76,   76,   59,    0,
   59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
    0,   59,   59,   59,   59,   59,   59,   59,    0,    0,
   59,   59,    0,   59,   59,   59,    0,   59,   59,   59,
   59,    0,   59,   59,   59,  124,    0,   59,   59,   59,
   59,    0,    0,    0,  124,    0,  124,  124,  124,  124,
  124,  124,  124,  124,  124,  124,    0,  124,  124,  124,
  124,  124,  124,  124,    0,    0,  124,  124,    0,  124,
  124,  124,    0,  124,  124,  124,  124,    0,  124,  124,
  124,    0,    0,  124,  124,  124,  124,   33,   33,   33,
    0,    0,   33,   33,   33,    0,    0,    0,    0,    0,
    0,    0,   33,   33,   33,   33,   33,   33,   33,   33,
   33,   33,   33,   33,    0,   37,   37,   37,    0,    0,
   37,   37,   37,    0,    0,    0,    0,   38,   38,   38,
   33,   37,   38,   38,   38,   39,   39,   39,    0,    0,
   39,   39,   39,   38,    0,    0,    0,   40,   40,   40,
    0,   39,   40,   40,   40,  125,  125,  125,   37,    0,
  125,  125,  125,   40,    0,    0,    0,  126,  126,  126,
   38,  125,  126,  126,  126,  127,  127,  127,   39,    0,
  127,  127,  127,  126,    0,    0,    0,  128,  128,  128,
   40,  127,  128,  128,  128,  129,  129,  129,  125,    0,
  129,  129,  129,  128,    0,    0,    0,  130,  130,  130,
  126,  129,  130,  130,  130,  131,  131,  131,  127,    0,
  131,  131,  131,  130,    0,    0,    0,   54,   54,   54,
  128,  131,   54,   54,   54,    0,    0,    0,  129,    0,
    0,    0,    0,   54,    0,    0,    0,    0,  179,    0,
  130,    0,    0,    0,    0,    0,    0,  114,  131,  115,
  116,  117,  118,  119,  120,  121,  122,  123,  124,    0,
   54,    0,    0,    0,    0,  299,  117,  118,  119,  120,
  121,  122,  123,  124,  114,  180,  115,  116,  117,  118,
  119,  120,  121,  122,  123,  124,    0,    0,    0,    0,
    0,    0,  323,  105,  106,  107,  108,  109,  110,  111,
    0,  114,  300,  115,  116,  117,  118,  119,  120,  121,
  122,  123,  124,    0,    0,    0,    0,    0,    0,    3,
    4,    5,    0,    0,  112,    6,    0,    0,  178,  324,
    7,    8,    9,   71,    0,   11,   12,   13,   72,   81,
   15,   16,   17,    0,    0,   18,   19,   20,   21,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,   10,  245,   11,   12,   13,   14,    0,
   15,   16,   17,    0,    0,   18,   19,   20,   21,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,   10,  286,   11,   12,   13,   14,    0,
   15,   16,   17,    0,    0,   18,   19,   20,   21,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,   71,    0,   11,   12,   13,   72,    0,
   15,   16,   17,    0,    0,   18,   19,   20,   21,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,   10,    0,   11,   12,   13,   14,    0,
   15,   16,   17,    0,    0,   18,   19,   20,   21,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,  248,    0,   11,   12,   13,   14,    0,
   15,   16,   17,    0,    0,   18,   19,   20,   21,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,   10,    0,   11,   12,   13,  262,    0,
   15,   16,   17,    0,    0,   18,   19,   20,   21,    3,
    4,    5,    0,    0,    0,    6,    0,    0,    0,    0,
    7,    8,    9,   10,    0,   11,   12,   13,  265,    0,
   15,   16,   17,    0,    0,   18,   19,   20,   21,  169,
  169,  169,    0,    0,    0,  169,    0,    0,    0,    0,
  169,  169,  169,  169,    0,  169,  169,  169,  169,    0,
  169,  169,  169,    0,    0,  169,  169,  169,  169,  114,
    0,  115,  116,  117,  118,  119,  120,  121,  122,  123,
  124,  114,    0,  115,  116,  117,  118,  119,  120,  121,
  122,  123,  124,    0,    0,    0,  114,  180,  115,  116,
  117,  118,  119,  120,  121,  122,  123,  124,  114,  274,
  115,  116,  117,  118,  119,  120,  121,  122,  123,  124,
    0,    0,    0,  114,  278,  115,  116,  117,  118,  119,
  120,  121,  122,  123,  124,  114,  281,  115,  116,  117,
  118,  119,  120,  121,  122,  123,  124,   44,   45,    0,
    0,  284,   98,   99,  100,  101,  102,  103,  104,    0,
  244,    0,  114,  328,  115,  116,  117,  118,  119,  120,
  121,  122,  123,  124,  114,  280,  115,  116,  117,  118,
  119,  120,  121,  122,  123,  124,    0,    0,    0,  114,
    0,  115,  116,  117,  118,  119,  120,  121,  122,  123,
  124,  113,    0,    0,    0,    0,    0,    0,    0,    0,
  114,    0,  115,  116,  117,  118,  119,  120,  121,  122,
  123,  124,  267,    0,    0,    0,    0,    0,    0,    0,
    0,  114,    0,  115,  116,  117,  118,  119,  120,  121,
  122,  123,  124,  268,    0,    0,    0,    0,    0,    0,
    0,    0,  114,    0,  115,  116,  117,  118,  119,  120,
  121,  122,  123,  124,  114,  306,  115,  116,  117,  118,
  119,  120,  121,  122,  123,  124,  114,    0,  115,  116,
  117,  118,  119,  120,  121,  122,  123,  124,  116,  117,
  118,  119,  120,  121,  122,  123,  124,
};
static const YYINT yycheck[] = {                          7,
    0,  265,    4,    5,    6,    7,    8,  265,   10,   60,
   10,  298,   63,   64,  306,   66,  308,  265,  224,   70,
    0,  259,  260,  265,  301,   25,   28,  301,  266,  265,
   32,   15,   16,  265,   42,    4,    5,    6,  302,    8,
   42,  181,  259,  260,  302,   25,  259,  260,  261,  266,
  298,  264,  265,  266,  302,   55,   36,  301,   58,   28,
  302,   41,  275,   32,   43,   65,  302,  278,  261,   71,
  302,   71,   51,   52,  301,   77,   55,   56,   57,   58,
  259,  260,  298,   62,   68,  302,  302,  298,   72,  302,
   90,   91,  301,  265,   78,  296,  297,   81,   98,   99,
  100,  101,  102,  103,  104,  105,  106,  107,  108,  109,
  110,  111,   92,   93,  254,  255,  256,  323,  118,  119,
  120,  121,  122,  123,  124,  127,  128,  129,  130,  131,
  302,  133,  259,  260,  134,  259,  260,  137,  262,  266,
  259,  260,  282,  264,  265,  125,  125,  147,  148,  264,
  265,  151,  280,  281,  282,  283,  284,  285,  127,  128,
  129,  130,  131,  301,  133,  259,  260,  167,  152,  169,
  264,  265,  266,  152,  153,  301,  176,  306,  157,  179,
  159,  181,  256,  263,  184,  185,  298,  261,  299,  300,
  301,  301,  243,  301,  259,  260,  247,  264,  265,  264,
  265,  266,  264,  265,  204,  205,  206,  207,  302,  297,
  299,  300,  301,  287,  288,  289,  224,  306,  287,  293,
  264,  265,  224,  306,  298,  299,  300,  301,  306,  303,
  304,  305,  306,  323,  308,  309,  310,  302,  295,  313,
  314,  315,  316,  290,  291,  292,  248,  318,  248,  296,
  297,  325,  326,  263,  254,  255,  256,  331,  263,  302,
  259,  260,  261,  278,  259,  260,  261,  263,  268,  264,
  265,  266,  295,  259,  260,  275,  299,  300,  301,  274,
  275,  276,  282,  306,  259,  260,  261,  265,  288,  302,
  290,  291,  265,  259,  260,  261,  302,  265,  264,  265,
  266,  259,  260,  261,  263,  266,  298,  302,  256,  275,
  289,  259,  260,  261,  262,  323,  301,  306,  306,  302,
  263,  323,  322,  248,  306,  305,  305,  268,  267,  268,
  269,  270,  271,  272,  273,  306,  302,  302,  302,  287,
  288,  289,  302,  305,  185,  293,  302,  302,  327,  328,
  298,  299,  300,  301,   25,  303,  304,  305,  306,  298,
  308,  309,  310,  311,  312,  313,  314,  315,  316,  317,
  318,  319,  320,  321,  322,  302,  324,   -1,   -1,  327,
  328,  329,  330,  256,   -1,   -1,  259,  260,  261,  262,
   -1,  259,  260,  261,   -1,   -1,  264,  265,  266,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  274,  275,  276,  277,
  278,  279,   -1,   -1,  287,  288,  289,   -1,   -1,   -1,
  293,   -1,   -1,   -1,   -1,  298,  299,  300,  301,   -1,
  303,  304,  305,  306,  302,  308,  309,  310,  311,  312,
  313,  314,  315,  316,  317,  318,  319,  320,  321,  322,
   -1,  324,   -1,   -1,  327,  328,  329,  330,  256,   -1,
   -1,  259,  260,  261,   -1,   -1,  259,  260,  261,   -1,
   -1,  264,  265,  266,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,  274,  275,  276,  277,   -1,   -1,   -1,   -1,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,  302,
  308,  309,  310,  311,  312,  313,  314,  315,  316,  317,
  318,  319,  320,  321,  322,   -1,  324,   -1,   -1,  327,
  328,  329,  330,  256,   -1,   -1,  259,  260,  261,   -1,
   -1,  259,  260,  261,   -1,   -1,  264,  265,  266,   -1,
  288,  289,  290,  291,  292,   -1,   -1,  275,  296,  297,
   -1,   -1,   -1,   -1,  287,  288,  289,   -1,   -1,   -1,
  293,   -1,   -1,   -1,   -1,  298,  299,  300,  301,   -1,
  303,  304,  305,  306,  302,  308,  309,  310,  311,  312,
  313,  314,  315,  316,  317,  318,  319,  320,  321,  322,
   -1,  324,   -1,   -1,  327,  328,  329,  330,  259,  260,
  261,   -1,  263,  264,  265,  266,  267,  268,  269,  270,
  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,
  281,  282,  283,  284,  285,   -1,  287,  288,  289,  290,
  291,  292,  293,   -1,  295,  296,  297,  298,  299,  300,
  301,  302,  303,  304,  305,  306,   -1,  308,  309,  310,
   -1,   -1,  313,  314,  315,  316,  259,  260,  261,   -1,
  263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,   -1,  287,  288,  289,  290,  291,  292,
  293,   -1,  295,  296,  297,  298,  299,  300,  301,  302,
  303,  304,  305,  306,   -1,  308,  309,  310,   -1,   -1,
  313,  314,  315,  316,  259,  260,  261,   -1,  263,  264,
  265,  266,  267,  268,  269,  270,  271,  272,  273,  274,
  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,   -1,  287,  288,  289,  290,  291,  292,  293,   -1,
  295,  296,  297,   -1,  299,  300,  301,  302,  303,  304,
  305,  306,   -1,  308,  309,  310,   -1,   -1,  313,  314,
  315,  316,  259,  260,  261,   -1,  263,  264,  265,  266,
  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,
  277,  278,  279,  280,  281,  282,  283,  284,  285,   -1,
  287,  288,  289,  290,  291,  292,  293,   -1,   -1,  296,
  297,   -1,  299,  300,  301,  302,  303,  304,  305,  306,
   -1,  308,  309,  310,   -1,   -1,  313,  314,  315,  316,
  259,  260,  261,   -1,   -1,  264,  265,  266,  267,  268,
  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  279,  280,  281,  282,  283,  284,  285,   -1,  287,  288,
  289,  290,  291,  292,  293,   -1,  295,  296,  297,   -1,
  299,  300,  301,  302,  303,  304,  305,  306,   -1,  308,
  309,  310,   -1,   -1,  313,  314,  315,  316,  259,  260,
  261,   -1,   -1,  264,  265,  266,  267,  268,  269,  270,
  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,
  281,  282,  283,  284,  285,   -1,  287,  288,  289,  290,
  291,  292,  293,   -1,   -1,  296,  297,  298,  299,  300,
  301,  302,  303,  304,  305,  306,   -1,  308,  309,  310,
   -1,   -1,  313,  314,  315,  316,  259,  260,  261,   -1,
   -1,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,   -1,  287,  288,  289,  290,  291,  292,
  293,   -1,  295,  296,   -1,  298,  299,  300,  301,  302,
  303,  304,  305,  306,   -1,  308,  309,  310,   -1,   -1,
  313,  314,  315,  316,  259,  260,  261,   -1,   -1,  264,
  265,  266,  267,  268,  269,  270,  271,  272,  273,  274,
  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,   -1,  287,  288,  289,  290,  291,  292,  293,   -1,
  295,  296,  297,   -1,  299,  300,  301,  302,  303,  304,
  305,  306,   -1,  308,  309,  310,   -1,   -1,  313,  314,
  315,  316,  259,  260,  261,   -1,   -1,  264,  265,  266,
  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,
  277,  278,  279,  280,  281,  282,  283,  284,  285,   -1,
  287,  288,  289,  290,  291,  292,  293,   -1,  295,   -1,
   -1,  298,  299,  300,  301,  302,  303,  304,  305,  306,
   -1,  308,  309,  310,   -1,   -1,  313,  314,  315,  316,
  259,  260,  261,   -1,   -1,  264,  265,  266,  267,  268,
  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  279,  280,  281,  282,  283,  284,  285,   -1,  287,  288,
  289,  290,  291,  292,  293,   -1,  295,   -1,   -1,  298,
  299,  300,  301,  302,  303,  304,  305,  306,   -1,  308,
  309,  310,   -1,   -1,  313,  314,  315,  316,  259,  260,
  261,   -1,   -1,  264,  265,  266,  267,  268,  269,  270,
  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,
  281,  282,  283,  284,  285,   -1,  287,  288,  289,  290,
  291,  292,  293,   -1,  295,   -1,   -1,  298,  299,  300,
  301,  302,  303,  304,  305,  306,   -1,  308,  309,  310,
   -1,   -1,  313,  314,  315,  316,  259,  260,  261,   -1,
   -1,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,   -1,  287,  288,  289,  290,  291,  292,
  293,   -1,  295,   -1,   -1,  298,  299,  300,  301,  302,
  303,  304,  305,  306,   -1,  308,  309,  310,   -1,   -1,
  313,  314,  315,  316,  259,  260,  261,   -1,   -1,  264,
  265,  266,  267,  268,  269,  270,  271,  272,  273,  274,
  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,   -1,  287,  288,  289,  290,  291,  292,  293,   -1,
  295,   -1,   -1,  298,  299,  300,  301,  302,  303,  304,
  305,  306,   -1,  308,  309,  310,   -1,   -1,  313,  314,
  315,  316,  259,  260,  261,   -1,   -1,  264,  265,  266,
  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,
  277,  278,  279,  280,  281,  282,  283,  284,  285,   -1,
  287,  288,  289,  290,  291,  292,  293,   -1,  295,   -1,
   -1,  298,  299,  300,  301,  302,  303,  304,  305,  306,
   -1,  308,  309,  310,   -1,   -1,  313,  314,  315,  316,
  259,  260,  261,   -1,   -1,  264,  265,  266,  267,  268,
  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  279,  280,  281,  282,  283,  284,  285,   -1,  287,  288,
  289,  290,  291,  292,  293,   -1,  295,   -1,   -1,  298,
  299,  300,  301,  302,  303,  304,  305,  306,   -1,  308,
  309,  310,   -1,   -1,  313,  314,  315,  316,  259,  260,
  261,   -1,   -1,  264,  265,  266,  267,  268,  269,  270,
  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,
  281,  282,  283,  284,  285,   -1,  287,  288,  289,  290,
  291,  292,  293,   -1,   -1,  296,  297,   -1,  299,  300,
  301,  302,  303,  304,  305,  306,   -1,  308,  309,  310,
   -1,   -1,  313,  314,  315,  316,  259,  260,  261,   -1,
   -1,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,   -1,  287,  288,  289,  290,  291,  292,
  293,   -1,  295,  296,  297,  298,   -1,   -1,   -1,  302,
  303,  304,  305,   -1,   -1,  308,  309,  310,   -1,   -1,
  313,  314,  315,  316,  259,  260,  261,   -1,   -1,  264,
  265,  266,  267,  268,  269,  270,  271,  272,  273,  274,
  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,   -1,  287,  288,  289,  290,  291,  292,  293,   -1,
   -1,  296,  297,  298,   -1,   -1,   -1,  302,  303,  304,
  305,   -1,   -1,  308,  309,  310,   -1,   -1,  313,  314,
  315,  316,  259,  260,  261,   -1,   -1,  264,  265,  266,
  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,
  277,  278,  279,  280,  281,  282,  283,  284,  285,   -1,
  287,  288,  289,   -1,   -1,   -1,  293,   -1,  295,   -1,
   -1,  298,  299,  300,  301,  302,  303,  304,  305,  306,
   -1,  308,  309,  310,   -1,   -1,  313,  314,  315,  316,
  259,  260,  261,   -1,   -1,  264,  265,  266,  267,  268,
  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  279,  280,  281,  282,  283,  284,  285,   -1,  287,  288,
  289,   -1,   -1,   -1,  293,   -1,  295,   -1,   -1,  298,
  299,  300,  301,  302,  303,  304,  305,  306,   -1,  308,
  309,  310,   -1,   -1,  313,  314,  315,  316,  259,  260,
  261,   -1,   -1,  264,  265,  266,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  274,  275,  276,  277,  278,  279,  280,
  281,  282,  283,  284,  285,   -1,  287,  288,  289,  290,
  291,  292,  293,   -1,   -1,  296,  297,   -1,  299,  300,
  301,  302,  303,  304,  305,  306,   -1,  308,  309,  310,
   -1,   -1,  313,  314,  315,  316,  259,  260,  261,   -1,
   -1,  264,  265,  266,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,  274,  275,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,   -1,  287,   -1,   -1,   -1,   -1,   -1,
  293,   -1,   -1,   -1,   -1,  298,  299,  300,  301,  302,
  303,  304,  305,  306,   -1,  308,  309,  310,   -1,   -1,
  313,  314,  315,  316,  259,  260,  261,   -1,   -1,  264,
  265,  266,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  274,
  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,   -1,  287,   -1,  259,  260,   -1,   -1,  293,   -1,
   -1,   -1,   -1,  298,  299,  300,  301,  302,  303,  304,
  305,  306,   -1,  308,  309,  310,   -1,   -1,  313,  314,
  315,  316,  287,  288,  289,   -1,   -1,   -1,  293,   -1,
   -1,   -1,   -1,  298,  299,  300,  301,   -1,  303,  304,
  305,  306,   -1,  308,  309,  310,   -1,   -1,  313,  314,
  315,  316,  260,   -1,   -1,  263,   -1,   -1,   -1,  267,
  268,  269,  270,  271,  272,  273,  274,   -1,  276,  277,
   -1,  279,  280,  281,  282,  283,  284,  285,   -1,  287,
  288,  289,  290,  291,  292,  293,  260,   -1,  296,  297,
   -1,  299,  300,  301,   -1,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,   -1,
   -1,   -1,   -1,  287,  288,  289,  260,   -1,   -1,  293,
   -1,   -1,   -1,   -1,  298,  299,  300,  301,   -1,  303,
  304,  305,  306,   -1,  308,  309,  310,   -1,   -1,  313,
  314,  315,  316,  287,  288,  289,   -1,   -1,   -1,  293,
   -1,   -1,   -1,   -1,  298,  299,  300,  301,   -1,  303,
  304,  305,  306,   -1,  308,  309,  310,   -1,   -1,  313,
  314,  315,  316,  263,   -1,  265,   -1,  267,  268,  269,
  270,  271,  272,  273,  274,   -1,  276,  277,  278,  279,
  280,  281,  282,  283,  284,  285,   -1,  287,  288,  289,
  290,  291,  292,  293,   -1,   -1,  296,  297,   -1,  299,
  300,  301,   -1,  303,  304,  305,  306,   -1,  308,  309,
  310,   -1,   -1,  313,  314,  315,  316,  263,   -1,   -1,
   -1,  267,  268,  269,  270,  271,  272,  273,  274,   -1,
  276,  277,  278,  279,  280,  281,  282,  283,  284,  285,
   -1,  287,  288,  289,  290,  291,  292,  293,   -1,   -1,
  296,  297,   -1,  299,  300,  301,   -1,  303,  304,  305,
  306,   -1,  308,  309,  310,  265,   -1,  313,  314,  315,
  316,   -1,   -1,   -1,  274,   -1,  276,  277,  278,  279,
  280,  281,  282,  283,  284,  285,   -1,  287,  288,  289,
  290,  291,  292,  293,   -1,   -1,  296,  297,   -1,  299,
  300,  301,   -1,  303,  304,  305,  306,   -1,  308,  309,
  310,   -1,   -1,  313,  314,  315,  316,  259,  260,  261,
   -1,   -1,  264,  265,  266,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,  274,  275,  276,  277,  278,  279,  280,  281,
  282,  283,  284,  285,   -1,  259,  260,  261,   -1,   -1,
  264,  265,  266,   -1,   -1,   -1,   -1,  259,  260,  261,
  302,  275,  264,  265,  266,  259,  260,  261,   -1,   -1,
  264,  265,  266,  275,   -1,   -1,   -1,  259,  260,  261,
   -1,  275,  264,  265,  266,  259,  260,  261,  302,   -1,
  264,  265,  266,  275,   -1,   -1,   -1,  259,  260,  261,
  302,  275,  264,  265,  266,  259,  260,  261,  302,   -1,
  264,  265,  266,  275,   -1,   -1,   -1,  259,  260,  261,
  302,  275,  264,  265,  266,  259,  260,  261,  302,   -1,
  264,  265,  266,  275,   -1,   -1,   -1,  259,  260,  261,
  302,  275,  264,  265,  266,  259,  260,  261,  302,   -1,
  264,  265,  266,  275,   -1,   -1,   -1,  259,  260,  261,
  302,  275,  264,  265,  266,   -1,   -1,   -1,  302,   -1,
   -1,   -1,   -1,  275,   -1,   -1,   -1,   -1,  265,   -1,
  302,   -1,   -1,   -1,   -1,   -1,   -1,  274,  302,  276,
  277,  278,  279,  280,  281,  282,  283,  284,  285,   -1,
  302,   -1,   -1,   -1,   -1,  265,  278,  279,  280,  281,
  282,  283,  284,  285,  274,  302,  276,  277,  278,  279,
  280,  281,  282,  283,  284,  285,   -1,   -1,   -1,   -1,
   -1,   -1,  265,  267,  268,  269,  270,  271,  272,  273,
   -1,  274,  302,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,   -1,   -1,   -1,   -1,   -1,   -1,  287,
  288,  289,   -1,   -1,  298,  293,   -1,   -1,  302,  302,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,  307,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,  302,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,  302,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  287,
  288,  289,   -1,   -1,   -1,  293,   -1,   -1,   -1,   -1,
  298,  299,  300,  301,   -1,  303,  304,  305,  306,   -1,
  308,  309,  310,   -1,   -1,  313,  314,  315,  316,  274,
   -1,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,  274,   -1,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,   -1,   -1,   -1,  274,  302,  276,  277,
  278,  279,  280,  281,  282,  283,  284,  285,  274,  302,
  276,  277,  278,  279,  280,  281,  282,  283,  284,  285,
   -1,   -1,   -1,  274,  302,  276,  277,  278,  279,  280,
  281,  282,  283,  284,  285,  274,  302,  276,  277,  278,
  279,  280,  281,  282,  283,  284,  285,  259,  260,   -1,
   -1,  302,  267,  268,  269,  270,  271,  272,  273,   -1,
  260,   -1,  274,  302,  276,  277,  278,  279,  280,  281,
  282,  283,  284,  285,  274,  260,  276,  277,  278,  279,
  280,  281,  282,  283,  284,  285,   -1,   -1,   -1,  274,
   -1,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,  265,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  274,   -1,  276,  277,  278,  279,  280,  281,  282,  283,
  284,  285,  265,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,  274,   -1,  276,  277,  278,  279,  280,  281,  282,
  283,  284,  285,  265,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,  274,   -1,  276,  277,  278,  279,  280,  281,
  282,  283,  284,  285,  274,  275,  276,  277,  278,  279,
  280,  281,  282,  283,  284,  285,  274,   -1,  276,  277,
  278,  279,  280,  281,  282,  283,  284,  285,  277,  278,
  279,  280,  281,  282,  283,  284,  285,
};
#define YYFINAL 25
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 331
#define YYUNDFTOKEN 389
#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
#if YYDEBUG
static const char *const yyname[] = {

"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"UNEXPECTED","BAD_DECIMAL","NL",
"SEMI_COLON","LBRACE","RBRACE","LBOX","RBOX","COMMA","IO_OUT","ASSIGN",
"ADD_ASG","SUB_ASG","MUL_ASG","DIV_ASG","MOD_ASG","POW_ASG","QMARK","COLON",
"OR","AND","IN","MATCH","EQ","NEQ","LT","LTE","GT","GTE","CAT","GETLINE","PLUS",
"MINUS","MUL","DIV","MOD","NOT","UMINUS","IO_IN","PIPE","POW","INC_or_DEC",
"DOLLAR","FIELD","LPAREN","RPAREN","DOUBLE","STRING_","RE","ID","D_ID",
"FUNCT_ID","BUILTIN","LENGTH","PRINT","PRINTF","SPLIT","MATCH_FUNC","SUB",
"GSUB","DO","WHILE","FOR","BREAK","CONTINUE","IF","ELSE","DELETE","BEGIN","END",
"EXIT","NEXT","NEXTFILE","RETURN","FUNCTION",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
"illegal-symbol",
};
static const char *const yyrule[] = {
"$accept : program",
"program : program_block",
"program : program program_block",
"program_block : PA_block",
"program_block : function_def",
"program_block : outside_error block",
"PA_block : block",
"$$1 :",
"PA_block : BEGIN $$1 block",
"$$2 :",
"PA_block : END $$2 block",
"$$3 :",
"PA_block : expr $$3 block_or_separator",
"$$4 :",
"$$5 :",
"PA_block : expr COMMA $$4 expr $$5 block_or_separator",
"block : LBRACE statement_list RBRACE",
"block : LBRACE error RBRACE",
"block_or_separator : block",
"block_or_separator : separator",
"statement_list : statement",
"statement_list : statement_list statement",
"statement : block",
"statement : expr separator",
"statement : separator",
"statement : error separator",
"statement : BREAK separator",
"statement : CONTINUE separator",
"statement : return_statement",
"statement : NEXT separator",
"statement : NEXTFILE separator",
"separator : NL",
"separator : SEMI_COLON",
"expr : cat_expr",
"expr : lvalue ASSIGN expr",
"expr : lvalue ADD_ASG expr",
"expr : lvalue SUB_ASG expr",
"expr : lvalue MUL_ASG expr",
"expr : lvalue DIV_ASG expr",
"expr : lvalue MOD_ASG expr",
"expr : lvalue POW_ASG expr",
"expr : expr EQ expr",
"expr : expr NEQ expr",
"expr : expr LT expr",
"expr : expr LTE expr",
"expr : expr GT expr",
"expr : expr GTE expr",
"expr : expr MATCH expr",
"$$6 :",
"expr : expr OR $$6 expr",
"$$7 :",
"expr : expr AND $$7 expr",
"$$8 :",
"$$9 :",
"expr : expr QMARK $$8 expr COLON $$9 expr",
"cat_expr : p_expr",
"cat_expr : cat_expr p_expr",
"p_expr : DOUBLE",
"p_expr : STRING_",
"p_expr : ID",
"p_expr : LPAREN expr RPAREN",
"p_expr : RE",
"p_expr : p_expr PLUS p_expr",
"p_expr : p_expr MINUS p_expr",
"p_expr : p_expr MUL p_expr",
"p_expr : p_expr DIV p_expr",
"p_expr : p_expr MOD p_expr",
"p_expr : p_expr POW p_expr",
"p_expr : NOT p_expr",
"p_expr : PLUS p_expr",
"p_expr : MINUS p_expr",
"p_expr : builtin",
"p_expr : ID INC_or_DEC",
"p_expr : INC_or_DEC lvalue",
"p_expr : field INC_or_DEC",
"p_expr : INC_or_DEC field",
"lvalue : ID",
"arglist :",
"arglist : args",
"args : expr",
"args : args COMMA expr",
"builtin : BUILTIN mark LPAREN ID RPAREN",
"builtin : BUILTIN mark LPAREN arglist RPAREN",
"builtin : LENGTH",
"mark :",
"statement : print mark pr_args pr_direction separator",
"print : PRINT",
"print : PRINTF",
"pr_args : arglist",
"pr_args : LPAREN arg2 RPAREN",
"pr_args : LPAREN RPAREN",
"arg2 : expr COMMA expr",
"arg2 : arg2 COMMA expr",
"pr_direction :",
"pr_direction : IO_OUT expr",
"if_front : IF LPAREN expr RPAREN",
"statement : if_front statement",
"else : ELSE",
"statement : if_front statement else statement",
"do : DO",
"statement : do statement WHILE LPAREN expr RPAREN separator",
"while_front : WHILE LPAREN expr RPAREN",
"statement : while_front statement",
"statement : for1 for2 for3 statement",
"for1 : FOR LPAREN SEMI_COLON",
"for1 : FOR LPAREN expr SEMI_COLON",
"for2 : SEMI_COLON",
"for2 : expr SEMI_COLON",
"for3 : RPAREN",
"for3 : expr RPAREN",
"expr : expr IN ID",
"expr : LPAREN arg2 RPAREN IN ID",
"lvalue : ID mark LBOX args RBOX",
"p_expr : ID mark LBOX args RBOX",
"p_expr : ID mark LBOX args RBOX INC_or_DEC",
"statement : DELETE ID mark LBOX args RBOX separator",
"statement : DELETE ID separator",
"array_loop_front : FOR LPAREN ID IN ID RPAREN",
"statement : array_loop_front statement",
"field : FIELD",
"field : DOLLAR D_ID",
"field : DOLLAR D_ID mark LBOX args RBOX",
"field : DOLLAR p_expr",
"field : LPAREN field RPAREN",
"p_expr : field",
"expr : field ASSIGN expr",
"expr : field ADD_ASG expr",
"expr : field SUB_ASG expr",
"expr : field MUL_ASG expr",
"expr : field DIV_ASG expr",
"expr : field MOD_ASG expr",
"expr : field POW_ASG expr",
"p_expr : split_front split_back",
"split_front : SPLIT LPAREN expr COMMA ID",
"split_back : RPAREN",
"split_back : COMMA expr RPAREN",
"p_expr : MATCH_FUNC LPAREN expr COMMA re_arg RPAREN",
"re_arg : expr",
"statement : EXIT separator",
"statement : EXIT expr separator",
"return_statement : RETURN separator",
"return_statement : RETURN expr separator",
"p_expr : getline",
"p_expr : getline fvalue",
"p_expr : getline_file p_expr",
"p_expr : p_expr PIPE GETLINE",
"p_expr : p_expr PIPE GETLINE fvalue",
"getline : GETLINE",
"fvalue : lvalue",
"fvalue : field",
"getline_file : getline IO_IN",
"getline_file : getline fvalue IO_IN",
"p_expr : sub_or_gsub LPAREN re_arg COMMA expr sub_back",
"sub_or_gsub : SUB",
"sub_or_gsub : GSUB",
"sub_back : RPAREN",
"sub_back : COMMA fvalue RPAREN",
"function_def : funct_start block",
"funct_start : funct_head LPAREN f_arglist RPAREN",
"funct_head : FUNCTION ID",
"funct_head : FUNCTION FUNCT_ID",
"f_arglist :",
"f_arglist : f_args",
"f_args : ID",
"f_args : f_args COMMA ID",
"outside_error : error",
"p_expr : FUNCT_ID mark call_args",
"call_args : LPAREN RPAREN",
"call_args : ca_front ca_back",
"ca_front : LPAREN",
"ca_front : ca_front expr COMMA",
"ca_front : ca_front ID COMMA",
"ca_back : expr RPAREN",
"ca_back : ID RPAREN",

};
#endif

int      yydebug;
int      yynerrs;

int      yyerrflag;
int      yychar;
YYSTYPE  yyval;
YYSTYPE  yylval;

/* define the initial stack-sizes */
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH  YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH  10000
#endif
#endif

#define YYINITSTACKSIZE 200

typedef struct {
    unsigned stacksize;
    YYINT    *s_base;
    YYINT    *s_mark;
    YYINT    *s_last;
    YYSTYPE  *l_base;
    YYSTYPE  *l_mark;
} YYSTACKDATA;
/* variables for the parser stack */
static YYSTACKDATA yystack;
#line 1190 "parse.y"

/*
 * Check for special case where there is a forward reference to a newly
 * declared function using an array parameter.  Because the parameter
 * mechanism for arrays uses a different byte code, we would like to know
 * if this is the case so that the function's contents can handle the array
 * type.
 */
static void
improve_arglist(const char *name)
{
    CA_REC *p, *p2;
    FCALL_REC *q;

    for (p = active_arglist; p != 0; p = p->link) {
	if (p->type == ST_LOCAL_NONE) {
	    for (q = resolve_list; q != 0; q = q->link) {
		if (!strcmp(q->callee->name, name)) {
		    for (p2 = q->arg_list; p2 != 0; p2 = p2->link) {
			if (p2->arg_num == p->arg_num) {
			    switch (p2->type) {
			    case ST_NONE:
			    case ST_LOCAL_NONE:
				break;
			    default:
				p->type = p2->type;
				p->sym_p->type = (char) p2->type;
				TRACE(("...set argument %d of %s to %s\n",
				       p->arg_num,
				       name,
				       type_to_str(p->type)));
				break;
			    }
			}
		    }
		    if (p->type != ST_LOCAL_NONE)
			break;
		}
	    }
	    if (p->type != ST_LOCAL_NONE)
		break;
	}
    }
}

/* maintain data for f_arglist to make it visible in funct_start */
static int
init_arglist(void)
{
    free_arglist();
    return 0;
}

static SYMTAB *
save_arglist(const char *s)
{
    SYMTAB *result = save_id(s);
    CA_REC *saveit = ZMALLOC(CA_REC);
    CA_REC *p, *q;

    if (saveit != 0) {
	int arg_num = 0;
	for (p = active_arglist, q = 0; p != 0; q = p, p = p->link) {
	    ++arg_num;
	}
	saveit->link = 0;
	saveit->type = ST_LOCAL_NONE;
	saveit->arg_num = (short) arg_num;
	saveit->sym_p = result;
	if (q != 0) {
	    q->link = saveit;
	} else {
	    active_arglist = saveit;
	}
    }

    return result;
}

static void
free_arglist(void)
{
    while (active_arglist != 0) {
	CA_REC *next = active_arglist->link;
	ZFREE(active_arglist);
	active_arglist = next;
    }
}

/* resize the code for a user function */

static void
resize_fblock(FBLOCK * fbp)
{
    CODEBLOCK *p = ZMALLOC(CODEBLOCK);

    code2op(_RET0, _HALT);
    /* make sure there is always a return */

    *p = active_code;
    fbp->code = code_shrink(p, &fbp->size);
    /* code_shrink() zfrees p */

    if (dump_code_flag)
	add_to_fdump_list(fbp);
}

/* convert FE_PUSHA  to  FE_PUSHI
   or F_PUSH to F_PUSHI
*/

static void
field_A2I(void)
{
    CELL *cp;

    if (code_ptr[-1].op == FE_PUSHA &&
	code_ptr[-1].ptr == (PTR) 0) {
	/* On most architectures, the two tests are the same; a good
	   compiler might eliminate one.  On LM_DOS, and possibly other
	   segmented architectures, they are not */
	code_ptr[-1].op = FE_PUSHI;
    } else {
	cp = (CELL *) code_ptr[-1].ptr;

	if ((cp == field) || ((cp > NF) && (cp <= LAST_PFIELD))) {
	    code_ptr[-2].op = _PUSHI;
	} else if (cp == NF) {
	    code_ptr[-2].op = NF_PUSHI;
	    code_ptr--;
	} else {
	    code_ptr[-2].op = F_PUSHI;
	    code_ptr->op = field_addr_to_index(code_ptr[-1].ptr);
	    code_ptr++;
	}
    }
}

/* we've seen an ID in a context where it should be a VAR,
   check that's consistent with previous usage */

static void
check_var(SYMTAB * p)
{
    switch (p->type) {
    case ST_NONE:		/* new id */
	p->type = ST_VAR;
	p->stval.cp = ZMALLOC(CELL);
	p->stval.cp->type = C_NOINIT;
	break;

    case ST_LOCAL_NONE:
	p->type = ST_LOCAL_VAR;
	active_funct->typev[p->offset] = ST_LOCAL_VAR;
	break;

    case ST_VAR:
    case ST_LOCAL_VAR:
	break;

    default:
	type_error(p);
	break;
    }
}

/* we've seen an ID in a context where it should be an ARRAY,
   check that's consistent with previous usage */
static void
check_array(SYMTAB * p)
{
    switch (p->type) {
    case ST_NONE:		/* a new array */
	p->type = ST_ARRAY;
	p->stval.array = new_ARRAY();
	no_leaks_array(p->stval.array);
	break;

    case ST_ARRAY:
    case ST_LOCAL_ARRAY:
	break;

    case ST_LOCAL_NONE:
	p->type = ST_LOCAL_ARRAY;
	active_funct->typev[p->offset] = ST_LOCAL_ARRAY;
	break;

    default:
	type_error(p);
	break;
    }
}

static void
code_array(SYMTAB * p)
{
    if (is_local(p))
	code2op(LA_PUSHA, p->offset);
    else
	code2(A_PUSHA, p->stval.array);
}

/* we've seen an ID as an argument to a user defined function */

static void
code_call_id(CA_REC * p, SYMTAB * ip)
{
    static CELL dummy;

    p->call_offset = code_offset;
    /* This always get set now.  So that fcall:relocate_arglist
       works. */

    switch (ip->type) {
    case ST_VAR:
	p->type = CA_EXPR;
	code2(_PUSHI, ip->stval.cp);
	break;

    case ST_LOCAL_VAR:
	p->type = CA_EXPR;
	code2op(L_PUSHI, ip->offset);
	break;

    case ST_ARRAY:
	p->type = CA_ARRAY;
	code2(A_PUSHA, ip->stval.array);
	break;

    case ST_LOCAL_ARRAY:
	p->type = CA_ARRAY;
	code2op(LA_PUSHA, ip->offset);
	break;

	/* not enough info to code it now; it will have to
	   be patched later */

    case ST_NONE:
	p->type = ST_NONE;
	p->sym_p = ip;
	code2(_PUSHI, &dummy);
	break;

    case ST_LOCAL_NONE:
	p->type = ST_LOCAL_NONE;
	p->type_p = &active_funct->typev[ip->offset];
	code2op(L_PUSHI, ip->offset);
	break;

#ifdef DEBUG
    default:
	bozo("code_call_id");
#endif

    }
}

/* an RE by itself was coded as _MATCH0 , change to
   push as an expression */

static void
RE_as_arg(void)
{
    CELL *cp = ZMALLOC(CELL);

    code_ptr -= 2;
    cp->type = C_RE;
    cp->ptr = code_ptr[1].ptr;
    code2(_PUSHC, cp);
    no_leaks_cell_ptr(cp);
}

/* reset the active_code back to the MAIN block */
static void
switch_code_to_main(void)
{
    switch (scope) {
    case SCOPE_BEGIN:
	*begin_code_p = active_code;
	active_code = *main_code_p;
	break;

    case SCOPE_END:
	*end_code_p = active_code;
	active_code = *main_code_p;
	break;

    case SCOPE_FUNCT:
	active_code = *main_code_p;
	break;

    case SCOPE_MAIN:
	break;
    }
    active_funct = (FBLOCK *) 0;
    scope = SCOPE_MAIN;
}

void
parse(void)
{
    if (yyparse() || compile_error_count != 0)
	mawk_exit(2);

    scan_cleanup();
    set_code();
    /* code must be set before call to resolve_fcalls() */
    if (resolve_list)
	resolve_fcalls();

    if (compile_error_count != 0)
	mawk_exit(2);
    if (dump_code_flag) {
	dump_code();
	mawk_exit(0);
    }
}
#line 1523 "parse.c"

#if YYDEBUG
#include <stdio.h>		/* needed for printf */
#endif

#include <stdlib.h>	/* needed for malloc, etc */
#include <string.h>	/* needed for memset */

/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data)
{
    int i;
    unsigned newsize;
    YYINT *newss;
    YYSTYPE *newvs;

    if ((newsize = data->stacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return YYENOMEM;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;

    i = (int) (data->s_mark - data->s_base);
    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
    if (newss == 0)
        return YYENOMEM;

    data->s_base = newss;
    data->s_mark = newss + i;

    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
    if (newvs == 0)
        return YYENOMEM;

    data->l_base = newvs;
    data->l_mark = newvs + i;

    data->stacksize = newsize;
    data->s_last = data->s_base + newsize - 1;
    return 0;
}

#if YYPURE || defined(YY_NO_LEAKS)
static void yyfreestack(YYSTACKDATA *data)
{
    free(data->s_base);
    free(data->l_base);
    memset(data, 0, sizeof(*data));
}
#else
#define yyfreestack(data) /* nothing */
#endif

#define YYABORT  goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR  goto yyerrlab

int
YYPARSE_DECL()
{
    int yym, yyn, yystate;
#if YYDEBUG
    const char *yys;

    if ((yys = getenv("YYDEBUG")) != 0)
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = YYEMPTY;
    yystate = 0;

#if YYPURE
    memset(&yystack, 0, sizeof(yystack));
#endif

    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    yystack.s_mark = yystack.s_base;
    yystack.l_mark = yystack.l_base;
    yystate = 0;
    *yystack.s_mark = 0;

yyloop:
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = YYLEX) < 0) yychar = YYEOF;
#if YYDEBUG
        if (yydebug)
        {
            yys = yyname[YYTRANSLATE(yychar)];
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
        {
            goto yyoverflow;
        }
        yystate = yytable[yyn];
        *++yystack.s_mark = yytable[yyn];
        *++yystack.l_mark = yylval;
        yychar = YYEMPTY;
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;

    YYERROR_CALL("syntax error");

    goto yyerrlab;

yyerrlab:
    ++yynerrs;

yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
#endif
                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
                {
                    goto yyoverflow;
                }
                yystate = yytable[yyn];
                *++yystack.s_mark = yytable[yyn];
                *++yystack.l_mark = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yystack.s_mark);
#endif
                if (yystack.s_mark <= yystack.s_base) goto yyabort;
                --yystack.s_mark;
                --yystack.l_mark;
            }
        }
    }
    else
    {
        if (yychar == YYEOF) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = yyname[YYTRANSLATE(yychar)];
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = YYEMPTY;
        goto yyloop;
    }

yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    if (yym)
        yyval = yystack.l_mark[1-yym];
    else
        memset(&yyval, 0, sizeof yyval);
    switch (yyn)
    {
case 6:
#line 216 "parse.y"
	{ /* this do nothing action removes a vacuous warning
                  from Bison */
             }
break;
case 7:
#line 221 "parse.y"
	{ be_setup(scope = SCOPE_BEGIN) ; }
break;
case 8:
#line 224 "parse.y"
	{ switch_code_to_main() ; }
break;
case 9:
#line 227 "parse.y"
	{ be_setup(scope = SCOPE_END) ; }
break;
case 10:
#line 230 "parse.y"
	{ switch_code_to_main() ; }
break;
case 11:
#line 233 "parse.y"
	{ code_jmp(_JZ, (INST*)0) ; }
break;
case 12:
#line 236 "parse.y"
	{ patch_jmp( code_ptr ) ; }
break;
case 13:
#line 240 "parse.y"
	{
               INST *p1 = CDP(yystack.l_mark[-1].start) ;
             int len ;

               code_push(p1, (unsigned) CodeOffset(p1), scope, active_funct) ;
               code_ptr = p1 ;

               code2op(_RANGE, 1) ;
               code_ptr += 3 ;
               len = (int) code_pop(code_ptr) ;
             code_ptr += len ;
               code1(_STOP) ;
             p1 = CDP(yystack.l_mark[-1].start) ;
               p1[2].op = CodeOffset(p1 + 1) ;
             }
break;
case 14:
#line 256 "parse.y"
	{ code1(_STOP) ; }
break;
case 15:
#line 259 "parse.y"
	{
               INST *p1 = CDP(yystack.l_mark[-5].start) ;

               p1[3].op = (int) (CDP(yystack.l_mark[0].start) - (p1 + 1)) ;
               p1[4].op = CodeOffset(p1 + 1) ;
             }
break;
case 16:
#line 270 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; }
break;
case 17:
#line 272 "parse.y"
	{ yyval.start = code_offset ; /* does nothing won't be executed */
              print_flag = getline_flag = paren_cnt = 0 ;
              yyerrok ; }
break;
case 19:
#line 279 "parse.y"
	{ yyval.start = code_offset ;
                       code1(_PUSHINT) ; code1(0) ;
                       code2(_PRINT, bi_print) ;
                     }
break;
case 23:
#line 292 "parse.y"
	{ code1(_POP) ; }
break;
case 24:
#line 294 "parse.y"
	{ yyval.start = code_offset ; }
break;
case 25:
#line 296 "parse.y"
	{ yyval.start = code_offset ;
                print_flag = getline_flag = 0 ;
                paren_cnt = 0 ;
                yyerrok ;
              }
break;
case 26:
#line 302 "parse.y"
	{ yyval.start = code_offset ; BC_insert('B', code_ptr+1) ;
               code2(_JMP, 0) /* don't use code_jmp ! */ ; }
break;
case 27:
#line 305 "parse.y"
	{ yyval.start = code_offset ; BC_insert('C', code_ptr+1) ;
               code2(_JMP, 0) ; }
break;
case 28:
#line 308 "parse.y"
	{ if ( scope != SCOPE_FUNCT )
                     compile_error("return outside function body") ;
             }
break;
case 29:
#line 312 "parse.y"
	{ if ( scope != SCOPE_MAIN )
                   compile_error( "improper use of next" ) ;
                yyval.start = code_offset ;
                code1(_NEXT) ;
              }
break;
case 30:
#line 318 "parse.y"
	{ if ( scope != SCOPE_MAIN )
                   compile_error( "improper use of nextfile" ) ;
                yyval.start = code_offset ;
                code1(_NEXTFILE) ;
              }
break;
case 34:
#line 329 "parse.y"
	{ code1(_ASSIGN) ; }
break;
case 35:
#line 330 "parse.y"
	{ code1(_ADD_ASG) ; }
break;
case 36:
#line 331 "parse.y"
	{ code1(_SUB_ASG) ; }
break;
case 37:
#line 332 "parse.y"
	{ code1(_MUL_ASG) ; }
break;
case 38:
#line 333 "parse.y"
	{ code1(_DIV_ASG) ; }
break;
case 39:
#line 334 "parse.y"
	{ code1(_MOD_ASG) ; }
break;
case 40:
#line 335 "parse.y"
	{ code1(_POW_ASG) ; }
break;
case 41:
#line 336 "parse.y"
	{ code1(_EQ) ; }
break;
case 42:
#line 337 "parse.y"
	{ code1(_NEQ) ; }
break;
case 43:
#line 338 "parse.y"
	{ code1(_LT) ; }
break;
case 44:
#line 339 "parse.y"
	{ code1(_LTE) ; }
break;
case 45:
#line 340 "parse.y"
	{ code1(_GT) ; }
break;
case 46:
#line 341 "parse.y"
	{ code1(_GTE) ; }
break;
case 47:
#line 344 "parse.y"
	{
            INST *p3 = CDP(yystack.l_mark[0].start) ;

            if ( p3 == code_ptr - 2 )
            {
               if ( p3->op == _MATCH0 )  p3->op = _MATCH1 ;

               else /* check for string */
               if ( p3->op == _PUSHS )
               { CELL *cp = ZMALLOC(CELL) ;

                 cp->type = C_STRING ;
                 cp->ptr = p3[1].ptr ;
                 cast_to_RE(cp) ;
                 no_leaks_re_ptr(cp->ptr) ;
                 code_ptr -= 2 ;
                 code2(_MATCH1, cp->ptr) ;
                 ZFREE(cp) ;
               }
               else  code1(_MATCH2) ;
            }
            else code1(_MATCH2) ;

            if ( !yystack.l_mark[-1].ival ) code1(_NOT) ;
          }
break;
case 48:
#line 372 "parse.y"
	{ code1(_TEST) ;
                code_jmp(_LJNZ, (INST*)0) ;
              }
break;
case 49:
#line 376 "parse.y"
	{ code1(_TEST) ; patch_jmp(code_ptr) ; }
break;
case 50:
#line 379 "parse.y"
	{ code1(_TEST) ;
                code_jmp(_LJZ, (INST*)0) ;
              }
break;
case 51:
#line 383 "parse.y"
	{ code1(_TEST) ; patch_jmp(code_ptr) ; }
break;
case 52:
#line 385 "parse.y"
	{ code_jmp(_JZ, (INST*)0) ; }
break;
case 53:
#line 386 "parse.y"
	{ code_jmp(_JMP, (INST*)0) ; }
break;
case 54:
#line 388 "parse.y"
	{ patch_jmp(code_ptr) ; patch_jmp(CDP(yystack.l_mark[0].start)) ; }
break;
case 56:
#line 393 "parse.y"
	{ code1(_CAT) ; }
break;
case 57:
#line 397 "parse.y"
	{  yyval.start = code_offset ; code2(_PUSHD, yystack.l_mark[0].ptr) ; }
break;
case 58:
#line 399 "parse.y"
	{ yyval.start = code_offset ; code2(_PUSHS, yystack.l_mark[0].ptr) ; }
break;
case 59:
#line 401 "parse.y"
	{ check_var(yystack.l_mark[0].stp) ;
	    yyval.start = code_offset ;
	    if ( is_local(yystack.l_mark[0].stp) )
	    { code2op(L_PUSHI, yystack.l_mark[0].stp->offset) ; }
	    else code2(_PUSHI, yystack.l_mark[0].stp->stval.cp) ;
          }
break;
case 60:
#line 409 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; }
break;
case 61:
#line 413 "parse.y"
	{ yyval.start = code_offset ;
              code2(_MATCH0, yystack.l_mark[0].ptr) ;
              no_leaks_re_ptr(yystack.l_mark[0].ptr);
            }
break;
case 62:
#line 419 "parse.y"
	{ code1(_ADD) ; }
break;
case 63:
#line 420 "parse.y"
	{ code1(_SUB) ; }
break;
case 64:
#line 421 "parse.y"
	{ code1(_MUL) ; }
break;
case 65:
#line 422 "parse.y"
	{ code1(_DIV) ; }
break;
case 66:
#line 423 "parse.y"
	{ code1(_MOD) ; }
break;
case 67:
#line 424 "parse.y"
	{ code1(_POW) ; }
break;
case 68:
#line 426 "parse.y"
	{ yyval.start = yystack.l_mark[0].start ; code1(_NOT) ; }
break;
case 69:
#line 428 "parse.y"
	{ yyval.start = yystack.l_mark[0].start ; code1(_UPLUS) ; }
break;
case 70:
#line 430 "parse.y"
	{ yyval.start = yystack.l_mark[0].start ; code1(_UMINUS) ; }
break;
case 72:
#line 435 "parse.y"
	{ check_var(yystack.l_mark[-1].stp) ;
             yyval.start = code_offset ;
             code_address(yystack.l_mark[-1].stp) ;

             if ( yystack.l_mark[0].ival == '+' )  code1(_POST_INC) ;
             else  code1(_POST_DEC) ;
           }
break;
case 73:
#line 443 "parse.y"
	{ yyval.start = yystack.l_mark[0].start ;
              if ( yystack.l_mark[-1].ival == '+' ) code1(_PRE_INC) ;
              else  code1(_PRE_DEC) ;
            }
break;
case 74:
#line 450 "parse.y"
	{ if (yystack.l_mark[0].ival == '+' ) code1(F_POST_INC ) ;
             else  code1(F_POST_DEC) ;
           }
break;
case 75:
#line 454 "parse.y"
	{ yyval.start = yystack.l_mark[0].start ;
             if ( yystack.l_mark[-1].ival == '+' ) code1(F_PRE_INC) ;
             else  code1( F_PRE_DEC) ;
           }
break;
case 76:
#line 461 "parse.y"
	{ yyval.start = code_offset ;
          check_var(yystack.l_mark[0].stp) ;
          code_address(yystack.l_mark[0].stp) ;
        }
break;
case 77:
#line 469 "parse.y"
	{ yyval.ival = 0 ; }
break;
case 79:
#line 474 "parse.y"
	{ yyval.ival = 1 ; }
break;
case 80:
#line 476 "parse.y"
	{ yyval.ival = yystack.l_mark[-2].ival + 1 ; }
break;
case 81:
#line 481 "parse.y"
	{ BI_REC *p = yystack.l_mark[-4].bip ;
          yyval.start = yystack.l_mark[-3].start ;
          if ( (int)p->min_args > 1 || (int)p->max_args < 1 )
            compile_error(
            "wrong number of arguments in call to %s" ,
            p->name ) ;
          /* if we have length(array), emit a different code */
          if ( p->fp == bi_length && is_array(yystack.l_mark[-1].stp) ) {
            check_array(yystack.l_mark[-1].stp) ;
            code_array(yystack.l_mark[-1].stp) ;
            { code1(_PUSHINT) ;  code1(1) ; }
            code1(A_LENGTH) ;
          } else {
            check_var(yystack.l_mark[-1].stp);
            if ( is_local(yystack.l_mark[-1].stp) )
            { code1(L_PUSHI); code1(yystack.l_mark[-1].stp->offset) ; }
            else { code2(_PUSHI, yystack.l_mark[-1].stp->stval.cp) ; }
            if ( p->min_args != p->max_args ) /* variable args */
                { code1(_PUSHINT) ;  code1(1) ; }
            code2(_BUILTIN, p->fp) ;
          }
        }
break;
case 82:
#line 504 "parse.y"
	{ BI_REC *p = yystack.l_mark[-4].bip ;
          yyval.start = yystack.l_mark[-3].start ;
          if ( (int)p->min_args > yystack.l_mark[-1].ival || (int)p->max_args < yystack.l_mark[-1].ival )
            compile_error(
            "wrong number of arguments in call to %s" ,
            p->name ) ;
          if ( p->min_args != p->max_args ) /* variable args */
              { code1(_PUSHINT) ;  code1(yystack.l_mark[-1].ival) ; }
          code2(_BUILTIN , p->fp) ;
        }
break;
case 83:
#line 515 "parse.y"
	{
            yyval.start = code_offset ;
            code1(_PUSHINT) ; code1(0) ;
            code2(_BUILTIN, yystack.l_mark[0].bip->fp) ;
          }
break;
case 84:
#line 524 "parse.y"
	{ yyval.start = code_offset ; }
break;
case 85:
#line 529 "parse.y"
	{ code2(_PRINT, yystack.l_mark[-4].fp) ;
              if ( yystack.l_mark[-4].fp == bi_printf && yystack.l_mark[-2].ival == 0 )
                    compile_error("no arguments in call to printf") ;
              print_flag = 0 ;
              yyval.start = yystack.l_mark[-3].start ;
            }
break;
case 86:
#line 537 "parse.y"
	{ yyval.fp = bi_print ; print_flag = 1 ;}
break;
case 87:
#line 538 "parse.y"
	{ yyval.fp = bi_printf ; print_flag = 1 ; }
break;
case 88:
#line 541 "parse.y"
	{ code2op(_PUSHINT, yystack.l_mark[0].ival) ; }
break;
case 89:
#line 543 "parse.y"
	{ yyval.ival = yystack.l_mark[-1].arg2p->cnt ; zfree(yystack.l_mark[-1].arg2p,sizeof(ARG2_REC)) ;
             code2op(_PUSHINT, yyval.ival) ;
           }
break;
case 90:
#line 547 "parse.y"
	{ yyval.ival=0 ; code2op(_PUSHINT, 0) ; }
break;
case 91:
#line 551 "parse.y"
	{ yyval.arg2p = (ARG2_REC*) zmalloc(sizeof(ARG2_REC)) ;
             yyval.arg2p->start = yystack.l_mark[-2].start ;
             yyval.arg2p->cnt = 2 ;
           }
break;
case 92:
#line 556 "parse.y"
	{ yyval.arg2p = yystack.l_mark[-2].arg2p ; yyval.arg2p->cnt++ ; }
break;
case 94:
#line 561 "parse.y"
	{ code2op(_PUSHINT, yystack.l_mark[-1].ival) ; }
break;
case 95:
#line 568 "parse.y"
	{  yyval.start = yystack.l_mark[-1].start ; eat_nl() ; code_jmp(_JZ, (INST*)0) ; }
break;
case 96:
#line 573 "parse.y"
	{ patch_jmp( code_ptr ) ;  }
break;
case 97:
#line 576 "parse.y"
	{ eat_nl() ; code_jmp(_JMP, (INST*)0) ; }
break;
case 98:
#line 581 "parse.y"
	{ patch_jmp(code_ptr) ;
                  patch_jmp(CDP(yystack.l_mark[0].start)) ;
                }
break;
case 99:
#line 590 "parse.y"
	{ eat_nl() ; BC_new() ; }
break;
case 100:
#line 595 "parse.y"
	{ yyval.start = yystack.l_mark[-5].start ;
          code_jmp(_JNZ, CDP(yystack.l_mark[-5].start)) ;
          BC_clear(code_ptr, CDP(yystack.l_mark[-2].start)) ; }
break;
case 101:
#line 601 "parse.y"
	{ eat_nl() ; BC_new() ;
                  yyval.start = yystack.l_mark[-1].start ;

                  /* check if const expression */
                  if ( code_ptr - 2 == CDP(yystack.l_mark[-1].start) &&
                       code_ptr[-2].op == _PUSHD &&
                       *(double*)code_ptr[-1].ptr != 0.0
                     )
                     code_ptr -= 2 ;
                  else
                  { INST *p3 = CDP(yystack.l_mark[-1].start) ;
                    code_push(p3, (unsigned) CodeOffset(p3), scope, active_funct) ;
                    code_ptr = p3 ;
                    code2(_JMP, (INST*)0) ; /* code2() not code_jmp() */
                  }
                }
break;
case 102:
#line 621 "parse.y"
	{
                  int  saved_offset ;
                  int len ;
                  INST *p1 = CDP(yystack.l_mark[-1].start) ;
                  INST *p2 = CDP(yystack.l_mark[0].start) ;

                  if ( p1 != p2 )  /* real test in loop */
                  {
                    p1[1].op = CodeOffset(p1 + 1) ;
                    saved_offset = code_offset ;
                    len = (int) code_pop(code_ptr) ;
                    code_ptr += len ;
                    code_jmp(_JNZ, CDP(yystack.l_mark[0].start)) ;
                    BC_clear(code_ptr, CDP(saved_offset)) ;
                  }
                  else /* while(1) */
                  {
                    code_jmp(_JMP, p1) ;
                    BC_clear(code_ptr, CDP(yystack.l_mark[0].start)) ;
                  }
                }
break;
case 103:
#line 647 "parse.y"
	{
                  int cont_offset = code_offset ;
                  unsigned len = code_pop(code_ptr) ;
                  INST *p2 = CDP(yystack.l_mark[-2].start) ;
                  INST *p4 = CDP(yystack.l_mark[0].start) ;

                  code_ptr += len ;

                  if ( p2 != p4 )  /* real test in for2 */
                  {
                    p4[-1].op = CodeOffset(p4 - 1) ;
                    len = code_pop(code_ptr) ;
                    code_ptr += len ;
                    code_jmp(_JNZ, CDP(yystack.l_mark[0].start)) ;
                  }
                  else /*  for(;;) */
                  code_jmp(_JMP, p4) ;

                  BC_clear(code_ptr, CDP(cont_offset)) ;

                }
break;
case 104:
#line 670 "parse.y"
	{ yyval.start = code_offset ; }
break;
case 105:
#line 672 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; code1(_POP) ; }
break;
case 106:
#line 675 "parse.y"
	{ yyval.start = code_offset ; }
break;
case 107:
#line 677 "parse.y"
	{
             if ( code_ptr - 2 == CDP(yystack.l_mark[-1].start) &&
                  code_ptr[-2].op == _PUSHD &&
                  * (double*) code_ptr[-1].ptr != 0.0
                )
                    code_ptr -= 2 ;
             else
             {
               INST *p1 = CDP(yystack.l_mark[-1].start) ;
               code_push(p1, (unsigned) CodeOffset(p1), scope, active_funct) ;
               code_ptr = p1 ;
               code2(_JMP, (INST*)0) ;
             }
           }
break;
case 108:
#line 694 "parse.y"
	{ eat_nl() ; BC_new() ;
             code_push((INST*)0,0, scope, active_funct) ;
           }
break;
case 109:
#line 698 "parse.y"
	{ INST *p1 = CDP(yystack.l_mark[-1].start) ;

             eat_nl() ; BC_new() ;
             code1(_POP) ;
             code_push(p1, (unsigned) CodeOffset(p1), scope, active_funct) ;
             code_ptr -= code_ptr - p1 ;
           }
break;
case 110:
#line 711 "parse.y"
	{ check_array(yystack.l_mark[0].stp) ;
             code_array(yystack.l_mark[0].stp) ;
             code1(A_TEST) ;
            }
break;
case 111:
#line 716 "parse.y"
	{ yyval.start = yystack.l_mark[-3].arg2p->start ;
             code2op(A_CAT, yystack.l_mark[-3].arg2p->cnt) ;
             zfree(yystack.l_mark[-3].arg2p, sizeof(ARG2_REC)) ;

             check_array(yystack.l_mark[0].stp) ;
             code_array(yystack.l_mark[0].stp) ;
             code1(A_TEST) ;
           }
break;
case 112:
#line 727 "parse.y"
	{
             if ( yystack.l_mark[-1].ival > 1 )
             { code2op(A_CAT, yystack.l_mark[-1].ival) ; }

             check_array(yystack.l_mark[-4].stp) ;
             if( is_local(yystack.l_mark[-4].stp) )
             { code2op(LAE_PUSHA, yystack.l_mark[-4].stp->offset) ; }
             else code2(AE_PUSHA, yystack.l_mark[-4].stp->stval.array) ;
             yyval.start = yystack.l_mark[-3].start ;
           }
break;
case 113:
#line 740 "parse.y"
	{
             if ( yystack.l_mark[-1].ival > 1 )
             { code2op(A_CAT, yystack.l_mark[-1].ival) ; }

             check_array(yystack.l_mark[-4].stp) ;
             if( is_local(yystack.l_mark[-4].stp) )
             { code2op(LAE_PUSHI, yystack.l_mark[-4].stp->offset) ; }
             else code2(AE_PUSHI, yystack.l_mark[-4].stp->stval.array) ;
             yyval.start = yystack.l_mark[-3].start ;
           }
break;
case 114:
#line 752 "parse.y"
	{
             if ( yystack.l_mark[-2].ival > 1 )
             { code2op(A_CAT,yystack.l_mark[-2].ival) ; }

             check_array(yystack.l_mark[-5].stp) ;
             if( is_local(yystack.l_mark[-5].stp) )
             { code2op(LAE_PUSHA, yystack.l_mark[-5].stp->offset) ; }
             else code2(AE_PUSHA, yystack.l_mark[-5].stp->stval.array) ;
             if ( yystack.l_mark[0].ival == '+' )  code1(_POST_INC) ;
             else  code1(_POST_DEC) ;

             yyval.start = yystack.l_mark[-4].start ;
           }
break;
case 115:
#line 769 "parse.y"
	{
               yyval.start = yystack.l_mark[-4].start ;
               if ( yystack.l_mark[-2].ival > 1 ) { code2op(A_CAT, yystack.l_mark[-2].ival) ; }
               check_array(yystack.l_mark[-5].stp) ;
               code_array(yystack.l_mark[-5].stp) ;
               code1(A_DEL) ;
             }
break;
case 116:
#line 777 "parse.y"
	{
                yyval.start = code_offset ;
                check_array(yystack.l_mark[-1].stp) ;
                code_array(yystack.l_mark[-1].stp) ;
                code1(DEL_A) ;
             }
break;
case 117:
#line 788 "parse.y"
	{ eat_nl() ; BC_new() ;
                      yyval.start = code_offset ;

                      check_var(yystack.l_mark[-3].stp) ;
                      code_address(yystack.l_mark[-3].stp) ;
                      check_array(yystack.l_mark[-1].stp) ;
                      code_array(yystack.l_mark[-1].stp) ;

                      code2(SET_ALOOP, (INST*)0) ;
                    }
break;
case 118:
#line 802 "parse.y"
	{
                INST *p2 = CDP(yystack.l_mark[0].start) ;

                p2[-1].op = CodeOffset(p2 - 1) ;
                BC_clear( code_ptr+2 , code_ptr) ;
                code_jmp(ALOOP, p2) ;
                code1(POP_AL) ;
              }
break;
case 119:
#line 819 "parse.y"
	{ yyval.start = code_offset ; code2(F_PUSHA, yystack.l_mark[0].cp) ; }
break;
case 120:
#line 821 "parse.y"
	{ check_var(yystack.l_mark[0].stp) ;
             yyval.start = code_offset ;
             if ( is_local(yystack.l_mark[0].stp) )
             { code2op(L_PUSHI, yystack.l_mark[0].stp->offset) ; }
             else code2(_PUSHI, yystack.l_mark[0].stp->stval.cp) ;

             CODE_FE_PUSHA() ;
           }
break;
case 121:
#line 830 "parse.y"
	{
             if ( yystack.l_mark[-1].ival > 1 )
             { code2op(A_CAT, yystack.l_mark[-1].ival) ; }

             check_array(yystack.l_mark[-4].stp) ;
             if( is_local(yystack.l_mark[-4].stp) )
             { code2op(LAE_PUSHI, yystack.l_mark[-4].stp->offset) ; }
             else code2(AE_PUSHI, yystack.l_mark[-4].stp->stval.array) ;

             CODE_FE_PUSHA()  ;

             yyval.start = yystack.l_mark[-3].start ;
           }
break;
case 122:
#line 844 "parse.y"
	{ yyval.start = yystack.l_mark[0].start ;  CODE_FE_PUSHA() ; }
break;
case 123:
#line 846 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; }
break;
case 124:
#line 850 "parse.y"
	{ field_A2I() ; }
break;
case 125:
#line 853 "parse.y"
	{ code1(F_ASSIGN) ; }
break;
case 126:
#line 854 "parse.y"
	{ code1(F_ADD_ASG) ; }
break;
case 127:
#line 855 "parse.y"
	{ code1(F_SUB_ASG) ; }
break;
case 128:
#line 856 "parse.y"
	{ code1(F_MUL_ASG) ; }
break;
case 129:
#line 857 "parse.y"
	{ code1(F_DIV_ASG) ; }
break;
case 130:
#line 858 "parse.y"
	{ code1(F_MOD_ASG) ; }
break;
case 131:
#line 859 "parse.y"
	{ code1(F_POW_ASG) ; }
break;
case 132:
#line 866 "parse.y"
	{ code2(_BUILTIN, bi_split) ; }
break;
case 133:
#line 870 "parse.y"
	{ yyval.start = yystack.l_mark[-2].start ;
              check_array(yystack.l_mark[0].stp) ;
              code_array(yystack.l_mark[0].stp)  ;
            }
break;
case 134:
#line 877 "parse.y"
	{ code2(_PUSHI, &fs_shadow) ; }
break;
case 135:
#line 879 "parse.y"
	{
                  if ( CDP(yystack.l_mark[-1].start) == code_ptr - 2 )
                  {
                    if ( code_ptr[-2].op == _MATCH0 )
                        RE_as_arg() ;
                    else
                    if ( code_ptr[-2].op == _PUSHS )
                    { CELL *cp = ZMALLOC(CELL) ;

                      cp->type = C_STRING ;
                      cp->ptr = code_ptr[-1].ptr ;
                      cast_for_split(cp) ;
                      code_ptr[-2].op = _PUSHC ;
                      code_ptr[-1].ptr = (PTR) cp ;
                      no_leaks_cell(cp);
                    }
                  }
                }
break;
case 136:
#line 904 "parse.y"
	{ yyval.start = yystack.l_mark[-3].start ;
          code2(_BUILTIN, bi_match) ;
        }
break;
case 137:
#line 911 "parse.y"
	{
               INST *p1 = CDP(yystack.l_mark[0].start) ;

               if ( p1 == code_ptr - 2 )
               {
                 if ( p1->op == _MATCH0 ) RE_as_arg() ;
                 else
                 if ( p1->op == _PUSHS )
                 { CELL *cp = ZMALLOC(CELL) ;

                   cp->type = C_STRING ;
                   cp->ptr = p1[1].ptr ;
                   cast_to_RE(cp) ;
                   p1->op = _PUSHC ;
                   p1[1].ptr = (PTR) cp ;
                   no_leaks_cell(cp);
                 }
               }
             }
break;
case 138:
#line 935 "parse.y"
	{ yyval.start = code_offset ;
                      code1(_EXIT0) ; }
break;
case 139:
#line 938 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; code1(_EXIT) ; }
break;
case 140:
#line 942 "parse.y"
	{ yyval.start = code_offset ;
                      code1(_RET0) ; }
break;
case 141:
#line 945 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; code1(_RET) ; }
break;
case 142:
#line 951 "parse.y"
	{ yyval.start = code_offset ;
            code2(F_PUSHA, &field[0]) ;
            code1(_PUSHINT) ; code1(0) ;
            code2(_BUILTIN, bi_getline) ;
            getline_flag = 0 ;
          }
break;
case 143:
#line 958 "parse.y"
	{ yyval.start = yystack.l_mark[0].start ;
            code1(_PUSHINT) ; code1(0) ;
            code2(_BUILTIN, bi_getline) ;
            getline_flag = 0 ;
          }
break;
case 144:
#line 964 "parse.y"
	{ code1(_PUSHINT) ; code1(F_IN) ;
            code2(_BUILTIN, bi_getline) ;
            /* getline_flag already off in yylex() */
          }
break;
case 145:
#line 969 "parse.y"
	{ code2(F_PUSHA, &field[0]) ;
            code1(_PUSHINT) ; code1(PIPE_IN) ;
            code2(_BUILTIN, bi_getline) ;
          }
break;
case 146:
#line 974 "parse.y"
	{
            code1(_PUSHINT) ; code1(PIPE_IN) ;
            code2(_BUILTIN, bi_getline) ;
          }
break;
case 147:
#line 980 "parse.y"
	{ getline_flag = 1 ; }
break;
case 150:
#line 985 "parse.y"
	{ yyval.start = code_offset ;
                   code2(F_PUSHA, field+0) ;
                 }
break;
case 151:
#line 989 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; }
break;
case 152:
#line 997 "parse.y"
	{
             INST *p5 = CDP(yystack.l_mark[-1].start) ;
             INST *p6 = CDP(yystack.l_mark[0].start) ;

             if ( p6 - p5 == 2 && p5->op == _PUSHS  )
             { /* cast from STRING to REPL at compile time */
               CELL *cp = ZMALLOC(CELL) ;
               cp->type = C_STRING ;
               cp->ptr = p5[1].ptr ;
               cast_to_REPL(cp) ;
               p5->op = _PUSHC ;
               p5[1].ptr = (PTR) cp ;
               no_leaks_cell(cp);
             }
             code2(_BUILTIN, yystack.l_mark[-5].fp) ;
             yyval.start = yystack.l_mark[-3].start ;
           }
break;
case 153:
#line 1016 "parse.y"
	{ yyval.fp = bi_sub ; }
break;
case 154:
#line 1017 "parse.y"
	{ yyval.fp = bi_gsub ; }
break;
case 155:
#line 1022 "parse.y"
	{ yyval.start = code_offset ;
                  code2(F_PUSHA, &field[0]) ;
                }
break;
case 156:
#line 1027 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ; }
break;
case 157:
#line 1035 "parse.y"
	{
                   resize_fblock(yystack.l_mark[-1].fbp) ;
                   restore_ids() ;
                   switch_code_to_main() ;
                 }
break;
case 158:
#line 1044 "parse.y"
	{ eat_nl() ;
                   scope = SCOPE_FUNCT ;
                   active_funct = yystack.l_mark[-3].fbp ;
                   *main_code_p = active_code ;

                   yystack.l_mark[-3].fbp->nargs = (unsigned short) yystack.l_mark[-1].ival ;
                   if ( yystack.l_mark[-1].ival )
                        yystack.l_mark[-3].fbp->typev = (char *)
                        memset( zmalloc((size_t) yystack.l_mark[-1].ival), ST_LOCAL_NONE, (size_t) yystack.l_mark[-1].ival) ;
                   else yystack.l_mark[-3].fbp->typev = (char *) 0 ;

                   code_ptr = code_base =
                       (INST *) zmalloc(INST_BYTES(PAGESZ));
                   code_limit = code_base + PAGESZ ;
                   code_warn = code_limit - CODEWARN ;
		   improve_arglist(yystack.l_mark[-3].fbp->name);
		   free_arglist();
                 }
break;
case 159:
#line 1065 "parse.y"
	{ FBLOCK  *fbp ;

                   if ( yystack.l_mark[0].stp->type == ST_NONE )
                   {
                         yystack.l_mark[0].stp->type = ST_FUNCT ;
                         fbp = yystack.l_mark[0].stp->stval.fbp =
                             (FBLOCK *) zmalloc(sizeof(FBLOCK)) ;
                         fbp->name = yystack.l_mark[0].stp->name ;
                         fbp->code = (INST*) 0 ;
                   }
                   else
                   {
                         type_error( yystack.l_mark[0].stp ) ;

                         /* this FBLOCK will not be put in
                            the symbol table */
                         fbp = (FBLOCK*) zmalloc(sizeof(FBLOCK)) ;
                         fbp->name = "" ;
                   }
                   yyval.fbp = fbp ;
                 }
break;
case 160:
#line 1088 "parse.y"
	{ yyval.fbp = yystack.l_mark[0].fbp ;
                   if ( yystack.l_mark[0].fbp->code )
                       compile_error("redefinition of %s" , yystack.l_mark[0].fbp->name) ;
                 }
break;
case 161:
#line 1094 "parse.y"
	{ yyval.ival = init_arglist() ; }
break;
case 163:
#line 1099 "parse.y"
	{ init_arglist();
	        yystack.l_mark[0].stp = save_arglist(yystack.l_mark[0].stp->name) ;
                yystack.l_mark[0].stp->offset = 0 ;
                yyval.ival = 1 ;
              }
break;
case 164:
#line 1105 "parse.y"
	{ if ( is_local(yystack.l_mark[0].stp) )
                  compile_error("%s is duplicated in argument list",
                    yystack.l_mark[0].stp->name) ;
                else
                { yystack.l_mark[0].stp = save_arglist(yystack.l_mark[0].stp->name) ;
                  yystack.l_mark[0].stp->offset = (unsigned char) yystack.l_mark[-2].ival ;
                  yyval.ival = yystack.l_mark[-2].ival + 1 ;
                }
              }
break;
case 165:
#line 1117 "parse.y"
	{  /* we may have to recover from a bungled function
                       definition */
                   /* can have local ids, before code scope
                      changes  */
                    restore_ids() ;

                    switch_code_to_main() ;
                 }
break;
case 166:
#line 1130 "parse.y"
	{ yyval.start = yystack.l_mark[-1].start ;
             code2(_CALL, yystack.l_mark[-2].fbp) ;

             if ( yystack.l_mark[0].ca_p )  code1(yystack.l_mark[0].ca_p->arg_num+1) ;
             else  code1(0) ;

             check_fcall(yystack.l_mark[-2].fbp, scope, code_move_level, active_funct, yystack.l_mark[0].ca_p) ;
           }
break;
case 167:
#line 1141 "parse.y"
	{ yyval.ca_p = (CA_REC *) 0 ; }
break;
case 168:
#line 1143 "parse.y"
	{ yyval.ca_p = yystack.l_mark[0].ca_p ;
                 yyval.ca_p->link = yystack.l_mark[-1].ca_p ;
                 yyval.ca_p->arg_num = (short) (yystack.l_mark[-1].ca_p ? yystack.l_mark[-1].ca_p->arg_num+1 : 0) ;
               }
break;
case 169:
#line 1158 "parse.y"
	{ yyval.ca_p = (CA_REC *) 0 ; }
break;
case 170:
#line 1160 "parse.y"
	{ yyval.ca_p = ZMALLOC(CA_REC) ;
                yyval.ca_p->link = yystack.l_mark[-2].ca_p ;
                yyval.ca_p->type = CA_EXPR  ;
                yyval.ca_p->arg_num = (short) (yystack.l_mark[-2].ca_p ? yystack.l_mark[-2].ca_p->arg_num+1 : 0) ;
                yyval.ca_p->call_offset = code_offset ;
              }
break;
case 171:
#line 1167 "parse.y"
	{ yyval.ca_p = ZMALLOC(CA_REC) ;
                yyval.ca_p->type = ST_NONE ;
                yyval.ca_p->link = yystack.l_mark[-2].ca_p ;
                yyval.ca_p->arg_num = (short) (yystack.l_mark[-2].ca_p ? yystack.l_mark[-2].ca_p->arg_num+1 : 0) ;

                code_call_id(yyval.ca_p, yystack.l_mark[-1].stp) ;
              }
break;
case 172:
#line 1177 "parse.y"
	{ yyval.ca_p = ZMALLOC(CA_REC) ;
                yyval.ca_p->type = CA_EXPR ;
                yyval.ca_p->call_offset = code_offset ;
              }
break;
case 173:
#line 1183 "parse.y"
	{ yyval.ca_p = ZMALLOC(CA_REC) ;
                yyval.ca_p->type = ST_NONE ;
                code_call_id(yyval.ca_p, yystack.l_mark[-1].stp) ;
              }
break;
#line 2816 "parse.c"
    }
    yystack.s_mark -= yym;
    yystate = *yystack.s_mark;
    yystack.l_mark -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yystack.s_mark = YYFINAL;
        *++yystack.l_mark = yyval;
        if (yychar < 0)
        {
            if ((yychar = YYLEX) < 0) yychar = YYEOF;
#if YYDEBUG
            if (yydebug)
            {
                yys = yyname[YYTRANSLATE(yychar)];
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == YYEOF) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
#endif
    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
    {
        goto yyoverflow;
    }
    *++yystack.s_mark = (YYINT) yystate;
    *++yystack.l_mark = yyval;
    goto yyloop;

yyoverflow:
    YYERROR_CALL("yacc stack overflow");

yyabort:
    yyfreestack(&yystack);
    return (1);

yyaccept:
    yyfreestack(&yystack);
    return (0);
}