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