Logo Search packages:      
Sourcecode: heaplayers version File versions

tperly.c

#ifdef BWGC
extern char *gc_malloc(), *gc_realloc();
#else
extern char *malloc(), *realloc();
#endif

# line 15 "perly.y"
#include "INTERN.h"
#include "perl.h"

STAB *scrstab;
ARG *arg4;  /* rarely used arguments to make_op() */
ARG *arg5;


# line 26 "perly.y"
typedef union  {
    int     ival;
    char *cval;
    ARG *arg;
    CMD *cmdval;
    struct compcmd compval;
    STAB *stabval;
    FCMD *formval;
} YYSTYPE;
# define WORD 257
# define APPEND 258
# define OPEN 259
# define SSELECT 260
# define LOOPEX 261
# define USING 262
# define FORMAT 263
# define DO 264
# define SHIFT 265
# define PUSH 266
# define POP 267
# define LVALFUN 268
# define WHILE 269
# define UNTIL 270
# define IF 271
# define UNLESS 272
# define ELSE 273
# define ELSIF 274
# define CONTINUE 275
# define SPLIT 276
# define FLIST 277
# define FOR 278
# define FILOP 279
# define FILOP2 280
# define FILOP3 281
# define FILOP4 282
# define FILOP22 283
# define FILOP25 284
# define FUNC0 285
# define FUNC1 286
# define FUNC2 287
# define FUNC2x 288
# define FUNC3 289
# define FUNC4 290
# define FUNC5 291
# define HSHFUN 292
# define HSHFUN3 293
# define FLIST2 294
# define SUB 295
# define FILETEST 296
# define LOCAL 297
# define DELETE 298
# define RELOP 299
# define EQOP 300
# define MULOP 301
# define ADDOP 302
# define PACKAGE 303
# define AMPER 304
# define FORMLIST 305
# define REG 306
# define ARYLEN 307
# define ARY 308
# define HSH 309
# define STAR 310
# define SUBST 311
# define PATTERN 312
# define RSTRING 313
# define TRANS 314
# define LISTOP 315
# define DOTDOT 316
# define OROR 317
# define ANDAND 318
# define UNIOP 319
# define LS 320
# define RS 321
# define MATCH 322
# define NMATCH 323
# define UMINUS 324
# define POW 325
# define INC 326
# define DEC 327
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256

# line 792 "perly.y"
 /* PROGRAM */
int yyexca[] ={
-1, 1,
      0, -1,
      -2, 0,
-1, 3,
      0, 2,
      -2, 39,
-1, 92,
      59, 35,
      -2, 0,
-1, 130,
      326, 0,
      327, 0,
      -2, 84,
-1, 131,
      326, 0,
      327, 0,
      -2, 85,
-1, 229,
      299, 0,
      -2, 66,
-1, 230,
      300, 0,
      -2, 67,
-1, 231,
      316, 0,
      -2, 71,
-1, 253,
      44, 175,
      41, 175,
      -2, 181,
-1, 254,
      44, 175,
      -2, 181,
-1, 382,
      41, 35,
      -2, 0,
      };
# define YYNPROD 182
# define YYLAST 3179
int yyact[]={

   322,    26,   198,    27,   107,   115,   116,   108,   109,   124,
   125,   115,   164,   108,   109,   179,   121,   122,   319,   107,
    88,    90,   167,   163,    94,    96,   110,   111,   121,   122,
   181,   107,   110,   111,   121,   122,   108,   107,   112,   146,
   133,   138,   153,   137,   251,   108,   109,   145,   282,    11,
   188,    92,   112,   108,   109,    12,   149,   121,   122,    83,
   107,   152,   191,   165,   110,   111,   121,   122,   300,   107,
   148,   171,    85,    84,   121,   122,   286,   107,   180,   101,
   162,    28,   182,   104,   105,   102,   189,    13,   147,   101,
   101,     3,   243,   101,    95,    14,   143,    21,   141,   248,
   101,    93,    89,   101,   209,   208,   210,   303,   113,   101,
   212,   214,   216,   218,   220,   222,   224,   226,   228,   229,
   230,   231,   232,   233,   234,   235,   236,    87,   144,   241,
   142,   187,   382,   287,   190,    86,    81,   323,   114,   375,
   101,   320,   323,   141,   166,   372,   101,   360,   320,   384,
   101,   329,   355,   327,   252,   406,   256,   256,   311,   404,
   256,   256,   256,   256,   256,   101,   359,   402,   400,   101,
   358,   312,   267,   268,   310,   142,   398,    28,   273,   274,
   275,   276,   277,    32,    28,    28,   193,   397,   195,   309,
    38,   250,   201,    31,   203,    30,   357,   255,   257,   101,
    11,   259,   260,   261,   262,   263,    12,   395,   356,    16,
    28,   101,   392,   352,   391,   237,   101,   291,   390,   292,
   387,   293,   386,   294,   374,   295,   373,   296,   370,   297,
   347,   298,   181,   101,   337,   365,   363,   101,    13,   164,
   164,   343,   264,   208,   265,   332,    14,   336,   266,   301,
   101,   289,   101,   331,   101,    82,    32,   324,   278,   154,
   325,   288,   279,    38,   101,   330,    31,   284,    30,   335,
   101,   321,   240,    28,   338,   239,    33,   318,   151,   326,
   283,   328,   270,   249,   182,   242,   333,   211,   196,   183,
   165,   165,   112,   339,   340,   341,   342,   178,   344,   115,
   116,   108,   109,   353,    99,   100,    97,    98,   155,   177,
   176,   175,   174,   115,   116,   108,   109,    91,   173,   172,
   110,   111,   121,   122,   362,   107,   170,   366,   169,   168,
   161,   256,   118,   256,   110,   111,   121,   122,   361,   107,
   376,   377,   160,   159,   158,   380,   157,   368,   113,    33,
   349,   156,   371,   150,   134,   199,    32,    10,     9,     2,
   378,   379,    17,    38,   317,     6,    31,    77,    30,   388,
    78,   103,   367,    15,   369,     7,     4,   123,   114,   393,
   385,   345,   346,     8,   348,   396,   350,   351,   389,     5,
    99,   100,    97,    98,     1,   401,     0,     0,   394,     0,
   403,     0,     0,     0,   405,     0,    24,    79,   399,    54,
    53,    51,   112,     0,    39,    63,    61,    62,    67,    18,
    19,    22,    23,     0,     0,     0,    64,    66,    20,    55,
    56,    57,    59,    58,    60,    68,    69,    70,    71,    72,
    73,    74,    75,    76,    65,   381,    36,    37,    44,    33,
   383,     0,     0,     0,    50,     0,    40,    45,    43,    42,
    41,    48,    47,    46,    49,    80,     0,     0,   113,    52,
     0,     0,     0,     0,     0,     0,    34,    35,     0,    24,
    79,     0,    54,    53,    51,    32,     0,    39,    63,    61,
    62,    67,    38,   315,     0,    31,     0,    30,   114,    64,
    66,     0,    55,    56,    57,    59,    58,    60,    68,    69,
    70,    71,    72,    73,    74,    75,    76,    65,     0,    36,
    37,    44,     0,     0,     0,     0,     0,    50,    29,    40,
    45,    43,    42,    41,    48,    47,    46,    49,    80,     0,
     0,     0,    52,     0,     0,     0,     0,     0,     0,    34,
    35,     0,     0,   115,   116,   108,   109,     0,    32,   126,
   127,   128,   129,   130,   131,    38,   308,     0,    31,     0,
    30,   119,   118,     0,   110,   111,   121,   122,    33,   107,
    79,     0,    54,    53,    51,     0,     0,    39,    63,    61,
    62,    67,     0,     0,     0,     0,     0,     0,     0,    64,
    66,     0,    55,    56,    57,    59,    58,    60,    68,    69,
    70,    71,    72,    73,    74,    75,    76,    65,     0,    36,
    37,    44,     0,     0,     0,     0,     0,    50,     0,    40,
    45,    43,    42,    41,    48,    47,    46,    49,    80,     0,
     0,     0,    52,     0,     0,     0,     0,     0,     0,    34,
    35,    33,     0,     0,    32,     0,     0,     0,     0,     0,
     0,    38,   306,     0,    31,     0,    30,     0,     0,     0,
     0,     0,     0,   115,   116,   108,   109,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,   110,   111,   121,   122,     0,   107,
     0,   112,     0,     0,   334,     0,     0,   320,     0,    79,
     0,    54,    53,    51,     0,     0,    39,    63,    61,    62,
    67,     0,     0,     0,   106,     0,   120,     0,    64,    66,
     0,    55,    56,    57,    59,    58,    60,    68,    69,    70,
    71,    72,    73,    74,    75,    76,    65,    33,    36,    37,
    44,     0,     0,     0,     0,     0,    50,   113,    40,    45,
    43,    42,    41,    48,    47,    46,    49,    80,     0,   112,
     0,    52,     0,     0,     0,     0,     0,     0,    34,    35,
     0,     0,    79,     0,    54,    53,    51,   114,     0,    39,
    63,    61,    62,    67,   120,     0,     0,     0,     0,     0,
     0,    64,    66,     0,    55,    56,    57,    59,    58,    60,
    68,    69,    70,    71,    72,    73,    74,    75,    76,    65,
     0,    36,    37,    44,     0,   113,     0,     0,     0,    50,
     0,    40,    45,    43,    42,    41,    48,    47,    46,    49,
    80,     0,     0,     0,    52,     0,    32,     0,     0,     0,
     0,    34,    35,    38,   302,   114,    31,     0,    30,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,    79,     0,
    54,    53,    51,     0,     0,    39,    63,    61,    62,    67,
     0,     0,     0,     0,     0,     0,     0,    64,    66,     0,
    55,    56,    57,    59,    58,    60,    68,    69,    70,    71,
    72,    73,    74,    75,    76,    65,     0,    36,    37,    44,
     0,     0,     0,     0,     0,    50,     0,    40,    45,    43,
    42,    41,    48,    47,    46,    49,    80,     0,     0,    33,
    52,     0,    32,     0,     0,     0,     0,    34,    35,    38,
   271,     0,    31,     0,    30,     0,     0,     0,     0,     0,
     0,     0,   115,   116,   108,   109,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,   117,
   119,   118,     0,   110,   111,   121,   122,     0,   107,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,    32,     0,     0,     0,     0,
     0,     0,    38,   258,     0,    31,     0,    30,     0,     0,
   115,   116,   108,   109,     0,    33,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   117,   119,   118,
     0,   110,   111,   121,   122,     0,   107,     0,     0,   112,
     0,     0,     0,     0,     0,   320,     0,     0,     0,     0,
    79,     0,    54,    53,    51,     0,     0,    39,    63,    61,
    62,    67,   106,     0,   120,     0,     0,     0,     0,    64,
    66,     0,    55,    56,    57,    59,    58,    60,    68,    69,
    70,    71,    72,    73,    74,    75,    76,    65,    33,    36,
    37,    44,     0,     0,     0,   113,     0,    50,     0,    40,
    45,    43,    42,    41,    48,    47,    46,    49,    80,     0,
     0,     0,    52,     0,    32,     0,     0,     0,     0,    34,
    35,    38,     0,     0,    31,   114,    30,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,   227,     0,     0,     0,    79,     0,    54,    53,
    51,     0,     0,    39,    63,    61,    62,    67,     0,     0,
     0,     0,     0,     0,     0,    64,    66,     0,    55,    56,
    57,    59,    58,    60,    68,    69,    70,    71,    72,    73,
    74,    75,    76,    65,     0,    36,    37,    44,     0,     0,
     0,     0,     0,    50,     0,    40,    45,    43,    42,    41,
    48,    47,    46,    49,    80,     0,     0,    33,    52,     0,
     0,     0,     0,     0,     0,    34,    35,     0,     0,   253,
     0,    54,    53,    51,     0,     0,    39,    63,    61,    62,
    67,     0,     0,     0,     0,     0,     0,     0,    64,    66,
     0,    55,    56,    57,    59,    58,    60,    68,    69,    70,
    71,    72,    73,    74,    75,    76,    65,     0,    36,    37,
    44,     0,     0,     0,     0,     0,    50,     0,    40,    45,
    43,    42,    41,    48,    47,    46,    49,    80,     0,     0,
     0,    52,     0,    32,     0,     0,     0,     0,    34,    35,
    38,     0,     0,    31,     0,    30,     0,     0,     0,     0,
   115,   116,   108,   109,     0,     0,     0,     0,     0,     0,
     0,   225,     0,     0,     0,     0,     0,   117,   119,   118,
     0,   110,   111,   121,   122,     0,   107,   112,     0,     0,
     0,     0,     0,   323,     0,     0,     0,     0,    79,     0,
    54,    53,    51,     0,     0,    39,    63,    61,    62,    67,
   106,     0,   120,     0,     0,     0,     0,    64,    66,     0,
    55,    56,    57,    59,    58,    60,    68,    69,    70,    71,
    72,    73,    74,    75,    76,    65,    33,    36,    37,    44,
     0,     0,     0,   113,     0,    50,     0,    40,    45,    43,
    42,    41,    48,    47,    46,    49,    80,     0,     0,    32,
    52,     0,     0,     0,     0,     0,    38,    34,    35,    31,
     0,    30,     0,   114,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   223,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,    32,     0,     0,     0,     0,     0,     0,
    38,     0,     0,    31,     0,    30,     0,     0,     0,     0,
     0,     0,    33,     0,     0,     0,     0,     0,     0,     0,
     0,   221,     0,     0,     0,     0,     0,    79,     0,    54,
    53,    51,     0,     0,    39,    63,    61,    62,    67,     0,
     0,     0,     0,     0,     0,     0,    64,    66,     0,    55,
    56,    57,    59,    58,    60,    68,    69,    70,    71,    72,
    73,    74,    75,    76,    65,     0,    36,    37,    44,     0,
     0,     0,     0,     0,    50,     0,    40,    45,    43,    42,
    41,    48,    47,    46,    49,    80,    33,     0,    32,    52,
     0,     0,     0,     0,     0,    38,    34,    35,    31,     0,
    30,     0,     0,     0,     0,     0,     0,     0,   115,   116,
   108,   109,     0,     0,     0,     0,   219,     0,     0,     0,
     0,     0,     0,     0,     0,   117,   119,   118,     0,   110,
   111,   121,   122,     0,   107,     0,     0,     0,     0,     0,
     0,     0,     0,    79,     0,    54,    53,    51,     0,     0,
    39,    63,    61,    62,    67,     0,     0,     0,     0,     0,
     0,     0,    64,    66,     0,    55,    56,    57,    59,    58,
    60,    68,    69,    70,    71,    72,    73,    74,    75,    76,
    65,    33,    36,    37,    44,     0,     0,     0,     0,     0,
    50,     0,    40,    45,    43,    42,    41,    48,    47,    46,
    49,    80,     0,     0,    32,    52,     0,     0,     0,     0,
     0,    38,    34,    35,    31,     0,    30,    79,     0,    54,
    53,    51,     0,     0,    39,    63,    61,    62,    67,     0,
     0,     0,   217,     0,     0,     0,    64,    66,     0,    55,
    56,    57,    59,    58,    60,    68,    69,    70,    71,    72,
    73,    74,    75,    76,    65,     0,    36,    37,    44,     0,
     0,     0,     0,     0,    50,     0,    40,    45,    43,    42,
    41,    48,    47,    46,    49,    80,     0,     0,    32,    52,
     0,     0,     0,     0,     0,    38,    34,    35,    31,     0,
    30,     0,     0,     0,     0,     0,     0,    33,     0,     0,
     0,     0,     0,     0,     0,     0,   215,     0,     0,     0,
     0,     0,    79,     0,    54,    53,    51,     0,     0,    39,
    63,    61,    62,    67,     0,     0,     0,     0,     0,     0,
     0,    64,    66,     0,    55,    56,    57,    59,    58,    60,
    68,    69,    70,    71,    72,    73,    74,    75,    76,    65,
     0,    36,    37,    44,     0,     0,     0,     0,     0,    50,
     0,    40,    45,    43,    42,    41,    48,    47,    46,    49,
    80,    33,     0,    32,    52,     0,     0,     0,     0,     0,
    38,    34,    35,    31,     0,    30,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,   213,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   112,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,    79,     0,
    54,    53,    51,     0,     0,    39,    63,    61,    62,    67,
   106,     0,   120,     0,     0,     0,     0,    64,    66,     0,
    55,    56,    57,    59,    58,    60,    68,    69,    70,    71,
    72,    73,    74,    75,    76,    65,    33,    36,    37,    44,
     0,     0,     0,   113,     0,    50,     0,    40,    45,    43,
    42,    41,    48,    47,    46,    49,    80,     0,     0,    32,
    52,     0,     0,     0,     0,     0,    38,    34,    35,    31,
     0,    30,    79,   114,    54,    53,    51,     0,     0,    39,
    63,    61,    62,    67,     0,     0,     0,     0,     0,     0,
     0,    64,    66,     0,    55,    56,    57,    59,    58,    60,
    68,    69,    70,    71,    72,    73,    74,    75,    76,    65,
     0,    36,    37,    44,     0,     0,     0,     0,     0,    50,
     0,    40,    45,    43,    42,    41,    48,    47,    46,    49,
    80,     0,     0,     0,    52,     0,     0,     0,    32,     0,
     0,    34,    35,     0,     0,    38,   136,     0,    31,    28,
    30,     0,    33,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,    79,     0,    54,
    53,    51,     0,     0,    39,    63,    61,    62,    67,     0,
     0,     0,     0,     0,     0,     0,    64,    66,     0,    55,
    56,    57,    59,    58,    60,    68,    69,    70,    71,    72,
    73,    74,    75,    76,    65,     0,    36,    37,    44,     0,
     0,     0,     0,     0,    50,     0,    40,    45,    43,    42,
    41,    48,    47,    46,    49,    80,     0,     0,    32,    52,
     0,    33,     0,     0,     0,    38,    34,    35,    31,     0,
    30,     0,     0,     0,     0,     0,     0,     0,   115,   116,
   108,   109,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   117,   119,   118,     0,   110,
   111,   121,   122,     0,   107,   112,     0,     0,     0,     0,
     0,     0,     0,   139,     0,    54,    53,    51,     0,     0,
    39,    63,    61,    62,    67,   299,     0,     0,   106,     0,
   120,     0,    64,    66,     0,    55,    56,    57,    59,    58,
    60,    68,    69,    70,    71,    72,    73,    74,    75,    76,
    65,    33,    36,    37,    44,     0,     0,     0,     0,     0,
    50,   113,   140,    45,    43,    42,    41,    48,    47,    46,
    49,    80,     0,     0,    32,    52,     0,     0,     0,     0,
     0,    38,    34,    35,    31,     0,    30,     0,     0,     0,
     0,   114,    79,     0,    54,    53,    51,     0,     0,    39,
    63,    61,    62,    67,     0,     0,     0,     0,     0,     0,
     0,    64,    66,     0,    55,    56,    57,    59,    58,    60,
    68,    69,    70,    71,    72,    73,    74,    75,    76,    65,
     0,    36,    37,    44,     0,     0,     0,     0,     0,    50,
     0,    40,    45,    43,    42,    41,    48,    47,    46,    49,
    80,     0,     0,    32,    52,     0,     0,     0,     0,     0,
    38,    34,    35,    31,     0,    30,     0,    33,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,   253,     0,    54,    53,    51,     0,     0,    39,
    63,    61,    62,    67,     0,     0,     0,     0,     0,     0,
     0,    64,    66,     0,    55,    56,    57,    59,    58,    60,
    68,    69,    70,    71,    72,    73,    74,    75,    76,    65,
     0,    36,    37,    44,     0,     0,     0,     0,     0,    50,
     0,    40,    45,    43,    42,    41,    48,    47,    46,    49,
    80,     0,     0,    32,    52,     0,    33,     0,     0,     0,
    38,    34,    35,    31,     0,    30,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,   115,   116,   108,   109,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,   117,   119,   118,     0,   110,   111,   121,
   122,     0,   107,     0,     0,     0,     0,     0,    79,     0,
    54,    53,    51,     0,     0,    39,    63,    61,    62,    67,
     0,     0,     0,     0,     0,     0,     0,    64,    66,     0,
    55,    56,    57,    59,    58,    60,    68,    69,    70,    71,
    72,    73,    74,    75,    76,    65,    33,    36,    37,    44,
     0,     0,     0,     0,     0,    50,     0,    40,    45,    43,
    42,    41,    48,    47,    46,    49,    80,     0,     0,    32,
    52,     0,     0,     0,     0,     0,    38,    34,    35,    31,
     0,    30,     0,     0,     0,     0,     0,   254,     0,    54,
    53,    51,     0,     0,    39,    63,    61,    62,    67,     0,
     0,     0,     0,     0,     0,     0,    64,    66,     0,    55,
    56,    57,    59,    58,    60,    68,    69,    70,    71,    72,
    73,    74,    75,    76,    65,     0,    36,    37,    44,     0,
     0,     0,     0,     0,    50,     0,    40,    45,    43,    42,
    41,    48,    47,    46,    49,    80,     0,     0,     0,    52,
     0,     0,     0,     0,     0,     0,    34,    35,     0,     0,
     0,    32,    33,     0,     0,     0,     0,     0,    38,     0,
     0,    31,     0,    30,     0,     0,     0,   185,     0,    54,
    53,    51,     0,     0,    39,    63,    61,    62,    67,     0,
     0,     0,     0,     0,     0,     0,    64,    66,     0,    55,
    56,    57,    59,    58,    60,    68,    69,    70,    71,    72,
    73,    74,    75,    76,    65,     0,    36,    37,    44,   141,
     0,     0,     0,     0,    50,     0,   186,    45,    43,    42,
    41,    48,    47,    46,    49,    80,     0,     0,     0,    52,
     0,     0,     0,     0,     0,     0,    34,    35,     0,     0,
     0,   142,     0,     0,    33,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,   132,     0,    54,    53,    51,     0,     0,
    39,    63,    61,    62,    67,     0,     0,     0,     0,     0,
     0,     0,    64,    66,     0,    55,    56,    57,    59,    58,
    60,    68,    69,    70,    71,    72,    73,    74,    75,    76,
    65,     0,    36,    37,    44,     0,     0,     0,     0,     0,
    50,     0,    40,    45,    43,    42,    41,    48,    47,    46,
    49,    80,     0,     0,     0,    52,     0,     0,     0,     0,
     0,     0,    34,    35,    25,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,    79,     0,    54,    53,    51,
     0,     0,    39,    63,    61,    62,    67,     0,     0,     0,
     0,     0,     0,   135,    64,    66,     0,    55,    56,    57,
    59,    58,    60,    68,    69,    70,    71,    72,    73,    74,
    75,    76,    65,     0,    36,    37,    44,     0,     0,     0,
     0,     0,    50,     0,    40,    45,    43,    42,    41,    48,
    47,    46,    49,    80,     0,   184,     0,    52,     0,     0,
     0,     0,   192,     0,   194,     0,     0,   197,   200,     0,
   202,     0,   204,   205,   206,   207,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,   238,
     0,     0,     0,     0,     0,     0,   244,   245,   246,   247,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   269,     0,     0,   272,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
   280,   281,     0,     0,     0,     0,     0,     0,     0,     0,
     0,   285,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,   290,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,   304,   305,   307,     0,
     0,     0,     0,   313,   314,   316,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,   192,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,   354,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,   364 };
int yypact[]={

 -1000, -1000, -1000,  -208, -1000, -1000,   150, -1000, -1000, -1000,
 -1000,    78,    -2,  -184,  -185, -1000, -1000,    76,    87,    62,
    11, -1000,    61,    54, -1000,   121,  -190,  1879, -1000,  -317,
  2241,  2241,  2241,  2241,  2241,  2241,  2526,   314,  2035,  1956,
     7, -1000, -1000,     5,  -259, -1000, -1000, -1000, -1000, -1000,
  -218,  -187,  2241,   313,    21,     2,   311,   306,   304,   303,
   302,   290,   -17,   -18,   289,   288,   286,  2241,   279,   278,
   272,   271,   270,   269,   257,   -25,   249, -1000, -1000, -1000,
  2410, -1000,    70,  -255,   -42,    75, -1000,  2241,   -42,  2241,
   -42,   248,   223,  2241,   -42,  2241,   -42,  2241,  2241,  2241,
  2241,  2241,   -42, -1000,   -42,   247,  2241,  1840,  1745,  1671,
  1555,  1460,  1386,  1270,  1101,  2241,  2241,  2241,  2241,  2241,
  2241,  2241,  2241, -1000, -1000, -1000,  -317,  -317,  -317,  -317,
 -1000, -1000, -1000,  -256,  2241,   231,    38,  -256, -1000,   245,
    52,  2241,  2241,  2241,  2241,   -24,   243,   151, -1000,  -256,
  2125, -1000,  2320,   982, -1000, -1000,  2125,  2125,  2125,  2125,
  2125,  -245, -1000,  -245, -1000, -1000, -1000,  -245,  2241,  2241,
  2241, -1000,   241,   909,  2241,  2241,  2241,  2241,  2241,  -227,
 -1000, -1000, -1000,  -227,   102,  2241,  2618,  -257, -1000, -1000,
 -1000,   239,   102, -1000,   226, -1000,  2241,    35,    74, -1000,
   220, -1000,   210, -1000,   102,   102,   102,   102,  1879, -1000,
 -1000,  2241,  1879,  2241,  -321,  2241,  -306,  2241,  -265,  2241,
  -248,  2241,  -248,  2241,  -294,  2241,     0,  2241,     0,  -256,
  -288,   254,   374,    14,  2167,  -321,  -321,   -57,   208,   813,
    16,  2241,   621,   525,    96,    49,    65,    46,  2241,   452,
   323,   236,  1021, -1000,   230,    93,  1879,   216, -1000,    93,
    97,   109,    97,   107,    93,   212,   204,   663,  1309,   206,
 -1000, -1000,   193,  1309,  1021,  1021,  1021,  1021,   200,    97,
   102,   102, -1000,   -42,   -42,   189,   -42,  2241,   -42,   -42,
   172,  1879,  1879,  1879,  1879,  1879,  1879,  1879,  1879,  2241,
 -1000, -1000, -1000,  2241,    59,   167, -1000,   155, -1000, -1000,
 -1000, -1000, -1000,    45,   125, -1000,   106, -1000, -1000,    97,
  2241, -1000,   195,  2241, -1000,   194,    93,  2125,    97,  2125,
   187, -1000, -1000,   104, -1000,   185, -1000, -1000,   183,    98,
    93,    97,    97, -1000,    93, -1000, -1000,   -42, -1000,    73,
 -1000, -1000,   -42,   731,    56, -1000, -1000, -1000, -1000, -1000,
 -1000,    97,  1879, -1000,   102, -1000,   181,   179,    93,    97,
 -1000,   177, -1000, -1000, -1000, -1000,   173,   171,    93,    97,
   166, -1000,   223, -1000, -1000,   146, -1000, -1000,   135,    97,
 -1000, -1000, -1000,   127,    93, -1000,   126, -1000, -1000,    93,
 -1000,   118,   -42,   114, -1000, -1000, -1000 };
int yypgo[]={

     0,   394,   389,   383,   377,     1,    91,   376,   375,   373,
   355,     2,   371,  2854,     3,     0,    18,   528,    44,    80,
    78,    62,   370,   367,   365,    97,   359,   358,   357 };
int yyr1[]={

     0,    26,     1,    25,    25,    12,    12,    12,     5,     4,
     6,     6,     7,     7,     7,     7,     7,    10,    10,    10,
    10,    10,    10,     9,     9,     9,     9,     8,     8,     8,
     8,     8,     8,     8,     8,    11,    11,    21,    21,    24,
    24,     2,     2,     2,     3,     3,    27,    28,    15,    13,
    13,    16,    14,    14,    14,    14,    14,    14,    14,    14,
    14,    14,    14,    14,    14,    14,    14,    14,    14,    14,
    14,    14,    14,    14,    14,    14,    14,    14,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
    22,    22,    22,    22,    22,    18,    18,    19,    19,    20,
    20,    23 };
int yyr2[]={

     0,     1,     5,     7,     5,     1,     5,    11,     9,     1,
     1,     5,     3,     5,     2,     5,     7,     3,     3,     7,
     7,     7,     7,    11,    11,     7,     7,    13,    13,     9,
     9,    15,    13,    21,     5,     1,     2,     1,     2,     1,
     4,     3,     3,     3,     9,     7,     7,     7,     5,     7,
     2,     5,     7,     9,     9,     9,     9,     9,     9,     9,
     9,     7,     7,     7,     7,     7,     7,     7,     7,     7,
     7,     7,     7,     7,    11,     7,     7,     3,     5,     5,
     5,     5,     5,     5,     5,     5,     5,     5,     3,     9,
     9,     7,     5,     5,     5,     3,     3,     9,     3,     3,
     9,    13,    11,     9,     9,    11,     3,     3,     3,     3,
     3,    11,    11,     9,     9,     5,    11,    11,     9,     9,
     5,     3,     5,     3,     5,     3,     9,    15,     5,     9,
    11,     9,     5,     5,     7,     3,    11,    13,    13,    15,
    19,    11,     5,     9,     5,     9,     3,     3,    13,    11,
     9,    11,     9,     5,     3,     3,     7,     7,     9,    11,
    11,    13,    13,    15,    17,     9,     5,    13,     2,     2,
     3,     5,     5,     7,     7,     3,     2,     3,     3,     3,
     3,     3 };
int yychk[]={

 -1000,    -1,   -26,    -6,    -7,    -2,   -24,    -8,    -3,   -27,
   -28,   257,   263,   295,   303,    -9,    59,   -10,   269,   270,
   278,   -25,   271,   272,   256,   -13,    -5,   -14,   123,   -17,
    45,    43,    33,   126,   326,   327,   296,   297,    40,   264,
   306,   310,   309,   308,   298,   307,   313,   312,   311,   314,
   304,   261,   319,   260,   259,   279,   280,   281,   283,   282,
   284,   266,   267,   265,   276,   294,   277,   268,   285,   286,
   287,   288,   289,   290,   291,   292,   293,   -23,   -22,   257,
   315,    58,   257,    61,   257,   257,    59,    40,    -5,    40,
    -5,   306,    40,    40,    -5,    40,    -5,   271,   272,   269,
   270,    44,   275,   -12,   273,   274,    61,   325,   301,   302,
   320,   321,    38,    94,   124,   299,   300,   316,   318,   317,
    63,   322,   323,    -4,   326,   327,   -17,   -17,   -17,   -17,
   -17,   -17,   257,   -14,    40,   -13,    41,   -14,    -5,   257,
   306,    91,   123,    91,   123,   306,   257,   306,   257,   -14,
    40,   257,    40,    40,   257,   306,    40,    40,    40,    40,
    40,    40,   -19,    40,   257,   308,   -19,    40,    40,    40,
    40,   -14,    40,    40,    40,    40,    40,    40,    40,    40,
   -20,   257,   309,    40,   -13,   257,   306,    61,   305,    -5,
    59,   -21,   -13,   -25,   -13,   -25,    40,   -13,   -11,   -10,
   -13,   -25,   -13,   -25,   -13,   -13,   -13,   -13,   -14,    -5,
    -5,    40,   -14,    61,   -14,    61,   -14,    61,   -14,    61,
   -14,    61,   -14,    61,   -14,    61,   -14,    61,   -14,   -14,
   -14,   -14,   -14,   -14,   -14,   -14,   -14,    -6,   -13,    44,
    41,    91,    40,    40,   -13,   -13,   -13,   -13,   123,    40,
    40,   -18,   -14,   257,   257,   -18,   -14,   -18,    41,   -18,
   -18,   -18,   -18,   -18,   -19,   -19,   -19,   -14,   -14,   -13,
    41,    41,   -13,   -14,   -14,   -14,   -14,   -14,   -20,   -20,
   -13,   -13,   305,    41,    41,   -13,    41,    59,    41,    41,
   -13,   -14,   -14,   -14,   -14,   -14,   -14,   -14,   -14,    58,
   125,    41,    41,    91,   -13,   -13,    41,   -13,    41,    93,
   125,    93,   125,   -13,   -13,    41,   -13,    41,    41,   -16,
    44,    41,   -15,    44,    41,   -15,   -16,    44,   -16,    44,
   -15,    41,    41,   -16,    41,   -15,    41,    41,   -15,   -16,
   -16,   -16,   -16,    41,   -16,   -25,   -25,    41,   -25,   -21,
   -25,   -25,    41,   -14,   -13,    93,    41,    41,   125,    41,
    41,   -16,   -14,    41,   -13,    41,   -15,   -18,   -16,   -18,
    41,   -16,    41,    41,    41,    41,   -15,   -15,   -16,   -16,
   -15,   -25,    59,   -25,    93,   -16,    41,    41,   -15,   -16,
    41,    41,    41,   -15,   -16,    41,   -11,    41,    41,   -16,
    41,   -15,    41,   -15,    41,    -5,    41 };
int yydef[]={

     1,    -2,    10,    -2,    11,    12,     0,    14,    41,    42,
    43,     0,     0,     0,     0,    13,    15,     0,     0,     0,
     0,    34,     0,     0,    17,    18,     5,    50,     9,    77,
     0,     0,     0,     0,     0,     0,    88,     0,     0,     0,
    95,    96,    98,    99,     0,   106,   107,   108,   109,   110,
     0,   121,   123,   125,     0,   135,     0,     0,     0,     0,
     0,     0,     0,   146,   147,     0,     0,   154,   155,     0,
     0,     0,     0,     0,     0,     0,     0,   168,   169,   181,
   170,    40,     0,     0,     0,     0,    16,    37,     0,     0,
     0,     0,    -2,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     4,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,    10,    82,    83,    78,    79,    80,    81,
    -2,    -2,    86,    87,     0,     0,    92,    93,    94,   181,
    95,     0,     0,     0,     0,     0,   115,   120,   122,   124,
     0,   128,     0,     0,   132,   133,     0,     0,     0,     0,
     0,     0,   142,     0,   177,   178,   144,     0,     0,     0,
     0,   153,     0,     0,     0,     0,     0,     0,     0,     0,
   166,   179,   180,     0,   171,   172,    95,     0,    45,    46,
    47,     0,    38,    29,     0,    30,     0,    18,     0,    36,
     0,    25,     0,    26,    19,    20,    21,    22,    49,     3,
     6,     0,    52,     0,    61,     0,    62,     0,    63,     0,
    64,     0,    65,     0,    68,     0,    69,     0,    70,    -2,
    -2,    -2,    72,    73,     0,    75,    76,    39,     0,     0,
    91,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,   176,    -2,    -2,     0,   176,     0,   134,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
   156,   157,     0,     0,     0,     0,     0,     0,     0,     0,
   173,   174,    44,     0,     0,     0,     0,    37,     0,     0,
     0,    53,    54,    55,    56,    57,    58,    59,    60,     0,
     8,    89,    90,     0,     0,     0,   113,     0,   118,    97,
   100,   103,   104,     0,     0,   114,     0,   119,   126,     0,
     0,   129,     0,     0,   131,     0,     0,     0,     0,     0,
     0,   143,   145,     0,   150,     0,   152,   158,     0,     0,
     0,     0,     0,   165,     0,    27,    28,     0,    32,     0,
    23,    24,     0,    74,     0,   102,   111,   116,   105,   112,
   117,     0,    51,   130,    48,   136,     0,     0,     0,     0,
   141,     0,   149,   151,   159,   160,     0,     0,     0,     0,
     0,    31,    -2,     7,   101,     0,   137,   138,     0,     0,
   148,   161,   162,     0,     0,   167,     0,   127,   139,     0,
   163,     0,     0,     0,   164,    33,   140 };
typedef struct { char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
#     define YYDEBUG    0     /* don't allow debugging */
#endif

#if YYDEBUG

yytoktype yytoks[] =
{
      "WORD",     257,
      "APPEND",   258,
      "OPEN",     259,
      "SSELECT",  260,
      "LOOPEX",   261,
      "USING",    262,
      "FORMAT",   263,
      "DO", 264,
      "SHIFT",    265,
      "PUSH",     266,
      "POP",      267,
      "LVALFUN",  268,
      "WHILE",    269,
      "UNTIL",    270,
      "IF", 271,
      "UNLESS",   272,
      "ELSE",     273,
      "ELSIF",    274,
      "CONTINUE", 275,
      "SPLIT",    276,
      "FLIST",    277,
      "FOR",      278,
      "FILOP",    279,
      "FILOP2",   280,
      "FILOP3",   281,
      "FILOP4",   282,
      "FILOP22",  283,
      "FILOP25",  284,
      "FUNC0",    285,
      "FUNC1",    286,
      "FUNC2",    287,
      "FUNC2x",   288,
      "FUNC3",    289,
      "FUNC4",    290,
      "FUNC5",    291,
      "HSHFUN",   292,
      "HSHFUN3",  293,
      "FLIST2",   294,
      "SUB",      295,
      "FILETEST", 296,
      "LOCAL",    297,
      "DELETE",   298,
      "RELOP",    299,
      "EQOP",     300,
      "MULOP",    301,
      "ADDOP",    302,
      "PACKAGE",  303,
      "AMPER",    304,
      "FORMLIST", 305,
      "REG",      306,
      "ARYLEN",   307,
      "ARY",      308,
      "HSH",      309,
      "STAR",     310,
      "SUBST",    311,
      "PATTERN",  312,
      "RSTRING",  313,
      "TRANS",    314,
      "LISTOP",   315,
      ",",  44,
      "=",  61,
      "?",  63,
      ":",  58,
      "DOTDOT",   316,
      "OROR",     317,
      "ANDAND",   318,
      "|",  124,
      "^",  94,
      "&",  38,
      "UNIOP",    319,
      "LS", 320,
      "RS", 321,
      "MATCH",    322,
      "NMATCH",   323,
      "!",  33,
      "~",  126,
      "UMINUS",   324,
      "POW",      325,
      "INC",      326,
      "DEC",      327,
      "(",  40,
      "-unknown-",      -1    /* ends search */
};

char * yyreds[] =
{
      "-no such reduction-",
      "prog : /* empty */",
      "prog : lineseq",
      "compblock : block CONTINUE block",
      "compblock : block else",
      "else : /* empty */",
      "else : ELSE block",
      "else : ELSIF '(' expr ')' compblock",
      "block : '{' remember lineseq '}'",
      "remember : /* empty */",
      "lineseq : /* empty */",
      "lineseq : lineseq line",
      "line : decl",
      "line : label cond",
      "line : loop",
      "line : label ';'",
      "line : label sideff ';'",
      "sideff : error",
      "sideff : expr",
      "sideff : expr IF expr",
      "sideff : expr UNLESS expr",
      "sideff : expr WHILE expr",
      "sideff : expr UNTIL expr",
      "cond : IF '(' expr ')' compblock",
      "cond : UNLESS '(' expr ')' compblock",
      "cond : IF block compblock",
      "cond : UNLESS block compblock",
      "loop : label WHILE '(' texpr ')' compblock",
      "loop : label UNTIL '(' expr ')' compblock",
      "loop : label WHILE block compblock",
      "loop : label UNTIL block compblock",
      "loop : label FOR REG '(' expr ')' compblock",
      "loop : label FOR '(' expr ')' compblock",
      "loop : label FOR '(' nexpr ';' texpr ';' nexpr ')' block",
      "loop : label compblock",
      "nexpr : /* empty */",
      "nexpr : sideff",
      "texpr : /* empty */",
      "texpr : expr",
      "label : /* empty */",
      "label : WORD ':'",
      "decl : format",
      "decl : subrout",
      "decl : package",
      "format : FORMAT WORD '=' FORMLIST",
      "format : FORMAT '=' FORMLIST",
      "subrout : SUB WORD block",
      "package : PACKAGE WORD ';'",
      "cexpr : ',' expr",
      "expr : expr ',' sexpr",
      "expr : sexpr",
      "csexpr : ',' sexpr",
      "sexpr : sexpr '=' sexpr",
      "sexpr : sexpr POW '=' sexpr",
      "sexpr : sexpr MULOP '=' sexpr",
      "sexpr : sexpr ADDOP '=' sexpr",
      "sexpr : sexpr LS '=' sexpr",
      "sexpr : sexpr RS '=' sexpr",
      "sexpr : sexpr '&' '=' sexpr",
      "sexpr : sexpr '^' '=' sexpr",
      "sexpr : sexpr '|' '=' sexpr",
      "sexpr : sexpr POW sexpr",
      "sexpr : sexpr MULOP sexpr",
      "sexpr : sexpr ADDOP sexpr",
      "sexpr : sexpr LS sexpr",
      "sexpr : sexpr RS sexpr",
      "sexpr : sexpr RELOP sexpr",
      "sexpr : sexpr EQOP sexpr",
      "sexpr : sexpr '&' sexpr",
      "sexpr : sexpr '^' sexpr",
      "sexpr : sexpr '|' sexpr",
      "sexpr : sexpr DOTDOT sexpr",
      "sexpr : sexpr ANDAND sexpr",
      "sexpr : sexpr OROR sexpr",
      "sexpr : sexpr '?' sexpr ':' sexpr",
      "sexpr : sexpr MATCH sexpr",
      "sexpr : sexpr NMATCH sexpr",
      "sexpr : term",
      "term : '-' term",
      "term : '+' term",
      "term : '!' term",
      "term : '~' term",
      "term : term INC",
      "term : term DEC",
      "term : INC term",
      "term : DEC term",
      "term : FILETEST WORD",
      "term : FILETEST sexpr",
      "term : FILETEST",
      "term : LOCAL '(' expr ')'",
      "term : '(' expr ',' ')'",
      "term : '(' expr ')'",
      "term : '(' ')'",
      "term : DO sexpr",
      "term : DO block",
      "term : REG",
      "term : STAR",
      "term : REG '[' expr ']'",
      "term : HSH",
      "term : ARY",
      "term : REG '{' expr '}'",
      "term : '(' expr ')' '[' expr ']'",
      "term : '(' ')' '[' expr ']'",
      "term : ARY '[' expr ']'",
      "term : ARY '{' expr '}'",
      "term : DELETE REG '{' expr '}'",
      "term : ARYLEN",
      "term : RSTRING",
      "term : PATTERN",
      "term : SUBST",
      "term : TRANS",
      "term : DO WORD '(' expr ')'",
      "term : AMPER WORD '(' expr ')'",
      "term : DO WORD '(' ')'",
      "term : AMPER WORD '(' ')'",
      "term : AMPER WORD",
      "term : DO REG '(' expr ')'",
      "term : AMPER REG '(' expr ')'",
      "term : DO REG '(' ')'",
      "term : AMPER REG '(' ')'",
      "term : AMPER REG",
      "term : LOOPEX",
      "term : LOOPEX WORD",
      "term : UNIOP",
      "term : UNIOP sexpr",
      "term : SSELECT",
      "term : SSELECT '(' handle ')'",
      "term : SSELECT '(' sexpr csexpr csexpr csexpr ')'",
      "term : OPEN WORD",
      "term : OPEN '(' WORD ')'",
      "term : OPEN '(' handle cexpr ')'",
      "term : FILOP '(' handle ')'",
      "term : FILOP WORD",
      "term : FILOP REG",
      "term : FILOP '(' ')'",
      "term : FILOP",
      "term : FILOP2 '(' handle cexpr ')'",
      "term : FILOP3 '(' handle csexpr cexpr ')'",
      "term : FILOP22 '(' handle ',' handle ')'",
      "term : FILOP4 '(' handle csexpr csexpr cexpr ')'",
      "term : FILOP25 '(' handle ',' handle csexpr csexpr cexpr ')'",
      "term : PUSH '(' aryword cexpr ')'",
      "term : POP aryword",
      "term : POP '(' aryword ')'",
      "term : SHIFT aryword",
      "term : SHIFT '(' aryword ')'",
      "term : SHIFT",
      "term : SPLIT",
      "term : SPLIT '(' sexpr csexpr csexpr ')'",
      "term : SPLIT '(' sexpr csexpr ')'",
      "term : SPLIT '(' sexpr ')'",
      "term : FLIST2 '(' sexpr cexpr ')'",
      "term : FLIST '(' expr ')'",
      "term : LVALFUN sexpr",
      "term : LVALFUN",
      "term : FUNC0",
      "term : FUNC0 '(' ')'",
      "term : FUNC1 '(' ')'",
      "term : FUNC1 '(' expr ')'",
      "term : FUNC2 '(' sexpr cexpr ')'",
      "term : FUNC2x '(' sexpr csexpr ')'",
      "term : FUNC2x '(' sexpr csexpr cexpr ')'",
      "term : FUNC3 '(' sexpr csexpr cexpr ')'",
      "term : FUNC4 '(' sexpr csexpr csexpr cexpr ')'",
      "term : FUNC5 '(' sexpr csexpr csexpr csexpr cexpr ')'",
      "term : HSHFUN '(' hshword ')'",
      "term : HSHFUN hshword",
      "term : HSHFUN3 '(' hshword csexpr cexpr ')'",
      "term : bareword",
      "term : listop",
      "listop : LISTOP",
      "listop : LISTOP expr",
      "listop : LISTOP WORD",
      "listop : LISTOP WORD expr",
      "listop : LISTOP REG expr",
      "handle : WORD",
      "handle : sexpr",
      "aryword : WORD",
      "aryword : ARY",
      "hshword : WORD",
      "hshword : HSH",
      "bareword : WORD",
};
#endif /* YYDEBUG */
#line 1 "/usr/lib/yaccpar"
/*    @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10   */

/*
** Skeleton parser driver for yacc output
*/

/*
** yacc user known macros and defines
*/
#define YYERROR         goto yyerrlab
#ifdef IGNOREFREE
#define YYACCEPT  { return(0); }
#define YYABORT         { return(1); }
#else
#define YYACCEPT  { Safefree(yys); free(yyv); return(0); }
#define YYABORT         { Safefree(yys); free(yyv); return(1); }
#endif
#define YYBACKUP( newtoken, newvalue )\
{\
      if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
      {\
            yyerror( "syntax error - cannot backup" );\
            goto yyerrlab;\
      }\
      yychar = newtoken;\
      yystate = *yyps;\
      yylval = newvalue;\
      goto yynewstate;\
}
#define YYRECOVERING()  (!!yyerrflag)
#ifndef YYDEBUG
#     define YYDEBUG    1     /* make debugging available */
#endif

/*
** user known globals
*/
int yydebug;                  /* set to 1 to get debugging */

/*
** driver internal defines
*/
#define YYFLAG          (-1000)

/*
** static variables used by the parser
*/
static YYSTYPE *yyv;                /* value stack */
static int *yys;              /* state stack */

static YYSTYPE *yypv;               /* top of value stack */
static int *yyps;             /* top of state stack */

static int yystate;                 /* current state */
static int yytmp;             /* extra var (lasts between blocks) */

int yynerrs;                  /* number of errors */

int yyerrflag;                /* error recovery flag */
int yychar;             /* current input token number */


/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
int
yyparse()
{
      register YYSTYPE *yypvt;      /* top of value stack for $vars */
      unsigned yymaxdepth = YYMAXDEPTH;

      /*
      ** Initialize externals - yyparse may be called more than once
      */
#ifdef BWGC 
      yyv = (YYSTYPE*)gc_malloc(yymaxdepth*sizeof(YYSTYPE));
      yys = (int*)gc_malloc(yymaxdepth*sizeof(int));
#else
      yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
      yys = (int*)malloc(yymaxdepth*sizeof(int));
#endif
      if (!yyv || !yys)
      {
            yyerror( "out of memory" );
            return(1);
      }
      yypv = &yyv[-1];
      yyps = &yys[-1];
      yystate = 0;
      yytmp = 0;
      yynerrs = 0;
      yyerrflag = 0;
      yychar = -1;

      goto yystack;
      {
            register YYSTYPE *yy_pv;      /* top of value stack */
            register int *yy_ps;          /* top of state stack */
            register int yy_state;        /* current state */
            register int  yy_n;           /* internal state number info */

            /*
            ** get globals into registers.
            ** branch to here only if YYBACKUP was called.
            */
      yynewstate:
            yy_pv = yypv;
            yy_ps = yyps;
            yy_state = yystate;
            goto yy_newstate;

            /*
            ** get globals into registers.
            ** either we just started, or we just finished a reduction
            */
      yystack:
            yy_pv = yypv;
            yy_ps = yyps;
            yy_state = yystate;

            /*
            ** top of for (;;) loop while no reductions done
            */
      yy_stack:
            /*
            ** put a state and value onto the stacks
            */
#if YYDEBUG
            /*
            ** if debugging, look up token value in list of value vs.
            ** name pairs.  0 and negative (-1) are special values.
            ** Note: linear search is used since time is not a real
            ** consideration while debugging.
            */
            if ( yydebug )
            {
                  register int yy_i;

                  (void)printf( "State %d, token ", yy_state );
                  if ( yychar == 0 )
                        (void)printf( "end-of-file\n" );
                  else if ( yychar < 0 )
                        (void)printf( "-none-\n" );
                  else
                  {
                        for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
                              yy_i++ )
                        {
                              if ( yytoks[yy_i].t_val == yychar )
                                    break;
                        }
                        (void)printf( "%s\n", yytoks[yy_i].t_name );
                  }
            }
#endif /* YYDEBUG */
            if ( ++yy_ps >= &yys[ yymaxdepth ] )      /* room on stack? */
            {
                  /*
                  ** reallocate and recover.  Note that pointers
                  ** have to be reset, or bad things will happen
                  */
                  int yyps_index = (yy_ps - yys);
                  int yypv_index = (yy_pv - yyv);
                  int yypvt_index = (yypvt - yyv);
                  yymaxdepth += YYMAXDEPTH;
#ifdef BWGC
                  yyv = (YYSTYPE*)gc_realloc((char*)yyv,
                        yymaxdepth * sizeof(YYSTYPE));
                  yys = (int*)gc_realloc((char*)yys,
                        yymaxdepth * sizeof(int));
#else
                  yyv = (YYSTYPE*)realloc((char*)yyv,
                        yymaxdepth * sizeof(YYSTYPE));
                  yys = (int*)realloc((char*)yys,
                        yymaxdepth * sizeof(int));
#endif
                  if (!yyv || !yys)
                  {
                        yyerror( "yacc stack overflow" );
                        return(1);
                  }
                  yy_ps = yys + yyps_index;
                  yy_pv = yyv + yypv_index;
                  yypvt = yyv + yypvt_index;
            }
            *yy_ps = yy_state;
            *++yy_pv = yyval;

            /*
            ** we have a new state - find out what to do
            */
      yy_newstate:
            if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
                  goto yydefault;         /* simple state */
#if YYDEBUG
            /*
            ** if debugging, need to mark whether new token grabbed
            */
            yytmp = yychar < 0;
#endif
            if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
                  yychar = 0;       /* reached EOF */
#if YYDEBUG
            if ( yydebug && yytmp )
            {
                  register int yy_i;

                  (void)printf( "Received token " );
                  if ( yychar == 0 )
                        (void)printf( "end-of-file\n" );
                  else if ( yychar < 0 )
                        (void)printf( "-none-\n" );
                  else
                  {
                        for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
                              yy_i++ )
                        {
                              if ( yytoks[yy_i].t_val == yychar )
                                    break;
                        }
                        (void)printf( "%s\n", yytoks[yy_i].t_name );
                  }
            }
#endif /* YYDEBUG */
            if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
                  goto yydefault;
            if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )  /*valid shift*/
            {
                  yychar = -1;
                  yyval = yylval;
                  yy_state = yy_n;
                  if ( yyerrflag > 0 )
                        yyerrflag--;
                  goto yy_stack;
            }

      yydefault:
            if ( ( yy_n = yydef[ yy_state ] ) == -2 )
            {
#if YYDEBUG
                  yytmp = yychar < 0;
#endif
                  if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
                        yychar = 0;       /* reached EOF */
#if YYDEBUG
                  if ( yydebug && yytmp )
                  {
                        register int yy_i;

                        (void)printf( "Received token " );
                        if ( yychar == 0 )
                              (void)printf( "end-of-file\n" );
                        else if ( yychar < 0 )
                              (void)printf( "-none-\n" );
                        else
                        {
                              for ( yy_i = 0;
                                    yytoks[yy_i].t_val >= 0;
                                    yy_i++ )
                              {
                                    if ( yytoks[yy_i].t_val
                                          == yychar )
                                    {
                                          break;
                                    }
                              }
                              (void)printf( "%s\n", yytoks[yy_i].t_name );
                        }
                  }
#endif /* YYDEBUG */
                  /*
                  ** look through exception table
                  */
                  {
                        register int *yyxi = yyexca;

                        while ( ( *yyxi != -1 ) ||
                              ( yyxi[1] != yy_state ) )
                        {
                              yyxi += 2;
                        }
                        while ( ( *(yyxi += 2) >= 0 ) &&
                              ( *yyxi != yychar ) )
                              ;
                        if ( ( yy_n = yyxi[1] ) < 0 )
                              YYACCEPT;
                  }
            }

            /*
            ** check for syntax error
            */
            if ( yy_n == 0 )  /* have an error */
            {
                  /* no worry about speed here! */
                  switch ( yyerrflag )
                  {
                  case 0:           /* new error */
                        yyerror( "syntax error" );
                        goto skip_init;
                  yyerrlab:
                        /*
                        ** get globals into registers.
                        ** we have a user generated syntax type error
                        */
                        yy_pv = yypv;
                        yy_ps = yyps;
                        yy_state = yystate;
                        yynerrs++;
                  skip_init:
                  case 1:
                  case 2:           /* incompletely recovered error */
                              /* try again... */
                        yyerrflag = 3;
                        /*
                        ** find state where "error" is a legal
                        ** shift action
                        */
                        while ( yy_ps >= yys )
                        {
                              yy_n = yypact[ *yy_ps ] + YYERRCODE;
                              if ( yy_n >= 0 && yy_n < YYLAST &&
                                    yychk[yyact[yy_n]] == YYERRCODE)                            {
                                    /*
                                    ** simulate shift of "error"
                                    */
                                    yy_state = yyact[ yy_n ];
                                    goto yy_stack;
                              }
                              /*
                              ** current state has no shift on
                              ** "error", pop stack
                              */
#if YYDEBUG
#     define _POP_ "Error recovery pops state %d, uncovers state %d\n"
                              if ( yydebug )
                                    (void)printf( _POP_, *yy_ps,
                                          yy_ps[-1] );
#     undef _POP_
#endif
                              yy_ps--;
                              yy_pv--;
                        }
                        /*
                        ** there is no state on stack with "error" as
                        ** a valid shift.  give up.
                        */
                        YYABORT;
                  case 3:           /* no shift yet; eat a token */
#if YYDEBUG
                        /*
                        ** if debugging, look up token in list of
                        ** pairs.  0 and negative shouldn't occur,
                        ** but since timing doesn't matter when
                        ** debugging, it doesn't hurt to leave the
                        ** tests here.
                        */
                        if ( yydebug )
                        {
                              register int yy_i;

                              (void)printf( "Error recovery discards " );
                              if ( yychar == 0 )
                                    (void)printf( "token end-of-file\n" );
                              else if ( yychar < 0 )
                                    (void)printf( "token -none-\n" );
                              else
                              {
                                    for ( yy_i = 0;
                                          yytoks[yy_i].t_val >= 0;
                                          yy_i++ )
                                    {
                                          if ( yytoks[yy_i].t_val
                                                == yychar )
                                          {
                                                break;
                                          }
                                    }
                                    (void)printf( "token %s\n",
                                          yytoks[yy_i].t_name );
                              }
                        }
#endif /* YYDEBUG */
                        if ( yychar == 0 )      /* reached EOF. quit */
                              YYABORT;
                        yychar = -1;
                        goto yy_newstate;
                  }
            }/* end if ( yy_n == 0 ) */
            /*
            ** reduction by production yy_n
            ** put stack tops, etc. so things right after switch
            */
#if YYDEBUG
            /*
            ** if debugging, print the string that is the user's
            ** specification of the reduction which is just about
            ** to be done.
            */
            if ( yydebug )
                  (void)printf( "Reduce by (%d) \"%s\"\n",
                        yy_n, yyreds[ yy_n ] );
#endif
            yytmp = yy_n;                 /* value to switch over */
            yypvt = yy_pv;                /* $vars top of value stack */
            /*
            ** Look in goto table for next state
            ** Sorry about using yy_state here as temporary
            ** register variable, but why not, if it works...
            ** If yyr2[ yy_n ] doesn't have the low order bit
            ** set, then there is no action to be done for
            ** this reduction.  So, no saving & unsaving of
            ** registers done.  The only difference between the
            ** code just after the if and the body of the if is
            ** the goto yy_stack in the body.  This way the test
            ** can be made before the choice of what to do is needed.
            */
            {
                  /* length of production doubled with extra bit */
                  register int yy_len = yyr2[ yy_n ];

                  if ( !( yy_len & 01 ) )
                  {
                        yy_len >>= 1;
                        yyval = ( yy_pv -= yy_len )[1];     /* $$ = $1 */
                        yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
                              *( yy_ps -= yy_len ) + 1;
                        if ( yy_state >= YYLAST ||
                              yychk[ yy_state =
                              yyact[ yy_state ] ] != -yy_n )
                        {
                              yy_state = yyact[ yypgo[ yy_n ] ];
                        }
                        goto yy_stack;
                  }
                  yy_len >>= 1;
                  yyval = ( yy_pv -= yy_len )[1];     /* $$ = $1 */
                  yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
                        *( yy_ps -= yy_len ) + 1;
                  if ( yy_state >= YYLAST ||
                        yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
                  {
                        yy_state = yyact[ yypgo[ yy_n ] ];
                  }
            }
                              /* save until reenter driver code */
            yystate = yy_state;
            yyps = yy_ps;
            yypv = yy_pv;
      }
      /*
      ** code supplied by user is placed in this switch
      */
      switch( yytmp )
      {
            
case 1:
# line 81 "perly.y"
{
#if defined(YYDEBUG) && defined(DEBUGGING)
                yydebug = (debug & 1);
#endif
            } break;
case 2:
# line 87 "perly.y"
{ if (in_eval)
                        eval_root = block_head(yypvt[-0].cmdval);
                      else
                        main_root = block_head(yypvt[-0].cmdval); } break;
case 3:
# line 94 "perly.y"
{ yyval.compval.comp_true = yypvt[-2].cmdval; yyval.compval.comp_alt = yypvt[-0].cmdval; } break;
case 4:
# line 96 "perly.y"
{ yyval.compval.comp_true = yypvt[-1].cmdval; yyval.compval.comp_alt = yypvt[-0].cmdval; } break;
case 5:
# line 100 "perly.y"
{ yyval.cmdval = Nullcmd; } break;
case 6:
# line 102 "perly.y"
{ yyval.cmdval = yypvt[-0].cmdval; } break;
case 7:
# line 104 "perly.y"
{ cmdline = yypvt[-4].ival;
                      yyval.cmdval = make_ccmd(C_ELSIF,yypvt[-2].arg,yypvt[-0].compval); } break;
case 8:
# line 109 "perly.y"
{ yyval.cmdval = block_head(yypvt[-1].cmdval);
                    if (savestack->ary_fill > yypvt[-2].ival)
                      restorelist(yypvt[-2].ival); } break;
case 9:
# line 115 "perly.y"
{ yyval.ival = savestack->ary_fill; } break;
case 10:
# line 119 "perly.y"
{ yyval.cmdval = Nullcmd; } break;
case 11:
# line 121 "perly.y"
{ yyval.cmdval = append_line(yypvt[-1].cmdval,yypvt[-0].cmdval); } break;
case 12:
# line 125 "perly.y"
{ yyval.cmdval = Nullcmd; } break;
case 13:
# line 127 "perly.y"
{ yyval.cmdval = add_label(yypvt[-1].cval,yypvt[-0].cmdval); } break;
case 15:
# line 130 "perly.y"
{ if (yypvt[-1].cval != Nullch) {
                        yyval.cmdval = add_label(yypvt[-1].cval, make_acmd(C_EXPR, Nullstab,
                          Nullarg, Nullarg) );
                      }
                      else {
                        yyval.cmdval = Nullcmd;
                        cmdline = NOLINE;
                      } } break;
case 16:
# line 139 "perly.y"
{ yyval.cmdval = add_label(yypvt[-2].cval,yypvt[-1].cmdval); } break;
case 17:
# line 143 "perly.y"
{ yyval.cmdval = Nullcmd; } break;
case 18:
# line 145 "perly.y"
{ yyval.cmdval = make_acmd(C_EXPR, Nullstab, yypvt[-0].arg, Nullarg); } break;
case 19:
# line 147 "perly.y"
{ yyval.cmdval = addcond(
                         make_acmd(C_EXPR, Nullstab, Nullarg, yypvt[-2].arg), yypvt[-0].arg); } break;
case 20:
# line 150 "perly.y"
{ yyval.cmdval = addcond(invert(
                         make_acmd(C_EXPR, Nullstab, Nullarg, yypvt[-2].arg)), yypvt[-0].arg); } break;
case 21:
# line 153 "perly.y"
{ yyval.cmdval = addloop(
                         make_acmd(C_EXPR, Nullstab, Nullarg, yypvt[-2].arg), yypvt[-0].arg); } break;
case 22:
# line 156 "perly.y"
{ yyval.cmdval = addloop(invert(
                         make_acmd(C_EXPR, Nullstab, Nullarg, yypvt[-2].arg)), yypvt[-0].arg); } break;
case 23:
# line 161 "perly.y"
{ cmdline = yypvt[-4].ival;
                      yyval.cmdval = make_icmd(C_IF,yypvt[-2].arg,yypvt[-0].compval); } break;
case 24:
# line 164 "perly.y"
{ cmdline = yypvt[-4].ival;
                      yyval.cmdval = invert(make_icmd(C_IF,yypvt[-2].arg,yypvt[-0].compval)); } break;
case 25:
# line 167 "perly.y"
{ cmdline = yypvt[-2].ival;
                      yyval.cmdval = make_ccmd(C_IF,cmd_to_arg(yypvt[-1].cmdval),yypvt[-0].compval); } break;
case 26:
# line 170 "perly.y"
{ cmdline = yypvt[-2].ival;
                      yyval.cmdval = invert(make_ccmd(C_IF,cmd_to_arg(yypvt[-1].cmdval),yypvt[-0].compval)); } break;
case 27:
# line 175 "perly.y"
{ cmdline = yypvt[-4].ival;
                      yyval.cmdval = wopt(add_label(yypvt[-5].cval,
                      make_ccmd(C_WHILE,yypvt[-2].arg,yypvt[-0].compval) )); } break;
case 28:
# line 179 "perly.y"
{ cmdline = yypvt[-4].ival;
                      yyval.cmdval = wopt(add_label(yypvt[-5].cval,
                      invert(make_ccmd(C_WHILE,yypvt[-2].arg,yypvt[-0].compval)) )); } break;
case 29:
# line 183 "perly.y"
{ cmdline = yypvt[-2].ival;
                      yyval.cmdval = wopt(add_label(yypvt[-3].cval,
                      make_ccmd(C_WHILE, cmd_to_arg(yypvt[-1].cmdval),yypvt[-0].compval) )); } break;
case 30:
# line 187 "perly.y"
{ cmdline = yypvt[-2].ival;
                      yyval.cmdval = wopt(add_label(yypvt[-3].cval,
                      invert(make_ccmd(C_WHILE, cmd_to_arg(yypvt[-1].cmdval),yypvt[-0].compval)) )); } break;
case 31:
# line 191 "perly.y"
{ cmdline = yypvt[-5].ival;
                      /*
                       * The following gobbledygook catches EXPRs that
                       * aren't explicit array refs and translates
                       *            foreach VAR (EXPR) {
                       * into
                       *            @ary = EXPR;
                       *            foreach VAR (@ary) {
                       * where @ary is a hidden array made by genstab().
                       * (Note that @ary may become a local array if
                       * it is determined that it might be called
                       * recursively.  See cmd_tosave().)
                       */
                      if (yypvt[-2].arg->arg_type != O_ARRAY) {
                        scrstab = aadd(genstab());
                        yyval.cmdval = append_line(
                            make_acmd(C_EXPR, Nullstab,
                              l(make_op(O_ASSIGN,2,
                              listish(make_op(O_ARRAY, 1,
                                stab2arg(A_STAB,scrstab),
                                Nullarg,Nullarg )),
                              listish(make_list(yypvt[-2].arg)),
                              Nullarg)),
                              Nullarg),
                            wopt(over(yypvt[-4].stabval,add_label(yypvt[-6].cval,
                              make_ccmd(C_WHILE,
                              make_op(O_ARRAY, 1,
                                stab2arg(A_STAB,scrstab),
                                Nullarg,Nullarg ),
                              yypvt[-0].compval)))));
                        yyval.cmdval->c_line = yypvt[-5].ival;
                        yyval.cmdval->c_head->c_line = yypvt[-5].ival;
                      }
                      else {
                        yyval.cmdval = wopt(over(yypvt[-4].stabval,add_label(yypvt[-6].cval,
                        make_ccmd(C_WHILE,yypvt[-2].arg,yypvt[-0].compval) )));
                      }
                  } break;
case 32:
# line 230 "perly.y"
{ cmdline = yypvt[-4].ival;
                      if (yypvt[-2].arg->arg_type != O_ARRAY) {
                        scrstab = aadd(genstab());
                        yyval.cmdval = append_line(
                            make_acmd(C_EXPR, Nullstab,
                              l(make_op(O_ASSIGN,2,
                              listish(make_op(O_ARRAY, 1,
                                stab2arg(A_STAB,scrstab),
                                Nullarg,Nullarg )),
                              listish(make_list(yypvt[-2].arg)),
                              Nullarg)),
                              Nullarg),
                            wopt(over(defstab,add_label(yypvt[-5].cval,
                              make_ccmd(C_WHILE,
                              make_op(O_ARRAY, 1,
                                stab2arg(A_STAB,scrstab),
                                Nullarg,Nullarg ),
                              yypvt[-0].compval)))));
                        yyval.cmdval->c_line = yypvt[-4].ival;
                        yyval.cmdval->c_head->c_line = yypvt[-4].ival;
                      }
                      else {  /* lisp, anyone? */
                        yyval.cmdval = wopt(over(defstab,add_label(yypvt[-5].cval,
                        make_ccmd(C_WHILE,yypvt[-2].arg,yypvt[-0].compval) )));
                      }
                  } break;
case 33:
# line 258 "perly.y"
{   yyval.compval.comp_true = yypvt[-0].cmdval;
                      yyval.compval.comp_alt = yypvt[-2].cmdval;
                      cmdline = yypvt[-8].ival;
                      yyval.cmdval = append_line(yypvt[-6].cmdval,wopt(add_label(yypvt[-9].cval,
                        make_ccmd(C_WHILE,yypvt[-4].arg,yyval.compval) ))); } break;
case 34:
# line 264 "perly.y"
{ yyval.cmdval = add_label(yypvt[-1].cval,make_ccmd(C_BLOCK,Nullarg,yypvt[-0].compval)); } break;
case 35:
# line 268 "perly.y"
{ yyval.cmdval = Nullcmd; } break;
case 37:
# line 273 "perly.y"
{ (void)scanstr("1"); yyval.arg = yylval.arg; } break;
case 39:
# line 278 "perly.y"
{ yyval.cval = Nullch; } break;
case 41:
# line 283 "perly.y"
{ yyval.ival = 0; } break;
case 42:
# line 285 "perly.y"
{ yyval.ival = 0; } break;
case 43:
# line 287 "perly.y"
{ yyval.ival = 0; } break;
case 44:
# line 291 "perly.y"
{ if (strEQ(yypvt[-2].cval,"stdout"))
                      make_form(stabent("STDOUT",TRUE),yypvt[-0].formval);
                    else if (strEQ(yypvt[-2].cval,"stderr"))
                      make_form(stabent("STDERR",TRUE),yypvt[-0].formval);
                    else
                      make_form(stabent(yypvt[-2].cval,TRUE),yypvt[-0].formval);
                    Safefree(yypvt[-2].cval); yypvt[-2].cval = Nullch; } break;
case 45:
# line 299 "perly.y"
{ make_form(stabent("STDOUT",TRUE),yypvt[-0].formval); } break;
case 46:
# line 303 "perly.y"
{ make_sub(yypvt[-1].cval,yypvt[-0].cmdval); } break;
case 47:
# line 307 "perly.y"
{ char tmpbuf[256];
                    STAB *tmpstab;

                    savehptr(&curstash);
                    saveitem(curstname);
                    str_set(curstname,yypvt[-1].cval);
                    sprintf(tmpbuf,"'_%s",yypvt[-1].cval);
                    tmpstab = stabent(tmpbuf,TRUE);
                    if (!stab_xhash(tmpstab))
                        stab_xhash(tmpstab) = hnew(0);
                    curstash = stab_xhash(tmpstab);
                    if (!curstash->tbl_name)
                        curstash->tbl_name = savestr(yypvt[-1].cval);
                    curstash->tbl_coeffsize = 0;
                    Safefree(yypvt[-1].cval); yypvt[-1].cval = Nullch;
                    cmdline = NOLINE;
                  } break;
case 48:
# line 327 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 49:
# line 331 "perly.y"
{ yyval.arg = make_op(O_COMMA, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 51:
# line 336 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 52:
# line 340 "perly.y"
{   yypvt[-2].arg = listish(yypvt[-2].arg);
                      if (yypvt[-2].arg->arg_type == O_ASSIGN && yypvt[-2].arg->arg_len == 1)
                        yypvt[-2].arg->arg_type = O_ITEM;   /* a local() */
                      if (yypvt[-2].arg->arg_type == O_LIST)
                        yypvt[-0].arg = listish(yypvt[-0].arg);
                      yyval.arg = l(make_op(O_ASSIGN, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg)); } break;
case 53:
# line 347 "perly.y"
{ yyval.arg = l(make_op(O_POW, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)); } break;
case 54:
# line 349 "perly.y"
{ yyval.arg = l(make_op(yypvt[-2].ival, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)); } break;
case 55:
# line 351 "perly.y"
{ yyval.arg = rcatmaybe(l(make_op(yypvt[-2].ival, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)));} break;
case 56:
# line 353 "perly.y"
{ yyval.arg = l(make_op(O_LEFT_SHIFT, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)); } break;
case 57:
# line 355 "perly.y"
{ yyval.arg = l(make_op(O_RIGHT_SHIFT, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)); } break;
case 58:
# line 357 "perly.y"
{ yyval.arg = l(make_op(O_BIT_AND, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)); } break;
case 59:
# line 359 "perly.y"
{ yyval.arg = l(make_op(O_XOR, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)); } break;
case 60:
# line 361 "perly.y"
{ yyval.arg = l(make_op(O_BIT_OR, 2, yypvt[-3].arg, yypvt[-0].arg, Nullarg)); } break;
case 61:
# line 365 "perly.y"
{ yyval.arg = make_op(O_POW, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 62:
# line 367 "perly.y"
{ if (yypvt[-1].ival == O_REPEAT)
                        yypvt[-2].arg = listish(yypvt[-2].arg);
                      yyval.arg = make_op(yypvt[-1].ival, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg);
                      if (yypvt[-1].ival == O_REPEAT) {
                        if (yyval.arg[1].arg_type != A_EXPR ||
                          yyval.arg[1].arg_ptr.arg_arg->arg_type != O_LIST)
                            yyval.arg[1].arg_flags &= ~AF_ARYOK;
                      } } break;
case 63:
# line 376 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 64:
# line 378 "perly.y"
{ yyval.arg = make_op(O_LEFT_SHIFT, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 65:
# line 380 "perly.y"
{ yyval.arg = make_op(O_RIGHT_SHIFT, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 66:
# line 382 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 67:
# line 384 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 68:
# line 386 "perly.y"
{ yyval.arg = make_op(O_BIT_AND, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 69:
# line 388 "perly.y"
{ yyval.arg = make_op(O_XOR, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 70:
# line 390 "perly.y"
{ yyval.arg = make_op(O_BIT_OR, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 71:
# line 392 "perly.y"
{ arg4 = Nullarg;
                    yyval.arg = make_op(O_F_OR_R, 4, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 72:
# line 395 "perly.y"
{ yyval.arg = make_op(O_AND, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 73:
# line 397 "perly.y"
{ yyval.arg = make_op(O_OR, 2, yypvt[-2].arg, yypvt[-0].arg, Nullarg); } break;
case 74:
# line 399 "perly.y"
{ yyval.arg = make_op(O_COND_EXPR, 3, yypvt[-4].arg, yypvt[-2].arg, yypvt[-0].arg); } break;
case 75:
# line 401 "perly.y"
{ yyval.arg = mod_match(O_MATCH, yypvt[-2].arg, yypvt[-0].arg); } break;
case 76:
# line 403 "perly.y"
{ yyval.arg = mod_match(O_NMATCH, yypvt[-2].arg, yypvt[-0].arg); } break;
case 77:
# line 405 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 78:
# line 409 "perly.y"
{ yyval.arg = make_op(O_NEGATE, 1, yypvt[-0].arg, Nullarg, Nullarg); } break;
case 79:
# line 411 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 80:
# line 413 "perly.y"
{ yyval.arg = make_op(O_NOT, 1, yypvt[-0].arg, Nullarg, Nullarg); } break;
case 81:
# line 415 "perly.y"
{ yyval.arg = make_op(O_COMPLEMENT, 1, yypvt[-0].arg, Nullarg, Nullarg);} break;
case 82:
# line 417 "perly.y"
{ yyval.arg = addflags(1, AF_POST|AF_UP,
                      l(make_op(O_ITEM,1,yypvt[-1].arg,Nullarg,Nullarg))); } break;
case 83:
# line 420 "perly.y"
{ yyval.arg = addflags(1, AF_POST,
                      l(make_op(O_ITEM,1,yypvt[-1].arg,Nullarg,Nullarg))); } break;
case 84:
# line 423 "perly.y"
{ yyval.arg = addflags(1, AF_PRE|AF_UP,
                      l(make_op(O_ITEM,1,yypvt[-0].arg,Nullarg,Nullarg))); } break;
case 85:
# line 426 "perly.y"
{ yyval.arg = addflags(1, AF_PRE,
                      l(make_op(O_ITEM,1,yypvt[-0].arg,Nullarg,Nullarg))); } break;
case 86:
# line 429 "perly.y"
{ opargs[yypvt[-1].ival] = 0; /* force it special */
                      yyval.arg = make_op(yypvt[-1].ival, 1,
                        stab2arg(A_STAB,stabent(yypvt[-0].cval,TRUE)),
                        Nullarg, Nullarg);
                  } break;
case 87:
# line 435 "perly.y"
{ opargs[yypvt[-1].ival] = 1;
                      yyval.arg = make_op(yypvt[-1].ival, 1, yypvt[-0].arg, Nullarg, Nullarg); } break;
case 88:
# line 438 "perly.y"
{ opargs[yypvt[-0].ival] = (yypvt[-0].ival != O_FTTTY);
                      yyval.arg = make_op(yypvt[-0].ival, 1,
                        stab2arg(A_STAB,
                          yypvt[-0].ival == O_FTTTY?stabent("STDIN",TRUE):defstab),
                        Nullarg, Nullarg); } break;
case 89:
# line 444 "perly.y"
{ yyval.arg = l(localize(make_op(O_ASSIGN, 1,
                        localize(listish(make_list(yypvt[-1].arg))),
                        Nullarg,Nullarg))); } break;
case 90:
# line 448 "perly.y"
{ yyval.arg = make_list(yypvt[-2].arg); } break;
case 91:
# line 450 "perly.y"
{ yyval.arg = make_list(yypvt[-1].arg); } break;
case 92:
# line 452 "perly.y"
{ yyval.arg = make_list(Nullarg); } break;
case 93:
# line 454 "perly.y"
{ yyval.arg = make_op(O_DOFILE,2,yypvt[-0].arg,Nullarg,Nullarg);
                    allstabs = TRUE;} break;
case 94:
# line 457 "perly.y"
{ yyval.arg = cmd_to_arg(yypvt[-0].cmdval); } break;
case 95:
# line 459 "perly.y"
{ yyval.arg = stab2arg(A_STAB,yypvt[-0].stabval); } break;
case 96:
# line 461 "perly.y"
{ yyval.arg = stab2arg(A_STAR,yypvt[-0].stabval); } break;
case 97:
# line 463 "perly.y"
{ yyval.arg = make_op(O_AELEM, 2,
                        stab2arg(A_STAB,aadd(yypvt[-3].stabval)), yypvt[-1].arg, Nullarg); } break;
case 98:
# line 466 "perly.y"
{ yyval.arg = make_op(O_HASH, 1,
                        stab2arg(A_STAB,yypvt[-0].stabval),
                        Nullarg, Nullarg); } break;
case 99:
# line 470 "perly.y"
{ yyval.arg = make_op(O_ARRAY, 1,
                        stab2arg(A_STAB,yypvt[-0].stabval),
                        Nullarg, Nullarg); } break;
case 100:
# line 474 "perly.y"
{ yyval.arg = make_op(O_HELEM, 2,
                        stab2arg(A_STAB,hadd(yypvt[-3].stabval)),
                        jmaybe(yypvt[-1].arg),
                        Nullarg); } break;
case 101:
# line 479 "perly.y"
{ yyval.arg = make_op(O_LSLICE, 3,
                        Nullarg,
                        listish(make_list(yypvt[-1].arg)),
                        listish(make_list(yypvt[-4].arg))); } break;
case 102:
# line 484 "perly.y"
{ yyval.arg = make_op(O_LSLICE, 3,
                        Nullarg,
                        listish(make_list(yypvt[-1].arg)),
                        Nullarg); } break;
case 103:
# line 489 "perly.y"
{ yyval.arg = make_op(O_ASLICE, 2,
                        stab2arg(A_STAB,aadd(yypvt[-3].stabval)),
                        listish(make_list(yypvt[-1].arg)),
                        Nullarg); } break;
case 104:
# line 494 "perly.y"
{ yyval.arg = make_op(O_HSLICE, 2,
                        stab2arg(A_STAB,hadd(yypvt[-3].stabval)),
                        listish(make_list(yypvt[-1].arg)),
                        Nullarg); } break;
case 105:
# line 499 "perly.y"
{ yyval.arg = make_op(O_DELETE, 2,
                        stab2arg(A_STAB,hadd(yypvt[-3].stabval)),
                        jmaybe(yypvt[-1].arg),
                        Nullarg); } break;
case 106:
# line 504 "perly.y"
{ yyval.arg = stab2arg(A_ARYLEN,yypvt[-0].stabval); } break;
case 107:
# line 506 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 108:
# line 508 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 109:
# line 510 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 110:
# line 512 "perly.y"
{ yyval.arg = yypvt[-0].arg; } break;
case 111:
# line 514 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_WORD,stabent(yypvt[-3].cval,TRUE)),
                        make_list(yypvt[-1].arg),
                        Nullarg); Safefree(yypvt[-3].cval); yypvt[-3].cval = Nullch;
                      yyval.arg->arg_flags |= AF_DEPR; } break;
case 112:
# line 520 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_WORD,stabent(yypvt[-3].cval,TRUE)),
                        make_list(yypvt[-1].arg),
                        Nullarg); Safefree(yypvt[-3].cval); yypvt[-3].cval = Nullch; } break;
case 113:
# line 525 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_WORD,stabent(yypvt[-2].cval,TRUE)),
                        make_list(Nullarg),
                        Nullarg);
                      yyval.arg->arg_flags |= AF_DEPR; } break;
case 114:
# line 531 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_WORD,stabent(yypvt[-2].cval,TRUE)),
                        make_list(Nullarg),
                        Nullarg); } break;
case 115:
# line 536 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_WORD,stabent(yypvt[-0].cval,TRUE)),
                        Nullarg,
                        Nullarg); } break;
case 116:
# line 541 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_STAB,yypvt[-3].stabval),
                        make_list(yypvt[-1].arg),
                        Nullarg);
                      yyval.arg->arg_flags |= AF_DEPR; } break;
case 117:
# line 547 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_STAB,yypvt[-3].stabval),
                        make_list(yypvt[-1].arg),
                        Nullarg); } break;
case 118:
# line 552 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_STAB,yypvt[-2].stabval),
                        make_list(Nullarg),
                        Nullarg);
                      yyval.arg->arg_flags |= AF_DEPR; } break;
case 119:
# line 558 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_STAB,yypvt[-2].stabval),
                        make_list(Nullarg),
                        Nullarg); } break;
case 120:
# line 563 "perly.y"
{ yyval.arg = make_op((perldb ? O_DBSUBR : O_SUBR), 2,
                        stab2arg(A_STAB,yypvt[-0].stabval),
                        Nullarg,
                        Nullarg); } break;
case 121:
# line 568 "perly.y"
{ yyval.arg = make_op(yypvt[-0].ival,0,Nullarg,Nullarg,Nullarg); } break;
case 122:
# line 570 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival,1,cval_to_arg(yypvt[-0].cval),
                      Nullarg,Nullarg); } break;
case 123:
# line 573 "perly.y"
{ yyval.arg = make_op(yypvt[-0].ival,0,Nullarg,Nullarg,Nullarg); } break;
case 124:
# line 575 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival,1,yypvt[-0].arg,Nullarg,Nullarg); } break;
case 125:
# line 577 "perly.y"
{ yyval.arg = make_op(O_SELECT, 0, Nullarg, Nullarg, Nullarg);} break;
case 126:
# line 579 "perly.y"
{ yyval.arg = make_op(O_SELECT, 1, yypvt[-1].arg, Nullarg, Nullarg); } break;
case 127:
# line 581 "perly.y"
{ arg4 = yypvt[-1].arg;
                    yyval.arg = make_op(O_SSELECT, 4, yypvt[-4].arg, yypvt[-3].arg, yypvt[-2].arg); } break;
case 128:
# line 584 "perly.y"
{ yyval.arg = make_op(O_OPEN, 2,
                      stab2arg(A_WORD,stabent(yypvt[-0].cval,TRUE)),
                      stab2arg(A_STAB,stabent(yypvt[-0].cval,TRUE)),
                      Nullarg); } break;
case 129:
# line 589 "perly.y"
{ yyval.arg = make_op(O_OPEN, 2,
                      stab2arg(A_WORD,stabent(yypvt[-1].cval,TRUE)),
                      stab2arg(A_STAB,stabent(yypvt[-1].cval,TRUE)),
                      Nullarg); } break;
case 130:
# line 594 "perly.y"
{ yyval.arg = make_op(O_OPEN, 2,
                      yypvt[-2].arg,
                      yypvt[-1].arg, Nullarg); } break;
case 131:
# line 598 "perly.y"
{ yyval.arg = make_op(yypvt[-3].ival, 1,
                      yypvt[-1].arg,
                      Nullarg, Nullarg); } break;
case 132:
# line 602 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival, 1,
                      stab2arg(A_WORD,stabent(yypvt[-0].cval,TRUE)),
                      Nullarg, Nullarg);
                    Safefree(yypvt[-0].cval); yypvt[-0].cval = Nullch; } break;
case 133:
# line 607 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival, 1,
                      stab2arg(A_STAB,yypvt[-0].stabval),
                      Nullarg, Nullarg); } break;
case 134:
# line 611 "perly.y"
{ yyval.arg = make_op(yypvt[-2].ival, 1,
                      stab2arg(A_WORD,Nullstab),
                      Nullarg, Nullarg); } break;
case 135:
# line 615 "perly.y"
{ yyval.arg = make_op(yypvt[-0].ival, 0,
                      Nullarg, Nullarg, Nullarg); } break;
case 136:
# line 618 "perly.y"
{ yyval.arg = make_op(yypvt[-4].ival, 2, yypvt[-2].arg, yypvt[-1].arg, Nullarg); } break;
case 137:
# line 620 "perly.y"
{ yyval.arg = make_op(yypvt[-5].ival, 3, yypvt[-3].arg, yypvt[-2].arg, make_list(yypvt[-1].arg)); } break;
case 138:
# line 622 "perly.y"
{ yyval.arg = make_op(yypvt[-5].ival, 2, yypvt[-3].arg, yypvt[-1].arg, Nullarg); } break;
case 139:
# line 624 "perly.y"
{ arg4 = yypvt[-1].arg; yyval.arg = make_op(yypvt[-6].ival, 4, yypvt[-4].arg, yypvt[-3].arg, yypvt[-2].arg); } break;
case 140:
# line 626 "perly.y"
{ arg4 = yypvt[-2].arg; arg5 = yypvt[-1].arg;
                    yyval.arg = make_op(yypvt[-8].ival, 5, yypvt[-6].arg, yypvt[-4].arg, yypvt[-3].arg); } break;
case 141:
# line 629 "perly.y"
{ yyval.arg = make_op(yypvt[-4].ival, 2,
                      yypvt[-2].arg,
                      make_list(yypvt[-1].arg),
                      Nullarg); } break;
case 142:
# line 634 "perly.y"
{ yyval.arg = make_op(O_POP, 1, yypvt[-0].arg, Nullarg, Nullarg); } break;
case 143:
# line 636 "perly.y"
{ yyval.arg = make_op(O_POP, 1, yypvt[-1].arg, Nullarg, Nullarg); } break;
case 144:
# line 638 "perly.y"
{ yyval.arg = make_op(O_SHIFT, 1, yypvt[-0].arg, Nullarg, Nullarg); } break;
case 145:
# line 640 "perly.y"
{ yyval.arg = make_op(O_SHIFT, 1, yypvt[-1].arg, Nullarg, Nullarg); } break;
case 146:
# line 642 "perly.y"
{ yyval.arg = make_op(O_SHIFT, 1,
                      stab2arg(A_STAB,
                        aadd(stabent(subline ? "_" : "ARGV", TRUE))),
                      Nullarg, Nullarg); } break;
case 147:
# line 647 "perly.y"
{   static char p[]="/\\s+/";
                      char *oldend = bufend;
                      ARG *oldarg = yylval.arg;
                      
                      bufend=p+5;
                      (void)scanpat(p);
                      bufend=oldend;
                      yyval.arg = make_split(defstab,yylval.arg,Nullarg);
                      yylval.arg = oldarg; } break;
case 148:
# line 657 "perly.y"
{ yyval.arg = mod_match(O_MATCH, yypvt[-2].arg,
                    make_split(defstab,yypvt[-3].arg,yypvt[-1].arg));} break;
case 149:
# line 660 "perly.y"
{ yyval.arg = mod_match(O_MATCH, yypvt[-1].arg,
                    make_split(defstab,yypvt[-2].arg,Nullarg) ); } break;
case 150:
# line 663 "perly.y"
{ yyval.arg = mod_match(O_MATCH,
                      stab2arg(A_STAB,defstab),
                      make_split(defstab,yypvt[-1].arg,Nullarg) ); } break;
case 151:
# line 667 "perly.y"
{ yyval.arg = make_op(yypvt[-4].ival, 2,
                      yypvt[-2].arg,
                      listish(make_list(yypvt[-1].arg)),
                      Nullarg); } break;
case 152:
# line 672 "perly.y"
{ yyval.arg = make_op(yypvt[-3].ival, 1,
                      make_list(yypvt[-1].arg),
                      Nullarg,
                      Nullarg); } break;
case 153:
# line 677 "perly.y"
{ yyval.arg = l(make_op(yypvt[-1].ival, 1, fixl(yypvt[-1].ival,yypvt[-0].arg),
                      Nullarg, Nullarg)); } break;
case 154:
# line 680 "perly.y"
{ yyval.arg = l(make_op(yypvt[-0].ival, 1,
                      stab2arg(A_STAB,defstab),
                      Nullarg, Nullarg)); } break;
case 155:
# line 684 "perly.y"
{ yyval.arg = make_op(yypvt[-0].ival, 0, Nullarg, Nullarg, Nullarg); } break;
case 156:
# line 686 "perly.y"
{ yyval.arg = make_op(yypvt[-2].ival, 0, Nullarg, Nullarg, Nullarg); } break;
case 157:
# line 688 "perly.y"
{ yyval.arg = make_op(yypvt[-2].ival, 0, Nullarg, Nullarg, Nullarg); } break;
case 158:
# line 690 "perly.y"
{ yyval.arg = make_op(yypvt[-3].ival, 1, yypvt[-1].arg, Nullarg, Nullarg); } break;
case 159:
# line 692 "perly.y"
{ yyval.arg = make_op(yypvt[-4].ival, 2, yypvt[-2].arg, yypvt[-1].arg, Nullarg);
                      if (yypvt[-4].ival == O_INDEX && yyval.arg[2].arg_type == A_SINGLE)
                        fbmcompile(yyval.arg[2].arg_ptr.arg_str,0); } break;
case 160:
# line 696 "perly.y"
{ yyval.arg = make_op(yypvt[-4].ival, 2, yypvt[-2].arg, yypvt[-1].arg, Nullarg);
                      if (yypvt[-4].ival == O_INDEX && yyval.arg[2].arg_type == A_SINGLE)
                        fbmcompile(yyval.arg[2].arg_ptr.arg_str,0); } break;
case 161:
# line 700 "perly.y"
{ yyval.arg = make_op(yypvt[-5].ival, 3, yypvt[-3].arg, yypvt[-2].arg, yypvt[-1].arg);
                      if (yypvt[-5].ival == O_INDEX && yyval.arg[2].arg_type == A_SINGLE)
                        fbmcompile(yyval.arg[2].arg_ptr.arg_str,0); } break;
case 162:
# line 704 "perly.y"
{ yyval.arg = make_op(yypvt[-5].ival, 3, yypvt[-3].arg, yypvt[-2].arg, yypvt[-1].arg); } break;
case 163:
# line 706 "perly.y"
{ arg4 = yypvt[-1].arg;
                    yyval.arg = make_op(yypvt[-6].ival, 4, yypvt[-4].arg, yypvt[-3].arg, yypvt[-2].arg); } break;
case 164:
# line 709 "perly.y"
{ arg4 = yypvt[-2].arg; arg5 = yypvt[-1].arg;
                    yyval.arg = make_op(yypvt[-7].ival, 5, yypvt[-5].arg, yypvt[-4].arg, yypvt[-3].arg); } break;
case 165:
# line 712 "perly.y"
{ yyval.arg = make_op(yypvt[-3].ival, 1,
                        yypvt[-1].arg,
                        Nullarg,
                        Nullarg); } break;
case 166:
# line 717 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival, 1,
                        yypvt[-0].arg,
                        Nullarg,
                        Nullarg); } break;
case 167:
# line 722 "perly.y"
{ yyval.arg = make_op(yypvt[-5].ival, 3, yypvt[-3].arg, yypvt[-2].arg, yypvt[-1].arg); } break;
case 170:
# line 728 "perly.y"
{ yyval.arg = make_op(yypvt[-0].ival,2,
                        stab2arg(A_WORD,Nullstab),
                        stab2arg(A_STAB,defstab),
                        Nullarg); } break;
case 171:
# line 733 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival,2,
                        stab2arg(A_WORD,Nullstab),
                        maybelistish(yypvt[-1].ival,make_list(yypvt[-0].arg)),
                        Nullarg); } break;
case 172:
# line 738 "perly.y"
{ yyval.arg = make_op(yypvt[-1].ival,2,
                        stab2arg(A_WORD,stabent(yypvt[-0].cval,TRUE)),
                        stab2arg(A_STAB,defstab),
                        Nullarg); } break;
case 173:
# line 743 "perly.y"
{ yyval.arg = make_op(yypvt[-2].ival,2,
                        stab2arg(A_WORD,stabent(yypvt[-1].cval,TRUE)),
                        maybelistish(yypvt[-2].ival,make_list(yypvt[-0].arg)),
                        Nullarg); Safefree(yypvt[-1].cval); yypvt[-1].cval = Nullch; } break;
case 174:
# line 748 "perly.y"
{ yyval.arg = make_op(yypvt[-2].ival,2,
                        stab2arg(A_STAB,yypvt[-1].stabval),
                        maybelistish(yypvt[-2].ival,make_list(yypvt[-0].arg)),
                        Nullarg); } break;
case 175:
# line 755 "perly.y"
{ yyval.arg = stab2arg(A_WORD,stabent(yypvt[-0].cval,TRUE));
                    Safefree(yypvt[-0].cval); yypvt[-0].cval = Nullch;} break;
case 177:
# line 761 "perly.y"
{ yyval.arg = stab2arg(A_WORD,aadd(stabent(yypvt[-0].cval,TRUE)));
                      Safefree(yypvt[-0].cval); yypvt[-0].cval = Nullch; } break;
case 178:
# line 764 "perly.y"
{ yyval.arg = stab2arg(A_STAB,yypvt[-0].stabval); } break;
case 179:
# line 768 "perly.y"
{ yyval.arg = stab2arg(A_WORD,hadd(stabent(yypvt[-0].cval,TRUE)));
                      Safefree(yypvt[-0].cval); yypvt[-0].cval = Nullch; } break;
case 180:
# line 771 "perly.y"
{ yyval.arg = stab2arg(A_STAB,yypvt[-0].stabval); } break;
case 181:
# line 780 "perly.y"
{ char *s;
                      yyval.arg = op_new(1);
                      yyval.arg->arg_type = O_ITEM;
                      yyval.arg[1].arg_type = A_SINGLE;
                      yyval.arg[1].arg_ptr.arg_str = str_make(yypvt[-0].cval,0);
                      for (s = yypvt[-0].cval; *s && islower(*s); s++) ;
                      if (dowarn && !*s)
                        warn(
                          "\"%s\" may clash with future reserved word",
                          yypvt[-0].cval );
                  } break;
      }
      goto yystack;           /* reset registers in driver code */
}

Generated by  Doxygen 1.6.0   Back to index