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