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