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