op.c

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