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