Move non-constant folding parts of fold_constants into a separate functions.
[perl.git] / op.c
1 #line 2 "op.c"
2 /*    op.c
3  *
4  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
5  *    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
6  *
7  *    You may distribute under the terms of either the GNU General Public
8  *    License or the Artistic License, as specified in the README file.
9  *
10  */
11
12 /*
13  * 'You see: Mr. Drogo, he married poor Miss Primula Brandybuck.  She was
14  *  our Mr. Bilbo's first cousin on the mother's side (her mother being the
15  *  youngest of the Old Took's daughters); and Mr. Drogo was his second
16  *  cousin.  So Mr. Frodo is his first *and* second cousin, once removed
17  *  either way, as the saying is, if you follow me.'       --the Gaffer
18  *
19  *     [p.23 of _The Lord of the Rings_, I/i: "A Long-Expected Party"]
20  */
21
22 /* This file contains the functions that create, manipulate and optimize
23  * the OP structures that hold a compiled perl program.
24  *
25  * A Perl program is compiled into a tree of OPs. Each op contains
26  * structural pointers (eg to its siblings and the next op in the
27  * execution sequence), a pointer to the function that would execute the
28  * op, plus any data specific to that op. For example, an OP_CONST op
29  * points to the pp_const() function and to an SV containing the constant
30  * value. When pp_const() is executed, its job is to push that SV onto the
31  * stack.
32  *
33  * OPs are mainly created by the newFOO() functions, which are mainly
34  * called from the parser (in perly.y) as the code is parsed. For example
35  * the Perl code $a + $b * $c would cause the equivalent of the following
36  * to be called (oversimplifying a bit):
37  *
38  *  newBINOP(OP_ADD, flags,
39  *      newSVREF($a),
40  *      newBINOP(OP_MULTIPLY, flags, newSVREF($b), newSVREF($c))
41  *  )
42  *
43  * Note that during the build of miniperl, a temporary copy of this file
44  * is made, called opmini.c.
45  */
46
47 /*
48 Perl's compiler is essentially a 3-pass compiler with interleaved phases:
49
50     A bottom-up pass
51     A top-down pass
52     An execution-order pass
53
54 The bottom-up pass is represented by all the "newOP" routines and
55 the ck_ routines.  The bottom-upness is actually driven by yacc.
56 So at the point that a ck_ routine fires, we have no idea what the
57 context is, either upward in the syntax tree, or either forward or
58 backward in the execution order.  (The bottom-up parser builds that
59 part of the execution order it knows about, but if you follow the "next"
60 links around, you'll find it's actually a closed loop through the
61 top level node.)
62
63 Whenever the bottom-up parser gets to a node that supplies context to
64 its components, it invokes that portion of the top-down pass that applies
65 to that part of the subtree (and marks the top node as processed, so
66 if a node further up supplies context, it doesn't have to take the
67 plunge again).  As a particular subcase of this, as the new node is
68 built, it takes all the closed execution loops of its subcomponents
69 and links them into a new closed loop for the higher level node.  But
70 it's still not the real execution order.
71
72 The actual execution order is not known till we get a grammar reduction
73 to a top-level unit like a subroutine or file that will be called by
74 "name" rather than via a "next" pointer.  At that point, we can call
75 into peep() to do that code's portion of the 3rd pass.  It has to be
76 recursive, but it's recursive on basic blocks, not on tree nodes.
77 */
78
79 /* To implement user lexical pragmas, there needs to be a way at run time to
80    get the compile time state of %^H for that block.  Storing %^H in every
81    block (or even COP) would be very expensive, so a different approach is
82    taken.  The (running) state of %^H is serialised into a tree of HE-like
83    structs.  Stores into %^H are chained onto the current leaf as a struct
84    refcounted_he * with the key and the value.  Deletes from %^H are saved
85    with a value of PL_sv_placeholder.  The state of %^H at any point can be
86    turned back into a regular HV by walking back up the tree from that point's
87    leaf, ignoring any key you've already seen (placeholder or not), storing
88    the rest into the HV structure, then removing the placeholders. Hence
89    memory is only used to store the %^H deltas from the enclosing COP, rather
90    than the entire %^H on each COP.
91
92    To cause actions on %^H to write out the serialisation records, it has
93    magic type 'H'. This magic (itself) does nothing, but its presence causes
94    the values to gain magic type 'h', which has entries for set and clear.
95    C<Perl_magic_sethint> updates C<PL_compiling.cop_hints_hash> with a store
96    record, with deletes written by C<Perl_magic_clearhint>. C<SAVEHINTS>
97    saves the current C<PL_compiling.cop_hints_hash> on the save stack, so that
98    it will be correctly restored when any inner compiling scope is exited.
99 */
100
101 #include "EXTERN.h"
102 #define PERL_IN_OP_C
103 #include "perl.h"
104 #include "keywords.h"
105
106 #define CALL_PEEP(o) PL_peepp(aTHX_ o)
107 #define CALL_RPEEP(o) PL_rpeepp(aTHX_ o)
108 #define CALL_OPFREEHOOK(o) if (PL_opfreehook) PL_opfreehook(aTHX_ o)
109
110 #if defined(PL_OP_SLAB_ALLOC)
111
112 #ifdef PERL_DEBUG_READONLY_OPS
113 #  define PERL_SLAB_SIZE 4096
114 #  include <sys/mman.h>
115 #endif
116
117 #ifndef PERL_SLAB_SIZE
118 #define PERL_SLAB_SIZE 2048
119 #endif
120
121 void *
122 Perl_Slab_Alloc(pTHX_ size_t sz)
123 {
124     dVAR;
125     /*
126      * To make incrementing use count easy PL_OpSlab is an I32 *
127      * To make inserting the link to slab PL_OpPtr is I32 **
128      * So compute size in units of sizeof(I32 *) as that is how Pl_OpPtr increments
129      * Add an overhead for pointer to slab and round up as a number of pointers
130      */
131     sz = (sz + 2*sizeof(I32 *) -1)/sizeof(I32 *);
132     if ((PL_OpSpace -= sz) < 0) {
133 #ifdef PERL_DEBUG_READONLY_OPS
134         /* We need to allocate chunk by chunk so that we can control the VM
135            mapping */
136         PL_OpPtr = (I32**) mmap(0, PERL_SLAB_SIZE*sizeof(I32*), PROT_READ|PROT_WRITE,
137                         MAP_ANON|MAP_PRIVATE, -1, 0);
138
139         DEBUG_m(PerlIO_printf(Perl_debug_log, "mapped %lu at %p\n",
140                               (unsigned long) PERL_SLAB_SIZE*sizeof(I32*),
141                               PL_OpPtr));
142         if(PL_OpPtr == MAP_FAILED) {
143             perror("mmap failed");
144             abort();
145         }
146 #else
147
148         PL_OpPtr = (I32 **) PerlMemShared_calloc(PERL_SLAB_SIZE,sizeof(I32*)); 
149 #endif
150         if (!PL_OpPtr) {
151             return NULL;
152         }
153         /* We reserve the 0'th I32 sized chunk as a use count */
154         PL_OpSlab = (I32 *) PL_OpPtr;
155         /* Reduce size by the use count word, and by the size we need.
156          * Latter is to mimic the '-=' in the if() above
157          */
158         PL_OpSpace = PERL_SLAB_SIZE - (sizeof(I32)+sizeof(I32 **)-1)/sizeof(I32 **) - sz;
159         /* Allocation pointer starts at the top.
160            Theory: because we build leaves before trunk allocating at end
161            means that at run time access is cache friendly upward
162          */
163         PL_OpPtr += PERL_SLAB_SIZE;
164
165 #ifdef PERL_DEBUG_READONLY_OPS
166         /* We remember this slab.  */
167         /* This implementation isn't efficient, but it is simple. */
168         PL_slabs = (I32**) realloc(PL_slabs, sizeof(I32**) * (PL_slab_count + 1));
169         PL_slabs[PL_slab_count++] = PL_OpSlab;
170         DEBUG_m(PerlIO_printf(Perl_debug_log, "Allocate %p\n", PL_OpSlab));
171 #endif
172     }
173     assert( PL_OpSpace >= 0 );
174     /* Move the allocation pointer down */
175     PL_OpPtr   -= sz;
176     assert( PL_OpPtr > (I32 **) PL_OpSlab );
177     *PL_OpPtr   = PL_OpSlab;    /* Note which slab it belongs to */
178     (*PL_OpSlab)++;             /* Increment use count of slab */
179     assert( PL_OpPtr+sz <= ((I32 **) PL_OpSlab + PERL_SLAB_SIZE) );
180     assert( *PL_OpSlab > 0 );
181     return (void *)(PL_OpPtr + 1);
182 }
183
184 #ifdef PERL_DEBUG_READONLY_OPS
185 void
186 Perl_pending_Slabs_to_ro(pTHX) {
187     /* Turn all the allocated op slabs read only.  */
188     U32 count = PL_slab_count;
189     I32 **const slabs = PL_slabs;
190
191     /* Reset the array of pending OP slabs, as we're about to turn this lot
192        read only. Also, do it ahead of the loop in case the warn triggers,
193        and a warn handler has an eval */
194
195     PL_slabs = NULL;
196     PL_slab_count = 0;
197
198     /* Force a new slab for any further allocation.  */
199     PL_OpSpace = 0;
200
201     while (count--) {
202         void *const start = slabs[count];
203         const size_t size = PERL_SLAB_SIZE* sizeof(I32*);
204         if(mprotect(start, size, PROT_READ)) {
205             Perl_warn(aTHX_ "mprotect for %p %lu failed with %d",
206                       start, (unsigned long) size, errno);
207         }
208     }
209
210     free(slabs);
211 }
212
213 STATIC void
214 S_Slab_to_rw(pTHX_ void *op)
215 {
216     I32 * const * const ptr = (I32 **) op;
217     I32 * const slab = ptr[-1];
218
219     PERL_ARGS_ASSERT_SLAB_TO_RW;
220
221     assert( ptr-1 > (I32 **) slab );
222     assert( ptr < ( (I32 **) slab + PERL_SLAB_SIZE) );
223     assert( *slab > 0 );
224     if(mprotect(slab, PERL_SLAB_SIZE*sizeof(I32*), PROT_READ|PROT_WRITE)) {
225         Perl_warn(aTHX_ "mprotect RW for %p %lu failed with %d",
226                   slab, (unsigned long) PERL_SLAB_SIZE*sizeof(I32*), errno);
227     }
228 }
229
230 OP *
231 Perl_op_refcnt_inc(pTHX_ OP *o)
232 {
233     if(o) {
234         Slab_to_rw(o);
235         ++o->op_targ;
236     }
237     return o;
238
239 }
240
241 PADOFFSET
242 Perl_op_refcnt_dec(pTHX_ OP *o)
243 {
244     PERL_ARGS_ASSERT_OP_REFCNT_DEC;
245     Slab_to_rw(o);
246     return --o->op_targ;
247 }
248 #else
249 #  define Slab_to_rw(op)
250 #endif
251
252 void
253 Perl_Slab_Free(pTHX_ void *op)
254 {
255     I32 * const * const ptr = (I32 **) op;
256     I32 * const slab = ptr[-1];
257     PERL_ARGS_ASSERT_SLAB_FREE;
258     assert( ptr-1 > (I32 **) slab );
259     assert( ptr < ( (I32 **) slab + PERL_SLAB_SIZE) );
260     assert( *slab > 0 );
261     Slab_to_rw(op);
262     if (--(*slab) == 0) {
263 #  ifdef NETWARE
264 #    define PerlMemShared PerlMem
265 #  endif
266         
267 #ifdef PERL_DEBUG_READONLY_OPS
268         U32 count = PL_slab_count;
269         /* Need to remove this slab from our list of slabs */
270         if (count) {
271             while (count--) {
272                 if (PL_slabs[count] == slab) {
273                     dVAR;
274                     /* Found it. Move the entry at the end to overwrite it.  */
275                     DEBUG_m(PerlIO_printf(Perl_debug_log,
276                                           "Deallocate %p by moving %p from %lu to %lu\n",
277                                           PL_OpSlab,
278                                           PL_slabs[PL_slab_count - 1],
279                                           PL_slab_count, count));
280                     PL_slabs[count] = PL_slabs[--PL_slab_count];
281                     /* Could realloc smaller at this point, but probably not
282                        worth it.  */
283                     if(munmap(slab, PERL_SLAB_SIZE*sizeof(I32*))) {
284                         perror("munmap failed");
285                         abort();
286                     }
287                     break;
288                 }
289             }
290         }
291 #else
292     PerlMemShared_free(slab);
293 #endif
294         if (slab == PL_OpSlab) {
295             PL_OpSpace = 0;
296         }
297     }
298 }
299 #endif
300 /*
301  * In the following definition, the ", (OP*)0" is just to make the compiler
302  * think the expression is of the right type: croak actually does a Siglongjmp.
303  */
304 #define CHECKOP(type,o) \
305     ((PL_op_mask && PL_op_mask[type])                           \
306      ? ( op_free((OP*)o),                                       \
307          Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]),  \
308          (OP*)0 )                                               \
309      : PL_check[type](aTHX_ (OP*)o))
310
311 #define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
312
313 #define CHANGE_TYPE(o,type) \
314     STMT_START {                                \
315         o->op_type = (OPCODE)type;              \
316         o->op_ppaddr = PL_ppaddr[type];         \
317     } STMT_END
318
319 STATIC const char*
320 S_gv_ename(pTHX_ GV *gv)
321 {
322     SV* const tmpsv = sv_newmortal();
323
324     PERL_ARGS_ASSERT_GV_ENAME;
325
326     gv_efullname3(tmpsv, gv, NULL);
327     return SvPV_nolen_const(tmpsv);
328 }
329
330 STATIC OP *
331 S_no_fh_allowed(pTHX_ OP *o)
332 {
333     PERL_ARGS_ASSERT_NO_FH_ALLOWED;
334
335     yyerror(Perl_form(aTHX_ "Missing comma after first argument to %s function",
336                  OP_DESC(o)));
337     return o;
338 }
339
340 STATIC OP *
341 S_too_few_arguments(pTHX_ OP *o, const char *name)
342 {
343     PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS;
344
345     yyerror(Perl_form(aTHX_ "Not enough arguments for %s", name));
346     return o;
347 }
348
349 STATIC OP *
350 S_too_many_arguments(pTHX_ OP *o, const char *name)
351 {
352     PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS;
353
354     yyerror(Perl_form(aTHX_ "Too many arguments for %s", name));
355     return o;
356 }
357
358 STATIC void
359 S_bad_type(pTHX_ I32 n, const char *t, const char *name, const OP *kid)
360 {
361     PERL_ARGS_ASSERT_BAD_TYPE;
362
363     yyerror(Perl_form(aTHX_ "Type of arg %d to %s must be %s (not %s)",
364                  (int)n, name, t, OP_DESC(kid)));
365 }
366
367 STATIC void
368 S_no_bareword_allowed(pTHX_ OP *o)
369 {
370     PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED;
371
372     if (PL_madskills)
373         return;         /* various ok barewords are hidden in extra OP_NULL */
374     qerror(Perl_mess(aTHX_
375                      "Bareword \"%"SVf"\" not allowed while \"strict subs\" in use",
376                      SVfARG(cSVOPo_sv)));
377     o->op_private &= ~OPpCONST_STRICT; /* prevent warning twice about the same OP */
378 }
379
380 /* "register" allocation */
381
382 PADOFFSET
383 Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags)
384 {
385     dVAR;
386     PADOFFSET off;
387     const bool is_our = (PL_parser->in_my == KEY_our);
388
389     PERL_ARGS_ASSERT_ALLOCMY;
390
391     if (flags & ~SVf_UTF8)
392         Perl_croak(aTHX_ "panic: allocmy illegal flag bits 0x%" UVxf,
393                    (UV)flags);
394
395     /* Until we're using the length for real, cross check that we're being
396        told the truth.  */
397     assert(strlen(name) == len);
398
399     /* complain about "my $<special_var>" etc etc */
400     if (len &&
401         !(is_our ||
402           isALPHA(name[1]) ||
403           ((flags & SVf_UTF8) && UTF8_IS_START(name[1])) ||
404           (name[1] == '_' && (*name == '$' || len > 2))))
405     {
406         /* name[2] is true if strlen(name) > 2  */
407         if (!isPRINT(name[1]) || strchr("\t\n\r\f", name[1])) {
408             yyerror(Perl_form(aTHX_ "Can't use global %c^%c%.*s in \"%s\"",
409                               name[0], toCTRL(name[1]), (int)(len - 2), name + 2,
410                               PL_parser->in_my == KEY_state ? "state" : "my"));
411         } else {
412             yyerror(Perl_form(aTHX_ "Can't use global %.*s in \"%s\"", (int) len, name,
413                               PL_parser->in_my == KEY_state ? "state" : "my"));
414         }
415     }
416
417     /* allocate a spare slot and store the name in that slot */
418
419     off = pad_add_name_pvn(name, len,
420                        (is_our ? padadd_OUR :
421                         PL_parser->in_my == KEY_state ? padadd_STATE : 0)
422                             | ( flags & SVf_UTF8 ? SVf_UTF8 : 0 ),
423                     PL_parser->in_my_stash,
424                     (is_our
425                         /* $_ is always in main::, even with our */
426                         ? (PL_curstash && !strEQ(name,"$_") ? PL_curstash : PL_defstash)
427                         : NULL
428                     )
429     );
430     /* anon sub prototypes contains state vars should always be cloned,
431      * otherwise the state var would be shared between anon subs */
432
433     if (PL_parser->in_my == KEY_state && CvANON(PL_compcv))
434         CvCLONE_on(PL_compcv);
435
436     return off;
437 }
438
439 /* free the body of an op without examining its contents.
440  * Always use this rather than FreeOp directly */
441
442 static void
443 S_op_destroy(pTHX_ OP *o)
444 {
445     if (o->op_latefree) {
446         o->op_latefreed = 1;
447         return;
448     }
449     FreeOp(o);
450 }
451
452 #ifdef USE_ITHREADS
453 #  define forget_pmop(a,b)      S_forget_pmop(aTHX_ a,b)
454 #else
455 #  define forget_pmop(a,b)      S_forget_pmop(aTHX_ a)
456 #endif
457
458 /* Destructor */
459
460 void
461 Perl_op_free(pTHX_ OP *o)
462 {
463     dVAR;
464     OPCODE type;
465
466     if (!o)
467         return;
468     if (o->op_latefreed) {
469         if (o->op_latefree)
470             return;
471         goto do_free;
472     }
473
474     type = o->op_type;
475     if (o->op_private & OPpREFCOUNTED) {
476         switch (type) {
477         case OP_LEAVESUB:
478         case OP_LEAVESUBLV:
479         case OP_LEAVEEVAL:
480         case OP_LEAVE:
481         case OP_SCOPE:
482         case OP_LEAVEWRITE:
483             {
484             PADOFFSET refcnt;
485             OP_REFCNT_LOCK;
486             refcnt = OpREFCNT_dec(o);
487             OP_REFCNT_UNLOCK;
488             if (refcnt) {
489                 /* Need to find and remove any pattern match ops from the list
490                    we maintain for reset().  */
491                 find_and_forget_pmops(o);
492                 return;
493             }
494             }
495             break;
496         default:
497             break;
498         }
499     }
500
501     /* Call the op_free hook if it has been set. Do it now so that it's called
502      * at the right time for refcounted ops, but still before all of the kids
503      * are freed. */
504     CALL_OPFREEHOOK(o);
505
506     if (o->op_flags & OPf_KIDS) {
507         register OP *kid, *nextkid;
508         for (kid = cUNOPo->op_first; kid; kid = nextkid) {
509             nextkid = kid->op_sibling; /* Get before next freeing kid */
510             op_free(kid);
511         }
512     }
513
514 #ifdef PERL_DEBUG_READONLY_OPS
515     Slab_to_rw(o);
516 #endif
517
518     /* COP* is not cleared by op_clear() so that we may track line
519      * numbers etc even after null() */
520     if (type == OP_NEXTSTATE || type == OP_DBSTATE
521             || (type == OP_NULL /* the COP might have been null'ed */
522                 && ((OPCODE)o->op_targ == OP_NEXTSTATE
523                     || (OPCODE)o->op_targ == OP_DBSTATE))) {
524         cop_free((COP*)o);
525     }
526
527     if (type == OP_NULL)
528         type = (OPCODE)o->op_targ;
529
530     op_clear(o);
531     if (o->op_latefree) {
532         o->op_latefreed = 1;
533         return;
534     }
535   do_free:
536     FreeOp(o);
537 #ifdef DEBUG_LEAKING_SCALARS
538     if (PL_op == o)
539         PL_op = NULL;
540 #endif
541 }
542
543 void
544 Perl_op_clear(pTHX_ OP *o)
545 {
546
547     dVAR;
548
549     PERL_ARGS_ASSERT_OP_CLEAR;
550
551 #ifdef PERL_MAD
552     mad_free(o->op_madprop);
553     o->op_madprop = 0;
554 #endif    
555
556  retry:
557     switch (o->op_type) {
558     case OP_NULL:       /* Was holding old type, if any. */
559         if (PL_madskills && o->op_targ != OP_NULL) {
560             o->op_type = (Optype)o->op_targ;
561             o->op_targ = 0;
562             goto retry;
563         }
564     case OP_ENTERTRY:
565     case OP_ENTEREVAL:  /* Was holding hints. */
566         o->op_targ = 0;
567         break;
568     default:
569         if (!(o->op_flags & OPf_REF)
570             || (PL_check[o->op_type] != Perl_ck_ftst))
571             break;
572         /* FALL THROUGH */
573     case OP_GVSV:
574     case OP_GV:
575     case OP_AELEMFAST:
576         {
577             GV *gv = (o->op_type == OP_GV || o->op_type == OP_GVSV)
578 #ifdef USE_ITHREADS
579                         && PL_curpad
580 #endif
581                         ? cGVOPo_gv : NULL;
582             /* It's possible during global destruction that the GV is freed
583                before the optree. Whilst the SvREFCNT_inc is happy to bump from
584                0 to 1 on a freed SV, the corresponding SvREFCNT_dec from 1 to 0
585                will trigger an assertion failure, because the entry to sv_clear
586                checks that the scalar is not already freed.  A check of for
587                !SvIS_FREED(gv) turns out to be invalid, because during global
588                destruction the reference count can be forced down to zero
589                (with SVf_BREAK set).  In which case raising to 1 and then
590                dropping to 0 triggers cleanup before it should happen.  I
591                *think* that this might actually be a general, systematic,
592                weakness of the whole idea of SVf_BREAK, in that code *is*
593                allowed to raise and lower references during global destruction,
594                so any *valid* code that happens to do this during global
595                destruction might well trigger premature cleanup.  */
596             bool still_valid = gv && SvREFCNT(gv);
597
598             if (still_valid)
599                 SvREFCNT_inc_simple_void(gv);
600 #ifdef USE_ITHREADS
601             if (cPADOPo->op_padix > 0) {
602                 /* No GvIN_PAD_off(cGVOPo_gv) here, because other references
603                  * may still exist on the pad */
604                 pad_swipe(cPADOPo->op_padix, TRUE);
605                 cPADOPo->op_padix = 0;
606             }
607 #else
608             SvREFCNT_dec(cSVOPo->op_sv);
609             cSVOPo->op_sv = NULL;
610 #endif
611             if (still_valid) {
612                 int try_downgrade = SvREFCNT(gv) == 2;
613                 SvREFCNT_dec(gv);
614                 if (try_downgrade)
615                     gv_try_downgrade(gv);
616             }
617         }
618         break;
619     case OP_METHOD_NAMED:
620     case OP_CONST:
621     case OP_HINTSEVAL:
622         SvREFCNT_dec(cSVOPo->op_sv);
623         cSVOPo->op_sv = NULL;
624 #ifdef USE_ITHREADS
625         /** Bug #15654
626           Even if op_clear does a pad_free for the target of the op,
627           pad_free doesn't actually remove the sv that exists in the pad;
628           instead it lives on. This results in that it could be reused as 
629           a target later on when the pad was reallocated.
630         **/
631         if(o->op_targ) {
632           pad_swipe(o->op_targ,1);
633           o->op_targ = 0;
634         }
635 #endif
636         break;
637     case OP_GOTO:
638     case OP_NEXT:
639     case OP_LAST:
640     case OP_REDO:
641         if (o->op_flags & (OPf_SPECIAL|OPf_STACKED|OPf_KIDS))
642             break;
643         /* FALL THROUGH */
644     case OP_TRANS:
645     case OP_TRANSR:
646         if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
647 #ifdef USE_ITHREADS
648             if (cPADOPo->op_padix > 0) {
649                 pad_swipe(cPADOPo->op_padix, TRUE);
650                 cPADOPo->op_padix = 0;
651             }
652 #else
653             SvREFCNT_dec(cSVOPo->op_sv);
654             cSVOPo->op_sv = NULL;
655 #endif
656         }
657         else {
658             PerlMemShared_free(cPVOPo->op_pv);
659             cPVOPo->op_pv = NULL;
660         }
661         break;
662     case OP_SUBST:
663         op_free(cPMOPo->op_pmreplrootu.op_pmreplroot);
664         goto clear_pmop;
665     case OP_PUSHRE:
666 #ifdef USE_ITHREADS
667         if (cPMOPo->op_pmreplrootu.op_pmtargetoff) {
668             /* No GvIN_PAD_off here, because other references may still
669              * exist on the pad */
670             pad_swipe(cPMOPo->op_pmreplrootu.op_pmtargetoff, TRUE);
671         }
672 #else
673         SvREFCNT_dec(MUTABLE_SV(cPMOPo->op_pmreplrootu.op_pmtargetgv));
674 #endif
675         /* FALL THROUGH */
676     case OP_MATCH:
677     case OP_QR:
678 clear_pmop:
679         forget_pmop(cPMOPo, 1);
680         cPMOPo->op_pmreplrootu.op_pmreplroot = NULL;
681         /* we use the same protection as the "SAFE" version of the PM_ macros
682          * here since sv_clean_all might release some PMOPs
683          * after PL_regex_padav has been cleared
684          * and the clearing of PL_regex_padav needs to
685          * happen before sv_clean_all
686          */
687 #ifdef USE_ITHREADS
688         if(PL_regex_pad) {        /* We could be in destruction */
689             const IV offset = (cPMOPo)->op_pmoffset;
690             ReREFCNT_dec(PM_GETRE(cPMOPo));
691             PL_regex_pad[offset] = &PL_sv_undef;
692             sv_catpvn_nomg(PL_regex_pad[0], (const char *)&offset,
693                            sizeof(offset));
694         }
695 #else
696         ReREFCNT_dec(PM_GETRE(cPMOPo));
697         PM_SETRE(cPMOPo, NULL);
698 #endif
699
700         break;
701     }
702
703     if (o->op_targ > 0) {
704         pad_free(o->op_targ);
705         o->op_targ = 0;
706     }
707 }
708
709 STATIC void
710 S_cop_free(pTHX_ COP* cop)
711 {
712     PERL_ARGS_ASSERT_COP_FREE;
713
714     CopFILE_free(cop);
715     CopSTASH_free(cop);
716     if (! specialWARN(cop->cop_warnings))
717         PerlMemShared_free(cop->cop_warnings);
718     cophh_free(CopHINTHASH_get(cop));
719 }
720
721 STATIC void
722 S_forget_pmop(pTHX_ PMOP *const o
723 #ifdef USE_ITHREADS
724               , U32 flags
725 #endif
726               )
727 {
728     HV * const pmstash = PmopSTASH(o);
729
730     PERL_ARGS_ASSERT_FORGET_PMOP;
731
732     if (pmstash && !SvIS_FREED(pmstash)) {
733         MAGIC * const mg = mg_find((const SV *)pmstash, PERL_MAGIC_symtab);
734         if (mg) {
735             PMOP **const array = (PMOP**) mg->mg_ptr;
736             U32 count = mg->mg_len / sizeof(PMOP**);
737             U32 i = count;
738
739             while (i--) {
740                 if (array[i] == o) {
741                     /* Found it. Move the entry at the end to overwrite it.  */
742                     array[i] = array[--count];
743                     mg->mg_len = count * sizeof(PMOP**);
744                     /* Could realloc smaller at this point always, but probably
745                        not worth it. Probably worth free()ing if we're the
746                        last.  */
747                     if(!count) {
748                         Safefree(mg->mg_ptr);
749                         mg->mg_ptr = NULL;
750                     }
751                     break;
752                 }
753             }
754         }
755     }
756     if (PL_curpm == o) 
757         PL_curpm = NULL;
758 #ifdef USE_ITHREADS
759     if (flags)
760         PmopSTASH_free(o);
761 #endif
762 }
763
764 STATIC void
765 S_find_and_forget_pmops(pTHX_ OP *o)
766 {
767     PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS;
768
769     if (o->op_flags & OPf_KIDS) {
770         OP *kid = cUNOPo->op_first;
771         while (kid) {
772             switch (kid->op_type) {
773             case OP_SUBST:
774             case OP_PUSHRE:
775             case OP_MATCH:
776             case OP_QR:
777                 forget_pmop((PMOP*)kid, 0);
778             }
779             find_and_forget_pmops(kid);
780             kid = kid->op_sibling;
781         }
782     }
783 }
784
785 void
786 Perl_op_null(pTHX_ OP *o)
787 {
788     dVAR;
789
790     PERL_ARGS_ASSERT_OP_NULL;
791
792     if (o->op_type == OP_NULL)
793         return;
794     if (!PL_madskills)
795         op_clear(o);
796     o->op_targ = o->op_type;
797     o->op_type = OP_NULL;
798     o->op_ppaddr = PL_ppaddr[OP_NULL];
799 }
800
801 void
802 Perl_op_refcnt_lock(pTHX)
803 {
804     dVAR;
805     PERL_UNUSED_CONTEXT;
806     OP_REFCNT_LOCK;
807 }
808
809 void
810 Perl_op_refcnt_unlock(pTHX)
811 {
812     dVAR;
813     PERL_UNUSED_CONTEXT;
814     OP_REFCNT_UNLOCK;
815 }
816
817 /* Contextualizers */
818
819 /*
820 =for apidoc Am|OP *|op_contextualize|OP *o|I32 context
821
822 Applies a syntactic context to an op tree representing an expression.
823 I<o> is the op tree, and I<context> must be C<G_SCALAR>, C<G_ARRAY>,
824 or C<G_VOID> to specify the context to apply.  The modified op tree
825 is returned.
826
827 =cut
828 */
829
830 OP *
831 Perl_op_contextualize(pTHX_ OP *o, I32 context)
832 {
833     PERL_ARGS_ASSERT_OP_CONTEXTUALIZE;
834     switch (context) {
835         case G_SCALAR: return scalar(o);
836         case G_ARRAY:  return list(o);
837         case G_VOID:   return scalarvoid(o);
838         default:
839             Perl_croak(aTHX_ "panic: op_contextualize bad context");
840             return o;
841     }
842 }
843
844 /*
845 =head1 Optree Manipulation Functions
846
847 =for apidoc Am|OP*|op_linklist|OP *o
848 This function is the implementation of the L</LINKLIST> macro. It should
849 not be called directly.
850
851 =cut
852 */
853
854 OP *
855 Perl_op_linklist(pTHX_ OP *o)
856 {
857     OP *first;
858
859     PERL_ARGS_ASSERT_OP_LINKLIST;
860
861     if (o->op_next)
862         return o->op_next;
863
864     /* establish postfix order */
865     first = cUNOPo->op_first;
866     if (first) {
867         register OP *kid;
868         o->op_next = LINKLIST(first);
869         kid = first;
870         for (;;) {
871             if (kid->op_sibling) {
872                 kid->op_next = LINKLIST(kid->op_sibling);
873                 kid = kid->op_sibling;
874             } else {
875                 kid->op_next = o;
876                 break;
877             }
878         }
879     }
880     else
881         o->op_next = o;
882
883     return o->op_next;
884 }
885
886 static OP *
887 S_scalarkids(pTHX_ OP *o)
888 {
889     if (o && o->op_flags & OPf_KIDS) {
890         OP *kid;
891         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
892             scalar(kid);
893     }
894     return o;
895 }
896
897 STATIC OP *
898 S_scalarboolean(pTHX_ OP *o)
899 {
900     dVAR;
901
902     PERL_ARGS_ASSERT_SCALARBOOLEAN;
903
904     if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST
905      && !(cBINOPo->op_first->op_flags & OPf_SPECIAL)) {
906         if (ckWARN(WARN_SYNTAX)) {
907             const line_t oldline = CopLINE(PL_curcop);
908
909             if (PL_parser && PL_parser->copline != NOLINE)
910                 CopLINE_set(PL_curcop, PL_parser->copline);
911             Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Found = in conditional, should be ==");
912             CopLINE_set(PL_curcop, oldline);
913         }
914     }
915     return scalar(o);
916 }
917
918 OP *
919 Perl_scalar(pTHX_ OP *o)
920 {
921     dVAR;
922     OP *kid;
923
924     /* assumes no premature commitment */
925     if (!o || (PL_parser && PL_parser->error_count)
926          || (o->op_flags & OPf_WANT)
927          || o->op_type == OP_RETURN)
928     {
929         return o;
930     }
931
932     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_SCALAR;
933
934     switch (o->op_type) {
935     case OP_REPEAT:
936         scalar(cBINOPo->op_first);
937         break;
938     case OP_OR:
939     case OP_AND:
940     case OP_COND_EXPR:
941         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
942             scalar(kid);
943         break;
944         /* FALL THROUGH */
945     case OP_SPLIT:
946     case OP_MATCH:
947     case OP_QR:
948     case OP_SUBST:
949     case OP_NULL:
950     default:
951         if (o->op_flags & OPf_KIDS) {
952             for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
953                 scalar(kid);
954         }
955         break;
956     case OP_LEAVE:
957     case OP_LEAVETRY:
958         kid = cLISTOPo->op_first;
959         scalar(kid);
960         kid = kid->op_sibling;
961     do_kids:
962         while (kid) {
963             OP *sib = kid->op_sibling;
964             if (sib && kid->op_type != OP_LEAVEWHEN)
965                 scalarvoid(kid);
966             else
967                 scalar(kid);
968             kid = sib;
969         }
970         PL_curcop = &PL_compiling;
971         break;
972     case OP_SCOPE:
973     case OP_LINESEQ:
974     case OP_LIST:
975         kid = cLISTOPo->op_first;
976         goto do_kids;
977     case OP_SORT:
978         Perl_ck_warner(aTHX_ packWARN(WARN_VOID), "Useless use of sort in scalar context");
979         break;
980     }
981     return o;
982 }
983
984 OP *
985 Perl_scalarvoid(pTHX_ OP *o)
986 {
987     dVAR;
988     OP *kid;
989     const char* useless = NULL;
990     SV* sv;
991     U8 want;
992
993     PERL_ARGS_ASSERT_SCALARVOID;
994
995     /* trailing mad null ops don't count as "there" for void processing */
996     if (PL_madskills &&
997         o->op_type != OP_NULL &&
998         o->op_sibling &&
999         o->op_sibling->op_type == OP_NULL)
1000     {
1001         OP *sib;
1002         for (sib = o->op_sibling;
1003                 sib && sib->op_type == OP_NULL;
1004                 sib = sib->op_sibling) ;
1005         
1006         if (!sib)
1007             return o;
1008     }
1009
1010     if (o->op_type == OP_NEXTSTATE
1011         || o->op_type == OP_DBSTATE
1012         || (o->op_type == OP_NULL && (o->op_targ == OP_NEXTSTATE
1013                                       || o->op_targ == OP_DBSTATE)))
1014         PL_curcop = (COP*)o;            /* for warning below */
1015
1016     /* assumes no premature commitment */
1017     want = o->op_flags & OPf_WANT;
1018     if ((want && want != OPf_WANT_SCALAR)
1019          || (PL_parser && PL_parser->error_count)
1020          || o->op_type == OP_RETURN || o->op_type == OP_REQUIRE || o->op_type == OP_LEAVEWHEN)
1021     {
1022         return o;
1023     }
1024
1025     if ((o->op_private & OPpTARGET_MY)
1026         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1027     {
1028         return scalar(o);                       /* As if inside SASSIGN */
1029     }
1030
1031     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
1032
1033     switch (o->op_type) {
1034     default:
1035         if (!(PL_opargs[o->op_type] & OA_FOLDCONST))
1036             break;
1037         /* FALL THROUGH */
1038     case OP_REPEAT:
1039         if (o->op_flags & OPf_STACKED)
1040             break;
1041         goto func_ops;
1042     case OP_SUBSTR:
1043         if (o->op_private == 4)
1044             break;
1045         /* FALL THROUGH */
1046     case OP_GVSV:
1047     case OP_WANTARRAY:
1048     case OP_GV:
1049     case OP_SMARTMATCH:
1050     case OP_PADSV:
1051     case OP_PADAV:
1052     case OP_PADHV:
1053     case OP_PADANY:
1054     case OP_AV2ARYLEN:
1055     case OP_REF:
1056     case OP_REFGEN:
1057     case OP_SREFGEN:
1058     case OP_DEFINED:
1059     case OP_HEX:
1060     case OP_OCT:
1061     case OP_LENGTH:
1062     case OP_VEC:
1063     case OP_INDEX:
1064     case OP_RINDEX:
1065     case OP_SPRINTF:
1066     case OP_AELEM:
1067     case OP_AELEMFAST:
1068     case OP_AELEMFAST_LEX:
1069     case OP_ASLICE:
1070     case OP_HELEM:
1071     case OP_HSLICE:
1072     case OP_UNPACK:
1073     case OP_PACK:
1074     case OP_JOIN:
1075     case OP_LSLICE:
1076     case OP_ANONLIST:
1077     case OP_ANONHASH:
1078     case OP_SORT:
1079     case OP_REVERSE:
1080     case OP_RANGE:
1081     case OP_FLIP:
1082     case OP_FLOP:
1083     case OP_CALLER:
1084     case OP_FILENO:
1085     case OP_EOF:
1086     case OP_TELL:
1087     case OP_GETSOCKNAME:
1088     case OP_GETPEERNAME:
1089     case OP_READLINK:
1090     case OP_TELLDIR:
1091     case OP_GETPPID:
1092     case OP_GETPGRP:
1093     case OP_GETPRIORITY:
1094     case OP_TIME:
1095     case OP_TMS:
1096     case OP_LOCALTIME:
1097     case OP_GMTIME:
1098     case OP_GHBYNAME:
1099     case OP_GHBYADDR:
1100     case OP_GHOSTENT:
1101     case OP_GNBYNAME:
1102     case OP_GNBYADDR:
1103     case OP_GNETENT:
1104     case OP_GPBYNAME:
1105     case OP_GPBYNUMBER:
1106     case OP_GPROTOENT:
1107     case OP_GSBYNAME:
1108     case OP_GSBYPORT:
1109     case OP_GSERVENT:
1110     case OP_GPWNAM:
1111     case OP_GPWUID:
1112     case OP_GGRNAM:
1113     case OP_GGRGID:
1114     case OP_GETLOGIN:
1115     case OP_PROTOTYPE:
1116       func_ops:
1117         if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)))
1118             /* Otherwise it's "Useless use of grep iterator" */
1119             useless = OP_DESC(o);
1120         break;
1121
1122     case OP_SPLIT:
1123         kid = cLISTOPo->op_first;
1124         if (kid && kid->op_type == OP_PUSHRE
1125 #ifdef USE_ITHREADS
1126                 && !((PMOP*)kid)->op_pmreplrootu.op_pmtargetoff)
1127 #else
1128                 && !((PMOP*)kid)->op_pmreplrootu.op_pmtargetgv)
1129 #endif
1130             useless = OP_DESC(o);
1131         break;
1132
1133     case OP_NOT:
1134        kid = cUNOPo->op_first;
1135        if (kid->op_type != OP_MATCH && kid->op_type != OP_SUBST &&
1136            kid->op_type != OP_TRANS && kid->op_type != OP_TRANSR) {
1137                 goto func_ops;
1138        }
1139        useless = "negative pattern binding (!~)";
1140        break;
1141
1142     case OP_SUBST:
1143         if (cPMOPo->op_pmflags & PMf_NONDESTRUCT)
1144             useless = "non-destructive substitution (s///r)";
1145         break;
1146
1147     case OP_TRANSR:
1148         useless = "non-destructive transliteration (tr///r)";
1149         break;
1150
1151     case OP_RV2GV:
1152     case OP_RV2SV:
1153     case OP_RV2AV:
1154     case OP_RV2HV:
1155         if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)) &&
1156                 (!o->op_sibling || o->op_sibling->op_type != OP_READLINE))
1157             useless = "a variable";
1158         break;
1159
1160     case OP_CONST:
1161         sv = cSVOPo_sv;
1162         if (cSVOPo->op_private & OPpCONST_STRICT)
1163             no_bareword_allowed(o);
1164         else {
1165             if (ckWARN(WARN_VOID)) {
1166                 if (SvOK(sv)) {
1167                     SV* msv = sv_2mortal(Perl_newSVpvf(aTHX_
1168                                 "a constant (%"SVf")", sv));
1169                     useless = SvPV_nolen(msv);
1170                 }
1171                 else
1172                     useless = "a constant (undef)";
1173                 if (o->op_private & OPpCONST_ARYBASE)
1174                     useless = NULL;
1175                 /* don't warn on optimised away booleans, eg 
1176                  * use constant Foo, 5; Foo || print; */
1177                 if (cSVOPo->op_private & OPpCONST_SHORTCIRCUIT)
1178                     useless = NULL;
1179                 /* the constants 0 and 1 are permitted as they are
1180                    conventionally used as dummies in constructs like
1181                         1 while some_condition_with_side_effects;  */
1182                 else if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
1183                     useless = NULL;
1184                 else if (SvPOK(sv)) {
1185                   /* perl4's way of mixing documentation and code
1186                      (before the invention of POD) was based on a
1187                      trick to mix nroff and perl code. The trick was
1188                      built upon these three nroff macros being used in
1189                      void context. The pink camel has the details in
1190                      the script wrapman near page 319. */
1191                     const char * const maybe_macro = SvPVX_const(sv);
1192                     if (strnEQ(maybe_macro, "di", 2) ||
1193                         strnEQ(maybe_macro, "ds", 2) ||
1194                         strnEQ(maybe_macro, "ig", 2))
1195                             useless = NULL;
1196                 }
1197             }
1198         }
1199         op_null(o);             /* don't execute or even remember it */
1200         break;
1201
1202     case OP_POSTINC:
1203         o->op_type = OP_PREINC;         /* pre-increment is faster */
1204         o->op_ppaddr = PL_ppaddr[OP_PREINC];
1205         break;
1206
1207     case OP_POSTDEC:
1208         o->op_type = OP_PREDEC;         /* pre-decrement is faster */
1209         o->op_ppaddr = PL_ppaddr[OP_PREDEC];
1210         break;
1211
1212     case OP_I_POSTINC:
1213         o->op_type = OP_I_PREINC;       /* pre-increment is faster */
1214         o->op_ppaddr = PL_ppaddr[OP_I_PREINC];
1215         break;
1216
1217     case OP_I_POSTDEC:
1218         o->op_type = OP_I_PREDEC;       /* pre-decrement is faster */
1219         o->op_ppaddr = PL_ppaddr[OP_I_PREDEC];
1220         break;
1221
1222     case OP_SASSIGN: {
1223         OP *rv2gv;
1224         UNOP *refgen, *rv2cv;
1225         LISTOP *exlist;
1226
1227         if ((o->op_private & ~OPpASSIGN_BACKWARDS) != 2)
1228             break;
1229
1230         rv2gv = ((BINOP *)o)->op_last;
1231         if (!rv2gv || rv2gv->op_type != OP_RV2GV)
1232             break;
1233
1234         refgen = (UNOP *)((BINOP *)o)->op_first;
1235
1236         if (!refgen || refgen->op_type != OP_REFGEN)
1237             break;
1238
1239         exlist = (LISTOP *)refgen->op_first;
1240         if (!exlist || exlist->op_type != OP_NULL
1241             || exlist->op_targ != OP_LIST)
1242             break;
1243
1244         if (exlist->op_first->op_type != OP_PUSHMARK)
1245             break;
1246
1247         rv2cv = (UNOP*)exlist->op_last;
1248
1249         if (rv2cv->op_type != OP_RV2CV)
1250             break;
1251
1252         assert ((rv2gv->op_private & OPpDONT_INIT_GV) == 0);
1253         assert ((o->op_private & OPpASSIGN_CV_TO_GV) == 0);
1254         assert ((rv2cv->op_private & OPpMAY_RETURN_CONSTANT) == 0);
1255
1256         o->op_private |= OPpASSIGN_CV_TO_GV;
1257         rv2gv->op_private |= OPpDONT_INIT_GV;
1258         rv2cv->op_private |= OPpMAY_RETURN_CONSTANT;
1259
1260         break;
1261     }
1262
1263     case OP_AASSIGN: {
1264         inplace_aassign(o);
1265         break;
1266     }
1267
1268     case OP_OR:
1269     case OP_AND:
1270         kid = cLOGOPo->op_first;
1271         if (kid->op_type == OP_NOT
1272             && (kid->op_flags & OPf_KIDS)
1273             && !PL_madskills) {
1274             if (o->op_type == OP_AND) {
1275                 o->op_type = OP_OR;
1276                 o->op_ppaddr = PL_ppaddr[OP_OR];
1277             } else {
1278                 o->op_type = OP_AND;
1279                 o->op_ppaddr = PL_ppaddr[OP_AND];
1280             }
1281             op_null(kid);
1282         }
1283
1284     case OP_DOR:
1285     case OP_COND_EXPR:
1286     case OP_ENTERGIVEN:
1287     case OP_ENTERWHEN:
1288         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1289             scalarvoid(kid);
1290         break;
1291
1292     case OP_NULL:
1293         if (o->op_flags & OPf_STACKED)
1294             break;
1295         /* FALL THROUGH */
1296     case OP_NEXTSTATE:
1297     case OP_DBSTATE:
1298     case OP_ENTERTRY:
1299     case OP_ENTER:
1300         if (!(o->op_flags & OPf_KIDS))
1301             break;
1302         /* FALL THROUGH */
1303     case OP_SCOPE:
1304     case OP_LEAVE:
1305     case OP_LEAVETRY:
1306     case OP_LEAVELOOP:
1307     case OP_LINESEQ:
1308     case OP_LIST:
1309     case OP_LEAVEGIVEN:
1310     case OP_LEAVEWHEN:
1311         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1312             scalarvoid(kid);
1313         break;
1314     case OP_ENTEREVAL:
1315         scalarkids(o);
1316         break;
1317     case OP_SCALAR:
1318         return scalar(o);
1319     }
1320     if (useless)
1321         Perl_ck_warner(aTHX_ packWARN(WARN_VOID), "Useless use of %s in void context", useless);
1322     return o;
1323 }
1324
1325 static OP *
1326 S_listkids(pTHX_ OP *o)
1327 {
1328     if (o && o->op_flags & OPf_KIDS) {
1329         OP *kid;
1330         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1331             list(kid);
1332     }
1333     return o;
1334 }
1335
1336 OP *
1337 Perl_list(pTHX_ OP *o)
1338 {
1339     dVAR;
1340     OP *kid;
1341
1342     /* assumes no premature commitment */
1343     if (!o || (o->op_flags & OPf_WANT)
1344          || (PL_parser && PL_parser->error_count)
1345          || o->op_type == OP_RETURN)
1346     {
1347         return o;
1348     }
1349
1350     if ((o->op_private & OPpTARGET_MY)
1351         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1352     {
1353         return o;                               /* As if inside SASSIGN */
1354     }
1355
1356     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
1357
1358     switch (o->op_type) {
1359     case OP_FLOP:
1360     case OP_REPEAT:
1361         list(cBINOPo->op_first);
1362         break;
1363     case OP_OR:
1364     case OP_AND:
1365     case OP_COND_EXPR:
1366         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1367             list(kid);
1368         break;
1369     default:
1370     case OP_MATCH:
1371     case OP_QR:
1372     case OP_SUBST:
1373     case OP_NULL:
1374         if (!(o->op_flags & OPf_KIDS))
1375             break;
1376         if (!o->op_next && cUNOPo->op_first->op_type == OP_FLOP) {
1377             list(cBINOPo->op_first);
1378             return gen_constant_list(o);
1379         }
1380     case OP_LIST:
1381         listkids(o);
1382         break;
1383     case OP_LEAVE:
1384     case OP_LEAVETRY:
1385         kid = cLISTOPo->op_first;
1386         list(kid);
1387         kid = kid->op_sibling;
1388     do_kids:
1389         while (kid) {
1390             OP *sib = kid->op_sibling;
1391             if (sib && kid->op_type != OP_LEAVEWHEN)
1392                 scalarvoid(kid);
1393             else
1394                 list(kid);
1395             kid = sib;
1396         }
1397         PL_curcop = &PL_compiling;
1398         break;
1399     case OP_SCOPE:
1400     case OP_LINESEQ:
1401         kid = cLISTOPo->op_first;
1402         goto do_kids;
1403     }
1404     return o;
1405 }
1406
1407 static OP *
1408 S_scalarseq(pTHX_ OP *o)
1409 {
1410     dVAR;
1411     if (o) {
1412         const OPCODE type = o->op_type;
1413
1414         if (type == OP_LINESEQ || type == OP_SCOPE ||
1415             type == OP_LEAVE || type == OP_LEAVETRY)
1416         {
1417             OP *kid;
1418             for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
1419                 if (kid->op_sibling) {
1420                     scalarvoid(kid);
1421                 }
1422             }
1423             PL_curcop = &PL_compiling;
1424         }
1425         o->op_flags &= ~OPf_PARENS;
1426         if (PL_hints & HINT_BLOCK_SCOPE)
1427             o->op_flags |= OPf_PARENS;
1428     }
1429     else
1430         o = newOP(OP_STUB, 0);
1431     return o;
1432 }
1433
1434 STATIC OP *
1435 S_modkids(pTHX_ OP *o, I32 type)
1436 {
1437     if (o && o->op_flags & OPf_KIDS) {
1438         OP *kid;
1439         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1440             op_lvalue(kid, type);
1441     }
1442     return o;
1443 }
1444
1445 /*
1446 =for apidoc finalize_optree
1447
1448 This function finalizes the optree. Should be called directly after
1449 the complete optree is built. It does some additional
1450 checking which can't be done in the normal ck_xxx functions and makes
1451 the tree thread-safe.
1452
1453 =cut
1454 */
1455 void
1456 Perl_finalize_optree(pTHX_ OP* o)
1457 {
1458     PERL_ARGS_ASSERT_FINALIZE_OPTREE;
1459
1460     ENTER;
1461     SAVEVPTR(PL_curcop);
1462
1463     finalize_op(o);
1464
1465     LEAVE;
1466 }
1467
1468 void
1469 S_finalize_op(pTHX_ OP* o)
1470 {
1471     PERL_ARGS_ASSERT_FINALIZE_OP;
1472
1473 #if defined(PERL_MAD) && defined(USE_ITHREADS)
1474     {
1475         /* Make sure mad ops are also thread-safe */
1476         MADPROP *mp = o->op_madprop;
1477         while (mp) {
1478             if (mp->mad_type == MAD_OP && mp->mad_vlen) {
1479                 OP *prop_op = (OP *) mp->mad_val;
1480                 /* We only need "Relocate sv to the pad for thread safety.", but this
1481                    easiest way to make sure it traverses everything */
1482                 if (prop_op->op_type == OP_CONST)
1483                     cSVOPx(prop_op)->op_private &= ~OPpCONST_STRICT;
1484                 finalize_op(prop_op);
1485             }
1486             mp = mp->mad_next;
1487         }
1488     }
1489 #endif
1490
1491     switch (o->op_type) {
1492     case OP_NEXTSTATE:
1493     case OP_DBSTATE:
1494         PL_curcop = ((COP*)o);          /* for warnings */
1495         break;
1496     case OP_EXEC:
1497         if ( o->op_sibling
1498             && (o->op_sibling->op_type == OP_NEXTSTATE || o->op_sibling->op_type == OP_DBSTATE)
1499             && ckWARN(WARN_SYNTAX))
1500             {
1501                 if (o->op_sibling->op_sibling) {
1502                     const OPCODE type = o->op_sibling->op_sibling->op_type;
1503                     if (type != OP_EXIT && type != OP_WARN && type != OP_DIE) {
1504                         const line_t oldline = CopLINE(PL_curcop);
1505                         CopLINE_set(PL_curcop, CopLINE((COP*)o->op_sibling));
1506                         Perl_warner(aTHX_ packWARN(WARN_EXEC),
1507                             "Statement unlikely to be reached");
1508                         Perl_warner(aTHX_ packWARN(WARN_EXEC),
1509                             "\t(Maybe you meant system() when you said exec()?)\n");
1510                         CopLINE_set(PL_curcop, oldline);
1511                     }
1512                 }
1513             }
1514         break;
1515
1516     case OP_GV:
1517         if ((o->op_private & OPpEARLY_CV) && ckWARN(WARN_PROTOTYPE)) {
1518             GV * const gv = cGVOPo_gv;
1519             if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX_const(GvCV(gv))) {
1520                 /* XXX could check prototype here instead of just carping */
1521                 SV * const sv = sv_newmortal();
1522                 gv_efullname3(sv, gv, NULL);
1523                 Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
1524                     "%"SVf"() called too early to check prototype",
1525                     SVfARG(sv));
1526             }
1527         }
1528         break;
1529
1530     case OP_CONST:
1531         if (cSVOPo->op_private & OPpCONST_STRICT)
1532             no_bareword_allowed(o);
1533         /* FALLTHROUGH */
1534 #ifdef USE_ITHREADS
1535     case OP_HINTSEVAL:
1536     case OP_METHOD_NAMED:
1537         /* Relocate sv to the pad for thread safety.
1538          * Despite being a "constant", the SV is written to,
1539          * for reference counts, sv_upgrade() etc. */
1540         if (cSVOPo->op_sv) {
1541             const PADOFFSET ix = pad_alloc(OP_CONST, SVs_PADTMP);
1542             if (o->op_type != OP_METHOD_NAMED &&
1543                 (SvPADTMP(cSVOPo->op_sv) || SvPADMY(cSVOPo->op_sv)))
1544             {
1545                 /* If op_sv is already a PADTMP/MY then it is being used by
1546                  * some pad, so make a copy. */
1547                 sv_setsv(PAD_SVl(ix),cSVOPo->op_sv);
1548                 SvREADONLY_on(PAD_SVl(ix));
1549                 SvREFCNT_dec(cSVOPo->op_sv);
1550             }
1551             else if (o->op_type != OP_METHOD_NAMED
1552                 && cSVOPo->op_sv == &PL_sv_undef) {
1553                 /* PL_sv_undef is hack - it's unsafe to store it in the
1554                    AV that is the pad, because av_fetch treats values of
1555                    PL_sv_undef as a "free" AV entry and will merrily
1556                    replace them with a new SV, causing pad_alloc to think
1557                    that this pad slot is free. (When, clearly, it is not)
1558                 */
1559                 SvOK_off(PAD_SVl(ix));
1560                 SvPADTMP_on(PAD_SVl(ix));
1561                 SvREADONLY_on(PAD_SVl(ix));
1562             }
1563             else {
1564                 SvREFCNT_dec(PAD_SVl(ix));
1565                 SvPADTMP_on(cSVOPo->op_sv);
1566                 PAD_SETSV(ix, cSVOPo->op_sv);
1567                 /* XXX I don't know how this isn't readonly already. */
1568                 SvREADONLY_on(PAD_SVl(ix));
1569             }
1570             cSVOPo->op_sv = NULL;
1571             o->op_targ = ix;
1572         }
1573 #endif
1574         break;
1575
1576     case OP_HELEM: {
1577         UNOP *rop;
1578         SV *lexname;
1579         GV **fields;
1580         SV **svp, *sv;
1581         const char *key = NULL;
1582         STRLEN keylen;
1583
1584         if (((BINOP*)o)->op_last->op_type != OP_CONST)
1585             break;
1586
1587         /* Make the CONST have a shared SV */
1588         svp = cSVOPx_svp(((BINOP*)o)->op_last);
1589         if ((!SvFAKE(sv = *svp) || !SvREADONLY(sv))
1590             && SvTYPE(sv) < SVt_PVMG && !SvROK(sv)) {
1591             key = SvPV_const(sv, keylen);
1592             lexname = newSVpvn_share(key,
1593                 SvUTF8(sv) ? -(I32)keylen : (I32)keylen,
1594                 0);
1595             SvREFCNT_dec(sv);
1596             *svp = lexname;
1597         }
1598
1599         if ((o->op_private & (OPpLVAL_INTRO)))
1600             break;
1601
1602         rop = (UNOP*)((BINOP*)o)->op_first;
1603         if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
1604             break;
1605         lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
1606         if (!SvPAD_TYPED(lexname))
1607             break;
1608         fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
1609         if (!fields || !GvHV(*fields))
1610             break;
1611         key = SvPV_const(*svp, keylen);
1612         if (!hv_fetch(GvHV(*fields), key,
1613                 SvUTF8(*svp) ? -(I32)keylen : (I32)keylen, FALSE)) {
1614             Perl_croak(aTHX_ "No such class field \"%s\" "
1615                 "in variable %s of type %s",
1616                 key, SvPV_nolen_const(lexname), HvNAME_get(SvSTASH(lexname)));
1617         }
1618         break;
1619     }
1620
1621     case OP_HSLICE: {
1622         UNOP *rop;
1623         SV *lexname;
1624         GV **fields;
1625         SV **svp;
1626         const char *key;
1627         STRLEN keylen;
1628         SVOP *first_key_op, *key_op;
1629
1630         if ((o->op_private & (OPpLVAL_INTRO))
1631             /* I bet there's always a pushmark... */
1632             || ((LISTOP*)o)->op_first->op_sibling->op_type != OP_LIST)
1633             /* hmmm, no optimization if list contains only one key. */
1634             break;
1635         rop = (UNOP*)((LISTOP*)o)->op_last;
1636         if (rop->op_type != OP_RV2HV)
1637             break;
1638         if (rop->op_first->op_type == OP_PADSV)
1639             /* @$hash{qw(keys here)} */
1640             rop = (UNOP*)rop->op_first;
1641         else {
1642             /* @{$hash}{qw(keys here)} */
1643             if (rop->op_first->op_type == OP_SCOPE
1644                 && cLISTOPx(rop->op_first)->op_last->op_type == OP_PADSV)
1645                 {
1646                     rop = (UNOP*)cLISTOPx(rop->op_first)->op_last;
1647                 }
1648             else
1649                 break;
1650         }
1651
1652         lexname = *av_fetch(PL_comppad_name, rop->op_targ, TRUE);
1653         if (!SvPAD_TYPED(lexname))
1654             break;
1655         fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
1656         if (!fields || !GvHV(*fields))
1657             break;
1658         /* Again guessing that the pushmark can be jumped over.... */
1659         first_key_op = (SVOP*)((LISTOP*)((LISTOP*)o)->op_first->op_sibling)
1660             ->op_first->op_sibling;
1661         for (key_op = first_key_op; key_op;
1662              key_op = (SVOP*)key_op->op_sibling) {
1663             if (key_op->op_type != OP_CONST)
1664                 continue;
1665             svp = cSVOPx_svp(key_op);
1666             key = SvPV_const(*svp, keylen);
1667             if (!hv_fetch(GvHV(*fields), key,
1668                     SvUTF8(*svp) ? -(I32)keylen : (I32)keylen, FALSE)) {
1669                 Perl_croak(aTHX_ "No such class field \"%s\" "
1670                     "in variable %s of type %s",
1671                     key, SvPV_nolen(lexname), HvNAME_get(SvSTASH(lexname)));
1672             }
1673         }
1674         break;
1675     }
1676     case OP_SUBST: {
1677         if (cPMOPo->op_pmreplrootu.op_pmreplroot)
1678             finalize_op(cPMOPo->op_pmreplrootu.op_pmreplroot);
1679         break;
1680     }
1681     default:
1682         break;
1683     }
1684
1685     if (o->op_flags & OPf_KIDS) {
1686         OP *kid;
1687         for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
1688             finalize_op(kid);
1689     }
1690 }
1691
1692 /*
1693 =for apidoc Amx|OP *|op_lvalue|OP *o|I32 type
1694
1695 Propagate lvalue ("modifiable") context to an op and its children.
1696 I<type> represents the context type, roughly based on the type of op that
1697 would do the modifying, although C<local()> is represented by OP_NULL,
1698 because it has no op type of its own (it is signalled by a flag on
1699 the lvalue op).
1700
1701 This function detects things that can't be modified, such as C<$x+1>, and
1702 generates errors for them. For example, C<$x+1 = 2> would cause it to be
1703 called with an op of type OP_ADD and a C<type> argument of OP_SASSIGN.
1704
1705 It also flags things that need to behave specially in an lvalue context,
1706 such as C<$$x = 5> which might have to vivify a reference in C<$x>.
1707
1708 =cut
1709 */
1710
1711 OP *
1712 Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags)
1713 {
1714     dVAR;
1715     OP *kid;
1716     /* -1 = error on localize, 0 = ignore localize, 1 = ok to localize */
1717     int localize = -1;
1718
1719     if (!o || (PL_parser && PL_parser->error_count))
1720         return o;
1721
1722     if ((o->op_private & OPpTARGET_MY)
1723         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1724     {
1725         return o;
1726     }
1727
1728     assert( (o->op_flags & OPf_WANT) != OPf_WANT_VOID );
1729
1730     switch (o->op_type) {
1731     case OP_UNDEF:
1732         localize = 0;
1733         PL_modcount++;
1734         return o;
1735     case OP_CONST:
1736         if (!(o->op_private & OPpCONST_ARYBASE))
1737             goto nomod;
1738         localize = 0;
1739         if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
1740             CopARYBASE_set(&PL_compiling,
1741                            (I32)SvIV(cSVOPx(PL_eval_start)->op_sv));
1742             PL_eval_start = 0;
1743         }
1744         else if (!type) {
1745             SAVECOPARYBASE(&PL_compiling);
1746             CopARYBASE_set(&PL_compiling, 0);
1747         }
1748         else if (type == OP_REFGEN)
1749             goto nomod;
1750         else
1751             Perl_croak(aTHX_ "That use of $[ is unsupported");
1752         break;
1753     case OP_STUB:
1754         if ((o->op_flags & OPf_PARENS) || PL_madskills)
1755             break;
1756         goto nomod;
1757     case OP_ENTERSUB:
1758         if ((type == OP_UNDEF || type == OP_REFGEN || type == OP_LOCK) &&
1759             !(o->op_flags & OPf_STACKED)) {
1760             o->op_type = OP_RV2CV;              /* entersub => rv2cv */
1761             /* Both ENTERSUB and RV2CV use this bit, but for different pur-
1762                poses, so we need it clear.  */
1763             o->op_private &= ~1;
1764             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
1765             assert(cUNOPo->op_first->op_type == OP_NULL);
1766             op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
1767             break;
1768         }
1769         else {                          /* lvalue subroutine call */
1770             o->op_private |= OPpLVAL_INTRO
1771                            |(OPpENTERSUB_INARGS * (type == OP_LEAVESUBLV));
1772             PL_modcount = RETURN_UNLIMITED_NUMBER;
1773             if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) {
1774                 /* Backward compatibility mode: */
1775                 o->op_private |= OPpENTERSUB_INARGS;
1776                 break;
1777             }
1778             else {                      /* Compile-time error message: */
1779                 OP *kid = cUNOPo->op_first;
1780                 CV *cv;
1781                 OP *okid;
1782
1783                 if (kid->op_type != OP_PUSHMARK) {
1784                     if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
1785                         Perl_croak(aTHX_
1786                                 "panic: unexpected lvalue entersub "
1787                                 "args: type/targ %ld:%"UVuf,
1788                                 (long)kid->op_type, (UV)kid->op_targ);
1789                     kid = kLISTOP->op_first;
1790                 }
1791                 while (kid->op_sibling)
1792                     kid = kid->op_sibling;
1793                 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
1794                     /* Indirect call */
1795                     if (kid->op_type == OP_METHOD_NAMED
1796                         || kid->op_type == OP_METHOD)
1797                     {
1798                         UNOP *newop;
1799
1800                         NewOp(1101, newop, 1, UNOP);
1801                         newop->op_type = OP_RV2CV;
1802                         newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
1803                         newop->op_first = NULL;
1804                         newop->op_next = (OP*)newop;
1805                         kid->op_sibling = (OP*)newop;
1806                         newop->op_private |= OPpLVAL_INTRO;
1807                         newop->op_private &= ~1;
1808                         break;
1809                     }
1810
1811                     if (kid->op_type != OP_RV2CV)
1812                         Perl_croak(aTHX_
1813                                    "panic: unexpected lvalue entersub "
1814                                    "entry via type/targ %ld:%"UVuf,
1815                                    (long)kid->op_type, (UV)kid->op_targ);
1816                     kid->op_private |= OPpLVAL_INTRO;
1817                     break;      /* Postpone until runtime */
1818                 }
1819
1820                 okid = kid;
1821                 kid = kUNOP->op_first;
1822                 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
1823                     kid = kUNOP->op_first;
1824                 if (kid->op_type == OP_NULL)
1825                     Perl_croak(aTHX_
1826                                "Unexpected constant lvalue entersub "
1827                                "entry via type/targ %ld:%"UVuf,
1828                                (long)kid->op_type, (UV)kid->op_targ);
1829                 if (kid->op_type != OP_GV) {
1830                     /* Restore RV2CV to check lvalueness */
1831                   restore_2cv:
1832                     if (kid->op_next && kid->op_next != kid) { /* Happens? */
1833                         okid->op_next = kid->op_next;
1834                         kid->op_next = okid;
1835                     }
1836                     else
1837                         okid->op_next = NULL;
1838                     okid->op_type = OP_RV2CV;
1839                     okid->op_targ = 0;
1840                     okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
1841                     okid->op_private |= OPpLVAL_INTRO;
1842                     okid->op_private &= ~1;
1843                     break;
1844                 }
1845
1846                 cv = GvCV(kGVOP_gv);
1847                 if (!cv)
1848                     goto restore_2cv;
1849                 if (CvLVALUE(cv))
1850                     break;
1851             }
1852         }
1853         /* FALL THROUGH */
1854     default:
1855       nomod:
1856         if (flags & OP_LVALUE_NO_CROAK) return NULL;
1857         /* grep, foreach, subcalls, refgen */
1858         if (type == OP_GREPSTART || type == OP_ENTERSUB
1859          || type == OP_REFGEN    || type == OP_LEAVESUBLV)
1860             break;
1861         yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
1862                      (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
1863                       ? "do block"
1864                       : (o->op_type == OP_ENTERSUB
1865                         ? "non-lvalue subroutine call"
1866                         : OP_DESC(o))),
1867                      type ? PL_op_desc[type] : "local"));
1868         return o;
1869
1870     case OP_PREINC:
1871     case OP_PREDEC:
1872     case OP_POW:
1873     case OP_MULTIPLY:
1874     case OP_DIVIDE:
1875     case OP_MODULO:
1876     case OP_REPEAT:
1877     case OP_ADD:
1878     case OP_SUBTRACT:
1879     case OP_CONCAT:
1880     case OP_LEFT_SHIFT:
1881     case OP_RIGHT_SHIFT:
1882     case OP_BIT_AND:
1883     case OP_BIT_XOR:
1884     case OP_BIT_OR:
1885     case OP_I_MULTIPLY:
1886     case OP_I_DIVIDE:
1887     case OP_I_MODULO:
1888     case OP_I_ADD:
1889     case OP_I_SUBTRACT:
1890         if (!(o->op_flags & OPf_STACKED))
1891             goto nomod;
1892         PL_modcount++;
1893         break;
1894
1895     case OP_COND_EXPR:
1896         localize = 1;
1897         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1898             op_lvalue(kid, type);
1899         break;
1900
1901     case OP_RV2AV:
1902     case OP_RV2HV:
1903         if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
1904            PL_modcount = RETURN_UNLIMITED_NUMBER;
1905             return o;           /* Treat \(@foo) like ordinary list. */
1906         }
1907         /* FALL THROUGH */
1908     case OP_RV2GV:
1909         if (scalar_mod_type(o, type))
1910             goto nomod;
1911         ref(cUNOPo->op_first, o->op_type);
1912         /* FALL THROUGH */
1913     case OP_ASLICE:
1914     case OP_HSLICE:
1915         if (type == OP_LEAVESUBLV)
1916             o->op_private |= OPpMAYBE_LVSUB;
1917         localize = 1;
1918         /* FALL THROUGH */
1919     case OP_AASSIGN:
1920     case OP_NEXTSTATE:
1921     case OP_DBSTATE:
1922        PL_modcount = RETURN_UNLIMITED_NUMBER;
1923         break;
1924     case OP_AV2ARYLEN:
1925         PL_hints |= HINT_BLOCK_SCOPE;
1926         if (type == OP_LEAVESUBLV)
1927             o->op_private |= OPpMAYBE_LVSUB;
1928         PL_modcount++;
1929         break;
1930     case OP_RV2SV:
1931         ref(cUNOPo->op_first, o->op_type);
1932         localize = 1;
1933         /* FALL THROUGH */
1934     case OP_GV:
1935         PL_hints |= HINT_BLOCK_SCOPE;
1936     case OP_SASSIGN:
1937     case OP_ANDASSIGN:
1938     case OP_ORASSIGN:
1939     case OP_DORASSIGN:
1940         PL_modcount++;
1941         break;
1942
1943     case OP_AELEMFAST:
1944     case OP_AELEMFAST_LEX:
1945         localize = -1;
1946         PL_modcount++;
1947         break;
1948
1949     case OP_PADAV:
1950     case OP_PADHV:
1951        PL_modcount = RETURN_UNLIMITED_NUMBER;
1952         if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
1953             return o;           /* Treat \(@foo) like ordinary list. */
1954         if (scalar_mod_type(o, type))
1955             goto nomod;
1956         if (type == OP_LEAVESUBLV)
1957             o->op_private |= OPpMAYBE_LVSUB;
1958         /* FALL THROUGH */
1959     case OP_PADSV:
1960         PL_modcount++;
1961         if (!type) /* local() */
1962             Perl_croak(aTHX_ "Can't localize lexical variable %"SVf,
1963                  PAD_COMPNAME_SV(o->op_targ));
1964         break;
1965
1966     case OP_PUSHMARK:
1967         localize = 0;
1968         break;
1969
1970     case OP_KEYS:
1971     case OP_RKEYS:
1972         if (type != OP_SASSIGN && type != OP_LEAVESUBLV)
1973             goto nomod;
1974         goto lvalue_func;
1975     case OP_SUBSTR:
1976         if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
1977             goto nomod;
1978         /* FALL THROUGH */
1979     case OP_POS:
1980     case OP_VEC:
1981       lvalue_func:
1982         if (type == OP_LEAVESUBLV)
1983             o->op_private |= OPpMAYBE_LVSUB;
1984         pad_free(o->op_targ);
1985         o->op_targ = pad_alloc(o->op_type, SVs_PADMY);
1986         assert(SvTYPE(PAD_SV(o->op_targ)) == SVt_NULL);
1987         if (o->op_flags & OPf_KIDS)
1988             op_lvalue(cBINOPo->op_first->op_sibling, type);
1989         break;
1990
1991     case OP_AELEM:
1992     case OP_HELEM:
1993         ref(cBINOPo->op_first, o->op_type);
1994         if (type == OP_ENTERSUB &&
1995              !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
1996             o->op_private |= OPpLVAL_DEFER;
1997         if (type == OP_LEAVESUBLV)
1998             o->op_private |= OPpMAYBE_LVSUB;
1999         localize = 1;
2000         PL_modcount++;
2001         break;
2002
2003     case OP_SCOPE:
2004     case OP_LEAVE:
2005     case OP_ENTER:
2006     case OP_LINESEQ:
2007         localize = 0;
2008         if (o->op_flags & OPf_KIDS)
2009             op_lvalue(cLISTOPo->op_last, type);
2010         break;
2011
2012     case OP_NULL:
2013         localize = 0;
2014         if (o->op_flags & OPf_SPECIAL)          /* do BLOCK */
2015             goto nomod;
2016         else if (!(o->op_flags & OPf_KIDS))
2017             break;
2018         if (o->op_targ != OP_LIST) {
2019             op_lvalue(cBINOPo->op_first, type);
2020             break;
2021         }
2022         /* FALL THROUGH */
2023     case OP_LIST:
2024         localize = 0;
2025         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2026             /* elements might be in void context because the list is
2027                in scalar context or because they are attribute sub calls */
2028             if ( (kid->op_flags & OPf_WANT) != OPf_WANT_VOID )
2029                 op_lvalue(kid, type);
2030         break;
2031
2032     case OP_RETURN:
2033         if (type != OP_LEAVESUBLV)
2034             goto nomod;
2035         break; /* op_lvalue()ing was handled by ck_return() */
2036     }
2037
2038     /* [20011101.069] File test operators interpret OPf_REF to mean that
2039        their argument is a filehandle; thus \stat(".") should not set
2040        it. AMS 20011102 */
2041     if (type == OP_REFGEN &&
2042         PL_check[o->op_type] == Perl_ck_ftst)
2043         return o;
2044
2045     if (type != OP_LEAVESUBLV)
2046         o->op_flags |= OPf_MOD;
2047
2048     if (type == OP_AASSIGN || type == OP_SASSIGN)
2049         o->op_flags |= OPf_SPECIAL|OPf_REF;
2050     else if (!type) { /* local() */
2051         switch (localize) {
2052         case 1:
2053             o->op_private |= OPpLVAL_INTRO;
2054             o->op_flags &= ~OPf_SPECIAL;
2055             PL_hints |= HINT_BLOCK_SCOPE;
2056             break;
2057         case 0:
2058             break;
2059         case -1:
2060             Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
2061                            "Useless localization of %s", OP_DESC(o));
2062         }
2063     }
2064     else if (type != OP_GREPSTART && type != OP_ENTERSUB
2065              && type != OP_LEAVESUBLV)
2066         o->op_flags |= OPf_REF;
2067     return o;
2068 }
2069
2070 STATIC bool
2071 S_scalar_mod_type(const OP *o, I32 type)
2072 {
2073     assert(o || type != OP_SASSIGN);
2074
2075     switch (type) {
2076     case OP_SASSIGN:
2077         if (o->op_type == OP_RV2GV)
2078             return FALSE;
2079         /* FALL THROUGH */
2080     case OP_PREINC:
2081     case OP_PREDEC:
2082     case OP_POSTINC:
2083     case OP_POSTDEC:
2084     case OP_I_PREINC:
2085     case OP_I_PREDEC:
2086     case OP_I_POSTINC:
2087     case OP_I_POSTDEC:
2088     case OP_POW:
2089     case OP_MULTIPLY:
2090     case OP_DIVIDE:
2091     case OP_MODULO:
2092     case OP_REPEAT:
2093     case OP_ADD:
2094     case OP_SUBTRACT:
2095     case OP_I_MULTIPLY:
2096     case OP_I_DIVIDE:
2097     case OP_I_MODULO:
2098     case OP_I_ADD:
2099     case OP_I_SUBTRACT:
2100     case OP_LEFT_SHIFT:
2101     case OP_RIGHT_SHIFT:
2102     case OP_BIT_AND:
2103     case OP_BIT_XOR:
2104     case OP_BIT_OR:
2105     case OP_CONCAT:
2106     case OP_SUBST:
2107     case OP_TRANS:
2108     case OP_TRANSR:
2109     case OP_READ:
2110     case OP_SYSREAD:
2111     case OP_RECV:
2112     case OP_ANDASSIGN:
2113     case OP_ORASSIGN:
2114     case OP_DORASSIGN:
2115         return TRUE;
2116     default:
2117         return FALSE;
2118     }
2119 }
2120
2121 STATIC bool
2122 S_is_handle_constructor(const OP *o, I32 numargs)
2123 {
2124     PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR;
2125
2126     switch (o->op_type) {
2127     case OP_PIPE_OP:
2128     case OP_SOCKPAIR:
2129         if (numargs == 2)
2130             return TRUE;
2131         /* FALL THROUGH */
2132     case OP_SYSOPEN:
2133     case OP_OPEN:
2134     case OP_SELECT:             /* XXX c.f. SelectSaver.pm */
2135     case OP_SOCKET:
2136     case OP_OPEN_DIR:
2137     case OP_ACCEPT:
2138         if (numargs == 1)
2139             return TRUE;
2140         /* FALLTHROUGH */
2141     default:
2142         return FALSE;
2143     }
2144 }
2145
2146 static OP *
2147 S_refkids(pTHX_ OP *o, I32 type)
2148 {
2149     if (o && o->op_flags & OPf_KIDS) {
2150         OP *kid;
2151         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2152             ref(kid, type);
2153     }
2154     return o;
2155 }
2156
2157 OP *
2158 Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
2159 {
2160     dVAR;
2161     OP *kid;
2162
2163     PERL_ARGS_ASSERT_DOREF;
2164
2165     if (!o || (PL_parser && PL_parser->error_count))
2166         return o;
2167
2168     switch (o->op_type) {
2169     case OP_ENTERSUB:
2170         if ((type == OP_EXISTS || type == OP_DEFINED) &&
2171             !(o->op_flags & OPf_STACKED)) {
2172             o->op_type = OP_RV2CV;             /* entersub => rv2cv */
2173             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
2174             assert(cUNOPo->op_first->op_type == OP_NULL);
2175             op_null(((LISTOP*)cUNOPo->op_first)->op_first);     /* disable pushmark */
2176             o->op_flags |= OPf_SPECIAL;
2177             o->op_private &= ~1;
2178         }
2179         else if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV){
2180             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2181                               : type == OP_RV2HV ? OPpDEREF_HV
2182                               : OPpDEREF_SV);
2183             o->op_flags |= OPf_MOD;
2184         }
2185
2186         break;
2187
2188     case OP_COND_EXPR:
2189         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
2190             doref(kid, type, set_op_ref);
2191         break;
2192     case OP_RV2SV:
2193         if (type == OP_DEFINED)
2194             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2195         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2196         /* FALL THROUGH */
2197     case OP_PADSV:
2198         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2199             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2200                               : type == OP_RV2HV ? OPpDEREF_HV
2201                               : OPpDEREF_SV);
2202             o->op_flags |= OPf_MOD;
2203         }
2204         break;
2205
2206     case OP_RV2AV:
2207     case OP_RV2HV:
2208         if (set_op_ref)
2209             o->op_flags |= OPf_REF;
2210         /* FALL THROUGH */
2211     case OP_RV2GV:
2212         if (type == OP_DEFINED)
2213             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2214         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2215         break;
2216
2217     case OP_PADAV:
2218     case OP_PADHV:
2219         if (set_op_ref)
2220             o->op_flags |= OPf_REF;
2221         break;
2222
2223     case OP_SCALAR:
2224     case OP_NULL:
2225         if (!(o->op_flags & OPf_KIDS))
2226             break;
2227         doref(cBINOPo->op_first, type, set_op_ref);
2228         break;
2229     case OP_AELEM:
2230     case OP_HELEM:
2231         doref(cBINOPo->op_first, o->op_type, set_op_ref);
2232         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2233             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2234                               : type == OP_RV2HV ? OPpDEREF_HV
2235                               : OPpDEREF_SV);
2236             o->op_flags |= OPf_MOD;
2237         }
2238         break;
2239
2240     case OP_SCOPE:
2241     case OP_LEAVE:
2242         set_op_ref = FALSE;
2243         /* FALL THROUGH */
2244     case OP_ENTER:
2245     case OP_LIST:
2246         if (!(o->op_flags & OPf_KIDS))
2247             break;
2248         doref(cLISTOPo->op_last, type, set_op_ref);
2249         break;
2250     default:
2251         break;
2252     }
2253     return scalar(o);
2254
2255 }
2256
2257 STATIC OP *
2258 S_dup_attrlist(pTHX_ OP *o)
2259 {
2260     dVAR;
2261     OP *rop;
2262
2263     PERL_ARGS_ASSERT_DUP_ATTRLIST;
2264
2265     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
2266      * where the first kid is OP_PUSHMARK and the remaining ones
2267      * are OP_CONST.  We need to push the OP_CONST values.
2268      */
2269     if (o->op_type == OP_CONST)
2270         rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc_NN(cSVOPo->op_sv));
2271 #ifdef PERL_MAD
2272     else if (o->op_type == OP_NULL)
2273         rop = NULL;
2274 #endif
2275     else {
2276         assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
2277         rop = NULL;
2278         for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
2279             if (o->op_type == OP_CONST)
2280                 rop = op_append_elem(OP_LIST, rop,
2281                                   newSVOP(OP_CONST, o->op_flags,
2282                                           SvREFCNT_inc_NN(cSVOPo->op_sv)));
2283         }
2284     }
2285     return rop;
2286 }
2287
2288 STATIC void
2289 S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
2290 {
2291     dVAR;
2292     SV *stashsv;
2293
2294     PERL_ARGS_ASSERT_APPLY_ATTRS;
2295
2296     /* fake up C<use attributes $pkg,$rv,@attrs> */
2297     ENTER;              /* need to protect against side-effects of 'use' */
2298     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2299
2300 #define ATTRSMODULE "attributes"
2301 #define ATTRSMODULE_PM "attributes.pm"
2302
2303     if (for_my) {
2304         /* Don't force the C<use> if we don't need it. */
2305         SV * const * const svp = hv_fetchs(GvHVn(PL_incgv), ATTRSMODULE_PM, FALSE);
2306         if (svp && *svp != &PL_sv_undef)
2307             NOOP;       /* already in %INC */
2308         else
2309             Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
2310                              newSVpvs(ATTRSMODULE), NULL);
2311     }
2312     else {
2313         Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2314                          newSVpvs(ATTRSMODULE),
2315                          NULL,
2316                          op_prepend_elem(OP_LIST,
2317                                       newSVOP(OP_CONST, 0, stashsv),
2318                                       op_prepend_elem(OP_LIST,
2319                                                    newSVOP(OP_CONST, 0,
2320                                                            newRV(target)),
2321                                                    dup_attrlist(attrs))));
2322     }
2323     LEAVE;
2324 }
2325
2326 STATIC void
2327 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
2328 {
2329     dVAR;
2330     OP *pack, *imop, *arg;
2331     SV *meth, *stashsv;
2332
2333     PERL_ARGS_ASSERT_APPLY_ATTRS_MY;
2334
2335     if (!attrs)
2336         return;
2337
2338     assert(target->op_type == OP_PADSV ||
2339            target->op_type == OP_PADHV ||
2340            target->op_type == OP_PADAV);
2341
2342     /* Ensure that attributes.pm is loaded. */
2343     apply_attrs(stash, PAD_SV(target->op_targ), attrs, TRUE);
2344
2345     /* Need package name for method call. */
2346     pack = newSVOP(OP_CONST, 0, newSVpvs(ATTRSMODULE));
2347
2348     /* Build up the real arg-list. */
2349     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2350
2351     arg = newOP(OP_PADSV, 0);
2352     arg->op_targ = target->op_targ;
2353     arg = op_prepend_elem(OP_LIST,
2354                        newSVOP(OP_CONST, 0, stashsv),
2355                        op_prepend_elem(OP_LIST,
2356                                     newUNOP(OP_REFGEN, 0,
2357                                             op_lvalue(arg, OP_REFGEN)),
2358                                     dup_attrlist(attrs)));
2359
2360     /* Fake up a method call to import */
2361     meth = newSVpvs_share("import");
2362     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
2363                    op_append_elem(OP_LIST,
2364                                op_prepend_elem(OP_LIST, pack, list(arg)),
2365                                newSVOP(OP_METHOD_NAMED, 0, meth)));
2366
2367     /* Combine the ops. */
2368     *imopsp = op_append_elem(OP_LIST, *imopsp, imop);
2369 }
2370
2371 /*
2372 =notfor apidoc apply_attrs_string
2373
2374 Attempts to apply a list of attributes specified by the C<attrstr> and
2375 C<len> arguments to the subroutine identified by the C<cv> argument which
2376 is expected to be associated with the package identified by the C<stashpv>
2377 argument (see L<attributes>).  It gets this wrong, though, in that it
2378 does not correctly identify the boundaries of the individual attribute
2379 specifications within C<attrstr>.  This is not really intended for the
2380 public API, but has to be listed here for systems such as AIX which
2381 need an explicit export list for symbols.  (It's called from XS code
2382 in support of the C<ATTRS:> keyword from F<xsubpp>.)  Patches to fix it
2383 to respect attribute syntax properly would be welcome.
2384
2385 =cut
2386 */
2387
2388 void
2389 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
2390                         const char *attrstr, STRLEN len)
2391 {
2392     OP *attrs = NULL;
2393
2394     PERL_ARGS_ASSERT_APPLY_ATTRS_STRING;
2395
2396     if (!len) {
2397         len = strlen(attrstr);
2398     }
2399
2400     while (len) {
2401         for (; isSPACE(*attrstr) && len; --len, ++attrstr) ;
2402         if (len) {
2403             const char * const sstr = attrstr;
2404             for (; !isSPACE(*attrstr) && len; --len, ++attrstr) ;
2405             attrs = op_append_elem(OP_LIST, attrs,
2406                                 newSVOP(OP_CONST, 0,
2407                                         newSVpvn(sstr, attrstr-sstr)));
2408         }
2409     }
2410
2411     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2412                      newSVpvs(ATTRSMODULE),
2413                      NULL, op_prepend_elem(OP_LIST,
2414                                   newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
2415                                   op_prepend_elem(OP_LIST,
2416                                                newSVOP(OP_CONST, 0,
2417                                                        newRV(MUTABLE_SV(cv))),
2418                                                attrs)));
2419 }
2420
2421 STATIC OP *
2422 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
2423 {
2424     dVAR;
2425     I32 type;
2426     const bool stately = PL_parser && PL_parser->in_my == KEY_state;
2427
2428     PERL_ARGS_ASSERT_MY_KID;
2429
2430     if (!o || (PL_parser && PL_parser->error_count))
2431         return o;
2432
2433     type = o->op_type;
2434     if (PL_madskills && type == OP_NULL && o->op_flags & OPf_KIDS) {
2435         (void)my_kid(cUNOPo->op_first, attrs, imopsp);
2436         return o;
2437     }
2438
2439     if (type == OP_LIST) {
2440         OP *kid;
2441         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2442             my_kid(kid, attrs, imopsp);
2443     } else if (type == OP_UNDEF
2444 #ifdef PERL_MAD
2445                || type == OP_STUB
2446 #endif
2447                ) {
2448         return o;
2449     } else if (type == OP_RV2SV ||      /* "our" declaration */
2450                type == OP_RV2AV ||
2451                type == OP_RV2HV) { /* XXX does this let anything illegal in? */
2452         if (cUNOPo->op_first->op_type != OP_GV) { /* MJD 20011224 */
2453             yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2454                         OP_DESC(o),
2455                         PL_parser->in_my == KEY_our
2456                             ? "our"
2457                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2458         } else if (attrs) {
2459             GV * const gv = cGVOPx_gv(cUNOPo->op_first);
2460             PL_parser->in_my = FALSE;
2461             PL_parser->in_my_stash = NULL;
2462             apply_attrs(GvSTASH(gv),
2463                         (type == OP_RV2SV ? GvSV(gv) :
2464                          type == OP_RV2AV ? MUTABLE_SV(GvAV(gv)) :
2465                          type == OP_RV2HV ? MUTABLE_SV(GvHV(gv)) : MUTABLE_SV(gv)),
2466                         attrs, FALSE);
2467         }
2468         o->op_private |= OPpOUR_INTRO;
2469         return o;
2470     }
2471     else if (type != OP_PADSV &&
2472              type != OP_PADAV &&
2473              type != OP_PADHV &&
2474              type != OP_PUSHMARK)
2475     {
2476         yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2477                           OP_DESC(o),
2478                           PL_parser->in_my == KEY_our
2479                             ? "our"
2480                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2481         return o;
2482     }
2483     else if (attrs && type != OP_PUSHMARK) {
2484         HV *stash;
2485
2486         PL_parser->in_my = FALSE;
2487         PL_parser->in_my_stash = NULL;
2488
2489         /* check for C<my Dog $spot> when deciding package */
2490         stash = PAD_COMPNAME_TYPE(o->op_targ);
2491         if (!stash)
2492             stash = PL_curstash;
2493         apply_attrs_my(stash, o, attrs, imopsp);
2494     }
2495     o->op_flags |= OPf_MOD;
2496     o->op_private |= OPpLVAL_INTRO;
2497     if (stately)
2498         o->op_private |= OPpPAD_STATE;
2499     return o;
2500 }
2501
2502 OP *
2503 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
2504 {
2505     dVAR;
2506     OP *rops;
2507     int maybe_scalar = 0;
2508
2509     PERL_ARGS_ASSERT_MY_ATTRS;
2510
2511 /* [perl #17376]: this appears to be premature, and results in code such as
2512    C< our(%x); > executing in list mode rather than void mode */
2513 #if 0
2514     if (o->op_flags & OPf_PARENS)
2515         list(o);
2516     else
2517         maybe_scalar = 1;
2518 #else
2519     maybe_scalar = 1;
2520 #endif
2521     if (attrs)
2522         SAVEFREEOP(attrs);
2523     rops = NULL;
2524     o = my_kid(o, attrs, &rops);
2525     if (rops) {
2526         if (maybe_scalar && o->op_type == OP_PADSV) {
2527             o = scalar(op_append_list(OP_LIST, rops, o));
2528             o->op_private |= OPpLVAL_INTRO;
2529         }
2530         else {
2531             /* The listop in rops might have a pushmark at the beginning,
2532                which will mess up list assignment. */
2533             LISTOP * const lrops = (LISTOP *)rops; /* for brevity */
2534             if (rops->op_type == OP_LIST && 
2535                 lrops->op_first && lrops->op_first->op_type == OP_PUSHMARK)
2536             {
2537                 OP * const pushmark = lrops->op_first;
2538                 lrops->op_first = pushmark->op_sibling;
2539                 op_free(pushmark);
2540             }
2541             o = op_append_list(OP_LIST, o, rops);
2542         }
2543     }
2544     PL_parser->in_my = FALSE;
2545     PL_parser->in_my_stash = NULL;
2546     return o;
2547 }
2548
2549 OP *
2550 Perl_sawparens(pTHX_ OP *o)
2551 {
2552     PERL_UNUSED_CONTEXT;
2553     if (o)
2554         o->op_flags |= OPf_PARENS;
2555     return o;
2556 }
2557
2558 OP *
2559 Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
2560 {
2561     OP *o;
2562     bool ismatchop = 0;
2563     const OPCODE ltype = left->op_type;
2564     const OPCODE rtype = right->op_type;
2565
2566     PERL_ARGS_ASSERT_BIND_MATCH;
2567
2568     if ( (ltype == OP_RV2AV || ltype == OP_RV2HV || ltype == OP_PADAV
2569           || ltype == OP_PADHV) && ckWARN(WARN_MISC))
2570     {
2571       const char * const desc
2572           = PL_op_desc[(
2573                           rtype == OP_SUBST || rtype == OP_TRANS
2574                        || rtype == OP_TRANSR
2575                        )
2576                        ? (int)rtype : OP_MATCH];
2577       const char * const sample = ((ltype == OP_RV2AV || ltype == OP_PADAV)
2578              ? "@array" : "%hash");
2579       Perl_warner(aTHX_ packWARN(WARN_MISC),
2580              "Applying %s to %s will act on scalar(%s)",
2581              desc, sample, sample);
2582     }
2583
2584     if (rtype == OP_CONST &&
2585         cSVOPx(right)->op_private & OPpCONST_BARE &&
2586         cSVOPx(right)->op_private & OPpCONST_STRICT)
2587     {
2588         no_bareword_allowed(right);
2589     }
2590
2591     /* !~ doesn't make sense with /r, so error on it for now */
2592     if (rtype == OP_SUBST && (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT) &&
2593         type == OP_NOT)
2594         yyerror("Using !~ with s///r doesn't make sense");
2595     if (rtype == OP_TRANSR && type == OP_NOT)
2596         yyerror("Using !~ with tr///r doesn't make sense");
2597
2598     ismatchop = (rtype == OP_MATCH ||
2599                  rtype == OP_SUBST ||
2600                  rtype == OP_TRANS || rtype == OP_TRANSR)
2601              && !(right->op_flags & OPf_SPECIAL);
2602     if (ismatchop && right->op_private & OPpTARGET_MY) {
2603         right->op_targ = 0;
2604         right->op_private &= ~OPpTARGET_MY;
2605     }
2606     if (!(right->op_flags & OPf_STACKED) && ismatchop) {
2607         OP *newleft;
2608
2609         right->op_flags |= OPf_STACKED;
2610         if (rtype != OP_MATCH && rtype != OP_TRANSR &&
2611             ! (rtype == OP_TRANS &&
2612                right->op_private & OPpTRANS_IDENTICAL) &&
2613             ! (rtype == OP_SUBST &&
2614                (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT)))
2615             newleft = op_lvalue(left, rtype);
2616         else
2617             newleft = left;
2618         if (right->op_type == OP_TRANS || right->op_type == OP_TRANSR)
2619             o = newBINOP(OP_NULL, OPf_STACKED, scalar(newleft), right);
2620         else
2621             o = op_prepend_elem(rtype, scalar(newleft), right);
2622         if (type == OP_NOT)
2623             return newUNOP(OP_NOT, 0, scalar(o));
2624         return o;
2625     }
2626     else
2627         return bind_match(type, left,
2628                 pmruntime(newPMOP(OP_MATCH, 0), right, 0));
2629 }
2630
2631 OP *
2632 Perl_invert(pTHX_ OP *o)
2633 {
2634     if (!o)
2635         return NULL;
2636     return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
2637 }
2638
2639 /*
2640 =for apidoc Amx|OP *|op_scope|OP *o
2641
2642 Wraps up an op tree with some additional ops so that at runtime a dynamic
2643 scope will be created.  The original ops run in the new dynamic scope,
2644 and then, provided that they exit normally, the scope will be unwound.
2645 The additional ops used to create and unwind the dynamic scope will
2646 normally be an C<enter>/C<leave> pair, but a C<scope> op may be used
2647 instead if the ops are simple enough to not need the full dynamic scope
2648 structure.
2649
2650 =cut
2651 */
2652
2653 OP *
2654 Perl_op_scope(pTHX_ OP *o)
2655 {
2656     dVAR;
2657     if (o) {
2658         if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) {
2659             o = op_prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
2660             o->op_type = OP_LEAVE;
2661             o->op_ppaddr = PL_ppaddr[OP_LEAVE];
2662         }
2663         else if (o->op_type == OP_LINESEQ) {
2664             OP *kid;
2665             o->op_type = OP_SCOPE;
2666             o->op_ppaddr = PL_ppaddr[OP_SCOPE];
2667             kid = ((LISTOP*)o)->op_first;
2668             if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) {
2669                 op_null(kid);
2670
2671                 /* The following deals with things like 'do {1 for 1}' */
2672                 kid = kid->op_sibling;
2673                 if (kid &&
2674                     (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE))
2675                     op_null(kid);
2676             }
2677         }
2678         else
2679             o = newLISTOP(OP_SCOPE, 0, o, NULL);
2680     }
2681     return o;
2682 }
2683
2684 int
2685 Perl_block_start(pTHX_ int full)
2686 {
2687     dVAR;
2688     const int retval = PL_savestack_ix;
2689
2690     pad_block_start(full);
2691     SAVEHINTS();
2692     PL_hints &= ~HINT_BLOCK_SCOPE;
2693     SAVECOMPILEWARNINGS();
2694     PL_compiling.cop_warnings = DUP_WARNINGS(PL_compiling.cop_warnings);
2695
2696     CALL_BLOCK_HOOKS(bhk_start, full);
2697
2698     return retval;
2699 }
2700
2701 OP*
2702 Perl_block_end(pTHX_ I32 floor, OP *seq)
2703 {
2704     dVAR;
2705     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
2706     OP* retval = scalarseq(seq);
2707
2708     CALL_BLOCK_HOOKS(bhk_pre_end, &retval);
2709
2710     LEAVE_SCOPE(floor);
2711     CopHINTS_set(&PL_compiling, PL_hints);
2712     if (needblockscope)
2713         PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
2714     pad_leavemy();
2715
2716     CALL_BLOCK_HOOKS(bhk_post_end, &retval);
2717
2718     return retval;
2719 }
2720
2721 /*
2722 =head1 Compile-time scope hooks
2723
2724 =for apidoc Aox||blockhook_register
2725
2726 Register a set of hooks to be called when the Perl lexical scope changes
2727 at compile time. See L<perlguts/"Compile-time scope hooks">.
2728
2729 =cut
2730 */
2731
2732 void
2733 Perl_blockhook_register(pTHX_ BHK *hk)
2734 {
2735     PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER;
2736
2737     Perl_av_create_and_push(aTHX_ &PL_blockhooks, newSViv(PTR2IV(hk)));
2738 }
2739
2740 STATIC OP *
2741 S_newDEFSVOP(pTHX)
2742 {
2743     dVAR;
2744     const PADOFFSET offset = pad_findmy_pvs("$_", 0);
2745     if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
2746         return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
2747     }
2748     else {
2749         OP * const o = newOP(OP_PADSV, 0);
2750         o->op_targ = offset;
2751         return o;
2752     }
2753 }
2754
2755 void
2756 Perl_newPROG(pTHX_ OP *o)
2757 {
2758     dVAR;
2759
2760     PERL_ARGS_ASSERT_NEWPROG;
2761
2762     if (PL_in_eval) {
2763         PERL_CONTEXT *cx;
2764         if (PL_eval_root)
2765                 return;
2766         PL_eval_root = newUNOP(OP_LEAVEEVAL,
2767                                ((PL_in_eval & EVAL_KEEPERR)
2768                                 ? OPf_SPECIAL : 0), o);
2769
2770         cx = &cxstack[cxstack_ix];
2771         assert(CxTYPE(cx) == CXt_EVAL);
2772
2773         if ((cx->blk_gimme & G_WANT) == G_VOID)
2774             scalarvoid(PL_eval_root);
2775         else if ((cx->blk_gimme & G_WANT) == G_ARRAY)
2776             list(PL_eval_root);
2777         else
2778             scalar(PL_eval_root);
2779
2780         /* don't use LINKLIST, since PL_eval_root might indirect through
2781          * a rather expensive function call and LINKLIST evaluates its
2782          * argument more than once */
2783         PL_eval_start = op_linklist(PL_eval_root);
2784         PL_eval_root->op_private |= OPpREFCOUNTED;
2785         OpREFCNT_set(PL_eval_root, 1);
2786         PL_eval_root->op_next = 0;
2787         CALL_PEEP(PL_eval_start);
2788         finalize_optree(PL_eval_root);
2789
2790     }
2791     else {
2792         if (o->op_type == OP_STUB) {
2793             PL_comppad_name = 0;
2794             PL_compcv = 0;
2795             S_op_destroy(aTHX_ o);
2796             return;
2797         }
2798         PL_main_root = op_scope(sawparens(scalarvoid(o)));
2799         PL_curcop = &PL_compiling;
2800         PL_main_start = LINKLIST(PL_main_root);
2801         PL_main_root->op_private |= OPpREFCOUNTED;
2802         OpREFCNT_set(PL_main_root, 1);
2803         PL_main_root->op_next = 0;
2804         CALL_PEEP(PL_main_start);
2805         finalize_optree(PL_main_root);
2806         PL_compcv = 0;
2807
2808         /* Register with debugger */
2809         if (PERLDB_INTER) {
2810             CV * const cv = get_cvs("DB::postponed", 0);
2811             if (cv) {
2812                 dSP;
2813                 PUSHMARK(SP);
2814                 XPUSHs(MUTABLE_SV(CopFILEGV(&PL_compiling)));
2815                 PUTBACK;
2816                 call_sv(MUTABLE_SV(cv), G_DISCARD);
2817             }
2818         }
2819     }
2820 }
2821
2822 OP *
2823 Perl_localize(pTHX_ OP *o, I32 lex)
2824 {
2825     dVAR;
2826
2827     PERL_ARGS_ASSERT_LOCALIZE;
2828
2829     if (o->op_flags & OPf_PARENS)
2830 /* [perl #17376]: this appears to be premature, and results in code such as
2831    C< our(%x); > executing in list mode rather than void mode */
2832 #if 0
2833         list(o);
2834 #else
2835         NOOP;
2836 #endif
2837     else {
2838         if ( PL_parser->bufptr > PL_parser->oldbufptr
2839             && PL_parser->bufptr[-1] == ','
2840             && ckWARN(WARN_PARENTHESIS))
2841         {
2842             char *s = PL_parser->bufptr;
2843             bool sigil = FALSE;
2844
2845             /* some heuristics to detect a potential error */
2846             while (*s && (strchr(", \t\n", *s)))
2847                 s++;
2848
2849             while (1) {
2850                 if (*s && strchr("@$%*", *s) && *++s
2851                        && (isALNUM(*s) || UTF8_IS_CONTINUED(*s))) {
2852                     s++;
2853                     sigil = TRUE;
2854                     while (*s && (isALNUM(*s) || UTF8_IS_CONTINUED(*s)))
2855                         s++;
2856                     while (*s && (strchr(", \t\n", *s)))
2857                         s++;
2858                 }
2859                 else
2860                     break;
2861             }
2862             if (sigil && (*s == ';' || *s == '=')) {
2863                 Perl_warner(aTHX_ packWARN(WARN_PARENTHESIS),
2864                                 "Parentheses missing around \"%s\" list",
2865                                 lex
2866                                     ? (PL_parser->in_my == KEY_our
2867                                         ? "our"
2868                                         : PL_parser->in_my == KEY_state
2869                                             ? "state"
2870                                             : "my")
2871                                     : "local");
2872             }
2873         }
2874     }
2875     if (lex)
2876         o = my(o);
2877     else
2878         o = op_lvalue(o, OP_NULL);              /* a bit kludgey */
2879     PL_parser->in_my = FALSE;
2880     PL_parser->in_my_stash = NULL;
2881     return o;
2882 }
2883
2884 OP *
2885 Perl_jmaybe(pTHX_ OP *o)
2886 {
2887     PERL_ARGS_ASSERT_JMAYBE;
2888
2889     if (o->op_type == OP_LIST) {
2890         OP * const o2
2891             = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL, SVt_PV)));
2892         o = convert(OP_JOIN, 0, op_prepend_elem(OP_LIST, o2, o));
2893     }
2894     return o;
2895 }
2896
2897 PERL_STATIC_INLINE OP *
2898 S_op_std_init(pTHX_ OP *o)
2899 {
2900     I32 type = o->op_type;
2901
2902     PERL_ARGS_ASSERT_OP_STD_INIT;
2903
2904     if (PL_opargs[type] & OA_RETSCALAR)
2905         scalar(o);
2906     if (PL_opargs[type] & OA_TARGET && !o->op_targ)
2907         o->op_targ = pad_alloc(type, SVs_PADTMP);
2908
2909     return o;
2910 }
2911
2912 PERL_STATIC_INLINE OP *
2913 S_op_integerize(pTHX_ OP *o)
2914 {
2915     I32 type = o->op_type;
2916
2917     PERL_ARGS_ASSERT_OP_INTEGERIZE;
2918
2919     /* integerize op, unless it happens to be C<-foo>.
2920      * XXX should pp_i_negate() do magic string negation instead? */
2921     if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER)
2922         && !(type == OP_NEGATE && cUNOPo->op_first->op_type == OP_CONST
2923              && (cUNOPo->op_first->op_private & OPpCONST_BARE)))
2924     {
2925         o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
2926     }
2927
2928     if (type == OP_NEGATE)
2929         /* XXX might want a ck_negate() for this */
2930         cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
2931
2932     return o;
2933 }
2934
2935 static OP *
2936 S_fold_constants(pTHX_ register OP *o)
2937 {
2938     dVAR;
2939     register OP * VOL curop;
2940     OP *newop;
2941     VOL I32 type = o->op_type;
2942     SV * VOL sv = NULL;
2943     int ret = 0;
2944     I32 oldscope;
2945     OP *old_next;
2946     SV * const oldwarnhook = PL_warnhook;
2947     SV * const olddiehook  = PL_diehook;
2948     COP not_compiling;
2949     dJMPENV;
2950
2951     PERL_ARGS_ASSERT_FOLD_CONSTANTS;
2952
2953     if (!(PL_opargs[type] & OA_FOLDCONST))
2954         goto nope;
2955
2956     switch (type) {
2957     case OP_UCFIRST:
2958     case OP_LCFIRST:
2959     case OP_UC:
2960     case OP_LC:
2961     case OP_SLT:
2962     case OP_SGT:
2963     case OP_SLE:
2964     case OP_SGE:
2965     case OP_SCMP:
2966     case OP_SPRINTF:
2967         /* XXX what about the numeric ops? */
2968         if (PL_hints & HINT_LOCALE)
2969             goto nope;
2970         break;
2971     }
2972
2973     if (PL_parser && PL_parser->error_count)
2974         goto nope;              /* Don't try to run w/ errors */
2975
2976     for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
2977         const OPCODE type = curop->op_type;
2978         if ((type != OP_CONST || (curop->op_private & OPpCONST_BARE)) &&
2979             type != OP_LIST &&
2980             type != OP_SCALAR &&
2981             type != OP_NULL &&
2982             type != OP_PUSHMARK)
2983         {
2984             goto nope;
2985         }
2986     }
2987
2988     curop = LINKLIST(o);
2989     old_next = o->op_next;
2990     o->op_next = 0;
2991     PL_op = curop;
2992
2993     oldscope = PL_scopestack_ix;
2994     create_eval_scope(G_FAKINGEVAL);
2995
2996     /* Verify that we don't need to save it:  */
2997     assert(PL_curcop == &PL_compiling);
2998     StructCopy(&PL_compiling, &not_compiling, COP);
2999     PL_curcop = &not_compiling;
3000     /* The above ensures that we run with all the correct hints of the
3001        currently compiling COP, but that IN_PERL_RUNTIME is not true. */
3002     assert(IN_PERL_RUNTIME);
3003     PL_warnhook = PERL_WARNHOOK_FATAL;
3004     PL_diehook  = NULL;
3005     JMPENV_PUSH(ret);
3006
3007     switch (ret) {
3008     case 0:
3009         CALLRUNOPS(aTHX);
3010         sv = *(PL_stack_sp--);
3011         if (o->op_targ && sv == PAD_SV(o->op_targ)) {   /* grab pad temp? */
3012 #ifdef PERL_MAD
3013             /* Can't simply swipe the SV from the pad, because that relies on
3014                the op being freed "real soon now". Under MAD, this doesn't
3015                happen (see the #ifdef below).  */
3016             sv = newSVsv(sv);
3017 #else
3018             pad_swipe(o->op_targ,  FALSE);
3019 #endif
3020         }
3021         else if (SvTEMP(sv)) {                  /* grab mortal temp? */
3022             SvREFCNT_inc_simple_void(sv);
3023             SvTEMP_off(sv);
3024         }
3025         break;
3026     case 3:
3027         /* Something tried to die.  Abandon constant folding.  */
3028         /* Pretend the error never happened.  */
3029         CLEAR_ERRSV();
3030         o->op_next = old_next;
3031         break;
3032     default:
3033         JMPENV_POP;
3034         /* Don't expect 1 (setjmp failed) or 2 (something called my_exit)  */
3035         PL_warnhook = oldwarnhook;
3036         PL_diehook  = olddiehook;
3037         /* XXX note that this croak may fail as we've already blown away
3038          * the stack - eg any nested evals */
3039         Perl_croak(aTHX_ "panic: fold_constants JMPENV_PUSH returned %d", ret);
3040     }
3041     JMPENV_POP;
3042     PL_warnhook = oldwarnhook;
3043     PL_diehook  = olddiehook;
3044     PL_curcop = &PL_compiling;
3045
3046     if (PL_scopestack_ix > oldscope)
3047         delete_eval_scope();
3048
3049     if (ret)
3050         goto nope;
3051
3052 #ifndef PERL_MAD
3053     op_free(o);
3054 #endif
3055     assert(sv);
3056     if (type == OP_RV2GV)
3057         newop = newGVOP(OP_GV, 0, MUTABLE_GV(sv));
3058     else
3059         newop = newSVOP(OP_CONST, 0, MUTABLE_SV(sv));
3060     op_getmad(o,newop,'f');
3061     return newop;
3062
3063  nope:
3064     return o;
3065 }
3066
3067 static OP *
3068 S_gen_constant_list(pTHX_ register OP *o)
3069 {
3070     dVAR;
3071     register OP *curop;
3072     const I32 oldtmps_floor = PL_tmps_floor;
3073
3074     list(o);
3075     if (PL_parser && PL_parser->error_count)
3076         return o;               /* Don't attempt to run with errors */
3077
3078     PL_op = curop = LINKLIST(o);
3079     o->op_next = 0;
3080     CALL_PEEP(curop);
3081     Perl_pp_pushmark(aTHX);
3082     CALLRUNOPS(aTHX);
3083     PL_op = curop;
3084     assert (!(curop->op_flags & OPf_SPECIAL));
3085     assert(curop->op_type == OP_RANGE);
3086     Perl_pp_anonlist(aTHX);
3087     PL_tmps_floor = oldtmps_floor;
3088
3089     o->op_type = OP_RV2AV;
3090     o->op_ppaddr = PL_ppaddr[OP_RV2AV];
3091     o->op_flags &= ~OPf_REF;    /* treat \(1..2) like an ordinary list */
3092     o->op_flags |= OPf_PARENS;  /* and flatten \(1..2,3) */
3093     o->op_opt = 0;              /* needs to be revisited in rpeep() */
3094     curop = ((UNOP*)o)->op_first;
3095     ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc_NN(*PL_stack_sp--));
3096 #ifdef PERL_MAD
3097     op_getmad(curop,o,'O');
3098 #else
3099     op_free(curop);
3100 #endif
3101     LINKLIST(o);
3102     return list(o);
3103 }
3104
3105 OP *
3106 Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
3107 {
3108     dVAR;
3109     if (!o || o->op_type != OP_LIST)
3110         o = newLISTOP(OP_LIST, 0, o, NULL);
3111     else
3112         o->op_flags &= ~OPf_WANT;
3113
3114     if (!(PL_opargs[type] & OA_MARK))
3115         op_null(cLISTOPo->op_first);
3116     else {
3117         OP * const kid2 = cLISTOPo->op_first->op_sibling;
3118         if (kid2 && kid2->op_type == OP_COREARGS) {
3119             op_null(cLISTOPo->op_first);
3120             kid2->op_private |= OPpCOREARGS_PUSHMARK;
3121         }
3122     }   
3123
3124     o->op_type = (OPCODE)type;
3125     o->op_ppaddr = PL_ppaddr[type];
3126     o->op_flags |= flags;
3127
3128     o = CHECKOP(type, o);
3129     if (o->op_type != (unsigned)type)
3130         return o;
3131
3132     return fold_constants(op_integerize(op_std_init(o)));
3133 }
3134
3135 /*
3136 =head1 Optree Manipulation Functions
3137 */
3138
3139 /* List constructors */
3140
3141 /*
3142 =for apidoc Am|OP *|op_append_elem|I32 optype|OP *first|OP *last
3143
3144 Append an item to the list of ops contained directly within a list-type
3145 op, returning the lengthened list.  I<first> is the list-type op,
3146 and I<last> is the op to append to the list.  I<optype> specifies the
3147 intended opcode for the list.  If I<first> is not already a list of the
3148 right type, it will be upgraded into one.  If either I<first> or I<last>
3149 is null, the other is returned unchanged.
3150
3151 =cut
3152 */
3153
3154 OP *
3155 Perl_op_append_elem(pTHX_ I32 type, OP *first, OP *last)
3156 {
3157     if (!first)
3158         return last;
3159
3160     if (!last)
3161         return first;
3162
3163     if (first->op_type != (unsigned)type
3164         || (type == OP_LIST && (first->op_flags & OPf_PARENS)))
3165     {
3166         return newLISTOP(type, 0, first, last);
3167     }
3168
3169     if (first->op_flags & OPf_KIDS)
3170         ((LISTOP*)first)->op_last->op_sibling = last;
3171     else {
3172         first->op_flags |= OPf_KIDS;
3173         ((LISTOP*)first)->op_first = last;
3174     }
3175     ((LISTOP*)first)->op_last = last;
3176     return first;
3177 }
3178
3179 /*
3180 =for apidoc Am|OP *|op_append_list|I32 optype|OP *first|OP *last
3181
3182 Concatenate the lists of ops contained directly within two list-type ops,
3183 returning the combined list.  I<first> and I<last> are the list-type ops
3184 to concatenate.  I<optype> specifies the intended opcode for the list.
3185 If either I<first> or I<last> is not already a list of the right type,
3186 it will be upgraded into one.  If either I<first> or I<last> is null,
3187 the other is returned unchanged.
3188
3189 =cut
3190 */
3191
3192 OP *
3193 Perl_op_append_list(pTHX_ I32 type, OP *first, OP *last)
3194 {
3195     if (!first)
3196         return last;
3197
3198     if (!last)
3199         return first;
3200
3201     if (first->op_type != (unsigned)type)
3202         return op_prepend_elem(type, first, last);
3203
3204     if (last->op_type != (unsigned)type)
3205         return op_append_elem(type, first, last);
3206
3207     ((LISTOP*)first)->op_last->op_sibling = ((LISTOP*)last)->op_first;
3208     ((LISTOP*)first)->op_last = ((LISTOP*)last)->op_last;
3209     first->op_flags |= (last->op_flags & OPf_KIDS);
3210
3211 #ifdef PERL_MAD
3212     if (((LISTOP*)last)->op_first && first->op_madprop) {
3213         MADPROP *mp = ((LISTOP*)last)->op_first->op_madprop;
3214         if (mp) {
3215             while (mp->mad_next)
3216                 mp = mp->mad_next;
3217             mp->mad_next = first->op_madprop;
3218         }
3219         else {
3220             ((LISTOP*)last)->op_first->op_madprop = first->op_madprop;
3221         }
3222     }
3223     first->op_madprop = last->op_madprop;
3224     last->op_madprop = 0;
3225 #endif
3226
3227     S_op_destroy(aTHX_ last);
3228
3229     return first;
3230 }
3231
3232 /*
3233 =for apidoc Am|OP *|op_prepend_elem|I32 optype|OP *first|OP *last
3234
3235 Prepend an item to the list of ops contained directly within a list-type
3236 op, returning the lengthened list.  I<first> is the op to prepend to the
3237 list, and I<last> is the list-type op.  I<optype> specifies the intended
3238 opcode for the list.  If I<last> is not already a list of the right type,
3239 it will be upgraded into one.  If either I<first> or I<last> is null,
3240 the other is returned unchanged.
3241
3242 =cut
3243 */
3244
3245 OP *
3246 Perl_op_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
3247 {
3248     if (!first)
3249         return last;
3250
3251     if (!last)
3252         return first;
3253
3254     if (last->op_type == (unsigned)type) {
3255         if (type == OP_LIST) {  /* already a PUSHMARK there */
3256             first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
3257             ((LISTOP*)last)->op_first->op_sibling = first;
3258             if (!(first->op_flags & OPf_PARENS))
3259                 last->op_flags &= ~OPf_PARENS;
3260         }
3261         else {
3262             if (!(last->op_flags & OPf_KIDS)) {
3263                 ((LISTOP*)last)->op_last = first;
3264                 last->op_flags |= OPf_KIDS;
3265             }
3266             first->op_sibling = ((LISTOP*)last)->op_first;
3267             ((LISTOP*)last)->op_first = first;
3268         }
3269         last->op_flags |= OPf_KIDS;
3270         return last;
3271     }
3272
3273     return newLISTOP(type, 0, first, last);
3274 }
3275
3276 /* Constructors */
3277
3278 #ifdef PERL_MAD
3279  
3280 TOKEN *
3281 Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop)
3282 {
3283     TOKEN *tk;
3284     Newxz(tk, 1, TOKEN);
3285     tk->tk_type = (OPCODE)optype;
3286     tk->tk_type = 12345;
3287     tk->tk_lval = lval;
3288     tk->tk_mad = madprop;
3289     return tk;
3290 }
3291
3292 void
3293 Perl_token_free(pTHX_ TOKEN* tk)
3294 {
3295     PERL_ARGS_ASSERT_TOKEN_FREE;
3296
3297     if (tk->tk_type != 12345)
3298         return;
3299     mad_free(tk->tk_mad);
3300     Safefree(tk);
3301 }
3302
3303 void
3304 Perl_token_getmad(pTHX_ TOKEN* tk, OP* o, char slot)
3305 {
3306     MADPROP* mp;
3307     MADPROP* tm;
3308
3309     PERL_ARGS_ASSERT_TOKEN_GETMAD;
3310
3311     if (tk->tk_type != 12345) {
3312         Perl_warner(aTHX_ packWARN(WARN_MISC),
3313              "Invalid TOKEN object ignored");
3314         return;
3315     }
3316     tm = tk->tk_mad;
3317     if (!tm)
3318         return;
3319
3320     /* faked up qw list? */
3321     if (slot == '(' &&
3322         tm->mad_type == MAD_SV &&
3323         SvPVX((SV *)tm->mad_val)[0] == 'q')
3324             slot = 'x';
3325
3326     if (o) {
3327         mp = o->op_madprop;
3328         if (mp) {
3329             for (;;) {
3330                 /* pretend constant fold didn't happen? */
3331                 if (mp->mad_key == 'f' &&
3332                     (o->op_type == OP_CONST ||
3333                      o->op_type == OP_GV) )
3334                 {
3335                     token_getmad(tk,(OP*)mp->mad_val,slot);
3336                     return;
3337                 }
3338                 if (!mp->mad_next)
3339                     break;
3340                 mp = mp->mad_next;
3341             }
3342             mp->mad_next = tm;
3343             mp = mp->mad_next;
3344         }
3345         else {
3346             o->op_madprop = tm;
3347             mp = o->op_madprop;
3348         }
3349         if (mp->mad_key == 'X')
3350             mp->mad_key = slot; /* just change the first one */
3351
3352         tk->tk_mad = 0;
3353     }
3354     else
3355         mad_free(tm);
3356     Safefree(tk);
3357 }
3358
3359 void
3360 Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot)
3361 {
3362     MADPROP* mp;
3363     if (!from)
3364         return;
3365     if (o) {
3366         mp = o->op_madprop;
3367         if (mp) {
3368             for (;;) {
3369                 /* pretend constant fold didn't happen? */
3370                 if (mp->mad_key == 'f' &&
3371                     (o->op_type == OP_CONST ||
3372                      o->op_type == OP_GV) )
3373                 {
3374                     op_getmad(from,(OP*)mp->mad_val,slot);
3375                     return;
3376                 }
3377                 if (!mp->mad_next)
3378                     break;
3379                 mp = mp->mad_next;
3380             }
3381             mp->mad_next = newMADPROP(slot,MAD_OP,from,0);
3382         }
3383         else {
3384             o->op_madprop = newMADPROP(slot,MAD_OP,from,0);
3385         }
3386     }
3387 }
3388
3389 void
3390 Perl_op_getmad(pTHX_ OP* from, OP* o, char slot)
3391 {
3392     MADPROP* mp;
3393     if (!from)
3394         return;
3395     if (o) {
3396         mp = o->op_madprop;
3397         if (mp) {
3398             for (;;) {
3399                 /* pretend constant fold didn't happen? */
3400                 if (mp->mad_key == 'f' &&
3401                     (o->op_type == OP_CONST ||
3402                      o->op_type == OP_GV) )
3403                 {
3404                     op_getmad(from,(OP*)mp->mad_val,slot);
3405                     return;
3406                 }
3407                 if (!mp->mad_next)
3408                     break;
3409                 mp = mp->mad_next;
3410             }
3411             mp->mad_next = newMADPROP(slot,MAD_OP,from,1);
3412         }
3413         else {
3414             o->op_madprop = newMADPROP(slot,MAD_OP,from,1);
3415         }
3416     }
3417     else {
3418         PerlIO_printf(PerlIO_stderr(),
3419                       "DESTROYING op = %0"UVxf"\n", PTR2UV(from));
3420         op_free(from);
3421     }
3422 }
3423
3424 void
3425 Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot)
3426 {
3427     MADPROP* tm;
3428     if (!mp || !o)
3429         return;
3430     if (slot)
3431         mp->mad_key = slot;
3432     tm = o->op_madprop;
3433     o->op_madprop = mp;
3434     for (;;) {
3435         if (!mp->mad_next)
3436             break;
3437         mp = mp->mad_next;
3438     }
3439     mp->mad_next = tm;
3440 }
3441
3442 void
3443 Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot)
3444 {
3445     if (!o)
3446         return;
3447     addmad(tm, &(o->op_madprop), slot);
3448 }
3449
3450 void
3451 Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot)
3452 {
3453     MADPROP* mp;
3454     if (!tm || !root)
3455         return;
3456     if (slot)
3457         tm->mad_key = slot;
3458     mp = *root;
3459     if (!mp) {
3460         *root = tm;
3461         return;
3462     }
3463     for (;;) {
3464         if (!mp->mad_next)
3465             break;
3466         mp = mp->mad_next;
3467     }
3468     mp->mad_next = tm;
3469 }
3470
3471 MADPROP *
3472 Perl_newMADsv(pTHX_ char key, SV* sv)
3473 {
3474     PERL_ARGS_ASSERT_NEWMADSV;
3475
3476     return newMADPROP(key, MAD_SV, sv, 0);
3477 }
3478
3479 MADPROP *
3480 Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen)
3481 {
3482     MADPROP *const mp = (MADPROP *) PerlMemShared_malloc(sizeof(MADPROP));
3483     mp->mad_next = 0;
3484     mp->mad_key = key;
3485     mp->mad_vlen = vlen;
3486     mp->mad_type = type;
3487     mp->mad_val = val;
3488 /*    PerlIO_printf(PerlIO_stderr(), "NEW  mp = %0x\n", mp);  */
3489     return mp;
3490 }
3491
3492 void
3493 Perl_mad_free(pTHX_ MADPROP* mp)
3494 {
3495 /*    PerlIO_printf(PerlIO_stderr(), "FREE mp = %0x\n", mp); */
3496     if (!mp)
3497         return;
3498     if (mp->mad_next)
3499         mad_free(mp->mad_next);
3500 /*    if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING && mp->mad_vlen)
3501         PerlIO_printf(PerlIO_stderr(), "DESTROYING '%c'=<%s>\n", mp->mad_key & 255, mp->mad_val); */
3502     switch (mp->mad_type) {
3503     case MAD_NULL:
3504         break;
3505     case MAD_PV:
3506         Safefree((char*)mp->mad_val);
3507         break;
3508     case MAD_OP:
3509         if (mp->mad_vlen)       /* vlen holds "strong/weak" boolean */
3510             op_free((OP*)mp->mad_val);
3511         break;
3512     case MAD_SV:
3513         sv_free(MUTABLE_SV(mp->mad_val));
3514         break;
3515     default:
3516         PerlIO_printf(PerlIO_stderr(), "Unrecognized mad\n");
3517         break;
3518     }
3519     PerlMemShared_free(mp);
3520 }
3521
3522 #endif
3523
3524 /*
3525 =head1 Optree construction
3526
3527 =for apidoc Am|OP *|newNULLLIST
3528
3529 Constructs, checks, and returns a new C<stub> op, which represents an
3530 empty list expression.
3531
3532 =cut
3533 */
3534
3535 OP *
3536 Perl_newNULLLIST(pTHX)
3537 {
3538     return newOP(OP_STUB, 0);
3539 }
3540
3541 static OP *
3542 S_force_list(pTHX_ OP *o)
3543 {
3544     if (!o || o->op_type != OP_LIST)
3545         o = newLISTOP(OP_LIST, 0, o, NULL);
3546     op_null(o);
3547     return o;
3548 }
3549
3550 /*
3551 =for apidoc Am|OP *|newLISTOP|I32 type|I32 flags|OP *first|OP *last
3552
3553 Constructs, checks, and returns an op of any list type.  I<type> is
3554 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
3555 C<OPf_KIDS> will be set automatically if required.  I<first> and I<last>
3556 supply up to two ops to be direct children of the list op; they are
3557 consumed by this function and become part of the constructed op tree.
3558
3559 =cut
3560 */
3561
3562 OP *
3563 Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
3564 {
3565     dVAR;
3566     LISTOP *listop;
3567
3568     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_LISTOP);
3569
3570     NewOp(1101, listop, 1, LISTOP);
3571
3572     listop->op_type = (OPCODE)type;
3573     listop->op_ppaddr = PL_ppaddr[type];
3574     if (first || last)
3575         flags |= OPf_KIDS;
3576     listop->op_flags = (U8)flags;
3577
3578     if (!last && first)
3579         last = first;
3580     else if (!first && last)
3581         first = last;
3582     else if (first)
3583         first->op_sibling = last;
3584     listop->op_first = first;
3585     listop->op_last = last;
3586     if (type == OP_LIST) {
3587         OP* const pushop = newOP(OP_PUSHMARK, 0);
3588         pushop->op_sibling = first;
3589         listop->op_first = pushop;
3590         listop->op_flags |= OPf_KIDS;
3591         if (!last)
3592             listop->op_last = pushop;
3593     }
3594
3595     return CHECKOP(type, listop);
3596 }
3597
3598 /*
3599 =for apidoc Am|OP *|newOP|I32 type|I32 flags
3600
3601 Constructs, checks, and returns an op of any base type (any type that
3602 has no extra fields).  I<type> is the opcode.  I<flags> gives the
3603 eight bits of C<op_flags>, and, shifted up eight bits, the eight bits
3604 of C<op_private>.
3605
3606 =cut
3607 */
3608
3609 OP *
3610 Perl_newOP(pTHX_ I32 type, I32 flags)
3611 {
3612     dVAR;
3613     OP *o;
3614
3615     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP
3616         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
3617         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
3618         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
3619
3620     NewOp(1101, o, 1, OP);
3621     o->op_type = (OPCODE)type;
3622     o->op_ppaddr = PL_ppaddr[type];
3623     o->op_flags = (U8)flags;
3624     o->op_latefree = 0;
3625     o->op_latefreed = 0;
3626     o->op_attached = 0;
3627
3628     o->op_next = o;
3629     o->op_private = (U8)(0 | (flags >> 8));
3630     if (PL_opargs[type] & OA_RETSCALAR)
3631         scalar(o);
3632     if (PL_opargs[type] & OA_TARGET)
3633         o->op_targ = pad_alloc(type, SVs_PADTMP);
3634     return CHECKOP(type, o);
3635 }
3636
3637 /*
3638 =for apidoc Am|OP *|newUNOP|I32 type|I32 flags|OP *first
3639
3640 Constructs, checks, and returns an op of any unary type.  I<type> is
3641 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
3642 C<OPf_KIDS> will be set automatically if required, and, shifted up eight
3643 bits, the eight bits of C<op_private>, except that the bit with value 1
3644 is automatically set.  I<first> supplies an optional op to be the direct
3645 child of the unary op; it is consumed by this function and become part
3646 of the constructed op tree.
3647
3648 =cut
3649 */
3650
3651 OP *
3652 Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
3653 {
3654     dVAR;
3655     UNOP *unop;
3656
3657     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_UNOP
3658         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
3659         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
3660         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP
3661         || type == OP_SASSIGN
3662         || type == OP_ENTERTRY
3663         || type == OP_NULL );
3664
3665     if (!first)
3666         first = newOP(OP_STUB, 0);
3667     if (PL_opargs[type] & OA_MARK)
3668         first = force_list(first);
3669
3670     NewOp(1101, unop, 1, UNOP);
3671     unop->op_type = (OPCODE)type;
3672     unop->op_ppaddr = PL_ppaddr[type];
3673     unop->op_first = first;
3674     unop->op_flags = (U8)(flags | OPf_KIDS);
3675     unop->op_private = (U8)(1 | (flags >> 8));
3676     unop = (UNOP*) CHECKOP(type, unop);
3677     if (unop->op_next)
3678         return (OP*)unop;
3679
3680     return fold_constants(op_integerize(op_std_init((OP *) unop)));
3681 }
3682
3683 /*
3684 =for apidoc Am|OP *|newBINOP|I32 type|I32 flags|OP *first|OP *last
3685
3686 Constructs, checks, and returns an op of any binary type.  I<type>
3687 is the opcode.  I<flags> gives the eight bits of C<op_flags>, except
3688 that C<OPf_KIDS> will be set automatically, and, shifted up eight bits,
3689 the eight bits of C<op_private>, except that the bit with value 1 or
3690 2 is automatically set as required.  I<first> and I<last> supply up to
3691 two ops to be the direct children of the binary op; they are consumed
3692 by this function and become part of the constructed op tree.
3693
3694 =cut
3695 */
3696
3697 OP *
3698 Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
3699 {
3700     dVAR;
3701     BINOP *binop;
3702
3703     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BINOP
3704         || type == OP_SASSIGN || type == OP_NULL );
3705
3706     NewOp(1101, binop, 1, BINOP);
3707
3708     if (!first)
3709         first = newOP(OP_NULL, 0);
3710
3711     binop->op_type = (OPCODE)type;
3712     binop->op_ppaddr = PL_ppaddr[type];
3713     binop->op_first = first;
3714     binop->op_flags = (U8)(flags | OPf_KIDS);
3715     if (!last) {
3716         last = first;
3717         binop->op_private = (U8)(1 | (flags >> 8));
3718     }
3719     else {
3720         binop->op_private = (U8)(2 | (flags >> 8));
3721         first->op_sibling = last;
3722     }
3723
3724     binop = (BINOP*)CHECKOP(type, binop);
3725     if (binop->op_next || binop->op_type != (OPCODE)type)
3726         return (OP*)binop;
3727
3728     binop->op_last = binop->op_first->op_sibling;
3729
3730     return fold_constants(op_integerize(op_std_init((OP *)binop)));
3731 }
3732
3733 static int uvcompare(const void *a, const void *b)
3734     __attribute__nonnull__(1)
3735     __attribute__nonnull__(2)
3736     __attribute__pure__;
3737 static int uvcompare(const void *a, const void *b)
3738 {
3739     if (*((const UV *)a) < (*(const UV *)b))
3740         return -1;
3741     if (*((const UV *)a) > (*(const UV *)b))
3742         return 1;
3743     if (*((const UV *)a+1) < (*(const UV *)b+1))
3744         return -1;
3745     if (*((const UV *)a+1) > (*(const UV *)b+1))
3746         return 1;
3747     return 0;
3748 }
3749
3750 static OP *
3751 S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
3752 {
3753     dVAR;
3754     SV * const tstr = ((SVOP*)expr)->op_sv;
3755     SV * const rstr =
3756 #ifdef PERL_MAD
3757                         (repl->op_type == OP_NULL)
3758                             ? ((SVOP*)((LISTOP*)repl)->op_first)->op_sv :
3759 #endif
3760                               ((SVOP*)repl)->op_sv;
3761     STRLEN tlen;
3762     STRLEN rlen;
3763     const U8 *t = (U8*)SvPV_const(tstr, tlen);
3764     const U8 *r = (U8*)SvPV_const(rstr, rlen);
3765     register I32 i;
3766     register I32 j;
3767     I32 grows = 0;
3768     register short *tbl;
3769
3770     const I32 complement = o->op_private & OPpTRANS_COMPLEMENT;
3771     const I32 squash     = o->op_private & OPpTRANS_SQUASH;
3772     I32 del              = o->op_private & OPpTRANS_DELETE;
3773     SV* swash;
3774
3775     PERL_ARGS_ASSERT_PMTRANS;
3776
3777     PL_hints |= HINT_BLOCK_SCOPE;
3778
3779     if (SvUTF8(tstr))
3780         o->op_private |= OPpTRANS_FROM_UTF;
3781
3782     if (SvUTF8(rstr))
3783         o->op_private |= OPpTRANS_TO_UTF;
3784
3785     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
3786         SV* const listsv = newSVpvs("# comment\n");
3787         SV* transv = NULL;
3788         const U8* tend = t + tlen;
3789         const U8* rend = r + rlen;
3790         STRLEN ulen;
3791         UV tfirst = 1;
3792         UV tlast = 0;
3793         IV tdiff;
3794         UV rfirst = 1;
3795         UV rlast = 0;
3796         IV rdiff;
3797         IV diff;
3798         I32 none = 0;
3799         U32 max = 0;
3800         I32 bits;
3801         I32 havefinal = 0;
3802         U32 final = 0;
3803         const I32 from_utf  = o->op_private & OPpTRANS_FROM_UTF;
3804         const I32 to_utf    = o->op_private & OPpTRANS_TO_UTF;
3805         U8* tsave = NULL;
3806         U8* rsave = NULL;
3807         const U32 flags = UTF8_ALLOW_DEFAULT;
3808
3809         if (!from_utf) {
3810             STRLEN len = tlen;
3811             t = tsave = bytes_to_utf8(t, &len);
3812             tend = t + len;
3813         }
3814         if (!to_utf && rlen) {
3815             STRLEN len = rlen;
3816             r = rsave = bytes_to_utf8(r, &len);
3817             rend = r + len;
3818         }
3819
3820 /* There are several snags with this code on EBCDIC:
3821    1. 0xFF is a legal UTF-EBCDIC byte (there are no illegal bytes).
3822    2. scan_const() in toke.c has encoded chars in native encoding which makes
3823       ranges at least in EBCDIC 0..255 range the bottom odd.
3824 */
3825
3826         if (complement) {
3827             U8 tmpbuf[UTF8_MAXBYTES+1];
3828             UV *cp;
3829             UV nextmin = 0;
3830             Newx(cp, 2*tlen, UV);
3831             i = 0;
3832             transv = newSVpvs("");
3833             while (t < tend) {
3834                 cp[2*i] = utf8n_to_uvuni(t, tend-t, &ulen, flags);
3835                 t += ulen;
3836                 if (t < tend && NATIVE_TO_UTF(*t) == 0xff) {
3837                     t++;
3838                     cp[2*i+1] = utf8n_to_uvuni(t, tend-t, &ulen, flags);
3839                     t += ulen;
3840                 }
3841                 else {
3842                  cp[2*i+1] = cp[2*i];
3843                 }
3844                 i++;
3845             }
3846             qsort(cp, i, 2*sizeof(UV), uvcompare);
3847             for (j = 0; j < i; j++) {
3848                 UV  val = cp[2*j];
3849                 diff = val - nextmin;
3850                 if (diff > 0) {
3851                     t = uvuni_to_utf8(tmpbuf,nextmin);
3852                     sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3853                     if (diff > 1) {
3854                         U8  range_mark = UTF_TO_NATIVE(0xff);
3855                         t = uvuni_to_utf8(tmpbuf, val - 1);
3856                         sv_catpvn(transv, (char *)&range_mark, 1);
3857                         sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3858                     }
3859                 }
3860                 val = cp[2*j+1];
3861                 if (val >= nextmin)
3862                     nextmin = val + 1;
3863             }
3864             t = uvuni_to_utf8(tmpbuf,nextmin);
3865             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3866             {
3867                 U8 range_mark = UTF_TO_NATIVE(0xff);
3868                 sv_catpvn(transv, (char *)&range_mark, 1);
3869             }
3870             t = uvuni_to_utf8(tmpbuf, 0x7fffffff);
3871             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3872             t = (const U8*)SvPVX_const(transv);
3873             tlen = SvCUR(transv);
3874             tend = t + tlen;
3875             Safefree(cp);
3876         }
3877         else if (!rlen && !del) {
3878             r = t; rlen = tlen; rend = tend;
3879         }
3880         if (!squash) {
3881                 if ((!rlen && !del) || t == r ||
3882                     (tlen == rlen && memEQ((char *)t, (char *)r, tlen)))
3883                 {
3884                     o->op_private |= OPpTRANS_IDENTICAL;
3885                 }
3886         }
3887
3888         while (t < tend || tfirst <= tlast) {
3889             /* see if we need more "t" chars */
3890             if (tfirst > tlast) {
3891                 tfirst = (I32)utf8n_to_uvuni(t, tend - t, &ulen, flags);
3892                 t += ulen;
3893                 if (t < tend && NATIVE_TO_UTF(*t) == 0xff) {    /* illegal utf8 val indicates range */
3894                     t++;
3895                     tlast = (I32)utf8n_to_uvuni(t, tend - t, &ulen, flags);
3896                     t += ulen;
3897                 }
3898                 else
3899                     tlast = tfirst;
3900             }
3901
3902             /* now see if we need more "r" chars */
3903             if (rfirst > rlast) {
3904                 if (r < rend) {
3905                     rfirst = (I32)utf8n_to_uvuni(r, rend - r, &ulen, flags);
3906                     r += ulen;
3907                     if (r < rend && NATIVE_TO_UTF(*r) == 0xff) {        /* illegal utf8 val indicates range */
3908                         r++;
3909                         rlast = (I32)utf8n_to_uvuni(r, rend - r, &ulen, flags);
3910                         r += ulen;
3911                     }
3912                     else
3913                         rlast = rfirst;
3914                 }
3915                 else {
3916                     if (!havefinal++)
3917                         final = rlast;
3918                     rfirst = rlast = 0xffffffff;
3919                 }
3920             }
3921
3922             /* now see which range will peter our first, if either. */
3923             tdiff = tlast - tfirst;
3924             rdiff = rlast - rfirst;
3925
3926             if (tdiff <= rdiff)
3927                 diff = tdiff;
3928             else
3929                 diff = rdiff;
3930
3931             if (rfirst == 0xffffffff) {
3932                 diff = tdiff;   /* oops, pretend rdiff is infinite */
3933                 if (diff > 0)
3934                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\tXXXX\n",
3935                                    (long)tfirst, (long)tlast);
3936                 else
3937                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\tXXXX\n", (long)tfirst);
3938             }
3939             else {
3940                 if (diff > 0)
3941                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\t%04lx\n",
3942                                    (long)tfirst, (long)(tfirst + diff),
3943                                    (long)rfirst);
3944                 else
3945                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\t%04lx\n",
3946                                    (long)tfirst, (long)rfirst);
3947
3948                 if (rfirst + diff > max)
3949                     max = rfirst + diff;
3950                 if (!grows)
3951                     grows = (tfirst < rfirst &&
3952                              UNISKIP(tfirst) < UNISKIP(rfirst + diff));
3953                 rfirst += diff + 1;
3954             }
3955             tfirst += diff + 1;
3956         }
3957
3958         none = ++max;
3959         if (del)
3960             del = ++max;
3961
3962         if (max > 0xffff)
3963             bits = 32;
3964         else if (max > 0xff)
3965             bits = 16;
3966         else
3967             bits = 8;
3968
3969         PerlMemShared_free(cPVOPo->op_pv);
3970         cPVOPo->op_pv = NULL;
3971
3972         swash = MUTABLE_SV(swash_init("utf8", "", listsv, bits, none));
3973 #ifdef USE_ITHREADS
3974         cPADOPo->op_padix = pad_alloc(OP_TRANS, SVs_PADTMP);
3975         SvREFCNT_dec(PAD_SVl(cPADOPo->op_padix));
3976         PAD_SETSV(cPADOPo->op_padix, swash);
3977         SvPADTMP_on(swash);
3978         SvREADONLY_on(swash);
3979 #else
3980         cSVOPo->op_sv = swash;
3981 #endif
3982         SvREFCNT_dec(listsv);
3983         SvREFCNT_dec(transv);
3984
3985         if (!del && havefinal && rlen)
3986             (void)hv_store(MUTABLE_HV(SvRV(swash)), "FINAL", 5,
3987                            newSVuv((UV)final), 0);
3988
3989         if (grows)
3990             o->op_private |= OPpTRANS_GROWS;
3991
3992         Safefree(tsave);
3993         Safefree(rsave);
3994
3995 #ifdef PERL_MAD
3996         op_getmad(expr,o,'e');
3997         op_getmad(repl,o,'r');
3998 #else
3999         op_free(expr);
4000         op_free(repl);
4001 #endif
4002         return o;
4003     }
4004
4005     tbl = (short*)cPVOPo->op_pv;
4006     if (complement) {
4007         Zero(tbl, 256, short);
4008         for (i = 0; i < (I32)tlen; i++)
4009             tbl[t[i]] = -1;
4010         for (i = 0, j = 0; i < 256; i++) {
4011             if (!tbl[i]) {
4012                 if (j >= (I32)rlen) {
4013                     if (del)
4014                         tbl[i] = -2;
4015                     else if (rlen)
4016                         tbl[i] = r[j-1];
4017                     else
4018                         tbl[i] = (short)i;
4019                 }
4020                 else {
4021                     if (i < 128 && r[j] >= 128)
4022                         grows = 1;
4023                     tbl[i] = r[j++];
4024                 }
4025             }
4026         }
4027         if (!del) {
4028             if (!rlen) {
4029                 j = rlen;
4030                 if (!squash)
4031                     o->op_private |= OPpTRANS_IDENTICAL;
4032             }
4033             else if (j >= (I32)rlen)
4034                 j = rlen - 1;
4035             else {
4036                 tbl = 
4037                     (short *)
4038                     PerlMemShared_realloc(tbl,
4039                                           (0x101+rlen-j) * sizeof(short));
4040                 cPVOPo->op_pv = (char*)tbl;
4041             }
4042             tbl[0x100] = (short)(rlen - j);
4043             for (i=0; i < (I32)rlen - j; i++)
4044                 tbl[0x101+i] = r[j+i];
4045         }
4046     }
4047     else {
4048         if (!rlen && !del) {
4049             r = t; rlen = tlen;
4050             if (!squash)
4051                 o->op_private |= OPpTRANS_IDENTICAL;
4052         }
4053         else if (!squash && rlen == tlen && memEQ((char*)t, (char*)r, tlen)) {
4054             o->op_private |= OPpTRANS_IDENTICAL;
4055         }
4056         for (i = 0; i < 256; i++)
4057             tbl[i] = -1;
4058         for (i = 0, j = 0; i < (I32)tlen; i++,j++) {
4059             if (j >= (I32)rlen) {
4060                 if (del) {
4061                     if (tbl[t[i]] == -1)
4062                         tbl[t[i]] = -2;
4063                     continue;
4064                 }
4065                 --j;
4066             }
4067             if (tbl[t[i]] == -1) {
4068                 if (t[i] < 128 && r[j] >= 128)
4069                     grows = 1;
4070                 tbl[t[i]] = r[j];
4071             }
4072         }
4073     }
4074
4075     if(del && rlen == tlen) {
4076         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Useless use of /d modifier in transliteration operator"); 
4077     } else if(rlen > tlen) {
4078         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Replacement list is longer than search list");
4079     }
4080
4081     if (grows)
4082         o->op_private |= OPpTRANS_GROWS;
4083 #ifdef PERL_MAD
4084     op_getmad(expr,o,'e');
4085     op_getmad(repl,o,'r');
4086 #else
4087     op_free(expr);
4088     op_free(repl);
4089 #endif
4090
4091     return o;
4092 }
4093
4094 /*
4095 =for apidoc Am|OP *|newPMOP|I32 type|I32 flags
4096
4097 Constructs, checks, and returns an op of any pattern matching type.
4098 I<type> is the opcode.  I<flags> gives the eight bits of C<op_flags>
4099 and, shifted up eight bits, the eight bits of C<op_private>.
4100
4101 =cut
4102 */
4103
4104 OP *
4105 Perl_newPMOP(pTHX_ I32 type, I32 flags)
4106 {
4107     dVAR;
4108     PMOP *pmop;
4109
4110     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_PMOP);
4111
4112     NewOp(1101, pmop, 1, PMOP);
4113     pmop->op_type = (OPCODE)type;
4114     pmop->op_ppaddr = PL_ppaddr[type];
4115     pmop->op_flags = (U8)flags;
4116     pmop->op_private = (U8)(0 | (flags >> 8));
4117
4118     if (PL_hints & HINT_RE_TAINT)
4119         pmop->op_pmflags |= PMf_RETAINT;
4120     if (PL_hints & HINT_LOCALE) {
4121         set_regex_charset(&(pmop->op_pmflags), REGEX_LOCALE_CHARSET);
4122     }
4123     else if ((! (PL_hints & HINT_BYTES)) && (PL_hints & HINT_UNI_8_BIT)) {
4124         set_regex_charset(&(pmop->op_pmflags), REGEX_UNICODE_CHARSET);
4125     }
4126     if (PL_hints & HINT_RE_FLAGS) {
4127         SV *reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4128          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags"), 0, 0
4129         );
4130         if (reflags && SvOK(reflags)) pmop->op_pmflags |= SvIV(reflags);
4131         reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4132          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags_charset"), 0, 0
4133         );
4134         if (reflags && SvOK(reflags)) {
4135             set_regex_charset(&(pmop->op_pmflags), (regex_charset)SvIV(reflags));
4136         }
4137     }
4138
4139
4140 #ifdef USE_ITHREADS
4141     assert(SvPOK(PL_regex_pad[0]));
4142     if (SvCUR(PL_regex_pad[0])) {
4143         /* Pop off the "packed" IV from the end.  */
4144         SV *const repointer_list = PL_regex_pad[0];
4145         const char *p = SvEND(repointer_list) - sizeof(IV);
4146         const IV offset = *((IV*)p);
4147
4148         assert(SvCUR(repointer_list) % sizeof(IV) == 0);
4149
4150         SvEND_set(repointer_list, p);
4151
4152         pmop->op_pmoffset = offset;
4153         /* This slot should be free, so assert this:  */
4154         assert(PL_regex_pad[offset] == &PL_sv_undef);
4155     } else {
4156         SV * const repointer = &PL_sv_undef;
4157         av_push(PL_regex_padav, repointer);
4158         pmop->op_pmoffset = av_len(PL_regex_padav);
4159         PL_regex_pad = AvARRAY(PL_regex_padav);
4160     }
4161 #endif
4162
4163     return CHECKOP(type, pmop);
4164 }
4165
4166 /* Given some sort of match op o, and an expression expr containing a
4167  * pattern, either compile expr into a regex and attach it to o (if it's
4168  * constant), or convert expr into a runtime regcomp op sequence (if it's
4169  * not)
4170  *
4171  * isreg indicates that the pattern is part of a regex construct, eg
4172  * $x =~ /pattern/ or split /pattern/, as opposed to $x =~ $pattern or
4173  * split "pattern", which aren't. In the former case, expr will be a list
4174  * if the pattern contains more than one term (eg /a$b/) or if it contains
4175  * a replacement, ie s/// or tr///.
4176  */
4177
4178 OP *
4179 Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
4180 {
4181     dVAR;
4182     PMOP *pm;
4183     LOGOP *rcop;
4184     I32 repl_has_vars = 0;
4185     OP* repl = NULL;
4186     bool reglist;
4187
4188     PERL_ARGS_ASSERT_PMRUNTIME;
4189
4190     if (
4191         o->op_type == OP_SUBST
4192      || o->op_type == OP_TRANS || o->op_type == OP_TRANSR
4193     ) {
4194         /* last element in list is the replacement; pop it */
4195         OP* kid;
4196         repl = cLISTOPx(expr)->op_last;
4197         kid = cLISTOPx(expr)->op_first;
4198         while (kid->op_sibling != repl)
4199             kid = kid->op_sibling;
4200         kid->op_sibling = NULL;
4201         cLISTOPx(expr)->op_last = kid;
4202     }
4203
4204     if (isreg && expr->op_type == OP_LIST &&
4205         cLISTOPx(expr)->op_first->op_sibling == cLISTOPx(expr)->op_last)
4206     {
4207         /* convert single element list to element */
4208         OP* const oe = expr;
4209         expr = cLISTOPx(oe)->op_first->op_sibling;
4210         cLISTOPx(oe)->op_first->op_sibling = NULL;
4211         cLISTOPx(oe)->op_last = NULL;
4212         op_free(oe);
4213     }
4214
4215     if (o->op_type == OP_TRANS || o->op_type == OP_TRANSR) {
4216         return pmtrans(o, expr, repl);
4217     }
4218
4219     reglist = isreg && expr->op_type == OP_LIST;
4220     if (reglist)
4221         op_null(expr);
4222
4223     PL_hints |= HINT_BLOCK_SCOPE;
4224     pm = (PMOP*)o;
4225
4226     if (expr->op_type == OP_CONST) {
4227         SV *pat = ((SVOP*)expr)->op_sv;
4228         U32 pm_flags = pm->op_pmflags & RXf_PMf_COMPILETIME;
4229
4230         if (o->op_flags & OPf_SPECIAL)
4231             pm_flags |= RXf_SPLIT;
4232
4233         if (DO_UTF8(pat)) {
4234             assert (SvUTF8(pat));
4235         } else if (SvUTF8(pat)) {
4236             /* Not doing UTF-8, despite what the SV says. Is this only if we're
4237                trapped in use 'bytes'?  */
4238             /* Make a copy of the octet sequence, but without the flag on, as
4239                the compiler now honours the SvUTF8 flag on pat.  */
4240             STRLEN len;
4241             const char *const p = SvPV(pat, len);
4242             pat = newSVpvn_flags(p, len, SVs_TEMP);
4243         }
4244
4245         PM_SETRE(pm, CALLREGCOMP(pat, pm_flags));
4246
4247 #ifdef PERL_MAD
4248         op_getmad(expr,(OP*)pm,'e');
4249 #else
4250         op_free(expr);
4251 #endif
4252     }
4253     else {
4254         if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL))
4255             expr = newUNOP((!(PL_hints & HINT_RE_EVAL)
4256                             ? OP_REGCRESET
4257                             : OP_REGCMAYBE),0,expr);
4258
4259         NewOp(1101, rcop, 1, LOGOP);
4260         rcop->op_type = OP_REGCOMP;
4261         rcop->op_ppaddr = PL_ppaddr[OP_REGCOMP];
4262         rcop->op_first = scalar(expr);
4263         rcop->op_flags |= OPf_KIDS
4264                             | ((PL_hints & HINT_RE_EVAL) ? OPf_SPECIAL : 0)
4265                             | (reglist ? OPf_STACKED : 0);
4266         rcop->op_private = 1;
4267         rcop->op_other = o;
4268         if (reglist)
4269             rcop->op_targ = pad_alloc(rcop->op_type, SVs_PADTMP);
4270
4271         /* /$x/ may cause an eval, since $x might be qr/(?{..})/  */
4272         if (PL_hints & HINT_RE_EVAL) PL_cv_has_eval = 1;
4273
4274         /* establish postfix order */
4275         if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL)) {
4276             LINKLIST(expr);
4277             rcop->op_next = expr;
4278             ((UNOP*)expr)->op_first->op_next = (OP*)rcop;
4279         }
4280         else {
4281             rcop->op_next = LINKLIST(expr);
4282             expr->op_next = (OP*)rcop;
4283         }
4284
4285         op_prepend_elem(o->op_type, scalar((OP*)rcop), o);
4286     }
4287
4288     if (repl) {
4289         OP *curop;
4290         if (pm->op_pmflags & PMf_EVAL) {
4291             curop = NULL;
4292             if (CopLINE(PL_curcop) < (line_t)PL_parser->multi_end)
4293                 CopLINE_set(PL_curcop, (line_t)PL_parser->multi_end);
4294         }
4295         else if (repl->op_type == OP_CONST)
4296             curop = repl;
4297         else {
4298             OP *lastop = NULL;
4299             for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
4300                 if (curop->op_type == OP_SCOPE
4301                         || curop->op_type == OP_LEAVE
4302                         || (PL_opargs[curop->op_type] & OA_DANGEROUS)) {
4303                     if (curop->op_type == OP_GV) {
4304                         GV * const gv = cGVOPx_gv(curop);
4305                         repl_has_vars = 1;
4306                         if (strchr("&`'123456789+-\016\022", *GvENAME(gv)))
4307                             break;
4308                     }
4309                     else if (curop->op_type == OP_RV2CV)
4310                         break;
4311                     else if (curop->op_type == OP_RV2SV ||
4312                              curop->op_type == OP_RV2AV ||
4313                              curop->op_type == OP_RV2HV ||
4314                              curop->op_type == OP_RV2GV) {
4315                         if (lastop && lastop->op_type != OP_GV) /*funny deref?*/
4316                             break;
4317                     }
4318                     else if (curop->op_type == OP_PADSV ||
4319                              curop->op_type == OP_PADAV ||
4320                              curop->op_type == OP_PADHV ||
4321                              curop->op_type == OP_PADANY)
4322                     {
4323                         repl_has_vars = 1;
4324                     }
4325                     else if (curop->op_type == OP_PUSHRE)
4326                         NOOP; /* Okay here, dangerous in newASSIGNOP */
4327                     else
4328                         break;
4329                 }
4330                 lastop = curop;
4331             }
4332         }
4333         if (curop == repl
4334             && !(repl_has_vars
4335                  && (!PM_GETRE(pm)
4336                      || RX_EXTFLAGS(PM_GETRE(pm)) & RXf_EVAL_SEEN)))
4337         {
4338             pm->op_pmflags |= PMf_CONST;        /* const for long enough */
4339             op_prepend_elem(o->op_type, scalar(repl), o);
4340         }
4341         else {
4342             if (curop == repl && !PM_GETRE(pm)) { /* Has variables. */
4343                 pm->op_pmflags |= PMf_MAYBE_CONST;
4344             }
4345             NewOp(1101, rcop, 1, LOGOP);
4346             rcop->op_type = OP_SUBSTCONT;
4347             rcop->op_ppaddr = PL_ppaddr[OP_SUBSTCONT];
4348             rcop->op_first = scalar(repl);
4349             rcop->op_flags |= OPf_KIDS;
4350             rcop->op_private = 1;
4351             rcop->op_other = o;
4352
4353             /* establish postfix order */
4354             rcop->op_next = LINKLIST(repl);
4355             repl->op_next = (OP*)rcop;
4356
4357             pm->op_pmreplrootu.op_pmreplroot = scalar((OP*)rcop);
4358             assert(!(pm->op_pmflags & PMf_ONCE));
4359             pm->op_pmstashstartu.op_pmreplstart = LINKLIST(rcop);
4360             rcop->op_next = 0;
4361         }
4362     }
4363
4364     return (OP*)pm;
4365 }
4366
4367 /*
4368 =for apidoc Am|OP *|newSVOP|I32 type|I32 flags|SV *sv
4369
4370 Constructs, checks, and returns an op of any type that involves an
4371 embedded SV.  I<type> is the opcode.  I<flags> gives the eight bits
4372 of C<op_flags>.  I<sv> gives the SV to embed in the op; this function
4373 takes ownership of one reference to it.
4374
4375 =cut
4376 */
4377
4378 OP *
4379 Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv)
4380 {
4381     dVAR;
4382     SVOP *svop;
4383
4384     PERL_ARGS_ASSERT_NEWSVOP;
4385
4386     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_SVOP
4387         || (PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4388         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP);
4389
4390     NewOp(1101, svop, 1, SVOP);
4391     svop->op_type = (OPCODE)type;
4392     svop->op_ppaddr = PL_ppaddr[type];
4393     svop->op_sv = sv;
4394     svop->op_next = (OP*)svop;
4395     svop->op_flags = (U8)flags;
4396     if (PL_opargs[type] & OA_RETSCALAR)
4397         scalar((OP*)svop);
4398     if (PL_opargs[type] & OA_TARGET)
4399         svop->op_targ = pad_alloc(type, SVs_PADTMP);
4400     return CHECKOP(type, svop);
4401 }
4402
4403 #ifdef USE_ITHREADS
4404
4405 /*
4406 =for apidoc Am|OP *|newPADOP|I32 type|I32 flags|SV *sv
4407
4408 Constructs, checks, and returns an op of any type that involves a
4409 reference to a pad element.  I<type> is the opcode.  I<flags> gives the
4410 eight bits of C<op_flags>.  A pad slot is automatically allocated, and
4411 is populated with I<sv>; this function takes ownership of one reference
4412 to it.
4413
4414 This function only exists if Perl has been compiled to use ithreads.
4415
4416 =cut
4417 */
4418
4419 OP *
4420 Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv)
4421 {
4422     dVAR;
4423     PADOP *padop;
4424
4425     PERL_ARGS_ASSERT_NEWPADOP;
4426
4427     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_SVOP
4428         || (PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4429         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP);
4430
4431     NewOp(1101, padop, 1, PADOP);
4432     padop->op_type = (OPCODE)type;
4433     padop->op_ppaddr = PL_ppaddr[type];
4434     padop->op_padix = pad_alloc(type, SVs_PADTMP);
4435     SvREFCNT_dec(PAD_SVl(padop->op_padix));
4436     PAD_SETSV(padop->op_padix, sv);
4437     assert(sv);
4438     SvPADTMP_on(sv);
4439     padop->op_next = (OP*)padop;
4440     padop->op_flags = (U8)flags;
4441     if (PL_opargs[type] & OA_RETSCALAR)
4442         scalar((OP*)padop);
4443     if (PL_opargs[type] & OA_TARGET)
4444         padop->op_targ = pad_alloc(type, SVs_PADTMP);
4445     return CHECKOP(type, padop);
4446 }
4447
4448 #endif /* !USE_ITHREADS */
4449
4450 /*
4451 =for apidoc Am|OP *|newGVOP|I32 type|I32 flags|GV *gv
4452
4453 Constructs, checks, and returns an op of any type that involves an
4454 embedded reference to a GV.  I<type> is the opcode.  I<flags> gives the
4455 eight bits of C<op_flags>.  I<gv> identifies the GV that the op should
4456 reference; calling this function does not transfer ownership of any
4457 reference to it.
4458
4459 =cut
4460 */
4461
4462 OP *
4463 Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
4464 {
4465     dVAR;
4466
4467     PERL_ARGS_ASSERT_NEWGVOP;
4468
4469 #ifdef USE_ITHREADS
4470     GvIN_PAD_on(gv);
4471     return newPADOP(type, flags, SvREFCNT_inc_simple_NN(gv));
4472 #else
4473     return newSVOP(type, flags, SvREFCNT_inc_simple_NN(gv));
4474 #endif
4475 }
4476
4477 /*
4478 =for apidoc Am|OP *|newPVOP|I32 type|I32 flags|char *pv
4479
4480 Constructs, checks, and returns an op of any type that involves an
4481 embedded C-level pointer (PV).  I<type> is the opcode.  I<flags> gives
4482 the eight bits of C<op_flags>.  I<pv> supplies the C-level pointer, which
4483 must have been allocated using L</PerlMemShared_malloc>; the memory will
4484 be freed when the op is destroyed.
4485
4486 =cut
4487 */
4488
4489 OP *
4490 Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
4491 {
4492     dVAR;
4493     PVOP *pvop;
4494
4495     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4496         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
4497
4498     NewOp(1101, pvop, 1, PVOP);
4499     pvop->op_type = (OPCODE)type;
4500     pvop->op_ppaddr = PL_ppaddr[type];
4501     pvop->op_pv = pv;
4502     pvop->op_next = (OP*)pvop;
4503     pvop->op_flags = (U8)flags;
4504     if (PL_opargs[type] & OA_RETSCALAR)
4505         scalar((OP*)pvop);
4506     if (PL_opargs[type] & OA_TARGET)
4507         pvop->op_targ = pad_alloc(type, SVs_PADTMP);
4508     return CHECKOP(type, pvop);
4509 }
4510
4511 #ifdef PERL_MAD
4512 OP*
4513 #else
4514 void
4515 #endif
4516 Perl_package(pTHX_ OP *o)
4517 {
4518     dVAR;
4519     SV *const sv = cSVOPo->op_sv;
4520 #ifdef PERL_MAD
4521     OP *pegop;
4522 #endif
4523
4524     PERL_ARGS_ASSERT_PACKAGE;
4525
4526     save_hptr(&PL_curstash);
4527     save_item(PL_curstname);
4528
4529     PL_curstash = gv_stashsv(sv, GV_ADD);
4530
4531     sv_setsv(PL_curstname, sv);
4532
4533     PL_hints |= HINT_BLOCK_SCOPE;
4534     PL_parser->copline = NOLINE;
4535     PL_parser->expect = XSTATE;
4536
4537 #ifndef PERL_MAD
4538     op_free(o);
4539 #else
4540     if (!PL_madskills) {
4541         op_free(o);
4542         return NULL;
4543     }
4544
4545     pegop = newOP(OP_NULL,0);
4546     op_getmad(o,pegop,'P');
4547     return pegop;
4548 #endif
4549 }
4550
4551 void
4552 Perl_package_version( pTHX_ OP *v )
4553 {
4554     dVAR;
4555     U32 savehints = PL_hints;
4556     PERL_ARGS_ASSERT_PACKAGE_VERSION;
4557     PL_hints &= ~HINT_STRICT_VARS;
4558     sv_setsv( GvSV(gv_fetchpvs("VERSION", GV_ADDMULTI, SVt_PV)), cSVOPx(v)->op_sv );
4559     PL_hints = savehints;
4560     op_free(v);
4561 }
4562
4563 #ifdef PERL_MAD
4564 OP*
4565 #else
4566 void
4567 #endif
4568 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
4569 {
4570     dVAR;
4571     OP *pack;
4572     OP *imop;
4573     OP *veop;
4574 #ifdef PERL_MAD
4575     OP *pegop = newOP(OP_NULL,0);
4576 #endif
4577     SV *use_version = NULL;
4578
4579     PERL_ARGS_ASSERT_UTILIZE;
4580
4581     if (idop->op_type != OP_CONST)
4582         Perl_croak(aTHX_ "Module name must be constant");
4583
4584     if (PL_madskills)
4585         op_getmad(idop,pegop,'U');
4586
4587     veop = NULL;
4588
4589     if (version) {
4590         SV * const vesv = ((SVOP*)version)->op_sv;
4591
4592         if (PL_madskills)
4593             op_getmad(version,pegop,'V');
4594         if (!arg && !SvNIOKp(vesv)) {
4595             arg = version;
4596         }
4597         else {
4598             OP *pack;
4599             SV *meth;
4600
4601             if (version->op_type != OP_CONST || !SvNIOKp(vesv))
4602                 Perl_croak(aTHX_ "Version number must be a constant number");
4603
4604             /* Make copy of idop so we don't free it twice */
4605             pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
4606
4607             /* Fake up a method call to VERSION */
4608             meth = newSVpvs_share("VERSION");
4609             veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
4610                             op_append_elem(OP_LIST,
4611                                         op_prepend_elem(OP_LIST, pack, list(version)),
4612                                         newSVOP(OP_METHOD_NAMED, 0, meth)));
4613         }
4614     }
4615
4616     /* Fake up an import/unimport */
4617     if (arg && arg->op_type == OP_STUB) {
4618         if (PL_madskills)
4619             op_getmad(arg,pegop,'S');
4620         imop = arg;             /* no import on explicit () */
4621     }
4622     else if (SvNIOKp(((SVOP*)idop)->op_sv)) {
4623         imop = NULL;            /* use 5.0; */
4624         if (aver)
4625             use_version = ((SVOP*)idop)->op_sv;
4626         else
4627             idop->op_private |= OPpCONST_NOVER;
4628     }
4629     else {
4630         SV *meth;
4631
4632         if (PL_madskills)
4633             op_getmad(arg,pegop,'A');
4634
4635         /* Make copy of idop so we don't free it twice */
4636         pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
4637
4638         /* Fake up a method call to import/unimport */
4639         meth = aver
4640             ? newSVpvs_share("import") : newSVpvs_share("unimport");
4641         imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
4642                        op_append_elem(OP_LIST,
4643                                    op_prepend_elem(OP_LIST, pack, list(arg)),
4644                                    newSVOP(OP_METHOD_NAMED, 0, meth)));
4645     }
4646
4647     /* Fake up the BEGIN {}, which does its thing immediately. */
4648     newATTRSUB(floor,
4649         newSVOP(OP_CONST, 0, newSVpvs_share("BEGIN")),
4650         NULL,
4651         NULL,
4652         op_append_elem(OP_LINESEQ,
4653             op_append_elem(OP_LINESEQ,
4654                 newSTATEOP(0, NULL, newUNOP(OP_REQUIRE, 0, idop)),
4655                 newSTATEOP(0, NULL, veop)),
4656             newSTATEOP(0, NULL, imop) ));
4657
4658     if (use_version) {
4659         /* If we request a version >= 5.9.5, load feature.pm with the
4660          * feature bundle that corresponds to the required version. */
4661         use_version = sv_2mortal(new_version(use_version));
4662
4663         if (vcmp(use_version,
4664                  sv_2mortal(upg_version(newSVnv(5.009005), FALSE))) >= 0) {
4665             SV *const importsv = vnormal(use_version);
4666             *SvPVX_mutable(importsv) = ':';
4667             ENTER_with_name("load_feature");
4668             Perl_load_module(aTHX_ 0, newSVpvs("feature"), NULL, importsv, NULL);
4669             LEAVE_with_name("load_feature");
4670         }
4671         /* If a version >= 5.11.0 is requested, strictures are on by default! */
4672         if (vcmp(use_version,
4673                  sv_2mortal(upg_version(newSVnv(5.011000), FALSE))) >= 0) {
4674             PL_hints |= (HINT_STRICT_REFS | HINT_STRICT_SUBS | HINT_STRICT_VARS);
4675         }
4676     }
4677
4678     /* The "did you use incorrect case?" warning used to be here.
4679      * The problem is that on case-insensitive filesystems one
4680      * might get false positives for "use" (and "require"):
4681      * "use Strict" or "require CARP" will work.  This causes
4682      * portability problems for the script: in case-strict
4683      * filesystems the script will stop working.
4684      *
4685      * The "incorrect case" warning checked whether "use Foo"
4686      * imported "Foo" to your namespace, but that is wrong, too:
4687      * there is no requirement nor promise in the language that
4688      * a Foo.pm should or would contain anything in package "Foo".
4689      *
4690      * There is very little Configure-wise that can be done, either:
4691      * the case-sensitivity of the build filesystem of Perl does not
4692      * help in guessing the case-sensitivity of the runtime environment.
4693      */
4694
4695     PL_hints |= HINT_BLOCK_SCOPE;
4696     PL_parser->copline = NOLINE;
4697     PL_parser->expect = XSTATE;
4698     PL_cop_seqmax++; /* Purely for B::*'s benefit */
4699     if (PL_cop_seqmax == PERL_PADSEQ_INTRO) /* not a legal value */
4700         PL_cop_seqmax++;
4701
4702 #ifdef PERL_MAD
4703     if (!PL_madskills) {
4704         /* FIXME - don't allocate pegop if !PL_madskills */
4705         op_free(pegop);
4706         return NULL;
4707     }
4708     return pegop;
4709 #endif
4710 }
4711
4712 /*
4713 =head1 Embedding Functions
4714
4715 =for apidoc load_module
4716
4717 Loads the module whose name is pointed to by the string part of name.
4718 Note that the actual module name, not its filename, should be given.
4719 Eg, "Foo::Bar" instead of "Foo/Bar.pm".  flags can be any of
4720 PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, or PERL_LOADMOD_IMPORT_OPS
4721 (or 0 for no flags). ver, if specified, provides version semantics
4722 similar to C<use Foo::Bar VERSION>.  The optional trailing SV*
4723 arguments can be used to specify arguments to the module's import()
4724 method, similar to C<use Foo::Bar VERSION LIST>.  They must be
4725 terminated with a final NULL pointer.  Note that this list can only
4726 be omitted when the PERL_LOADMOD_NOIMPORT flag has been used.
4727 Otherwise at least a single NULL pointer to designate the default
4728 import list is required.
4729
4730 =cut */
4731
4732 void
4733 Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...)
4734 {
4735     va_list args;
4736
4737     PERL_ARGS_ASSERT_LOAD_MODULE;
4738
4739     va_start(args, ver);
4740     vload_module(flags, name, ver, &args);
4741     va_end(args);
4742 }
4743
4744 #ifdef PERL_IMPLICIT_CONTEXT
4745 void
4746 Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...)
4747 {
4748     dTHX;
4749     va_list args;
4750     PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT;
4751     va_start(args, ver);
4752     vload_module(flags, name, ver, &args);
4753     va_end(args);
4754 }
4755 #endif
4756
4757 void
4758 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
4759 {
4760     dVAR;
4761     OP *veop, *imop;
4762     OP * const modname = newSVOP(OP_CONST, 0, name);
4763
4764     PERL_ARGS_ASSERT_VLOAD_MODULE;
4765
4766     modname->op_private |= OPpCONST_BARE;
4767     if (ver) {
4768         veop = newSVOP(OP_CONST, 0, ver);
4769     }
4770     else
4771         veop = NULL;
4772     if (flags & PERL_LOADMOD_NOIMPORT) {
4773         imop = sawparens(newNULLLIST());
4774     }
4775     else if (flags & PERL_LOADMOD_IMPORT_OPS) {
4776         imop = va_arg(*args, OP*);
4777     }
4778     else {
4779         SV *sv;
4780         imop = NULL;
4781         sv = va_arg(*args, SV*);
4782         while (sv) {
4783             imop = op_append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
4784             sv = va_arg(*args, SV*);
4785         }
4786     }
4787
4788     /* utilize() fakes up a BEGIN { require ..; import ... }, so make sure
4789      * that it has a PL_parser to play with while doing that, and also
4790      * that it doesn't mess with any existing parser, by creating a tmp
4791      * new parser with lex_start(). This won't actually be used for much,
4792      * since pp_require() will create another parser for the real work. */
4793
4794     ENTER;
4795     SAVEVPTR(PL_curcop);
4796     lex_start(NULL, NULL, LEX_START_SAME_FILTER);
4797     utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
4798             veop, modname, imop);
4799     LEAVE;
4800 }
4801
4802 OP *
4803 Perl_dofile(pTHX_ OP *term, I32 force_builtin)
4804 {
4805     dVAR;
4806     OP *doop;
4807     GV *gv = NULL;
4808
4809     PERL_ARGS_ASSERT_DOFILE;
4810
4811     if (!force_builtin) {
4812         gv = gv_fetchpvs("do", GV_NOTQUAL, SVt_PVCV);
4813         if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
4814             GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "do", FALSE);
4815             gv = gvp ? *gvp : NULL;
4816         }
4817     }
4818
4819     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
4820         doop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
4821                                op_append_elem(OP_LIST, term,
4822                                            scalar(newUNOP(OP_RV2CV, 0,
4823                                                           newGVOP(OP_GV, 0, gv))))));
4824     }
4825     else {
4826         doop = newUNOP(OP_DOFILE, 0, scalar(term));
4827     }
4828     return doop;
4829 }
4830
4831 /*
4832 =head1 Optree construction
4833
4834 =for apidoc Am|OP *|newSLICEOP|I32 flags|OP *subscript|OP *listval
4835
4836 Constructs, checks, and returns an C<lslice> (list slice) op.  I<flags>
4837 gives the eight bits of C<op_flags>, except that C<OPf_KIDS> will
4838 be set automatically, and, shifted up eight bits, the eight bits of
4839 C<op_private>, except that the bit with value 1 or 2 is automatically
4840 set as required.  I<listval> and I<subscript> supply the parameters of
4841 the slice; they are consumed by this function and become part of the
4842 constructed op tree.
4843
4844 =cut
4845 */
4846
4847 OP *
4848 Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listval)
4849 {
4850     return newBINOP(OP_LSLICE, flags,
4851             list(force_list(subscript)),
4852             list(force_list(listval)) );
4853 }
4854
4855 STATIC I32
4856 S_is_list_assignment(pTHX_ register const OP *o)
4857 {
4858     unsigned type;
4859     U8 flags;
4860
4861     if (!o)
4862         return TRUE;
4863
4864     if ((o->op_type == OP_NULL) && (o->op_flags & OPf_KIDS))
4865         o = cUNOPo->op_first;
4866
4867     flags = o->op_flags;
4868     type = o->op_type;
4869     if (type == OP_COND_EXPR) {
4870         const I32 t = is_list_assignment(cLOGOPo->op_first->op_sibling);
4871         const I32 f = is_list_assignment(cLOGOPo->op_first->op_sibling->op_sibling);
4872
4873         if (t && f)
4874             return TRUE;
4875         if (t || f)
4876             yyerror("Assignment to both a list and a scalar");
4877         return FALSE;
4878     }
4879
4880     if (type == OP_LIST &&
4881         (flags & OPf_WANT) == OPf_WANT_SCALAR &&
4882         o->op_private & OPpLVAL_INTRO)
4883         return FALSE;
4884
4885     if (type == OP_LIST || flags & OPf_PARENS ||
4886         type == OP_RV2AV || type == OP_RV2HV ||
4887         type == OP_ASLICE || type == OP_HSLICE)
4888         return TRUE;
4889
4890     if (type == OP_PADAV || type == OP_PADHV)
4891         return TRUE;
4892
4893     if (type == OP_RV2SV)
4894         return FALSE;
4895
4896     return FALSE;
4897 }
4898
4899 /*
4900   Helper function for newASSIGNOP to detection commonality between the
4901   lhs and the rhs.  Marks all variables with PL_generation.  If it
4902   returns TRUE the assignment must be able to handle common variables.
4903 */
4904 PERL_STATIC_INLINE bool
4905 S_aassign_common_vars(pTHX_ OP* o)
4906 {
4907     OP *curop;
4908     for (curop = cUNOPo->op_first; curop; curop=curop->op_sibling) {
4909         if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
4910             if (curop->op_type == OP_GV) {
4911                 GV *gv = cGVOPx_gv(curop);
4912                 if (gv == PL_defgv
4913                     || (int)GvASSIGN_GENERATION(gv) == PL_generation)
4914                     return TRUE;
4915                 GvASSIGN_GENERATION_set(gv, PL_generation);
4916             }
4917             else if (curop->op_type == OP_PADSV ||
4918                 curop->op_type == OP_PADAV ||
4919                 curop->op_type == OP_PADHV ||
4920                 curop->op_type == OP_PADANY)
4921                 {
4922                     if (PAD_COMPNAME_GEN(curop->op_targ)