Fix AUTOLOAD, or kill me
[perl.git] / perly.c.diff
1 Index: perly.c
2 ***************
3 *** 13,82 ****
4   }
5   
6 ! #line 29 "perly.y"
7 ! typedef union {
8 !     I32       ival;
9 !     char *pval;
10 !     OP *opval;
11 !     GV *gvval;
12 ! } YYSTYPE;
13 ! #line 23 "y.tab.c"
14 ! #define WORD 257
15 ! #define METHOD 258
16 ! #define FUNCMETH 259
17 ! #define THING 260
18 ! #define PMFUNC 261
19 ! #define PRIVATEREF 262
20 ! #define FUNC0SUB 263
21 ! #define UNIOPSUB 264
22 ! #define LSTOPSUB 265
23 ! #define LABEL 266
24 ! #define FORMAT 267
25 ! #define SUB 268
26 ! #define ANONSUB 269
27 ! #define PACKAGE 270
28 ! #define USE 271
29 ! #define WHILE 272
30 ! #define UNTIL 273
31 ! #define IF 274
32 ! #define UNLESS 275
33 ! #define ELSE 276
34 ! #define ELSIF 277
35 ! #define CONTINUE 278
36 ! #define FOR 279
37 ! #define LOOPEX 280
38 ! #define DOTDOT 281
39 ! #define FUNC0 282
40 ! #define FUNC1 283
41 ! #define FUNC 284
42 ! #define UNIOP 285
43 ! #define LSTOP 286
44 ! #define RELOP 287
45 ! #define EQOP 288
46 ! #define MULOP 289
47 ! #define ADDOP 290
48 ! #define DOLSHARP 291
49 ! #define DO 292
50 ! #define HASHBRACK 293
51 ! #define NOAMP 294
52 ! #define LOCAL 295
53 ! #define MY 296
54 ! #define OROP 297
55 ! #define ANDOP 298
56 ! #define NOTOP 299
57 ! #define ASSIGNOP 300
58 ! #define OROR 301
59 ! #define ANDAND 302
60 ! #define BITOROP 303
61 ! #define BITANDOP 304
62 ! #define SHIFTOP 305
63 ! #define MATCHOP 306
64 ! #define UMINUS 307
65 ! #define REFGEN 308
66 ! #define POWOP 309
67 ! #define PREINC 310
68 ! #define PREDEC 311
69 ! #define POSTINC 312
70 ! #define POSTDEC 313
71 ! #define ARROW 314
72   #define YYERRCODE 256
73   short yylhs[] = {                                        -1,
74 --- 13,17 ----
75   }
76   
77 ! #line 16 "perly.c"
78   #define YYERRCODE 256
79   short yylhs[] = {                                        -1,
80 ***************
81 *** 1303,1313 ****
82   int yyerrflag;
83   int yychar;
84 - short *yyssp;
85 - YYSTYPE *yyvsp;
86   YYSTYPE yyval;
87   YYSTYPE yylval;
88 - short yyss[YYSTACKSIZE];
89 - YYSTYPE yyvs[YYSTACKSIZE];
90 - #define yystacksize YYSTACKSIZE
91   #line 624 "perly.y"
92    /* PROGRAM */
93 --- 1238,1243 ----
94 ***************
95 *** 1316,1327 ****
96 --- 1246,1302 ----
97   #define YYACCEPT goto yyaccept
98   #define YYERROR goto yyerrlab
99
100 + struct ysv {
101 +     short* yyss;
102 +     YYSTYPE* yyvs;
103 +     int oldyydebug;
104 +     int oldyynerrs;
105 +     int oldyyerrflag;
106 +     int oldyychar;
107 +     YYSTYPE oldyyval;
108 +     YYSTYPE oldyylval;
109 + };
110
111 + void
112 + yydestruct(ptr)
113 + void* ptr;
114 + {
115 +     struct ysv* ysave = (struct ysv*)ptr;
116 +     if (ysave->yyss) Safefree(ysave->yyss);
117 +     if (ysave->yyvs) Safefree(ysave->yyvs);
118 +     yydebug   = ysave->oldyydebug;
119 +     yynerrs   = ysave->oldyynerrs;
120 +     yyerrflag = ysave->oldyyerrflag;
121 +     yychar    = ysave->oldyychar;
122 +     yyval     = ysave->oldyyval;
123 +     yylval    = ysave->oldyylval;
124 +     Safefree(ysave);
125 + }
126
127   int
128   yyparse()
129   {
130       register int yym, yyn, yystate;
131 +     register short *yyssp;
132 +     register YYSTYPE *yyvsp;
133 +     short* yyss;
134 +     YYSTYPE* yyvs;
135 +     unsigned yystacksize = YYSTACKSIZE;
136 +     int retval = 0;
137   #if YYDEBUG
138       register char *yys;
139       extern char *getenv();
140 + #endif
141
142 +     struct ysv *ysave = (struct ysv*)safemalloc(sizeof(struct ysv));
143 +     SAVEDESTRUCTOR(yydestruct, ysave);
144 +     ysave->oldyydebug = yydebug;
145 +     ysave->oldyynerrs = yynerrs;
146 +     ysave->oldyyerrflag       = yyerrflag;
147 +     ysave->oldyychar  = yychar;
148 +     ysave->oldyyval   = yyval;
149 +     ysave->oldyylval  = yylval;
150   
151 + #if YYDEBUG
152       if (yys = getenv("YYDEBUG"))
153       {
154 ***************
155 *** 1336,1339 ****
156 --- 1311,1322 ----
157       yychar = (-1);
158   
159 +     /*
160 +     ** Initialize private stacks (yyparse may be called from an action)
161 +     */
162 +     ysave->yyss = yyss = (short*)safemalloc(yystacksize*sizeof(short));
163 +     ysave->yyvs = yyvs = (YYSTYPE*)safemalloc(yystacksize*sizeof(YYSTYPE));
164 +     if (!yyvs || !yyss)
165 +       goto yyoverflow;
166
167       yyssp = yyss;
168       yyvsp = yyvs;
169 ***************
170 *** 1351,1355 ****
171               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
172               if (!yys) yys = "illegal-symbol";
173 !             printf("yydebug: state %d, reading %d (%s)\n", yystate,
174                       yychar, yys);
175           }
176 --- 1334,1338 ----
177               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
178               if (!yys) yys = "illegal-symbol";
179 !             fprintf(stderr, "yydebug: state %d, reading %d (%s)\n", yystate,
180                       yychar, yys);
181           }
182 ***************
183 *** 1361,1370 ****
184   #if YYDEBUG
185           if (yydebug)
186 !             printf("yydebug: state %d, shifting to state %d\n",
187                       yystate, yytable[yyn]);
188   #endif
189           if (yyssp >= yyss + yystacksize - 1)
190           {
191 !             goto yyoverflow;
192           }
193           *++yyssp = yystate = yytable[yyn];
194 --- 1344,1367 ----
195   #if YYDEBUG
196           if (yydebug)
197 !             fprintf(stderr, "yydebug: state %d, shifting to state %d\n",
198                       yystate, yytable[yyn]);
199   #endif
200           if (yyssp >= yyss + yystacksize - 1)
201           {
202 !           /*
203 !           ** reallocate and recover.  Note that pointers
204 !           ** have to be reset, or bad things will happen
205 !           */
206 !           int yyps_index = (yyssp - yyss);
207 !           int yypv_index = (yyvsp - yyvs);
208 !           yystacksize += YYSTACKSIZE;
209 !           ysave->yyvs = yyvs =
210 !               (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
211 !           ysave->yyss = yyss =
212 !               (short*)realloc((char*)yyss,yystacksize * sizeof(short));
213 !           if (!yyvs || !yyss)
214 !               goto yyoverflow;
215 !           yyssp = yyss + yyps_index;
216 !           yyvsp = yyvs + yypv_index;
217           }
218           *++yyssp = yystate = yytable[yyn];
219 ***************
220 *** 1402,1411 ****
221   #if YYDEBUG
222                   if (yydebug)
223 !                     printf("yydebug: state %d, error recovery shifting\
224 !  to state %d\n", *yyssp, yytable[yyn]);
225   #endif
226                   if (yyssp >= yyss + yystacksize - 1)
227                   {
228 !                     goto yyoverflow;
229                   }
230                   *++yyssp = yystate = yytable[yyn];
231 --- 1399,1423 ----
232   #if YYDEBUG
233                   if (yydebug)
234 !                     fprintf(stderr,
235 !                    "yydebug: state %d, error recovery shifting to state %d\n",
236 !                    *yyssp, yytable[yyn]);
237   #endif
238                   if (yyssp >= yyss + yystacksize - 1)
239                   {
240 !                   /*
241 !                   ** reallocate and recover.  Note that pointers
242 !                   ** have to be reset, or bad things will happen
243 !                   */
244 !                   int yyps_index = (yyssp - yyss);
245 !                   int yypv_index = (yyvsp - yyvs);
246 !                   yystacksize += YYSTACKSIZE;
247 !                   ysave->yyvs = yyvs = (YYSTYPE*)realloc((char*)yyvs,
248 !                       yystacksize * sizeof(YYSTYPE));
249 !                   ysave->yyss = yyss = (short*)realloc((char*)yyss,
250 !                       yystacksize * sizeof(short));
251 !                   if (!yyvs || !yyss)
252 !                       goto yyoverflow;
253 !                   yyssp = yyss + yyps_index;
254 !                   yyvsp = yyvs + yypv_index;
255                   }
256                   *++yyssp = yystate = yytable[yyn];
257 ***************
258 *** 1417,1422 ****
259   #if YYDEBUG
260                   if (yydebug)
261 !                     printf("yydebug: error recovery discarding state %d\n",
262 !                             *yyssp);
263   #endif
264                   if (yyssp <= yyss) goto yyabort;
265 --- 1429,1435 ----
266   #if YYDEBUG
267                   if (yydebug)
268 !                     fprintf(stderr,
269 !                       "yydebug: error recovery discarding state %d\n",
270 !                       *yyssp);
271   #endif
272                   if (yyssp <= yyss) goto yyabort;
273 ***************
274 *** 1435,1440 ****
275               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
276               if (!yys) yys = "illegal-symbol";
277 !             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
278 !                     yystate, yychar, yys);
279           }
280   #endif
281 --- 1448,1454 ----
282               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
283               if (!yys) yys = "illegal-symbol";
284 !             fprintf(stderr,
285 !               "yydebug: state %d, error recovery discards token %d (%s)\n",
286 !               yystate, yychar, yys);
287           }
288   #endif
289 ***************
290 *** 1445,1449 ****
291   #if YYDEBUG
292       if (yydebug)
293 !         printf("yydebug: state %d, reducing by rule %d (%s)\n",
294                   yystate, yyn, yyrule[yyn]);
295   #endif
296 --- 1459,1463 ----
297   #if YYDEBUG
298       if (yydebug)
299 !         fprintf(stderr, "yydebug: state %d, reducing by rule %d (%s)\n",
300                   yystate, yyn, yyrule[yyn]);
301   #endif
302 ***************
303 *** 2222,2227 ****
304   #if YYDEBUG
305           if (yydebug)
306 !             printf("yydebug: after reduction, shifting from state 0 to\
307 !  state %d\n", YYFINAL);
308   #endif
309           yystate = YYFINAL;
310 --- 2236,2242 ----
311   #if YYDEBUG
312           if (yydebug)
313 !             fprintf(stderr,
314 !               "yydebug: after reduction, shifting from state 0 to state %d\n",
315 !               YYFINAL);
316   #endif
317           yystate = YYFINAL;
318 ***************
319 *** 2237,2241 ****
320                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
321                   if (!yys) yys = "illegal-symbol";
322 !                 printf("yydebug: state %d, reading %d (%s)\n",
323                           YYFINAL, yychar, yys);
324               }
325 --- 2252,2256 ----
326                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
327                   if (!yys) yys = "illegal-symbol";
328 !                 fprintf(stderr, "yydebug: state %d, reading %d (%s)\n",
329                           YYFINAL, yychar, yys);
330               }
331 ***************
332 *** 2252,2261 ****
333   #if YYDEBUG
334       if (yydebug)
335 !         printf("yydebug: after reduction, shifting from state %d \
336 ! to state %d\n", *yyssp, yystate);
337   #endif
338       if (yyssp >= yyss + yystacksize - 1)
339       {
340 !         goto yyoverflow;
341       }
342       *++yyssp = yystate;
343 --- 2267,2291 ----
344   #if YYDEBUG
345       if (yydebug)
346 !         fprintf(stderr,
347 !           "yydebug: after reduction, shifting from state %d to state %d\n",
348 !           *yyssp, yystate);
349   #endif
350       if (yyssp >= yyss + yystacksize - 1)
351       {
352 !       /*
353 !       ** reallocate and recover.  Note that pointers
354 !       ** have to be reset, or bad things will happen
355 !       */
356 !       int yyps_index = (yyssp - yyss);
357 !       int yypv_index = (yyvsp - yyvs);
358 !       yystacksize += YYSTACKSIZE;
359 !       ysave->yyvs = yyvs =
360 !           (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
361 !       ysave->yyss = yyss =
362 !           (short*)realloc((char*)yyss,yystacksize * sizeof(short));
363 !       if (!yyvs || !yyss)
364 !           goto yyoverflow;
365 !       yyssp = yyss + yyps_index;
366 !       yyvsp = yyvs + yypv_index;
367       }
368       *++yyssp = yystate;
369 ***************
370 *** 2263,2270 ****
371       goto yyloop;
372   yyoverflow:
373 !     yyerror("yacc stack overflow");
374   yyabort:
375 !     return (1);
376   yyaccept:
377 !     return (0);
378   }
379 --- 2293,2300 ----
380       goto yyloop;
381   yyoverflow:
382 !     yyerror("Out of memory for yacc stack");
383   yyabort:
384 !     retval = 1;
385   yyaccept:
386 !     return retval;
387   }