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