op.c

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