This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
[MERGE] assorted su signature tweaks
[perl5.git] / perly.y
1 /*    perly.y
2  *
3  *    Copyright (c) 1991-2002, 2003, 2004, 2005, 2006 Larry Wall
4  *    Copyright (c) 2007, 2008, 2009, 2010, 2011 by Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  *
9  */
10
11 /*
12  * 'I see,' laughed Strider.  'I look foul and feel fair.  Is that it?
13  *  All that is gold does not glitter, not all those who wander are lost.'
14  *
15  *     [p.171 of _The Lord of the Rings_, I/x: "Strider"]
16  */
17
18 /*
19  * This file holds the grammar for the Perl language. If edited, you need
20  * to run regen_perly.pl, which re-creates the files perly.h, perly.tab
21  * and perly.act which are derived from this.
22  *
23  * The main job of of this grammar is to call the various newFOO()
24  * functions in op.c to build a syntax tree of OP structs.
25  * It relies on the lexer in toke.c to do the tokenizing.
26  *
27  * Note: due to the way that the cleanup code works WRT to freeing ops on
28  * the parse stack, it is dangerous to assign to the $n variables within
29  * an action.
30  */
31
32 /*  Make the parser re-entrant. */
33
34 %pure-parser
35
36 %start grammar
37
38 %union {
39     I32 ival; /* __DEFAULT__ (marker for regen_perly.pl;
40                                 must always be 1st union member) */
41     char *pval;
42     OP *opval;
43     GV *gvval;
44 }
45
46 %token <ival> GRAMPROG GRAMEXPR GRAMBLOCK GRAMBARESTMT GRAMFULLSTMT GRAMSTMTSEQ GRAMSUBSIGNATURE
47
48 %token <ival> '{' '}' '[' ']' '-' '+' '@' '%' '&' '=' '.'
49
50 %token <opval> BAREWORD METHOD FUNCMETH THING PMFUNC PRIVATEREF QWLIST
51 %token <opval> FUNC0OP FUNC0SUB UNIOPSUB LSTOPSUB
52 %token <opval> PLUGEXPR PLUGSTMT
53 %token <opval> LABEL
54 %token <ival> FORMAT SUB SIGSUB ANONSUB ANON_SIGSUB PACKAGE USE
55 %token <ival> WHILE UNTIL IF UNLESS ELSE ELSIF CONTINUE FOR
56 %token <ival> GIVEN WHEN DEFAULT
57 %token <ival> LOOPEX DOTDOT YADAYADA
58 %token <ival> FUNC0 FUNC1 FUNC UNIOP LSTOP
59 %token <ival> RELOP EQOP MULOP ADDOP
60 %token <ival> DOLSHARP DO HASHBRACK NOAMP
61 %token <ival> LOCAL MY REQUIRE
62 %token <ival> COLONATTR FORMLBRACK FORMRBRACK
63 %token <ival> SUBLEXSTART SUBLEXEND
64
65 %type <ival> grammar remember mremember
66 %type <ival>  startsub startanonsub startformsub
67
68 %type <ival> mintro
69
70 %type <opval> stmtseq fullstmt labfullstmt barestmt block mblock else
71 %type <opval> expr term subscripted scalar ary hsh arylen star amper sideff
72 %type <opval> sliceme kvslice gelem
73 %type <opval> listexpr nexpr texpr iexpr mexpr mnexpr
74 %type <opval> optlistexpr optexpr optrepl indirob listop method
75 %type <opval> formname subname proto cont my_scalar my_var
76 %type <opval> refgen_topic formblock
77 %type <opval> subattrlist myattrlist myattrterm myterm
78 %type <opval> termbinop termunop anonymous termdo
79 %type <ival>  sigslurpsigil
80 %type <opval> sigvarname sigdefault sigscalarelem sigslurpelem
81 %type <opval> sigelem siglist siglistornull subsigguts subsignature optsubsignature
82 %type <opval> subbody optsubbody sigsubbody optsigsubbody
83 %type <opval> formstmtseq formline formarg
84
85 %nonassoc <ival> PREC_LOW
86 %nonassoc LOOPEX
87
88 %left <ival> OROP DOROP
89 %left <ival> ANDOP
90 %right <ival> NOTOP
91 %nonassoc LSTOP LSTOPSUB
92 %left <ival> ','
93 %right <ival> ASSIGNOP
94 %right <ival> '?' ':'
95 %nonassoc DOTDOT
96 %left <ival> OROR DORDOR
97 %left <ival> ANDAND
98 %left <ival> BITOROP
99 %left <ival> BITANDOP
100 %nonassoc EQOP
101 %nonassoc RELOP
102 %nonassoc UNIOP UNIOPSUB
103 %nonassoc REQUIRE
104 %left <ival> SHIFTOP
105 %left ADDOP
106 %left MULOP
107 %left <ival> MATCHOP
108 %right <ival> '!' '~' UMINUS REFGEN
109 %right <ival> POWOP
110 %nonassoc <ival> PREINC PREDEC POSTINC POSTDEC POSTJOIN
111 %left <ival> ARROW
112 %nonassoc <ival> ')'
113 %left <ival> '('
114 %left '[' '{'
115
116 %% /* RULES */
117
118 /* Top-level choice of what kind of thing yyparse was called to parse */
119 grammar :       GRAMPROG
120                         {
121                           parser->expect = XSTATE;
122                           $<ival>$ = 0;
123                         }
124                 remember stmtseq
125                         {
126                           newPROG(block_end($3,$4));
127                           PL_compiling.cop_seq = 0;
128                           $$ = 0;
129                         }
130         |       GRAMEXPR
131                         {
132                           parser->expect = XTERM;
133                           $<ival>$ = 0;
134                         }
135                 optexpr
136                         {
137                           PL_eval_root = $3;
138                           $$ = 0;
139                         }
140         |       GRAMBLOCK
141                         {
142                           parser->expect = XBLOCK;
143                           $<ival>$ = 0;
144                         }
145                 block
146                         {
147                           PL_pad_reset_pending = TRUE;
148                           PL_eval_root = $3;
149                           $$ = 0;
150                           yyunlex();
151                           parser->yychar = yytoken = YYEOF;
152                         }
153         |       GRAMBARESTMT
154                         {
155                           parser->expect = XSTATE;
156                           $<ival>$ = 0;
157                         }
158                 barestmt
159                         {
160                           PL_pad_reset_pending = TRUE;
161                           PL_eval_root = $3;
162                           $$ = 0;
163                           yyunlex();
164                           parser->yychar = yytoken = YYEOF;
165                         }
166         |       GRAMFULLSTMT
167                         {
168                           parser->expect = XSTATE;
169                           $<ival>$ = 0;
170                         }
171                 fullstmt
172                         {
173                           PL_pad_reset_pending = TRUE;
174                           PL_eval_root = $3;
175                           $$ = 0;
176                           yyunlex();
177                           parser->yychar = yytoken = YYEOF;
178                         }
179         |       GRAMSTMTSEQ
180                         {
181                           parser->expect = XSTATE;
182                           $<ival>$ = 0;
183                         }
184                 stmtseq
185                         {
186                           PL_eval_root = $3;
187                           $$ = 0;
188                         }
189         |       GRAMSUBSIGNATURE
190                         {
191                           parser->expect = XSTATE;
192                           $<ival>$ = 0;
193                         }
194                 subsigguts
195                         {
196                           PL_eval_root = $3;
197                           $$ = 0;
198                         }
199         ;
200
201 /* An ordinary block */
202 block   :       '{' remember stmtseq '}'
203                         { if (parser->copline > (line_t)$1)
204                               parser->copline = (line_t)$1;
205                           $$ = block_end($2, $3);
206                         }
207         ;
208
209 /* format body */
210 formblock:      '=' remember ';' FORMRBRACK formstmtseq ';' '.'
211                         { if (parser->copline > (line_t)$1)
212                               parser->copline = (line_t)$1;
213                           $$ = block_end($2, $5);
214                         }
215         ;
216
217 remember:       /* NULL */      /* start a full lexical scope */
218                         { $$ = block_start(TRUE);
219                           parser->parsed_sub = 0; }
220         ;
221
222 mblock  :       '{' mremember stmtseq '}'
223                         { if (parser->copline > (line_t)$1)
224                               parser->copline = (line_t)$1;
225                           $$ = block_end($2, $3);
226                         }
227         ;
228
229 mremember:      /* NULL */      /* start a partial lexical scope */
230                         { $$ = block_start(FALSE);
231                           parser->parsed_sub = 0; }
232         ;
233
234 /* A sequence of statements in the program */
235 stmtseq :       /* NULL */
236                         { $$ = NULL; }
237         |       stmtseq fullstmt
238                         {   $$ = op_append_list(OP_LINESEQ, $1, $2);
239                             PL_pad_reset_pending = TRUE;
240                             if ($1 && $2)
241                                 PL_hints |= HINT_BLOCK_SCOPE;
242                         }
243         ;
244
245 /* A sequence of format lines */
246 formstmtseq:    /* NULL */
247                         { $$ = NULL; }
248         |       formstmtseq formline
249                         {   $$ = op_append_list(OP_LINESEQ, $1, $2);
250                             PL_pad_reset_pending = TRUE;
251                             if ($1 && $2)
252                                 PL_hints |= HINT_BLOCK_SCOPE;
253                         }
254         ;
255
256 /* A statement in the program, including optional labels */
257 fullstmt:       barestmt
258                         {
259                           $$ = $1 ? newSTATEOP(0, NULL, $1) : NULL;
260                         }
261         |       labfullstmt
262                         { $$ = $1; }
263         ;
264
265 labfullstmt:    LABEL barestmt
266                         {
267                           SV *label = cSVOPx_sv($1);
268                           $$ = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
269                                             savepv(SvPVX_const(label)), $2);
270                           op_free($1);
271                         }
272         |       LABEL labfullstmt
273                         {
274                           SV *label = cSVOPx_sv($1);
275                           $$ = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
276                                             savepv(SvPVX_const(label)), $2);
277                           op_free($1);
278                         }
279         ;
280
281 /* A bare statement, lacking label and other aspects of state op */
282 barestmt:       PLUGSTMT
283                         { $$ = $1; }
284         |       FORMAT startformsub formname formblock
285                         {
286                           CV *fmtcv = PL_compcv;
287                           newFORM($2, $3, $4);
288                           $$ = NULL;
289                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
290                               pad_add_weakref(fmtcv);
291                           }
292                           parser->parsed_sub = 1;
293                         }
294         |       SUB subname startsub
295                     /* sub declaration or definition not within scope
296                        of 'use feature "signatures"'*/
297                         {
298                           init_named_cv(PL_compcv, $2);
299                           parser->in_my = 0;
300                           parser->in_my_stash = NULL;
301                         }
302                     proto subattrlist optsubbody
303                         {
304                           SvREFCNT_inc_simple_void(PL_compcv);
305                           $2->op_type == OP_CONST
306                               ? newATTRSUB($3, $2, $5, $6, $7)
307                               : newMYSUB($3, $2, $5, $6, $7)
308                           ;
309                           $$ = NULL;
310                           intro_my();
311                           parser->parsed_sub = 1;
312                         }
313         |       SIGSUB subname startsub
314                     /* sub declaration or definition under 'use feature
315                      * "signatures"'. (Note that a signature isn't
316                      * allowed in a declaration)
317                      */
318                         {
319                           init_named_cv(PL_compcv, $2);
320                           parser->in_my = 0;
321                           parser->in_my_stash = NULL;
322                         }
323                     subattrlist optsigsubbody
324                         {
325                           SvREFCNT_inc_simple_void(PL_compcv);
326                           $2->op_type == OP_CONST
327                               ? newATTRSUB($3, $2, NULL, $5, $6)
328                               : newMYSUB(  $3, $2, NULL, $5, $6)
329                           ;
330                           $$ = NULL;
331                           intro_my();
332                           parser->parsed_sub = 1;
333                         }
334         |       PACKAGE BAREWORD BAREWORD ';'
335                         {
336                           package($3);
337                           if ($2)
338                               package_version($2);
339                           $$ = NULL;
340                         }
341         |       USE startsub
342                         { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
343                 BAREWORD BAREWORD optlistexpr ';'
344                         {
345                           SvREFCNT_inc_simple_void(PL_compcv);
346                           utilize($1, $2, $4, $5, $6);
347                           parser->parsed_sub = 1;
348                           $$ = NULL;
349                         }
350         |       IF '(' remember mexpr ')' mblock else
351                         {
352                           $$ = block_end($3,
353                               newCONDOP(0, $4, op_scope($6), $7));
354                           parser->copline = (line_t)$1;
355                         }
356         |       UNLESS '(' remember mexpr ')' mblock else
357                         {
358                           $$ = block_end($3,
359                               newCONDOP(0, $4, $7, op_scope($6)));
360                           parser->copline = (line_t)$1;
361                         }
362         |       GIVEN '(' remember mexpr ')' mblock
363                         {
364                           $$ = block_end($3, newGIVENOP($4, op_scope($6), 0));
365                           parser->copline = (line_t)$1;
366                         }
367         |       WHEN '(' remember mexpr ')' mblock
368                         { $$ = block_end($3, newWHENOP($4, op_scope($6))); }
369         |       DEFAULT block
370                         { $$ = newWHENOP(0, op_scope($2)); }
371         |       WHILE '(' remember texpr ')' mintro mblock cont
372                         {
373                           $$ = block_end($3,
374                                   newWHILEOP(0, 1, NULL,
375                                       $4, $7, $8, $6));
376                           parser->copline = (line_t)$1;
377                         }
378         |       UNTIL '(' remember iexpr ')' mintro mblock cont
379                         {
380                           $$ = block_end($3,
381                                   newWHILEOP(0, 1, NULL,
382                                       $4, $7, $8, $6));
383                           parser->copline = (line_t)$1;
384                         }
385         |       FOR '(' remember mnexpr ';'
386                         { parser->expect = XTERM; }
387                 texpr ';'
388                         { parser->expect = XTERM; }
389                 mintro mnexpr ')'
390                 mblock
391                         {
392                           OP *initop = $4;
393                           OP *forop = newWHILEOP(0, 1, NULL,
394                                       scalar($7), $13, $11, $10);
395                           if (initop) {
396                               forop = op_prepend_elem(OP_LINESEQ, initop,
397                                   op_append_elem(OP_LINESEQ,
398                                       newOP(OP_UNSTACK, OPf_SPECIAL),
399                                       forop));
400                           }
401                           PL_hints |= HINT_BLOCK_SCOPE;
402                           $$ = block_end($3, forop);
403                           parser->copline = (line_t)$1;
404                         }
405         |       FOR MY remember my_scalar '(' mexpr ')' mblock cont
406                         {
407                           $$ = block_end($3, newFOROP(0, $4, $6, $8, $9));
408                           parser->copline = (line_t)$1;
409                         }
410         |       FOR scalar '(' remember mexpr ')' mblock cont
411                         {
412                           $$ = block_end($4, newFOROP(0,
413                                       op_lvalue($2, OP_ENTERLOOP), $5, $7, $8));
414                           parser->copline = (line_t)$1;
415                         }
416         |       FOR my_refgen remember my_var
417                         { parser->in_my = 0; $<opval>$ = my($4); }
418                 '(' mexpr ')' mblock cont
419                         {
420                           $$ = block_end(
421                                 $3,
422                                 newFOROP(0,
423                                          op_lvalue(
424                                             newUNOP(OP_REFGEN, 0,
425                                                     $<opval>5),
426                                             OP_ENTERLOOP),
427                                          $7, $9, $10)
428                           );
429                           parser->copline = (line_t)$1;
430                         }
431         |       FOR REFGEN refgen_topic '(' remember mexpr ')' mblock cont
432                         {
433                           $$ = block_end($5, newFOROP(
434                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
435                                                      $3),
436                                              OP_ENTERLOOP), $6, $8, $9));
437                           parser->copline = (line_t)$1;
438                         }
439         |       FOR '(' remember mexpr ')' mblock cont
440                         {
441                           $$ = block_end($3,
442                                   newFOROP(0, NULL, $4, $6, $7));
443                           parser->copline = (line_t)$1;
444                         }
445         |       block cont
446                         {
447                           /* a block is a loop that happens once */
448                           $$ = newWHILEOP(0, 1, NULL,
449                                   NULL, $1, $2, 0);
450                         }
451         |       PACKAGE BAREWORD BAREWORD '{' remember
452                         {
453                           package($3);
454                           if ($2) {
455                               package_version($2);
456                           }
457                         }
458                 stmtseq '}'
459                         {
460                           /* a block is a loop that happens once */
461                           $$ = newWHILEOP(0, 1, NULL,
462                                   NULL, block_end($5, $7), NULL, 0);
463                           if (parser->copline > (line_t)$4)
464                               parser->copline = (line_t)$4;
465                         }
466         |       sideff ';'
467                         {
468                           $$ = $1;
469                         }
470         |       YADAYADA ';'
471                         {
472                           $$ = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
473                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
474                         }
475         |       ';'
476                         {
477                           $$ = NULL;
478                           parser->copline = NOLINE;
479                         }
480         ;
481
482 /* Format line */
483 formline:       THING formarg
484                         { OP *list;
485                           if ($2) {
486                               OP *term = $2;
487                               list = op_append_elem(OP_LIST, $1, term);
488                           }
489                           else {
490                               list = $1;
491                           }
492                           if (parser->copline == NOLINE)
493                                parser->copline = CopLINE(PL_curcop)-1;
494                           else parser->copline--;
495                           $$ = newSTATEOP(0, NULL,
496                                           op_convert_list(OP_FORMLINE, 0, list));
497                         }
498         ;
499
500 formarg :       /* NULL */
501                         { $$ = NULL; }
502         |       FORMLBRACK stmtseq FORMRBRACK
503                         { $$ = op_unscope($2); }
504         ;
505
506 /* An expression which may have a side-effect */
507 sideff  :       error
508                         { $$ = NULL; }
509         |       expr
510                         { $$ = $1; }
511         |       expr IF expr
512                         { $$ = newLOGOP(OP_AND, 0, $3, $1); }
513         |       expr UNLESS expr
514                         { $$ = newLOGOP(OP_OR, 0, $3, $1); }
515         |       expr WHILE expr
516                         { $$ = newLOOPOP(OPf_PARENS, 1, scalar($3), $1); }
517         |       expr UNTIL iexpr
518                         { $$ = newLOOPOP(OPf_PARENS, 1, $3, $1); }
519         |       expr FOR expr
520                         { $$ = newFOROP(0, NULL, $3, $1, NULL);
521                           parser->copline = (line_t)$2; }
522         |       expr WHEN expr
523                         { $$ = newWHENOP($3, op_scope($1)); }
524         ;
525
526 /* else and elsif blocks */
527 else    :       /* NULL */
528                         { $$ = NULL; }
529         |       ELSE mblock
530                         {
531                           ($2)->op_flags |= OPf_PARENS;
532                           $$ = op_scope($2);
533                         }
534         |       ELSIF '(' mexpr ')' mblock else
535                         { parser->copline = (line_t)$1;
536                             $$ = newCONDOP(0,
537                                 newSTATEOP(OPf_SPECIAL,NULL,$3),
538                                 op_scope($5), $6);
539                           PL_hints |= HINT_BLOCK_SCOPE;
540                         }
541         ;
542
543 /* Continue blocks */
544 cont    :       /* NULL */
545                         { $$ = NULL; }
546         |       CONTINUE block
547                         { $$ = op_scope($2); }
548         ;
549
550 /* determine whether there are any new my declarations */
551 mintro  :       /* NULL */
552                         { $$ = (PL_min_intro_pending &&
553                             PL_max_intro_pending >=  PL_min_intro_pending);
554                           intro_my(); }
555
556 /* Normal expression */
557 nexpr   :       /* NULL */
558                         { $$ = NULL; }
559         |       sideff
560         ;
561
562 /* Boolean expression */
563 texpr   :       /* NULL means true */
564                         { YYSTYPE tmplval;
565                           (void)scan_num("1", &tmplval);
566                           $$ = tmplval.opval; }
567         |       expr
568         ;
569
570 /* Inverted boolean expression */
571 iexpr   :       expr
572                         { $$ = invert(scalar($1)); }
573         ;
574
575 /* Expression with its own lexical scope */
576 mexpr   :       expr
577                         { $$ = $1; intro_my(); }
578         ;
579
580 mnexpr  :       nexpr
581                         { $$ = $1; intro_my(); }
582         ;
583
584 formname:       BAREWORD        { $$ = $1; }
585         |       /* NULL */      { $$ = NULL; }
586         ;
587
588 startsub:       /* NULL */      /* start a regular subroutine scope */
589                         { $$ = start_subparse(FALSE, 0);
590                             SAVEFREESV(PL_compcv); }
591
592         ;
593
594 startanonsub:   /* NULL */      /* start an anonymous subroutine scope */
595                         { $$ = start_subparse(FALSE, CVf_ANON);
596                             SAVEFREESV(PL_compcv); }
597         ;
598
599 startformsub:   /* NULL */      /* start a format subroutine scope */
600                         { $$ = start_subparse(TRUE, 0);
601                             SAVEFREESV(PL_compcv); }
602         ;
603
604 /* Name of a subroutine - must be a bareword, could be special */
605 subname :       BAREWORD
606         |       PRIVATEREF
607         ;
608
609 /* Subroutine prototype */
610 proto   :       /* NULL */
611                         { $$ = NULL; }
612         |       THING
613         ;
614
615 /* Optional list of subroutine attributes */
616 subattrlist:    /* NULL */
617                         { $$ = NULL; }
618         |       COLONATTR THING
619                         { $$ = $2; }
620         |       COLONATTR
621                         { $$ = NULL; }
622         ;
623
624 /* List of attributes for a "my" variable declaration */
625 myattrlist:     COLONATTR THING
626                         { $$ = $2; }
627         |       COLONATTR
628                         { $$ = NULL; }
629         ;
630
631
632
633 /* --------------------------------------
634  * subroutine signature parsing
635  */
636
637 /* the '' or 'foo' part of a '$' or '@foo' etc signature variable  */
638 sigvarname:     /* NULL */
639                         { parser->in_my = 0; $$ = NULL; }
640         |       PRIVATEREF
641                         { parser->in_my = 0; $$ = $1; }
642         ;
643
644 sigslurpsigil:
645                 '@'
646                         { $$ = '@'; }
647         |       '%'
648                         { $$ = '%'; }
649
650 /* @, %, @foo, %foo */
651 sigslurpelem: sigslurpsigil sigvarname sigdefault/* def only to catch errors */ 
652                         {
653                             I32 sigil   = $1;
654                             OP *var     = $2;
655                             OP *defexpr = $3;
656
657                             if (parser->sig_slurpy)
658                                 yyerror("Multiple slurpy parameters not allowed");
659                             parser->sig_slurpy = (char)sigil;
660
661                             if (defexpr)
662                                 yyerror("A slurpy parameter may not have "
663                                         "a default value");
664
665                             $$ = var ? newSTATEOP(0, NULL, var) : NULL;
666                         }
667         ;
668
669 /* default part of sub signature scalar element: i.e. '= default_expr' */
670 sigdefault:     /* NULL */
671                         { $$ = NULL; }
672         |       ASSIGNOP
673                         { $$ = newOP(OP_NULL, 0); }
674         |       ASSIGNOP term
675                         { $$ = $2; }
676
677
678 /* subroutine signature scalar element: e.g. '$x', '$=', '$x = $default' */
679 sigscalarelem:
680                 '$' sigvarname sigdefault
681                         {
682                             OP *var     = $2;
683                             OP *defexpr = $3;
684
685                             if (parser->sig_slurpy)
686                                 yyerror("Slurpy parameter not last");
687
688                             parser->sig_elems++;
689
690                             if (defexpr) {
691                                 parser->sig_optelems++;
692
693                                 if (   defexpr->op_type == OP_NULL
694                                     && !(defexpr->op_flags & OPf_KIDS))
695                                 {
696                                     /* handle '$=' special case */
697                                     if (var)
698                                         yyerror("Optional parameter "
699                                                     "lacks default expression");
700                                     op_free(defexpr);
701                                 }
702                                 else { 
703                                     /* a normal '=default' expression */ 
704                                     OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
705                                                         defexpr,
706                                                         LINKLIST(defexpr));
707                                     /* re-purpose op_targ to hold @_ index */
708                                     defop->op_targ =
709                                         (PADOFFSET)(parser->sig_elems - 1);
710
711                                     if (var) {
712                                         var->op_flags |= OPf_STACKED;
713                                         (void)op_sibling_splice(var,
714                                                         NULL, 0, defop);
715                                         scalar(defop);
716                                     }
717                                     else
718                                         var = newUNOP(OP_NULL, 0, defop);
719
720                                     LINKLIST(var);
721                                     /* NB: normally the first child of a
722                                      * logop is executed before the logop,
723                                      * and it pushes a boolean result
724                                      * ready for the logop. For ARGDEFELEM,
725                                      * the op itself does the boolean
726                                      * calculation, so set the first op to
727                                      * it instead.
728                                      */
729                                     var->op_next = defop;
730                                     defexpr->op_next = var;
731                                 }
732                             }
733                             else {
734                                 if (parser->sig_optelems)
735                                     yyerror("Mandatory parameter "
736                                             "follows optional parameter");
737                             }
738
739                             $$ = var ? newSTATEOP(0, NULL, var) : NULL;
740                         }
741         ;
742
743
744 /* subroutine signature element: e.g. '$x = $default' or '%h' */
745 sigelem:        sigscalarelem
746                         { parser->in_my = KEY_sigvar; $$ = $1; }
747         |       sigslurpelem
748                         { parser->in_my = KEY_sigvar; $$ = $1; }
749         ;
750
751 /* list of subroutine signature elements */
752 siglist:
753                 siglist ','
754                         { $$ = $1; }
755         |       siglist ',' sigelem
756                         {
757                           $$ = op_append_list(OP_LINESEQ, $1, $3);
758                         }
759         |       sigelem  %prec PREC_LOW
760                         { $$ = $1; }
761         ;
762
763 /* () or (....) */
764 siglistornull:          /* NULL */
765                         { $$ = NULL; }
766         |       siglist
767                         { $$ = $1; }
768
769 /* optional subroutine signature */
770 optsubsignature:        /* NULL */
771                         { $$ = NULL; }
772         |       subsignature
773                         { $$ = $1; }
774
775 /* Subroutine signature */
776 subsignature:   '(' subsigguts ')'
777                         { $$ = $2; }
778
779 subsigguts:
780                         {
781                             ENTER;
782                             SAVEIV(parser->sig_elems);
783                             SAVEIV(parser->sig_optelems);
784                             SAVEI8(parser->sig_slurpy);
785                             parser->sig_elems    = 0;
786                             parser->sig_optelems = 0;
787                             parser->sig_slurpy   = 0;
788                             parser->in_my        = KEY_sigvar;
789                         }
790                 siglistornull
791                         {
792                             OP            *sigops = $2;
793                             struct op_argcheck_aux *aux;
794                             OP            *check;
795
796                             if (!FEATURE_SIGNATURES_IS_ENABLED)
797                                 Perl_croak(aTHX_ "Experimental "
798                                     "subroutine signatures not enabled");
799
800                             /* We shouldn't get here otherwise */
801                             Perl_ck_warner_d(aTHX_
802                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
803                                 "The signatures feature is experimental");
804
805                             aux = (struct op_argcheck_aux*)
806                                     PerlMemShared_malloc(
807                                         sizeof(struct op_argcheck_aux));
808                             aux->params     = parser->sig_elems;
809                             aux->opt_params = parser->sig_optelems;
810                             aux->slurpy     = parser->sig_slurpy;
811                             check = newUNOP_AUX(OP_ARGCHECK, 0, NULL,
812                                             (UNOP_AUX_item *)aux);
813                             sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
814                             sigops = op_prepend_elem(OP_LINESEQ,
815                                                 newSTATEOP(0, NULL, NULL),
816                                                 sigops);
817                             /* a nextstate at the end handles context
818                              * correctly for an empty sub body */
819                             sigops = op_append_elem(OP_LINESEQ,
820                                                 sigops,
821                                                 newSTATEOP(0, NULL, NULL));
822                             /* wrap the list of arg ops in a NULL aux op.
823                               This serves two purposes. First, it makes
824                               the arg list a separate subtree from the
825                               body of the sub, and secondly the null op
826                               may in future be upgraded to an OP_SIGNATURE
827                               when implemented. For now leave it as
828                               ex-argcheck */
829                             $$ = newUNOP_AUX(OP_ARGCHECK, 0, sigops, NULL);
830                             op_null($$);
831
832                             parser->in_my = 0;
833                             /* tell the toker that attrributes can follow
834                              * this sig, but only so that the toker
835                              * can skip through any (illegal) trailing
836                              * attribute text then give a useful error
837                              * message about "attributes before sig",
838                              * rather than falling over ina mess at
839                              * unrecognised syntax.
840                              */
841                             parser->expect = XATTRBLOCK;
842                             parser->sig_seen = TRUE;
843                             LEAVE;
844                         }
845         ;
846
847 /* Optional subroutine body (for named subroutine declaration) */
848 optsubbody:     subbody { $$ = $1; }
849         |       ';'     { $$ = NULL; }
850         ;
851
852
853 /* Subroutine body (without signature) */
854 subbody:        remember  '{' stmtseq '}'
855                         {
856                           if (parser->copline > (line_t)$2)
857                               parser->copline = (line_t)$2;
858                           $$ = block_end($1, $3);
859                         }
860         ;
861
862
863 /* optional [ Subroutine body with optional signature ] (for named
864  * subroutine declaration) */
865 optsigsubbody:  sigsubbody { $$ = $1; }
866         |       ';'        { $$ = NULL; }
867
868 /* Subroutine body with optional signature */
869 sigsubbody:     remember optsubsignature '{' stmtseq '}'
870                         {
871                           if (parser->copline > (line_t)$3)
872                               parser->copline = (line_t)$3;
873                           $$ = block_end($1,
874                                 op_append_list(OP_LINESEQ, $2, $4));
875                         }
876         ;
877
878
879 /* Ordinary expressions; logical combinations */
880 expr    :       expr ANDOP expr
881                         { $$ = newLOGOP(OP_AND, 0, $1, $3); }
882         |       expr OROP expr
883                         { $$ = newLOGOP($2, 0, $1, $3); }
884         |       expr DOROP expr
885                         { $$ = newLOGOP(OP_DOR, 0, $1, $3); }
886         |       listexpr %prec PREC_LOW
887         ;
888
889 /* Expressions are a list of terms joined by commas */
890 listexpr:       listexpr ','
891                         { $$ = $1; }
892         |       listexpr ',' term
893                         {
894                           OP* term = $3;
895                           $$ = op_append_elem(OP_LIST, $1, term);
896                         }
897         |       term %prec PREC_LOW
898         ;
899
900 /* List operators */
901 listop  :       LSTOP indirob listexpr /* map {...} @args or print $fh @args */
902                         { $$ = op_convert_list($1, OPf_STACKED,
903                                 op_prepend_elem(OP_LIST, newGVREF($1,$2), $3) );
904                         }
905         |       FUNC '(' indirob expr ')'      /* print ($fh @args */
906                         { $$ = op_convert_list($1, OPf_STACKED,
907                                 op_prepend_elem(OP_LIST, newGVREF($1,$3), $4) );
908                         }
909         |       term ARROW method '(' optexpr ')' /* $foo->bar(list) */
910                         { $$ = op_convert_list(OP_ENTERSUB, OPf_STACKED,
911                                 op_append_elem(OP_LIST,
912                                     op_prepend_elem(OP_LIST, scalar($1), $5),
913                                     newMETHOP(OP_METHOD, 0, $3)));
914                         }
915         |       term ARROW method                     /* $foo->bar */
916                         { $$ = op_convert_list(OP_ENTERSUB, OPf_STACKED,
917                                 op_append_elem(OP_LIST, scalar($1),
918                                     newMETHOP(OP_METHOD, 0, $3)));
919                         }
920         |       METHOD indirob optlistexpr           /* new Class @args */
921                         { $$ = op_convert_list(OP_ENTERSUB, OPf_STACKED,
922                                 op_append_elem(OP_LIST,
923                                     op_prepend_elem(OP_LIST, $2, $3),
924                                     newMETHOP(OP_METHOD, 0, $1)));
925                         }
926         |       FUNCMETH indirob '(' optexpr ')'    /* method $object (@args) */
927                         { $$ = op_convert_list(OP_ENTERSUB, OPf_STACKED,
928                                 op_append_elem(OP_LIST,
929                                     op_prepend_elem(OP_LIST, $2, $4),
930                                     newMETHOP(OP_METHOD, 0, $1)));
931                         }
932         |       LSTOP optlistexpr                    /* print @args */
933                         { $$ = op_convert_list($1, 0, $2); }
934         |       FUNC '(' optexpr ')'                 /* print (@args) */
935                         { $$ = op_convert_list($1, 0, $3); }
936         |       FUNC SUBLEXSTART optexpr SUBLEXEND          /* uc($arg) from "\U..." */
937                         { $$ = op_convert_list($1, 0, $3); }
938         |       LSTOPSUB startanonsub block /* sub f(&@);   f { foo } ... */
939                         { SvREFCNT_inc_simple_void(PL_compcv);
940                           $<opval>$ = newANONATTRSUB($2, 0, NULL, $3); }
941                     optlistexpr         %prec LSTOP  /* ... @bar */
942                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
943                                  op_append_elem(OP_LIST,
944                                    op_prepend_elem(OP_LIST, $<opval>4, $5), $1));
945                         }
946         ;
947
948 /* Names of methods. May use $object->$methodname */
949 method  :       METHOD
950         |       scalar
951         ;
952
953 /* Some kind of subscripted expression */
954 subscripted:    gelem '{' expr ';' '}'        /* *main::{something} */
955                         /* In this and all the hash accessors, ';' is
956                          * provided by the tokeniser */
957                         { $$ = newBINOP(OP_GELEM, 0, $1, scalar($3)); }
958         |       scalar '[' expr ']'          /* $array[$element] */
959                         { $$ = newBINOP(OP_AELEM, 0, oopsAV($1), scalar($3));
960                         }
961         |       term ARROW '[' expr ']'      /* somearef->[$element] */
962                         { $$ = newBINOP(OP_AELEM, 0,
963                                         ref(newAVREF($1),OP_RV2AV),
964                                         scalar($4));
965                         }
966         |       subscripted '[' expr ']'    /* $foo->[$bar]->[$baz] */
967                         { $$ = newBINOP(OP_AELEM, 0,
968                                         ref(newAVREF($1),OP_RV2AV),
969                                         scalar($3));
970                         }
971         |       scalar '{' expr ';' '}'    /* $foo{bar();} */
972                         { $$ = newBINOP(OP_HELEM, 0, oopsHV($1), jmaybe($3));
973                         }
974         |       term ARROW '{' expr ';' '}' /* somehref->{bar();} */
975                         { $$ = newBINOP(OP_HELEM, 0,
976                                         ref(newHVREF($1),OP_RV2HV),
977                                         jmaybe($4)); }
978         |       subscripted '{' expr ';' '}' /* $foo->[bar]->{baz;} */
979                         { $$ = newBINOP(OP_HELEM, 0,
980                                         ref(newHVREF($1),OP_RV2HV),
981                                         jmaybe($3)); }
982         |       term ARROW '(' ')'          /* $subref->() */
983                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
984                                    newCVREF(0, scalar($1)));
985                           if (parser->expect == XBLOCK)
986                               parser->expect = XOPERATOR;
987                         }
988         |       term ARROW '(' expr ')'     /* $subref->(@args) */
989                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
990                                    op_append_elem(OP_LIST, $4,
991                                        newCVREF(0, scalar($1))));
992                           if (parser->expect == XBLOCK)
993                               parser->expect = XOPERATOR;
994                         }
995
996         |       subscripted '(' expr ')'   /* $foo->{bar}->(@args) */
997                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
998                                    op_append_elem(OP_LIST, $3,
999                                                newCVREF(0, scalar($1))));
1000                           if (parser->expect == XBLOCK)
1001                               parser->expect = XOPERATOR;
1002                         }
1003         |       subscripted '(' ')'        /* $foo->{bar}->() */
1004                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
1005                                    newCVREF(0, scalar($1)));
1006                           if (parser->expect == XBLOCK)
1007                               parser->expect = XOPERATOR;
1008                         }
1009         |       '(' expr ')' '[' expr ']'            /* list slice */
1010                         { $$ = newSLICEOP(0, $5, $2); }
1011         |       QWLIST '[' expr ']'            /* list literal slice */
1012                         { $$ = newSLICEOP(0, $3, $1); }
1013         |       '(' ')' '[' expr ']'                 /* empty list slice! */
1014                         { $$ = newSLICEOP(0, $4, NULL); }
1015     ;
1016
1017 /* Binary operators between terms */
1018 termbinop:      term ASSIGNOP term                     /* $x = $y, $x += $y */
1019                         { $$ = newASSIGNOP(OPf_STACKED, $1, $2, $3); }
1020         |       term POWOP term                        /* $x ** $y */
1021                         { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
1022         |       term MULOP term                        /* $x * $y, $x x $y */
1023                         {   if ($2 != OP_REPEAT)
1024                                 scalar($1);
1025                             $$ = newBINOP($2, 0, $1, scalar($3));
1026                         }
1027         |       term ADDOP term                        /* $x + $y */
1028                         { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
1029         |       term SHIFTOP term                      /* $x >> $y, $x << $y */
1030                         { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
1031         |       term RELOP term                        /* $x > $y, etc. */
1032                         { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
1033         |       term EQOP term                         /* $x == $y, $x eq $y */
1034                         { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
1035         |       term BITANDOP term                     /* $x & $y */
1036                         { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
1037         |       term BITOROP term                      /* $x | $y */
1038                         { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
1039         |       term DOTDOT term                       /* $x..$y, $x...$y */
1040                         { $$ = newRANGE($2, scalar($1), scalar($3)); }
1041         |       term ANDAND term                       /* $x && $y */
1042                         { $$ = newLOGOP(OP_AND, 0, $1, $3); }
1043         |       term OROR term                         /* $x || $y */
1044                         { $$ = newLOGOP(OP_OR, 0, $1, $3); }
1045         |       term DORDOR term                       /* $x // $y */
1046                         { $$ = newLOGOP(OP_DOR, 0, $1, $3); }
1047         |       term MATCHOP term                      /* $x =~ /$y/ */
1048                         { $$ = bind_match($2, $1, $3); }
1049     ;
1050
1051 /* Unary operators and terms */
1052 termunop : '-' term %prec UMINUS                       /* -$x */
1053                         { $$ = newUNOP(OP_NEGATE, 0, scalar($2)); }
1054         |       '+' term %prec UMINUS                  /* +$x */
1055                         { $$ = $2; }
1056
1057         |       '!' term                               /* !$x */
1058                         { $$ = newUNOP(OP_NOT, 0, scalar($2)); }
1059         |       '~' term                               /* ~$x */
1060                         { $$ = newUNOP($1, 0, scalar($2)); }
1061         |       term POSTINC                           /* $x++ */
1062                         { $$ = newUNOP(OP_POSTINC, 0,
1063                                         op_lvalue(scalar($1), OP_POSTINC)); }
1064         |       term POSTDEC                           /* $x-- */
1065                         { $$ = newUNOP(OP_POSTDEC, 0,
1066                                         op_lvalue(scalar($1), OP_POSTDEC));}
1067         |       term POSTJOIN    /* implicit join after interpolated ->@ */
1068                         { $$ = op_convert_list(OP_JOIN, 0,
1069                                        op_append_elem(
1070                                         OP_LIST,
1071                                         newSVREF(scalar(
1072                                             newSVOP(OP_CONST,0,
1073                                                     newSVpvs("\""))
1074                                         )),
1075                                         $1
1076                                        ));
1077                         }
1078         |       PREINC term                            /* ++$x */
1079                         { $$ = newUNOP(OP_PREINC, 0,
1080                                         op_lvalue(scalar($2), OP_PREINC)); }
1081         |       PREDEC term                            /* --$x */
1082                         { $$ = newUNOP(OP_PREDEC, 0,
1083                                         op_lvalue(scalar($2), OP_PREDEC)); }
1084
1085     ;
1086
1087 /* Constructors for anonymous data */
1088 anonymous:      '[' expr ']'
1089                         { $$ = newANONLIST($2); }
1090         |       '[' ']'
1091                         { $$ = newANONLIST(NULL);}
1092         |       HASHBRACK expr ';' '}'  %prec '(' /* { foo => "Bar" } */
1093                         { $$ = newANONHASH($2); }
1094         |       HASHBRACK ';' '}'       %prec '(' /* { } (';' by tokener) */
1095                         { $$ = newANONHASH(NULL); }
1096         |       ANONSUB     startanonsub proto subattrlist subbody    %prec '('
1097                         { SvREFCNT_inc_simple_void(PL_compcv);
1098                           $$ = newANONATTRSUB($2, $3, $4, $5); }
1099         |       ANON_SIGSUB startanonsub subattrlist sigsubbody %prec '('
1100                         { SvREFCNT_inc_simple_void(PL_compcv);
1101                           $$ = newANONATTRSUB($2, NULL, $3, $4); }
1102     ;
1103
1104 /* Things called with "do" */
1105 termdo  :       DO term %prec UNIOP                     /* do $filename */
1106                         { $$ = dofile($2, $1);}
1107         |       DO block        %prec '('               /* do { code */
1108                         { $$ = newUNOP(OP_NULL, OPf_SPECIAL, op_scope($2));}
1109         ;
1110
1111 term    :       termbinop
1112         |       termunop
1113         |       anonymous
1114         |       termdo
1115         |       term '?' term ':' term
1116                         { $$ = newCONDOP(0, $1, $3, $5); }
1117         |       REFGEN term                          /* \$x, \@y, \%z */
1118                         { $$ = newUNOP(OP_REFGEN, 0, $2); }
1119         |       MY REFGEN term
1120                         { $$ = newUNOP(OP_REFGEN, 0, localize($3,1)); }
1121         |       myattrterm      %prec UNIOP
1122                         { $$ = $1; }
1123         |       LOCAL term      %prec UNIOP
1124                         { $$ = localize($2,0); }
1125         |       '(' expr ')'
1126                         { $$ = sawparens($2); }
1127         |       QWLIST
1128                         { $$ = $1; }
1129         |       '(' ')'
1130                         { $$ = sawparens(newNULLLIST()); }
1131         |       scalar  %prec '('
1132                         { $$ = $1; }
1133         |       star    %prec '('
1134                         { $$ = $1; }
1135         |       hsh     %prec '('
1136                         { $$ = $1; }
1137         |       ary     %prec '('
1138                         { $$ = $1; }
1139         |       arylen  %prec '('                    /* $#x, $#{ something } */
1140                         { $$ = newUNOP(OP_AV2ARYLEN, 0, ref($1, OP_AV2ARYLEN));}
1141         |       subscripted
1142                         { $$ = $1; }
1143         |       sliceme '[' expr ']'                     /* array slice */
1144                         { $$ = op_prepend_elem(OP_ASLICE,
1145                                 newOP(OP_PUSHMARK, 0),
1146                                     newLISTOP(OP_ASLICE, 0,
1147                                         list($3),
1148                                         ref($1, OP_ASLICE)));
1149                           if ($$ && $1)
1150                               $$->op_private |=
1151                                   $1->op_private & OPpSLICEWARNING;
1152                         }
1153         |       kvslice '[' expr ']'                 /* array key/value slice */
1154                         { $$ = op_prepend_elem(OP_KVASLICE,
1155                                 newOP(OP_PUSHMARK, 0),
1156                                     newLISTOP(OP_KVASLICE, 0,
1157                                         list($3),
1158                                         ref(oopsAV($1), OP_KVASLICE)));
1159                           if ($$ && $1)
1160                               $$->op_private |=
1161                                   $1->op_private & OPpSLICEWARNING;
1162                         }
1163         |       sliceme '{' expr ';' '}'                 /* @hash{@keys} */
1164                         { $$ = op_prepend_elem(OP_HSLICE,
1165                                 newOP(OP_PUSHMARK, 0),
1166                                     newLISTOP(OP_HSLICE, 0,
1167                                         list($3),
1168                                         ref(oopsHV($1), OP_HSLICE)));
1169                           if ($$ && $1)
1170                               $$->op_private |=
1171                                   $1->op_private & OPpSLICEWARNING;
1172                         }
1173         |       kvslice '{' expr ';' '}'                 /* %hash{@keys} */
1174                         { $$ = op_prepend_elem(OP_KVHSLICE,
1175                                 newOP(OP_PUSHMARK, 0),
1176                                     newLISTOP(OP_KVHSLICE, 0,
1177                                         list($3),
1178                                         ref($1, OP_KVHSLICE)));
1179                           if ($$ && $1)
1180                               $$->op_private |=
1181                                   $1->op_private & OPpSLICEWARNING;
1182                         }
1183         |       THING   %prec '('
1184                         { $$ = $1; }
1185         |       amper                                /* &foo; */
1186                         { $$ = newUNOP(OP_ENTERSUB, 0, scalar($1)); }
1187         |       amper '(' ')'                 /* &foo() or foo() */
1188                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar($1));
1189                         }
1190         |       amper '(' expr ')'          /* &foo(@args) or foo(@args) */
1191                         {
1192                           $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
1193                                 op_append_elem(OP_LIST, $3, scalar($1)));
1194                         }
1195         |       NOAMP subname optlistexpr       /* foo @args (no parens) */
1196                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
1197                             op_append_elem(OP_LIST, $3, scalar($2)));
1198                         }
1199         |       term ARROW '$' '*'
1200                         { $$ = newSVREF($1); }
1201         |       term ARROW '@' '*'
1202                         { $$ = newAVREF($1); }
1203         |       term ARROW '%' '*'
1204                         { $$ = newHVREF($1); }
1205         |       term ARROW '&' '*'
1206                         { $$ = newUNOP(OP_ENTERSUB, 0,
1207                                        scalar(newCVREF($3,$1))); }
1208         |       term ARROW '*' '*'      %prec '('
1209                         { $$ = newGVREF(0,$1); }
1210         |       LOOPEX  /* loop exiting command (goto, last, dump, etc) */
1211                         { $$ = newOP($1, OPf_SPECIAL);
1212                             PL_hints |= HINT_BLOCK_SCOPE; }
1213         |       LOOPEX term
1214                         { $$ = newLOOPEX($1,$2); }
1215         |       NOTOP listexpr                       /* not $foo */
1216                         { $$ = newUNOP(OP_NOT, 0, scalar($2)); }
1217         |       UNIOP                                /* Unary op, $_ implied */
1218                         { $$ = newOP($1, 0); }
1219         |       UNIOP block                          /* eval { foo }* */
1220                         { $$ = newUNOP($1, 0, $2); }
1221         |       UNIOP term                           /* Unary op */
1222                         { $$ = newUNOP($1, 0, $2); }
1223         |       REQUIRE                              /* require, $_ implied */
1224                         { $$ = newOP(OP_REQUIRE, $1 ? OPf_SPECIAL : 0); }
1225         |       REQUIRE term                         /* require Foo */
1226                         { $$ = newUNOP(OP_REQUIRE, $1 ? OPf_SPECIAL : 0, $2); }
1227         |       UNIOPSUB
1228                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar($1)); }
1229         |       UNIOPSUB term                        /* Sub treated as unop */
1230                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
1231                             op_append_elem(OP_LIST, $2, scalar($1))); }
1232         |       FUNC0                                /* Nullary operator */
1233                         { $$ = newOP($1, 0); }
1234         |       FUNC0 '(' ')'
1235                         { $$ = newOP($1, 0);}
1236         |       FUNC0OP       /* Same as above, but op created in toke.c */
1237                         { $$ = $1; }
1238         |       FUNC0OP '(' ')'
1239                         { $$ = $1; }
1240         |       FUNC0SUB                             /* Sub treated as nullop */
1241                         { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar($1)); }
1242         |       FUNC1 '(' ')'                        /* not () */
1243                         { $$ = ($1 == OP_NOT)
1244                           ? newUNOP($1, 0, newSVOP(OP_CONST, 0, newSViv(0)))
1245                           : newOP($1, OPf_SPECIAL); }
1246         |       FUNC1 '(' expr ')'                   /* not($foo) */
1247                         { $$ = newUNOP($1, 0, $3); }
1248         |       PMFUNC /* m//, s///, qr//, tr/// */
1249                         {
1250                             if (   $1->op_type != OP_TRANS
1251                                 && $1->op_type != OP_TRANSR
1252                                 && (((PMOP*)$1)->op_pmflags & PMf_HAS_CV))
1253                             {
1254                                 $<ival>$ = start_subparse(FALSE, CVf_ANON);
1255                                 SAVEFREESV(PL_compcv);
1256                             } else
1257                                 $<ival>$ = 0;
1258                         }
1259                     SUBLEXSTART listexpr optrepl SUBLEXEND
1260                         { $$ = pmruntime($1, $4, $5, 1, $<ival>2); }
1261         |       BAREWORD
1262         |       listop
1263         |       PLUGEXPR
1264         ;
1265
1266 /* "my" declarations, with optional attributes */
1267 myattrterm:     MY myterm myattrlist
1268                         { $$ = my_attrs($2,$3); }
1269         |       MY myterm
1270                         { $$ = localize($2,1); }
1271         |       MY REFGEN myterm myattrlist
1272                         { $$ = newUNOP(OP_REFGEN, 0, my_attrs($3,$4)); }
1273         ;
1274
1275 /* Things that can be "my"'d */
1276 myterm  :       '(' expr ')'
1277                         { $$ = sawparens($2); }
1278         |       '(' ')'
1279                         { $$ = sawparens(newNULLLIST()); }
1280
1281         |       scalar  %prec '('
1282                         { $$ = $1; }
1283         |       hsh     %prec '('
1284                         { $$ = $1; }
1285         |       ary     %prec '('
1286                         { $$ = $1; }
1287         ;
1288
1289 /* Basic list expressions */
1290 optlistexpr:    /* NULL */ %prec PREC_LOW
1291                         { $$ = NULL; }
1292         |       listexpr    %prec PREC_LOW
1293                         { $$ = $1; }
1294         ;
1295
1296 optexpr:        /* NULL */
1297                         { $$ = NULL; }
1298         |       expr
1299                         { $$ = $1; }
1300         ;
1301
1302 optrepl:        /* NULL */
1303                         { $$ = NULL; }
1304         |       '/' expr
1305                         { $$ = $2; }
1306         ;
1307
1308 /* A little bit of trickery to make "for my $foo (@bar)" actually be
1309    lexical */
1310 my_scalar:      scalar
1311                         { parser->in_my = 0; $$ = my($1); }
1312         ;
1313
1314 my_var  :       scalar
1315         |       ary
1316         |       hsh
1317         ;
1318
1319 refgen_topic:   my_var
1320         |       amper
1321         ;
1322
1323 my_refgen:      MY REFGEN
1324         |       REFGEN MY
1325         ;
1326
1327 amper   :       '&' indirob
1328                         { $$ = newCVREF($1,$2); }
1329         ;
1330
1331 scalar  :       '$' indirob
1332                         { $$ = newSVREF($2); }
1333         ;
1334
1335 ary     :       '@' indirob
1336                         { $$ = newAVREF($2);
1337                           if ($$) $$->op_private |= $1;
1338                         }
1339         ;
1340
1341 hsh     :       '%' indirob
1342                         { $$ = newHVREF($2);
1343                           if ($$) $$->op_private |= $1;
1344                         }
1345         ;
1346
1347 arylen  :       DOLSHARP indirob
1348                         { $$ = newAVREF($2); }
1349         |       term ARROW DOLSHARP '*'
1350                         { $$ = newAVREF($1); }
1351         ;
1352
1353 star    :       '*' indirob
1354                         { $$ = newGVREF(0,$2); }
1355         ;
1356
1357 sliceme :       ary
1358         |       term ARROW '@'
1359                         { $$ = newAVREF($1); }
1360         ;
1361
1362 kvslice :       hsh
1363         |       term ARROW '%'
1364                         { $$ = newHVREF($1); }
1365         ;
1366
1367 gelem   :       star
1368         |       term ARROW '*'
1369                         { $$ = newGVREF(0,$1); }
1370         ;
1371
1372 /* Indirect objects */
1373 indirob :       BAREWORD
1374                         { $$ = scalar($1); }
1375         |       scalar %prec PREC_LOW
1376                         { $$ = scalar($1); }
1377         |       block
1378                         { $$ = op_scope($1); }
1379
1380         |       PRIVATEREF
1381                         { $$ = $1; }
1382         ;