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