Parallel Makefiles
[perl.git] / perly.c.diff
1 Index: perly.c
2 *** perly.c.old Wed Jun 10 03:48:43 1998
3 --- perly.c     Wed Jun 10 03:55:10 1998
4 ***************
5 *** 7,10 ****
6 --- 7,18 ----
7   #include "perl.h"
8   
9 + #ifdef PERL_OBJECT
10 + static void
11 + Dep(CPerlObj *pPerl)
12 + {
13 +     pPerl->deprecate("\"do\" to call subroutines");
14 + }
15 + #define dep() Dep(this)
16 + #else
17   static void
18   dep(void)
19 ***************
20 *** 12,82 ****
21       deprecate("\"do\" to call subroutines");
22   }
23   
24 ! #line 29 "perly.y"
25 ! typedef union {
26 !     I32       ival;
27 !     char *pval;
28 !     OP *opval;
29 !     GV *gvval;
30 ! } YYSTYPE;
31 ! #line 23 "y.tab.c"
32 ! #define WORD 257
33 ! #define METHOD 258
34 ! #define FUNCMETH 259
35 ! #define THING 260
36 ! #define PMFUNC 261
37 ! #define PRIVATEREF 262
38 ! #define FUNC0SUB 263
39 ! #define UNIOPSUB 264
40 ! #define LSTOPSUB 265
41 ! #define LABEL 266
42 ! #define FORMAT 267
43 ! #define SUB 268
44 ! #define ANONSUB 269
45 ! #define PACKAGE 270
46 ! #define USE 271
47 ! #define WHILE 272
48 ! #define UNTIL 273
49 ! #define IF 274
50 ! #define UNLESS 275
51 ! #define ELSE 276
52 ! #define ELSIF 277
53 ! #define CONTINUE 278
54 ! #define FOR 279
55 ! #define LOOPEX 280
56 ! #define DOTDOT 281
57 ! #define FUNC0 282
58 ! #define FUNC1 283
59 ! #define FUNC 284
60 ! #define UNIOP 285
61 ! #define LSTOP 286
62 ! #define RELOP 287
63 ! #define EQOP 288
64 ! #define MULOP 289
65 ! #define ADDOP 290
66 ! #define DOLSHARP 291
67 ! #define DO 292
68 ! #define HASHBRACK 293
69 ! #define NOAMP 294
70 ! #define LOCAL 295
71 ! #define MY 296
72 ! #define OROP 297
73 ! #define ANDOP 298
74 ! #define NOTOP 299
75 ! #define ASSIGNOP 300
76 ! #define OROR 301
77 ! #define ANDAND 302
78 ! #define BITOROP 303
79 ! #define BITANDOP 304
80 ! #define SHIFTOP 305
81 ! #define MATCHOP 306
82 ! #define UMINUS 307
83 ! #define REFGEN 308
84 ! #define POWOP 309
85 ! #define PREINC 310
86 ! #define PREDEC 311
87 ! #define POSTINC 312
88 ! #define POSTDEC 313
89 ! #define ARROW 314
90   #define YYERRCODE 256
91   short yylhs[] = {                                        -1,
92 --- 20,26 ----
93       deprecate("\"do\" to call subroutines");
94   }
95 + #endif
96   
97 ! #line 16 "perly.c"
98   #define YYERRCODE 256
99   short yylhs[] = {                                        -1,
100 ***************
101 *** 1337,1361 ****
102   int yyerrflag;
103   int yychar;
104 - short *yyssp;
105 - YYSTYPE *yyvsp;
106   YYSTYPE yyval;
107   YYSTYPE yylval;
108 - short yyss[YYSTACKSIZE];
109 - YYSTYPE yyvs[YYSTACKSIZE];
110 - #define yystacksize YYSTACKSIZE
111   #line 635 "perly.y"
112    /* PROGRAM */
113 ! #line 1349 "y.tab.c"
114   #define YYABORT goto yyabort
115   #define YYACCEPT goto yyaccept
116   #define YYERROR goto yyerrlab
117   int
118 ! yyparse()
119   {
120       register int yym, yyn, yystate;
121   #if YYDEBUG
122       register char *yys;
123       extern char *getenv();
124   
125       if (yys = getenv("YYDEBUG"))
126       {
127 --- 1281,1347 ----
128   int yyerrflag;
129   int yychar;
130   YYSTYPE yyval;
131   YYSTYPE yylval;
132   #line 635 "perly.y"
133    /* PROGRAM */
134 ! #line 1349 "perly.c"
135   #define YYABORT goto yyabort
136   #define YYACCEPT goto yyaccept
137   #define YYERROR goto yyerrlab
138
139 + struct ysv {
140 +     short* yyss;
141 +     YYSTYPE* yyvs;
142 +     int oldyydebug;
143 +     int oldyynerrs;
144 +     int oldyyerrflag;
145 +     int oldyychar;
146 +     YYSTYPE oldyyval;
147 +     YYSTYPE oldyylval;
148 + };
149
150 + void
151 + yydestruct(void *ptr)
152 + {
153 +     struct ysv* ysave = (struct ysv*)ptr;
154 +     if (ysave->yyss) Safefree(ysave->yyss);
155 +     if (ysave->yyvs) Safefree(ysave->yyvs);
156 +     yydebug   = ysave->oldyydebug;
157 +     yynerrs   = ysave->oldyynerrs;
158 +     yyerrflag = ysave->oldyyerrflag;
159 +     yychar    = ysave->oldyychar;
160 +     yyval     = ysave->oldyyval;
161 +     yylval    = ysave->oldyylval;
162 +     Safefree(ysave);
163 + }
164
165   int
166 ! yyparse(void)
167   {
168       register int yym, yyn, yystate;
169 +     register short *yyssp;
170 +     register YYSTYPE *yyvsp;
171 +     short* yyss;
172 +     YYSTYPE* yyvs;
173 +     unsigned yystacksize = YYSTACKSIZE;
174 +     int retval = 0;
175   #if YYDEBUG
176       register char *yys;
177 + #ifndef __cplusplus
178       extern char *getenv();
179 + #endif
180 + #endif
181
182 +     struct ysv *ysave;
183 +     New(73, ysave, 1, struct ysv);
184 +     SAVEDESTRUCTOR(yydestruct, ysave);
185 +     ysave->oldyydebug = yydebug;
186 +     ysave->oldyynerrs = yynerrs;
187 +     ysave->oldyyerrflag       = yyerrflag;
188 +     ysave->oldyychar  = yychar;
189 +     ysave->oldyyval   = yyval;
190 +     ysave->oldyylval  = yylval;
191   
192 + #if YYDEBUG
193       if (yys = getenv("YYDEBUG"))
194       {
195 ***************
196 *** 1370,1373 ****
197 --- 1356,1369 ----
198       yychar = (-1);
199   
200 +     /*
201 +     ** Initialize private stacks (yyparse may be called from an action)
202 +     */
203 +     New(73, yyss, yystacksize, short);
204 +     New(73, yyvs, yystacksize, YYSTYPE);
205 +     ysave->yyss = yyss;
206 +     ysave->yyvs = yyvs;
207 +     if (!yyvs || !yyss)
208 +       goto yyoverflow;
209
210       yyssp = yyss;
211       yyvsp = yyvs;
212 ***************
213 *** 1385,1389 ****
214               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
215               if (!yys) yys = "illegal-symbol";
216 !             printf("yydebug: state %d, reading %d (%s)\n", yystate,
217                       yychar, yys);
218           }
219 --- 1381,1385 ----
220               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
221               if (!yys) yys = "illegal-symbol";
222 !             PerlIO_printf(Perl_debug_log, "yydebug: state %d, reading %d (%s)\n", yystate,
223                       yychar, yys);
224           }
225 ***************
226 *** 1395,1404 ****
227   #if YYDEBUG
228           if (yydebug)
229 !             printf("yydebug: state %d, shifting to state %d\n",
230                       yystate, yytable[yyn]);
231   #endif
232           if (yyssp >= yyss + yystacksize - 1)
233           {
234 !             goto yyoverflow;
235           }
236           *++yyssp = yystate = yytable[yyn];
237 --- 1391,1414 ----
238   #if YYDEBUG
239           if (yydebug)
240 !             PerlIO_printf(Perl_debug_log, "yydebug: state %d, shifting to state %d\n",
241                       yystate, yytable[yyn]);
242   #endif
243           if (yyssp >= yyss + yystacksize - 1)
244           {
245 !           /*
246 !           ** reallocate and recover.  Note that pointers
247 !           ** have to be reset, or bad things will happen
248 !           */
249 !           int yyps_index = (yyssp - yyss);
250 !           int yypv_index = (yyvsp - yyvs);
251 !           yystacksize += YYSTACKSIZE;
252 !           ysave->yyvs = yyvs =
253 !               (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
254 !           ysave->yyss = yyss =
255 !               (short*)realloc((char*)yyss,yystacksize * sizeof(short));
256 !           if (!yyvs || !yyss)
257 !               goto yyoverflow;
258 !           yyssp = yyss + yyps_index;
259 !           yyvsp = yyvs + yypv_index;
260           }
261           *++yyssp = yystate = yytable[yyn];
262 ***************
263 *** 1436,1445 ****
264   #if YYDEBUG
265                   if (yydebug)
266 !                     printf("yydebug: state %d, error recovery shifting\
267 !  to state %d\n", *yyssp, yytable[yyn]);
268   #endif
269                   if (yyssp >= yyss + yystacksize - 1)
270                   {
271 !                     goto yyoverflow;
272                   }
273                   *++yyssp = yystate = yytable[yyn];
274 --- 1446,1470 ----
275   #if YYDEBUG
276                   if (yydebug)
277 !                     PerlIO_printf(Perl_debug_log,
278 !                    "yydebug: state %d, error recovery shifting to state %d\n",
279 !                    *yyssp, yytable[yyn]);
280   #endif
281                   if (yyssp >= yyss + yystacksize - 1)
282                   {
283 !                   /*
284 !                   ** reallocate and recover.  Note that pointers
285 !                   ** have to be reset, or bad things will happen
286 !                   */
287 !                   int yyps_index = (yyssp - yyss);
288 !                   int yypv_index = (yyvsp - yyvs);
289 !                   yystacksize += YYSTACKSIZE;
290 !                   ysave->yyvs = yyvs = (YYSTYPE*)realloc((char*)yyvs,
291 !                       yystacksize * sizeof(YYSTYPE));
292 !                   ysave->yyss = yyss = (short*)realloc((char*)yyss,
293 !                       yystacksize * sizeof(short));
294 !                   if (!yyvs || !yyss)
295 !                       goto yyoverflow;
296 !                   yyssp = yyss + yyps_index;
297 !                   yyvsp = yyvs + yypv_index;
298                   }
299                   *++yyssp = yystate = yytable[yyn];
300 ***************
301 *** 1451,1456 ****
302   #if YYDEBUG
303                   if (yydebug)
304 !                     printf("yydebug: error recovery discarding state %d\n",
305 !                             *yyssp);
306   #endif
307                   if (yyssp <= yyss) goto yyabort;
308 --- 1476,1482 ----
309   #if YYDEBUG
310                   if (yydebug)
311 !                     PerlIO_printf(Perl_debug_log,
312 !                       "yydebug: error recovery discarding state %d\n",
313 !                       *yyssp);
314   #endif
315                   if (yyssp <= yyss) goto yyabort;
316 ***************
317 *** 1469,1474 ****
318               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
319               if (!yys) yys = "illegal-symbol";
320 !             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
321 !                     yystate, yychar, yys);
322           }
323   #endif
324 --- 1495,1501 ----
325               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
326               if (!yys) yys = "illegal-symbol";
327 !             PerlIO_printf(Perl_debug_log,
328 !               "yydebug: state %d, error recovery discards token %d (%s)\n",
329 !               yystate, yychar, yys);
330           }
331   #endif
332 ***************
333 *** 1479,1483 ****
334   #if YYDEBUG
335       if (yydebug)
336 !         printf("yydebug: state %d, reducing by rule %d (%s)\n",
337                   yystate, yyn, yyrule[yyn]);
338   #endif
339 --- 1506,1510 ----
340   #if YYDEBUG
341       if (yydebug)
342 !         PerlIO_printf(Perl_debug_log, "yydebug: state %d, reducing by rule %d (%s)\n",
343                   yystate, yyn, yyrule[yyn]);
344   #endif
345 ***************
346 *** 2263,2267 ****
347   { yyval.opval = yyvsp[0].opval; }
348   break;
349 ! #line 2266 "y.tab.c"
350       }
351       yyssp -= yym;
352 --- 2290,2294 ----
353   { yyval.opval = yyvsp[0].opval; }
354   break;
355 ! #line 2266 "perly.c"
356       }
357       yyssp -= yym;
358 ***************
359 *** 2273,2278 ****
360   #if YYDEBUG
361           if (yydebug)
362 !             printf("yydebug: after reduction, shifting from state 0 to\
363 !  state %d\n", YYFINAL);
364   #endif
365           yystate = YYFINAL;
366 --- 2300,2306 ----
367   #if YYDEBUG
368           if (yydebug)
369 !             PerlIO_printf(Perl_debug_log,
370 !               "yydebug: after reduction, shifting from state 0 to state %d\n",
371 !               YYFINAL);
372   #endif
373           yystate = YYFINAL;
374 ***************
375 *** 2288,2292 ****
376                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
377                   if (!yys) yys = "illegal-symbol";
378 !                 printf("yydebug: state %d, reading %d (%s)\n",
379                           YYFINAL, yychar, yys);
380               }
381 --- 2316,2320 ----
382                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
383                   if (!yys) yys = "illegal-symbol";
384 !                 PerlIO_printf(Perl_debug_log, "yydebug: state %d, reading %d (%s)\n",
385                           YYFINAL, yychar, yys);
386               }
387 ***************
388 *** 2303,2312 ****
389   #if YYDEBUG
390       if (yydebug)
391 !         printf("yydebug: after reduction, shifting from state %d \
392 ! to state %d\n", *yyssp, yystate);
393   #endif
394       if (yyssp >= yyss + yystacksize - 1)
395       {
396 !         goto yyoverflow;
397       }
398       *++yyssp = yystate;
399 --- 2331,2355 ----
400   #if YYDEBUG
401       if (yydebug)
402 !         PerlIO_printf(Perl_debug_log,
403 !           "yydebug: after reduction, shifting from state %d to state %d\n",
404 !           *yyssp, yystate);
405   #endif
406       if (yyssp >= yyss + yystacksize - 1)
407       {
408 !       /*
409 !       ** reallocate and recover.  Note that pointers
410 !       ** have to be reset, or bad things will happen
411 !       */
412 !       int yyps_index = (yyssp - yyss);
413 !       int yypv_index = (yyvsp - yyvs);
414 !       yystacksize += YYSTACKSIZE;
415 !       ysave->yyvs = yyvs =
416 !           (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
417 !       ysave->yyss = yyss =
418 !           (short*)realloc((char*)yyss,yystacksize * sizeof(short));
419 !       if (!yyvs || !yyss)
420 !           goto yyoverflow;
421 !       yyssp = yyss + yyps_index;
422 !       yyvsp = yyvs + yypv_index;
423       }
424       *++yyssp = yystate;
425 ***************
426 *** 2314,2321 ****
427       goto yyloop;
428   yyoverflow:
429 !     yyerror("yacc stack overflow");
430   yyabort:
431 !     return (1);
432   yyaccept:
433 !     return (0);
434   }
435 --- 2357,2364 ----
436       goto yyloop;
437   yyoverflow:
438 !     yyerror("Out of memory for yacc stack");
439   yyabort:
440 !     retval = 1;
441   yyaccept:
442 !     return retval;
443   }