WinCE Perl EVC4 support
[perl.git] / op.c
1 #line 2 "op.c"
2 /*    op.c
3  *
4  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
5  *    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
6  *
7  *    You may distribute under the terms of either the GNU General Public
8  *    License or the Artistic License, as specified in the README file.
9  *
10  */
11
12 /*
13  * 'You see: Mr. Drogo, he married poor Miss Primula Brandybuck.  She was
14  *  our Mr. Bilbo's first cousin on the mother's side (her mother being the
15  *  youngest of the Old Took's daughters); and Mr. Drogo was his second
16  *  cousin.  So Mr. Frodo is his first *and* second cousin, once removed
17  *  either way, as the saying is, if you follow me.'       --the Gaffer
18  *
19  *     [p.23 of _The Lord of the Rings_, I/i: "A Long-Expected Party"]
20  */
21
22 /* This file contains the functions that create, manipulate and optimize
23  * the OP structures that hold a compiled perl program.
24  *
25  * A Perl program is compiled into a tree of OPs. Each op contains
26  * structural pointers (eg to its siblings and the next op in the
27  * execution sequence), a pointer to the function that would execute the
28  * op, plus any data specific to that op. For example, an OP_CONST op
29  * points to the pp_const() function and to an SV containing the constant
30  * value. When pp_const() is executed, its job is to push that SV onto the
31  * stack.
32  *
33  * OPs are mainly created by the newFOO() functions, which are mainly
34  * called from the parser (in perly.y) as the code is parsed. For example
35  * the Perl code $a + $b * $c would cause the equivalent of the following
36  * to be called (oversimplifying a bit):
37  *
38  *  newBINOP(OP_ADD, flags,
39  *      newSVREF($a),
40  *      newBINOP(OP_MULTIPLY, flags, newSVREF($b), newSVREF($c))
41  *  )
42  *
43  * Note that during the build of miniperl, a temporary copy of this file
44  * is made, called opmini.c.
45  */
46
47 /*
48 Perl's compiler is essentially a 3-pass compiler with interleaved phases:
49
50     A bottom-up pass
51     A top-down pass
52     An execution-order pass
53
54 The bottom-up pass is represented by all the "newOP" routines and
55 the ck_ routines.  The bottom-upness is actually driven by yacc.
56 So at the point that a ck_ routine fires, we have no idea what the
57 context is, either upward in the syntax tree, or either forward or
58 backward in the execution order.  (The bottom-up parser builds that
59 part of the execution order it knows about, but if you follow the "next"
60 links around, you'll find it's actually a closed loop through the
61 top level node.)
62
63 Whenever the bottom-up parser gets to a node that supplies context to
64 its components, it invokes that portion of the top-down pass that applies
65 to that part of the subtree (and marks the top node as processed, so
66 if a node further up supplies context, it doesn't have to take the
67 plunge again).  As a particular subcase of this, as the new node is
68 built, it takes all the closed execution loops of its subcomponents
69 and links them into a new closed loop for the higher level node.  But
70 it's still not the real execution order.
71
72 The actual execution order is not known till we get a grammar reduction
73 to a top-level unit like a subroutine or file that will be called by
74 "name" rather than via a "next" pointer.  At that point, we can call
75 into peep() to do that code's portion of the 3rd pass.  It has to be
76 recursive, but it's recursive on basic blocks, not on tree nodes.
77 */
78
79 /* To implement user lexical pragmas, there needs to be a way at run time to
80    get the compile time state of %^H for that block.  Storing %^H in every
81    block (or even COP) would be very expensive, so a different approach is
82    taken.  The (running) state of %^H is serialised into a tree of HE-like
83    structs.  Stores into %^H are chained onto the current leaf as a struct
84    refcounted_he * with the key and the value.  Deletes from %^H are saved
85    with a value of PL_sv_placeholder.  The state of %^H at any point can be
86    turned back into a regular HV by walking back up the tree from that point's
87    leaf, ignoring any key you've already seen (placeholder or not), storing
88    the rest into the HV structure, then removing the placeholders. Hence
89    memory is only used to store the %^H deltas from the enclosing COP, rather
90    than the entire %^H on each COP.
91
92    To cause actions on %^H to write out the serialisation records, it has
93    magic type 'H'. This magic (itself) does nothing, but its presence causes
94    the values to gain magic type 'h', which has entries for set and clear.
95    C<Perl_magic_sethint> updates C<PL_compiling.cop_hints_hash> with a store
96    record, with deletes written by C<Perl_magic_clearhint>. C<SAVEHINTS>
97    saves the current C<PL_compiling.cop_hints_hash> on the save stack, so that
98    it will be correctly restored when any inner compiling scope is exited.
99 */
100
101 #include "EXTERN.h"
102 #define PERL_IN_OP_C
103 #include "perl.h"
104 #include "keywords.h"
105 #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         if (!hv_fetch_ent(GvHV(*fields), *svp, FALSE, 0)) {
1914             Perl_croak(aTHX_ "No such class field \"%"SVf"\" " 
1915                            "in variable %"SVf" of type %"HEKf, 
1916                       SVfARG(*svp), SVfARG(lexname),
1917                       HEKfARG(HvNAME_HEK(SvSTASH(lexname))));
1918         }
1919         break;
1920     }
1921
1922     case OP_HSLICE: {
1923         UNOP *rop;
1924         SV *lexname;
1925         GV **fields;
1926         SV **svp;
1927         SVOP *first_key_op, *key_op;
1928
1929         S_scalar_slice_warning(aTHX_ o);
1930
1931         if ((o->op_private & (OPpLVAL_INTRO))
1932             /* I bet there's always a pushmark... */
1933             || ((LISTOP*)o)->op_first->op_sibling->op_type != OP_LIST)
1934             /* hmmm, no optimization if list contains only one key. */
1935             break;
1936         rop = (UNOP*)((LISTOP*)o)->op_last;
1937         if (rop->op_type != OP_RV2HV)
1938             break;
1939         if (rop->op_first->op_type == OP_PADSV)
1940             /* @$hash{qw(keys here)} */
1941             rop = (UNOP*)rop->op_first;
1942         else {
1943             /* @{$hash}{qw(keys here)} */
1944             if (rop->op_first->op_type == OP_SCOPE
1945                 && cLISTOPx(rop->op_first)->op_last->op_type == OP_PADSV)
1946                 {
1947                     rop = (UNOP*)cLISTOPx(rop->op_first)->op_last;
1948                 }
1949             else
1950                 break;
1951         }
1952
1953         lexname = *av_fetch(PL_comppad_name, rop->op_targ, TRUE);
1954         if (!SvPAD_TYPED(lexname))
1955             break;
1956         fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
1957         if (!fields || !GvHV(*fields))
1958             break;
1959         /* Again guessing that the pushmark can be jumped over.... */
1960         first_key_op = (SVOP*)((LISTOP*)((LISTOP*)o)->op_first->op_sibling)
1961             ->op_first->op_sibling;
1962         for (key_op = first_key_op; key_op;
1963              key_op = (SVOP*)key_op->op_sibling) {
1964             if (key_op->op_type != OP_CONST)
1965                 continue;
1966             svp = cSVOPx_svp(key_op);
1967             if (!hv_fetch_ent(GvHV(*fields), *svp, FALSE, 0)) {
1968                 Perl_croak(aTHX_ "No such class field \"%"SVf"\" " 
1969                            "in variable %"SVf" of type %"HEKf, 
1970                       SVfARG(*svp), SVfARG(lexname),
1971                       HEKfARG(HvNAME_HEK(SvSTASH(lexname))));
1972             }
1973         }
1974         break;
1975     }
1976     case OP_ASLICE:
1977         S_scalar_slice_warning(aTHX_ o);
1978         break;
1979
1980     case OP_SUBST: {
1981         if (cPMOPo->op_pmreplrootu.op_pmreplroot)
1982             finalize_op(cPMOPo->op_pmreplrootu.op_pmreplroot);
1983         break;
1984     }
1985     default:
1986         break;
1987     }
1988
1989     if (o->op_flags & OPf_KIDS) {
1990         OP *kid;
1991         for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
1992             finalize_op(kid);
1993     }
1994 }
1995
1996 /*
1997 =for apidoc Amx|OP *|op_lvalue|OP *o|I32 type
1998
1999 Propagate lvalue ("modifiable") context to an op and its children.
2000 I<type> represents the context type, roughly based on the type of op that
2001 would do the modifying, although C<local()> is represented by OP_NULL,
2002 because it has no op type of its own (it is signalled by a flag on
2003 the lvalue op).
2004
2005 This function detects things that can't be modified, such as C<$x+1>, and
2006 generates errors for them. For example, C<$x+1 = 2> would cause it to be
2007 called with an op of type OP_ADD and a C<type> argument of OP_SASSIGN.
2008
2009 It also flags things that need to behave specially in an lvalue context,
2010 such as C<$$x = 5> which might have to vivify a reference in C<$x>.
2011
2012 =cut
2013 */
2014
2015 OP *
2016 Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags)
2017 {
2018     dVAR;
2019     OP *kid;
2020     /* -1 = error on localize, 0 = ignore localize, 1 = ok to localize */
2021     int localize = -1;
2022
2023     if (!o || (PL_parser && PL_parser->error_count))
2024         return o;
2025
2026     if ((o->op_private & OPpTARGET_MY)
2027         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
2028     {
2029         return o;
2030     }
2031
2032     assert( (o->op_flags & OPf_WANT) != OPf_WANT_VOID );
2033
2034     if (type == OP_PRTF || type == OP_SPRINTF) type = OP_ENTERSUB;
2035
2036     switch (o->op_type) {
2037     case OP_UNDEF:
2038         PL_modcount++;
2039         return o;
2040     case OP_STUB:
2041         if ((o->op_flags & OPf_PARENS) || PL_madskills)
2042             break;
2043         goto nomod;
2044     case OP_ENTERSUB:
2045         if ((type == OP_UNDEF || type == OP_REFGEN || type == OP_LOCK) &&
2046             !(o->op_flags & OPf_STACKED)) {
2047             o->op_type = OP_RV2CV;              /* entersub => rv2cv */
2048             /* Both ENTERSUB and RV2CV use this bit, but for different pur-
2049                poses, so we need it clear.  */
2050             o->op_private &= ~1;
2051             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
2052             assert(cUNOPo->op_first->op_type == OP_NULL);
2053             op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
2054             break;
2055         }
2056         else {                          /* lvalue subroutine call */
2057             o->op_private |= OPpLVAL_INTRO
2058                            |(OPpENTERSUB_INARGS * (type == OP_LEAVESUBLV));
2059             PL_modcount = RETURN_UNLIMITED_NUMBER;
2060             if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) {
2061                 /* Potential lvalue context: */
2062                 o->op_private |= OPpENTERSUB_INARGS;
2063                 break;
2064             }
2065             else {                      /* Compile-time error message: */
2066                 OP *kid = cUNOPo->op_first;
2067                 CV *cv;
2068
2069                 if (kid->op_type != OP_PUSHMARK) {
2070                     if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
2071                         Perl_croak(aTHX_
2072                                 "panic: unexpected lvalue entersub "
2073                                 "args: type/targ %ld:%"UVuf,
2074                                 (long)kid->op_type, (UV)kid->op_targ);
2075                     kid = kLISTOP->op_first;
2076                 }
2077                 while (kid->op_sibling)
2078                     kid = kid->op_sibling;
2079                 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
2080                     break;      /* Postpone until runtime */
2081                 }
2082
2083                 kid = kUNOP->op_first;
2084                 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
2085                     kid = kUNOP->op_first;
2086                 if (kid->op_type == OP_NULL)
2087                     Perl_croak(aTHX_
2088                                "Unexpected constant lvalue entersub "
2089                                "entry via type/targ %ld:%"UVuf,
2090                                (long)kid->op_type, (UV)kid->op_targ);
2091                 if (kid->op_type != OP_GV) {
2092                     break;
2093                 }
2094
2095                 cv = GvCV(kGVOP_gv);
2096                 if (!cv)
2097                     break;
2098                 if (CvLVALUE(cv))
2099                     break;
2100             }
2101         }
2102         /* FALL THROUGH */
2103     default:
2104       nomod:
2105         if (flags & OP_LVALUE_NO_CROAK) return NULL;
2106         /* grep, foreach, subcalls, refgen */
2107         if (type == OP_GREPSTART || type == OP_ENTERSUB
2108          || type == OP_REFGEN    || type == OP_LEAVESUBLV)
2109             break;
2110         yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
2111                      (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
2112                       ? "do block"
2113                       : (o->op_type == OP_ENTERSUB
2114                         ? "non-lvalue subroutine call"
2115                         : OP_DESC(o))),
2116                      type ? PL_op_desc[type] : "local"));
2117         return o;
2118
2119     case OP_PREINC:
2120     case OP_PREDEC:
2121     case OP_POW:
2122     case OP_MULTIPLY:
2123     case OP_DIVIDE:
2124     case OP_MODULO:
2125     case OP_REPEAT:
2126     case OP_ADD:
2127     case OP_SUBTRACT:
2128     case OP_CONCAT:
2129     case OP_LEFT_SHIFT:
2130     case OP_RIGHT_SHIFT:
2131     case OP_BIT_AND:
2132     case OP_BIT_XOR:
2133     case OP_BIT_OR:
2134     case OP_I_MULTIPLY:
2135     case OP_I_DIVIDE:
2136     case OP_I_MODULO:
2137     case OP_I_ADD:
2138     case OP_I_SUBTRACT:
2139         if (!(o->op_flags & OPf_STACKED))
2140             goto nomod;
2141         PL_modcount++;
2142         break;
2143
2144     case OP_COND_EXPR:
2145         localize = 1;
2146         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
2147             op_lvalue(kid, type);
2148         break;
2149
2150     case OP_RV2AV:
2151     case OP_RV2HV:
2152         if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
2153            PL_modcount = RETURN_UNLIMITED_NUMBER;
2154             return o;           /* Treat \(@foo) like ordinary list. */
2155         }
2156         /* FALL THROUGH */
2157     case OP_RV2GV:
2158         if (scalar_mod_type(o, type))
2159             goto nomod;
2160         ref(cUNOPo->op_first, o->op_type);
2161         /* FALL THROUGH */
2162     case OP_ASLICE:
2163     case OP_HSLICE:
2164         localize = 1;
2165         /* FALL THROUGH */
2166     case OP_AASSIGN:
2167         if (type == OP_LEAVESUBLV)
2168             o->op_private |= OPpMAYBE_LVSUB;
2169         /* FALL THROUGH */
2170     case OP_NEXTSTATE:
2171     case OP_DBSTATE:
2172        PL_modcount = RETURN_UNLIMITED_NUMBER;
2173         break;
2174     case OP_KVHSLICE:
2175     case OP_KVASLICE:
2176         if (type == OP_LEAVESUBLV)
2177             o->op_private |= OPpMAYBE_LVSUB;
2178         goto nomod;
2179     case OP_AV2ARYLEN:
2180         PL_hints |= HINT_BLOCK_SCOPE;
2181         if (type == OP_LEAVESUBLV)
2182             o->op_private |= OPpMAYBE_LVSUB;
2183         PL_modcount++;
2184         break;
2185     case OP_RV2SV:
2186         ref(cUNOPo->op_first, o->op_type);
2187         localize = 1;
2188         /* FALL THROUGH */
2189     case OP_GV:
2190         PL_hints |= HINT_BLOCK_SCOPE;
2191     case OP_SASSIGN:
2192     case OP_ANDASSIGN:
2193     case OP_ORASSIGN:
2194     case OP_DORASSIGN:
2195         PL_modcount++;
2196         break;
2197
2198     case OP_AELEMFAST:
2199     case OP_AELEMFAST_LEX:
2200         localize = -1;
2201         PL_modcount++;
2202         break;
2203
2204     case OP_PADAV:
2205     case OP_PADHV:
2206        PL_modcount = RETURN_UNLIMITED_NUMBER;
2207         if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
2208             return o;           /* Treat \(@foo) like ordinary list. */
2209         if (scalar_mod_type(o, type))
2210             goto nomod;
2211         if (type == OP_LEAVESUBLV)
2212             o->op_private |= OPpMAYBE_LVSUB;
2213         /* FALL THROUGH */
2214     case OP_PADSV:
2215         PL_modcount++;
2216         if (!type) /* local() */
2217             Perl_croak(aTHX_ "Can't localize lexical variable %"SVf,
2218                  PAD_COMPNAME_SV(o->op_targ));
2219         break;
2220
2221     case OP_PUSHMARK:
2222         localize = 0;
2223         break;
2224
2225     case OP_KEYS:
2226     case OP_RKEYS:
2227         if (type != OP_SASSIGN && type != OP_LEAVESUBLV)
2228             goto nomod;
2229         goto lvalue_func;
2230     case OP_SUBSTR:
2231         if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
2232             goto nomod;
2233         /* FALL THROUGH */
2234     case OP_POS:
2235     case OP_VEC:
2236       lvalue_func:
2237         if (type == OP_LEAVESUBLV)
2238             o->op_private |= OPpMAYBE_LVSUB;
2239         if (o->op_flags & OPf_KIDS)
2240             op_lvalue(cBINOPo->op_first->op_sibling, type);
2241         break;
2242
2243     case OP_AELEM:
2244     case OP_HELEM:
2245         ref(cBINOPo->op_first, o->op_type);
2246         if (type == OP_ENTERSUB &&
2247              !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
2248             o->op_private |= OPpLVAL_DEFER;
2249         if (type == OP_LEAVESUBLV)
2250             o->op_private |= OPpMAYBE_LVSUB;
2251         localize = 1;
2252         PL_modcount++;
2253         break;
2254
2255     case OP_SCOPE:
2256     case OP_LEAVE:
2257     case OP_ENTER:
2258     case OP_LINESEQ:
2259         localize = 0;
2260         if (o->op_flags & OPf_KIDS)
2261             op_lvalue(cLISTOPo->op_last, type);
2262         break;
2263
2264     case OP_NULL:
2265         localize = 0;
2266         if (o->op_flags & OPf_SPECIAL)          /* do BLOCK */
2267             goto nomod;
2268         else if (!(o->op_flags & OPf_KIDS))
2269             break;
2270         if (o->op_targ != OP_LIST) {
2271             op_lvalue(cBINOPo->op_first, type);
2272             break;
2273         }
2274         /* FALL THROUGH */
2275     case OP_LIST:
2276         localize = 0;
2277         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2278             /* elements might be in void context because the list is
2279                in scalar context or because they are attribute sub calls */
2280             if ( (kid->op_flags & OPf_WANT) != OPf_WANT_VOID )
2281                 op_lvalue(kid, type);
2282         break;
2283
2284     case OP_RETURN:
2285         if (type != OP_LEAVESUBLV)
2286             goto nomod;
2287         break; /* op_lvalue()ing was handled by ck_return() */
2288
2289     case OP_COREARGS:
2290         return o;
2291     }
2292
2293     /* [20011101.069] File test operators interpret OPf_REF to mean that
2294        their argument is a filehandle; thus \stat(".") should not set
2295        it. AMS 20011102 */
2296     if (type == OP_REFGEN &&
2297         PL_check[o->op_type] == Perl_ck_ftst)
2298         return o;
2299
2300     if (type != OP_LEAVESUBLV)
2301         o->op_flags |= OPf_MOD;
2302
2303     if (type == OP_AASSIGN || type == OP_SASSIGN)
2304         o->op_flags |= OPf_SPECIAL|OPf_REF;
2305     else if (!type) { /* local() */
2306         switch (localize) {
2307         case 1:
2308             o->op_private |= OPpLVAL_INTRO;
2309             o->op_flags &= ~OPf_SPECIAL;
2310             PL_hints |= HINT_BLOCK_SCOPE;
2311             break;
2312         case 0:
2313             break;
2314         case -1:
2315             Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
2316                            "Useless localization of %s", OP_DESC(o));
2317         }
2318     }
2319     else if (type != OP_GREPSTART && type != OP_ENTERSUB
2320              && type != OP_LEAVESUBLV)
2321         o->op_flags |= OPf_REF;
2322     return o;
2323 }
2324
2325 STATIC bool
2326 S_scalar_mod_type(const OP *o, I32 type)
2327 {
2328     switch (type) {
2329     case OP_POS:
2330     case OP_SASSIGN:
2331         if (o && o->op_type == OP_RV2GV)
2332             return FALSE;
2333         /* FALL THROUGH */
2334     case OP_PREINC:
2335     case OP_PREDEC:
2336     case OP_POSTINC:
2337     case OP_POSTDEC:
2338     case OP_I_PREINC:
2339     case OP_I_PREDEC:
2340     case OP_I_POSTINC:
2341     case OP_I_POSTDEC:
2342     case OP_POW:
2343     case OP_MULTIPLY:
2344     case OP_DIVIDE:
2345     case OP_MODULO:
2346     case OP_REPEAT:
2347     case OP_ADD:
2348     case OP_SUBTRACT:
2349     case OP_I_MULTIPLY:
2350     case OP_I_DIVIDE:
2351     case OP_I_MODULO:
2352     case OP_I_ADD:
2353     case OP_I_SUBTRACT:
2354     case OP_LEFT_SHIFT:
2355     case OP_RIGHT_SHIFT:
2356     case OP_BIT_AND:
2357     case OP_BIT_XOR:
2358     case OP_BIT_OR:
2359     case OP_CONCAT:
2360     case OP_SUBST:
2361     case OP_TRANS:
2362     case OP_TRANSR:
2363     case OP_READ:
2364     case OP_SYSREAD:
2365     case OP_RECV:
2366     case OP_ANDASSIGN:
2367     case OP_ORASSIGN:
2368     case OP_DORASSIGN:
2369         return TRUE;
2370     default:
2371         return FALSE;
2372     }
2373 }
2374
2375 STATIC bool
2376 S_is_handle_constructor(const OP *o, I32 numargs)
2377 {
2378     PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR;
2379
2380     switch (o->op_type) {
2381     case OP_PIPE_OP:
2382     case OP_SOCKPAIR:
2383         if (numargs == 2)
2384             return TRUE;
2385         /* FALL THROUGH */
2386     case OP_SYSOPEN:
2387     case OP_OPEN:
2388     case OP_SELECT:             /* XXX c.f. SelectSaver.pm */
2389     case OP_SOCKET:
2390     case OP_OPEN_DIR:
2391     case OP_ACCEPT:
2392         if (numargs == 1)
2393             return TRUE;
2394         /* FALLTHROUGH */
2395     default:
2396         return FALSE;
2397     }
2398 }
2399
2400 static OP *
2401 S_refkids(pTHX_ OP *o, I32 type)
2402 {
2403     if (o && o->op_flags & OPf_KIDS) {
2404         OP *kid;
2405         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2406             ref(kid, type);
2407     }
2408     return o;
2409 }
2410
2411 OP *
2412 Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
2413 {
2414     dVAR;
2415     OP *kid;
2416
2417     PERL_ARGS_ASSERT_DOREF;
2418
2419     if (!o || (PL_parser && PL_parser->error_count))
2420         return o;
2421
2422     switch (o->op_type) {
2423     case OP_ENTERSUB:
2424         if ((type == OP_EXISTS || type == OP_DEFINED) &&
2425             !(o->op_flags & OPf_STACKED)) {
2426             o->op_type = OP_RV2CV;             /* entersub => rv2cv */
2427             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
2428             assert(cUNOPo->op_first->op_type == OP_NULL);
2429             op_null(((LISTOP*)cUNOPo->op_first)->op_first);     /* disable pushmark */
2430             o->op_flags |= OPf_SPECIAL;
2431             o->op_private &= ~1;
2432         }
2433         else if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV){
2434             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2435                               : type == OP_RV2HV ? OPpDEREF_HV
2436                               : OPpDEREF_SV);
2437             o->op_flags |= OPf_MOD;
2438         }
2439
2440         break;
2441
2442     case OP_COND_EXPR:
2443         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
2444             doref(kid, type, set_op_ref);
2445         break;
2446     case OP_RV2SV:
2447         if (type == OP_DEFINED)
2448             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2449         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2450         /* FALL THROUGH */
2451     case OP_PADSV:
2452         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2453             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2454                               : type == OP_RV2HV ? OPpDEREF_HV
2455                               : OPpDEREF_SV);
2456             o->op_flags |= OPf_MOD;
2457         }
2458         break;
2459
2460     case OP_RV2AV:
2461     case OP_RV2HV:
2462         if (set_op_ref)
2463             o->op_flags |= OPf_REF;
2464         /* FALL THROUGH */
2465     case OP_RV2GV:
2466         if (type == OP_DEFINED)
2467             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2468         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2469         break;
2470
2471     case OP_PADAV:
2472     case OP_PADHV:
2473         if (set_op_ref)
2474             o->op_flags |= OPf_REF;
2475         break;
2476
2477     case OP_SCALAR:
2478     case OP_NULL:
2479         if (!(o->op_flags & OPf_KIDS) || type == OP_DEFINED)
2480             break;
2481         doref(cBINOPo->op_first, type, set_op_ref);
2482         break;
2483     case OP_AELEM:
2484     case OP_HELEM:
2485         doref(cBINOPo->op_first, o->op_type, set_op_ref);
2486         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2487             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2488                               : type == OP_RV2HV ? OPpDEREF_HV
2489                               : OPpDEREF_SV);
2490             o->op_flags |= OPf_MOD;
2491         }
2492         break;
2493
2494     case OP_SCOPE:
2495     case OP_LEAVE:
2496         set_op_ref = FALSE;
2497         /* FALL THROUGH */
2498     case OP_ENTER:
2499     case OP_LIST:
2500         if (!(o->op_flags & OPf_KIDS))
2501             break;
2502         doref(cLISTOPo->op_last, type, set_op_ref);
2503         break;
2504     default:
2505         break;
2506     }
2507     return scalar(o);
2508
2509 }
2510
2511 STATIC OP *
2512 S_dup_attrlist(pTHX_ OP *o)
2513 {
2514     dVAR;
2515     OP *rop;
2516
2517     PERL_ARGS_ASSERT_DUP_ATTRLIST;
2518
2519     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
2520      * where the first kid is OP_PUSHMARK and the remaining ones
2521      * are OP_CONST.  We need to push the OP_CONST values.
2522      */
2523     if (o->op_type == OP_CONST)
2524         rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc_NN(cSVOPo->op_sv));
2525 #ifdef PERL_MAD
2526     else if (o->op_type == OP_NULL)
2527         rop = NULL;
2528 #endif
2529     else {
2530         assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
2531         rop = NULL;
2532         for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
2533             if (o->op_type == OP_CONST)
2534                 rop = op_append_elem(OP_LIST, rop,
2535                                   newSVOP(OP_CONST, o->op_flags,
2536                                           SvREFCNT_inc_NN(cSVOPo->op_sv)));
2537         }
2538     }
2539     return rop;
2540 }
2541
2542 STATIC void
2543 S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
2544 {
2545     dVAR;
2546     SV * const stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2547
2548     PERL_ARGS_ASSERT_APPLY_ATTRS;
2549
2550     /* fake up C<use attributes $pkg,$rv,@attrs> */
2551     ENTER;              /* need to protect against side-effects of 'use' */
2552
2553 #define ATTRSMODULE "attributes"
2554 #define ATTRSMODULE_PM "attributes.pm"
2555
2556     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2557                          newSVpvs(ATTRSMODULE),
2558                          NULL,
2559                          op_prepend_elem(OP_LIST,
2560                                       newSVOP(OP_CONST, 0, stashsv),
2561                                       op_prepend_elem(OP_LIST,
2562                                                    newSVOP(OP_CONST, 0,
2563                                                            newRV(target)),
2564                                                    dup_attrlist(attrs))));
2565     LEAVE;
2566 }
2567
2568 STATIC void
2569 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
2570 {
2571     dVAR;
2572     OP *pack, *imop, *arg;
2573     SV *meth, *stashsv, **svp;
2574
2575     PERL_ARGS_ASSERT_APPLY_ATTRS_MY;
2576
2577     if (!attrs)
2578         return;
2579
2580     assert(target->op_type == OP_PADSV ||
2581            target->op_type == OP_PADHV ||
2582            target->op_type == OP_PADAV);
2583
2584     /* Ensure that attributes.pm is loaded. */
2585     ENTER;              /* need to protect against side-effects of 'use' */
2586     /* Don't force the C<use> if we don't need it. */
2587     svp = hv_fetchs(GvHVn(PL_incgv), ATTRSMODULE_PM, FALSE);
2588     if (svp && *svp != &PL_sv_undef)
2589         NOOP;   /* already in %INC */
2590     else
2591         Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
2592                                newSVpvs(ATTRSMODULE), NULL);
2593     LEAVE;
2594
2595     /* Need package name for method call. */
2596     pack = newSVOP(OP_CONST, 0, newSVpvs(ATTRSMODULE));
2597
2598     /* Build up the real arg-list. */
2599     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2600
2601     arg = newOP(OP_PADSV, 0);
2602     arg->op_targ = target->op_targ;
2603     arg = op_prepend_elem(OP_LIST,
2604                        newSVOP(OP_CONST, 0, stashsv),
2605                        op_prepend_elem(OP_LIST,
2606                                     newUNOP(OP_REFGEN, 0,
2607                                             op_lvalue(arg, OP_REFGEN)),
2608                                     dup_attrlist(attrs)));
2609
2610     /* Fake up a method call to import */
2611     meth = newSVpvs_share("import");
2612     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
2613                    op_append_elem(OP_LIST,
2614                                op_prepend_elem(OP_LIST, pack, list(arg)),
2615                                newSVOP(OP_METHOD_NAMED, 0, meth)));
2616
2617     /* Combine the ops. */
2618     *imopsp = op_append_elem(OP_LIST, *imopsp, imop);
2619 }
2620
2621 /*
2622 =notfor apidoc apply_attrs_string
2623
2624 Attempts to apply a list of attributes specified by the C<attrstr> and
2625 C<len> arguments to the subroutine identified by the C<cv> argument which
2626 is expected to be associated with the package identified by the C<stashpv>
2627 argument (see L<attributes>).  It gets this wrong, though, in that it
2628 does not correctly identify the boundaries of the individual attribute
2629 specifications within C<attrstr>.  This is not really intended for the
2630 public API, but has to be listed here for systems such as AIX which
2631 need an explicit export list for symbols.  (It's called from XS code
2632 in support of the C<ATTRS:> keyword from F<xsubpp>.)  Patches to fix it
2633 to respect attribute syntax properly would be welcome.
2634
2635 =cut
2636 */
2637
2638 void
2639 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
2640                         const char *attrstr, STRLEN len)
2641 {
2642     OP *attrs = NULL;
2643
2644     PERL_ARGS_ASSERT_APPLY_ATTRS_STRING;
2645
2646     if (!len) {
2647         len = strlen(attrstr);
2648     }
2649
2650     while (len) {
2651         for (; isSPACE(*attrstr) && len; --len, ++attrstr) ;
2652         if (len) {
2653             const char * const sstr = attrstr;
2654             for (; !isSPACE(*attrstr) && len; --len, ++attrstr) ;
2655             attrs = op_append_elem(OP_LIST, attrs,
2656                                 newSVOP(OP_CONST, 0,
2657                                         newSVpvn(sstr, attrstr-sstr)));
2658         }
2659     }
2660
2661     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2662                      newSVpvs(ATTRSMODULE),
2663                      NULL, op_prepend_elem(OP_LIST,
2664                                   newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
2665                                   op_prepend_elem(OP_LIST,
2666                                                newSVOP(OP_CONST, 0,
2667                                                        newRV(MUTABLE_SV(cv))),
2668                                                attrs)));
2669 }
2670
2671 STATIC void
2672 S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV * name)
2673 {
2674     OP *new_proto = NULL;
2675     STRLEN pvlen;
2676     char *pv;
2677     OP *o;
2678
2679     PERL_ARGS_ASSERT_MOVE_PROTO_ATTR;
2680
2681     if (!*attrs)
2682         return;
2683
2684     o = *attrs;
2685     if (o->op_type == OP_CONST) {
2686         pv = SvPV(cSVOPo_sv, pvlen);
2687         if (pvlen >= 10 && memEQ(pv, "prototype(", 10)) {
2688             SV * const tmpsv = newSVpvn_flags(pv + 10, pvlen - 11, SvUTF8(cSVOPo_sv));
2689             SV ** const tmpo = cSVOPx_svp(o);
2690             SvREFCNT_dec(cSVOPo_sv);
2691             *tmpo = tmpsv;
2692             new_proto = o;
2693             *attrs = NULL;
2694         }
2695     } else if (o->op_type == OP_LIST) {
2696         OP * lasto = NULL;
2697         assert(o->op_flags & OPf_KIDS);
2698         assert(cLISTOPo->op_first->op_type == OP_PUSHMARK);
2699         /* Counting on the first op to hit the lasto = o line */
2700         for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
2701             if (o->op_type == OP_CONST) {
2702                 pv = SvPV(cSVOPo_sv, pvlen);
2703                 if (pvlen >= 10 && memEQ(pv, "prototype(", 10)) {
2704                     SV * const tmpsv = newSVpvn_flags(pv + 10, pvlen - 11, SvUTF8(cSVOPo_sv));
2705                     SV ** const tmpo = cSVOPx_svp(o);
2706                     SvREFCNT_dec(cSVOPo_sv);
2707                     *tmpo = tmpsv;
2708                     if (new_proto && ckWARN(WARN_MISC)) {
2709                         STRLEN new_len;
2710                         const char * newp = SvPV(cSVOPo_sv, new_len);
2711                         Perl_warner(aTHX_ packWARN(WARN_MISC),
2712                             "Attribute prototype(%"UTF8f") discards earlier prototype attribute in same sub",
2713                             UTF8fARG(SvUTF8(cSVOPo_sv), new_len, newp));
2714                         op_free(new_proto);
2715                     }
2716                     else if (new_proto)
2717                         op_free(new_proto);
2718                     new_proto = o;
2719                     lasto->op_sibling = o->op_sibling;
2720                     continue;
2721                 }
2722             }
2723             lasto = o;
2724         }
2725         /* If the list is now just the PUSHMARK, scrap the whole thing; otherwise attributes.xs
2726            would get pulled in with no real need */
2727         if (!cLISTOPx(*attrs)->op_first->op_sibling) {
2728             op_free(*attrs);
2729             *attrs = NULL;
2730         }
2731     }
2732
2733     if (new_proto) {
2734         SV *svname;
2735         if (isGV(name)) {
2736             svname = sv_newmortal();
2737             gv_efullname3(svname, name, NULL);
2738         }
2739         else if (SvPOK(name) && *SvPVX((SV *)name) == '&')
2740             svname = newSVpvn_flags(SvPVX((SV *)name)+1, SvCUR(name)-1, SvUTF8(name)|SVs_TEMP);
2741         else
2742             svname = (SV *)name;
2743         if (ckWARN(WARN_ILLEGALPROTO))
2744             (void)validate_proto(svname, cSVOPx_sv(new_proto), TRUE);
2745         if (*proto && ckWARN(WARN_PROTOTYPE)) {
2746             STRLEN old_len, new_len;
2747             const char * oldp = SvPV(cSVOPx_sv(*proto), old_len);
2748             const char * newp = SvPV(cSVOPx_sv(new_proto), new_len);
2749
2750             Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
2751                 "Prototype '%"UTF8f"' overridden by attribute 'prototype(%"UTF8f")'"
2752                 " in %"SVf,
2753                 UTF8fARG(SvUTF8(cSVOPx_sv(*proto)), old_len, oldp),
2754                 UTF8fARG(SvUTF8(cSVOPx_sv(new_proto)), new_len, newp),
2755                 SVfARG(svname));
2756         }
2757         if (*proto)
2758             op_free(*proto);
2759         *proto = new_proto;
2760     }
2761 }
2762
2763 STATIC OP *
2764 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
2765 {
2766     dVAR;
2767     I32 type;
2768     const bool stately = PL_parser && PL_parser->in_my == KEY_state;
2769
2770     PERL_ARGS_ASSERT_MY_KID;
2771
2772     if (!o || (PL_parser && PL_parser->error_count))
2773         return o;
2774
2775     type = o->op_type;
2776     if (PL_madskills && type == OP_NULL && o->op_flags & OPf_KIDS) {
2777         (void)my_kid(cUNOPo->op_first, attrs, imopsp);
2778         return o;
2779     }
2780
2781     if (type == OP_LIST) {
2782         OP *kid;
2783         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2784             my_kid(kid, attrs, imopsp);
2785         return o;
2786     } else if (type == OP_UNDEF || type == OP_STUB) {
2787         return o;
2788     } else if (type == OP_RV2SV ||      /* "our" declaration */
2789                type == OP_RV2AV ||
2790                type == OP_RV2HV) { /* XXX does this let anything illegal in? */
2791         if (cUNOPo->op_first->op_type != OP_GV) { /* MJD 20011224 */
2792             yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2793                         OP_DESC(o),
2794                         PL_parser->in_my == KEY_our
2795                             ? "our"
2796                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2797         } else if (attrs) {
2798             GV * const gv = cGVOPx_gv(cUNOPo->op_first);
2799             PL_parser->in_my = FALSE;
2800             PL_parser->in_my_stash = NULL;
2801             apply_attrs(GvSTASH(gv),
2802                         (type == OP_RV2SV ? GvSV(gv) :
2803                          type == OP_RV2AV ? MUTABLE_SV(GvAV(gv)) :
2804                          type == OP_RV2HV ? MUTABLE_SV(GvHV(gv)) : MUTABLE_SV(gv)),
2805                         attrs);
2806         }
2807         o->op_private |= OPpOUR_INTRO;
2808         return o;
2809     }
2810     else if (type != OP_PADSV &&
2811              type != OP_PADAV &&
2812              type != OP_PADHV &&
2813              type != OP_PUSHMARK)
2814     {
2815         yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2816                           OP_DESC(o),
2817                           PL_parser->in_my == KEY_our
2818                             ? "our"
2819                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2820         return o;
2821     }
2822     else if (attrs && type != OP_PUSHMARK) {
2823         HV *stash;
2824
2825         PL_parser->in_my = FALSE;
2826         PL_parser->in_my_stash = NULL;
2827
2828         /* check for C<my Dog $spot> when deciding package */
2829         stash = PAD_COMPNAME_TYPE(o->op_targ);
2830         if (!stash)
2831             stash = PL_curstash;
2832         apply_attrs_my(stash, o, attrs, imopsp);
2833     }
2834     o->op_flags |= OPf_MOD;
2835     o->op_private |= OPpLVAL_INTRO;
2836     if (stately)
2837         o->op_private |= OPpPAD_STATE;
2838     return o;
2839 }
2840
2841 OP *
2842 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
2843 {
2844     dVAR;
2845     OP *rops;
2846     int maybe_scalar = 0;
2847
2848     PERL_ARGS_ASSERT_MY_ATTRS;
2849
2850 /* [perl #17376]: this appears to be premature, and results in code such as
2851    C< our(%x); > executing in list mode rather than void mode */
2852 #if 0
2853     if (o->op_flags & OPf_PARENS)
2854         list(o);
2855     else
2856         maybe_scalar = 1;
2857 #else
2858     maybe_scalar = 1;
2859 #endif
2860     if (attrs)
2861         SAVEFREEOP(attrs);
2862     rops = NULL;
2863     o = my_kid(o, attrs, &rops);
2864     if (rops) {
2865         if (maybe_scalar && o->op_type == OP_PADSV) {
2866             o = scalar(op_append_list(OP_LIST, rops, o));
2867             o->op_private |= OPpLVAL_INTRO;
2868         }
2869         else {
2870             /* The listop in rops might have a pushmark at the beginning,
2871                which will mess up list assignment. */
2872             LISTOP * const lrops = (LISTOP *)rops; /* for brevity */
2873             if (rops->op_type == OP_LIST && 
2874                 lrops->op_first && lrops->op_first->op_type == OP_PUSHMARK)
2875             {
2876                 OP * const pushmark = lrops->op_first;
2877                 lrops->op_first = pushmark->op_sibling;
2878                 op_free(pushmark);
2879             }
2880             o = op_append_list(OP_LIST, o, rops);
2881         }
2882     }
2883     PL_parser->in_my = FALSE;
2884     PL_parser->in_my_stash = NULL;
2885     return o;
2886 }
2887
2888 OP *
2889 Perl_sawparens(pTHX_ OP *o)
2890 {
2891     PERL_UNUSED_CONTEXT;
2892     if (o)
2893         o->op_flags |= OPf_PARENS;
2894     return o;
2895 }
2896
2897 OP *
2898 Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
2899 {
2900     OP *o;
2901     bool ismatchop = 0;
2902     const OPCODE ltype = left->op_type;
2903     const OPCODE rtype = right->op_type;
2904
2905     PERL_ARGS_ASSERT_BIND_MATCH;
2906
2907     if ( (ltype == OP_RV2AV || ltype == OP_RV2HV || ltype == OP_PADAV
2908           || ltype == OP_PADHV) && ckWARN(WARN_MISC))
2909     {
2910       const char * const desc
2911           = PL_op_desc[(
2912                           rtype == OP_SUBST || rtype == OP_TRANS
2913                        || rtype == OP_TRANSR
2914                        )
2915                        ? (int)rtype : OP_MATCH];
2916       const bool isary = ltype == OP_RV2AV || ltype == OP_PADAV;
2917       SV * const name =
2918         S_op_varname(aTHX_ left);
2919       if (name)
2920         Perl_warner(aTHX_ packWARN(WARN_MISC),
2921              "Applying %s to %"SVf" will act on scalar(%"SVf")",
2922              desc, name, name);
2923       else {
2924         const char * const sample = (isary
2925              ? "@array" : "%hash");
2926         Perl_warner(aTHX_ packWARN(WARN_MISC),
2927              "Applying %s to %s will act on scalar(%s)",
2928              desc, sample, sample);
2929       }
2930     }
2931
2932     if (rtype == OP_CONST &&
2933         cSVOPx(right)->op_private & OPpCONST_BARE &&
2934         cSVOPx(right)->op_private & OPpCONST_STRICT)
2935     {
2936         no_bareword_allowed(right);
2937     }
2938
2939     /* !~ doesn't make sense with /r, so error on it for now */
2940     if (rtype == OP_SUBST && (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT) &&
2941         type == OP_NOT)
2942         yyerror("Using !~ with s///r doesn't make sense");
2943     if (rtype == OP_TRANSR && type == OP_NOT)
2944         yyerror("Using !~ with tr///r doesn't make sense");
2945
2946     ismatchop = (rtype == OP_MATCH ||
2947                  rtype == OP_SUBST ||
2948                  rtype == OP_TRANS || rtype == OP_TRANSR)
2949              && !(right->op_flags & OPf_SPECIAL);
2950     if (ismatchop && right->op_private & OPpTARGET_MY) {
2951         right->op_targ = 0;
2952         right->op_private &= ~OPpTARGET_MY;
2953     }
2954     if (!(right->op_flags & OPf_STACKED) && ismatchop) {
2955         OP *newleft;
2956
2957         right->op_flags |= OPf_STACKED;
2958         if (rtype != OP_MATCH && rtype != OP_TRANSR &&
2959             ! (rtype == OP_TRANS &&
2960                right->op_private & OPpTRANS_IDENTICAL) &&
2961             ! (rtype == OP_SUBST &&
2962                (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT)))
2963             newleft = op_lvalue(left, rtype);
2964         else
2965             newleft = left;
2966         if (right->op_type == OP_TRANS || right->op_type == OP_TRANSR)
2967             o = newBINOP(OP_NULL, OPf_STACKED, scalar(newleft), right);
2968         else
2969             o = op_prepend_elem(rtype, scalar(newleft), right);
2970         if (type == OP_NOT)
2971             return newUNOP(OP_NOT, 0, scalar(o));
2972         return o;
2973     }
2974     else
2975         return bind_match(type, left,
2976                 pmruntime(newPMOP(OP_MATCH, 0), right, 0, 0));
2977 }
2978
2979 OP *
2980 Perl_invert(pTHX_ OP *o)
2981 {
2982     if (!o)
2983         return NULL;
2984     return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
2985 }
2986
2987 /*
2988 =for apidoc Amx|OP *|op_scope|OP *o
2989
2990 Wraps up an op tree with some additional ops so that at runtime a dynamic
2991 scope will be created.  The original ops run in the new dynamic scope,
2992 and then, provided that they exit normally, the scope will be unwound.
2993 The additional ops used to create and unwind the dynamic scope will
2994 normally be an C<enter>/C<leave> pair, but a C<scope> op may be used
2995 instead if the ops are simple enough to not need the full dynamic scope
2996 structure.
2997
2998 =cut
2999 */
3000
3001 OP *
3002 Perl_op_scope(pTHX_ OP *o)
3003 {
3004     dVAR;
3005     if (o) {
3006         if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || TAINTING_get) {
3007             o = op_prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
3008             o->op_type = OP_LEAVE;
3009             o->op_ppaddr = PL_ppaddr[OP_LEAVE];
3010         }
3011         else if (o->op_type == OP_LINESEQ) {
3012             OP *kid;
3013             o->op_type = OP_SCOPE;
3014             o->op_ppaddr = PL_ppaddr[OP_SCOPE];
3015             kid = ((LISTOP*)o)->op_first;
3016             if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) {
3017                 op_null(kid);
3018
3019                 /* The following deals with things like 'do {1 for 1}' */
3020                 kid = kid->op_sibling;
3021                 if (kid &&
3022                     (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE))
3023                     op_null(kid);
3024             }
3025         }
3026         else
3027             o = newLISTOP(OP_SCOPE, 0, o, NULL);
3028     }
3029     return o;
3030 }
3031
3032 OP *
3033 Perl_op_unscope(pTHX_ OP *o)
3034 {
3035     if (o && o->op_type == OP_LINESEQ) {
3036         OP *kid = cLISTOPo->op_first;
3037         for(; kid; kid = kid->op_sibling)
3038             if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE)
3039                 op_null(kid);
3040     }
3041     return o;
3042 }
3043
3044 int
3045 Perl_block_start(pTHX_ int full)
3046 {
3047     dVAR;
3048     const int retval = PL_savestack_ix;
3049
3050     pad_block_start(full);
3051     SAVEHINTS();
3052     PL_hints &= ~HINT_BLOCK_SCOPE;
3053     SAVECOMPILEWARNINGS();
3054     PL_compiling.cop_warnings = DUP_WARNINGS(PL_compiling.cop_warnings);
3055
3056     CALL_BLOCK_HOOKS(bhk_start, full);
3057
3058     return retval;
3059 }
3060
3061 OP*
3062 Perl_block_end(pTHX_ I32 floor, OP *seq)
3063 {
3064     dVAR;
3065     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
3066     OP* retval = scalarseq(seq);
3067     OP *o;
3068
3069     CALL_BLOCK_HOOKS(bhk_pre_end, &retval);
3070
3071     LEAVE_SCOPE(floor);
3072     if (needblockscope)
3073         PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
3074     o = pad_leavemy();
3075
3076     if (o) {
3077         /* pad_leavemy has created a sequence of introcv ops for all my
3078            subs declared in the block.  We have to replicate that list with
3079            clonecv ops, to deal with this situation:
3080
3081                sub {
3082                    my sub s1;
3083                    my sub s2;
3084                    sub s1 { state sub foo { \&s2 } }
3085                }->()
3086
3087            Originally, I was going to have introcv clone the CV and turn
3088            off the stale flag.  Since &s1 is declared before &s2, the
3089            introcv op for &s1 is executed (on sub entry) before the one for
3090            &s2.  But the &foo sub inside &s1 (which is cloned when &s1 is
3091            cloned, since it is a state sub) closes over &s2 and expects
3092            to see it in its outer CV’s pad.  If the introcv op clones &s1,
3093            then &s2 is still marked stale.  Since &s1 is not active, and
3094            &foo closes over &s1’s implicit entry for &s2, we get a ‘Varia-
3095            ble will not stay shared’ warning.  Because it is the same stub
3096            that will be used when the introcv op for &s2 is executed, clos-
3097            ing over it is safe.  Hence, we have to turn off the stale flag
3098            on all lexical subs in the block before we clone any of them.
3099            Hence, having introcv clone the sub cannot work.  So we create a
3100            list of ops like this:
3101
3102                lineseq
3103                   |
3104                   +-- introcv
3105                   |
3106                   +-- introcv
3107                   |
3108                   +-- introcv
3109                   |
3110                   .
3111                   .
3112                   .
3113                   |
3114                   +-- clonecv
3115                   |
3116                   +-- clonecv
3117                   |
3118                   +-- clonecv
3119                   |
3120                   .
3121                   .
3122                   .
3123          */
3124         OP *kid = o->op_flags & OPf_KIDS ? cLISTOPo->op_first : o;
3125         OP * const last = o->op_flags & OPf_KIDS ? cLISTOPo->op_last : o;
3126         for (;; kid = kid->op_sibling) {
3127             OP *newkid = newOP(OP_CLONECV, 0);
3128             newkid->op_targ = kid->op_targ;
3129             o = op_append_elem(OP_LINESEQ, o, newkid);
3130             if (kid == last) break;
3131         }
3132         retval = op_prepend_elem(OP_LINESEQ, o, retval);
3133     }
3134
3135     CALL_BLOCK_HOOKS(bhk_post_end, &retval);
3136
3137     return retval;
3138 }
3139
3140 /*
3141 =head1 Compile-time scope hooks
3142
3143 =for apidoc Aox||blockhook_register
3144
3145 Register a set of hooks to be called when the Perl lexical scope changes
3146 at compile time. See L<perlguts/"Compile-time scope hooks">.
3147
3148 =cut
3149 */
3150
3151 void
3152 Perl_blockhook_register(pTHX_ BHK *hk)
3153 {
3154     PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER;
3155
3156     Perl_av_create_and_push(aTHX_ &PL_blockhooks, newSViv(PTR2IV(hk)));
3157 }
3158
3159 STATIC OP *
3160 S_newDEFSVOP(pTHX)
3161 {
3162     dVAR;
3163     const PADOFFSET offset = pad_findmy_pvs("$_", 0);
3164     if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
3165         return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
3166     }
3167     else {
3168         OP * const o = newOP(OP_PADSV, 0);
3169         o->op_targ = offset;
3170         return o;
3171     }
3172 }
3173
3174 void
3175 Perl_newPROG(pTHX_ OP *o)
3176 {
3177     dVAR;
3178
3179     PERL_ARGS_ASSERT_NEWPROG;
3180
3181     if (PL_in_eval) {
3182         PERL_CONTEXT *cx;
3183         I32 i;
3184         if (PL_eval_root)
3185                 return;
3186         PL_eval_root = newUNOP(OP_LEAVEEVAL,
3187                                ((PL_in_eval & EVAL_KEEPERR)
3188                                 ? OPf_SPECIAL : 0), o);
3189
3190         cx = &cxstack[cxstack_ix];
3191         assert(CxTYPE(cx) == CXt_EVAL);
3192
3193         if ((cx->blk_gimme & G_WANT) == G_VOID)
3194             scalarvoid(PL_eval_root);
3195         else if ((cx->blk_gimme & G_WANT) == G_ARRAY)
3196             list(PL_eval_root);
3197         else
3198             scalar(PL_eval_root);
3199
3200         PL_eval_start = op_linklist(PL_eval_root);
3201         PL_eval_root->op_private |= OPpREFCOUNTED;
3202         OpREFCNT_set(PL_eval_root, 1);
3203         PL_eval_root->op_next = 0;
3204         i = PL_savestack_ix;
3205         SAVEFREEOP(o);
3206         ENTER;
3207         CALL_PEEP(PL_eval_start);
3208         finalize_optree(PL_eval_root);
3209         LEAVE;
3210         PL_savestack_ix = i;
3211     }
3212     else {
3213         if (o->op_type == OP_STUB) {
3214             /* This block is entered if nothing is compiled for the main
3215                program. This will be the case for an genuinely empty main
3216                program, or one which only has BEGIN blocks etc, so already
3217                run and freed.
3218
3219                Historically (5.000) the guard above was !o. However, commit
3220                f8a08f7b8bd67b28 (Jun 2001), integrated to blead as
3221                c71fccf11fde0068, changed perly.y so that newPROG() is now
3222                called with the output of block_end(), which returns a new
3223                OP_STUB for the case of an empty optree. ByteLoader (and
3224                maybe other things) also take this path, because they set up
3225                PL_main_start and PL_main_root directly, without generating an
3226                optree.
3227
3228                If the parsing the main program aborts (due to parse errors,
3229                or due to BEGIN or similar calling exit), then newPROG()
3230                isn't even called, and hence this code path and its cleanups
3231                are skipped. This shouldn't make a make a difference:
3232                * a non-zero return from perl_parse is a failure, and
3233                  perl_destruct() should be called immediately.
3234                * however, if exit(0) is called during the parse, then
3235                  perl_parse() returns 0, and perl_run() is called. As
3236                  PL_main_start will be NULL, perl_run() will return
3237                  promptly, and the exit code will remain 0.
3238             */
3239
3240             PL_comppad_name = 0;
3241             PL_compcv = 0;
3242             S_op_destroy(aTHX_ o);
3243             return;
3244         }
3245         PL_main_root = op_scope(sawparens(scalarvoid(o)));
3246         PL_curcop = &PL_compiling;
3247         PL_main_start = LINKLIST(PL_main_root);
3248         PL_main_root->op_private |= OPpREFCOUNTED;
3249         OpREFCNT_set(PL_main_root, 1);
3250         PL_main_root->op_next = 0;
3251         CALL_PEEP(PL_main_start);
3252         finalize_optree(PL_main_root);
3253         cv_forget_slab(PL_compcv);
3254         PL_compcv = 0;
3255
3256         /* Register with debugger */
3257         if (PERLDB_INTER) {
3258             CV * const cv = get_cvs("DB::postponed", 0);
3259             if (cv) {
3260                 dSP;
3261                 PUSHMARK(SP);
3262                 XPUSHs(MUTABLE_SV(CopFILEGV(&PL_compiling)));
3263                 PUTBACK;
3264                 call_sv(MUTABLE_SV(cv), G_DISCARD);
3265             }
3266         }
3267     }
3268 }
3269
3270 OP *
3271 Perl_localize(pTHX_ OP *o, I32 lex)
3272 {
3273     dVAR;
3274
3275     PERL_ARGS_ASSERT_LOCALIZE;
3276
3277     if (o->op_flags & OPf_PARENS)
3278 /* [perl #17376]: this appears to be premature, and results in code such as
3279    C< our(%x); > executing in list mode rather than void mode */
3280 #if 0
3281         list(o);
3282 #else
3283         NOOP;
3284 #endif
3285     else {
3286         if ( PL_parser->bufptr > PL_parser->oldbufptr
3287             && PL_parser->bufptr[-1] == ','
3288             && ckWARN(WARN_PARENTHESIS))
3289         {
3290             char *s = PL_parser->bufptr;
3291             bool sigil = FALSE;
3292
3293             /* some heuristics to detect a potential error */
3294             while (*s && (strchr(", \t\n", *s)))
3295                 s++;
3296
3297             while (1) {
3298                 if (*s && strchr("@$%*", *s) && *++s
3299                        && (isWORDCHAR(*s) || UTF8_IS_CONTINUED(*s))) {
3300                     s++;
3301                     sigil = TRUE;
3302                     while (*s && (isWORDCHAR(*s) || UTF8_IS_CONTINUED(*s)))
3303                         s++;
3304                     while (*s && (strchr(", \t\n", *s)))
3305                         s++;
3306                 }
3307                 else
3308                     break;
3309             }
3310             if (sigil && (*s == ';' || *s == '=')) {
3311                 Perl_warner(aTHX_ packWARN(WARN_PARENTHESIS),
3312                                 "Parentheses missing around \"%s\" list",
3313                                 lex
3314                                     ? (PL_parser->in_my == KEY_our
3315                                         ? "our"
3316                                         : PL_parser->in_my == KEY_state
3317                                             ? "state"
3318                                             : "my")
3319                                     : "local");
3320             }
3321         }
3322     }
3323     if (lex)
3324         o = my(o);
3325     else
3326         o = op_lvalue(o, OP_NULL);              /* a bit kludgey */
3327     PL_parser->in_my = FALSE;
3328     PL_parser->in_my_stash = NULL;
3329     return o;
3330 }
3331
3332 OP *
3333 Perl_jmaybe(pTHX_ OP *o)
3334 {
3335     PERL_ARGS_ASSERT_JMAYBE;
3336
3337     if (o->op_type == OP_LIST) {
3338         OP * const o2
3339             = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL, SVt_PV)));
3340         o = convert(OP_JOIN, 0, op_prepend_elem(OP_LIST, o2, o));
3341     }
3342     return o;
3343 }
3344
3345 PERL_STATIC_INLINE OP *
3346 S_op_std_init(pTHX_ OP *o)
3347 {
3348     I32 type = o->op_type;
3349
3350     PERL_ARGS_ASSERT_OP_STD_INIT;
3351
3352     if (PL_opargs[type] & OA_RETSCALAR)
3353         scalar(o);
3354     if (PL_opargs[type] & OA_TARGET && !o->op_targ)
3355         o->op_targ = pad_alloc(type, SVs_PADTMP);
3356
3357     return o;
3358 }
3359
3360 PERL_STATIC_INLINE OP *
3361 S_op_integerize(pTHX_ OP *o)
3362 {
3363     I32 type = o->op_type;
3364
3365     PERL_ARGS_ASSERT_OP_INTEGERIZE;
3366
3367     /* integerize op. */
3368     if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER))
3369     {
3370         dVAR;
3371         o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
3372     }
3373
3374     if (type == OP_NEGATE)
3375         /* XXX might want a ck_negate() for this */
3376         cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
3377
3378     return o;
3379 }
3380
3381 static OP *
3382 S_fold_constants(pTHX_ OP *o)
3383 {
3384     dVAR;
3385     OP * VOL curop;
3386     OP *newop;
3387     VOL I32 type = o->op_type;
3388     SV * VOL sv = NULL;
3389     int ret = 0;
3390     I32 oldscope;
3391     OP *old_next;
3392     SV * const oldwarnhook = PL_warnhook;
3393     SV * const olddiehook  = PL_diehook;
3394     COP not_compiling;
3395     dJMPENV;
3396
3397     PERL_ARGS_ASSERT_FOLD_CONSTANTS;
3398
3399     if (!(PL_opargs[type] & OA_FOLDCONST))
3400         goto nope;
3401
3402     switch (type) {
3403     case OP_UCFIRST:
3404     case OP_LCFIRST:
3405     case OP_UC:
3406     case OP_LC:
3407     case OP_FC:
3408     case OP_SLT:
3409     case OP_SGT:
3410     case OP_SLE:
3411     case OP_SGE:
3412     case OP_SCMP:
3413     case OP_SPRINTF:
3414         /* XXX what about the numeric ops? */
3415         if (IN_LOCALE_COMPILETIME)
3416             goto nope;
3417         break;
3418     case OP_PACK:
3419         if (!cLISTOPo->op_first->op_sibling
3420           || cLISTOPo->op_first->op_sibling->op_type != OP_CONST)
3421             goto nope;
3422         {
3423             SV * const sv = cSVOPx_sv(cLISTOPo->op_first->op_sibling);
3424             if (!SvPOK(sv) || SvGMAGICAL(sv)) goto nope;
3425             {
3426                 const char *s = SvPVX_const(sv);
3427                 while (s < SvEND(sv)) {
3428                     if (*s == 'p' || *s == 'P') goto nope;
3429                     s++;
3430                 }
3431             }
3432         }
3433         break;
3434     case OP_REPEAT:
3435         if (o->op_private & OPpREPEAT_DOLIST) goto nope;
3436         break;
3437     case OP_SREFGEN:
3438         if (cUNOPx(cUNOPo->op_first)->op_first->op_type != OP_CONST
3439          || SvPADTMP(cSVOPx_sv(cUNOPx(cUNOPo->op_first)->op_first)))
3440             goto nope;
3441     }
3442
3443     if (PL_parser && PL_parser->error_count)
3444         goto nope;              /* Don't try to run w/ errors */
3445
3446     for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
3447         const OPCODE type = curop->op_type;
3448         if ((type != OP_CONST || (curop->op_private & OPpCONST_BARE)) &&
3449             type != OP_LIST &&
3450             type != OP_SCALAR &&
3451             type != OP_NULL &&
3452             type != OP_PUSHMARK)
3453         {
3454             goto nope;
3455         }
3456     }
3457
3458     curop = LINKLIST(o);
3459     old_next = o->op_next;
3460     o->op_next = 0;
3461     PL_op = curop;
3462
3463     oldscope = PL_scopestack_ix;
3464     create_eval_scope(G_FAKINGEVAL);
3465
3466     /* Verify that we don't need to save it:  */
3467     assert(PL_curcop == &PL_compiling);
3468     StructCopy(&PL_compiling, &not_compiling, COP);
3469     PL_curcop = &not_compiling;
3470     /* The above ensures that we run with all the correct hints of the
3471        currently compiling COP, but that IN_PERL_RUNTIME is not true. */
3472     assert(IN_PERL_RUNTIME);
3473     PL_warnhook = PERL_WARNHOOK_FATAL;
3474     PL_diehook  = NULL;
3475     JMPENV_PUSH(ret);
3476
3477     switch (ret) {
3478     case 0:
3479         CALLRUNOPS(aTHX);
3480         sv = *(PL_stack_sp--);
3481         if (o->op_targ && sv == PAD_SV(o->op_targ)) {   /* grab pad temp? */
3482 #ifdef PERL_MAD
3483             /* Can't simply swipe the SV from the pad, because that relies on
3484                the op being freed "real soon now". Under MAD, this doesn't
3485                happen (see the #ifdef below).  */
3486             sv = newSVsv(sv);
3487 #else
3488             pad_swipe(o->op_targ,  FALSE);
3489 #endif
3490         }
3491         else if (SvTEMP(sv)) {                  /* grab mortal temp? */
3492             SvREFCNT_inc_simple_void(sv);
3493             SvTEMP_off(sv);
3494         }
3495         else { assert(SvIMMORTAL(sv)); }
3496         break;
3497     case 3:
3498         /* Something tried to die.  Abandon constant folding.  */
3499         /* Pretend the error never happened.  */
3500         CLEAR_ERRSV();
3501         o->op_next = old_next;
3502         break;
3503     default:
3504         JMPENV_POP;
3505         /* Don't expect 1 (setjmp failed) or 2 (something called my_exit)  */
3506         PL_warnhook = oldwarnhook;
3507         PL_diehook  = olddiehook;
3508         /* XXX note that this croak may fail as we've already blown away
3509          * the stack - eg any nested evals */
3510         Perl_croak(aTHX_ "panic: fold_constants JMPENV_PUSH returned %d", ret);
3511     }
3512     JMPENV_POP;
3513     PL_warnhook = oldwarnhook;
3514     PL_diehook  = olddiehook;
3515     PL_curcop = &PL_compiling;
3516
3517     if (PL_scopestack_ix > oldscope)
3518         delete_eval_scope();
3519
3520     if (ret)
3521         goto nope;
3522
3523 #ifndef PERL_MAD
3524     op_free(o);
3525 #endif
3526     assert(sv);
3527     if (type == OP_STRINGIFY) SvPADTMP_off(sv);
3528     else if (!SvIMMORTAL(sv)) SvPADTMP_on(sv);
3529     if (type == OP_RV2GV)
3530         newop = newGVOP(OP_GV, 0, MUTABLE_GV(sv));
3531     else
3532     {
3533         newop = newSVOP(OP_CONST, 0, MUTABLE_SV(sv));
3534         if (type != OP_STRINGIFY) newop->op_folded = 1;
3535     }
3536     op_getmad(o,newop,'f');
3537     return newop;
3538
3539  nope:
3540     return o;
3541 }
3542
3543 static OP *
3544 S_gen_constant_list(pTHX_ OP *o)
3545 {
3546     dVAR;
3547     OP *curop;
3548     const SSize_t oldtmps_floor = PL_tmps_floor;
3549     SV **svp;
3550     AV *av;
3551
3552     list(o);
3553     if (PL_parser && PL_parser->error_count)
3554         return o;               /* Don't attempt to run with errors */
3555
3556     PL_op = curop = LINKLIST(o);
3557     o->op_next = 0;
3558     CALL_PEEP(curop);
3559     Perl_pp_pushmark(aTHX);
3560     CALLRUNOPS(aTHX);
3561     PL_op = curop;
3562     assert (!(curop->op_flags & OPf_SPECIAL));
3563     assert(curop->op_type == OP_RANGE);
3564     Perl_pp_anonlist(aTHX);
3565     PL_tmps_floor = oldtmps_floor;
3566
3567     o->op_type = OP_RV2AV;
3568     o->op_ppaddr = PL_ppaddr[OP_RV2AV];
3569     o->op_flags &= ~OPf_REF;    /* treat \(1..2) like an ordinary list */
3570     o->op_flags |= OPf_PARENS;  /* and flatten \(1..2,3) */
3571     o->op_opt = 0;              /* needs to be revisited in rpeep() */
3572     curop = ((UNOP*)o)->op_first;
3573     av = (AV *)SvREFCNT_inc_NN(*PL_stack_sp--);
3574     ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, (SV *)av);
3575     if (AvFILLp(av) != -1)
3576         for (svp = AvARRAY(av) + AvFILLp(av); svp >= AvARRAY(av); --svp)
3577             SvPADTMP_on(*svp);
3578 #ifdef PERL_MAD
3579     op_getmad(curop,o,'O');
3580 #else
3581     op_free(curop);
3582 #endif
3583     LINKLIST(o);
3584     return list(o);
3585 }
3586
3587 OP *
3588 Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
3589 {
3590     dVAR;
3591     if (type < 0) type = -type, flags |= OPf_SPECIAL;
3592     if (!o || o->op_type != OP_LIST)
3593         o = newLISTOP(OP_LIST, 0, o, NULL);
3594     else
3595         o->op_flags &= ~OPf_WANT;
3596
3597     if (!(PL_opargs[type] & OA_MARK))
3598         op_null(cLISTOPo->op_first);
3599     else {
3600         OP * const kid2 = cLISTOPo->op_first->op_sibling;
3601         if (kid2 && kid2->op_type == OP_COREARGS) {
3602             op_null(cLISTOPo->op_first);
3603             kid2->op_private |= OPpCOREARGS_PUSHMARK;
3604         }
3605     }   
3606
3607     o->op_type = (OPCODE)type;
3608     o->op_ppaddr = PL_ppaddr[type];
3609     o->op_flags |= flags;
3610
3611     o = CHECKOP(type, o);
3612     if (o->op_type != (unsigned)type)
3613         return o;
3614
3615     return fold_constants(op_integerize(op_std_init(o)));
3616 }
3617
3618 /*
3619 =head1 Optree Manipulation Functions
3620 */
3621
3622 /* List constructors */
3623
3624 /*
3625 =for apidoc Am|OP *|op_append_elem|I32 optype|OP *first|OP *last
3626
3627 Append an item to the list of ops contained directly within a list-type
3628 op, returning the lengthened list.  I<first> is the list-type op,
3629 and I<last> is the op to append to the list.  I<optype> specifies the
3630 intended opcode for the list.  If I<first> is not already a list of the
3631 right type, it will be upgraded into one.  If either I<first> or I<last>
3632 is null, the other is returned unchanged.
3633
3634 =cut
3635 */
3636
3637 OP *
3638 Perl_op_append_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 (first->op_type != (unsigned)type
3647         || (type == OP_LIST && (first->op_flags & OPf_PARENS)))
3648     {
3649         return newLISTOP(type, 0, first, last);
3650     }
3651
3652     if (first->op_flags & OPf_KIDS)
3653         ((LISTOP*)first)->op_last->op_sibling = last;
3654     else {
3655         first->op_flags |= OPf_KIDS;
3656         ((LISTOP*)first)->op_first = last;
3657     }
3658     ((LISTOP*)first)->op_last = last;
3659     return first;
3660 }
3661
3662 /*
3663 =for apidoc Am|OP *|op_append_list|I32 optype|OP *first|OP *last
3664
3665 Concatenate the lists of ops contained directly within two list-type ops,
3666 returning the combined list.  I<first> and I<last> are the list-type ops
3667 to concatenate.  I<optype> specifies the intended opcode for the list.
3668 If either I<first> or I<last> is not already a list of the right type,
3669 it will be upgraded into one.  If either I<first> or I<last> is null,
3670 the other is returned unchanged.
3671
3672 =cut
3673 */
3674
3675 OP *
3676 Perl_op_append_list(pTHX_ I32 type, OP *first, OP *last)
3677 {
3678     if (!first)
3679         return last;
3680
3681     if (!last)
3682         return first;
3683
3684     if (first->op_type != (unsigned)type)
3685         return op_prepend_elem(type, first, last);
3686
3687     if (last->op_type != (unsigned)type)
3688         return op_append_elem(type, first, last);
3689
3690     ((LISTOP*)first)->op_last->op_sibling = ((LISTOP*)last)->op_first;
3691     ((LISTOP*)first)->op_last = ((LISTOP*)last)->op_last;
3692     first->op_flags |= (last->op_flags & OPf_KIDS);
3693
3694 #ifdef PERL_MAD
3695     if (((LISTOP*)last)->op_first && first->op_madprop) {
3696         MADPROP *mp = ((LISTOP*)last)->op_first->op_madprop;
3697         if (mp) {
3698             while (mp->mad_next)
3699                 mp = mp->mad_next;
3700             mp->mad_next = first->op_madprop;
3701         }
3702         else {
3703             ((LISTOP*)last)->op_first->op_madprop = first->op_madprop;
3704         }
3705     }
3706     first->op_madprop = last->op_madprop;
3707     last->op_madprop = 0;
3708 #endif
3709
3710     S_op_destroy(aTHX_ last);
3711
3712     return first;
3713 }
3714
3715 /*
3716 =for apidoc Am|OP *|op_prepend_elem|I32 optype|OP *first|OP *last
3717
3718 Prepend an item to the list of ops contained directly within a list-type
3719 op, returning the lengthened list.  I<first> is the op to prepend to the
3720 list, and I<last> is the list-type op.  I<optype> specifies the intended
3721 opcode for the list.  If I<last> is not already a list of the right type,
3722 it will be upgraded into one.  If either I<first> or I<last> is null,
3723 the other is returned unchanged.
3724
3725 =cut
3726 */
3727
3728 OP *
3729 Perl_op_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
3730 {
3731     if (!first)
3732         return last;
3733
3734     if (!last)
3735         return first;
3736
3737     if (last->op_type == (unsigned)type) {
3738         if (type == OP_LIST) {  /* already a PUSHMARK there */
3739             first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
3740             ((LISTOP*)last)->op_first->op_sibling = first;
3741             if (!(first->op_flags & OPf_PARENS))
3742                 last->op_flags &= ~OPf_PARENS;
3743         }
3744         else {
3745             if (!(last->op_flags & OPf_KIDS)) {
3746                 ((LISTOP*)last)->op_last = first;
3747                 last->op_flags |= OPf_KIDS;
3748             }
3749             first->op_sibling = ((LISTOP*)last)->op_first;
3750             ((LISTOP*)last)->op_first = first;
3751         }
3752         last->op_flags |= OPf_KIDS;
3753         return last;
3754     }
3755
3756     return newLISTOP(type, 0, first, last);
3757 }
3758
3759 /* Constructors */
3760
3761 #ifdef PERL_MAD
3762  
3763 TOKEN *
3764 Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop)
3765 {
3766     TOKEN *tk;
3767     Newxz(tk, 1, TOKEN);
3768     tk->tk_type = (OPCODE)optype;
3769     tk->tk_type = 12345;
3770     tk->tk_lval = lval;
3771     tk->tk_mad = madprop;
3772     return tk;
3773 }
3774
3775 void
3776 Perl_token_free(pTHX_ TOKEN* tk)
3777 {
3778     PERL_ARGS_ASSERT_TOKEN_FREE;
3779
3780     if (tk->tk_type != 12345)
3781         return;
3782     mad_free(tk->tk_mad);
3783     Safefree(tk);
3784 }
3785
3786 void
3787 Perl_token_getmad(pTHX_ TOKEN* tk, OP* o, char slot)
3788 {
3789     MADPROP* mp;
3790     MADPROP* tm;
3791
3792     PERL_ARGS_ASSERT_TOKEN_GETMAD;
3793
3794     if (tk->tk_type != 12345) {
3795         Perl_warner(aTHX_ packWARN(WARN_MISC),
3796              "Invalid TOKEN object ignored");
3797         return;
3798     }
3799     tm = tk->tk_mad;
3800     if (!tm)
3801         return;
3802
3803     /* faked up qw list? */
3804     if (slot == '(' &&
3805         tm->mad_type == MAD_SV &&
3806         SvPVX((SV *)tm->mad_val)[0] == 'q')
3807             slot = 'x';
3808
3809     if (o) {
3810         mp = o->op_madprop;
3811         if (mp) {
3812             for (;;) {
3813                 /* pretend constant fold didn't happen? */
3814                 if (mp->mad_key == 'f' &&
3815                     (o->op_type == OP_CONST ||
3816                      o->op_type == OP_GV) )
3817                 {
3818                     token_getmad(tk,(OP*)mp->mad_val,slot);
3819                     return;
3820                 }
3821                 if (!mp->mad_next)
3822                     break;
3823                 mp = mp->mad_next;
3824             }
3825             mp->mad_next = tm;
3826             mp = mp->mad_next;
3827         }
3828         else {
3829             o->op_madprop = tm;
3830             mp = o->op_madprop;
3831         }
3832         if (mp->mad_key == 'X')
3833             mp->mad_key = slot; /* just change the first one */
3834
3835         tk->tk_mad = 0;
3836     }
3837     else
3838         mad_free(tm);
3839     Safefree(tk);
3840 }
3841
3842 void
3843 Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot)
3844 {
3845     MADPROP* mp;
3846     if (!from)
3847         return;
3848     if (o) {
3849         mp = o->op_madprop;
3850         if (mp) {
3851             for (;;) {
3852                 /* pretend constant fold didn't happen? */
3853                 if (mp->mad_key == 'f' &&
3854                     (o->op_type == OP_CONST ||
3855                      o->op_type == OP_GV) )
3856                 {
3857                     op_getmad(from,(OP*)mp->mad_val,slot);
3858                     return;
3859                 }
3860                 if (!mp->mad_next)
3861                     break;
3862                 mp = mp->mad_next;
3863             }
3864             mp->mad_next = newMADPROP(slot,MAD_OP,from,0);
3865         }
3866         else {
3867             o->op_madprop = newMADPROP(slot,MAD_OP,from,0);
3868         }
3869     }
3870 }
3871
3872 void
3873 Perl_op_getmad(pTHX_ OP* from, OP* o, char slot)
3874 {
3875     MADPROP* mp;
3876     if (!from)
3877         return;
3878     if (o) {
3879         mp = o->op_madprop;
3880         if (mp) {
3881             for (;;) {
3882                 /* pretend constant fold didn't happen? */
3883                 if (mp->mad_key == 'f' &&
3884                     (o->op_type == OP_CONST ||
3885                      o->op_type == OP_GV) )
3886                 {
3887                     op_getmad(from,(OP*)mp->mad_val,slot);
3888                     return;
3889                 }
3890                 if (!mp->mad_next)
3891                     break;
3892                 mp = mp->mad_next;
3893             }
3894             mp->mad_next = newMADPROP(slot,MAD_OP,from,1);
3895         }
3896         else {
3897             o->op_madprop = newMADPROP(slot,MAD_OP,from,1);
3898         }
3899     }
3900     else {
3901         PerlIO_printf(PerlIO_stderr(),
3902                       "DESTROYING op = %0"UVxf"\n", PTR2UV(from));
3903         op_free(from);
3904     }
3905 }
3906
3907 void
3908 Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot)
3909 {
3910     MADPROP* tm;
3911     if (!mp || !o)
3912         return;
3913     if (slot)
3914         mp->mad_key = slot;
3915     tm = o->op_madprop;
3916     o->op_madprop = mp;
3917     for (;;) {
3918         if (!mp->mad_next)
3919             break;
3920         mp = mp->mad_next;
3921     }
3922     mp->mad_next = tm;
3923 }
3924
3925 void
3926 Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot)
3927 {
3928     if (!o)
3929         return;
3930     addmad(tm, &(o->op_madprop), slot);
3931 }
3932
3933 void
3934 Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot)
3935 {
3936     MADPROP* mp;
3937     if (!tm || !root)
3938         return;
3939     if (slot)
3940         tm->mad_key = slot;
3941     mp = *root;
3942     if (!mp) {
3943         *root = tm;
3944         return;
3945     }
3946     for (;;) {
3947         if (!mp->mad_next)
3948             break;
3949         mp = mp->mad_next;
3950     }
3951     mp->mad_next = tm;
3952 }
3953
3954 MADPROP *
3955 Perl_newMADsv(pTHX_ char key, SV* sv)
3956 {
3957     PERL_ARGS_ASSERT_NEWMADSV;
3958
3959     return newMADPROP(key, MAD_SV, sv, 0);
3960 }
3961
3962 MADPROP *
3963 Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen)
3964 {
3965     MADPROP *const mp = (MADPROP *) PerlMemShared_malloc(sizeof(MADPROP));
3966     mp->mad_next = 0;
3967     mp->mad_key = key;
3968     mp->mad_vlen = vlen;
3969     mp->mad_type = type;
3970     mp->mad_val = val;
3971 /*    PerlIO_printf(PerlIO_stderr(), "NEW  mp = %0x\n", mp);  */
3972     return mp;
3973 }
3974
3975 void
3976 Perl_mad_free(pTHX_ MADPROP* mp)
3977 {
3978 /*    PerlIO_printf(PerlIO_stderr(), "FREE mp = %0x\n", mp); */
3979     if (!mp)
3980         return;
3981     if (mp->mad_next)
3982         mad_free(mp->mad_next);
3983 /*    if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING && mp->mad_vlen)
3984         PerlIO_printf(PerlIO_stderr(), "DESTROYING '%c'=<%s>\n", mp->mad_key & 255, mp->mad_val); */
3985     switch (mp->mad_type) {
3986     case MAD_NULL:
3987         break;
3988     case MAD_PV:
3989         Safefree(mp->mad_val);
3990         break;
3991     case MAD_OP:
3992         if (mp->mad_vlen)       /* vlen holds "strong/weak" boolean */
3993             op_free((OP*)mp->mad_val);
3994         break;
3995     case MAD_SV:
3996         sv_free(MUTABLE_SV(mp->mad_val));
3997         break;
3998     default:
3999         PerlIO_printf(PerlIO_stderr(), "Unrecognized mad\n");
4000         break;
4001     }
4002     PerlMemShared_free(mp);
4003 }
4004
4005 #endif
4006
4007 /*
4008 =head1 Optree construction
4009
4010 =for apidoc Am|OP *|newNULLLIST
4011
4012 Constructs, checks, and returns a new C<stub> op, which represents an
4013 empty list expression.
4014
4015 =cut
4016 */
4017
4018 OP *
4019 Perl_newNULLLIST(pTHX)
4020 {
4021     return newOP(OP_STUB, 0);
4022 }
4023
4024 static OP *
4025 S_force_list(pTHX_ OP *o)
4026 {
4027     if (!o || o->op_type != OP_LIST)
4028         o = newLISTOP(OP_LIST, 0, o, NULL);
4029     op_null(o);
4030     return o;
4031 }
4032
4033 /*
4034 =for apidoc Am|OP *|newLISTOP|I32 type|I32 flags|OP *first|OP *last
4035
4036 Constructs, checks, and returns an op of any list type.  I<type> is
4037 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
4038 C<OPf_KIDS> will be set automatically if required.  I<first> and I<last>
4039 supply up to two ops to be direct children of the list op; they are
4040 consumed by this function and become part of the constructed op tree.
4041
4042 =cut
4043 */
4044
4045 OP *
4046 Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
4047 {
4048     dVAR;
4049     LISTOP *listop;
4050
4051     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_LISTOP);
4052
4053     NewOp(1101, listop, 1, LISTOP);
4054
4055     listop->op_type = (OPCODE)type;
4056     listop->op_ppaddr = PL_ppaddr[type];
4057     if (first || last)
4058         flags |= OPf_KIDS;
4059     listop->op_flags = (U8)flags;
4060
4061     if (!last && first)
4062         last = first;
4063     else if (!first && last)
4064         first = last;
4065     else if (first)
4066         first->op_sibling = last;
4067     listop->op_first = first;
4068     listop->op_last = last;
4069     if (type == OP_LIST) {
4070         OP* const pushop = newOP(OP_PUSHMARK, 0);
4071         pushop->op_sibling = first;
4072         listop->op_first = pushop;
4073         listop->op_flags |= OPf_KIDS;
4074         if (!last)
4075             listop->op_last = pushop;
4076     }
4077
4078     return CHECKOP(type, listop);
4079 }
4080
4081 /*
4082 =for apidoc Am|OP *|newOP|I32 type|I32 flags
4083
4084 Constructs, checks, and returns an op of any base type (any type that
4085 has no extra fields).  I<type> is the opcode.  I<flags> gives the
4086 eight bits of C<op_flags>, and, shifted up eight bits, the eight bits
4087 of C<op_private>.
4088
4089 =cut
4090 */
4091
4092 OP *
4093 Perl_newOP(pTHX_ I32 type, I32 flags)
4094 {
4095     dVAR;
4096     OP *o;
4097
4098     if (type == -OP_ENTEREVAL) {
4099         type = OP_ENTEREVAL;
4100         flags |= OPpEVAL_BYTES<<8;
4101     }
4102
4103     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP
4104         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
4105         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
4106         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
4107
4108     NewOp(1101, o, 1, OP);
4109     o->op_type = (OPCODE)type;
4110     o->op_ppaddr = PL_ppaddr[type];
4111     o->op_flags = (U8)flags;
4112
4113     o->op_next = o;
4114     o->op_private = (U8)(0 | (flags >> 8));
4115     if (PL_opargs[type] & OA_RETSCALAR)
4116         scalar(o);
4117     if (PL_opargs[type] & OA_TARGET)
4118         o->op_targ = pad_alloc(type, SVs_PADTMP);
4119     return CHECKOP(type, o);
4120 }
4121
4122 /*
4123 =for apidoc Am|OP *|newUNOP|I32 type|I32 flags|OP *first
4124
4125 Constructs, checks, and returns an op of any unary type.  I<type> is
4126 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
4127 C<OPf_KIDS> will be set automatically if required, and, shifted up eight
4128 bits, the eight bits of C<op_private>, except that the bit with value 1
4129 is automatically set.  I<first> supplies an optional op to be the direct
4130 child of the unary op; it is consumed by this function and become part
4131 of the constructed op tree.
4132
4133 =cut
4134 */
4135
4136 OP *
4137 Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
4138 {
4139     dVAR;
4140     UNOP *unop;
4141
4142     if (type == -OP_ENTEREVAL) {
4143         type = OP_ENTEREVAL;
4144         flags |= OPpEVAL_BYTES<<8;
4145     }
4146
4147     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_UNOP
4148         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
4149         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
4150         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP
4151         || type == OP_SASSIGN
4152         || type == OP_ENTERTRY
4153         || type == OP_NULL );
4154
4155     if (!first)
4156         first = newOP(OP_STUB, 0);
4157     if (PL_opargs[type] & OA_MARK)
4158         first = force_list(first);
4159
4160     NewOp(1101, unop, 1, UNOP);
4161     unop->op_type = (OPCODE)type;
4162     unop->op_ppaddr = PL_ppaddr[type];
4163     unop->op_first = first;
4164     unop->op_flags = (U8)(flags | OPf_KIDS);
4165     unop->op_private = (U8)(1 | (flags >> 8));
4166     unop = (UNOP*) CHECKOP(type, unop);
4167     if (unop->op_next)
4168         return (OP*)unop;
4169
4170     return fold_constants(op_integerize(op_std_init((OP *) unop)));
4171 }
4172
4173 /*
4174 =for apidoc Am|OP *|newBINOP|I32 type|I32 flags|OP *first|OP *last
4175
4176 Constructs, checks, and returns an op of any binary type.  I<type>
4177 is the opcode.  I<flags> gives the eight bits of C<op_flags>, except
4178 that C<OPf_KIDS> will be set automatically, and, shifted up eight bits,
4179 the eight bits of C<op_private>, except that the bit with value 1 or
4180 2 is automatically set as required.  I<first> and I<last> supply up to
4181 two ops to be the direct children of the binary op; they are consumed
4182 by this function and become part of the constructed op tree.
4183
4184 =cut
4185 */
4186
4187 OP *
4188 Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
4189 {
4190     dVAR;
4191     BINOP *binop;
4192
4193     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BINOP
4194         || type == OP_SASSIGN || type == OP_NULL );
4195
4196     NewOp(1101, binop, 1, BINOP);
4197
4198     if (!first)
4199         first = newOP(OP_NULL, 0);
4200
4201     binop->op_type = (OPCODE)type;
4202     binop->op_ppaddr = PL_ppaddr[type];
4203     binop->op_first = first;
4204     binop->op_flags = (U8)(flags | OPf_KIDS);
4205     if (!last) {
4206         last = first;
4207         binop->op_private = (U8)(1 | (flags >> 8));
4208     }
4209     else {
4210         binop->op_private = (U8)(2 | (flags >> 8));
4211         first->op_sibling = last;
4212     }
4213
4214     binop = (BINOP*)CHECKOP(type, binop);
4215     if (binop->op_next || binop->op_type != (OPCODE)type)
4216         return (OP*)binop;
4217
4218     binop->op_last = binop->op_first->op_sibling;
4219
4220     return fold_constants(op_integerize(op_std_init((OP *)binop)));
4221 }
4222
4223 static int uvcompare(const void *a, const void *b)
4224     __attribute__nonnull__(1)
4225     __attribute__nonnull__(2)
4226     __attribute__pure__;
4227 static int uvcompare(const void *a, const void *b)
4228 {
4229     if (*((const UV *)a) < (*(const UV *)b))
4230         return -1;
4231     if (*((const UV *)a) > (*(const UV *)b))
4232         return 1;
4233     if (*((const UV *)a+1) < (*(const UV *)b+1))
4234         return -1;
4235     if (*((const UV *)a+1) > (*(const UV *)b+1))
4236         return 1;
4237     return 0;
4238 }
4239
4240 static OP *
4241 S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
4242 {
4243     dVAR;
4244     SV * const tstr = ((SVOP*)expr)->op_sv;
4245     SV * const rstr =
4246 #ifdef PERL_MAD
4247                         (repl->op_type == OP_NULL)
4248                             ? ((SVOP*)((LISTOP*)repl)->op_first)->op_sv :
4249 #endif
4250                               ((SVOP*)repl)->op_sv;
4251     STRLEN tlen;
4252     STRLEN rlen;
4253     const U8 *t = (U8*)SvPV_const(tstr, tlen);
4254     const U8 *r = (U8*)SvPV_const(rstr, rlen);
4255     I32 i;
4256     I32 j;
4257     I32 grows = 0;
4258     short *tbl;
4259
4260     const I32 complement = o->op_private & OPpTRANS_COMPLEMENT;
4261     const I32 squash     = o->op_private & OPpTRANS_SQUASH;
4262     I32 del              = o->op_private & OPpTRANS_DELETE;
4263     SV* swash;
4264
4265     PERL_ARGS_ASSERT_PMTRANS;
4266
4267     PL_hints |= HINT_BLOCK_SCOPE;
4268
4269     if (SvUTF8(tstr))
4270         o->op_private |= OPpTRANS_FROM_UTF;
4271
4272     if (SvUTF8(rstr))
4273         o->op_private |= OPpTRANS_TO_UTF;
4274
4275     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
4276         SV* const listsv = newSVpvs("# comment\n");
4277         SV* transv = NULL;
4278         const U8* tend = t + tlen;
4279         const U8* rend = r + rlen;
4280         STRLEN ulen;
4281         UV tfirst = 1;
4282         UV tlast = 0;
4283         IV tdiff;
4284         UV rfirst = 1;
4285         UV rlast = 0;
4286         IV rdiff;
4287         IV diff;
4288         I32 none = 0;
4289         U32 max = 0;
4290         I32 bits;
4291         I32 havefinal = 0;
4292         U32 final = 0;
4293         const I32 from_utf  = o->op_private & OPpTRANS_FROM_UTF;
4294         const I32 to_utf    = o->op_private & OPpTRANS_TO_UTF;
4295         U8* tsave = NULL;
4296         U8* rsave = NULL;
4297         const U32 flags = UTF8_ALLOW_DEFAULT;
4298
4299         if (!from_utf) {
4300             STRLEN len = tlen;
4301             t = tsave = bytes_to_utf8(t, &len);
4302             tend = t + len;
4303         }
4304         if (!to_utf && rlen) {
4305             STRLEN len = rlen;
4306             r = rsave = bytes_to_utf8(r, &len);
4307             rend = r + len;
4308         }
4309
4310 /* There is a  snag with this code on EBCDIC: scan_const() in toke.c has
4311  * encoded chars in native encoding which makes ranges in the EBCDIC 0..255
4312  * odd.  */
4313
4314         if (complement) {
4315             U8 tmpbuf[UTF8_MAXBYTES+1];
4316             UV *cp;
4317             UV nextmin = 0;
4318             Newx(cp, 2*tlen, UV);
4319             i = 0;
4320             transv = newSVpvs("");
4321             while (t < tend) {
4322                 cp[2*i] = utf8n_to_uvchr(t, tend-t, &ulen, flags);
4323                 t += ulen;
4324                 if (t < tend && *t == ILLEGAL_UTF8_BYTE) {
4325                     t++;
4326                     cp[2*i+1] = utf8n_to_uvchr(t, tend-t, &ulen, flags);
4327                     t += ulen;
4328                 }
4329                 else {
4330                  cp[2*i+1] = cp[2*i];
4331                 }
4332                 i++;
4333             }
4334             qsort(cp, i, 2*sizeof(UV), uvcompare);
4335             for (j = 0; j < i; j++) {
4336                 UV  val = cp[2*j];
4337                 diff = val - nextmin;
4338                 if (diff > 0) {
4339                     t = uvchr_to_utf8(tmpbuf,nextmin);
4340                     sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4341                     if (diff > 1) {
4342                         U8  range_mark = ILLEGAL_UTF8_BYTE;
4343                         t = uvchr_to_utf8(tmpbuf, val - 1);
4344                         sv_catpvn(transv, (char *)&range_mark, 1);
4345                         sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4346                     }
4347                 }
4348                 val = cp[2*j+1];
4349                 if (val >= nextmin)
4350                     nextmin = val + 1;
4351             }
4352             t = uvchr_to_utf8(tmpbuf,nextmin);
4353             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4354             {
4355                 U8 range_mark = ILLEGAL_UTF8_BYTE;
4356                 sv_catpvn(transv, (char *)&range_mark, 1);
4357             }
4358             t = uvchr_to_utf8(tmpbuf, 0x7fffffff);
4359             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4360             t = (const U8*)SvPVX_const(transv);
4361             tlen = SvCUR(transv);
4362             tend = t + tlen;
4363             Safefree(cp);
4364         }
4365         else if (!rlen && !del) {
4366             r = t; rlen = tlen; rend = tend;
4367         }
4368         if (!squash) {
4369                 if ((!rlen && !del) || t == r ||
4370                     (tlen == rlen && memEQ((char *)t, (char *)r, tlen)))
4371                 {
4372                     o->op_private |= OPpTRANS_IDENTICAL;
4373                 }
4374         }
4375
4376         while (t < tend || tfirst <= tlast) {
4377             /* see if we need more "t" chars */
4378             if (tfirst > tlast) {
4379                 tfirst = (I32)utf8n_to_uvchr(t, tend - t, &ulen, flags);
4380                 t += ulen;
4381                 if (t < tend && *t == ILLEGAL_UTF8_BYTE) {      /* illegal utf8 val indicates range */
4382                     t++;
4383                     tlast = (I32)utf8n_to_uvchr(t, tend - t, &ulen, flags);
4384                     t += ulen;
4385                 }
4386                 else
4387                     tlast = tfirst;
4388             }
4389
4390             /* now see if we need more "r" chars */
4391             if (rfirst > rlast) {
4392                 if (r < rend) {
4393                     rfirst = (I32)utf8n_to_uvchr(r, rend - r, &ulen, flags);
4394                     r += ulen;
4395                     if (r < rend && *r == ILLEGAL_UTF8_BYTE) {  /* illegal utf8 val indicates range */
4396                         r++;
4397                         rlast = (I32)utf8n_to_uvchr(r, rend - r, &ulen, flags);
4398                         r += ulen;
4399                     }
4400                     else
4401                         rlast = rfirst;
4402                 }
4403                 else {
4404                     if (!havefinal++)
4405                         final = rlast;
4406                     rfirst = rlast = 0xffffffff;
4407                 }
4408             }
4409
4410             /* now see which range will peter our first, if either. */
4411             tdiff = tlast - tfirst;
4412             rdiff = rlast - rfirst;
4413
4414             if (tdiff <= rdiff)
4415                 diff = tdiff;
4416             else
4417                 diff = rdiff;
4418
4419             if (rfirst == 0xffffffff) {
4420                 diff = tdiff;   /* oops, pretend rdiff is infinite */
4421                 if (diff > 0)
4422                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\tXXXX\n",
4423                                    (long)tfirst, (long)tlast);
4424                 else
4425                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\tXXXX\n", (long)tfirst);
4426             }
4427             else {
4428                 if (diff > 0)
4429                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\t%04lx\n",
4430                                    (long)tfirst, (long)(tfirst + diff),
4431                                    (long)rfirst);
4432                 else
4433                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\t%04lx\n",
4434                                    (long)tfirst, (long)rfirst);
4435
4436                 if (rfirst + diff > max)
4437                     max = rfirst + diff;
4438                 if (!grows)
4439                     grows = (tfirst < rfirst &&
4440                              UNISKIP(tfirst) < UNISKIP(rfirst + diff));
4441                 rfirst += diff + 1;
4442             }
4443             tfirst += diff + 1;
4444         }
4445
4446         none = ++max;
4447         if (del)
4448             del = ++max;
4449
4450         if (max > 0xffff)
4451             bits = 32;
4452         else if (max > 0xff)
4453             bits = 16;
4454         else
4455             bits = 8;
4456
4457         swash = MUTABLE_SV(swash_init("utf8", "", listsv, bits, none));
4458 #ifdef USE_ITHREADS
4459         cPADOPo->op_padix = pad_alloc(OP_TRANS, SVf_READONLY);
4460         SvREFCNT_dec(PAD_SVl(cPADOPo->op_padix));
4461         PAD_SETSV(cPADOPo->op_padix, swash);
4462         SvPADTMP_on(swash);
4463         SvREADONLY_on(swash);
4464 #else
4465         cSVOPo->op_sv = swash;
4466 #endif
4467         SvREFCNT_dec(listsv);
4468         SvREFCNT_dec(transv);
4469
4470         if (!del && havefinal && rlen)
4471             (void)hv_store(MUTABLE_HV(SvRV(swash)), "FINAL", 5,
4472                            newSVuv((UV)final), 0);
4473
4474         if (grows)
4475             o->op_private |= OPpTRANS_GROWS;
4476
4477         Safefree(tsave);
4478         Safefree(rsave);
4479
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         return o;
4488     }
4489
4490     tbl = (short*)PerlMemShared_calloc(
4491         (o->op_private & OPpTRANS_COMPLEMENT) &&
4492             !(o->op_private & OPpTRANS_DELETE) ? 258 : 256,
4493         sizeof(short));
4494     cPVOPo->op_pv = (char*)tbl;
4495     if (complement) {
4496         for (i = 0; i < (I32)tlen; i++)
4497             tbl[t[i]] = -1;
4498         for (i = 0, j = 0; i < 256; i++) {
4499             if (!tbl[i]) {
4500                 if (j >= (I32)rlen) {
4501                     if (del)
4502                         tbl[i] = -2;
4503                     else if (rlen)
4504                         tbl[i] = r[j-1];
4505                     else
4506                         tbl[i] = (short)i;
4507                 }
4508                 else {
4509                     if (i < 128 && r[j] >= 128)
4510                         grows = 1;
4511                     tbl[i] = r[j++];
4512                 }
4513             }
4514         }
4515         if (!del) {
4516             if (!rlen) {
4517                 j = rlen;
4518                 if (!squash)
4519                     o->op_private |= OPpTRANS_IDENTICAL;
4520             }
4521             else if (j >= (I32)rlen)
4522                 j = rlen - 1;
4523             else {
4524                 tbl = 
4525                     (short *)
4526                     PerlMemShared_realloc(tbl,
4527                                           (0x101+rlen-j) * sizeof(short));
4528                 cPVOPo->op_pv = (char*)tbl;
4529             }
4530             tbl[0x100] = (short)(rlen - j);
4531             for (i=0; i < (I32)rlen - j; i++)
4532                 tbl[0x101+i] = r[j+i];
4533         }
4534     }
4535     else {
4536         if (!rlen && !del) {
4537             r = t; rlen = tlen;
4538             if (!squash)
4539                 o->op_private |= OPpTRANS_IDENTICAL;
4540         }
4541         else if (!squash && rlen == tlen && memEQ((char*)t, (char*)r, tlen)) {
4542             o->op_private |= OPpTRANS_IDENTICAL;
4543         }
4544         for (i = 0; i < 256; i++)
4545             tbl[i] = -1;
4546         for (i = 0, j = 0; i < (I32)tlen; i++,j++) {
4547             if (j >= (I32)rlen) {
4548                 if (del) {
4549                     if (tbl[t[i]] == -1)
4550                         tbl[t[i]] = -2;
4551                     continue;
4552                 }
4553                 --j;
4554             }
4555             if (tbl[t[i]] == -1) {
4556                 if (t[i] < 128 && r[j] >= 128)
4557                     grows = 1;
4558                 tbl[t[i]] = r[j];
4559             }
4560         }
4561     }
4562
4563     if(del && rlen == tlen) {
4564         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Useless use of /d modifier in transliteration operator"); 
4565     } else if(rlen > tlen && !complement) {
4566         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Replacement list is longer than search list");
4567     }
4568
4569     if (grows)
4570         o->op_private |= OPpTRANS_GROWS;
4571 #ifdef PERL_MAD
4572     op_getmad(expr,o,'e');
4573     op_getmad(repl,o,'r');
4574 #else
4575     op_free(expr);
4576     op_free(repl);
4577 #endif
4578
4579     return o;
4580 }
4581
4582 /*
4583 =for apidoc Am|OP *|newPMOP|I32 type|I32 flags
4584
4585 Constructs, checks, and returns an op of any pattern matching type.
4586 I<type> is the opcode.  I<flags> gives the eight bits of C<op_flags>
4587 and, shifted up eight bits, the eight bits of C<op_private>.
4588
4589 =cut
4590 */
4591
4592 OP *
4593 Perl_newPMOP(pTHX_ I32 type, I32 flags)
4594 {
4595     dVAR;
4596     PMOP *pmop;
4597
4598     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_PMOP);
4599
4600     NewOp(1101, pmop, 1, PMOP);
4601     pmop->op_type = (OPCODE)type;
4602     pmop->op_ppaddr = PL_ppaddr[type];
4603     pmop->op_flags = (U8)flags;
4604     pmop->op_private = (U8)(0 | (flags >> 8));
4605
4606     if (PL_hints & HINT_RE_TAINT)
4607         pmop->op_pmflags |= PMf_RETAINT;
4608     if (IN_LOCALE_COMPILETIME) {
4609         set_regex_charset(&(pmop->op_pmflags), REGEX_LOCALE_CHARSET);
4610     }
4611     else if ((! (PL_hints & HINT_BYTES))
4612                 /* Both UNI_8_BIT and locale :not_characters imply Unicode */
4613              && (PL_hints & (HINT_UNI_8_BIT|HINT_LOCALE_NOT_CHARS)))
4614     {
4615         set_regex_charset(&(pmop->op_pmflags), REGEX_UNICODE_CHARSET);
4616     }
4617     if (PL_hints & HINT_RE_FLAGS) {
4618         SV *reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4619          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags"), 0, 0
4620         );
4621         if (reflags && SvOK(reflags)) pmop->op_pmflags |= SvIV(reflags);
4622         reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4623          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags_charset"), 0, 0
4624         );
4625         if (reflags && SvOK(reflags)) {
4626             set_regex_charset(&(pmop->op_pmflags), (regex_charset)SvIV(reflags));
4627         }
4628     }
4629
4630
4631 #ifdef USE_ITHREADS
4632     assert(SvPOK(PL_regex_pad[0]));
4633     if (SvCUR(PL_regex_pad[0])) {
4634         /* Pop off the "packed" IV from the end.  */
4635         SV *const repointer_list = PL_regex_pad[0];
4636         const char *p = SvEND(repointer_list) - sizeof(IV);
4637         const IV offset = *((IV*)p);
4638
4639         assert(SvCUR(repointer_list) % sizeof(IV) == 0);
4640
4641         SvEND_set(repointer_list, p);
4642
4643         pmop->op_pmoffset = offset;
4644         /* This slot should be free, so assert this:  */
4645         assert(PL_regex_pad[offset] == &PL_sv_undef);
4646     } else {
4647         SV * const repointer = &PL_sv_undef;
4648         av_push(PL_regex_padav, repointer);
4649         pmop->op_pmoffset = av_len(PL_regex_padav);
4650         PL_regex_pad = AvARRAY(PL_regex_padav);
4651     }
4652 #endif
4653
4654     return CHECKOP(type, pmop);
4655 }
4656
4657 /* Given some sort of match op o, and an expression expr containing a
4658  * pattern, either compile expr into a regex and attach it to o (if it's
4659  * constant), or convert expr into a runtime regcomp op sequence (if it's
4660  * not)
4661  *
4662  * isreg indicates that the pattern is part of a regex construct, eg
4663  * $x =~ /pattern/ or split /pattern/, as opposed to $x =~ $pattern or
4664  * split "pattern", which aren't. In the former case, expr will be a list
4665  * if the pattern contains more than one term (eg /a$b/) or if it contains
4666  * a replacement, ie s/// or tr///.
4667  *
4668  * When the pattern has been compiled within a new anon CV (for
4669  * qr/(?{...})/ ), then floor indicates the savestack level just before
4670  * the new sub was created
4671  */
4672
4673 OP *
4674 Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg, I32 floor)
4675 {
4676     dVAR;
4677     PMOP *pm;
4678     LOGOP *rcop;
4679     I32 repl_has_vars = 0;
4680     OP* repl = NULL;
4681     bool is_trans = (o->op_type == OP_TRANS || o->op_type == OP_TRANSR);
4682     bool is_compiletime;
4683     bool has_code;
4684
4685     PERL_ARGS_ASSERT_PMRUNTIME;
4686
4687     /* for s/// and tr///, last element in list is the replacement; pop it */
4688
4689     if (is_trans || o->op_type == OP_SUBST) {
4690         OP* kid;
4691         repl = cLISTOPx(expr)->op_last;
4692         kid = cLISTOPx(expr)->op_first;
4693         while (kid->op_sibling != repl)
4694             kid = kid->op_sibling;
4695         kid->op_sibling = NULL;
4696         cLISTOPx(expr)->op_last = kid;
4697     }
4698
4699     /* for TRANS, convert LIST/PUSH/CONST into CONST, and pass to pmtrans() */
4700
4701     if (is_trans) {
4702         OP* const oe = expr;
4703         assert(expr->op_type == OP_LIST);
4704         assert(cLISTOPx(expr)->op_first->op_type == OP_PUSHMARK);
4705         assert(cLISTOPx(expr)->op_first->op_sibling == cLISTOPx(expr)->op_last);
4706         expr = cLISTOPx(oe)->op_last;
4707         cLISTOPx(oe)->op_first->op_sibling = NULL;
4708         cLISTOPx(oe)->op_last = NULL;
4709         op_free(oe);
4710
4711         return pmtrans(o, expr, repl);
4712     }
4713
4714     /* find whether we have any runtime or code elements;
4715      * at the same time, temporarily set the op_next of each DO block;
4716      * then when we LINKLIST, this will cause the DO blocks to be excluded
4717      * from the op_next chain (and from having LINKLIST recursively
4718      * applied to them). We fix up the DOs specially later */
4719
4720     is_compiletime = 1;
4721     has_code = 0;
4722     if (expr->op_type == OP_LIST) {
4723         OP *o;
4724         for (o = cLISTOPx(expr)->op_first; o; o = o->op_sibling) {
4725             if (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)) {
4726                 has_code = 1;
4727                 assert(!o->op_next && o->op_sibling);
4728                 o->op_next = o->op_sibling;
4729             }
4730             else if (o->op_type != OP_CONST && o->op_type != OP_PUSHMARK)
4731                 is_compiletime = 0;
4732         }
4733     }
4734     else if (expr->op_type != OP_CONST)
4735         is_compiletime = 0;
4736
4737     LINKLIST(expr);
4738
4739     /* fix up DO blocks; treat each one as a separate little sub;
4740      * also, mark any arrays as LIST/REF */
4741
4742     if (expr->op_type == OP_LIST) {
4743         OP *o;
4744         for (o = cLISTOPx(expr)->op_first; o; o = o->op_sibling) {
4745
4746             if (o->op_type == OP_PADAV || o->op_type == OP_RV2AV) {
4747                 assert( !(o->op_flags  & OPf_WANT));
4748                 /* push the array rather than its contents. The regex
4749                  * engine will retrieve and join the elements later */
4750                 o->op_flags |= (OPf_WANT_LIST | OPf_REF);
4751                 continue;
4752             }
4753
4754             if (!(o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)))
4755                 continue;
4756             o->op_next = NULL; /* undo temporary hack from above */
4757             scalar(o);
4758             LINKLIST(o);
4759             if (cLISTOPo->op_first->op_type == OP_LEAVE) {
4760                 LISTOP *leaveop = cLISTOPx(cLISTOPo->op_first);
4761                 /* skip ENTER */
4762                 assert(leaveop->op_first->op_type == OP_ENTER);
4763                 assert(leaveop->op_first->op_sibling);
4764                 o->op_next = leaveop->op_first->op_sibling;
4765                 /* skip leave */
4766                 assert(leaveop->op_flags & OPf_KIDS);
4767                 assert(leaveop->op_last->op_next == (OP*)leaveop);
4768                 leaveop->op_next = NULL; /* stop on last op */
4769                 op_null((OP*)leaveop);
4770             }
4771             else {
4772                 /* skip SCOPE */
4773                 OP *scope = cLISTOPo->op_first;
4774                 assert(scope->op_type == OP_SCOPE);
4775                 assert(scope->op_flags & OPf_KIDS);
4776                 scope->op_next = NULL; /* stop on last op */
4777                 op_null(scope);
4778             }
4779             /* have to peep the DOs individually as we've removed it from
4780              * the op_next chain */
4781             CALL_PEEP(o);
4782             if (is_compiletime)
4783                 /* runtime finalizes as part of finalizing whole tree */
4784                 finalize_optree(o);
4785         }
4786     }
4787     else if (expr->op_type == OP_PADAV || expr->op_type == OP_RV2AV) {
4788         assert( !(expr->op_flags  & OPf_WANT));
4789         /* push the array rather than its contents. The regex
4790          * engine will retrieve and join the elements later */
4791         expr->op_flags |= (OPf_WANT_LIST | OPf_REF);
4792     }
4793
4794     PL_hints |= HINT_BLOCK_SCOPE;
4795     pm = (PMOP*)o;
4796     assert(floor==0 || (pm->op_pmflags & PMf_HAS_CV));
4797
4798     if (is_compiletime) {
4799         U32 rx_flags = pm->op_pmflags & RXf_PMf_COMPILETIME;
4800         regexp_engine const *eng = current_re_engine();
4801
4802         if (o->op_flags & OPf_SPECIAL)
4803             rx_flags |= RXf_SPLIT;
4804
4805         if (!has_code || !eng->op_comp) {
4806             /* compile-time simple constant pattern */
4807
4808             if ((pm->op_pmflags & PMf_HAS_CV) && !has_code) {
4809                 /* whoops! we guessed that a qr// had a code block, but we
4810                  * were wrong (e.g. /[(?{}]/ ). Throw away the PL_compcv
4811                  * that isn't required now. Note that we have to be pretty
4812                  * confident that nothing used that CV's pad while the
4813                  * regex was parsed */
4814                 assert(AvFILLp(PL_comppad) == 0); /* just @_ */
4815                 /* But we know that one op is using this CV's slab. */
4816                 cv_forget_slab(PL_compcv);
4817                 LEAVE_SCOPE(floor);
4818                 pm->op_pmflags &= ~PMf_HAS_CV;
4819             }
4820
4821             PM_SETRE(pm,
4822                 eng->op_comp
4823                     ? eng->op_comp(aTHX_ NULL, 0, expr, eng, NULL, NULL,
4824                                         rx_flags, pm->op_pmflags)
4825                     : Perl_re_op_compile(aTHX_ NULL, 0, expr, eng, NULL, NULL,
4826                                         rx_flags, pm->op_pmflags)
4827             );
4828 #ifdef PERL_MAD
4829             op_getmad(expr,(OP*)pm,'e');
4830 #else
4831             op_free(expr);
4832 #endif
4833         }
4834         else {
4835             /* compile-time pattern that includes literal code blocks */
4836             REGEXP* re = eng->op_comp(aTHX_ NULL, 0, expr, eng, NULL, NULL,
4837                         rx_flags,
4838                         (pm->op_pmflags |
4839                             ((PL_hints & HINT_RE_EVAL) ? PMf_USE_RE_EVAL : 0))
4840                     );
4841             PM_SETRE(pm, re);
4842             if (pm->op_pmflags & PMf_HAS_CV) {
4843                 CV *cv;
4844                 /* this QR op (and the anon sub we embed it in) is never
4845                  * actually executed. It's just a placeholder where we can
4846                  * squirrel away expr in op_code_list without the peephole
4847                  * optimiser etc processing it for a second time */
4848                 OP *qr = newPMOP(OP_QR, 0);
4849                 ((PMOP*)qr)->op_code_list = expr;
4850
4851                 /* handle the implicit sub{} wrapped round the qr/(?{..})/ */
4852                 SvREFCNT_inc_simple_void(PL_compcv);
4853                 cv = newATTRSUB(floor, 0, NULL, NULL, qr);
4854                 ReANY(re)->qr_anoncv = cv;
4855
4856                 /* attach the anon CV to the pad so that
4857                  * pad_fixup_inner_anons() can find it */
4858                 (void)pad_add_anon(cv, o->op_type);
4859                 SvREFCNT_inc_simple_void(cv);
4860             }
4861             else {
4862                 pm->op_code_list = expr;
4863             }
4864         }
4865     }
4866     else {
4867         /* runtime pattern: build chain of regcomp etc ops */
4868         bool reglist;
4869         PADOFFSET cv_targ = 0;
4870
4871         reglist = isreg && expr->op_type == OP_LIST;
4872         if (reglist)
4873             op_null(expr);
4874