This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
ae599ad55faf8dd697fa3ab71b490a37b20fe1c0
[perl5.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_OR:
1264     case OP_AND:
1265         kid = cLOGOPo->op_first;
1266         if (kid->op_type == OP_NOT
1267             && (kid->op_flags & OPf_KIDS)
1268             && !PL_madskills) {
1269             if (o->op_type == OP_AND) {
1270                 o->op_type = OP_OR;
1271                 o->op_ppaddr = PL_ppaddr[OP_OR];
1272             } else {
1273                 o->op_type = OP_AND;
1274                 o->op_ppaddr = PL_ppaddr[OP_AND];
1275             }
1276             op_null(kid);
1277         }
1278
1279     case OP_DOR:
1280     case OP_COND_EXPR:
1281     case OP_ENTERGIVEN:
1282     case OP_ENTERWHEN:
1283         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1284             scalarvoid(kid);
1285         break;
1286
1287     case OP_NULL:
1288         if (o->op_flags & OPf_STACKED)
1289             break;
1290         /* FALL THROUGH */
1291     case OP_NEXTSTATE:
1292     case OP_DBSTATE:
1293     case OP_ENTERTRY:
1294     case OP_ENTER:
1295         if (!(o->op_flags & OPf_KIDS))
1296             break;
1297         /* FALL THROUGH */
1298     case OP_SCOPE:
1299     case OP_LEAVE:
1300     case OP_LEAVETRY:
1301     case OP_LEAVELOOP:
1302     case OP_LINESEQ:
1303     case OP_LIST:
1304     case OP_LEAVEGIVEN:
1305     case OP_LEAVEWHEN:
1306         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1307             scalarvoid(kid);
1308         break;
1309     case OP_ENTEREVAL:
1310         scalarkids(o);
1311         break;
1312     case OP_SCALAR:
1313         return scalar(o);
1314     }
1315     if (useless)
1316         Perl_ck_warner(aTHX_ packWARN(WARN_VOID), "Useless use of %s in void context", useless);
1317     return o;
1318 }
1319
1320 static OP *
1321 S_listkids(pTHX_ OP *o)
1322 {
1323     if (o && o->op_flags & OPf_KIDS) {
1324         OP *kid;
1325         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1326             list(kid);
1327     }
1328     return o;
1329 }
1330
1331 OP *
1332 Perl_list(pTHX_ OP *o)
1333 {
1334     dVAR;
1335     OP *kid;
1336
1337     /* assumes no premature commitment */
1338     if (!o || (o->op_flags & OPf_WANT)
1339          || (PL_parser && PL_parser->error_count)
1340          || o->op_type == OP_RETURN)
1341     {
1342         return o;
1343     }
1344
1345     if ((o->op_private & OPpTARGET_MY)
1346         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1347     {
1348         return o;                               /* As if inside SASSIGN */
1349     }
1350
1351     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
1352
1353     switch (o->op_type) {
1354     case OP_FLOP:
1355     case OP_REPEAT:
1356         list(cBINOPo->op_first);
1357         break;
1358     case OP_OR:
1359     case OP_AND:
1360     case OP_COND_EXPR:
1361         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1362             list(kid);
1363         break;
1364     default:
1365     case OP_MATCH:
1366     case OP_QR:
1367     case OP_SUBST:
1368     case OP_NULL:
1369         if (!(o->op_flags & OPf_KIDS))
1370             break;
1371         if (!o->op_next && cUNOPo->op_first->op_type == OP_FLOP) {
1372             list(cBINOPo->op_first);
1373             return gen_constant_list(o);
1374         }
1375     case OP_LIST:
1376         listkids(o);
1377         break;
1378     case OP_LEAVE:
1379     case OP_LEAVETRY:
1380         kid = cLISTOPo->op_first;
1381         list(kid);
1382         kid = kid->op_sibling;
1383     do_kids:
1384         while (kid) {
1385             OP *sib = kid->op_sibling;
1386             if (sib && kid->op_type != OP_LEAVEWHEN)
1387                 scalarvoid(kid);
1388             else
1389                 list(kid);
1390             kid = sib;
1391         }
1392         PL_curcop = &PL_compiling;
1393         break;
1394     case OP_SCOPE:
1395     case OP_LINESEQ:
1396         kid = cLISTOPo->op_first;
1397         goto do_kids;
1398     }
1399     return o;
1400 }
1401
1402 static OP *
1403 S_scalarseq(pTHX_ OP *o)
1404 {
1405     dVAR;
1406     if (o) {
1407         const OPCODE type = o->op_type;
1408
1409         if (type == OP_LINESEQ || type == OP_SCOPE ||
1410             type == OP_LEAVE || type == OP_LEAVETRY)
1411         {
1412             OP *kid;
1413             for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
1414                 if (kid->op_sibling) {
1415                     scalarvoid(kid);
1416                 }
1417             }
1418             PL_curcop = &PL_compiling;
1419         }
1420         o->op_flags &= ~OPf_PARENS;
1421         if (PL_hints & HINT_BLOCK_SCOPE)
1422             o->op_flags |= OPf_PARENS;
1423     }
1424     else
1425         o = newOP(OP_STUB, 0);
1426     return o;
1427 }
1428
1429 STATIC OP *
1430 S_modkids(pTHX_ OP *o, I32 type)
1431 {
1432     if (o && o->op_flags & OPf_KIDS) {
1433         OP *kid;
1434         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1435             op_lvalue(kid, type);
1436     }
1437     return o;
1438 }
1439
1440 /*
1441 =for apidoc finalize_optree
1442
1443 This function finalizes the optree. Should be called directly after
1444 the complete optree is built. It does some additional
1445 checking which can't be done in the normal ck_xxx functions and makes
1446 the tree thread-safe.
1447
1448 =cut
1449 */
1450 void
1451 Perl_finalize_optree(pTHX_ OP* o)
1452 {
1453     PERL_ARGS_ASSERT_FINALIZE_OPTREE;
1454
1455     ENTER;
1456     SAVEVPTR(PL_curcop);
1457
1458     finalize_op(o);
1459
1460     LEAVE;
1461 }
1462
1463 void
1464 S_finalize_op(pTHX_ OP* o)
1465 {
1466     PERL_ARGS_ASSERT_FINALIZE_OP;
1467
1468 #if defined(PERL_MAD) && defined(USE_ITHREADS)
1469     {
1470         /* Make sure mad ops are also thread-safe */
1471         MADPROP *mp = o->op_madprop;
1472         while (mp) {
1473             if (mp->mad_type == MAD_OP && mp->mad_vlen) {
1474                 OP *prop_op = (OP *) mp->mad_val;
1475                 /* We only need "Relocate sv to the pad for thread safety.", but this
1476                    easiest way to make sure it traverses everything */
1477                 if (prop_op->op_type == OP_CONST)
1478                     cSVOPx(prop_op)->op_private &= ~OPpCONST_STRICT;
1479                 finalize_op(prop_op);
1480             }
1481             mp = mp->mad_next;
1482         }
1483     }
1484 #endif
1485
1486     switch (o->op_type) {
1487     case OP_NEXTSTATE:
1488     case OP_DBSTATE:
1489         PL_curcop = ((COP*)o);          /* for warnings */
1490         break;
1491     case OP_EXEC:
1492         if ( o->op_sibling
1493             && (o->op_sibling->op_type == OP_NEXTSTATE || o->op_sibling->op_type == OP_DBSTATE)
1494             && ckWARN(WARN_SYNTAX))
1495             {
1496                 if (o->op_sibling->op_sibling) {
1497                     const OPCODE type = o->op_sibling->op_sibling->op_type;
1498                     if (type != OP_EXIT && type != OP_WARN && type != OP_DIE) {
1499                         const line_t oldline = CopLINE(PL_curcop);
1500                         CopLINE_set(PL_curcop, CopLINE((COP*)o->op_sibling));
1501                         Perl_warner(aTHX_ packWARN(WARN_EXEC),
1502                             "Statement unlikely to be reached");
1503                         Perl_warner(aTHX_ packWARN(WARN_EXEC),
1504                             "\t(Maybe you meant system() when you said exec()?)\n");
1505                         CopLINE_set(PL_curcop, oldline);
1506                     }
1507                 }
1508             }
1509         break;
1510
1511     case OP_GV:
1512         if ((o->op_private & OPpEARLY_CV) && ckWARN(WARN_PROTOTYPE)) {
1513             GV * const gv = cGVOPo_gv;
1514             if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX_const(GvCV(gv))) {
1515                 /* XXX could check prototype here instead of just carping */
1516                 SV * const sv = sv_newmortal();
1517                 gv_efullname3(sv, gv, NULL);
1518                 Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
1519                     "%"SVf"() called too early to check prototype",
1520                     SVfARG(sv));
1521             }
1522         }
1523         break;
1524
1525     case OP_CONST:
1526         if (cSVOPo->op_private & OPpCONST_STRICT)
1527             no_bareword_allowed(o);
1528         /* FALLTHROUGH */
1529 #ifdef USE_ITHREADS
1530     case OP_HINTSEVAL:
1531     case OP_METHOD_NAMED:
1532         /* Relocate sv to the pad for thread safety.
1533          * Despite being a "constant", the SV is written to,
1534          * for reference counts, sv_upgrade() etc. */
1535         if (cSVOPo->op_sv) {
1536             const PADOFFSET ix = pad_alloc(OP_CONST, SVs_PADTMP);
1537             if (o->op_type != OP_METHOD_NAMED &&
1538                 (SvPADTMP(cSVOPo->op_sv) || SvPADMY(cSVOPo->op_sv)))
1539             {
1540                 /* If op_sv is already a PADTMP/MY then it is being used by
1541                  * some pad, so make a copy. */
1542                 sv_setsv(PAD_SVl(ix),cSVOPo->op_sv);
1543                 SvREADONLY_on(PAD_SVl(ix));
1544                 SvREFCNT_dec(cSVOPo->op_sv);
1545             }
1546             else if (o->op_type != OP_METHOD_NAMED
1547                 && cSVOPo->op_sv == &PL_sv_undef) {
1548                 /* PL_sv_undef is hack - it's unsafe to store it in the
1549                    AV that is the pad, because av_fetch treats values of
1550                    PL_sv_undef as a "free" AV entry and will merrily
1551                    replace them with a new SV, causing pad_alloc to think
1552                    that this pad slot is free. (When, clearly, it is not)
1553                 */
1554                 SvOK_off(PAD_SVl(ix));
1555                 SvPADTMP_on(PAD_SVl(ix));
1556                 SvREADONLY_on(PAD_SVl(ix));
1557             }
1558             else {
1559                 SvREFCNT_dec(PAD_SVl(ix));
1560                 SvPADTMP_on(cSVOPo->op_sv);
1561                 PAD_SETSV(ix, cSVOPo->op_sv);
1562                 /* XXX I don't know how this isn't readonly already. */
1563                 SvREADONLY_on(PAD_SVl(ix));
1564             }
1565             cSVOPo->op_sv = NULL;
1566             o->op_targ = ix;
1567         }
1568 #endif
1569         break;
1570
1571     case OP_HELEM: {
1572         UNOP *rop;
1573         SV *lexname;
1574         GV **fields;
1575         SV **svp, *sv;
1576         const char *key = NULL;
1577         STRLEN keylen;
1578
1579         if (((BINOP*)o)->op_last->op_type != OP_CONST)
1580             break;
1581
1582         /* Make the CONST have a shared SV */
1583         svp = cSVOPx_svp(((BINOP*)o)->op_last);
1584         if ((!SvFAKE(sv = *svp) || !SvREADONLY(sv))
1585             && SvTYPE(sv) < SVt_PVMG && !SvROK(sv)) {
1586             key = SvPV_const(sv, keylen);
1587             lexname = newSVpvn_share(key,
1588                 SvUTF8(sv) ? -(I32)keylen : (I32)keylen,
1589                 0);
1590             SvREFCNT_dec(sv);
1591             *svp = lexname;
1592         }
1593
1594         if ((o->op_private & (OPpLVAL_INTRO)))
1595             break;
1596
1597         rop = (UNOP*)((BINOP*)o)->op_first;
1598         if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
1599             break;
1600         lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
1601         if (!SvPAD_TYPED(lexname))
1602             break;
1603         fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
1604         if (!fields || !GvHV(*fields))
1605             break;
1606         key = SvPV_const(*svp, keylen);
1607         if (!hv_fetch(GvHV(*fields), key,
1608                 SvUTF8(*svp) ? -(I32)keylen : (I32)keylen, FALSE)) {
1609             Perl_croak(aTHX_ "No such class field \"%s\" "
1610                 "in variable %s of type %s",
1611                 key, SvPV_nolen_const(lexname), HvNAME_get(SvSTASH(lexname)));
1612         }
1613         break;
1614     }
1615
1616     case OP_HSLICE: {
1617         UNOP *rop;
1618         SV *lexname;
1619         GV **fields;
1620         SV **svp;
1621         const char *key;
1622         STRLEN keylen;
1623         SVOP *first_key_op, *key_op;
1624
1625         if ((o->op_private & (OPpLVAL_INTRO))
1626             /* I bet there's always a pushmark... */
1627             || ((LISTOP*)o)->op_first->op_sibling->op_type != OP_LIST)
1628             /* hmmm, no optimization if list contains only one key. */
1629             break;
1630         rop = (UNOP*)((LISTOP*)o)->op_last;
1631         if (rop->op_type != OP_RV2HV)
1632             break;
1633         if (rop->op_first->op_type == OP_PADSV)
1634             /* @$hash{qw(keys here)} */
1635             rop = (UNOP*)rop->op_first;
1636         else {
1637             /* @{$hash}{qw(keys here)} */
1638             if (rop->op_first->op_type == OP_SCOPE
1639                 && cLISTOPx(rop->op_first)->op_last->op_type == OP_PADSV)
1640                 {
1641                     rop = (UNOP*)cLISTOPx(rop->op_first)->op_last;
1642                 }
1643             else
1644                 break;
1645         }
1646
1647         lexname = *av_fetch(PL_comppad_name, rop->op_targ, TRUE);
1648         if (!SvPAD_TYPED(lexname))
1649             break;
1650         fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
1651         if (!fields || !GvHV(*fields))
1652             break;
1653         /* Again guessing that the pushmark can be jumped over.... */
1654         first_key_op = (SVOP*)((LISTOP*)((LISTOP*)o)->op_first->op_sibling)
1655             ->op_first->op_sibling;
1656         for (key_op = first_key_op; key_op;
1657              key_op = (SVOP*)key_op->op_sibling) {
1658             if (key_op->op_type != OP_CONST)
1659                 continue;
1660             svp = cSVOPx_svp(key_op);
1661             key = SvPV_const(*svp, keylen);
1662             if (!hv_fetch(GvHV(*fields), key,
1663                     SvUTF8(*svp) ? -(I32)keylen : (I32)keylen, FALSE)) {
1664                 Perl_croak(aTHX_ "No such class field \"%s\" "
1665                     "in variable %s of type %s",
1666                     key, SvPV_nolen(lexname), HvNAME_get(SvSTASH(lexname)));
1667             }
1668         }
1669         break;
1670     }
1671     case OP_SUBST: {
1672         if (cPMOPo->op_pmreplrootu.op_pmreplroot)
1673             finalize_op(cPMOPo->op_pmreplrootu.op_pmreplroot);
1674         break;
1675     }
1676     default:
1677         break;
1678     }
1679
1680     if (o->op_flags & OPf_KIDS) {
1681         OP *kid;
1682         for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
1683             finalize_op(kid);
1684     }
1685 }
1686
1687 /*
1688 =for apidoc Amx|OP *|op_lvalue|OP *o|I32 type
1689
1690 Propagate lvalue ("modifiable") context to an op and its children.
1691 I<type> represents the context type, roughly based on the type of op that
1692 would do the modifying, although C<local()> is represented by OP_NULL,
1693 because it has no op type of its own (it is signalled by a flag on
1694 the lvalue op).
1695
1696 This function detects things that can't be modified, such as C<$x+1>, and
1697 generates errors for them. For example, C<$x+1 = 2> would cause it to be
1698 called with an op of type OP_ADD and a C<type> argument of OP_SASSIGN.
1699
1700 It also flags things that need to behave specially in an lvalue context,
1701 such as C<$$x = 5> which might have to vivify a reference in C<$x>.
1702
1703 =cut
1704 */
1705
1706 OP *
1707 Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags)
1708 {
1709     dVAR;
1710     OP *kid;
1711     /* -1 = error on localize, 0 = ignore localize, 1 = ok to localize */
1712     int localize = -1;
1713
1714     if (!o || (PL_parser && PL_parser->error_count))
1715         return o;
1716
1717     if ((o->op_private & OPpTARGET_MY)
1718         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1719     {
1720         return o;
1721     }
1722
1723     assert( (o->op_flags & OPf_WANT) != OPf_WANT_VOID );
1724
1725     switch (o->op_type) {
1726     case OP_UNDEF:
1727         localize = 0;
1728         PL_modcount++;
1729         return o;
1730     case OP_CONST:
1731         if (!(o->op_private & OPpCONST_ARYBASE))
1732             goto nomod;
1733         localize = 0;
1734         if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
1735             CopARYBASE_set(&PL_compiling,
1736                            (I32)SvIV(cSVOPx(PL_eval_start)->op_sv));
1737             PL_eval_start = 0;
1738         }
1739         else if (!type) {
1740             SAVECOPARYBASE(&PL_compiling);
1741             CopARYBASE_set(&PL_compiling, 0);
1742         }
1743         else if (type == OP_REFGEN)
1744             goto nomod;
1745         else
1746             Perl_croak(aTHX_ "That use of $[ is unsupported");
1747         break;
1748     case OP_STUB:
1749         if ((o->op_flags & OPf_PARENS) || PL_madskills)
1750             break;
1751         goto nomod;
1752     case OP_ENTERSUB:
1753         if ((type == OP_UNDEF || type == OP_REFGEN || type == OP_LOCK) &&
1754             !(o->op_flags & OPf_STACKED)) {
1755             o->op_type = OP_RV2CV;              /* entersub => rv2cv */
1756             /* Both ENTERSUB and RV2CV use this bit, but for different pur-
1757                poses, so we need it clear.  */
1758             o->op_private &= ~1;
1759             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
1760             assert(cUNOPo->op_first->op_type == OP_NULL);
1761             op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
1762             break;
1763         }
1764         else {                          /* lvalue subroutine call */
1765             o->op_private |= OPpLVAL_INTRO
1766                            |(OPpENTERSUB_INARGS * (type == OP_LEAVESUBLV));
1767             PL_modcount = RETURN_UNLIMITED_NUMBER;
1768             if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) {
1769                 /* Backward compatibility mode: */
1770                 o->op_private |= OPpENTERSUB_INARGS;
1771                 break;
1772             }
1773             else {                      /* Compile-time error message: */
1774                 OP *kid = cUNOPo->op_first;
1775                 CV *cv;
1776                 OP *okid;
1777
1778                 if (kid->op_type != OP_PUSHMARK) {
1779                     if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
1780                         Perl_croak(aTHX_
1781                                 "panic: unexpected lvalue entersub "
1782                                 "args: type/targ %ld:%"UVuf,
1783                                 (long)kid->op_type, (UV)kid->op_targ);
1784                     kid = kLISTOP->op_first;
1785                 }
1786                 while (kid->op_sibling)
1787                     kid = kid->op_sibling;
1788                 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
1789                     /* Indirect call */
1790                     if (kid->op_type == OP_METHOD_NAMED
1791                         || kid->op_type == OP_METHOD)
1792                     {
1793                         UNOP *newop;
1794
1795                         NewOp(1101, newop, 1, UNOP);
1796                         newop->op_type = OP_RV2CV;
1797                         newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
1798                         newop->op_first = NULL;
1799                         newop->op_next = (OP*)newop;
1800                         kid->op_sibling = (OP*)newop;
1801                         newop->op_private |= OPpLVAL_INTRO;
1802                         newop->op_private &= ~1;
1803                         break;
1804                     }
1805
1806                     if (kid->op_type != OP_RV2CV)
1807                         Perl_croak(aTHX_
1808                                    "panic: unexpected lvalue entersub "
1809                                    "entry via type/targ %ld:%"UVuf,
1810                                    (long)kid->op_type, (UV)kid->op_targ);
1811                     kid->op_private |= OPpLVAL_INTRO;
1812                     break;      /* Postpone until runtime */
1813                 }
1814
1815                 okid = kid;
1816                 kid = kUNOP->op_first;
1817                 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
1818                     kid = kUNOP->op_first;
1819                 if (kid->op_type == OP_NULL)
1820                     Perl_croak(aTHX_
1821                                "Unexpected constant lvalue entersub "
1822                                "entry via type/targ %ld:%"UVuf,
1823                                (long)kid->op_type, (UV)kid->op_targ);
1824                 if (kid->op_type != OP_GV) {
1825                     /* Restore RV2CV to check lvalueness */
1826                   restore_2cv:
1827                     if (kid->op_next && kid->op_next != kid) { /* Happens? */
1828                         okid->op_next = kid->op_next;
1829                         kid->op_next = okid;
1830                     }
1831                     else
1832                         okid->op_next = NULL;
1833                     okid->op_type = OP_RV2CV;
1834                     okid->op_targ = 0;
1835                     okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
1836                     okid->op_private |= OPpLVAL_INTRO;
1837                     okid->op_private &= ~1;
1838                     break;
1839                 }
1840
1841                 cv = GvCV(kGVOP_gv);
1842                 if (!cv)
1843                     goto restore_2cv;
1844                 if (CvLVALUE(cv))
1845                     break;
1846             }
1847         }
1848         /* FALL THROUGH */
1849     default:
1850       nomod:
1851         if (flags & OP_LVALUE_NO_CROAK) return NULL;
1852         /* grep, foreach, subcalls, refgen */
1853         if (type == OP_GREPSTART || type == OP_ENTERSUB
1854          || type == OP_REFGEN    || type == OP_LEAVESUBLV)
1855             break;
1856         yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
1857                      (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
1858                       ? "do block"
1859                       : (o->op_type == OP_ENTERSUB
1860                         ? "non-lvalue subroutine call"
1861                         : OP_DESC(o))),
1862                      type ? PL_op_desc[type] : "local"));
1863         return o;
1864
1865     case OP_PREINC:
1866     case OP_PREDEC:
1867     case OP_POW:
1868     case OP_MULTIPLY:
1869     case OP_DIVIDE:
1870     case OP_MODULO:
1871     case OP_REPEAT:
1872     case OP_ADD:
1873     case OP_SUBTRACT:
1874     case OP_CONCAT:
1875     case OP_LEFT_SHIFT:
1876     case OP_RIGHT_SHIFT:
1877     case OP_BIT_AND:
1878     case OP_BIT_XOR:
1879     case OP_BIT_OR:
1880     case OP_I_MULTIPLY:
1881     case OP_I_DIVIDE:
1882     case OP_I_MODULO:
1883     case OP_I_ADD:
1884     case OP_I_SUBTRACT:
1885         if (!(o->op_flags & OPf_STACKED))
1886             goto nomod;
1887         PL_modcount++;
1888         break;
1889
1890     case OP_COND_EXPR:
1891         localize = 1;
1892         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1893             op_lvalue(kid, type);
1894         break;
1895
1896     case OP_RV2AV:
1897     case OP_RV2HV:
1898         if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
1899            PL_modcount = RETURN_UNLIMITED_NUMBER;
1900             return o;           /* Treat \(@foo) like ordinary list. */
1901         }
1902         /* FALL THROUGH */
1903     case OP_RV2GV:
1904         if (scalar_mod_type(o, type))
1905             goto nomod;
1906         ref(cUNOPo->op_first, o->op_type);
1907         /* FALL THROUGH */
1908     case OP_ASLICE:
1909     case OP_HSLICE:
1910         if (type == OP_LEAVESUBLV)
1911             o->op_private |= OPpMAYBE_LVSUB;
1912         localize = 1;
1913         /* FALL THROUGH */
1914     case OP_AASSIGN:
1915     case OP_NEXTSTATE:
1916     case OP_DBSTATE:
1917        PL_modcount = RETURN_UNLIMITED_NUMBER;
1918         break;
1919     case OP_AV2ARYLEN:
1920         PL_hints |= HINT_BLOCK_SCOPE;
1921         if (type == OP_LEAVESUBLV)
1922             o->op_private |= OPpMAYBE_LVSUB;
1923         PL_modcount++;
1924         break;
1925     case OP_RV2SV:
1926         ref(cUNOPo->op_first, o->op_type);
1927         localize = 1;
1928         /* FALL THROUGH */
1929     case OP_GV:
1930         PL_hints |= HINT_BLOCK_SCOPE;
1931     case OP_SASSIGN:
1932     case OP_ANDASSIGN:
1933     case OP_ORASSIGN:
1934     case OP_DORASSIGN:
1935         PL_modcount++;
1936         break;
1937
1938     case OP_AELEMFAST:
1939     case OP_AELEMFAST_LEX:
1940         localize = -1;
1941         PL_modcount++;
1942         break;
1943
1944     case OP_PADAV:
1945     case OP_PADHV:
1946        PL_modcount = RETURN_UNLIMITED_NUMBER;
1947         if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
1948             return o;           /* Treat \(@foo) like ordinary list. */
1949         if (scalar_mod_type(o, type))
1950             goto nomod;
1951         if (type == OP_LEAVESUBLV)
1952             o->op_private |= OPpMAYBE_LVSUB;
1953         /* FALL THROUGH */
1954     case OP_PADSV:
1955         PL_modcount++;
1956         if (!type) /* local() */
1957             Perl_croak(aTHX_ "Can't localize lexical variable %"SVf,
1958                  PAD_COMPNAME_SV(o->op_targ));
1959         break;
1960
1961     case OP_PUSHMARK:
1962         localize = 0;
1963         break;
1964
1965     case OP_KEYS:
1966     case OP_RKEYS:
1967         if (type != OP_SASSIGN && type != OP_LEAVESUBLV)
1968             goto nomod;
1969         goto lvalue_func;
1970     case OP_SUBSTR:
1971         if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
1972             goto nomod;
1973         /* FALL THROUGH */
1974     case OP_POS:
1975     case OP_VEC:
1976       lvalue_func:
1977         if (type == OP_LEAVESUBLV)
1978             o->op_private |= OPpMAYBE_LVSUB;
1979         pad_free(o->op_targ);
1980         o->op_targ = pad_alloc(o->op_type, SVs_PADMY);
1981         assert(SvTYPE(PAD_SV(o->op_targ)) == SVt_NULL);
1982         if (o->op_flags & OPf_KIDS)
1983             op_lvalue(cBINOPo->op_first->op_sibling, type);
1984         break;
1985
1986     case OP_AELEM:
1987     case OP_HELEM:
1988         ref(cBINOPo->op_first, o->op_type);
1989         if (type == OP_ENTERSUB &&
1990              !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
1991             o->op_private |= OPpLVAL_DEFER;
1992         if (type == OP_LEAVESUBLV)
1993             o->op_private |= OPpMAYBE_LVSUB;
1994         localize = 1;
1995         PL_modcount++;
1996         break;
1997
1998     case OP_SCOPE:
1999     case OP_LEAVE:
2000     case OP_ENTER:
2001     case OP_LINESEQ:
2002         localize = 0;
2003         if (o->op_flags & OPf_KIDS)
2004             op_lvalue(cLISTOPo->op_last, type);
2005         break;
2006
2007     case OP_NULL:
2008         localize = 0;
2009         if (o->op_flags & OPf_SPECIAL)          /* do BLOCK */
2010             goto nomod;
2011         else if (!(o->op_flags & OPf_KIDS))
2012             break;
2013         if (o->op_targ != OP_LIST) {
2014             op_lvalue(cBINOPo->op_first, type);
2015             break;
2016         }
2017         /* FALL THROUGH */
2018     case OP_LIST:
2019         localize = 0;
2020         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2021             /* elements might be in void context because the list is
2022                in scalar context or because they are attribute sub calls */
2023             if ( (kid->op_flags & OPf_WANT) != OPf_WANT_VOID )
2024                 op_lvalue(kid, type);
2025         break;
2026
2027     case OP_RETURN:
2028         if (type != OP_LEAVESUBLV)
2029             goto nomod;
2030         break; /* op_lvalue()ing was handled by ck_return() */
2031     }
2032
2033     /* [20011101.069] File test operators interpret OPf_REF to mean that
2034        their argument is a filehandle; thus \stat(".") should not set
2035        it. AMS 20011102 */
2036     if (type == OP_REFGEN &&
2037         PL_check[o->op_type] == Perl_ck_ftst)
2038         return o;
2039
2040     if (type != OP_LEAVESUBLV)
2041         o->op_flags |= OPf_MOD;
2042
2043     if (type == OP_AASSIGN || type == OP_SASSIGN)
2044         o->op_flags |= OPf_SPECIAL|OPf_REF;
2045     else if (!type) { /* local() */
2046         switch (localize) {
2047         case 1:
2048             o->op_private |= OPpLVAL_INTRO;
2049             o->op_flags &= ~OPf_SPECIAL;
2050             PL_hints |= HINT_BLOCK_SCOPE;
2051             break;
2052         case 0:
2053             break;
2054         case -1:
2055             Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
2056                            "Useless localization of %s", OP_DESC(o));
2057         }
2058     }
2059     else if (type != OP_GREPSTART && type != OP_ENTERSUB
2060              && type != OP_LEAVESUBLV)
2061         o->op_flags |= OPf_REF;
2062     return o;
2063 }
2064
2065 STATIC bool
2066 S_scalar_mod_type(const OP *o, I32 type)
2067 {
2068     assert(o || type != OP_SASSIGN);
2069
2070     switch (type) {
2071     case OP_SASSIGN:
2072         if (o->op_type == OP_RV2GV)
2073             return FALSE;
2074         /* FALL THROUGH */
2075     case OP_PREINC:
2076     case OP_PREDEC:
2077     case OP_POSTINC:
2078     case OP_POSTDEC:
2079     case OP_I_PREINC:
2080     case OP_I_PREDEC:
2081     case OP_I_POSTINC:
2082     case OP_I_POSTDEC:
2083     case OP_POW:
2084     case OP_MULTIPLY:
2085     case OP_DIVIDE:
2086     case OP_MODULO:
2087     case OP_REPEAT:
2088     case OP_ADD:
2089     case OP_SUBTRACT:
2090     case OP_I_MULTIPLY:
2091     case OP_I_DIVIDE:
2092     case OP_I_MODULO:
2093     case OP_I_ADD:
2094     case OP_I_SUBTRACT:
2095     case OP_LEFT_SHIFT:
2096     case OP_RIGHT_SHIFT:
2097     case OP_BIT_AND:
2098     case OP_BIT_XOR:
2099     case OP_BIT_OR:
2100     case OP_CONCAT:
2101     case OP_SUBST:
2102     case OP_TRANS:
2103     case OP_TRANSR:
2104     case OP_READ:
2105     case OP_SYSREAD:
2106     case OP_RECV:
2107     case OP_ANDASSIGN:
2108     case OP_ORASSIGN:
2109     case OP_DORASSIGN:
2110         return TRUE;
2111     default:
2112         return FALSE;
2113     }
2114 }
2115
2116 STATIC bool
2117 S_is_handle_constructor(const OP *o, I32 numargs)
2118 {
2119     PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR;
2120
2121     switch (o->op_type) {
2122     case OP_PIPE_OP:
2123     case OP_SOCKPAIR:
2124         if (numargs == 2)
2125             return TRUE;
2126         /* FALL THROUGH */
2127     case OP_SYSOPEN:
2128     case OP_OPEN:
2129     case OP_SELECT:             /* XXX c.f. SelectSaver.pm */
2130     case OP_SOCKET:
2131     case OP_OPEN_DIR:
2132     case OP_ACCEPT:
2133         if (numargs == 1)
2134             return TRUE;
2135         /* FALLTHROUGH */
2136     default:
2137         return FALSE;
2138     }
2139 }
2140
2141 static OP *
2142 S_refkids(pTHX_ OP *o, I32 type)
2143 {
2144     if (o && o->op_flags & OPf_KIDS) {
2145         OP *kid;
2146         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2147             ref(kid, type);
2148     }
2149     return o;
2150 }
2151
2152 OP *
2153 Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
2154 {
2155     dVAR;
2156     OP *kid;
2157
2158     PERL_ARGS_ASSERT_DOREF;
2159
2160     if (!o || (PL_parser && PL_parser->error_count))
2161         return o;
2162
2163     switch (o->op_type) {
2164     case OP_ENTERSUB:
2165         if ((type == OP_EXISTS || type == OP_DEFINED) &&
2166             !(o->op_flags & OPf_STACKED)) {
2167             o->op_type = OP_RV2CV;             /* entersub => rv2cv */
2168             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
2169             assert(cUNOPo->op_first->op_type == OP_NULL);
2170             op_null(((LISTOP*)cUNOPo->op_first)->op_first);     /* disable pushmark */
2171             o->op_flags |= OPf_SPECIAL;
2172             o->op_private &= ~1;
2173         }
2174         else if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV){
2175             o->op_private |= OPpENTERSUB_DEREF;
2176             o->op_flags |= OPf_MOD;
2177         }
2178
2179         break;
2180
2181     case OP_COND_EXPR:
2182         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
2183             doref(kid, type, set_op_ref);
2184         break;
2185     case OP_RV2SV:
2186         if (type == OP_DEFINED)
2187             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2188         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2189         /* FALL THROUGH */
2190     case OP_PADSV:
2191         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2192             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2193                               : type == OP_RV2HV ? OPpDEREF_HV
2194                               : OPpDEREF_SV);
2195             o->op_flags |= OPf_MOD;
2196         }
2197         break;
2198
2199     case OP_RV2AV:
2200     case OP_RV2HV:
2201         if (set_op_ref)
2202             o->op_flags |= OPf_REF;
2203         /* FALL THROUGH */
2204     case OP_RV2GV:
2205         if (type == OP_DEFINED)
2206             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2207         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2208         break;
2209
2210     case OP_PADAV:
2211     case OP_PADHV:
2212         if (set_op_ref)
2213             o->op_flags |= OPf_REF;
2214         break;
2215
2216     case OP_SCALAR:
2217     case OP_NULL:
2218         if (!(o->op_flags & OPf_KIDS))
2219             break;
2220         doref(cBINOPo->op_first, type, set_op_ref);
2221         break;
2222     case OP_AELEM:
2223     case OP_HELEM:
2224         doref(cBINOPo->op_first, o->op_type, set_op_ref);
2225         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2226             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2227                               : type == OP_RV2HV ? OPpDEREF_HV
2228                               : OPpDEREF_SV);
2229             o->op_flags |= OPf_MOD;
2230         }
2231         break;
2232
2233     case OP_SCOPE:
2234     case OP_LEAVE:
2235         set_op_ref = FALSE;
2236         /* FALL THROUGH */
2237     case OP_ENTER:
2238     case OP_LIST:
2239         if (!(o->op_flags & OPf_KIDS))
2240             break;
2241         doref(cLISTOPo->op_last, type, set_op_ref);
2242         break;
2243     default:
2244         break;
2245     }
2246     return scalar(o);
2247
2248 }
2249
2250 STATIC OP *
2251 S_dup_attrlist(pTHX_ OP *o)
2252 {
2253     dVAR;
2254     OP *rop;
2255
2256     PERL_ARGS_ASSERT_DUP_ATTRLIST;
2257
2258     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
2259      * where the first kid is OP_PUSHMARK and the remaining ones
2260      * are OP_CONST.  We need to push the OP_CONST values.
2261      */
2262     if (o->op_type == OP_CONST)
2263         rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc_NN(cSVOPo->op_sv));
2264 #ifdef PERL_MAD
2265     else if (o->op_type == OP_NULL)
2266         rop = NULL;
2267 #endif
2268     else {
2269         assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
2270         rop = NULL;
2271         for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
2272             if (o->op_type == OP_CONST)
2273                 rop = op_append_elem(OP_LIST, rop,
2274                                   newSVOP(OP_CONST, o->op_flags,
2275                                           SvREFCNT_inc_NN(cSVOPo->op_sv)));
2276         }
2277     }
2278     return rop;
2279 }
2280
2281 STATIC void
2282 S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
2283 {
2284     dVAR;
2285     SV *stashsv;
2286
2287     PERL_ARGS_ASSERT_APPLY_ATTRS;
2288
2289     /* fake up C<use attributes $pkg,$rv,@attrs> */
2290     ENTER;              /* need to protect against side-effects of 'use' */
2291     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2292
2293 #define ATTRSMODULE "attributes"
2294 #define ATTRSMODULE_PM "attributes.pm"
2295
2296     if (for_my) {
2297         /* Don't force the C<use> if we don't need it. */
2298         SV * const * const svp = hv_fetchs(GvHVn(PL_incgv), ATTRSMODULE_PM, FALSE);
2299         if (svp && *svp != &PL_sv_undef)
2300             NOOP;       /* already in %INC */
2301         else
2302             Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
2303                              newSVpvs(ATTRSMODULE), NULL);
2304     }
2305     else {
2306         Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2307                          newSVpvs(ATTRSMODULE),
2308                          NULL,
2309                          op_prepend_elem(OP_LIST,
2310                                       newSVOP(OP_CONST, 0, stashsv),
2311                                       op_prepend_elem(OP_LIST,
2312                                                    newSVOP(OP_CONST, 0,
2313                                                            newRV(target)),
2314                                                    dup_attrlist(attrs))));
2315     }
2316     LEAVE;
2317 }
2318
2319 STATIC void
2320 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
2321 {
2322     dVAR;
2323     OP *pack, *imop, *arg;
2324     SV *meth, *stashsv;
2325
2326     PERL_ARGS_ASSERT_APPLY_ATTRS_MY;
2327
2328     if (!attrs)
2329         return;
2330
2331     assert(target->op_type == OP_PADSV ||
2332            target->op_type == OP_PADHV ||
2333            target->op_type == OP_PADAV);
2334
2335     /* Ensure that attributes.pm is loaded. */
2336     apply_attrs(stash, PAD_SV(target->op_targ), attrs, TRUE);
2337
2338     /* Need package name for method call. */
2339     pack = newSVOP(OP_CONST, 0, newSVpvs(ATTRSMODULE));
2340
2341     /* Build up the real arg-list. */
2342     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2343
2344     arg = newOP(OP_PADSV, 0);
2345     arg->op_targ = target->op_targ;
2346     arg = op_prepend_elem(OP_LIST,
2347                        newSVOP(OP_CONST, 0, stashsv),
2348                        op_prepend_elem(OP_LIST,
2349                                     newUNOP(OP_REFGEN, 0,
2350                                             op_lvalue(arg, OP_REFGEN)),
2351                                     dup_attrlist(attrs)));
2352
2353     /* Fake up a method call to import */
2354     meth = newSVpvs_share("import");
2355     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
2356                    op_append_elem(OP_LIST,
2357                                op_prepend_elem(OP_LIST, pack, list(arg)),
2358                                newSVOP(OP_METHOD_NAMED, 0, meth)));
2359
2360     /* Combine the ops. */
2361     *imopsp = op_append_elem(OP_LIST, *imopsp, imop);
2362 }
2363
2364 /*
2365 =notfor apidoc apply_attrs_string
2366
2367 Attempts to apply a list of attributes specified by the C<attrstr> and
2368 C<len> arguments to the subroutine identified by the C<cv> argument which
2369 is expected to be associated with the package identified by the C<stashpv>
2370 argument (see L<attributes>).  It gets this wrong, though, in that it
2371 does not correctly identify the boundaries of the individual attribute
2372 specifications within C<attrstr>.  This is not really intended for the
2373 public API, but has to be listed here for systems such as AIX which
2374 need an explicit export list for symbols.  (It's called from XS code
2375 in support of the C<ATTRS:> keyword from F<xsubpp>.)  Patches to fix it
2376 to respect attribute syntax properly would be welcome.
2377
2378 =cut
2379 */
2380
2381 void
2382 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
2383                         const char *attrstr, STRLEN len)
2384 {
2385     OP *attrs = NULL;
2386
2387     PERL_ARGS_ASSERT_APPLY_ATTRS_STRING;
2388
2389     if (!len) {
2390         len = strlen(attrstr);
2391     }
2392
2393     while (len) {
2394         for (; isSPACE(*attrstr) && len; --len, ++attrstr) ;
2395         if (len) {
2396             const char * const sstr = attrstr;
2397             for (; !isSPACE(*attrstr) && len; --len, ++attrstr) ;
2398             attrs = op_append_elem(OP_LIST, attrs,
2399                                 newSVOP(OP_CONST, 0,
2400                                         newSVpvn(sstr, attrstr-sstr)));
2401         }
2402     }
2403
2404     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2405                      newSVpvs(ATTRSMODULE),
2406                      NULL, op_prepend_elem(OP_LIST,
2407                                   newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
2408                                   op_prepend_elem(OP_LIST,
2409                                                newSVOP(OP_CONST, 0,
2410                                                        newRV(MUTABLE_SV(cv))),
2411                                                attrs)));
2412 }
2413
2414 STATIC OP *
2415 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
2416 {
2417     dVAR;
2418     I32 type;
2419     const bool stately = PL_parser && PL_parser->in_my == KEY_state;
2420
2421     PERL_ARGS_ASSERT_MY_KID;
2422
2423     if (!o || (PL_parser && PL_parser->error_count))
2424         return o;
2425
2426     type = o->op_type;
2427     if (PL_madskills && type == OP_NULL && o->op_flags & OPf_KIDS) {
2428         (void)my_kid(cUNOPo->op_first, attrs, imopsp);
2429         return o;
2430     }
2431
2432     if (type == OP_LIST) {
2433         OP *kid;
2434         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2435             my_kid(kid, attrs, imopsp);
2436     } else if (type == OP_UNDEF
2437 #ifdef PERL_MAD
2438                || type == OP_STUB
2439 #endif
2440                ) {
2441         return o;
2442     } else if (type == OP_RV2SV ||      /* "our" declaration */
2443                type == OP_RV2AV ||
2444                type == OP_RV2HV) { /* XXX does this let anything illegal in? */
2445         if (cUNOPo->op_first->op_type != OP_GV) { /* MJD 20011224 */
2446             yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2447                         OP_DESC(o),
2448                         PL_parser->in_my == KEY_our
2449                             ? "our"
2450                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2451         } else if (attrs) {
2452             GV * const gv = cGVOPx_gv(cUNOPo->op_first);
2453             PL_parser->in_my = FALSE;
2454             PL_parser->in_my_stash = NULL;
2455             apply_attrs(GvSTASH(gv),
2456                         (type == OP_RV2SV ? GvSV(gv) :
2457                          type == OP_RV2AV ? MUTABLE_SV(GvAV(gv)) :
2458                          type == OP_RV2HV ? MUTABLE_SV(GvHV(gv)) : MUTABLE_SV(gv)),
2459                         attrs, FALSE);
2460         }
2461         o->op_private |= OPpOUR_INTRO;
2462         return o;
2463     }
2464     else if (type != OP_PADSV &&
2465              type != OP_PADAV &&
2466              type != OP_PADHV &&
2467              type != OP_PUSHMARK)
2468     {
2469         yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2470                           OP_DESC(o),
2471                           PL_parser->in_my == KEY_our
2472                             ? "our"
2473                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2474         return o;
2475     }
2476     else if (attrs && type != OP_PUSHMARK) {
2477         HV *stash;
2478
2479         PL_parser->in_my = FALSE;
2480         PL_parser->in_my_stash = NULL;
2481
2482         /* check for C<my Dog $spot> when deciding package */
2483         stash = PAD_COMPNAME_TYPE(o->op_targ);
2484         if (!stash)
2485             stash = PL_curstash;
2486         apply_attrs_my(stash, o, attrs, imopsp);
2487     }
2488     o->op_flags |= OPf_MOD;
2489     o->op_private |= OPpLVAL_INTRO;
2490     if (stately)
2491         o->op_private |= OPpPAD_STATE;
2492     return o;
2493 }
2494
2495 OP *
2496 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
2497 {
2498     dVAR;
2499     OP *rops;
2500     int maybe_scalar = 0;
2501
2502     PERL_ARGS_ASSERT_MY_ATTRS;
2503
2504 /* [perl #17376]: this appears to be premature, and results in code such as
2505    C< our(%x); > executing in list mode rather than void mode */
2506 #if 0
2507     if (o->op_flags & OPf_PARENS)
2508         list(o);
2509     else
2510         maybe_scalar = 1;
2511 #else
2512     maybe_scalar = 1;
2513 #endif
2514     if (attrs)
2515         SAVEFREEOP(attrs);
2516     rops = NULL;
2517     o = my_kid(o, attrs, &rops);
2518     if (rops) {
2519         if (maybe_scalar && o->op_type == OP_PADSV) {
2520             o = scalar(op_append_list(OP_LIST, rops, o));
2521             o->op_private |= OPpLVAL_INTRO;
2522         }
2523         else {
2524             /* The listop in rops might have a pushmark at the beginning,
2525                which will mess up list assignment. */
2526             LISTOP * const lrops = (LISTOP *)rops; /* for brevity */
2527             if (rops->op_type == OP_LIST && 
2528                 lrops->op_first && lrops->op_first->op_type == OP_PUSHMARK)
2529             {
2530                 OP * const pushmark = lrops->op_first;
2531                 lrops->op_first = pushmark->op_sibling;
2532                 op_free(pushmark);
2533             }
2534             o = op_append_list(OP_LIST, o, rops);
2535         }
2536     }
2537     PL_parser->in_my = FALSE;
2538     PL_parser->in_my_stash = NULL;
2539     return o;
2540 }
2541
2542 OP *
2543 Perl_sawparens(pTHX_ OP *o)
2544 {
2545     PERL_UNUSED_CONTEXT;
2546     if (o)
2547         o->op_flags |= OPf_PARENS;
2548     return o;
2549 }
2550
2551 OP *
2552 Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
2553 {
2554     OP *o;
2555     bool ismatchop = 0;
2556     const OPCODE ltype = left->op_type;
2557     const OPCODE rtype = right->op_type;
2558
2559     PERL_ARGS_ASSERT_BIND_MATCH;
2560
2561     if ( (ltype == OP_RV2AV || ltype == OP_RV2HV || ltype == OP_PADAV
2562           || ltype == OP_PADHV) && ckWARN(WARN_MISC))
2563     {
2564       const char * const desc
2565           = PL_op_desc[(
2566                           rtype == OP_SUBST || rtype == OP_TRANS
2567                        || rtype == OP_TRANSR
2568                        )
2569                        ? (int)rtype : OP_MATCH];
2570       const char * const sample = ((ltype == OP_RV2AV || ltype == OP_PADAV)
2571              ? "@array" : "%hash");
2572       Perl_warner(aTHX_ packWARN(WARN_MISC),
2573              "Applying %s to %s will act on scalar(%s)",
2574              desc, sample, sample);
2575     }
2576
2577     if (rtype == OP_CONST &&
2578         cSVOPx(right)->op_private & OPpCONST_BARE &&
2579         cSVOPx(right)->op_private & OPpCONST_STRICT)
2580     {
2581         no_bareword_allowed(right);
2582     }
2583
2584     /* !~ doesn't make sense with /r, so error on it for now */
2585     if (rtype == OP_SUBST && (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT) &&
2586         type == OP_NOT)
2587         yyerror("Using !~ with s///r doesn't make sense");
2588     if (rtype == OP_TRANSR && type == OP_NOT)
2589         yyerror("Using !~ with tr///r doesn't make sense");
2590
2591     ismatchop = (rtype == OP_MATCH ||
2592                  rtype == OP_SUBST ||
2593                  rtype == OP_TRANS || rtype == OP_TRANSR)
2594              && !(right->op_flags & OPf_SPECIAL);
2595     if (ismatchop && right->op_private & OPpTARGET_MY) {
2596         right->op_targ = 0;
2597         right->op_private &= ~OPpTARGET_MY;
2598     }
2599     if (!(right->op_flags & OPf_STACKED) && ismatchop) {
2600         OP *newleft;
2601
2602         right->op_flags |= OPf_STACKED;
2603         if (rtype != OP_MATCH && rtype != OP_TRANSR &&
2604             ! (rtype == OP_TRANS &&
2605                right->op_private & OPpTRANS_IDENTICAL) &&
2606             ! (rtype == OP_SUBST &&
2607                (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT)))
2608             newleft = op_lvalue(left, rtype);
2609         else
2610             newleft = left;
2611         if (right->op_type == OP_TRANS || right->op_type == OP_TRANSR)
2612             o = newBINOP(OP_NULL, OPf_STACKED, scalar(newleft), right);
2613         else
2614             o = op_prepend_elem(rtype, scalar(newleft), right);
2615         if (type == OP_NOT)
2616             return newUNOP(OP_NOT, 0, scalar(o));
2617         return o;
2618     }
2619     else
2620         return bind_match(type, left,
2621                 pmruntime(newPMOP(OP_MATCH, 0), right, 0));
2622 }
2623
2624 OP *
2625 Perl_invert(pTHX_ OP *o)
2626 {
2627     if (!o)
2628         return NULL;
2629     return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
2630 }
2631
2632 /*
2633 =for apidoc Amx|OP *|op_scope|OP *o
2634
2635 Wraps up an op tree with some additional ops so that at runtime a dynamic
2636 scope will be created.  The original ops run in the new dynamic scope,
2637 and then, provided that they exit normally, the scope will be unwound.
2638 The additional ops used to create and unwind the dynamic scope will
2639 normally be an C<enter>/C<leave> pair, but a C<scope> op may be used
2640 instead if the ops are simple enough to not need the full dynamic scope
2641 structure.
2642
2643 =cut
2644 */
2645
2646 OP *
2647 Perl_op_scope(pTHX_ OP *o)
2648 {
2649     dVAR;
2650     if (o) {
2651         if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) {
2652             o = op_prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
2653             o->op_type = OP_LEAVE;
2654             o->op_ppaddr = PL_ppaddr[OP_LEAVE];
2655         }
2656         else if (o->op_type == OP_LINESEQ) {
2657             OP *kid;
2658             o->op_type = OP_SCOPE;
2659             o->op_ppaddr = PL_ppaddr[OP_SCOPE];
2660             kid = ((LISTOP*)o)->op_first;
2661             if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) {
2662                 op_null(kid);
2663
2664                 /* The following deals with things like 'do {1 for 1}' */
2665                 kid = kid->op_sibling;
2666                 if (kid &&
2667                     (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE))
2668                     op_null(kid);
2669             }
2670         }
2671         else
2672             o = newLISTOP(OP_SCOPE, 0, o, NULL);
2673     }
2674     return o;
2675 }
2676
2677 int
2678 Perl_block_start(pTHX_ int full)
2679 {
2680     dVAR;
2681     const int retval = PL_savestack_ix;
2682
2683     pad_block_start(full);
2684     SAVEHINTS();
2685     PL_hints &= ~HINT_BLOCK_SCOPE;
2686     SAVECOMPILEWARNINGS();
2687     PL_compiling.cop_warnings = DUP_WARNINGS(PL_compiling.cop_warnings);
2688
2689     CALL_BLOCK_HOOKS(bhk_start, full);
2690
2691     return retval;
2692 }
2693
2694 OP*
2695 Perl_block_end(pTHX_ I32 floor, OP *seq)
2696 {
2697     dVAR;
2698     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
2699     OP* retval = scalarseq(seq);
2700
2701     CALL_BLOCK_HOOKS(bhk_pre_end, &retval);
2702
2703     LEAVE_SCOPE(floor);
2704     CopHINTS_set(&PL_compiling, PL_hints);
2705     if (needblockscope)
2706         PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
2707     pad_leavemy();
2708
2709     CALL_BLOCK_HOOKS(bhk_post_end, &retval);
2710
2711     return retval;
2712 }
2713
2714 /*
2715 =head1 Compile-time scope hooks
2716
2717 =for apidoc Aox||blockhook_register
2718
2719 Register a set of hooks to be called when the Perl lexical scope changes
2720 at compile time. See L<perlguts/"Compile-time scope hooks">.
2721
2722 =cut
2723 */
2724
2725 void
2726 Perl_blockhook_register(pTHX_ BHK *hk)
2727 {
2728     PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER;
2729
2730     Perl_av_create_and_push(aTHX_ &PL_blockhooks, newSViv(PTR2IV(hk)));
2731 }
2732
2733 STATIC OP *
2734 S_newDEFSVOP(pTHX)
2735 {
2736     dVAR;
2737     const PADOFFSET offset = pad_findmy_pvs("$_", 0);
2738     if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
2739         return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
2740     }
2741     else {
2742         OP * const o = newOP(OP_PADSV, 0);
2743         o->op_targ = offset;
2744         return o;
2745     }
2746 }
2747
2748 void
2749 Perl_newPROG(pTHX_ OP *o)
2750 {
2751     dVAR;
2752
2753     PERL_ARGS_ASSERT_NEWPROG;
2754
2755     if (PL_in_eval) {
2756         PERL_CONTEXT *cx;
2757         if (PL_eval_root)
2758                 return;
2759         PL_eval_root = newUNOP(OP_LEAVEEVAL,
2760                                ((PL_in_eval & EVAL_KEEPERR)
2761                                 ? OPf_SPECIAL : 0), o);
2762
2763         cx = &cxstack[cxstack_ix];
2764         assert(CxTYPE(cx) == CXt_EVAL);
2765
2766         if ((cx->blk_gimme & G_WANT) == G_VOID)
2767             scalarvoid(PL_eval_root);
2768         else if ((cx->blk_gimme & G_WANT) == G_ARRAY)
2769             list(PL_eval_root);
2770         else
2771             scalar(PL_eval_root);
2772
2773         /* don't use LINKLIST, since PL_eval_root might indirect through
2774          * a rather expensive function call and LINKLIST evaluates its
2775          * argument more than once */
2776         PL_eval_start = op_linklist(PL_eval_root);
2777         PL_eval_root->op_private |= OPpREFCOUNTED;
2778         OpREFCNT_set(PL_eval_root, 1);
2779         PL_eval_root->op_next = 0;
2780         CALL_PEEP(PL_eval_start);
2781         finalize_optree(PL_eval_root);
2782
2783     }
2784     else {
2785         if (o->op_type == OP_STUB) {
2786             PL_comppad_name = 0;
2787             PL_compcv = 0;
2788             S_op_destroy(aTHX_ o);
2789             return;
2790         }
2791         PL_main_root = op_scope(sawparens(scalarvoid(o)));
2792         PL_curcop = &PL_compiling;
2793         PL_main_start = LINKLIST(PL_main_root);
2794         PL_main_root->op_private |= OPpREFCOUNTED;
2795         OpREFCNT_set(PL_main_root, 1);
2796         PL_main_root->op_next = 0;
2797         CALL_PEEP(PL_main_start);
2798         finalize_optree(PL_main_root);
2799         PL_compcv = 0;
2800
2801         /* Register with debugger */
2802         if (PERLDB_INTER) {
2803             CV * const cv = get_cvs("DB::postponed", 0);
2804             if (cv) {
2805                 dSP;
2806                 PUSHMARK(SP);
2807                 XPUSHs(MUTABLE_SV(CopFILEGV(&PL_compiling)));
2808                 PUTBACK;
2809                 call_sv(MUTABLE_SV(cv), G_DISCARD);
2810             }
2811         }
2812     }
2813 }
2814
2815 OP *
2816 Perl_localize(pTHX_ OP *o, I32 lex)
2817 {
2818     dVAR;
2819
2820     PERL_ARGS_ASSERT_LOCALIZE;
2821
2822     if (o->op_flags & OPf_PARENS)
2823 /* [perl #17376]: this appears to be premature, and results in code such as
2824    C< our(%x); > executing in list mode rather than void mode */
2825 #if 0
2826         list(o);
2827 #else
2828         NOOP;
2829 #endif
2830     else {
2831         if ( PL_parser->bufptr > PL_parser->oldbufptr
2832             && PL_parser->bufptr[-1] == ','
2833             && ckWARN(WARN_PARENTHESIS))
2834         {
2835             char *s = PL_parser->bufptr;
2836             bool sigil = FALSE;
2837
2838             /* some heuristics to detect a potential error */
2839             while (*s && (strchr(", \t\n", *s)))
2840                 s++;
2841
2842             while (1) {
2843                 if (*s && strchr("@$%*", *s) && *++s
2844                        && (isALNUM(*s) || UTF8_IS_CONTINUED(*s))) {
2845                     s++;
2846                     sigil = TRUE;
2847                     while (*s && (isALNUM(*s) || UTF8_IS_CONTINUED(*s)))
2848                         s++;
2849                     while (*s && (strchr(", \t\n", *s)))
2850                         s++;
2851                 }
2852                 else
2853                     break;
2854             }
2855             if (sigil && (*s == ';' || *s == '=')) {
2856                 Perl_warner(aTHX_ packWARN(WARN_PARENTHESIS),
2857                                 "Parentheses missing around \"%s\" list",
2858                                 lex
2859                                     ? (PL_parser->in_my == KEY_our
2860                                         ? "our"
2861                                         : PL_parser->in_my == KEY_state
2862                                             ? "state"
2863                                             : "my")
2864                                     : "local");
2865             }
2866         }
2867     }
2868     if (lex)
2869         o = my(o);
2870     else
2871         o = op_lvalue(o, OP_NULL);              /* a bit kludgey */
2872     PL_parser->in_my = FALSE;
2873     PL_parser->in_my_stash = NULL;
2874     return o;
2875 }
2876
2877 OP *
2878 Perl_jmaybe(pTHX_ OP *o)
2879 {
2880     PERL_ARGS_ASSERT_JMAYBE;
2881
2882     if (o->op_type == OP_LIST) {
2883         OP * const o2
2884             = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL, SVt_PV)));
2885         o = convert(OP_JOIN, 0, op_prepend_elem(OP_LIST, o2, o));
2886     }
2887     return o;
2888 }
2889
2890 static OP *
2891 S_fold_constants(pTHX_ register OP *o)
2892 {
2893     dVAR;
2894     register OP * VOL curop;
2895     OP *newop;
2896     VOL I32 type = o->op_type;
2897     SV * VOL sv = NULL;
2898     int ret = 0;
2899     I32 oldscope;
2900     OP *old_next;
2901     SV * const oldwarnhook = PL_warnhook;
2902     SV * const olddiehook  = PL_diehook;
2903     COP not_compiling;
2904     dJMPENV;
2905
2906     PERL_ARGS_ASSERT_FOLD_CONSTANTS;
2907
2908     if (PL_opargs[type] & OA_RETSCALAR)
2909         scalar(o);
2910     if (PL_opargs[type] & OA_TARGET && !o->op_targ)
2911         o->op_targ = pad_alloc(type, SVs_PADTMP);
2912
2913     /* integerize op, unless it happens to be C<-foo>.
2914      * XXX should pp_i_negate() do magic string negation instead? */
2915     if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER)
2916         && !(type == OP_NEGATE && cUNOPo->op_first->op_type == OP_CONST
2917              && (cUNOPo->op_first->op_private & OPpCONST_BARE)))
2918     {
2919         o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
2920     }
2921
2922     if (!(PL_opargs[type] & OA_FOLDCONST))
2923         goto nope;
2924
2925     switch (type) {
2926     case OP_NEGATE:
2927         /* XXX might want a ck_negate() for this */
2928         cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
2929         break;
2930     case OP_UCFIRST:
2931     case OP_LCFIRST:
2932     case OP_UC:
2933     case OP_LC:
2934     case OP_SLT:
2935     case OP_SGT:
2936     case OP_SLE:
2937     case OP_SGE:
2938     case OP_SCMP:
2939     case OP_SPRINTF:
2940         /* XXX what about the numeric ops? */
2941         if (PL_hints & HINT_LOCALE)
2942             goto nope;
2943         break;
2944     }
2945
2946     if (PL_parser && PL_parser->error_count)
2947         goto nope;              /* Don't try to run w/ errors */
2948
2949     for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
2950         const OPCODE type = curop->op_type;
2951         if ((type != OP_CONST || (curop->op_private & OPpCONST_BARE)) &&
2952             type != OP_LIST &&
2953             type != OP_SCALAR &&
2954             type != OP_NULL &&
2955             type != OP_PUSHMARK)
2956         {
2957             goto nope;
2958         }
2959     }
2960
2961     curop = LINKLIST(o);
2962     old_next = o->op_next;
2963     o->op_next = 0;
2964     PL_op = curop;
2965
2966     oldscope = PL_scopestack_ix;
2967     create_eval_scope(G_FAKINGEVAL);
2968
2969     /* Verify that we don't need to save it:  */
2970     assert(PL_curcop == &PL_compiling);
2971     StructCopy(&PL_compiling, &not_compiling, COP);
2972     PL_curcop = &not_compiling;
2973     /* The above ensures that we run with all the correct hints of the
2974        currently compiling COP, but that IN_PERL_RUNTIME is not true. */
2975     assert(IN_PERL_RUNTIME);
2976     PL_warnhook = PERL_WARNHOOK_FATAL;
2977     PL_diehook  = NULL;
2978     JMPENV_PUSH(ret);
2979
2980     switch (ret) {
2981     case 0:
2982         CALLRUNOPS(aTHX);
2983         sv = *(PL_stack_sp--);
2984         if (o->op_targ && sv == PAD_SV(o->op_targ)) {   /* grab pad temp? */
2985 #ifdef PERL_MAD
2986             /* Can't simply swipe the SV from the pad, because that relies on
2987                the op being freed "real soon now". Under MAD, this doesn't
2988                happen (see the #ifdef below).  */
2989             sv = newSVsv(sv);
2990 #else
2991             pad_swipe(o->op_targ,  FALSE);
2992 #endif
2993         }
2994         else if (SvTEMP(sv)) {                  /* grab mortal temp? */
2995             SvREFCNT_inc_simple_void(sv);
2996             SvTEMP_off(sv);
2997         }
2998         break;
2999     case 3:
3000         /* Something tried to die.  Abandon constant folding.  */
3001         /* Pretend the error never happened.  */
3002         CLEAR_ERRSV();
3003         o->op_next = old_next;
3004         break;
3005     default:
3006         JMPENV_POP;
3007         /* Don't expect 1 (setjmp failed) or 2 (something called my_exit)  */
3008         PL_warnhook = oldwarnhook;
3009         PL_diehook  = olddiehook;
3010         /* XXX note that this croak may fail as we've already blown away
3011          * the stack - eg any nested evals */
3012         Perl_croak(aTHX_ "panic: fold_constants JMPENV_PUSH returned %d", ret);
3013     }
3014     JMPENV_POP;
3015     PL_warnhook = oldwarnhook;
3016     PL_diehook  = olddiehook;
3017     PL_curcop = &PL_compiling;
3018
3019     if (PL_scopestack_ix > oldscope)
3020         delete_eval_scope();
3021
3022     if (ret)
3023         goto nope;
3024
3025 #ifndef PERL_MAD
3026     op_free(o);
3027 #endif
3028     assert(sv);
3029     if (type == OP_RV2GV)
3030         newop = newGVOP(OP_GV, 0, MUTABLE_GV(sv));
3031     else
3032         newop = newSVOP(OP_CONST, 0, MUTABLE_SV(sv));
3033     op_getmad(o,newop,'f');
3034     return newop;
3035
3036  nope:
3037     return o;
3038 }
3039
3040 static OP *
3041 S_gen_constant_list(pTHX_ register OP *o)
3042 {
3043     dVAR;
3044     register OP *curop;
3045     const I32 oldtmps_floor = PL_tmps_floor;
3046
3047     list(o);
3048     if (PL_parser && PL_parser->error_count)
3049         return o;               /* Don't attempt to run with errors */
3050
3051     PL_op = curop = LINKLIST(o);
3052     o->op_next = 0;
3053     CALL_PEEP(curop);
3054     Perl_pp_pushmark(aTHX);
3055     CALLRUNOPS(aTHX);
3056     PL_op = curop;
3057     assert (!(curop->op_flags & OPf_SPECIAL));
3058     assert(curop->op_type == OP_RANGE);
3059     Perl_pp_anonlist(aTHX);
3060     PL_tmps_floor = oldtmps_floor;
3061
3062     o->op_type = OP_RV2AV;
3063     o->op_ppaddr = PL_ppaddr[OP_RV2AV];
3064     o->op_flags &= ~OPf_REF;    /* treat \(1..2) like an ordinary list */
3065     o->op_flags |= OPf_PARENS;  /* and flatten \(1..2,3) */
3066     o->op_opt = 0;              /* needs to be revisited in rpeep() */
3067     curop = ((UNOP*)o)->op_first;
3068     ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc_NN(*PL_stack_sp--));
3069 #ifdef PERL_MAD
3070     op_getmad(curop,o,'O');
3071 #else
3072     op_free(curop);
3073 #endif
3074     LINKLIST(o);
3075     return list(o);
3076 }
3077
3078 OP *
3079 Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
3080 {
3081     dVAR;
3082     if (!o || o->op_type != OP_LIST)
3083         o = newLISTOP(OP_LIST, 0, o, NULL);
3084     else
3085         o->op_flags &= ~OPf_WANT;
3086
3087     if (!(PL_opargs[type] & OA_MARK))
3088         op_null(cLISTOPo->op_first);
3089
3090     o->op_type = (OPCODE)type;
3091     o->op_ppaddr = PL_ppaddr[type];
3092     o->op_flags |= flags;
3093
3094     o = CHECKOP(type, o);
3095     if (o->op_type != (unsigned)type)
3096         return o;
3097
3098     return fold_constants(o);
3099 }
3100
3101 /*
3102 =head1 Optree Manipulation Functions
3103 */
3104
3105 /* List constructors */
3106
3107 /*
3108 =for apidoc Am|OP *|op_append_elem|I32 optype|OP *first|OP *last
3109
3110 Append an item to the list of ops contained directly within a list-type
3111 op, returning the lengthened list.  I<first> is the list-type op,
3112 and I<last> is the op to append to the list.  I<optype> specifies the
3113 intended opcode for the list.  If I<first> is not already a list of the
3114 right type, it will be upgraded into one.  If either I<first> or I<last>
3115 is null, the other is returned unchanged.
3116
3117 =cut
3118 */
3119
3120 OP *
3121 Perl_op_append_elem(pTHX_ I32 type, OP *first, OP *last)
3122 {
3123     if (!first)
3124         return last;
3125
3126     if (!last)
3127         return first;
3128
3129     if (first->op_type != (unsigned)type
3130         || (type == OP_LIST && (first->op_flags & OPf_PARENS)))
3131     {
3132         return newLISTOP(type, 0, first, last);
3133     }
3134
3135     if (first->op_flags & OPf_KIDS)
3136         ((LISTOP*)first)->op_last->op_sibling = last;
3137     else {
3138         first->op_flags |= OPf_KIDS;
3139         ((LISTOP*)first)->op_first = last;
3140     }
3141     ((LISTOP*)first)->op_last = last;
3142     return first;
3143 }
3144
3145 /*
3146 =for apidoc Am|OP *|op_append_list|I32 optype|OP *first|OP *last
3147
3148 Concatenate the lists of ops contained directly within two list-type ops,
3149 returning the combined list.  I<first> and I<last> are the list-type ops
3150 to concatenate.  I<optype> specifies the intended opcode for the list.
3151 If either I<first> or I<last> is not already a list of the right type,
3152 it will be upgraded into one.  If either I<first> or I<last> is null,
3153 the other is returned unchanged.
3154
3155 =cut
3156 */
3157
3158 OP *
3159 Perl_op_append_list(pTHX_ I32 type, OP *first, OP *last)
3160 {
3161     if (!first)
3162         return last;
3163
3164     if (!last)
3165         return first;
3166
3167     if (first->op_type != (unsigned)type)
3168         return op_prepend_elem(type, first, last);
3169
3170     if (last->op_type != (unsigned)type)
3171         return op_append_elem(type, first, last);
3172
3173     ((LISTOP*)first)->op_last->op_sibling = ((LISTOP*)last)->op_first;
3174     ((LISTOP*)first)->op_last = ((LISTOP*)last)->op_last;
3175     first->op_flags |= (last->op_flags & OPf_KIDS);
3176
3177 #ifdef PERL_MAD
3178     if (((LISTOP*)last)->op_first && first->op_madprop) {
3179         MADPROP *mp = ((LISTOP*)last)->op_first->op_madprop;
3180         if (mp) {
3181             while (mp->mad_next)
3182                 mp = mp->mad_next;
3183             mp->mad_next = first->op_madprop;
3184         }
3185         else {
3186             ((LISTOP*)last)->op_first->op_madprop = first->op_madprop;
3187         }
3188     }
3189     first->op_madprop = last->op_madprop;
3190     last->op_madprop = 0;
3191 #endif
3192
3193     S_op_destroy(aTHX_ last);
3194
3195     return first;
3196 }
3197
3198 /*
3199 =for apidoc Am|OP *|op_prepend_elem|I32 optype|OP *first|OP *last
3200
3201 Prepend an item to the list of ops contained directly within a list-type
3202 op, returning the lengthened list.  I<first> is the op to prepend to the
3203 list, and I<last> is the list-type op.  I<optype> specifies the intended
3204 opcode for the list.  If I<last> is not already a list of the right type,
3205 it will be upgraded into one.  If either I<first> or I<last> is null,
3206 the other is returned unchanged.
3207
3208 =cut
3209 */
3210
3211 OP *
3212 Perl_op_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
3213 {
3214     if (!first)
3215         return last;
3216
3217     if (!last)
3218         return first;
3219
3220     if (last->op_type == (unsigned)type) {
3221         if (type == OP_LIST) {  /* already a PUSHMARK there */
3222             first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
3223             ((LISTOP*)last)->op_first->op_sibling = first;
3224             if (!(first->op_flags & OPf_PARENS))
3225                 last->op_flags &= ~OPf_PARENS;
3226         }
3227         else {
3228             if (!(last->op_flags & OPf_KIDS)) {
3229                 ((LISTOP*)last)->op_last = first;
3230                 last->op_flags |= OPf_KIDS;
3231             }
3232             first->op_sibling = ((LISTOP*)last)->op_first;
3233             ((LISTOP*)last)->op_first = first;
3234         }
3235         last->op_flags |= OPf_KIDS;
3236         return last;
3237     }
3238
3239     return newLISTOP(type, 0, first, last);
3240 }
3241
3242 /* Constructors */
3243
3244 #ifdef PERL_MAD
3245  
3246 TOKEN *
3247 Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop)
3248 {
3249     TOKEN *tk;
3250     Newxz(tk, 1, TOKEN);
3251     tk->tk_type = (OPCODE)optype;
3252     tk->tk_type = 12345;
3253     tk->tk_lval = lval;
3254     tk->tk_mad = madprop;
3255     return tk;
3256 }
3257
3258 void
3259 Perl_token_free(pTHX_ TOKEN* tk)
3260 {
3261     PERL_ARGS_ASSERT_TOKEN_FREE;
3262
3263     if (tk->tk_type != 12345)
3264         return;
3265     mad_free(tk->tk_mad);
3266     Safefree(tk);
3267 }
3268
3269 void
3270 Perl_token_getmad(pTHX_ TOKEN* tk, OP* o, char slot)
3271 {
3272     MADPROP* mp;
3273     MADPROP* tm;
3274
3275     PERL_ARGS_ASSERT_TOKEN_GETMAD;
3276
3277     if (tk->tk_type != 12345) {
3278         Perl_warner(aTHX_ packWARN(WARN_MISC),
3279              "Invalid TOKEN object ignored");
3280         return;
3281     }
3282     tm = tk->tk_mad;
3283     if (!tm)
3284         return;
3285
3286     /* faked up qw list? */
3287     if (slot == '(' &&
3288         tm->mad_type == MAD_SV &&
3289         SvPVX((SV *)tm->mad_val)[0] == 'q')
3290             slot = 'x';
3291
3292     if (o) {
3293         mp = o->op_madprop;
3294         if (mp) {
3295             for (;;) {
3296                 /* pretend constant fold didn't happen? */
3297                 if (mp->mad_key == 'f' &&
3298                     (o->op_type == OP_CONST ||
3299                      o->op_type == OP_GV) )
3300                 {
3301                     token_getmad(tk,(OP*)mp->mad_val,slot);
3302                     return;
3303                 }
3304                 if (!mp->mad_next)
3305                     break;
3306                 mp = mp->mad_next;
3307             }
3308             mp->mad_next = tm;
3309             mp = mp->mad_next;
3310         }
3311         else {
3312             o->op_madprop = tm;
3313             mp = o->op_madprop;
3314         }
3315         if (mp->mad_key == 'X')
3316             mp->mad_key = slot; /* just change the first one */
3317
3318         tk->tk_mad = 0;
3319     }
3320     else
3321         mad_free(tm);
3322     Safefree(tk);
3323 }
3324
3325 void
3326 Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot)
3327 {
3328     MADPROP* mp;
3329     if (!from)
3330         return;
3331     if (o) {
3332         mp = o->op_madprop;
3333         if (mp) {
3334             for (;;) {
3335                 /* pretend constant fold didn't happen? */
3336                 if (mp->mad_key == 'f' &&
3337                     (o->op_type == OP_CONST ||
3338                      o->op_type == OP_GV) )
3339                 {
3340                     op_getmad(from,(OP*)mp->mad_val,slot);
3341                     return;
3342                 }
3343                 if (!mp->mad_next)
3344                     break;
3345                 mp = mp->mad_next;
3346             }
3347             mp->mad_next = newMADPROP(slot,MAD_OP,from,0);
3348         }
3349         else {
3350             o->op_madprop = newMADPROP(slot,MAD_OP,from,0);
3351         }
3352     }
3353 }
3354
3355 void
3356 Perl_op_getmad(pTHX_ OP* from, OP* o, char slot)
3357 {
3358     MADPROP* mp;
3359     if (!from)
3360         return;
3361     if (o) {
3362         mp = o->op_madprop;
3363         if (mp) {
3364             for (;;) {
3365                 /* pretend constant fold didn't happen? */
3366                 if (mp->mad_key == 'f' &&
3367                     (o->op_type == OP_CONST ||
3368                      o->op_type == OP_GV) )
3369                 {
3370                     op_getmad(from,(OP*)mp->mad_val,slot);
3371                     return;
3372                 }
3373                 if (!mp->mad_next)
3374                     break;
3375                 mp = mp->mad_next;
3376             }
3377             mp->mad_next = newMADPROP(slot,MAD_OP,from,1);
3378         }
3379         else {
3380             o->op_madprop = newMADPROP(slot,MAD_OP,from,1);
3381         }
3382     }
3383     else {
3384         PerlIO_printf(PerlIO_stderr(),
3385                       "DESTROYING op = %0"UVxf"\n", PTR2UV(from));
3386         op_free(from);
3387     }
3388 }
3389
3390 void
3391 Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot)
3392 {
3393     MADPROP* tm;
3394     if (!mp || !o)
3395         return;
3396     if (slot)
3397         mp->mad_key = slot;
3398     tm = o->op_madprop;
3399     o->op_madprop = mp;
3400     for (;;) {
3401         if (!mp->mad_next)
3402             break;
3403         mp = mp->mad_next;
3404     }
3405     mp->mad_next = tm;
3406 }
3407
3408 void
3409 Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot)
3410 {
3411     if (!o)
3412         return;
3413     addmad(tm, &(o->op_madprop), slot);
3414 }
3415
3416 void
3417 Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot)
3418 {
3419     MADPROP* mp;
3420     if (!tm || !root)
3421         return;
3422     if (slot)
3423         tm->mad_key = slot;
3424     mp = *root;
3425     if (!mp) {
3426         *root = tm;
3427         return;
3428     }
3429     for (;;) {
3430         if (!mp->mad_next)
3431             break;
3432         mp = mp->mad_next;
3433     }
3434     mp->mad_next = tm;
3435 }
3436
3437 MADPROP *
3438 Perl_newMADsv(pTHX_ char key, SV* sv)
3439 {
3440     PERL_ARGS_ASSERT_NEWMADSV;
3441
3442     return newMADPROP(key, MAD_SV, sv, 0);
3443 }
3444
3445 MADPROP *
3446 Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen)
3447 {
3448     MADPROP *const mp = (MADPROP *) PerlMemShared_malloc(sizeof(MADPROP));
3449     mp->mad_next = 0;
3450     mp->mad_key = key;
3451     mp->mad_vlen = vlen;
3452     mp->mad_type = type;
3453     mp->mad_val = val;
3454 /*    PerlIO_printf(PerlIO_stderr(), "NEW  mp = %0x\n", mp);  */
3455     return mp;
3456 }
3457
3458 void
3459 Perl_mad_free(pTHX_ MADPROP* mp)
3460 {
3461 /*    PerlIO_printf(PerlIO_stderr(), "FREE mp = %0x\n", mp); */
3462     if (!mp)
3463         return;
3464     if (mp->mad_next)
3465         mad_free(mp->mad_next);
3466 /*    if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING && mp->mad_vlen)
3467         PerlIO_printf(PerlIO_stderr(), "DESTROYING '%c'=<%s>\n", mp->mad_key & 255, mp->mad_val); */
3468     switch (mp->mad_type) {
3469     case MAD_NULL:
3470         break;
3471     case MAD_PV:
3472         Safefree((char*)mp->mad_val);
3473         break;
3474     case MAD_OP:
3475         if (mp->mad_vlen)       /* vlen holds "strong/weak" boolean */
3476             op_free((OP*)mp->mad_val);
3477         break;
3478     case MAD_SV:
3479         sv_free(MUTABLE_SV(mp->mad_val));
3480         break;
3481     default:
3482         PerlIO_printf(PerlIO_stderr(), "Unrecognized mad\n");
3483         break;
3484     }
3485     PerlMemShared_free(mp);
3486 }
3487
3488 #endif
3489
3490 /*
3491 =head1 Optree construction
3492
3493 =for apidoc Am|OP *|newNULLLIST
3494
3495 Constructs, checks, and returns a new C<stub> op, which represents an
3496 empty list expression.
3497
3498 =cut
3499 */
3500
3501 OP *
3502 Perl_newNULLLIST(pTHX)
3503 {
3504     return newOP(OP_STUB, 0);
3505 }
3506
3507 static OP *
3508 S_force_list(pTHX_ OP *o)
3509 {
3510     if (!o || o->op_type != OP_LIST)
3511         o = newLISTOP(OP_LIST, 0, o, NULL);
3512     op_null(o);
3513     return o;
3514 }
3515
3516 /*
3517 =for apidoc Am|OP *|newLISTOP|I32 type|I32 flags|OP *first|OP *last
3518
3519 Constructs, checks, and returns an op of any list type.  I<type> is
3520 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
3521 C<OPf_KIDS> will be set automatically if required.  I<first> and I<last>
3522 supply up to two ops to be direct children of the list op; they are
3523 consumed by this function and become part of the constructed op tree.
3524
3525 =cut
3526 */
3527
3528 OP *
3529 Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
3530 {
3531     dVAR;
3532     LISTOP *listop;
3533
3534     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_LISTOP);
3535
3536     NewOp(1101, listop, 1, LISTOP);
3537
3538     listop->op_type = (OPCODE)type;
3539     listop->op_ppaddr = PL_ppaddr[type];
3540     if (first || last)
3541         flags |= OPf_KIDS;
3542     listop->op_flags = (U8)flags;
3543
3544     if (!last && first)
3545         last = first;
3546     else if (!first && last)
3547         first = last;
3548     else if (first)
3549         first->op_sibling = last;
3550     listop->op_first = first;
3551     listop->op_last = last;
3552     if (type == OP_LIST) {
3553         OP* const pushop = newOP(OP_PUSHMARK, 0);
3554         pushop->op_sibling = first;
3555         listop->op_first = pushop;
3556         listop->op_flags |= OPf_KIDS;
3557         if (!last)
3558             listop->op_last = pushop;
3559     }
3560
3561     return CHECKOP(type, listop);
3562 }
3563
3564 /*
3565 =for apidoc Am|OP *|newOP|I32 type|I32 flags
3566
3567 Constructs, checks, and returns an op of any base type (any type that
3568 has no extra fields).  I<type> is the opcode.  I<flags> gives the
3569 eight bits of C<op_flags>, and, shifted up eight bits, the eight bits
3570 of C<op_private>.
3571
3572 =cut
3573 */
3574
3575 OP *
3576 Perl_newOP(pTHX_ I32 type, I32 flags)
3577 {
3578     dVAR;
3579     OP *o;
3580
3581     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP
3582         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
3583         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
3584         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
3585
3586     NewOp(1101, o, 1, OP);
3587     o->op_type = (OPCODE)type;
3588     o->op_ppaddr = PL_ppaddr[type];
3589     o->op_flags = (U8)flags;
3590     o->op_latefree = 0;
3591     o->op_latefreed = 0;
3592     o->op_attached = 0;
3593
3594     o->op_next = o;
3595     o->op_private = (U8)(0 | (flags >> 8));
3596     if (PL_opargs[type] & OA_RETSCALAR)
3597         scalar(o);
3598     if (PL_opargs[type] & OA_TARGET)
3599         o->op_targ = pad_alloc(type, SVs_PADTMP);
3600     return CHECKOP(type, o);
3601 }
3602
3603 /*
3604 =for apidoc Am|OP *|newUNOP|I32 type|I32 flags|OP *first
3605
3606 Constructs, checks, and returns an op of any unary type.  I<type> is
3607 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
3608 C<OPf_KIDS> will be set automatically if required, and, shifted up eight
3609 bits, the eight bits of C<op_private>, except that the bit with value 1
3610 is automatically set.  I<first> supplies an optional op to be the direct
3611 child of the unary op; it is consumed by this function and become part
3612 of the constructed op tree.
3613
3614 =cut
3615 */
3616
3617 OP *
3618 Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
3619 {
3620     dVAR;
3621     UNOP *unop;
3622
3623     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_UNOP
3624         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
3625         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
3626         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP
3627         || type == OP_SASSIGN
3628         || type == OP_ENTERTRY
3629         || type == OP_NULL );
3630
3631     if (!first)
3632         first = newOP(OP_STUB, 0);
3633     if (PL_opargs[type] & OA_MARK)
3634         first = force_list(first);
3635
3636     NewOp(1101, unop, 1, UNOP);
3637     unop->op_type = (OPCODE)type;
3638     unop->op_ppaddr = PL_ppaddr[type];
3639     unop->op_first = first;
3640     unop->op_flags = (U8)(flags | OPf_KIDS);
3641     unop->op_private = (U8)(1 | (flags >> 8));
3642     unop = (UNOP*) CHECKOP(type, unop);
3643     if (unop->op_next)
3644         return (OP*)unop;
3645
3646     return fold_constants((OP *) unop);
3647 }
3648
3649 /*
3650 =for apidoc Am|OP *|newBINOP|I32 type|I32 flags|OP *first|OP *last
3651
3652 Constructs, checks, and returns an op of any binary type.  I<type>
3653 is the opcode.  I<flags> gives the eight bits of C<op_flags>, except
3654 that C<OPf_KIDS> will be set automatically, and, shifted up eight bits,
3655 the eight bits of C<op_private>, except that the bit with value 1 or
3656 2 is automatically set as required.  I<first> and I<last> supply up to
3657 two ops to be the direct children of the binary op; they are consumed
3658 by this function and become part of the constructed op tree.
3659
3660 =cut
3661 */
3662
3663 OP *
3664 Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
3665 {
3666     dVAR;
3667     BINOP *binop;
3668
3669     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BINOP
3670         || type == OP_SASSIGN || type == OP_NULL );
3671
3672     NewOp(1101, binop, 1, BINOP);
3673
3674     if (!first)
3675         first = newOP(OP_NULL, 0);
3676
3677     binop->op_type = (OPCODE)type;
3678     binop->op_ppaddr = PL_ppaddr[type];
3679     binop->op_first = first;
3680     binop->op_flags = (U8)(flags | OPf_KIDS);
3681     if (!last) {
3682         last = first;
3683         binop->op_private = (U8)(1 | (flags >> 8));
3684     }
3685     else {
3686         binop->op_private = (U8)(2 | (flags >> 8));
3687         first->op_sibling = last;
3688     }
3689
3690     binop = (BINOP*)CHECKOP(type, binop);
3691     if (binop->op_next || binop->op_type != (OPCODE)type)
3692         return (OP*)binop;
3693
3694     binop->op_last = binop->op_first->op_sibling;
3695
3696     return fold_constants((OP *)binop);
3697 }
3698
3699 static int uvcompare(const void *a, const void *b)
3700     __attribute__nonnull__(1)
3701     __attribute__nonnull__(2)
3702     __attribute__pure__;
3703 static int uvcompare(const void *a, const void *b)
3704 {
3705     if (*((const UV *)a) < (*(const UV *)b))
3706         return -1;
3707     if (*((const UV *)a) > (*(const UV *)b))
3708         return 1;
3709     if (*((const UV *)a+1) < (*(const UV *)b+1))
3710         return -1;
3711     if (*((const UV *)a+1) > (*(const UV *)b+1))
3712         return 1;
3713     return 0;
3714 }
3715
3716 static OP *
3717 S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
3718 {
3719     dVAR;
3720     SV * const tstr = ((SVOP*)expr)->op_sv;
3721     SV * const rstr =
3722 #ifdef PERL_MAD
3723                         (repl->op_type == OP_NULL)
3724                             ? ((SVOP*)((LISTOP*)repl)->op_first)->op_sv :
3725 #endif
3726                               ((SVOP*)repl)->op_sv;
3727     STRLEN tlen;
3728     STRLEN rlen;
3729     const U8 *t = (U8*)SvPV_const(tstr, tlen);
3730     const U8 *r = (U8*)SvPV_const(rstr, rlen);
3731     register I32 i;
3732     register I32 j;
3733     I32 grows = 0;
3734     register short *tbl;
3735
3736     const I32 complement = o->op_private & OPpTRANS_COMPLEMENT;
3737     const I32 squash     = o->op_private & OPpTRANS_SQUASH;
3738     I32 del              = o->op_private & OPpTRANS_DELETE;
3739     SV* swash;
3740
3741     PERL_ARGS_ASSERT_PMTRANS;
3742
3743     PL_hints |= HINT_BLOCK_SCOPE;
3744
3745     if (SvUTF8(tstr))
3746         o->op_private |= OPpTRANS_FROM_UTF;
3747
3748     if (SvUTF8(rstr))
3749         o->op_private |= OPpTRANS_TO_UTF;
3750
3751     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
3752         SV* const listsv = newSVpvs("# comment\n");
3753         SV* transv = NULL;
3754         const U8* tend = t + tlen;
3755         const U8* rend = r + rlen;
3756         STRLEN ulen;
3757         UV tfirst = 1;
3758         UV tlast = 0;
3759         IV tdiff;
3760         UV rfirst = 1;
3761         UV rlast = 0;
3762         IV rdiff;
3763         IV diff;
3764         I32 none = 0;
3765         U32 max = 0;
3766         I32 bits;
3767         I32 havefinal = 0;
3768         U32 final = 0;
3769         const I32 from_utf  = o->op_private & OPpTRANS_FROM_UTF;
3770         const I32 to_utf    = o->op_private & OPpTRANS_TO_UTF;
3771         U8* tsave = NULL;
3772         U8* rsave = NULL;
3773         const U32 flags = UTF8_ALLOW_DEFAULT;
3774
3775         if (!from_utf) {
3776             STRLEN len = tlen;
3777             t = tsave = bytes_to_utf8(t, &len);
3778             tend = t + len;
3779         }
3780         if (!to_utf && rlen) {
3781             STRLEN len = rlen;
3782             r = rsave = bytes_to_utf8(r, &len);
3783             rend = r + len;
3784         }
3785
3786 /* There are several snags with this code on EBCDIC:
3787    1. 0xFF is a legal UTF-EBCDIC byte (there are no illegal bytes).
3788    2. scan_const() in toke.c has encoded chars in native encoding which makes
3789       ranges at least in EBCDIC 0..255 range the bottom odd.
3790 */
3791
3792         if (complement) {
3793             U8 tmpbuf[UTF8_MAXBYTES+1];
3794             UV *cp;
3795             UV nextmin = 0;
3796             Newx(cp, 2*tlen, UV);
3797             i = 0;
3798             transv = newSVpvs("");
3799             while (t < tend) {
3800                 cp[2*i] = utf8n_to_uvuni(t, tend-t, &ulen, flags);
3801                 t += ulen;
3802                 if (t < tend && NATIVE_TO_UTF(*t) == 0xff) {
3803                     t++;
3804                     cp[2*i+1] = utf8n_to_uvuni(t, tend-t, &ulen, flags);
3805                     t += ulen;
3806                 }
3807                 else {
3808                  cp[2*i+1] = cp[2*i];
3809                 }
3810                 i++;
3811             }
3812             qsort(cp, i, 2*sizeof(UV), uvcompare);
3813             for (j = 0; j < i; j++) {
3814                 UV  val = cp[2*j];
3815                 diff = val - nextmin;
3816                 if (diff > 0) {
3817                     t = uvuni_to_utf8(tmpbuf,nextmin);
3818                     sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3819                     if (diff > 1) {
3820                         U8  range_mark = UTF_TO_NATIVE(0xff);
3821                         t = uvuni_to_utf8(tmpbuf, val - 1);
3822                         sv_catpvn(transv, (char *)&range_mark, 1);
3823                         sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3824                     }
3825                 }
3826                 val = cp[2*j+1];
3827                 if (val >= nextmin)
3828                     nextmin = val + 1;
3829             }
3830             t = uvuni_to_utf8(tmpbuf,nextmin);
3831             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3832             {
3833                 U8 range_mark = UTF_TO_NATIVE(0xff);
3834                 sv_catpvn(transv, (char *)&range_mark, 1);
3835             }
3836             t = uvuni_to_utf8(tmpbuf, 0x7fffffff);
3837             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
3838             t = (const U8*)SvPVX_const(transv);
3839             tlen = SvCUR(transv);
3840             tend = t + tlen;
3841             Safefree(cp);
3842         }
3843         else if (!rlen && !del) {
3844             r = t; rlen = tlen; rend = tend;
3845         }
3846         if (!squash) {
3847                 if ((!rlen && !del) || t == r ||
3848                     (tlen == rlen && memEQ((char *)t, (char *)r, tlen)))
3849                 {
3850                     o->op_private |= OPpTRANS_IDENTICAL;
3851                 }
3852         }
3853
3854         while (t < tend || tfirst <= tlast) {
3855             /* see if we need more "t" chars */
3856             if (tfirst > tlast) {
3857                 tfirst = (I32)utf8n_to_uvuni(t, tend - t, &ulen, flags);
3858                 t += ulen;
3859                 if (t < tend && NATIVE_TO_UTF(*t) == 0xff) {    /* illegal utf8 val indicates range */
3860                     t++;
3861                     tlast = (I32)utf8n_to_uvuni(t, tend - t, &ulen, flags);
3862                     t += ulen;
3863                 }
3864                 else
3865                     tlast = tfirst;
3866             }
3867
3868             /* now see if we need more "r" chars */
3869             if (rfirst > rlast) {
3870                 if (r < rend) {
3871                     rfirst = (I32)utf8n_to_uvuni(r, rend - r, &ulen, flags);
3872                     r += ulen;
3873                     if (r < rend && NATIVE_TO_UTF(*r) == 0xff) {        /* illegal utf8 val indicates range */
3874                         r++;
3875                         rlast = (I32)utf8n_to_uvuni(r, rend - r, &ulen, flags);
3876                         r += ulen;
3877                     }
3878                     else
3879                         rlast = rfirst;
3880                 }
3881                 else {
3882                     if (!havefinal++)
3883                         final = rlast;
3884                     rfirst = rlast = 0xffffffff;
3885                 }
3886             }
3887
3888             /* now see which range will peter our first, if either. */
3889             tdiff = tlast - tfirst;
3890             rdiff = rlast - rfirst;
3891
3892             if (tdiff <= rdiff)
3893                 diff = tdiff;
3894             else
3895                 diff = rdiff;
3896
3897             if (rfirst == 0xffffffff) {
3898                 diff = tdiff;   /* oops, pretend rdiff is infinite */
3899                 if (diff > 0)
3900                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\tXXXX\n",
3901                                    (long)tfirst, (long)tlast);
3902                 else
3903                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\tXXXX\n", (long)tfirst);
3904             }
3905             else {
3906                 if (diff > 0)
3907                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\t%04lx\n",
3908                                    (long)tfirst, (long)(tfirst + diff),
3909                                    (long)rfirst);
3910                 else
3911                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\t%04lx\n",
3912                                    (long)tfirst, (long)rfirst);
3913
3914                 if (rfirst + diff > max)
3915                     max = rfirst + diff;
3916                 if (!grows)
3917                     grows = (tfirst < rfirst &&
3918                              UNISKIP(tfirst) < UNISKIP(rfirst + diff));
3919                 rfirst += diff + 1;
3920             }
3921             tfirst += diff + 1;
3922         }
3923
3924         none = ++max;
3925         if (del)
3926             del = ++max;
3927
3928         if (max > 0xffff)
3929             bits = 32;
3930         else if (max > 0xff)
3931             bits = 16;
3932         else
3933             bits = 8;
3934
3935         PerlMemShared_free(cPVOPo->op_pv);
3936         cPVOPo->op_pv = NULL;
3937
3938         swash = MUTABLE_SV(swash_init("utf8", "", listsv, bits, none));
3939 #ifdef USE_ITHREADS
3940         cPADOPo->op_padix = pad_alloc(OP_TRANS, SVs_PADTMP);
3941         SvREFCNT_dec(PAD_SVl(cPADOPo->op_padix));
3942         PAD_SETSV(cPADOPo->op_padix, swash);
3943         SvPADTMP_on(swash);
3944         SvREADONLY_on(swash);
3945 #else
3946         cSVOPo->op_sv = swash;
3947 #endif
3948         SvREFCNT_dec(listsv);
3949         SvREFCNT_dec(transv);
3950
3951         if (!del && havefinal && rlen)
3952             (void)hv_store(MUTABLE_HV(SvRV(swash)), "FINAL", 5,
3953                            newSVuv((UV)final), 0);
3954
3955         if (grows)
3956             o->op_private |= OPpTRANS_GROWS;
3957
3958         Safefree(tsave);
3959         Safefree(rsave);
3960
3961 #ifdef PERL_MAD
3962         op_getmad(expr,o,'e');
3963         op_getmad(repl,o,'r');
3964 #else
3965         op_free(expr);
3966         op_free(repl);
3967 #endif
3968         return o;
3969     }
3970
3971     tbl = (short*)cPVOPo->op_pv;
3972     if (complement) {
3973         Zero(tbl, 256, short);
3974         for (i = 0; i < (I32)tlen; i++)
3975             tbl[t[i]] = -1;
3976         for (i = 0, j = 0; i < 256; i++) {
3977             if (!tbl[i]) {
3978                 if (j >= (I32)rlen) {
3979                     if (del)
3980                         tbl[i] = -2;
3981                     else if (rlen)
3982                         tbl[i] = r[j-1];
3983                     else
3984                         tbl[i] = (short)i;
3985                 }
3986                 else {
3987                     if (i < 128 && r[j] >= 128)
3988                         grows = 1;
3989                     tbl[i] = r[j++];
3990                 }
3991             }
3992         }
3993         if (!del) {
3994             if (!rlen) {
3995                 j = rlen;
3996                 if (!squash)
3997                     o->op_private |= OPpTRANS_IDENTICAL;
3998             }
3999             else if (j >= (I32)rlen)
4000                 j = rlen - 1;
4001             else {
4002                 tbl = 
4003                     (short *)
4004                     PerlMemShared_realloc(tbl,
4005                                           (0x101+rlen-j) * sizeof(short));
4006                 cPVOPo->op_pv = (char*)tbl;
4007             }
4008             tbl[0x100] = (short)(rlen - j);
4009             for (i=0; i < (I32)rlen - j; i++)
4010                 tbl[0x101+i] = r[j+i];
4011         }
4012     }
4013     else {
4014         if (!rlen && !del) {
4015             r = t; rlen = tlen;
4016             if (!squash)
4017                 o->op_private |= OPpTRANS_IDENTICAL;
4018         }
4019         else if (!squash && rlen == tlen && memEQ((char*)t, (char*)r, tlen)) {
4020             o->op_private |= OPpTRANS_IDENTICAL;
4021         }
4022         for (i = 0; i < 256; i++)
4023             tbl[i] = -1;
4024         for (i = 0, j = 0; i < (I32)tlen; i++,j++) {
4025             if (j >= (I32)rlen) {
4026                 if (del) {
4027                     if (tbl[t[i]] == -1)
4028                         tbl[t[i]] = -2;
4029                     continue;
4030                 }
4031                 --j;
4032             }
4033             if (tbl[t[i]] == -1) {
4034                 if (t[i] < 128 && r[j] >= 128)
4035                     grows = 1;
4036                 tbl[t[i]] = r[j];
4037             }
4038         }
4039     }
4040
4041     if(del && rlen == tlen) {
4042         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Useless use of /d modifier in transliteration operator"); 
4043     } else if(rlen > tlen) {
4044         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Replacement list is longer than search list");
4045     }
4046
4047     if (grows)
4048         o->op_private |= OPpTRANS_GROWS;
4049 #ifdef PERL_MAD
4050     op_getmad(expr,o,'e');
4051     op_getmad(repl,o,'r');
4052 #else
4053     op_free(expr);
4054     op_free(repl);
4055 #endif
4056
4057     return o;
4058 }
4059
4060 /*
4061 =for apidoc Am|OP *|newPMOP|I32 type|I32 flags
4062
4063 Constructs, checks, and returns an op of any pattern matching type.
4064 I<type> is the opcode.  I<flags> gives the eight bits of C<op_flags>
4065 and, shifted up eight bits, the eight bits of C<op_private>.
4066
4067 =cut
4068 */
4069
4070 OP *
4071 Perl_newPMOP(pTHX_ I32 type, I32 flags)
4072 {
4073     dVAR;
4074     PMOP *pmop;
4075
4076     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_PMOP);
4077
4078     NewOp(1101, pmop, 1, PMOP);
4079     pmop->op_type = (OPCODE)type;
4080     pmop->op_ppaddr = PL_ppaddr[type];
4081     pmop->op_flags = (U8)flags;
4082     pmop->op_private = (U8)(0 | (flags >> 8));
4083
4084     if (PL_hints & HINT_RE_TAINT)
4085         pmop->op_pmflags |= PMf_RETAINT;
4086     if (PL_hints & HINT_LOCALE) {
4087         set_regex_charset(&(pmop->op_pmflags), REGEX_LOCALE_CHARSET);
4088     }
4089     else if ((! (PL_hints & HINT_BYTES)) && (PL_hints & HINT_UNI_8_BIT)) {
4090         set_regex_charset(&(pmop->op_pmflags), REGEX_UNICODE_CHARSET);
4091     }
4092     if (PL_hints & HINT_RE_FLAGS) {
4093         SV *reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4094          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags"), 0, 0
4095         );
4096         if (reflags && SvOK(reflags)) pmop->op_pmflags |= SvIV(reflags);
4097         reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4098          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags_charset"), 0, 0
4099         );
4100         if (reflags && SvOK(reflags)) {
4101             set_regex_charset(&(pmop->op_pmflags), (regex_charset)SvIV(reflags));
4102         }
4103     }
4104
4105
4106 #ifdef USE_ITHREADS
4107     assert(SvPOK(PL_regex_pad[0]));
4108     if (SvCUR(PL_regex_pad[0])) {
4109         /* Pop off the "packed" IV from the end.  */
4110         SV *const repointer_list = PL_regex_pad[0];
4111         const char *p = SvEND(repointer_list) - sizeof(IV);
4112         const IV offset = *((IV*)p);
4113
4114         assert(SvCUR(repointer_list) % sizeof(IV) == 0);
4115
4116         SvEND_set(repointer_list, p);
4117
4118         pmop->op_pmoffset = offset;
4119         /* This slot should be free, so assert this:  */
4120         assert(PL_regex_pad[offset] == &PL_sv_undef);
4121     } else {
4122         SV * const repointer = &PL_sv_undef;
4123         av_push(PL_regex_padav, repointer);
4124         pmop->op_pmoffset = av_len(PL_regex_padav);
4125         PL_regex_pad = AvARRAY(PL_regex_padav);
4126     }
4127 #endif
4128
4129     return CHECKOP(type, pmop);
4130 }
4131
4132 /* Given some sort of match op o, and an expression expr containing a
4133  * pattern, either compile expr into a regex and attach it to o (if it's
4134  * constant), or convert expr into a runtime regcomp op sequence (if it's
4135  * not)
4136  *
4137  * isreg indicates that the pattern is part of a regex construct, eg
4138  * $x =~ /pattern/ or split /pattern/, as opposed to $x =~ $pattern or
4139  * split "pattern", which aren't. In the former case, expr will be a list
4140  * if the pattern contains more than one term (eg /a$b/) or if it contains
4141  * a replacement, ie s/// or tr///.
4142  */
4143
4144 OP *
4145 Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
4146 {
4147     dVAR;
4148     PMOP *pm;
4149     LOGOP *rcop;
4150     I32 repl_has_vars = 0;
4151     OP* repl = NULL;
4152     bool reglist;
4153
4154     PERL_ARGS_ASSERT_PMRUNTIME;
4155
4156     if (
4157         o->op_type == OP_SUBST
4158      || o->op_type == OP_TRANS || o->op_type == OP_TRANSR
4159     ) {
4160         /* last element in list is the replacement; pop it */
4161         OP* kid;
4162         repl = cLISTOPx(expr)->op_last;
4163         kid = cLISTOPx(expr)->op_first;
4164         while (kid->op_sibling != repl)
4165             kid = kid->op_sibling;
4166         kid->op_sibling = NULL;
4167         cLISTOPx(expr)->op_last = kid;
4168     }
4169
4170     if (isreg && expr->op_type == OP_LIST &&
4171         cLISTOPx(expr)->op_first->op_sibling == cLISTOPx(expr)->op_last)
4172     {
4173         /* convert single element list to element */
4174         OP* const oe = expr;
4175         expr = cLISTOPx(oe)->op_first->op_sibling;
4176         cLISTOPx(oe)->op_first->op_sibling = NULL;
4177         cLISTOPx(oe)->op_last = NULL;
4178         op_free(oe);
4179     }
4180
4181     if (o->op_type == OP_TRANS || o->op_type == OP_TRANSR) {
4182         return pmtrans(o, expr, repl);
4183     }
4184
4185     reglist = isreg && expr->op_type == OP_LIST;
4186     if (reglist)
4187         op_null(expr);
4188
4189     PL_hints |= HINT_BLOCK_SCOPE;
4190     pm = (PMOP*)o;
4191
4192     if (expr->op_type == OP_CONST) {
4193         SV *pat = ((SVOP*)expr)->op_sv;
4194         U32 pm_flags = pm->op_pmflags & RXf_PMf_COMPILETIME;
4195
4196         if (o->op_flags & OPf_SPECIAL)
4197             pm_flags |= RXf_SPLIT;
4198
4199         if (DO_UTF8(pat)) {
4200             assert (SvUTF8(pat));
4201         } else if (SvUTF8(pat)) {
4202             /* Not doing UTF-8, despite what the SV says. Is this only if we're
4203                trapped in use 'bytes'?  */
4204             /* Make a copy of the octet sequence, but without the flag on, as
4205                the compiler now honours the SvUTF8 flag on pat.  */
4206             STRLEN len;
4207             const char *const p = SvPV(pat, len);
4208             pat = newSVpvn_flags(p, len, SVs_TEMP);
4209         }
4210
4211         PM_SETRE(pm, CALLREGCOMP(pat, pm_flags));
4212
4213 #ifdef PERL_MAD
4214         op_getmad(expr,(OP*)pm,'e');
4215 #else
4216         op_free(expr);
4217 #endif
4218     }
4219     else {
4220         if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL))
4221             expr = newUNOP((!(PL_hints & HINT_RE_EVAL)
4222                             ? OP_REGCRESET
4223                             : OP_REGCMAYBE),0,expr);
4224
4225         NewOp(1101, rcop, 1, LOGOP);
4226         rcop->op_type = OP_REGCOMP;
4227         rcop->op_ppaddr = PL_ppaddr[OP_REGCOMP];
4228         rcop->op_first = scalar(expr);
4229         rcop->op_flags |= OPf_KIDS
4230                             | ((PL_hints & HINT_RE_EVAL) ? OPf_SPECIAL : 0)
4231                             | (reglist ? OPf_STACKED : 0);
4232         rcop->op_private = 1;
4233         rcop->op_other = o;
4234         if (reglist)
4235             rcop->op_targ = pad_alloc(rcop->op_type, SVs_PADTMP);
4236
4237         /* /$x/ may cause an eval, since $x might be qr/(?{..})/  */
4238         if (PL_hints & HINT_RE_EVAL) PL_cv_has_eval = 1;
4239
4240         /* establish postfix order */
4241         if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL)) {
4242             LINKLIST(expr);
4243             rcop->op_next = expr;
4244             ((UNOP*)expr)->op_first->op_next = (OP*)rcop;
4245         }
4246         else {
4247             rcop->op_next = LINKLIST(expr);
4248             expr->op_next = (OP*)rcop;
4249         }
4250
4251         op_prepend_elem(o->op_type, scalar((OP*)rcop), o);
4252     }
4253
4254     if (repl) {
4255         OP *curop;
4256         if (pm->op_pmflags & PMf_EVAL) {
4257             curop = NULL;
4258             if (CopLINE(PL_curcop) < (line_t)PL_parser->multi_end)
4259                 CopLINE_set(PL_curcop, (line_t)PL_parser->multi_end);
4260         }
4261         else if (repl->op_type == OP_CONST)
4262             curop = repl;
4263         else {
4264             OP *lastop = NULL;
4265             for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
4266                 if (curop->op_type == OP_SCOPE
4267                         || curop->op_type == OP_LEAVE
4268                         || (PL_opargs[curop->op_type] & OA_DANGEROUS)) {
4269                     if (curop->op_type == OP_GV) {
4270                         GV * const gv = cGVOPx_gv(curop);
4271                         repl_has_vars = 1;
4272                         if (strchr("&`'123456789+-\016\022", *GvENAME(gv)))
4273                             break;
4274                     }
4275                     else if (curop->op_type == OP_RV2CV)
4276                         break;
4277                     else if (curop->op_type == OP_RV2SV ||
4278                              curop->op_type == OP_RV2AV ||
4279                              curop->op_type == OP_RV2HV ||
4280                              curop->op_type == OP_RV2GV) {
4281                         if (lastop && lastop->op_type != OP_GV) /*funny deref?*/
4282                             break;
4283                     }
4284                     else if (curop->op_type == OP_PADSV ||
4285                              curop->op_type == OP_PADAV ||
4286                              curop->op_type == OP_PADHV ||
4287                              curop->op_type == OP_PADANY)
4288                     {
4289                         repl_has_vars = 1;
4290                     }
4291                     else if (curop->op_type == OP_PUSHRE)
4292                         NOOP; /* Okay here, dangerous in newASSIGNOP */
4293                     else
4294                         break;
4295                 }
4296                 lastop = curop;
4297             }
4298         }
4299         if (curop == repl
4300             && !(repl_has_vars
4301                  && (!PM_GETRE(pm)
4302                      || RX_EXTFLAGS(PM_GETRE(pm)) & RXf_EVAL_SEEN)))
4303         {
4304             pm->op_pmflags |= PMf_CONST;        /* const for long enough */
4305             op_prepend_elem(o->op_type, scalar(repl), o);
4306         }
4307         else {
4308             if (curop == repl && !PM_GETRE(pm)) { /* Has variables. */
4309                 pm->op_pmflags |= PMf_MAYBE_CONST;
4310             }
4311             NewOp(1101, rcop, 1, LOGOP);
4312             rcop->op_type = OP_SUBSTCONT;
4313             rcop->op_ppaddr = PL_ppaddr[OP_SUBSTCONT];
4314             rcop->op_first = scalar(repl);
4315             rcop->op_flags |= OPf_KIDS;
4316             rcop->op_private = 1;
4317             rcop->op_other = o;
4318
4319             /* establish postfix order */
4320             rcop->op_next = LINKLIST(repl);
4321             repl->op_next = (OP*)rcop;
4322
4323             pm->op_pmreplrootu.op_pmreplroot = scalar((OP*)rcop);
4324             assert(!(pm->op_pmflags & PMf_ONCE));
4325             pm->op_pmstashstartu.op_pmreplstart = LINKLIST(rcop);
4326             rcop->op_next = 0;
4327         }
4328     }
4329
4330     return (OP*)pm;
4331 }
4332
4333 /*
4334 =for apidoc Am|OP *|newSVOP|I32 type|I32 flags|SV *sv
4335
4336 Constructs, checks, and returns an op of any type that involves an
4337 embedded SV.  I<type> is the opcode.  I<flags> gives the eight bits
4338 of C<op_flags>.  I<sv> gives the SV to embed in the op; this function
4339 takes ownership of one reference to it.
4340
4341 =cut
4342 */
4343
4344 OP *
4345 Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv)
4346 {
4347     dVAR;
4348     SVOP *svop;
4349
4350     PERL_ARGS_ASSERT_NEWSVOP;
4351
4352     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_SVOP
4353         || (PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4354         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP);
4355
4356     NewOp(1101, svop, 1, SVOP);
4357     svop->op_type = (OPCODE)type;
4358     svop->op_ppaddr = PL_ppaddr[type];
4359     svop->op_sv = sv;
4360     svop->op_next = (OP*)svop;
4361     svop->op_flags = (U8)flags;
4362     if (PL_opargs[type] & OA_RETSCALAR)
4363         scalar((OP*)svop);
4364     if (PL_opargs[type] & OA_TARGET)
4365         svop->op_targ = pad_alloc(type, SVs_PADTMP);
4366     return CHECKOP(type, svop);
4367 }
4368
4369 #ifdef USE_ITHREADS
4370
4371 /*
4372 =for apidoc Am|OP *|newPADOP|I32 type|I32 flags|SV *sv
4373
4374 Constructs, checks, and returns an op of any type that involves a
4375 reference to a pad element.  I<type> is the opcode.  I<flags> gives the
4376 eight bits of C<op_flags>.  A pad slot is automatically allocated, and
4377 is populated with I<sv>; this function takes ownership of one reference
4378 to it.
4379
4380 This function only exists if Perl has been compiled to use ithreads.
4381
4382 =cut
4383 */
4384
4385 OP *
4386 Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv)
4387 {
4388     dVAR;
4389     PADOP *padop;
4390
4391     PERL_ARGS_ASSERT_NEWPADOP;
4392
4393     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_SVOP
4394         || (PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4395         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP);
4396
4397     NewOp(1101, padop, 1, PADOP);
4398     padop->op_type = (OPCODE)type;
4399     padop->op_ppaddr = PL_ppaddr[type];
4400     padop->op_padix = pad_alloc(type, SVs_PADTMP);
4401     SvREFCNT_dec(PAD_SVl(padop->op_padix));
4402     PAD_SETSV(padop->op_padix, sv);
4403     assert(sv);
4404     SvPADTMP_on(sv);
4405     padop->op_next = (OP*)padop;
4406     padop->op_flags = (U8)flags;
4407     if (PL_opargs[type] & OA_RETSCALAR)
4408         scalar((OP*)padop);
4409     if (PL_opargs[type] & OA_TARGET)
4410         padop->op_targ = pad_alloc(type, SVs_PADTMP);
4411     return CHECKOP(type, padop);
4412 }
4413
4414 #endif /* !USE_ITHREADS */
4415
4416 /*
4417 =for apidoc Am|OP *|newGVOP|I32 type|I32 flags|GV *gv
4418
4419 Constructs, checks, and returns an op of any type that involves an
4420 embedded reference to a GV.  I<type> is the opcode.  I<flags> gives the
4421 eight bits of C<op_flags>.  I<gv> identifies the GV that the op should
4422 reference; calling this function does not transfer ownership of any
4423 reference to it.
4424
4425 =cut
4426 */
4427
4428 OP *
4429 Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
4430 {
4431     dVAR;
4432
4433     PERL_ARGS_ASSERT_NEWGVOP;
4434
4435 #ifdef USE_ITHREADS
4436     GvIN_PAD_on(gv);
4437     return newPADOP(type, flags, SvREFCNT_inc_simple_NN(gv));
4438 #else
4439     return newSVOP(type, flags, SvREFCNT_inc_simple_NN(gv));
4440 #endif
4441 }
4442
4443 /*
4444 =for apidoc Am|OP *|newPVOP|I32 type|I32 flags|char *pv
4445
4446 Constructs, checks, and returns an op of any type that involves an
4447 embedded C-level pointer (PV).  I<type> is the opcode.  I<flags> gives
4448 the eight bits of C<op_flags>.  I<pv> supplies the C-level pointer, which
4449 must have been allocated using L</PerlMemShared_malloc>; the memory will
4450 be freed when the op is destroyed.
4451
4452 =cut
4453 */
4454
4455 OP *
4456 Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
4457 {
4458     dVAR;
4459     PVOP *pvop;
4460
4461     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4462         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
4463
4464     NewOp(1101, pvop, 1, PVOP);
4465     pvop->op_type = (OPCODE)type;
4466     pvop->op_ppaddr = PL_ppaddr[type];
4467     pvop->op_pv = pv;
4468     pvop->op_next = (OP*)pvop;
4469     pvop->op_flags = (U8)flags;
4470     if (PL_opargs[type] & OA_RETSCALAR)
4471         scalar((OP*)pvop);
4472     if (PL_opargs[type] & OA_TARGET)
4473         pvop->op_targ = pad_alloc(type, SVs_PADTMP);
4474     return CHECKOP(type, pvop);
4475 }
4476
4477 #ifdef PERL_MAD
4478 OP*
4479 #else
4480 void
4481 #endif
4482 Perl_package(pTHX_ OP *o)
4483 {
4484     dVAR;
4485     SV *const sv = cSVOPo->op_sv;
4486 #ifdef PERL_MAD
4487     OP *pegop;
4488 #endif
4489
4490     PERL_ARGS_ASSERT_PACKAGE;
4491
4492     save_hptr(&PL_curstash);
4493     save_item(PL_curstname);
4494
4495     PL_curstash = gv_stashsv(sv, GV_ADD);
4496
4497     sv_setsv(PL_curstname, sv);
4498
4499     PL_hints |= HINT_BLOCK_SCOPE;
4500     PL_parser->copline = NOLINE;
4501     PL_parser->expect = XSTATE;
4502
4503 #ifndef PERL_MAD
4504     op_free(o);
4505 #else
4506     if (!PL_madskills) {
4507         op_free(o);
4508         return NULL;
4509     }
4510
4511     pegop = newOP(OP_NULL,0);
4512     op_getmad(o,pegop,'P');
4513     return pegop;
4514 #endif
4515 }
4516
4517 void
4518 Perl_package_version( pTHX_ OP *v )
4519 {
4520     dVAR;
4521     U32 savehints = PL_hints;
4522     PERL_ARGS_ASSERT_PACKAGE_VERSION;
4523     PL_hints &= ~HINT_STRICT_VARS;
4524     sv_setsv( GvSV(gv_fetchpvs("VERSION", GV_ADDMULTI, SVt_PV)), cSVOPx(v)->op_sv );
4525     PL_hints = savehints;
4526     op_free(v);
4527 }
4528
4529 #ifdef PERL_MAD
4530 OP*
4531 #else
4532 void
4533 #endif
4534 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
4535 {
4536     dVAR;
4537     OP *pack;
4538     OP *imop;
4539     OP *veop;
4540 #ifdef PERL_MAD
4541     OP *pegop = newOP(OP_NULL,0);
4542 #endif
4543     SV *use_version = NULL;
4544
4545     PERL_ARGS_ASSERT_UTILIZE;
4546
4547     if (idop->op_type != OP_CONST)
4548         Perl_croak(aTHX_ "Module name must be constant");
4549
4550     if (PL_madskills)
4551         op_getmad(idop,pegop,'U');
4552
4553     veop = NULL;
4554
4555     if (version) {
4556         SV * const vesv = ((SVOP*)version)->op_sv;
4557
4558         if (PL_madskills)
4559             op_getmad(version,pegop,'V');
4560         if (!arg && !SvNIOKp(vesv)) {
4561             arg = version;
4562         }
4563         else {
4564             OP *pack;
4565             SV *meth;
4566
4567             if (version->op_type != OP_CONST || !SvNIOKp(vesv))
4568                 Perl_croak(aTHX_ "Version number must be a constant number");
4569
4570             /* Make copy of idop so we don't free it twice */
4571             pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
4572
4573             /* Fake up a method call to VERSION */
4574             meth = newSVpvs_share("VERSION");
4575             veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
4576                             op_append_elem(OP_LIST,
4577                                         op_prepend_elem(OP_LIST, pack, list(version)),
4578                                         newSVOP(OP_METHOD_NAMED, 0, meth)));
4579         }
4580     }
4581
4582     /* Fake up an import/unimport */
4583     if (arg && arg->op_type == OP_STUB) {
4584         if (PL_madskills)
4585             op_getmad(arg,pegop,'S');
4586         imop = arg;             /* no import on explicit () */
4587     }
4588     else if (SvNIOKp(((SVOP*)idop)->op_sv)) {
4589         imop = NULL;            /* use 5.0; */
4590         if (aver)
4591             use_version = ((SVOP*)idop)->op_sv;
4592         else
4593             idop->op_private |= OPpCONST_NOVER;
4594     }
4595     else {
4596         SV *meth;
4597
4598         if (PL_madskills)
4599             op_getmad(arg,pegop,'A');
4600
4601         /* Make copy of idop so we don't free it twice */
4602         pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
4603
4604         /* Fake up a method call to import/unimport */
4605         meth = aver
4606             ? newSVpvs_share("import") : newSVpvs_share("unimport");
4607         imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
4608                        op_append_elem(OP_LIST,
4609                                    op_prepend_elem(OP_LIST, pack, list(arg)),
4610                                    newSVOP(OP_METHOD_NAMED, 0, meth)));
4611     }
4612
4613     /* Fake up the BEGIN {}, which does its thing immediately. */
4614     newATTRSUB(floor,
4615         newSVOP(OP_CONST, 0, newSVpvs_share("BEGIN")),
4616         NULL,
4617         NULL,
4618         op_append_elem(OP_LINESEQ,
4619             op_append_elem(OP_LINESEQ,
4620                 newSTATEOP(0, NULL, newUNOP(OP_REQUIRE, 0, idop)),
4621                 newSTATEOP(0, NULL, veop)),
4622             newSTATEOP(0, NULL, imop) ));
4623
4624     if (use_version) {
4625         /* If we request a version >= 5.9.5, load feature.pm with the
4626          * feature bundle that corresponds to the required version. */
4627         use_version = sv_2mortal(new_version(use_version));
4628
4629         if (vcmp(use_version,
4630                  sv_2mortal(upg_version(newSVnv(5.009005), FALSE))) >= 0) {
4631             SV *const importsv = vnormal(use_version);
4632             *SvPVX_mutable(importsv) = ':';
4633             ENTER_with_name("load_feature");
4634             Perl_load_module(aTHX_ 0, newSVpvs("feature"), NULL, importsv, NULL);
4635             LEAVE_with_name("load_feature");
4636         }
4637         /* If a version >= 5.11.0 is requested, strictures are on by default! */
4638         if (vcmp(use_version,
4639                  sv_2mortal(upg_version(newSVnv(5.011000), FALSE))) >= 0) {
4640             PL_hints |= (HINT_STRICT_REFS | HINT_STRICT_SUBS | HINT_STRICT_VARS);
4641         }
4642     }
4643
4644     /* The "did you use incorrect case?" warning used to be here.
4645      * The problem is that on case-insensitive filesystems one
4646      * might get false positives for "use" (and "require"):
4647      * "use Strict" or "require CARP" will work.  This causes
4648      * portability problems for the script: in case-strict
4649      * filesystems the script will stop working.
4650      *
4651      * The "incorrect case" warning checked whether "use Foo"
4652      * imported "Foo" to your namespace, but that is wrong, too:
4653      * there is no requirement nor promise in the language that
4654      * a Foo.pm should or would contain anything in package "Foo".
4655      *
4656      * There is very little Configure-wise that can be done, either:
4657      * the case-sensitivity of the build filesystem of Perl does not
4658      * help in guessing the case-sensitivity of the runtime environment.
4659      */
4660
4661     PL_hints |= HINT_BLOCK_SCOPE;
4662     PL_parser->copline = NOLINE;
4663     PL_parser->expect = XSTATE;
4664     PL_cop_seqmax++; /* Purely for B::*'s benefit */
4665     if (PL_cop_seqmax == PERL_PADSEQ_INTRO) /* not a legal value */
4666         PL_cop_seqmax++;
4667
4668 #ifdef PERL_MAD
4669     if (!PL_madskills) {
4670         /* FIXME - don't allocate pegop if !PL_madskills */
4671         op_free(pegop);
4672         return NULL;
4673     }
4674     return pegop;
4675 #endif
4676 }
4677
4678 /*
4679 =head1 Embedding Functions
4680
4681 =for apidoc load_module
4682
4683 Loads the module whose name is pointed to by the string part of name.
4684 Note that the actual module name, not its filename, should be given.
4685 Eg, "Foo::Bar" instead of "Foo/Bar.pm".  flags can be any of
4686 PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, or PERL_LOADMOD_IMPORT_OPS
4687 (or 0 for no flags). ver, if specified, provides version semantics
4688 similar to C<use Foo::Bar VERSION>.  The optional trailing SV*
4689 arguments can be used to specify arguments to the module's import()
4690 method, similar to C<use Foo::Bar VERSION LIST>.  They must be
4691 terminated with a final NULL pointer.  Note that this list can only
4692 be omitted when the PERL_LOADMOD_NOIMPORT flag has been used.
4693 Otherwise at least a single NULL pointer to designate the default
4694 import list is required.
4695
4696 =cut */
4697
4698 void
4699 Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...)
4700 {
4701     va_list args;
4702
4703     PERL_ARGS_ASSERT_LOAD_MODULE;
4704
4705     va_start(args, ver);
4706     vload_module(flags, name, ver, &args);
4707     va_end(args);
4708 }
4709
4710 #ifdef PERL_IMPLICIT_CONTEXT
4711 void
4712 Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...)
4713 {
4714     dTHX;
4715     va_list args;
4716     PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT;
4717     va_start(args, ver);
4718     vload_module(flags, name, ver, &args);
4719     va_end(args);
4720 }
4721 #endif
4722
4723 void
4724 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
4725 {
4726     dVAR;
4727     OP *veop, *imop;
4728     OP * const modname = newSVOP(OP_CONST, 0, name);
4729
4730     PERL_ARGS_ASSERT_VLOAD_MODULE;
4731
4732     modname->op_private |= OPpCONST_BARE;
4733     if (ver) {
4734         veop = newSVOP(OP_CONST, 0, ver);
4735     }
4736     else
4737         veop = NULL;
4738     if (flags & PERL_LOADMOD_NOIMPORT) {
4739         imop = sawparens(newNULLLIST());
4740     }
4741     else if (flags & PERL_LOADMOD_IMPORT_OPS) {
4742         imop = va_arg(*args, OP*);
4743     }
4744     else {
4745         SV *sv;
4746         imop = NULL;
4747         sv = va_arg(*args, SV*);
4748         while (sv) {
4749             imop = op_append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
4750             sv = va_arg(*args, SV*);
4751         }
4752     }
4753
4754     /* utilize() fakes up a BEGIN { require ..; import ... }, so make sure
4755      * that it has a PL_parser to play with while doing that, and also
4756      * that it doesn't mess with any existing parser, by creating a tmp
4757      * new parser with lex_start(). This won't actually be used for much,
4758      * since pp_require() will create another parser for the real work. */
4759
4760     ENTER;
4761     SAVEVPTR(PL_curcop);
4762     lex_start(NULL, NULL, LEX_START_SAME_FILTER);
4763     utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
4764             veop, modname, imop);
4765     LEAVE;
4766 }
4767
4768 OP *
4769 Perl_dofile(pTHX_ OP *term, I32 force_builtin)
4770 {
4771     dVAR;
4772     OP *doop;
4773     GV *gv = NULL;
4774
4775     PERL_ARGS_ASSERT_DOFILE;
4776
4777     if (!force_builtin) {
4778         gv = gv_fetchpvs("do", GV_NOTQUAL, SVt_PVCV);
4779         if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
4780             GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "do", FALSE);
4781             gv = gvp ? *gvp : NULL;
4782         }
4783     }
4784
4785     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
4786         doop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
4787                                op_append_elem(OP_LIST, term,
4788                                            scalar(newUNOP(OP_RV2CV, 0,
4789                                                           newGVOP(OP_GV, 0, gv))))));
4790     }
4791     else {
4792         doop = newUNOP(OP_DOFILE, 0, scalar(term));
4793     }
4794     return doop;
4795 }
4796
4797 /*
4798 =head1 Optree construction
4799
4800 =for apidoc Am|OP *|newSLICEOP|I32 flags|OP *subscript|OP *listval
4801
4802 Constructs, checks, and returns an C<lslice> (list slice) op.  I<flags>
4803 gives the eight bits of C<op_flags>, except that C<OPf_KIDS> will
4804 be set automatically, and, shifted up eight bits, the eight bits of
4805 C<op_private>, except that the bit with value 1 or 2 is automatically
4806 set as required.  I<listval> and I<subscript> supply the parameters of
4807 the slice; they are consumed by this function and become part of the
4808 constructed op tree.
4809
4810 =cut
4811 */
4812
4813 OP *
4814 Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listval)
4815 {
4816     return newBINOP(OP_LSLICE, flags,
4817             list(force_list(subscript)),
4818             list(force_list(listval)) );
4819 }
4820
4821 STATIC I32
4822 S_is_list_assignment(pTHX_ register const OP *o)
4823 {
4824     unsigned type;
4825     U8 flags;
4826
4827     if (!o)
4828         return TRUE;
4829
4830     if ((o->op_type == OP_NULL) && (o->op_flags & OPf_KIDS))
4831         o = cUNOPo->op_first;
4832
4833     flags = o->op_flags;
4834     type = o->op_type;
4835     if (type == OP_COND_EXPR) {
4836         const I32 t = is_list_assignment(cLOGOPo->op_first->op_sibling);
4837         const I32 f = is_list_assignment(cLOGOPo->op_first->op_sibling->op_sibling);
4838
4839         if (t && f)
4840             return TRUE;
4841         if (t || f)
4842             yyerror("Assignment to both a list and a scalar");
4843         return FALSE;
4844     }
4845
4846     if (type == OP_LIST &&
4847         (flags & OPf_WANT) == OPf_WANT_SCALAR &&
4848         o->op_private & OPpLVAL_INTRO)
4849         return FALSE;
4850
4851     if (type == OP_LIST || flags & OPf_PARENS ||
4852         type == OP_RV2AV || type == OP_RV2HV ||
4853         type == OP_ASLICE || type == OP_HSLICE)
4854         return TRUE;
4855
4856     if (type == OP_PADAV || type == OP_PADHV)
4857         return TRUE;
4858
4859     if (type == OP_RV2SV)
4860         return FALSE;
4861
4862     return FALSE;
4863 }
4864
4865 /*
4866   Helper function for newASSIGNOP to detection commonality between the
4867   lhs and the rhs.  Marks all variables with PL_generation.  If it
4868   returns TRUE the assignment must be able to handle common variables.
4869 */
4870 PERL_STATIC_INLINE bool
4871 S_aassign_common_vars(pTHX_ OP* o)
4872 {
4873     OP *curop;
4874     for (curop = cUNOPo->op_first; curop; curop=curop->op_sibling) {
4875         if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
4876             if (curop->op_type == OP_GV) {
4877                 GV *gv = cGVOPx_gv(curop);
4878                 if (gv == PL_defgv
4879                     || (int)GvASS