perl 5.0 alpha 2
[perl.git] / perly.c
1 extern char *malloc(), *realloc();
2
3 # line 39 "perly.y"
4 #include "EXTERN.h"
5 #include "perl.h"
6
7 /*SUPPRESS 530*/
8 /*SUPPRESS 593*/
9 /*SUPPRESS 595*/
10
11
12 # line 50 "perly.y"
13 typedef union  {
14     I32 ival;
15     char *pval;
16     OP *opval;
17     GV *gvval;
18 } YYSTYPE;
19 # define WORD 257
20 # define METHOD 258
21 # define THING 259
22 # define PMFUNC 260
23 # define LABEL 261
24 # define FORMAT 262
25 # define SUB 263
26 # define PACKAGE 264
27 # define WHILE 265
28 # define UNTIL 266
29 # define IF 267
30 # define UNLESS 268
31 # define ELSE 269
32 # define ELSIF 270
33 # define CONTINUE 271
34 # define FOR 272
35 # define LOOPEX 273
36 # define DOTDOT 274
37 # define FUNC0 275
38 # define FUNC1 276
39 # define FUNC 277
40 # define RELOP 278
41 # define EQOP 279
42 # define MULOP 280
43 # define ADDOP 281
44 # define DOLSHARP 282
45 # define DO 283
46 # define LOCAL 284
47 # define DELETE 285
48 # define HASHBRACK 286
49 # define LSTOP 287
50 # define OROR 288
51 # define ANDAND 289
52 # define BITOROP 290
53 # define BITANDOP 291
54 # define UNIOP 292
55 # define SHIFTOP 293
56 # define MATCHOP 294
57 # define ARROW 295
58 # define UMINUS 296
59 # define REFGEN 297
60 # define POWOP 298
61 # define PREINC 299
62 # define PREDEC 300
63 # define POSTINC 301
64 # define POSTDEC 302
65 #define yyclearin yychar = -1
66 #define yyerrok yyerrflag = 0
67 extern int yychar;
68 extern int yyerrflag;
69 #ifndef YYMAXDEPTH
70 #define YYMAXDEPTH 150
71 #endif
72 YYSTYPE yylval, yyval;
73 # define YYERRCODE 256
74
75 # line 569 "perly.y"
76  /* PROGRAM */
77 int yyexca[] ={
78 -1, 1,
79         0, -1,
80         -2, 0,
81 -1, 3,
82         0, 2,
83         -2, 39,
84 -1, 21,
85         295, 145,
86         -2, 25,
87 -1, 40,
88         41, 97,
89         265, 97,
90         266, 97,
91         267, 97,
92         268, 97,
93         274, 97,
94         278, 97,
95         279, 97,
96         280, 97,
97         281, 97,
98         44, 97,
99         61, 97,
100         63, 97,
101         58, 97,
102         288, 97,
103         289, 97,
104         290, 97,
105         291, 97,
106         293, 97,
107         294, 97,
108         295, 97,
109         298, 97,
110         301, 97,
111         302, 97,
112         59, 97,
113         93, 97,
114         -2, 144,
115 -1, 54,
116         41, 133,
117         265, 133,
118         266, 133,
119         267, 133,
120         268, 133,
121         274, 133,
122         278, 133,
123         279, 133,
124         280, 133,
125         281, 133,
126         44, 133,
127         61, 133,
128         63, 133,
129         58, 133,
130         288, 133,
131         289, 133,
132         290, 133,
133         291, 133,
134         293, 133,
135         294, 133,
136         295, 133,
137         298, 133,
138         301, 133,
139         302, 133,
140         59, 133,
141         93, 133,
142         -2, 143,
143 -1, 76,
144         59, 35,
145         -2, 0,
146 -1, 112,
147         301, 0,
148         302, 0,
149         -2, 88,
150 -1, 113,
151         301, 0,
152         302, 0,
153         -2, 89,
154 -1, 192,
155         278, 0,
156         -2, 71,
157 -1, 193,
158         279, 0,
159         -2, 72,
160 -1, 194,
161         274, 0,
162         -2, 75,
163 -1, 310,
164         41, 35,
165         -2, 0,
166         };
167 # define YYNPROD 152
168 # define YYLAST 2258
169 int yyact[]={
170
171    107,   162,   104,   105,    90,   102,   229,   103,   148,    90,
172     21,   239,    67,   104,   105,   150,   228,    91,    25,    72,
173     74,   240,   241,    80,    82,    78,    91,    92,    56,    31,
174     26,   102,    56,    58,    61,    90,    37,   132,    57,    30,
175    102,    29,    69,    68,    90,   244,   115,   117,   119,   129,
176     98,   133,    91,    92,   324,    16,   155,    77,    91,    92,
177     59,    14,    11,    12,    13,    93,   102,   152,    87,   153,
178     90,    93,   102,   157,   317,   159,    90,   315,   198,   164,
179    156,   166,   158,   168,   298,   161,   297,    38,   165,   296,
180    167,   262,   169,   170,   171,   172,   202,   210,    26,   200,
181    268,   215,   123,   220,    31,    81,    87,    56,    58,    61,
182    199,    37,   121,    57,    30,    26,    29,    87,   258,    26,
183     79,   203,    32,    73,     3,   310,    98,    99,    91,    92,
184    211,   212,   213,   214,   124,    59,   218,    98,    99,    91,
185     92,    93,   102,    71,   122,   223,    90,    97,    96,    95,
186     94,   237,    93,   102,   121,   316,   154,    90,    87,    70,
187     87,    87,    38,    87,    66,    87,   295,    31,    87,   235,
188     56,    58,    61,   318,    37,   299,    57,    30,   293,    29,
189    243,    14,    11,    12,    13,   327,   122,   325,    26,    98,
190     99,    91,    92,    87,    26,   204,    87,    32,    59,   320,
191     96,    95,    94,    26,    93,   102,    26,   255,   256,    90,
192    292,   266,   259,   174,   265,   232,    87,   234,   314,   304,
193     98,    99,    91,    92,   267,    38,    26,   323,   271,   273,
194     87,   264,   281,    94,   282,    93,   102,   284,   278,   286,
195     90,   287,   263,   289,   206,   197,   156,    56,   202,   139,
196    207,   200,    24,    54,    65,    46,    53,    26,   231,   221,
197     32,    18,    19,    22,    23,   209,    56,   294,    20,    49,
198    126,    51,    52,    63,   288,   280,   254,   300,    60,    48,
199     36,    45,    39,    62,   308,   101,   219,   160,    50,    85,
200     86,    83,    84,    33,   285,    34,    35,   312,   311,   274,
201    242,   313,    87,    87,   238,   233,    31,    87,    87,    56,
202     58,    61,   322,    37,   272,    57,    30,   149,    29,    25,
203     85,    86,    83,    84,   326,   201,   328,    24,    54,    65,
204     46,    53,    56,   137,   136,   135,    76,    59,   329,   306,
205    307,   127,   309,     8,    49,     7,    51,    52,    63,   163,
206      2,     9,    55,    60,    48,    36,    45,    39,    62,    17,
207     47,    41,    44,    50,    38,    42,   321,    43,    33,    31,
208     34,    35,    56,    58,    61,    15,    37,   270,    57,    30,
209     10,    29,     5,   208,   205,    88,     6,     4,   147,     1,
210      0,    54,    65,    46,    53,     0,    26,     0,     0,    32,
211     59,     0,     0,     0,     0,     0,     0,    49,     0,    51,
212     52,    63,     0,     0,     0,    28,    60,    48,    36,    45,
213     39,    62,     0,     0,     0,     0,    50,    38,     0,   150,
214      0,    33,    31,    34,    35,    56,    58,    61,     0,    37,
215      0,    57,    30,     0,    29,   106,   108,   109,   110,   111,
216    112,   113,    98,    99,    91,    92,     0,     0,   261,    26,
217      0,     0,    32,    59,    95,    94,     0,    93,   102,     0,
218      0,     0,    90,     0,     0,     0,    31,     0,     0,    56,
219     58,    61,     0,    37,     0,    57,    30,   236,    29,     0,
220     38,     0,     0,     0,     0,     0,   100,     0,     0,     0,
221     98,    99,    91,    92,     0,     0,     0,    59,     0,     0,
222     97,    96,    95,    94,     0,    93,   102,     0,     0,     0,
223     90,   275,    26,     0,   276,    32,     0,     0,     0,     0,
224     54,    65,    46,    53,    38,   225,   260,     0,   227,     0,
225    230,    89,     0,   101,   269,     0,    49,     0,    51,    52,
226     63,     0,     0,     0,     0,    60,    48,    36,    45,    39,
227     62,   283,     0,     0,     0,    50,    26,     0,     0,    32,
228     33,    31,    34,    35,    56,    58,    61,     0,    37,   257,
229     57,    30,     0,    29,     0,     0,     0,     0,     0,     0,
230      0,     0,     0,    54,    65,    46,    53,   301,     0,   302,
231      0,     0,    59,     0,     0,     0,     0,     0,     0,    49,
232      0,    51,    52,    63,     0,   277,     0,   279,    60,    48,
233     36,    45,    39,    62,   319,     0,     0,     0,    50,    38,
234      0,     0,     0,    33,     0,    34,    35,     0,     0,     0,
235      0,     0,     0,   291,    89,     0,   101,     0,     0,     0,
236      0,    64,     0,     0,     0,     0,    54,    65,    46,    53,
237      0,    26,     0,     0,    32,     0,     0,     0,     0,   305,
238      0,     0,    49,     0,    51,    52,    63,     0,     0,     0,
239      0,    60,    48,    36,    45,    39,    62,    89,     0,   101,
240      0,    50,     0,     0,     0,     0,    33,     0,    34,    35,
241     54,    65,    46,    53,     0,     0,     0,     0,   138,   141,
242    142,   143,   144,   145,   146,     0,    49,   151,    51,    52,
243     63,     0,     0,     0,     0,    60,    48,    36,    45,    39,
244     62,     0,     0,     0,     0,    50,     0,     0,     0,     0,
245     33,    31,    34,    35,    56,    58,    61,     0,    37,   222,
246     57,    30,     0,    29,   100,     0,     0,     0,    98,    99,
247     91,    92,     0,     0,     0,     0,     0,     0,    97,    96,
248     95,    94,    59,    93,   102,     0,     0,     0,    90,     0,
249      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
250      0,     0,     0,     0,     0,    54,    65,    46,    53,    38,
251      0,   226,     0,     0,     0,     0,     0,     0,     0,     0,
252      0,    49,     0,    51,    52,    63,     0,     0,     0,     0,
253     60,    48,    36,    45,    39,    62,     0,     0,     0,     0,
254     50,    26,     0,     0,    32,    33,    31,    34,    35,    56,
255     58,    61,     0,    37,   217,    57,    30,     0,    29,     0,
256      0,     0,     0,     0,     0,     0,     0,   100,     0,     0,
257      0,    98,    99,    91,    92,     0,     0,    59,     0,     0,
258      0,    97,    96,    95,    94,     0,    93,   102,     0,     0,
259     31,    90,     0,    56,    58,    61,     0,    37,     0,    57,
260     30,     0,    29,     0,    38,     0,     0,     0,     0,     0,
261    100,     0,     0,     0,    98,    99,    91,    92,   190,     0,
262      0,    59,     0,     0,    97,    96,    95,    94,     0,    93,
263    102,     0,     0,     0,    90,     0,    26,     0,     0,    32,
264     31,     0,     0,    56,    58,    61,     0,    37,    38,    57,
265     30,     0,    29,     0,     0,     0,     0,     0,     0,     0,
266      0,     0,     0,     0,     0,     0,     0,     0,   188,     0,
267      0,    59,     0,     0,     0,    54,    65,    46,    53,     0,
268     26,     0,     0,    32,     0,     0,     0,     0,     0,     0,
269      0,    49,     0,    51,    52,    63,     0,     0,    38,     0,
270     60,    48,    36,    45,    39,    62,     0,     0,     0,     0,
271     50,     0,     0,     0,     0,    33,    31,    34,    35,    56,
272     58,    61,     0,    37,     0,    57,    30,     0,    29,     0,
273     26,     0,     0,    32,     0,     0,     0,     0,     0,     0,
274      0,     0,     0,     0,   186,     0,     0,    59,     0,     0,
275      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
276      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
277     54,    65,    46,    53,    38,     0,     0,     0,     0,     0,
278      0,     0,     0,     0,     0,     0,    49,     0,    51,    52,
279     63,     0,     0,     0,     0,    60,    48,    36,    45,    39,
280     62,     0,     0,     0,     0,    50,    26,     0,     0,    32,
281     33,     0,    34,    35,    54,    65,    46,    53,     0,    31,
282      0,     0,    56,    58,    61,     0,    37,     0,    57,    30,
283     49,    29,    51,    52,    63,     0,     0,     0,     0,    60,
284     48,    36,    45,    39,    62,     0,     0,   184,     0,    50,
285     59,     0,     0,     0,    33,     0,    34,    35,     0,     0,
286      0,     0,     0,     0,    54,    65,    46,    53,     0,     0,
287      0,     0,     0,     0,     0,     0,     0,    38,     0,     0,
288     49,     0,    51,    52,    63,     0,     0,     0,     0,    60,
289     48,    36,    45,    39,    62,     0,     0,     0,     0,    50,
290      0,     0,     0,     0,    33,     0,    34,    35,     0,    26,
291      0,     0,    32,     0,     0,     0,    31,     0,     0,    56,
292     58,    61,     0,    37,     0,    57,    30,     0,    29,     0,
293      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
294     54,    65,    46,    53,   182,     0,     0,    59,     0,     0,
295      0,     0,     0,     0,     0,     0,    49,     0,    51,    52,
296     63,     0,     0,     0,    40,    60,    48,    36,    45,    39,
297     62,     0,     0,     0,    38,    50,     0,     0,     0,     0,
298     33,     0,    34,    35,    31,    75,     0,    56,    58,    61,
299      0,    37,     0,    57,    30,     0,    29,     0,     0,     0,
300      0,     0,     0,     0,     0,     0,    26,     0,     0,    32,
301    125,     0,   180,   131,     0,    59,     0,     0,     0,     0,
302      0,   140,   140,   140,   140,   140,   140,     0,     0,    31,
303    140,     0,    56,    58,    61,     0,    37,     0,    57,    30,
304      0,    29,    38,    54,    65,    46,    53,     0,     0,     0,
305      0,     0,     0,     0,     0,     0,     0,   178,     0,    49,
306     59,    51,    52,    63,     0,     0,     0,     0,    60,    48,
307     36,    45,    39,    62,    26,     0,     0,    32,    50,     0,
308      0,     0,     0,    33,     0,    34,    35,    38,     0,     0,
309      0,   216,     0,     0,     0,    31,     0,     0,    56,    58,
310     61,     0,    37,     0,    57,    30,     0,    29,     0,     0,
311      0,     0,     0,     0,     0,     0,     0,     0,     0,    26,
312      0,     0,    32,   176,     0,     0,    59,     0,     0,     0,
313      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
314     54,    65,    46,    53,     0,     0,     0,     0,     0,     0,
315      0,     0,     0,    38,     0,     0,    49,     0,    51,    52,
316     63,     0,     0,     0,     0,    60,    48,    36,    45,    39,
317     62,     0,     0,     0,     0,    50,   253,     0,     0,    89,
318     33,   101,    34,    35,     0,    26,     0,     0,    32,     0,
319      0,     0,     0,     0,    31,     0,     0,    56,    58,    61,
320      0,    37,     0,    57,    30,     0,    29,     0,    54,    65,
321     46,    53,     0,     0,     0,     0,     0,     0,     0,     0,
322    120,     0,     0,     0,    49,    59,    51,    52,    63,     0,
323      0,     0,     0,    60,    48,    36,    45,    39,    62,     0,
324      0,     0,     0,    50,     0,     0,     0,     0,    33,     0,
325     34,    35,    38,    54,    65,    46,    53,     0,     0,     0,
326      0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
327      0,    51,    52,    63,     0,     0,     0,     0,    60,    48,
328     36,    45,    39,    62,    26,     0,     0,    32,    50,     0,
329      0,     0,     0,    33,     0,    34,    35,    31,     0,     0,
330     56,    58,    61,     0,    37,     0,    57,    30,     0,    29,
331      0,     0,     0,     0,     0,     0,     0,     0,     0,    54,
332     65,    46,    53,     0,     0,     0,     0,     0,    59,     0,
333      0,     0,     0,     0,     0,    49,     0,    51,    52,    63,
334      0,     0,     0,     0,    60,    48,    36,    45,    39,    62,
335      0,     0,     0,     0,    50,    38,     0,   118,     0,    33,
336      0,    34,    35,     0,    31,     0,     0,    56,    58,    61,
337      0,    37,   116,    57,    30,     0,    29,     0,     0,     0,
338      0,     0,     0,     0,     0,     0,     0,    26,     0,     0,
339     32,     0,   100,     0,     0,    59,    98,    99,    91,    92,
340      0,     0,     0,     0,     0,     0,    97,    96,    95,    94,
341      0,    93,   102,     0,     0,     0,    90,     0,    54,    65,
342     46,    53,    38,     0,     0,     0,     0,     0,     0,     0,
343      0,     0,     0,     0,    49,     0,    51,    52,    63,     0,
344      0,     0,     0,    60,    48,    36,    45,    39,    62,     0,
345      0,     0,     0,    50,    26,     0,     0,    32,    33,     0,
346     34,    35,    31,     0,     0,    56,    58,    61,     0,    37,
347      0,    57,    30,     0,    29,     0,     0,     0,     0,     0,
348      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
349      0,     0,     0,    59,     0,     0,     0,     0,     0,     0,
350      0,     0,     0,     0,     0,     0,     0,    31,     0,     0,
351     56,    58,    61,     0,    37,     0,    57,    30,     0,    29,
352     38,    54,    65,    46,    53,     0,     0,     0,     0,     0,
353      0,     0,     0,     0,     0,     0,     0,    49,    59,    51,
354     52,    63,     0,     0,     0,     0,    60,    48,    36,    45,
355     39,    62,    26,     0,     0,    32,    50,     0,     0,     0,
356      0,    33,     0,    34,    35,    38,     0,     0,     0,     0,
357      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
358      0,     0,     0,     0,     0,     0,     0,     0,    54,    65,
359     46,    53,     0,     0,     0,     0,     0,    26,     0,     0,
360     32,     0,     0,     0,    49,     0,    51,    52,    63,     0,
361      0,     0,     0,    60,    48,    36,    45,    39,    62,     0,
362      0,     0,     0,    50,     0,     0,     0,     0,    33,     0,
363     34,    35,     0,     0,     0,     0,     0,     0,     0,     0,
364      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
365      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
366      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
367      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
368      0,     0,     0,     0,     0,     0,    54,    65,    46,    53,
369     27,     0,     0,     0,     0,     0,     0,     0,     0,     0,
370      0,     0,    49,     0,    51,    52,    63,     0,     0,     0,
371      0,    60,    48,    36,    45,    39,    62,     0,     0,     0,
372      0,    50,     0,     0,     0,     0,    33,   114,    34,    35,
373      0,   130,    65,    46,    53,     0,     0,     0,     0,   128,
374      0,   134,     0,     0,     0,     0,     0,    49,     0,    51,
375     52,    63,     0,     0,     0,     0,    60,    48,    36,    45,
376     39,    62,     0,     0,     0,     0,    50,     0,     0,     0,
377      0,    33,     0,    34,    35,     0,     0,     0,   173,     0,
378    175,   177,   179,   181,   183,   185,   187,   189,   191,   192,
379    193,   194,   195,   196,     0,     0,     0,     0,     0,     0,
380      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
381      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
382      0,     0,     0,     0,     0,     0,     0,     0,   224,     0,
383      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
384      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
385      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
386      0,     0,     0,     0,     0,     0,     0,   245,     0,   246,
387      0,   247,     0,   248,     0,   249,     0,   250,     0,   251,
388      0,   252,     0,     0,     0,     0,     0,     0,     0,     0,
389      0,   173,     0,     0,     0,   173,     0,     0,   173,     0,
390      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
391      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
392      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
393      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
394      0,     0,     0,     0,   290,     0,     0,     0,     0,     0,
395      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
396      0,     0,     0,     0,     0,     0,     0,   303 };
397 int yypact[]={
398
399  -1000, -1000, -1000,  -200, -1000, -1000, -1000, -1000, -1000,    -4,
400  -1000,   -93,  -214,  -215, -1000, -1000, -1000,   100,   103,    83,
401    296,  -246,    80,    65, -1000,    24, -1000,   626,  -288,  1719,
402   1719,  1719,  1719,  1719,  1719,  1719,  1719,  1621,  1554,  1451,
403     21, -1000, -1000,    11, -1000,   230, -1000,   301,  1764,  -220,
404   1719,   295,   294,   293, -1000, -1000,    -8,    -8,    -8,    -8,
405     -8,    -8,  1719,   277,  -280,    -8,   -25, -1000,   -25,    97,
406  -1000,  1719,   -25,  1719,   -25,   247,    71, -1000,   -25,  1719,
407    -25,  1719,   -25,  1719,  1719,  1719,  1719,  1719, -1000,  1719,
408   1352,  1286,  1241,  1173,  1076,   973,   897,   847,  1719,  1719,
409   1719,  1719,  1719,   -13, -1000, -1000,  -299, -1000,  -299,  -299,
410   -299,  -299, -1000, -1000,  -222,   207,    30,   151, -1000,   206,
411    -28,  1719,  1719,  1719,  1719,   -22,   211,   803,  -222, -1000,
412    246,    63, -1000, -1000,  -222,   218,   708,  1719, -1000, -1000,
413  -1000, -1000, -1000, -1000, -1000, -1000,   134, -1000,   124,  1719,
414   -271,  1719, -1000, -1000, -1000,   217,   124,  -246,   264,  -246,
415   1719,    55,    92, -1000, -1000,   263,  -248,   259,  -248,   124,
416    124,   124,   124,   626,   -80,   626,  1719,  -294,  1719,  -289,
417   1719,  -263,  1719,  -254,  1719,  -152,  1719,   -58,  1719,   174,
418   1719,   -89,  -222,  -228,  -141,  1408,  -294,   236,  1719,  1719,
419    538,    27, -1000,  1719,   443, -1000, -1000,   399, -1000,   -34,
420  -1000,   149,   172,   121,   152,  1719,   -23, -1000,   207,   336,
421    273, -1000, -1000,   258,   480, -1000,   134,   197,  1719,   235,
422  -1000,   -25, -1000,   -25, -1000,   207,   -25,  1719,   -25, -1000,
423    -25,   234,   -25, -1000, -1000,   626,   626,   626,   626,   626,
424    626,   626,   626,  1719,  1719,   117,   119, -1000,  1719,    73,
425  -1000,   -36, -1000, -1000,   -39, -1000,   -41,   116,  1719, -1000,
426  -1000,   207, -1000,   207, -1000, -1000,  1719,   178, -1000, -1000,
427   1719,  -246,  -246,   -25,  -246,    66,  -248, -1000,  1719,  -248,
428    222,   177, -1000,   -48,    62, -1000, -1000, -1000, -1000,   -51,
429    114, -1000, -1000,   583, -1000,   158, -1000, -1000,  -246, -1000,
430     71, -1000,   186, -1000, -1000, -1000, -1000, -1000,   -71, -1000,
431  -1000, -1000,   146,   -25,   144,   -25,  -248, -1000, -1000, -1000 };
432 int yypgo[]={
433
434      0,   389,   387,   386,   385,   325,   384,   383,     0,   124,
435    382,   380,   375,     1,    11,     8,  1980,   415,  1254,   367,
436    365,   362,   361,   360,   349,   388,   651,    56,   352,   351,
437     57,   350,   345,   343 };
438 int yyr1[]={
439
440      0,    31,     1,     8,     4,     9,     9,     9,    10,    10,
441     10,    10,    24,    24,    24,    24,    24,    24,    14,    14,
442     14,    12,    12,    12,    12,    30,    30,    11,    11,    11,
443     11,    11,    11,    11,    11,    13,    13,    27,    27,    29,
444     29,     2,     2,     2,     3,     3,    32,    33,    15,    15,
445     28,    28,    28,    28,    28,    28,    28,    28,    16,    16,
446     16,    16,    16,    16,    16,    16,    16,    16,    16,    16,
447     16,    16,    16,    16,    16,    16,    16,    16,    16,    16,
448     16,    17,    17,    17,    17,    17,    17,    17,    17,    17,
449     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
450     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
451     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
452     17,    17,    17,    17,    17,    17,    17,    17,    17,    17,
453     17,    17,    17,    17,    17,    25,    25,    23,    18,    19,
454     20,    21,    22,    26,    26,    26,     5,     5,     6,     6,
455      7,     7 };
456 int yyr2[]={
457
458      0,     1,     5,     9,     1,     1,     5,     5,     5,     2,
459      5,     7,     3,     3,     7,     7,     7,     7,     1,     5,
460     13,    13,    13,     9,     9,     1,     5,    15,    15,    11,
461     11,    17,    15,    21,     7,     1,     2,     1,     2,     1,
462      2,     3,     3,     3,     7,     5,     7,     7,     7,     2,
463      7,    11,     9,    13,    13,     7,     5,     9,     7,     9,
464      9,     9,     9,     9,     9,     9,     9,     7,     7,     7,
465      7,     7,     7,     7,     7,     7,     7,     7,    11,     7,
466      3,     5,     5,     5,     5,     5,     5,     5,     5,     5,
467      5,     7,     5,     7,     5,     7,     7,     3,     3,     9,
468     11,     3,     3,     3,    11,    13,    13,    11,     9,    11,
469     13,    17,     3,     3,     7,     9,     5,     5,     9,    11,
470      9,    11,     3,     5,     3,     5,     5,     3,     7,     7,
471      9,     9,    13,     2,     2,     1,     3,     5,     5,     5,
472      5,     5,     5,     3,     3,     3,     5,     3,     5,     3,
473      7,     5 };
474 int yychk[]={
475
476  -1000,    -1,   -31,    -9,    -2,   -10,    -3,   -32,   -33,   -29,
477    -11,   262,   263,   264,   261,   -12,    59,   -24,   265,   266,
478    272,    -8,   267,   268,   256,   -15,   123,   -16,   -17,    45,
479     43,    33,   126,   297,   299,   300,   284,    40,    91,   286,
480    -18,   -22,   -20,   -19,   -21,   285,   259,   -23,   283,   273,
481    292,   275,   276,   260,   257,   -28,    36,    42,    37,    64,
482    282,    38,   287,   277,   -26,   258,   257,    -8,   257,   257,
483     59,    40,    -8,    40,    -8,   -18,    40,   -30,   271,    40,
484     -8,    40,    -8,   267,   268,   265,   266,    44,    -4,    61,
485    298,   280,   281,   293,   291,   290,   289,   288,   278,   279,
486    274,    63,   294,   295,   301,   302,   -17,    -8,   -17,   -17,
487    -17,   -17,   -17,   -17,   -16,   -15,    41,   -15,    93,   -15,
488     59,    91,   123,    91,   123,   -18,    40,    40,   -16,    -8,
489    257,   -18,   257,    -8,   -16,    40,    40,    40,   -26,   257,
490    -18,   -26,   -26,   -26,   -26,   -26,   -26,   -25,   -15,    40,
491    295,   -26,    -8,    -8,    59,   -27,   -15,    -8,   -15,    -8,
492     40,   -15,   -13,   -24,    -8,   -15,    -8,   -15,    -8,   -15,
493    -15,   -15,   -15,   -16,    -9,   -16,    61,   -16,    61,   -16,
494     61,   -16,    61,   -16,    61,   -16,    61,   -16,    61,   -16,
495     61,   -16,   -16,   -16,   -16,   -16,   -16,   258,    91,   123,
496     44,    -5,    41,    91,    44,    -6,    93,    44,    -7,    59,
497    125,   -15,   -15,   -15,   -15,   123,   -18,    41,   -15,    40,
498     40,    41,    41,   -15,   -16,   -25,   -26,   -25,   287,   277,
499    -25,    41,   -30,    41,   -30,   -15,    -5,    59,    41,   -14,
500    269,   270,    41,   -14,   125,   -16,   -16,   -16,   -16,   -16,
501    -16,   -16,   -16,    58,    40,   -15,   -15,    41,    91,   -15,
502     93,    59,   125,    93,    59,    93,    59,   -15,   123,    -5,
503     41,   -15,    41,   -15,    41,    41,    44,   -25,    41,   -25,
504     40,    -8,    -8,    -5,    -8,   -27,    -8,    -8,    40,    -8,
505    -16,   -25,    93,    59,   -15,    93,   125,   125,   125,    59,
506    -15,    -5,    -5,   -16,    41,   -25,   -30,   -30,    -8,   -30,
507     59,   -14,   -15,   -14,    41,   125,    93,   125,    59,    41,
508     41,   -30,   -13,    41,   125,    41,    -8,    41,    -8,   -14 };
509 int yydef[]={
510
511      1,    -2,     5,    -2,     6,     7,    41,    42,    43,     0,
512      9,     0,     0,     0,    40,     8,    10,     0,     0,     0,
513      0,    -2,     0,     0,    12,    13,     4,    49,    80,     0,
514      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
515     -2,    98,   101,   102,   103,     0,   112,   113,     0,   122,
516    124,   127,     0,     0,    -2,   134,     0,     0,     0,     0,
517      0,     0,   135,     0,     0,     0,     0,    45,     0,     0,
518     11,    37,     0,     0,     0,     0,    -2,    34,     0,     0,
519      0,     0,     0,     0,     0,     0,     0,     0,     5,     0,
520      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
521      0,     0,     0,     0,    86,    87,    81,   145,    82,    83,
522     84,    85,    -2,    -2,    90,     0,    92,     0,    94,     0,
523      0,     0,     0,     0,     0,     0,     0,     0,   116,   117,
524    133,    97,   123,   125,   126,     0,     0,     0,   138,   143,
525    144,   142,   140,   139,   141,   137,   135,    56,   136,   135,
526      0,   135,    44,    46,    47,     0,    38,    25,     0,    25,
527      0,    13,     0,    36,    26,     0,    18,     0,    18,    14,
528     15,    16,    17,    48,    39,    58,     0,    67,     0,    68,
529      0,    69,     0,    70,     0,    73,     0,    74,     0,    76,
530      0,    77,    -2,    -2,    -2,     0,    79,     0,     0,     0,
531      0,    91,   147,     0,     0,    93,   149,     0,    95,     0,
532     96,     0,     0,     0,     0,     0,     0,   114,     0,     0,
533      0,   128,   129,     0,     0,    50,   135,     0,   135,     0,
534     55,     0,    29,     0,    30,     0,     0,    37,     0,    23,
535      0,     0,     0,    24,     3,    59,    60,    61,    62,    63,
536     64,    65,    66,     0,   135,     0,     0,   146,     0,     0,
537    148,     0,   151,    99,     0,   108,     0,     0,     0,   115,
538    118,     0,   120,     0,   130,   131,     0,     0,    57,    52,
539    135,    25,    25,     0,    25,     0,    18,    19,     0,    18,
540     78,     0,   100,     0,     0,   107,   150,   104,   109,     0,
541      0,   119,   121,     0,    51,     0,    27,    28,    25,    32,
542     -2,    21,     0,    22,    54,   105,   106,   110,     0,   132,
543     53,    31,     0,     0,     0,     0,    18,   111,    33,    20 };
544 typedef struct { char *t_name; int t_val; } yytoktype;
545 #ifndef YYDEBUG
546 #       define YYDEBUG  0       /* don't allow debugging */
547 #endif
548
549 #if YYDEBUG
550
551 yytoktype yytoks[] =
552 {
553         "{",    123,
554         ")",    41,
555         "WORD", 257,
556         "METHOD",       258,
557         "THING",        259,
558         "PMFUNC",       260,
559         "LABEL",        261,
560         "FORMAT",       262,
561         "SUB",  263,
562         "PACKAGE",      264,
563         "WHILE",        265,
564         "UNTIL",        266,
565         "IF",   267,
566         "UNLESS",       268,
567         "ELSE", 269,
568         "ELSIF",        270,
569         "CONTINUE",     271,
570         "FOR",  272,
571         "LOOPEX",       273,
572         "DOTDOT",       274,
573         "FUNC0",        275,
574         "FUNC1",        276,
575         "FUNC", 277,
576         "RELOP",        278,
577         "EQOP", 279,
578         "MULOP",        280,
579         "ADDOP",        281,
580         "DOLSHARP",     282,
581         "DO",   283,
582         "LOCAL",        284,
583         "DELETE",       285,
584         "HASHBRACK",    286,
585         "LSTOP",        287,
586         ",",    44,
587         "=",    61,
588         "?",    63,
589         ":",    58,
590         "OROR", 288,
591         "ANDAND",       289,
592         "BITOROP",      290,
593         "BITANDOP",     291,
594         "UNIOP",        292,
595         "SHIFTOP",      293,
596         "MATCHOP",      294,
597         "ARROW",        295,
598         "!",    33,
599         "~",    126,
600         "UMINUS",       296,
601         "REFGEN",       297,
602         "POWOP",        298,
603         "PREINC",       299,
604         "PREDEC",       300,
605         "POSTINC",      301,
606         "POSTDEC",      302,
607         "(",    40,
608         "-unknown-",    -1      /* ends search */
609 };
610
611 char * yyreds[] =
612 {
613         "-no such reduction-",
614         "prog : /* empty */",
615         "prog : lineseq",
616         "block : '{' remember lineseq '}'",
617         "remember : /* empty */",
618         "lineseq : /* empty */",
619         "lineseq : lineseq decl",
620         "lineseq : lineseq line",
621         "line : label cond",
622         "line : loop",
623         "line : label ';'",
624         "line : label sideff ';'",
625         "sideff : error",
626         "sideff : expr",
627         "sideff : expr IF expr",
628         "sideff : expr UNLESS expr",
629         "sideff : expr WHILE expr",
630         "sideff : expr UNTIL expr",
631         "else : /* empty */",
632         "else : ELSE block",
633         "else : ELSIF '(' expr ')' block else",
634         "cond : IF '(' expr ')' block else",
635         "cond : UNLESS '(' expr ')' block else",
636         "cond : IF block block else",
637         "cond : UNLESS block block else",
638         "cont : /* empty */",
639         "cont : CONTINUE block",
640         "loop : label WHILE '(' texpr ')' block cont",
641         "loop : label UNTIL '(' expr ')' block cont",
642         "loop : label WHILE block block cont",
643         "loop : label UNTIL block block cont",
644         "loop : label FOR scalar '(' expr crp block cont",
645         "loop : label FOR '(' expr crp block cont",
646         "loop : label FOR '(' nexpr ';' texpr ';' nexpr ')' block",
647         "loop : label block cont",
648         "nexpr : /* empty */",
649         "nexpr : sideff",
650         "texpr : /* empty */",
651         "texpr : expr",
652         "label : /* empty */",
653         "label : LABEL",
654         "decl : format",
655         "decl : subrout",
656         "decl : package",
657         "format : FORMAT WORD block",
658         "format : FORMAT block",
659         "subrout : SUB WORD block",
660         "package : PACKAGE WORD ';'",
661         "expr : expr ',' sexpr",
662         "expr : sexpr",
663         "listop : LSTOP indirob listexpr",
664         "listop : FUNC '(' indirob listexpr ')'",
665         "listop : indirob ARROW LSTOP listexpr",
666         "listop : indirob ARROW FUNC '(' listexpr ')'",
667         "listop : term ARROW METHOD '(' listexpr ')'",
668         "listop : METHOD indirob listexpr",
669         "listop : LSTOP listexpr",
670         "listop : FUNC '(' listexpr ')'",
671         "sexpr : sexpr '=' sexpr",
672         "sexpr : sexpr POWOP '=' sexpr",
673         "sexpr : sexpr MULOP '=' sexpr",
674         "sexpr : sexpr ADDOP '=' sexpr",
675         "sexpr : sexpr SHIFTOP '=' sexpr",
676         "sexpr : sexpr BITANDOP '=' sexpr",
677         "sexpr : sexpr BITOROP '=' sexpr",
678         "sexpr : sexpr ANDAND '=' sexpr",
679         "sexpr : sexpr OROR '=' sexpr",
680         "sexpr : sexpr POWOP sexpr",
681         "sexpr : sexpr MULOP sexpr",
682         "sexpr : sexpr ADDOP sexpr",
683         "sexpr : sexpr SHIFTOP sexpr",
684         "sexpr : sexpr RELOP sexpr",
685         "sexpr : sexpr EQOP sexpr",
686         "sexpr : sexpr BITANDOP sexpr",
687         "sexpr : sexpr BITOROP sexpr",
688         "sexpr : sexpr DOTDOT sexpr",
689         "sexpr : sexpr ANDAND sexpr",
690         "sexpr : sexpr OROR sexpr",
691         "sexpr : sexpr '?' sexpr ':' sexpr",
692         "sexpr : sexpr MATCHOP sexpr",
693         "sexpr : term",
694         "term : '-' term",
695         "term : '+' term",
696         "term : '!' term",
697         "term : '~' term",
698         "term : REFGEN term",
699         "term : term POSTINC",
700         "term : term POSTDEC",
701         "term : PREINC term",
702         "term : PREDEC term",
703         "term : LOCAL sexpr",
704         "term : '(' expr crp",
705         "term : '(' ')'",
706         "term : '[' expr crb",
707         "term : '[' ']'",
708         "term : HASHBRACK expr crhb",
709         "term : HASHBRACK ';' '}'",
710         "term : scalar",
711         "term : star",
712         "term : scalar '[' expr ']'",
713         "term : term ARROW '[' expr ']'",
714         "term : hsh",
715         "term : ary",
716         "term : arylen",
717         "term : scalar '{' expr ';' '}'",
718         "term : term ARROW '{' expr ';' '}'",
719         "term : '(' expr crp '[' expr ']'",
720         "term : '(' ')' '[' expr ']'",
721         "term : ary '[' expr ']'",
722         "term : ary '{' expr ';' '}'",
723         "term : DELETE scalar '{' expr ';' '}'",
724         "term : DELETE '(' scalar '{' expr ';' '}' ')'",
725         "term : THING",
726         "term : amper",
727         "term : amper '(' ')'",
728         "term : amper '(' expr crp",
729         "term : DO sexpr",
730         "term : DO block",
731         "term : DO WORD '(' ')'",
732         "term : DO WORD '(' expr crp",
733         "term : DO scalar '(' ')'",
734         "term : DO scalar '(' expr crp",
735         "term : LOOPEX",
736         "term : LOOPEX WORD",
737         "term : UNIOP",
738         "term : UNIOP block",
739         "term : UNIOP sexpr",
740         "term : FUNC0",
741         "term : FUNC0 '(' ')'",
742         "term : FUNC1 '(' ')'",
743         "term : FUNC1 '(' expr ')'",
744         "term : PMFUNC '(' sexpr ')'",
745         "term : PMFUNC '(' sexpr ',' sexpr ')'",
746         "term : WORD",
747         "term : listop",
748         "listexpr : /* empty */",
749         "listexpr : expr",
750         "amper : '&' indirob",
751         "scalar : '$' indirob",
752         "ary : '@' indirob",
753         "hsh : '%' indirob",
754         "arylen : DOLSHARP indirob",
755         "star : '*' indirob",
756         "indirob : WORD",
757         "indirob : scalar",
758         "indirob : block",
759         "crp : ',' ')'",
760         "crp : ')'",
761         "crb : ',' ']'",
762         "crb : ']'",
763         "crhb : ',' ';' '}'",
764         "crhb : ';' '}'",
765 };
766 #endif /* YYDEBUG */
767 #line 1 "/usr/lib/yaccpar"
768 /*      @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10   */
769
770 /*
771 ** Skeleton parser driver for yacc output
772 */
773
774 /*
775 ** yacc user known macros and defines
776 */
777 #define YYERROR         goto yyerrlab
778 #define YYACCEPT        { free(yys); free(yyv); return(0); }
779 #define YYABORT         { free(yys); free(yyv); return(1); }
780 #define YYBACKUP( newtoken, newvalue )\
781 {\
782         if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
783         {\
784                 yyerror( "syntax error - cannot backup" );\
785                 goto yyerrlab;\
786         }\
787         yychar = newtoken;\
788         yystate = *yyps;\
789         yylval = newvalue;\
790         goto yynewstate;\
791 }
792 #define YYRECOVERING()  (!!yyerrflag)
793 #ifndef YYDEBUG
794 #       define YYDEBUG  1       /* make debugging available */
795 #endif
796
797 /*
798 ** user known globals
799 */
800 int yydebug;                    /* set to 1 to get debugging */
801
802 /*
803 ** driver internal defines
804 */
805 #define YYFLAG          (-1000)
806
807 /*
808 ** static variables used by the parser
809 */
810 static YYSTYPE *yyv;                    /* value stack */
811 static int *yys;                        /* state stack */
812
813 static YYSTYPE *yypv;                   /* top of value stack */
814 static int *yyps;                       /* top of state stack */
815
816 static int yystate;                     /* current state */
817 static int yytmp;                       /* extra var (lasts between blocks) */
818
819 int yynerrs;                    /* number of errors */
820
821 int yyerrflag;                  /* error recovery flag */
822 int yychar;                     /* current input token number */
823
824
825 /*
826 ** yyparse - return 0 if worked, 1 if syntax error not recovered from
827 */
828 int
829 yyparse()
830 {
831         register YYSTYPE *yypvt;        /* top of value stack for $vars */
832         unsigned yymaxdepth = YYMAXDEPTH;
833
834         /*
835         ** Initialize externals - yyparse may be called more than once
836         */
837         yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
838         yys = (int*)malloc(yymaxdepth*sizeof(int));
839         if (!yyv || !yys)
840         {
841                 yyerror( "out of memory" );
842                 return(1);
843         }
844         yypv = &yyv[-1];
845         yyps = &yys[-1];
846         yystate = 0;
847         yytmp = 0;
848         yynerrs = 0;
849         yyerrflag = 0;
850         yychar = -1;
851
852         goto yystack;
853         {
854                 register YYSTYPE *yy_pv;        /* top of value stack */
855                 register int *yy_ps;            /* top of state stack */
856                 register int yy_state;          /* current state */
857                 register int  yy_n;             /* internal state number info */
858
859                 /*
860                 ** get globals into registers.
861                 ** branch to here only if YYBACKUP was called.
862                 */
863         yynewstate:
864                 yy_pv = yypv;
865                 yy_ps = yyps;
866                 yy_state = yystate;
867                 goto yy_newstate;
868
869                 /*
870                 ** get globals into registers.
871                 ** either we just started, or we just finished a reduction
872                 */
873         yystack:
874                 yy_pv = yypv;
875                 yy_ps = yyps;
876                 yy_state = yystate;
877
878                 /*
879                 ** top of for (;;) loop while no reductions done
880                 */
881         yy_stack:
882                 /*
883                 ** put a state and value onto the stacks
884                 */
885 #if YYDEBUG
886                 /*
887                 ** if debugging, look up token value in list of value vs.
888                 ** name pairs.  0 and negative (-1) are special values.
889                 ** Note: linear search is used since time is not a real
890                 ** consideration while debugging.
891                 */
892                 if ( yydebug )
893                 {
894                         register int yy_i;
895
896                         (void)printf( "State %d, token ", yy_state );
897                         if ( yychar == 0 )
898                                 (void)printf( "end-of-file\n" );
899                         else if ( yychar < 0 )
900                                 (void)printf( "-none-\n" );
901                         else
902                         {
903                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
904                                         yy_i++ )
905                                 {
906                                         if ( yytoks[yy_i].t_val == yychar )
907                                                 break;
908                                 }
909                                 (void)printf( "%s\n", yytoks[yy_i].t_name );
910                         }
911                 }
912 #endif /* YYDEBUG */
913                 if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
914                 {
915                         /*
916                         ** reallocate and recover.  Note that pointers
917                         ** have to be reset, or bad things will happen
918                         */
919                         int yyps_index = (yy_ps - yys);
920                         int yypv_index = (yy_pv - yyv);
921                         int yypvt_index = (yypvt - yyv);
922                         yymaxdepth += YYMAXDEPTH;
923                         yyv = (YYSTYPE*)realloc((char*)yyv,
924                                 yymaxdepth * sizeof(YYSTYPE));
925                         yys = (int*)realloc((char*)yys,
926                                 yymaxdepth * sizeof(int));
927                         if (!yyv || !yys)
928                         {
929                                 yyerror( "yacc stack overflow" );
930                                 return(1);
931                         }
932                         yy_ps = yys + yyps_index;
933                         yy_pv = yyv + yypv_index;
934                         yypvt = yyv + yypvt_index;
935                 }
936                 *yy_ps = yy_state;
937                 *++yy_pv = yyval;
938
939                 /*
940                 ** we have a new state - find out what to do
941                 */
942         yy_newstate:
943                 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
944                         goto yydefault;         /* simple state */
945 #if YYDEBUG
946                 /*
947                 ** if debugging, need to mark whether new token grabbed
948                 */
949                 yytmp = yychar < 0;
950 #endif
951                 if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
952                         yychar = 0;             /* reached EOF */
953 #if YYDEBUG
954                 if ( yydebug && yytmp )
955                 {
956                         register int yy_i;
957
958                         (void)printf( " *** Received token " );
959                         if ( yychar == 0 )
960                                 (void)printf( "end-of-file\n" );
961                         else if ( yychar < 0 )
962                                 (void)printf( "-none-\n" );
963                         else
964                         {
965                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
966                                         yy_i++ )
967                                 {
968                                         if ( yytoks[yy_i].t_val == yychar )
969                                                 break;
970                                 }
971                                 (void)printf( "%s\n", yytoks[yy_i].t_name );
972                         }
973                 }
974 #endif /* YYDEBUG */
975                 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
976                         goto yydefault;
977                 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )  /*valid shift*/
978                 {
979                         yychar = -1;
980                         yyval = yylval;
981                         yy_state = yy_n;
982                         if ( yyerrflag > 0 )
983                                 yyerrflag--;
984                         goto yy_stack;
985                 }
986
987         yydefault:
988                 if ( ( yy_n = yydef[ yy_state ] ) == -2 )
989                 {
990 #if YYDEBUG
991                         yytmp = yychar < 0;
992 #endif
993                         if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
994                                 yychar = 0;             /* reached EOF */
995 #if YYDEBUG
996                         if ( yydebug && yytmp )
997                         {
998                                 register int yy_i;
999
1000                                 (void)printf( " *** Received token " );
1001                                 if ( yychar == 0 )
1002                                         (void)printf( "end-of-file\n" );
1003                                 else if ( yychar < 0 )
1004                                         (void)printf( "-none-\n" );
1005                                 else
1006                                 {
1007                                         for ( yy_i = 0;
1008                                                 yytoks[yy_i].t_val >= 0;
1009                                                 yy_i++ )
1010                                         {
1011                                                 if ( yytoks[yy_i].t_val
1012                                                         == yychar )
1013                                                 {
1014                                                         break;
1015                                                 }
1016                                         }
1017                                         (void)printf( "%s\n", yytoks[yy_i].t_name );
1018                                 }
1019                         }
1020 #endif /* YYDEBUG */
1021                         /*
1022                         ** look through exception table
1023                         */
1024                         {
1025                                 register int *yyxi = yyexca;
1026
1027                                 while ( ( *yyxi != -1 ) ||
1028                                         ( yyxi[1] != yy_state ) )
1029                                 {
1030                                         yyxi += 2;
1031                                 }
1032                                 while ( ( *(yyxi += 2) >= 0 ) &&
1033                                         ( *yyxi != yychar ) )
1034                                         ;
1035                                 if ( ( yy_n = yyxi[1] ) < 0 )
1036                                         YYACCEPT;
1037                         }
1038                 }
1039
1040                 /*
1041                 ** check for syntax error
1042                 */
1043                 if ( yy_n == 0 )        /* have an error */
1044                 {
1045                         /* no worry about speed here! */
1046                         switch ( yyerrflag )
1047                         {
1048                         case 0:         /* new error */
1049                                 yyerror( "syntax error" );
1050                                 goto skip_init;
1051                         yyerrlab:
1052                                 /*
1053                                 ** get globals into registers.
1054                                 ** we have a user generated syntax type error
1055                                 */
1056                                 yy_pv = yypv;
1057                                 yy_ps = yyps;
1058                                 yy_state = yystate;
1059                                 yynerrs++;
1060                         skip_init:
1061                         case 1:
1062                         case 2:         /* incompletely recovered error */
1063                                         /* try again... */
1064                                 yyerrflag = 3;
1065                                 /*
1066                                 ** find state where "error" is a legal
1067                                 ** shift action
1068                                 */
1069                                 while ( yy_ps >= yys )
1070                                 {
1071                                         yy_n = yypact[ *yy_ps ] + YYERRCODE;
1072                                         if ( yy_n >= 0 && yy_n < YYLAST &&
1073                                                 yychk[yyact[yy_n]] == YYERRCODE)                                        {
1074                                                 /*
1075                                                 ** simulate shift of "error"
1076                                                 */
1077                                                 yy_state = yyact[ yy_n ];
1078                                                 goto yy_stack;
1079                                         }
1080                                         /*
1081                                         ** current state has no shift on
1082                                         ** "error", pop stack
1083                                         */
1084 #if YYDEBUG
1085 #       define _POP_ "Error recovery pops state %d, uncovers state %d\n"
1086                                         if ( yydebug )
1087                                                 (void)printf( _POP_, *yy_ps,
1088                                                         yy_ps[-1] );
1089 #       undef _POP_
1090 #endif
1091                                         yy_ps--;
1092                                         yy_pv--;
1093                                 }
1094                                 /*
1095                                 ** there is no state on stack with "error" as
1096                                 ** a valid shift.  give up.
1097                                 */
1098                                 YYABORT;
1099                         case 3:         /* no shift yet; eat a token */
1100 #if YYDEBUG
1101                                 /*
1102                                 ** if debugging, look up token in list of
1103                                 ** pairs.  0 and negative shouldn't occur,
1104                                 ** but since timing doesn't matter when
1105                                 ** debugging, it doesn't hurt to leave the
1106                                 ** tests here.
1107                                 */
1108                                 if ( yydebug )
1109                                 {
1110                                         register int yy_i;
1111
1112                                         (void)printf( "Error recovery discards " );
1113                                         if ( yychar == 0 )
1114                                                 (void)printf( "token end-of-file\n" );
1115                                         else if ( yychar < 0 )
1116                                                 (void)printf( "token -none-\n" );
1117                                         else
1118                                         {
1119                                                 for ( yy_i = 0;
1120                                                         yytoks[yy_i].t_val >= 0;
1121                                                         yy_i++ )
1122                                                 {
1123                                                         if ( yytoks[yy_i].t_val
1124                                                                 == yychar )
1125                                                         {
1126                                                                 break;
1127                                                         }
1128                                                 }
1129                                                 (void)printf( "token %s\n",
1130                                                         yytoks[yy_i].t_name );
1131                                         }
1132                                 }
1133 #endif /* YYDEBUG */
1134                                 if ( yychar == 0 )      /* reached EOF. quit */
1135                                         YYABORT;
1136                                 yychar = -1;
1137                                 goto yy_newstate;
1138                         }
1139                 }/* end if ( yy_n == 0 ) */
1140                 /*
1141                 ** reduction by production yy_n
1142                 ** put stack tops, etc. so things right after switch
1143                 */
1144 #if YYDEBUG
1145                 /*
1146                 ** if debugging, print the string that is the user's
1147                 ** specification of the reduction which is just about
1148                 ** to be done.
1149                 */
1150                 if ( yydebug )
1151                         (void)printf( "Reduce by (%d) \"%s\"\n",
1152                                 yy_n, yyreds[ yy_n ] );
1153 #endif
1154                 yytmp = yy_n;                   /* value to switch over */
1155                 yypvt = yy_pv;                  /* $vars top of value stack */
1156                 /*
1157                 ** Look in goto table for next state
1158                 ** Sorry about using yy_state here as temporary
1159                 ** register variable, but why not, if it works...
1160                 ** If yyr2[ yy_n ] doesn't have the low order bit
1161                 ** set, then there is no action to be done for
1162                 ** this reduction.  So, no saving & unsaving of
1163                 ** registers done.  The only difference between the
1164                 ** code just after the if and the body of the if is
1165                 ** the goto yy_stack in the body.  This way the test
1166                 ** can be made before the choice of what to do is needed.
1167                 */
1168                 {
1169                         /* length of production doubled with extra bit */
1170                         register int yy_len = yyr2[ yy_n ];
1171
1172                         if ( !( yy_len & 01 ) )
1173                         {
1174                                 yy_len >>= 1;
1175                                 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
1176                                 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
1177                                         *( yy_ps -= yy_len ) + 1;
1178                                 if ( yy_state >= YYLAST ||
1179                                         yychk[ yy_state =
1180                                         yyact[ yy_state ] ] != -yy_n )
1181                                 {
1182                                         yy_state = yyact[ yypgo[ yy_n ] ];
1183                                 }
1184                                 goto yy_stack;
1185                         }
1186                         yy_len >>= 1;
1187                         yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
1188                         yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
1189                                 *( yy_ps -= yy_len ) + 1;
1190                         if ( yy_state >= YYLAST ||
1191                                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
1192                         {
1193                                 yy_state = yyact[ yypgo[ yy_n ] ];
1194                         }
1195                 }
1196                                         /* save until reenter driver code */
1197                 yystate = yy_state;
1198                 yyps = yy_ps;
1199                 yypv = yy_pv;
1200         }
1201         /*
1202         ** code supplied by user is placed in this switch
1203         */
1204         switch( yytmp )
1205         {
1206                 
1207 case 1:
1208 # line 100 "perly.y"
1209 {
1210 #if defined(YYDEBUG) && defined(DEBUGGING)
1211                     yydebug = (debug & 1);
1212 #endif
1213                     expect = XBLOCK;
1214                 } break;
1215 case 2:
1216 # line 107 "perly.y"
1217 {   if (in_eval) {
1218                                 eval_root = newUNOP(OP_LEAVEEVAL, 0, yypvt[-0].opval);
1219                                 eval_start = linklist(eval_root);
1220                                 eval_root->op_next = 0;
1221                                 peep(eval_start);
1222                             }
1223                             else
1224                                 main_root = block_head(scalar(yypvt[-0].opval), &main_start);
1225                         } break;
1226 case 3:
1227 # line 119 "perly.y"
1228 { yyval.opval = scalarseq(yypvt[-1].opval);
1229                           if (copline > (line_t)yypvt[-3].ival)
1230                               copline = yypvt[-3].ival;
1231                           if (savestack_ix > yypvt[-2].ival)
1232                             leave_scope(yypvt[-2].ival);
1233                           expect = XBLOCK; } break;
1234 case 4:
1235 # line 128 "perly.y"
1236 { yyval.ival = savestack_ix; } break;
1237 case 5:
1238 # line 132 "perly.y"
1239 { yyval.opval = Nullop; } break;
1240 case 6:
1241 # line 134 "perly.y"
1242 { yyval.opval = yypvt[-1].opval; } break;
1243 case 7:
1244 # line 136 "perly.y"
1245 { yyval.opval = append_list(OP_LINESEQ, yypvt[-1].opval, yypvt[-0].opval); pad_reset(); } break;
1246 case 8:
1247 # line 140 "perly.y"
1248 { yyval.opval = newSTATEOP(0, yypvt[-1].pval, yypvt[-0].opval); } break;
1249 case 10:
1250 # line 143 "perly.y"
1251 { if (yypvt[-1].pval != Nullch) {
1252                               yyval.opval = newSTATEOP(0, yypvt[-1].pval, newOP(OP_NULL, 0));
1253                             }
1254                             else {
1255                               yyval.opval = Nullop;
1256                               copline = NOLINE;
1257                             }
1258                             expect = XBLOCK; } break;
1259 case 11:
1260 # line 152 "perly.y"
1261 { yyval.opval = newSTATEOP(0, yypvt[-2].pval, yypvt[-1].opval);
1262                           expect = XBLOCK; } break;
1263 case 12:
1264 # line 157 "perly.y"
1265 { yyval.opval = Nullop; } break;
1266 case 13:
1267 # line 159 "perly.y"
1268 { yyval.opval = yypvt[-0].opval; } break;
1269 case 14:
1270 # line 161 "perly.y"
1271 { yyval.opval = newLOGOP(OP_AND, 0, yypvt[-0].opval, yypvt[-2].opval); } break;
1272 case 15:
1273 # line 163 "perly.y"
1274 { yyval.opval = newLOGOP(OP_OR, 0, yypvt[-0].opval, yypvt[-2].opval); } break;
1275 case 16:
1276 # line 165 "perly.y"
1277 { yyval.opval = newLOOPOP(0, 1, scalar(yypvt[-0].opval), yypvt[-2].opval, Nullop); } break;
1278 case 17:
1279 # line 167 "perly.y"
1280 { yyval.opval = newLOOPOP(0, 1, invert(scalar(yypvt[-0].opval)), yypvt[-2].opval, Nullop);} break;
1281 case 18:
1282 # line 171 "perly.y"
1283 { yyval.opval = Nullop; } break;
1284 case 19:
1285 # line 173 "perly.y"
1286 { yyval.opval = scope(yypvt[-0].opval); } break;
1287 case 20:
1288 # line 175 "perly.y"
1289 { copline = yypvt[-5].ival;
1290                             yyval.opval = newCONDOP(0, yypvt[-3].opval, scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1291 case 21:
1292 # line 180 "perly.y"
1293 { copline = yypvt[-5].ival;
1294                             yyval.opval = newCONDOP(0, yypvt[-3].opval, scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1295 case 22:
1296 # line 183 "perly.y"
1297 { copline = yypvt[-5].ival;
1298                             yyval.opval = newCONDOP(0,
1299                                 invert(scalar(yypvt[-3].opval)), scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1300 case 23:
1301 # line 187 "perly.y"
1302 { copline = yypvt[-3].ival;
1303                             yyval.opval = newCONDOP(0, scope(yypvt[-2].opval), scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1304 case 24:
1305 # line 190 "perly.y"
1306 { copline = yypvt[-3].ival;
1307                             yyval.opval = newCONDOP(0, invert(scalar(scope(yypvt[-2].opval))),
1308                                                 scope(yypvt[-1].opval), yypvt[-0].opval); } break;
1309 case 25:
1310 # line 196 "perly.y"
1311 { yyval.opval = Nullop; } break;
1312 case 26:
1313 # line 198 "perly.y"
1314 { yyval.opval = scope(yypvt[-0].opval); } break;
1315 case 27:
1316 # line 202 "perly.y"
1317 { copline = yypvt[-5].ival;
1318                             yyval.opval = newSTATEOP(0, yypvt[-6].pval,
1319                                     newWHILEOP(0, 1, Nullop, yypvt[-3].opval, yypvt[-1].opval, yypvt[-0].opval) ); } break;
1320 case 28:
1321 # line 206 "perly.y"
1322 { copline = yypvt[-5].ival;
1323                             yyval.opval = newSTATEOP(0, yypvt[-6].pval,
1324                                     newWHILEOP(0, 1, Nullop,
1325                                         invert(scalar(yypvt[-3].opval)), yypvt[-1].opval, yypvt[-0].opval) ); } break;
1326 case 29:
1327 # line 211 "perly.y"
1328 { copline = yypvt[-3].ival;
1329                             yyval.opval = newSTATEOP(0, yypvt[-4].pval,
1330                                     newWHILEOP(0, 1, Nullop,
1331                                         scope(yypvt[-2].opval), yypvt[-1].opval, yypvt[-0].opval) ); } break;
1332 case 30:
1333 # line 216 "perly.y"
1334 { copline = yypvt[-3].ival;
1335                             yyval.opval = newSTATEOP(0, yypvt[-4].pval,
1336                                     newWHILEOP(0, 1, Nullop,
1337                                         invert(scalar(scope(yypvt[-2].opval))), yypvt[-1].opval, yypvt[-0].opval)); } break;
1338 case 31:
1339 # line 221 "perly.y"
1340 { yyval.opval = newFOROP(0, yypvt[-7].pval, yypvt[-6].ival, ref(yypvt[-5].opval, OP_ENTERLOOP),
1341                                 yypvt[-3].opval, yypvt[-1].opval, yypvt[-0].opval); } break;
1342 case 32:
1343 # line 224 "perly.y"
1344 { yyval.opval = newFOROP(0, yypvt[-6].pval, yypvt[-5].ival, Nullop, yypvt[-3].opval, yypvt[-1].opval, yypvt[-0].opval); } break;
1345 case 33:
1346 # line 227 "perly.y"
1347 {  copline = yypvt[-8].ival;
1348                             yyval.opval = append_elem(OP_LINESEQ,
1349                                     newSTATEOP(0, yypvt[-9].pval, scalar(yypvt[-6].opval)),
1350                                     newSTATEOP(0, yypvt[-9].pval,
1351                                         newWHILEOP(0, 1, Nullop,
1352                                             scalar(yypvt[-4].opval), yypvt[-0].opval, scalar(yypvt[-2].opval)) )); } break;
1353 case 34:
1354 # line 234 "perly.y"
1355 { yyval.opval = newSTATEOP(0,
1356                                 yypvt[-2].pval, newWHILEOP(0, 1, Nullop, Nullop, yypvt[-1].opval, yypvt[-0].opval)); } break;
1357 case 35:
1358 # line 239 "perly.y"
1359 { yyval.opval = Nullop; } break;
1360 case 37:
1361 # line 244 "perly.y"
1362 { (void)scan_num("1"); yyval.opval = yylval.opval; } break;
1363 case 39:
1364 # line 249 "perly.y"
1365 { yyval.pval = Nullch; } break;
1366 case 41:
1367 # line 254 "perly.y"
1368 { yyval.ival = 0; } break;
1369 case 42:
1370 # line 256 "perly.y"
1371 { yyval.ival = 0; } break;
1372 case 43:
1373 # line 258 "perly.y"
1374 { yyval.ival = 0; } break;
1375 case 44:
1376 # line 262 "perly.y"
1377 { newFORM(yypvt[-2].ival, yypvt[-1].opval, yypvt[-0].opval); } break;
1378 case 45:
1379 # line 264 "perly.y"
1380 { newFORM(yypvt[-1].ival, Nullop, yypvt[-0].opval); } break;
1381 case 46:
1382 # line 268 "perly.y"
1383 { newSUB(yypvt[-2].ival, yypvt[-1].opval, yypvt[-0].opval); } break;
1384 case 47:
1385 # line 272 "perly.y"
1386 { package(yypvt[-1].opval); } break;
1387 case 48:
1388 # line 276 "perly.y"
1389 { yyval.opval = append_elem(OP_LIST, yypvt[-2].opval, yypvt[-0].opval); } break;
1390 case 50:
1391 # line 281 "perly.y"
1392 { yyval.opval = convert(yypvt[-2].ival, OPf_STACKED,
1393                                 prepend_elem(OP_LIST, newGVREF(yypvt[-1].opval), yypvt[-0].opval) ); } break;
1394 case 51:
1395 # line 284 "perly.y"
1396 { yyval.opval = convert(yypvt[-4].ival, OPf_STACKED,
1397                                 prepend_elem(OP_LIST, newGVREF(yypvt[-2].opval), yypvt[-1].opval) ); } break;
1398 case 52:
1399 # line 287 "perly.y"
1400 { yyval.opval = convert(yypvt[-1].ival, OPf_STACKED,
1401                                 prepend_elem(OP_LIST, newGVREF(yypvt[-3].opval), yypvt[-0].opval) ); } break;
1402 case 53:
1403 # line 290 "perly.y"
1404 { yyval.opval = convert(yypvt[-3].ival, OPf_STACKED,
1405                                 prepend_elem(OP_LIST, newGVREF(yypvt[-5].opval), yypvt[-1].opval) ); } break;
1406 case 54:
1407 # line 293 "perly.y"
1408 { yyval.opval = convert(OP_ENTERSUBR, OPf_STACKED|OPf_SPECIAL,
1409                                 prepend_elem(OP_LIST, newMETHOD(yypvt[-5].opval,yypvt[-3].opval), yypvt[-1].opval)); } break;
1410 case 55:
1411 # line 296 "perly.y"
1412 { yyval.opval = convert(OP_ENTERSUBR, OPf_STACKED|OPf_SPECIAL,
1413                                 prepend_elem(OP_LIST, newMETHOD(yypvt[-1].opval,yypvt[-2].opval), yypvt[-0].opval)); } break;
1414 case 56:
1415 # line 299 "perly.y"
1416 { yyval.opval = convert(yypvt[-1].ival, 0, yypvt[-0].opval); } break;
1417 case 57:
1418 # line 301 "perly.y"
1419 { yyval.opval = convert(yypvt[-3].ival, 0, yypvt[-1].opval); } break;
1420 case 58:
1421 # line 305 "perly.y"
1422 { yyval.opval = newASSIGNOP(OPf_STACKED, yypvt[-2].opval, yypvt[-0].opval); } break;
1423 case 59:
1424 # line 307 "perly.y"
1425 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1426                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1427 case 60:
1428 # line 310 "perly.y"
1429 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1430                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1431 case 61:
1432 # line 313 "perly.y"
1433 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1434                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval));} break;
1435 case 62:
1436 # line 316 "perly.y"
1437 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1438                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1439 case 63:
1440 # line 319 "perly.y"
1441 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1442                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1443 case 64:
1444 # line 322 "perly.y"
1445 { yyval.opval = newBINOP(yypvt[-2].ival, OPf_STACKED,
1446                                 ref(scalar(yypvt[-3].opval), yypvt[-2].ival), scalar(yypvt[-0].opval)); } break;
1447 case 65:
1448 # line 325 "perly.y"
1449 { yyval.opval = newLOGOP(OP_ANDASSIGN, 0,
1450                                 ref(scalar(yypvt[-3].opval), OP_ANDASSIGN),
1451                                 newUNOP(OP_SASSIGN, 0, scalar(yypvt[-0].opval))); } break;
1452 case 66:
1453 # line 329 "perly.y"
1454 { yyval.opval = newLOGOP(OP_ORASSIGN, 0,
1455                                 ref(scalar(yypvt[-3].opval), OP_ORASSIGN),
1456                                 newUNOP(OP_SASSIGN, 0, scalar(yypvt[-0].opval))); } break;
1457 case 67:
1458 # line 335 "perly.y"
1459 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1460 case 68:
1461 # line 337 "perly.y"
1462 {   if (yypvt[-1].ival != OP_REPEAT)
1463                                 scalar(yypvt[-2].opval);
1464                             yyval.opval = newBINOP(yypvt[-1].ival, 0, yypvt[-2].opval, scalar(yypvt[-0].opval)); } break;
1465 case 69:
1466 # line 341 "perly.y"
1467 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1468 case 70:
1469 # line 343 "perly.y"
1470 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1471 case 71:
1472 # line 345 "perly.y"
1473 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1474 case 72:
1475 # line 347 "perly.y"
1476 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1477 case 73:
1478 # line 349 "perly.y"
1479 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1480 case 74:
1481 # line 351 "perly.y"
1482 { yyval.opval = newBINOP(yypvt[-1].ival, 0, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval)); } break;
1483 case 75:
1484 # line 353 "perly.y"
1485 { yyval.opval = newRANGE(yypvt[-1].ival, scalar(yypvt[-2].opval), scalar(yypvt[-0].opval));} break;
1486 case 76:
1487 # line 355 "perly.y"
1488 { yyval.opval = newLOGOP(OP_AND, 0, yypvt[-2].opval, yypvt[-0].opval); } break;
1489 case 77:
1490 # line 357 "perly.y"
1491 { yyval.opval = newLOGOP(OP_OR, 0, yypvt[-2].opval, yypvt[-0].opval); } break;
1492 case 78:
1493 # line 359 "perly.y"
1494 { yyval.opval = newCONDOP(0, yypvt[-4].opval, yypvt[-2].opval, yypvt[-0].opval); } break;
1495 case 79:
1496 # line 361 "perly.y"
1497 { yyval.opval = bind_match(yypvt[-1].ival, yypvt[-2].opval, yypvt[-0].opval); } break;
1498 case 80:
1499 # line 363 "perly.y"
1500 { yyval.opval = yypvt[-0].opval; } break;
1501 case 81:
1502 # line 367 "perly.y"
1503 { yyval.opval = newUNOP(OP_NEGATE, 0, scalar(yypvt[-0].opval)); } break;
1504 case 82:
1505 # line 369 "perly.y"
1506 { yyval.opval = yypvt[-0].opval; } break;
1507 case 83:
1508 # line 371 "perly.y"
1509 { yyval.opval = newUNOP(OP_NOT, 0, scalar(yypvt[-0].opval)); } break;
1510 case 84:
1511 # line 373 "perly.y"
1512 { yyval.opval = newUNOP(OP_COMPLEMENT, 0, scalar(yypvt[-0].opval));} break;
1513 case 85:
1514 # line 375 "perly.y"
1515 { yyval.opval = newUNOP(OP_REFGEN, 0, ref(yypvt[-0].opval, OP_REFGEN)); } break;
1516 case 86:
1517 # line 377 "perly.y"
1518 { yyval.opval = newUNOP(OP_POSTINC, 0,
1519                                         ref(scalar(yypvt[-1].opval), OP_POSTINC)); } break;
1520 case 87:
1521 # line 380 "perly.y"
1522 { yyval.opval = newUNOP(OP_POSTDEC, 0,
1523                                         ref(scalar(yypvt[-1].opval), OP_POSTDEC)); } break;
1524 case 88:
1525 # line 383 "perly.y"
1526 { yyval.opval = newUNOP(OP_PREINC, 0,
1527                                         ref(scalar(yypvt[-0].opval), OP_PREINC)); } break;
1528 case 89:
1529 # line 386 "perly.y"
1530 { yyval.opval = newUNOP(OP_PREDEC, 0,
1531                                         ref(scalar(yypvt[-0].opval), OP_PREDEC)); } break;
1532 case 90:
1533 # line 389 "perly.y"
1534 { yyval.opval = localize(yypvt[-0].opval); } break;
1535 case 91:
1536 # line 391 "perly.y"
1537 { yyval.opval = sawparens(yypvt[-1].opval); } break;
1538 case 92:
1539 # line 393 "perly.y"
1540 { yyval.opval = newNULLLIST(); } break;
1541 case 93:
1542 # line 395 "perly.y"
1543 { yyval.opval = newANONLIST(yypvt[-1].opval); } break;
1544 case 94:
1545 # line 397 "perly.y"
1546 { yyval.opval = newANONLIST(Nullop); } break;
1547 case 95:
1548 # line 399 "perly.y"
1549 { yyval.opval = newANONHASH(yypvt[-1].opval); } break;
1550 case 96:
1551 # line 401 "perly.y"
1552 { yyval.opval = newANONHASH(Nullop); } break;
1553 case 97:
1554 # line 403 "perly.y"
1555 { yyval.opval = yypvt[-0].opval; } break;
1556 case 98:
1557 # line 405 "perly.y"
1558 { yyval.opval = yypvt[-0].opval; } break;
1559 case 99:
1560 # line 407 "perly.y"
1561 { yyval.opval = newBINOP(OP_AELEM, 0, oopsAV(yypvt[-3].opval), scalar(yypvt[-1].opval)); } break;
1562 case 100:
1563 # line 409 "perly.y"
1564 { yyval.opval = newBINOP(OP_AELEM, 0,
1565                                         scalar(ref(newAVREF(yypvt[-4].opval),OP_RV2AV)),
1566                                         scalar(yypvt[-1].opval));} break;
1567 case 101:
1568 # line 413 "perly.y"
1569 { yyval.opval = yypvt[-0].opval; } break;
1570 case 102:
1571 # line 415 "perly.y"
1572 { yyval.opval = yypvt[-0].opval; } break;
1573 case 103:
1574 # line 417 "perly.y"
1575 { yyval.opval = newUNOP(OP_AV2ARYLEN, 0, ref(yypvt[-0].opval, OP_AV2ARYLEN));} break;
1576 case 104:
1577 # line 419 "perly.y"
1578 { yyval.opval = newBINOP(OP_HELEM, 0, oopsHV(yypvt[-4].opval), jmaybe(yypvt[-2].opval));
1579                             expect = XOPERATOR; } break;
1580 case 105:
1581 # line 422 "perly.y"
1582 { yyval.opval = newBINOP(OP_HELEM, 0,
1583                                         scalar(ref(newHVREF(yypvt[-5].opval),OP_RV2HV)),
1584                                         jmaybe(yypvt[-2].opval));
1585                             expect = XOPERATOR; } break;
1586 case 106:
1587 # line 427 "perly.y"
1588 { yyval.opval = newSLICEOP(0, yypvt[-1].opval, yypvt[-4].opval); } break;
1589 case 107:
1590 # line 429 "perly.y"
1591 { yyval.opval = newSLICEOP(0, yypvt[-1].opval, Nullop); } break;
1592 case 108:
1593 # line 431 "perly.y"
1594 { yyval.opval = prepend_elem(OP_ASLICE,
1595                                 newOP(OP_PUSHMARK, 0),
1596                                 list(
1597                                     newLISTOP(OP_ASLICE, 0,
1598                                         list(yypvt[-1].opval),
1599                                         ref(yypvt[-3].opval, OP_ASLICE)))); } break;
1600 case 109:
1601 # line 438 "perly.y"
1602 { yyval.opval = prepend_elem(OP_HSLICE,
1603                                 newOP(OP_PUSHMARK, 0),
1604                                 list(
1605                                     newLISTOP(OP_HSLICE, 0,
1606                                         list(yypvt[-2].opval),
1607                                         ref(oopsHV(yypvt[-4].opval), OP_HSLICE))));
1608                             expect = XOPERATOR; } break;
1609 case 110:
1610 # line 446 "perly.y"
1611 { yyval.opval = newBINOP(OP_DELETE, 0, oopsHV(yypvt[-4].opval), jmaybe(yypvt[-2].opval));
1612                             expect = XOPERATOR; } break;
1613 case 111:
1614 # line 449 "perly.y"
1615 { yyval.opval = newBINOP(OP_DELETE, 0, oopsHV(yypvt[-5].opval), jmaybe(yypvt[-3].opval));
1616                             expect = XOPERATOR; } break;
1617 case 112:
1618 # line 452 "perly.y"
1619 { yyval.opval = yypvt[-0].opval; } break;
1620 case 113:
1621 # line 454 "perly.y"
1622 { yyval.opval = newUNOP(OP_ENTERSUBR, 0,
1623                                 scalar(yypvt[-0].opval)); } break;
1624 case 114:
1625 # line 457 "perly.y"
1626 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_STACKED, scalar(yypvt[-2].opval)); } break;
1627 case 115:
1628 # line 459 "perly.y"
1629 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_STACKED,
1630                             list(prepend_elem(OP_LIST, scalar(yypvt[-3].opval), yypvt[-1].opval))); } break;
1631 case 116:
1632 # line 462 "perly.y"
1633 { yyval.opval = newUNOP(OP_DOFILE, 0, scalar(yypvt[-0].opval));
1634                           allgvs = TRUE;} break;
1635 case 117:
1636 # line 465 "perly.y"
1637 { yyval.opval = newUNOP(OP_NULL, OPf_SPECIAL, scope(yypvt[-0].opval)); } break;
1638 case 118:
1639 # line 467 "perly.y"
1640 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1641                             list(prepend_elem(OP_LIST,
1642                                 scalar(newCVREF(scalar(yypvt[-2].opval))), newNULLLIST()))); } break;
1643 case 119:
1644 # line 471 "perly.y"
1645 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1646                             list(prepend_elem(OP_LIST,
1647                                 scalar(newCVREF(scalar(yypvt[-3].opval))),
1648                                 yypvt[-1].opval))); } break;
1649 case 120:
1650 # line 476 "perly.y"
1651 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1652                             list(prepend_elem(OP_LIST,
1653                                 scalar(newCVREF(scalar(yypvt[-2].opval))), newNULLLIST())));} break;
1654 case 121:
1655 # line 480 "perly.y"
1656 { yyval.opval = newUNOP(OP_ENTERSUBR, OPf_SPECIAL|OPf_STACKED,
1657                             list(prepend_elem(OP_LIST,
1658                                 scalar(newCVREF(scalar(yypvt[-3].opval))),
1659                                 yypvt[-1].opval))); } break;
1660 case 122:
1661 # line 485 "perly.y"
1662 { yyval.opval = newOP(yypvt[-0].ival, OPf_SPECIAL); } break;
1663 case 123:
1664 # line 487 "perly.y"
1665 { yyval.opval = newPVOP(yypvt[-1].ival, 0,
1666                                 savestr(SvPVnx(((SVOP*)yypvt[-0].opval)->op_sv)));
1667                             op_free(yypvt[-0].opval); } break;
1668 case 124:
1669 # line 491 "perly.y"
1670 { yyval.opval = newOP(yypvt[-0].ival, 0); } break;
1671 case 125:
1672 # line 493 "perly.y"
1673 { yyval.opval = newUNOP(yypvt[-1].ival, 0, yypvt[-0].opval); } break;
1674 case 126:
1675 # line 495 "perly.y"
1676 { yyval.opval = newUNOP(yypvt[-1].ival, 0, yypvt[-0].opval); } break;
1677 case 127:
1678 # line 497 "perly.y"
1679 { yyval.opval = newOP(yypvt[-0].ival, 0); } break;
1680 case 128:
1681 # line 499 "perly.y"
1682 { yyval.opval = newOP(yypvt[-2].ival, 0); } break;
1683 case 129:
1684 # line 501 "perly.y"
1685 { yyval.opval = newOP(yypvt[-2].ival, OPf_SPECIAL); } break;
1686 case 130:
1687 # line 503 "perly.y"
1688 { yyval.opval = newUNOP(yypvt[-3].ival, 0, yypvt[-1].opval); } break;
1689 case 131:
1690 # line 505 "perly.y"
1691 { yyval.opval = pmruntime(yypvt[-3].opval, yypvt[-1].opval, Nullop); } break;
1692 case 132:
1693 # line 507 "perly.y"
1694 { yyval.opval = pmruntime(yypvt[-5].opval, yypvt[-3].opval, yypvt[-1].opval); } break;
1695 case 135:
1696 # line 513 "perly.y"
1697 { yyval.opval = newNULLLIST(); } break;
1698 case 136:
1699 # line 515 "perly.y"
1700 { yyval.opval = yypvt[-0].opval; } break;
1701 case 137:
1702 # line 519 "perly.y"
1703 { yyval.opval = newCVREF(yypvt[-0].opval); } break;
1704 case 138:
1705 # line 523 "perly.y"
1706 { yyval.opval = newSVREF(yypvt[-0].opval); } break;
1707 case 139:
1708 # line 527 "perly.y"
1709 { yyval.opval = newAVREF(yypvt[-0].opval); } break;
1710 case 140:
1711 # line 531 "perly.y"
1712 { yyval.opval = newHVREF(yypvt[-0].opval); } break;
1713 case 141:
1714 # line 535 "perly.y"
1715 { yyval.opval = newAVREF(yypvt[-0].opval); } break;
1716 case 142:
1717 # line 539 "perly.y"
1718 { yyval.opval = newGVREF(yypvt[-0].opval); } break;
1719 case 143:
1720 # line 543 "perly.y"
1721 { yyval.opval = scalar(yypvt[-0].opval); } break;
1722 case 144:
1723 # line 545 "perly.y"
1724 { yyval.opval = scalar(yypvt[-0].opval); } break;
1725 case 145:
1726 # line 547 "perly.y"
1727 { yyval.opval = scalar(scope(yypvt[-0].opval)); } break;
1728 case 146:
1729 # line 552 "perly.y"
1730 { yyval.ival = 1; } break;
1731 case 147:
1732 # line 554 "perly.y"
1733 { yyval.ival = 0; } break;
1734 case 148:
1735 # line 558 "perly.y"
1736 { yyval.ival = 1; } break;
1737 case 149:
1738 # line 560 "perly.y"
1739 { yyval.ival = 0; } break;
1740 case 150:
1741 # line 564 "perly.y"
1742 { yyval.ival = 1; } break;
1743 case 151:
1744 # line 566 "perly.y"
1745 { yyval.ival = 0; } break;
1746         }
1747         goto yystack;           /* reset registers in driver code */
1748 }