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