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