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